(calc-rewrite-selection): Make rules a local variable.

(calc-rewr-sel): New variable.
(calc-rewrite-selection, calc-locate-selection-marker, calc-rewrite):
Use the declared variable calc-rewr-sel instead of sel.

(math-rewrite):  Use let* to declare variables.

(math-mt-many): Declare it.

(math-rewrite-whole-expr): New variable.
(math-rewrite, math-rewrite-phase): Replace variable expr by declared
variable.

(math-import-list): Declare it.

(math-rewrite-heads-heads, math-rewrite-heads-skips)
(math-rewrite-heads-blanks ): New variables.
(math-rewrite-heads, math-rewrite-heads-rec): Replace variables heads,
skips and blanks by declared variables.

(math-regs, math-num-regs, math-prog-last, math-bound-vars)
(math-conds, math-copy-neg, math-rhs, math-pattern, math-remembering)
(math-aliased-vars): Declare them.

(math-rwcomp-subst-old, math-rwcomp-subst-new)
(math-rwcomp-subst-old-func, math-rwcomp-subst-new-func):
New variables.
(math-rwcomp-substitute, math-rwcomp-subst-rec): Replace variables
old, new, old-func and new-func by declared variables.

(math-rwcomp-assoc-args, math-rwcomp-addsub-args):  Remove unnecessary
variable.

(math-rewrite-phase): Declare it.

(math-apply-rw-regs): New variable.
(math-apply-rewrites, math-rwapply-replace-regs,
math-rwapply-reg-looks-negp): Replace variable regs by declared variable.

(math-apply-rw-ruleset): New variable.
(math-apply-rewrites, math-rwapply-remember): Replace variable ruleset
by declared variable.

1 files changed, 220 insertions, 147 deletions

diff --git a/lisp/calc/calc-rewr.el b/lisp/calc/calc-rewr.el
index fd361bd3eee..85e4700ef10 100644
--- a/lisp/calc/calc-rewr.el
+++ b/lisp/calc/calc-rewr.el
@@ -3,8 +3,7 @@
 ;; Copyright (C) 1990, 1991, 1992, 1993, 2001 Free Software Foundation, Inc.
 
 ;; Author: David Gillespie <daveg@synaptics.com>
-;; Maintainers: D. Goel <deego@gnufans.org>
-;;              Colin Walters <walters@debian.org>
+;; Maintainer: Jay Belanger <belanger@truman.edu>
 
 ;; This file is part of GNU Emacs.
 
@@ -36,6 +35,11 @@
 
 
 (defvar math-rewrite-default-iters 100)
+
+;; The variable calc-rewr-sel is local to calc-rewrite-selection and 
+;; calc-rewrite, but is used by calc-locate-selection-marker.
+(defvar calc-rewr-sel)
+
 (defun calc-rewrite-selection (rules-str &optional many prefix)
   (interactive "sRewrite rule(s): \np")
   (calc-slow-wrapper
@@ -43,9 +47,10 @@
    (let* ((num (max 1 (calc-locate-cursor-element (point))))
 	  (reselect t)
 	  (pop-rules nil)
+          rules
 	  (entry (calc-top num 'entry))
 	  (expr (car entry))
-	  (sel (calc-auto-selection entry))
+	  (calc-rewr-sel (calc-auto-selection entry))
 	  (math-rewrite-selections t)
 	  (math-rewrite-default-iters 1))
      (if (or (null rules-str) (equal rules-str "") (equal rules-str "$"))
@@ -73,10 +78,10 @@
      (if (eq many 0)
 	 (setq many '(var inf var-inf))
        (if many (setq many (prefix-numeric-value many))))
-     (if sel
+     (if calc-rewr-sel
 	 (setq expr (calc-replace-sub-formula (car entry)
-					      sel
-					      (list 'calcFunc-select sel)))
+					      calc-rewr-sel
+					      (list 'calcFunc-select calc-rewr-sel)))
        (setq expr (car entry)
 	     reselect nil
 	     math-rewrite-selections nil))
@@ -85,22 +90,22 @@
 		  (math-rewrite
 		   (calc-normalize expr)
 		   rules many)))
-	   sel nil
+	   calc-rewr-sel nil
 	   expr (calc-locate-select-marker expr))
-     (or (consp sel) (setq sel nil))
+     (or (consp calc-rewr-sel) (setq calc-rewr-sel nil))
      (if pop-rules (calc-pop-stack 1))
      (calc-pop-push-record-list 1 (or prefix "rwrt") (list expr)
 				(- num (if pop-rules 1 0))
-				(list (and reselect sel))))
+				(list (and reselect calc-rewr-sel))))
    (calc-handle-whys)))
 
-(defun calc-locate-select-marker (expr)    ; changes "sel"
+(defun calc-locate-select-marker (expr)
   (if (Math-primp expr)
       expr
     (if (and (eq (car expr) 'calcFunc-select)
 	     (= (length expr) 2))
 	(progn
-	  (setq sel (if sel t (nth 1 expr)))
+	  (setq calc-rewr-sel (if calc-rewr-sel t (nth 1 expr)))
 	  (nth 1 expr))
       (cons (car expr)
 	    (mapcar 'calc-locate-select-marker (cdr expr))))))
@@ -138,7 +143,7 @@
 	 (setq many '(var inf var-inf))
        (if many (setq many (prefix-numeric-value many))))
      (setq expr (calc-normalize (math-rewrite expr rules many)))
-     (let (sel)
+     (let (calc-rewr-sel)
        (setq expr (calc-locate-select-marker expr)))
      (calc-pop-push-record-list n "rwrt" (list expr)))
    (calc-handle-whys)))
@@ -165,33 +170,38 @@
        (calc-enter-result n "mtch" (math-match-patterns pat expr nil))))))
 
 
-
-(defun math-rewrite (whole-expr rules &optional math-mt-many)
-  (let ((crules (math-compile-rewrites rules))
-	(heads (math-rewrite-heads whole-expr))
-	(trace-buffer (get-buffer "*Trace*"))
-	(calc-display-just 'center)
-	(calc-display-origin 39)
-	(calc-line-breaking 78)
-	(calc-line-numbering nil)
-	(calc-show-selections t)
-	(calc-why nil)
-	(math-mt-func (function
-                       (lambda (x)
-                         (let ((result (math-apply-rewrites x (cdr crules)
-                                                            heads crules)))
-                           (if result
-                               (progn
-                                 (if trace-buffer
-                                     (let ((fmt (math-format-stack-value
-                                                 (list result nil nil))))
-                                       (save-excursion
-                                         (set-buffer trace-buffer)
-                                         (insert "\nrewrite to\n" fmt "\n"))))
-                                 (setq heads (math-rewrite-heads result heads t))))
-                           result)))))
+(defvar math-mt-many)
+
+;; The variable math-rewrite-whole-expr is local to math-rewrite,
+;; but is used by math-rewrite-phase
+(defvar math-rewrite-whole-expr)
+
+(defun math-rewrite (math-rewrite-whole-expr rules &optional math-mt-many)
+  (let* ((crules (math-compile-rewrites rules))
+         (heads (math-rewrite-heads math-rewrite-whole-expr))
+         (trace-buffer (get-buffer "*Trace*"))
+         (calc-display-just 'center)
+         (calc-display-origin 39)
+         (calc-line-breaking 78)
+         (calc-line-numbering nil)
+         (calc-show-selections t)
+         (calc-why nil)
+         (math-mt-func (function
+                        (lambda (x)
+                          (let ((result (math-apply-rewrites x (cdr crules)
+                                                             heads crules)))
+                            (if result
+                                (progn
+                                  (if trace-buffer
+                                      (let ((fmt (math-format-stack-value
+                                                  (list result nil nil))))
+                                        (save-excursion
+                                          (set-buffer trace-buffer)
+                                          (insert "\nrewrite to\n" fmt "\n"))))
+                                  (setq heads (math-rewrite-heads result heads t))))
+                            result)))))
     (if trace-buffer
-	(let ((fmt (math-format-stack-value (list whole-expr nil nil))))
+	(let ((fmt (math-format-stack-value (list math-rewrite-whole-expr nil nil))))
 	  (save-excursion
 	    (set-buffer trace-buffer)
 	    (setq truncate-lines t)
@@ -203,26 +213,27 @@
     (if (equal math-mt-many '(neg (var inf var-inf))) (setq math-mt-many -1000000))
     (math-rewrite-phase (nth 3 (car crules)))
     (if trace-buffer
-	(let ((fmt (math-format-stack-value (list whole-expr nil nil))))
+	(let ((fmt (math-format-stack-value (list math-rewrite-whole-expr nil nil))))
 	  (save-excursion
 	    (set-buffer trace-buffer)
 	    (insert "\nDone rewriting"
 		    (if (= math-mt-many 0) " (reached iteration limit)" "")
 		    ":\n" fmt "\n"))))
-    whole-expr))
+    math-rewrite-whole-expr))
 
 (defun math-rewrite-phase (sched)
   (while (and sched (/= math-mt-many 0))
     (if (listp (car sched))
-	(while (let ((save-expr whole-expr))
+	(while (let ((save-expr math-rewrite-whole-expr))
 		 (math-rewrite-phase (car sched))
-		 (not (equal whole-expr save-expr))))
+		 (not (equal math-rewrite-whole-expr save-expr))))
       (if (symbolp (car sched))
 	  (progn
-	    (setq whole-expr (math-normalize (list (car sched) whole-expr)))
+	    (setq math-rewrite-whole-expr 
+                  (math-normalize (list (car sched) math-rewrite-whole-expr)))
 	    (if trace-buffer
 		(let ((fmt (math-format-stack-value
-			    (list whole-expr nil nil))))
+			    (list math-rewrite-whole-expr nil nil))))
 		  (save-excursion
 		    (set-buffer trace-buffer)
 		    (insert "\ncall "
@@ -233,10 +244,10 @@
 	      (save-excursion
 		(set-buffer trace-buffer)
 		(insert (format "\n(Phase %d)\n" math-rewrite-phase))))
-	  (while (let ((save-expr whole-expr))
-		   (setq whole-expr (math-normalize
-				     (math-map-tree-rec whole-expr)))
-		   (not (equal whole-expr save-expr)))))))
+	  (while (let ((save-expr math-rewrite-whole-expr))
+		   (setq math-rewrite-whole-expr (math-normalize
+				     (math-map-tree-rec math-rewrite-whole-expr)))
+		   (not (equal math-rewrite-whole-expr save-expr)))))))
     (setq sched (cdr sched))))
 
 (defun calcFunc-rewrite (expr rules &optional many)
@@ -488,6 +499,28 @@
 
 (defvar math-rewrite-whole nil)
 (defvar math-make-import-list nil)
+
+;; The variable math-import-list is local to part of math-compile-rewrites,
+;; but is also used in a different part, and so the local version could
+;; be affected by the non-local version when math-compile-rewrites calls itself. 
+(defvar math-import-list nil)
+
+;; The variables math-regs, math-num-regs, math-prog-last, math-bound-vars, 
+;; math-conds, math-copy-neg, math-rhs, math-pattern, math-remembering and
+;; math-aliased-vars are local to math-compile-rewrites, 
+;; but are used by many functions math-rwcomp-*, which are called by 
+;; math-compile-rewrites.
+(defvar math-regs)
+(defvar math-num-regs)
+(defvar math-prog-last)
+(defvar math-bound-vars)
+(defvar math-conds)
+(defvar math-copy-neg)
+(defvar math-rhs)
+(defvar math-pattern)
+(defvar math-remembering)
+(defvar math-aliased-vars)
+
 (defun math-compile-rewrites (rules &optional name)
   (if (eq (car-safe rules) 'var)
       (let ((prop (get (nth 2 rules) 'math-rewrite-cache))
@@ -731,26 +764,34 @@
 	      (math-flatten-lands (nth 2 expr)))
     (list expr)))
 
+;; The variables math-rewrite-heads-heads (i.e.; heads for math-rewrite-heads)
+;; math-rewrite-heads-blanks and math-rewrite-heads-skips are local to 
+;; math-rewrite-heads, but used by math-rewrite-heads-rec, which is called by 
+;; math-rewrite-heads.
+(defvar math-rewrite-heads-heads)
+(defvar math-rewrite-heads-skips)
+(defvar math-rewrite-heads-blanks)
+
 (defun math-rewrite-heads (expr &optional more all)
-  (let ((heads more)
-	(skips (and (not all)
+  (let ((math-rewrite-heads-heads more)
+	(math-rewrite-heads-skips (and (not all)
 		    '(calcFunc-apply calcFunc-condition calcFunc-opt
 				     calcFunc-por calcFunc-pnot)))
-	(blanks (and (not all)
+	(math-rewrite-heads-blanks (and (not all)
 		     '(calcFunc-quote calcFunc-plain calcFunc-select
 				      calcFunc-cons calcFunc-rcons
 				      calcFunc-pand))))
     (or (Math-primp expr)
 	(math-rewrite-heads-rec expr))
-    heads))
+    math-rewrite-heads-heads))
 
 (defun math-rewrite-heads-rec (expr)
-  (or (memq (car expr) skips)
+  (or (memq (car expr) math-rewrite-heads-skips)
       (progn
-	(or (memq (car expr) heads)
-	    (memq (car expr) blanks)
+	(or (memq (car expr) math-rewrite-heads-heads)
+	    (memq (car expr) math-rewrite-heads-blanks)
 	    (memq 'algebraic (get (car expr) 'math-rewrite-props))
-	    (setq heads (cons (car expr) heads)))
+	    (setq math-rewrite-heads-heads (cons (car expr) math-rewrite-heads-heads)))
 	(while (setq expr (cdr expr))
 	  (or (Math-primp (car expr))
 	      (math-rewrite-heads-rec (car expr)))))))
@@ -793,21 +834,31 @@
 	(list 'neg (list 'calcFunc-register (nth 1 entry)))
       (list 'calcFunc-register (nth 1 entry)))))
 
-(defun math-rwcomp-substitute (expr old new)
-  (if (and (eq (car-safe old) 'var)
-	   (memq (car-safe new) '(var calcFunc-lambda)))
-      (let ((old-func (math-var-to-calcFunc old))
-	    (new-func (math-var-to-calcFunc new)))
+;; The variables math-rwcomp-subst-old, math-rwcomp-subst-new,
+;; math-rwcomp-subst-old-func and math-rwcomp-subst-new-func
+;; are local to math-rwcomp-substitute, but are used by
+;; math-rwcomp-subst-rec, which is called by math-rwcomp-substitute.
+(defvar math-rwcomp-subst-new)
+(defvar math-rwcomp-subst-old)
+(defvar math-rwcomp-subst-new-func)
+(defvar math-rwcomp-subst-old-func)
+
+(defun math-rwcomp-substitute (expr math-rwcomp-subst-old math-rwcomp-subst-new)
+  (if (and (eq (car-safe math-rwcomp-subst-old) 'var)
+	   (memq (car-safe math-rwcomp-subst-new) '(var calcFunc-lambda)))
+      (let ((math-rwcomp-subst-old-func (math-var-to-calcFunc math-rwcomp-subst-old))
+	    (math-rwcomp-subst-new-func (math-var-to-calcFunc math-rwcomp-subst-new)))
 	(math-rwcomp-subst-rec expr))
-    (let ((old-func nil))
+    (let ((math-rwcomp-subst-old-func nil))
       (math-rwcomp-subst-rec expr))))
 
 (defun math-rwcomp-subst-rec (expr)
-  (cond ((equal expr old) new)
+  (cond ((equal expr math-rwcomp-subst-old) math-rwcomp-subst-new)
 	((Math-primp expr) expr)
-	(t (if (eq (car expr) old-func)
-	       (math-build-call new-func (mapcar 'math-rwcomp-subst-rec
-						 (cdr expr)))
+	(t (if (eq (car expr) math-rwcomp-subst-old-func)
+	       (math-build-call math-rwcomp-subst-new-func 
+                                (mapcar 'math-rwcomp-subst-rec
+                                        (cdr expr)))
 	     (cons (car expr)
 		   (mapcar 'math-rwcomp-subst-rec (cdr expr)))))))
 
@@ -1268,22 +1319,18 @@
 (defun math-rwcomp-assoc-args (expr)
   (if (and (eq (car-safe (nth 1 expr)) (car expr))
 	   (= (length (nth 1 expr)) 3))
-      (math-rwcomp-assoc-args (nth 1 expr))
-    (setq math-args (cons (nth 1 expr) math-args)))
+      (math-rwcomp-assoc-args (nth 1 expr)))
   (if (and (eq (car-safe (nth 2 expr)) (car expr))
 	   (= (length (nth 2 expr)) 3))
-      (math-rwcomp-assoc-args (nth 2 expr))
-    (setq math-args (cons (nth 2 expr) math-args))))
+      (math-rwcomp-assoc-args (nth 2 expr))))
 
 (defun math-rwcomp-addsub-args (expr)
   (if (memq (car-safe (nth 1 expr)) '(+ -))
-      (math-rwcomp-addsub-args (nth 1 expr))
-    (setq math-args (cons (nth 1 expr) math-args)))
+      (math-rwcomp-addsub-args (nth 1 expr)))
   (if (eq (car expr) '-)
-      (setq math-args (cons (math-rwcomp-neg (nth 2 expr)) math-args))
+      ()
     (if (eq (car-safe (nth 2 expr)) '+)
-	(math-rwcomp-addsub-args (nth 2 expr))
-      (setq math-args (cons (nth 2 expr) math-args)))))
+	(math-rwcomp-addsub-args (nth 2 expr)))))
 
 (defun math-rwcomp-order (a b)
   (< (math-rwcomp-priority (car a))
@@ -1419,14 +1466,23 @@
 	      form
 	      '(setcar rules orig))))
 
-(setq math-rewrite-phase 1)
+(defvar math-rewrite-phase 1)
+
+;; The variable math-apply-rw-regs is local to math-apply-rewrites,
+;; but is used by math-rwapply-replace-regs and math-rwapply-reg-looks-negp
+;; which are called by math-apply-rewrites.
+(defvar math-apply-rw-regs)
 
-(defun math-apply-rewrites (expr rules &optional heads ruleset)
+;; The variable math-apply-rw-ruleset is local to math-apply-rewrites,
+;; but is used by math-rwapply-remember.
+(defvar math-apply-rw-ruleset)
+
+(defun math-apply-rewrites (expr rules &optional heads math-apply-rw-ruleset)
   (and
    (setq rules (cdr (or (assq (car-safe expr) rules)
 			(assq nil rules))))
    (let ((result nil)
-	 op regs inst part pc mark btrack
+	 op math-apply-rw-regs inst part pc mark btrack
 	 (tracing math-rwcomp-tracing)
 	 (phase math-rewrite-phase))
      (while rules
@@ -1437,35 +1493,37 @@
 	(and (setq part (nth 3 (car rules)))
 	     (not (memq phase part)))
 	(progn
-	  (setq regs (car (car rules))
+	  (setq math-apply-rw-regs (car (car rules))
 		pc (nth 1 (car rules))
 		btrack nil)
-	  (aset regs 0 expr)
+	  (aset math-apply-rw-regs 0 expr)
 	  (while pc
 
 	    (and tracing
 		 (progn (terpri) (princ (car pc))
 			(if (and (natnump (nth 1 (car pc)))
-				 (< (nth 1 (car pc)) (length regs)))
-			    (princ (format "\n  part = %s"
-					   (aref regs (nth 1 (car pc))))))))
+				 (< (nth 1 (car pc)) (length math-apply-rw-regs)))
+			    (princ 
+                             (format "\n  part = %s"
+                                     (aref math-apply-rw-regs (nth 1 (car pc))))))))
 
 	    (cond ((eq (setq op (car (setq inst (car pc)))) 'func)
-		   (if (and (consp (setq part (aref regs (car (cdr inst)))))
+		   (if (and (consp 
+                             (setq part (aref math-apply-rw-regs (car (cdr inst)))))
 			    (eq (car part)
 				(car (setq inst (cdr (cdr inst)))))
 			    (progn
 			      (while (and (setq inst (cdr inst)
 						part (cdr part))
 					  inst)
-				(aset regs (car inst) (car part)))
+				(aset math-apply-rw-regs (car inst) (car part)))
 			      (not (or inst part))))
 		       (setq pc (cdr pc))
 		     (math-rwfail)))
 
 		  ((eq op 'same)
-		   (if (or (equal (setq part (aref regs (nth 1 inst)))
-				  (setq mark (aref regs (nth 2 inst))))
+		   (if (or (equal (setq part (aref math-apply-rw-regs (nth 1 inst)))
+				  (setq mark (aref math-apply-rw-regs (nth 2 inst))))
 			   (Math-equal part mark))
 		       (setq pc (cdr pc))
 		     (math-rwfail)))
@@ -1474,22 +1532,23 @@
 			calc-matrix-mode
 			(not (eq calc-matrix-mode 'scalar))
 			(eq (car (nth 2 inst)) '*)
-			(consp (setq part (aref regs (car (cdr inst)))))
+			(consp (setq part (aref math-apply-rw-regs (car (cdr inst)))))
 			(eq (car part) '*)
 			(not (math-known-scalarp part)))
 		   (setq mark (nth 3 inst)
 			 pc (cdr pc))
 		   (if (aref mark 4)
 		       (progn
-			 (aset regs (nth 4 inst) (nth 2 part))
+			 (aset math-apply-rw-regs (nth 4 inst) (nth 2 part))
 			 (aset mark 1 (cdr (cdr part))))
-		     (aset regs (nth 4 inst) (nth 1 part))
+		     (aset math-apply-rw-regs (nth 4 inst) (nth 1 part))
 		     (aset mark 1 (cdr part)))
 		   (aset mark 0 (cdr part))
 		   (aset mark 2 0))
 
 		  ((eq op 'try)
-		   (if (and (consp (setq part (aref regs (car (cdr inst)))))
+		   (if (and (consp (setq part 
+                                         (aref math-apply-rw-regs (car (cdr inst)))))
 			    (memq (car part) (nth 2 inst))
 			    (= (length part) 3)
 			    (or (not (eq (car part) '/))
@@ -1525,7 +1584,7 @@
 					      op))
 			       btrack (cons pc btrack)
 			       pc (cdr pc))
-			 (aset regs (nth 2 inst) (car op))
+			 (aset math-apply-rw-regs (nth 2 inst) (car op))
 			 (aset mark 0 op)
 			 (aset mark 1 op)
 			 (aset mark 2 (if (cdr (cdr op)) 1 0)))
@@ -1537,12 +1596,12 @@
 			     (progn
 			       (setq mark (nth 3 inst)
 				     pc (cdr pc))
-			       (aset regs (nth 4 inst) (nth 1 part))
+			       (aset math-apply-rw-regs (nth 4 inst) (nth 1 part))
 			       (aset mark 1 -1)
 			       (aset mark 2 4))
 			   (setq mark (nth 3 inst)
 				 pc (cdr pc))
-			   (aset regs (nth 4 inst) part)
+			   (aset math-apply-rw-regs (nth 4 inst) part)
 			   (aset mark 2 3))
 		       (math-rwfail))))
 
@@ -1551,7 +1610,7 @@
 			 mark (nth 3 part)
 			 op (aref mark 2)
 			 pc (cdr pc))
-		   (aset regs (nth 2 inst)
+		   (aset math-apply-rw-regs (nth 2 inst)
 			 (cond
 			  ((eq op 0)
 			   (if (eq (aref mark 0) (aref mark 1))
@@ -1591,17 +1650,17 @@
 
 		  ((eq op 'select)
 		   (setq pc (cdr pc))
-		   (if (and (consp (setq part (aref regs (nth 1 inst))))
+		   (if (and (consp (setq part (aref math-apply-rw-regs (nth 1 inst))))
 			    (eq (car part) 'calcFunc-select))
-		       (aset regs (nth 2 inst) (nth 1 part))
+		       (aset math-apply-rw-regs (nth 2 inst) (nth 1 part))
 		     (if math-rewrite-selections
 			 (math-rwfail)
-		       (aset regs (nth 2 inst) part))))
+		       (aset math-apply-rw-regs (nth 2 inst) part))))
 
 		  ((eq op 'same-neg)
-		   (if (or (equal (setq part (aref regs (nth 1 inst)))
+		   (if (or (equal (setq part (aref math-apply-rw-regs (nth 1 inst)))
 				  (setq mark (math-neg
-					      (aref regs (nth 2 inst)))))
+					      (aref math-apply-rw-regs (nth 2 inst)))))
 			   (Math-equal part mark))
 		       (setq pc (cdr pc))
 		     (math-rwfail)))
@@ -1613,22 +1672,24 @@
 			 op (aref mark 2))
 		   (cond ((eq op 0)
 			  (if (setq op (cdr (aref mark 1)))
-			      (aset regs (nth 4 inst) (car (aset mark 1 op)))
+			      (aset math-apply-rw-regs (nth 4 inst) 
+                                    (car (aset mark 1 op)))
 			    (if (nth 5 inst)
 				(progn
 				  (aset mark 2 3)
-				  (aset regs (nth 4 inst)
-					(aref regs (nth 1 inst))))
+				  (aset math-apply-rw-regs (nth 4 inst)
+					(aref math-apply-rw-regs (nth 1 inst))))
 			      (math-rwfail t))))
 			 ((eq op 1)
 			  (if (setq op (cdr (aref mark 1)))
-			      (aset regs (nth 4 inst) (car (aset mark 1 op)))
+			      (aset math-apply-rw-regs (nth 4 inst) 
+                                    (car (aset mark 1 op)))
 			    (if (= (aref mark 3) 1)
 				(if (nth 5 inst)
 				    (progn
 				      (aset mark 2 3)
-				      (aset regs (nth 4 inst)
-					    (aref regs (nth 1 inst))))
+				      (aset math-apply-rw-regs (nth 4 inst)
+					    (aref math-apply-rw-regs (nth 1 inst))))
 				  (math-rwfail t))
 			      (aset mark 2 2)
 			      (aset mark 1 (cons nil (aref mark 0)))
@@ -1666,19 +1727,20 @@
 						   (list '- part
 							 (nth 1 (car mark)))
 						 (list op part (car mark))))))
-				(aset regs (nth 4 inst) part))
+				(aset math-apply-rw-regs (nth 4 inst) part))
 			    (if (nth 5 inst)
 				(progn
 				  (aset mark 2 3)
-				  (aset regs (nth 4 inst)
-					(aref regs (nth 1 inst))))
+				  (aset math-apply-rw-regs (nth 4 inst)
+					(aref math-apply-rw-regs (nth 1 inst))))
 			      (math-rwfail t))))
 			 ((eq op 4)
 			  (setq btrack (cdr btrack)))
 			 (t (math-rwfail t))))
 
 		  ((eq op 'integer)
-		   (if (Math-integerp (setq part (aref regs (nth 1 inst))))
+		   (if (Math-integerp (setq part 
+                                            (aref math-apply-rw-regs (nth 1 inst))))
 		       (setq pc (cdr pc))
 		     (if (Math-primp part)
 			 (math-rwfail)
@@ -1688,7 +1750,7 @@
 			 (math-rwfail)))))
 
 		  ((eq op 'real)
-		   (if (Math-realp (setq part (aref regs (nth 1 inst))))
+		   (if (Math-realp (setq part (aref math-apply-rw-regs (nth 1 inst))))
 		       (setq pc (cdr pc))
 		     (if (Math-primp part)
 			 (math-rwfail)
@@ -1698,7 +1760,7 @@
 			 (math-rwfail)))))
 
 		  ((eq op 'constant)
-		   (if (math-constp (setq part (aref regs (nth 1 inst))))
+		   (if (math-constp (setq part (aref math-apply-rw-regs (nth 1 inst))))
 		       (setq pc (cdr pc))
 		     (if (Math-primp part)
 			 (math-rwfail)
@@ -1708,7 +1770,8 @@
 			 (math-rwfail)))))
 
 		  ((eq op 'negative)
-		   (if (math-looks-negp (setq part (aref regs (nth 1 inst))))
+		   (if (math-looks-negp (setq part 
+                                              (aref math-apply-rw-regs (nth 1 inst))))
 		       (setq pc (cdr pc))
 		     (if (Math-primp part)
 			 (math-rwfail)
@@ -1718,15 +1781,16 @@
 			 (math-rwfail)))))
 
 		  ((eq op 'rel)
-		   (setq part (math-compare (aref regs (nth 1 inst))
-					    (aref regs (nth 3 inst)))
+		   (setq part (math-compare (aref math-apply-rw-regs (nth 1 inst))
+					    (aref math-apply-rw-regs (nth 3 inst)))
 			 op (nth 2 inst))
 		   (if (= part 2)
 		       (setq part (math-rweval
 				   (math-simplify
 				    (calcFunc-sign
-				     (math-sub (aref regs (nth 1 inst))
-					       (aref regs (nth 3 inst))))))))
+				     (math-sub 
+                                      (aref math-apply-rw-regs (nth 1 inst))
+                                      (aref math-apply-rw-regs (nth 3 inst))))))))
 		   (if (cond ((eq op 'calcFunc-eq)
 			      (eq part 0))
 			     ((eq op 'calcFunc-neq)
@@ -1743,44 +1807,48 @@
 		     (math-rwfail)))
 
 		  ((eq op 'func-def)
-		   (if (and (consp (setq part (aref regs (car (cdr inst)))))
-			    (eq (car part)
-				(car (setq inst (cdr (cdr inst))))))
+		   (if (and 
+                        (consp (setq part (aref math-apply-rw-regs (car (cdr inst)))))
+                        (eq (car part)
+                            (car (setq inst (cdr (cdr inst))))))
 		       (progn
 			 (setq inst (cdr inst)
 			       mark (car inst))
 			 (while (and (setq inst (cdr inst)
 					   part (cdr part))
 				     inst)
-			   (aset regs (car inst) (car part)))
+			   (aset math-apply-rw-regs (car inst) (car part)))
 			 (if (or inst part)
 			     (setq pc (cdr pc))
 			   (while (eq (car (car (setq pc (cdr pc))))
 				      'func-def))
 			   (setq pc (cdr pc))   ; skip over "func"
 			   (while mark
-			     (aset regs (cdr (car mark)) (car (car mark)))
+			     (aset math-apply-rw-regs (cdr (car mark)) (car (car mark)))
 			     (setq mark (cdr mark)))))
 		     (math-rwfail)))
 
 		  ((eq op 'func-opt)
-		   (if (or (not (and (consp
-				      (setq part (aref regs (car (cdr inst)))))
-				     (eq (car part) (nth 2 inst))))
+		   (if (or (not 
+                            (and 
+                             (consp
+                              (setq part (aref math-apply-rw-regs (car (cdr inst)))))
+                             (eq (car part) (nth 2 inst))))
 			   (and (= (length part) 2)
 				(setq part (nth 1 part))))
 		       (progn
 			 (setq mark (nth 3 inst))
-			 (aset regs (nth 4 inst) part)
+			 (aset math-apply-rw-regs (nth 4 inst) part)
 			 (while (eq (car (car (setq pc (cdr pc)))) 'func-def))
 			 (setq pc (cdr pc))   ; skip over "func"
 			 (while mark
-			   (aset regs (cdr (car mark)) (car (car mark)))
+			   (aset math-apply-rw-regs (cdr (car mark)) (car (car mark)))
 			   (setq mark (cdr mark))))
 		     (setq pc (cdr pc))))
 
 		  ((eq op 'mod)
-		   (if (if (Math-zerop (setq part (aref regs (nth 1 inst))))
+		   (if (if (Math-zerop 
+                            (setq part (aref math-apply-rw-regs (nth 1 inst))))
 			   (Math-zerop (nth 3 inst))
 			 (and (not (Math-zerop (nth 2 inst)))
 			      (progn
@@ -1793,34 +1861,38 @@
 		     (math-rwfail)))
 
 		  ((eq op 'apply)
-		   (if (and (consp (setq part (aref regs (car (cdr inst)))))
+		   (if (and (consp 
+                             (setq part (aref math-apply-rw-regs (car (cdr inst)))))
 			    (not (Math-objvecp part))
 			    (not (eq (car part) 'var)))
 		       (progn
-			 (aset regs (nth 2 inst)
+			 (aset math-apply-rw-regs (nth 2 inst)
 			       (math-calcFunc-to-var (car part)))
-			 (aset regs (nth 3 inst)
+			 (aset math-apply-rw-regs (nth 3 inst)
 			       (cons 'vec (cdr part)))
 			 (setq pc (cdr pc)))
 		     (math-rwfail)))
 
 		  ((eq op 'cons)
-		   (if (and (consp (setq part (aref regs (car (cdr inst)))))
+		   (if (and (consp 
+                             (setq part (aref math-apply-rw-regs (car (cdr inst)))))
 			    (eq (car part) 'vec)
 			    (cdr part))
 		       (progn
-			 (aset regs (nth 2 inst) (nth 1 part))
-			 (aset regs (nth 3 inst) (cons 'vec (cdr (cdr part))))
+			 (aset math-apply-rw-regs (nth 2 inst) (nth 1 part))
+			 (aset math-apply-rw-regs (nth 3 inst) 
+                               (cons 'vec (cdr (cdr part))))
 			 (setq pc (cdr pc)))
 		     (math-rwfail)))
 
 		  ((eq op 'rcons)
-		   (if (and (consp (setq part (aref regs (car (cdr inst)))))
+		   (if (and (consp 
+                             (setq part (aref math-apply-rw-regs (car (cdr inst)))))
 			    (eq (car part) 'vec)
 			    (cdr part))
 		       (progn
-			 (aset regs (nth 2 inst) (calcFunc-rhead part))
-			 (aset regs (nth 3 inst) (calcFunc-rtail part))
+			 (aset math-apply-rw-regs (nth 2 inst) (calcFunc-rhead part))
+			 (aset math-apply-rw-regs (nth 3 inst) (calcFunc-rtail part))
 			 (setq pc (cdr pc)))
 		     (math-rwfail)))
 
@@ -1833,19 +1905,20 @@
 		     (math-rwfail)))
 
 		  ((eq op 'let)
-		   (aset regs (nth 1 inst)
+		   (aset math-apply-rw-regs (nth 1 inst)
 			 (math-rweval
 			  (math-normalize
 			   (math-rwapply-replace-regs (nth 2 inst)))))
 		   (setq pc (cdr pc)))
 
 		  ((eq op 'copy)
-		   (aset regs (nth 2 inst) (aref regs (nth 1 inst)))
+		   (aset math-apply-rw-regs (nth 2 inst) 
+                         (aref math-apply-rw-regs (nth 1 inst)))
 		   (setq pc (cdr pc)))
 
 		  ((eq op 'copy-neg)
-		   (aset regs (nth 2 inst)
-			 (math-rwapply-neg (aref regs (nth 1 inst))))
+		   (aset math-apply-rw-regs (nth 2 inst)
+			 (math-rwapply-neg (aref math-apply-rw-regs (nth 1 inst))))
 		   (setq pc (cdr pc)))
 
 		  ((eq op 'alt)
@@ -1904,7 +1977,7 @@
   (cond ((Math-primp expr)
 	 expr)
 	((eq (car expr) 'calcFunc-register)
-	 (setq expr (aref regs (nth 1 expr)))
+	 (setq expr (aref math-apply-rw-regs (nth 1 expr)))
 	 (if (eq (car-safe expr) '*)
 	     (if (eq (nth 1 expr) -1)
 		 (math-neg (nth 2 expr))
@@ -1953,7 +2026,7 @@
 	 (math-rwapply-reg-neg (nth 1 expr)))
 	((and (eq (car expr) 'neg)
 	      (eq (car-safe (nth 1 expr)) 'calcFunc-register)
-	      (math-scalarp (aref regs (nth 1 (nth 1 expr)))))
+	      (math-scalarp (aref math-apply-rw-regs (nth 1 (nth 1 expr)))))
 	 (math-neg (math-rwapply-replace-regs (nth 1 expr))))
 	((and (eq (car expr) '+)
 	      (math-rwapply-reg-looks-negp (nth 1 expr)))
@@ -2001,14 +2074,14 @@
 	 (if (Math-primp (nth 1 expr))
 	     (nth 1 expr)
 	   (if (eq (car (nth 1 expr)) 'calcFunc-register)
-	       (aref regs (nth 1 (nth 1 expr)))
+	       (aref math-apply-rw-regs (nth 1 (nth 1 expr)))
 	     (cons (car (nth 1 expr)) (mapcar 'math-rwapply-replace-regs
 					      (cdr (nth 1 expr)))))))
 	(t (cons (car expr) (mapcar 'math-rwapply-replace-regs (cdr expr))))))
 
 (defun math-rwapply-reg-looks-negp (expr)
   (if (eq (car-safe expr) 'calcFunc-register)
-      (math-looks-negp (aref regs (nth 1 expr)))
+      (math-looks-negp (aref math-apply-rw-regs (nth 1 expr)))
     (if (memq (car-safe expr) '(* /))
 	(or (math-rwapply-reg-looks-negp (nth 1 expr))
 	    (math-rwapply-reg-looks-negp (nth 2 expr))))))
@@ -2025,8 +2098,8 @@
 				       (math-rwapply-reg-neg (nth 2 expr)))))))
 
 (defun math-rwapply-remember (old new)
-  (let ((varval (symbol-value (nth 2 (car ruleset))))
-	(rules (assq (car-safe old) ruleset)))
+  (let ((varval (symbol-value (nth 2 (car math-apply-rw-ruleset))))
+	(rules (assq (car-safe old) math-apply-rw-ruleset)))
     (if (and (eq (car-safe varval) 'vec)
 	     (not (memq (car-safe old) '(nil schedule + -)))
 	     rules)