From 3e82dcf235fb63cf1617482511566b818f808e79 Mon Sep 17 00:00:00 2001
From: "Charles B. Haley" <cbh@research.uucp>
Date: Wed, 31 Oct 1979 20:28:53 -0800
Subject: [PATCH] BSD 3 development Work on file usr/src/cmd/pi/var.c

Co-Authored-By: Bill Joy <wnj@ucbvax.Berkeley.EDU>
Co-Authored-By: Ken Thompson <ken@research.uucp>
Synthesized-from: 3bsd
---
 usr/src/cmd/pi/var.c | 246 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 246 insertions(+)
 create mode 100644 usr/src/cmd/pi/var.c

diff --git a/usr/src/cmd/pi/var.c b/usr/src/cmd/pi/var.c
new file mode 100644
index 0000000000..266e160726
--- /dev/null
+++ b/usr/src/cmd/pi/var.c
@@ -0,0 +1,246 @@
+/* Copyright (c) 1979 Regents of the University of California */
+#
+/*
+ * pi - Pascal interpreter code translator
+ *
+ * Charles Haley, Bill Joy UCB
+ * Version 1.2 November 1978
+ */
+
+#include "whoami"
+#include "0.h"
+
+/*
+ * Declare variables of a var part.  DPOFF1 is
+ * the local variable storage for all prog/proc/func
+ * modules aside from the block mark.  The total size
+ * of all the local variables is entered into the
+ * size array.
+ */
+varbeg()
+{
+
+#ifndef PI1
+	if (parts & VPRT)
+		error("All variables must be declared in one var part");
+	parts |= VPRT;
+#endif
+#ifndef PI0
+	sizes[cbn].om_max = sizes[cbn].om_off = -DPOFF1;
+#endif
+	forechain = NIL;
+#ifdef PI0
+	send(REVVBEG);
+#endif
+}
+
+var(vline, vidl, vtype)
+#ifdef PI0
+	int vline, *vidl, *vtype;
+{
+	register struct nl *np;
+	register int *vl;
+
+	np = gtype(vtype);
+	line = vline;
+	for (vl = vidl; vl != NIL; vl = vl[2])
+		enter(defnl(vl[1], VAR, np, 0));
+	send(REVVAR, vline, vidl, vtype);
+}
+#else
+	int vline;
+	register int *vidl;
+	int *vtype;
+{
+	register struct nl *np;
+	register struct om *op;
+	long w;
+	int o2;
+	int *ovidl = vidl;
+
+	np = gtype(vtype);
+	line = vline;
+	w = (lwidth(np) + 1) &~ 1;
+	op = &sizes[cbn];
+	for (; vidl != NIL; vidl = vidl[2]) {
+		op->om_off -= w;
+		o2 = op->om_off;
+		enter(defnl(vidl[1], VAR, np, o2));
+	}
+#	ifdef PTREE
+	    {
+		pPointer	*Vars;
+		pPointer	Var = VarDecl( ovidl , vtype );
+
+		pSeize( PorFHeader[ nesting ] );
+		Vars = &( pDEF( PorFHeader[ nesting ] ).PorFVars );
+		*Vars = ListAppend( *Vars , Var );
+		pRelease( PorFHeader[ nesting ] );
+	    }
+#	endif
+}
+#endif
+
+varend()
+{
+
+	foredecl();
+#ifndef PI0
+	sizes[cbn].om_max = sizes[cbn].om_off;
+#else
+	send(REVVEND);
+#endif
+}
+
+/*
+ * Evening
+ */
+even(w)
+	register int w;
+{
+	if (w < 0)
+		return (w & ~1);
+	return ((w+1) & ~1);
+}
+
+/*
+ * Find the width of a type in bytes.
+ */
+width(np)
+	struct nl *np;
+{
+
+	return (lwidth(np));
+}
+
+long lwidth(np)
+	struct nl *np;
+{
+	register struct nl *p;
+	long w;
+
+	p = np;
+	if (p == NIL)
+		return (0);
+loop:
+	switch (p->class) {
+		case TYPE:
+			switch (nloff(p)) {
+				case TNIL:
+					return (2);
+				case TSTR:
+				case TSET:
+					panic("width");
+				default:
+					p = p->type;
+					goto loop;
+			}
+		case ARRAY:
+			return (aryconst(p, 0));
+		case PTR:
+		case FILET:
+			return ( sizeof ( int * ) );
+		case RANGE:
+			if (p->type == nl+TDOUBLE)
+#ifdef DEBUG
+				return (hp21mx ? 4 : 8);
+#else
+				return (8);
+#endif
+		case SCAL:
+			return (bytes(p->range[0], p->range[1]));
+		case SET:
+			setran(p->type);
+			return ( (set.uprbp>>3) + 1);
+		case STR:
+		case RECORD:
+			return ( p->value[NL_OFFS] );
+		default:
+			panic("wclass");
+	}
+}
+
+/*
+ * Return the width of an element
+ * of a n time subscripted np.
+ */
+long aryconst(np, n)
+	struct nl *np;
+	int n;
+{
+	register struct nl *p;
+	long s, d;
+
+	if ((p = np) == NIL)
+		return (NIL);
+	if (p->class != ARRAY)
+		panic("ary");
+	s = width(p->type);
+	/*
+	 * Arrays of anything but characters are word aligned.
+	 */
+	if (s & 1)
+		if (s != 1)
+			s++;
+	/*
+	 * Skip the first n subscripts
+	 */
+	while (n >= 0) {
+		p = p->chain;
+		n--;
+	}
+	/*
+	 * Sum across remaining subscripts.
+	 */
+	while (p != NIL) {
+		if (p->class != RANGE && p->class != SCAL)
+			panic("aryran");
+		d = p->range[1] - p->range[0] + 1;
+		s *= d;
+		p = p->chain;
+	}
+	return (s);
+}
+
+/*
+ * Find the lower bound of a set, and also its size in bits.
+ */
+setran(q)
+	struct nl *q;
+{
+	register lb, ub;
+	register struct nl *p;
+
+	p = q;
+	if (p == NIL)
+		return (NIL);
+	lb = p->range[0];
+	ub = p->range[1];
+	if (p->class != RANGE && p->class != SCAL)
+		panic("setran");
+	set.lwrb = lb;
+	/* set.(upperbound prime) = number of bits - 1; */
+	set.uprbp = ub-lb;
+}
+
+/*
+ * Return the number of bytes required to hold an arithmetic quantity
+ */
+bytes(lb, ub)
+	long lb, ub;
+{
+
+#ifndef DEBUG
+	if (lb < -32768 || ub > 32767)
+		return (4);
+	else if (lb < -128 || ub > 127)
+		return (2);
+#else
+	if (!hp21mx && (lb < -32768 || ub > 32767))
+		return (4);
+	if (lb < -128 || ub > 127)
+		return (2);
+#endif
+	else
+		return (1);
+}
-- 
2.20.1