* lisp/calc/: Use lexical scoping in all the files

Includes the following pervasive changes:
- Move some defvars earlier in the file so they cover earlier let-bindings
- Change dynamically scoped `calc-FOO` or `math-FOO` function arguments
  to just FOO and then let-bind the `calc-FOO` or `math-FOO` variable
  explicitly in the body of the function.  In some cases, the
  beginning of the function was changed to refer to FOO so as to delay
  the binding to a nearby `let` when I could ensure that it did
  not make a difference.
- Add an underscore in front of unused vars or comment them out altogether.
- Replace unused `err` arg to `condition-case` with nil.

Plus the additional itemized changes below.

* lisp/calc/calc-map.el (calcFunc-reducer):
* lisp/calc/calc-arith.el (math-setup-declarations):
* lisp/calc/calc-help.el (calc-full-help, calc-help-index-entries)
(calc-full-help): Use `ignore-errors`.

* lisp/calc/calc-embed.el (calc-embedded-modes-change):
Declare `the-language` and `the-display-just` as dynamically scoped.

* lisp/calc/calc-forms.el (math-setup-year-holidays): Use `dolist`.

* lisp/calc/calc-graph.el (calc-graph-set-styles): Use `symbol-value`
rather than `eval.`
(calc-graph-delete-temps, calc-graph-set-styles): Use ignore-errors.

* lisp/calc/calc-macs.el (calc-with-trail-buffer): Add artificial use
of `save-buf` to silence compiler warnings in all the cases where
`body` doesn't make use of it.

* lisp/calc/calc-math.el (math-largest-emacs-expt)
(math-smallest-emacs-expt, math-use-emacs-fn): Use ignore-errors.

* lisp/calc/calc-mode.el (calc-total-algebraic-mode): Remove "P" from
interactive spec since it's not used anyway.

* lisp/calc/calc-rewr.el (calc-match): Simplify.

* lisp/calc/calc.el (calc-buffer): Give it a global nil value,
so it's automatically declared dynbound in any file that requires `calc`.
(calcDigit-nondigit): Adjust accordingly.

* lisp/calc/calcalg2.el (calcFunc-table): Declare `var-dummy` as dynbound.
(math-scan-for-limits): Comment out dead code.

* lisp/calc/calcalg3.el (math-general-fit): Declare `var-YVAL` and
`var-YVALX` as dynbound.

1 files changed, 25 insertions, 19 deletions

diff --git a/lisp/calc/calc-rewr.el b/lisp/calc/calc-rewr.el
index bb909e728e1..2cc7b6beef0 100644
--- a/lisp/calc/calc-rewr.el
+++ b/lisp/calc/calc-rewr.el
@@ -1,4 +1,4 @@
-;;; calc-rewr.el --- rewriting functions for Calc
+;;; calc-rewr.el --- rewriting functions for Calc  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 1990-1993, 2001-2020 Free Software Foundation, Inc.
 
@@ -142,7 +142,7 @@
      (calc-pop-push-record-list n "rwrt" (list expr)))
    (calc-handle-whys)))
 
-(defun calc-match (pat &optional interactive)
+(defun calc-match (pat &optional _interactive)
   (interactive "sPattern: \np")
   (calc-slow-wrapper
    (let (n expr)
@@ -158,9 +158,9 @@
        (setq expr (calc-top-n 1)
 	     n 1))
      (or (math-vectorp expr) (error "Argument must be a vector"))
-     (if (calc-is-inverse)
-	 (calc-enter-result n "mtcn" (math-match-patterns pat expr t))
-       (calc-enter-result n "mtch" (math-match-patterns pat expr nil))))))
+     (calc-enter-result n "mtcn"
+                        (math-match-patterns pat expr
+                                             (not (not (calc-is-inverse))))))))
 
 
 (defvar math-mt-many)
@@ -169,8 +169,10 @@
 ;; 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))
+(defun math-rewrite (rewrite-whole-expr rules &optional mt-many)
+  (let* ((math-rewrite-whole-expr rewrite-whole-expr)
+         (math-mt-many mt-many)
+         (crules (math-compile-rewrites rules))
          (heads (math-rewrite-heads math-rewrite-whole-expr))
          (trace-buffer (get-buffer "*Trace*"))
          (calc-display-just 'center)
@@ -211,6 +213,8 @@
 		    ":\n" fmt "\n"))))
     math-rewrite-whole-expr))
 
+(defvar math-rewrite-phase 1)
+
 (defun math-rewrite-phase (sched)
   (while (and sched (/= math-mt-many 0))
     (if (listp (car sched))
@@ -464,6 +468,8 @@
 ;;;    whole match the name v.  Beware of circular structures!
 ;;;
 
+(defvar math-rewrite-whole nil)
+
 (defun math-compile-patterns (pats)
   (if (and (eq (car-safe pats) 'var)
 	   (calc-var-value (nth 2 pats)))
@@ -485,7 +491,6 @@
 					       (cdr pats)
 					     (list pats)))))))))
 
-(defvar math-rewrite-whole nil)
 (defvar math-make-import-list nil)
 
 ;; The variable math-import-list is local to part of math-compile-rewrites,
@@ -580,7 +585,7 @@
     (let ((rule-set nil)
 	  (all-heads nil)
 	  (nil-rules nil)
-	  (rule-count 0)
+	  ;; (rule-count 0)
 	  (math-schedule nil)
 	  (math-iterations nil)
 	  (math-phases nil)
@@ -831,14 +836,16 @@
 (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)))
+(defun math-rwcomp-substitute (expr rwcomp-subst-old rwcomp-subst-new)
+  (let ((math-rwcomp-subst-old rwcomp-subst-old)
+        (math-rwcomp-subst-new rwcomp-subst-new))
+  (if (and (eq (car-safe rwcomp-subst-old) 'var)
+	   (memq (car-safe rwcomp-subst-new) '(var calcFunc-lambda)))
+      (let ((math-rwcomp-subst-old-func (math-var-to-calcFunc rwcomp-subst-old))
+	    (math-rwcomp-subst-new-func (math-var-to-calcFunc rwcomp-subst-new)))
 	(math-rwcomp-subst-rec expr))
     (let ((math-rwcomp-subst-old-func nil))
-      (math-rwcomp-subst-rec expr))))
+      (math-rwcomp-subst-rec expr)))))
 
 (defun math-rwcomp-subst-rec (expr)
   (cond ((equal expr math-rwcomp-subst-old) math-rwcomp-subst-new)
@@ -1452,8 +1459,6 @@
 	 ,form
        (setcar rules orig))))
 
-(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.
@@ -1463,11 +1468,12 @@
 ;; but is used by math-rwapply-remember.
 (defvar math-apply-rw-ruleset)
 
-(defun math-apply-rewrites (expr rules &optional heads math-apply-rw-ruleset)
+(defun math-apply-rewrites (expr rules &optional heads apply-rw-ruleset)
   (and
    (setq rules (cdr (or (assq (car-safe expr) rules)
 			(assq nil rules))))
-   (let ((result nil)
+   (let ((math-apply-rw-ruleset apply-rw-ruleset)
+	 (result nil)
 	 op math-apply-rw-regs inst part pc mark btrack
 	 (tracing math-rwcomp-tracing)
 	 (phase math-rewrite-phase))