date and time created 81/03/02 21:28:57 by peter

SCCS-vsn: usr.bin/pascal/pxp/rval.c 1.1

diff --git a/usr/src/usr.bin/pascal/pxp/rval.c b/usr/src/usr.bin/pascal/pxp/rval.c
new file mode 100644 (file)
index 0000000..6fee110
--- /dev/null
+++ b/usr/src/usr.bin/pascal/pxp/rval.c
@@ -0,0 +1,140 @@
+static char *sccsid = "@(#)rval.c      1.1 (Berkeley) %G%";
+/* Copyright (c) 1979 Regents of the University of California */
+#
+/*
+ * pxp - Pascal execution profiler
+ *
+ * Bill Joy UCB
+ * Version 1.2 January 1979
+ */
+
+#include "0.h"
+#include "tree.h"
+
+extern char *opnames[];
+
+#define alph(c)                ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
+/*
+ * Rvalue reformats an expression.
+ * Par is a flag indicating that the expression
+ * should be parenthesized if it is non-atomic.
+ */
+rvalue(r, par)
+       register int *r;
+       int par;
+{
+       register int *al;
+       register char *opname;
+
+       if (r == NIL) {
+               ppid("{expr}");
+               return;
+       }
+       if (r[0] <= T_IN)
+               opname = opnames[r[0]];
+       switch (r[0]) {
+               case T_BINT:
+               case T_INT:
+               case T_FINT:
+                       ppnumb(r[2]);
+                       if (r[0] == T_BINT)
+                               ppsep("b");
+                       return;
+               case T_NIL:
+                       ppkw("nil");
+                       return;
+               case T_FCALL:
+                       funccod(r);
+                       return;
+               case T_VAR:
+                       lvalue(r);
+                       return;
+               case T_CSET:
+                       cset(r);
+                       return;
+               case T_STRNG:
+                       ppstr(r[2]);
+                       return;
+       }
+       if (par)
+               ppbra("(");
+       switch (r[0]) {
+               default:
+                       panic("rval");
+               case T_PLUS:
+               case T_MINUS:
+                       ppop(r[0] == T_PLUS ? "+" : "-");
+                       al = r[2];
+                       rvalue(r[2], prec(al) > prec(r) || full);
+                       break;
+               case T_NOT:
+                       ppkw(opname);
+                       ppspac();
+                       rvalue(r[2], 1);
+                       break;
+               case T_EQ:
+               case T_NE:
+               case T_GE:
+               case T_LE:
+               case T_GT:
+               case T_LT:
+                       al = r[2];
+                       rvalue(al, prec(al) <= prec(r) || full);
+                       goto rest;
+               case T_AND:
+               case T_OR:
+               case T_MULT:
+               case T_ADD:
+               case T_SUB:
+               case T_DIVD:
+               case T_MOD:
+               case T_DIV:
+               case T_IN:
+                       al = r[2];
+                       rvalue(al, prec(al) < prec(r) || full);
+rest:
+                       ppspac();
+                       if (alph(opname[0]))
+                               ppkw(opname);
+                       else
+                               ppop(opname);
+                       ppspac();
+                       al = r[3];
+                       rvalue(al, prec(al) <= prec(r) || full);
+                       break;
+       }
+       if (par)
+               ppket(")");
+}
+
+/*
+ * Prec returns the precedence of an operator,
+ * with larger numbers indicating stronger binding.
+ * This is used to determine when parenthesization
+ * is needed on subexpressions.
+ */
+prec(r)
+       register int *r;
+{
+
+       if (r == NIL)
+               return;
+       switch (r[0]) {
+               case T_NOT:
+                       return (3);
+               case T_MULT:
+               case T_DIVD:
+               case T_DIV:
+               case T_MOD:
+               case T_AND:
+                       return (2);
+               case T_ADD:
+               case T_SUB:
+               case T_OR:
+               case T_PLUS:
+               case T_MINUS:
+                       return (1);
+               default:
+                       return (0);
+       }
+}