* 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, 40 insertions, 41 deletions

diff --git a/lisp/calc/calc-arith.el b/lisp/calc/calc-arith.el
index b487aae6883..ae397c4f2c4 100644
--- a/lisp/calc/calc-arith.el
+++ b/lisp/calc/calc-arith.el
@@ -1,4 +1,4 @@
-;;; calc-arith.el --- arithmetic functions for Calc
+;;; calc-arith.el --- arithmetic functions for Calc  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 1990-1993, 2001-2020 Free Software Foundation, Inc.
 
@@ -250,44 +250,43 @@
 	     (while (setq p (cdr p))
 	       (and (eq (car-safe (car p)) 'vec)
 		    (setq vec (nth 2 (car p)))
-		    (condition-case err
-			(let ((v (nth 1 (car p))))
-			  (setq type nil range nil)
-			  (or (eq (car-safe vec) 'vec)
-			      (setq vec (list 'vec vec)))
-			  (while (and (setq vec (cdr vec))
-				      (not (Math-objectp (car vec))))
-			    (and (eq (car-safe (car vec)) 'var)
-				 (let ((st (assq (nth 1 (car vec))
-						 math-super-types)))
-				   (cond (st (setq type (append type st)))
-					 ((eq (nth 1 (car vec)) 'pos)
-					  (setq type (append type
-							     '(real number))
-						range
-						'(intv 1 0 (var inf var-inf))))
-					 ((eq (nth 1 (car vec)) 'nonneg)
-					  (setq type (append type
-							     '(real number))
-						range
-						'(intv 3 0
-						       (var inf var-inf))))))))
-			  (if vec
-			      (setq type (append type '(real number))
-				    range (math-prepare-set (cons 'vec vec))))
-			  (setq type (list type range))
-			  (or (eq (car-safe v) 'vec)
-			      (setq v (list 'vec v)))
-			  (while (setq v (cdr v))
-			    (if (or (eq (car-safe (car v)) 'var)
-				    (not (Math-primp (car v))))
-				(setq math-decls-cache
-				      (cons (cons (if (eq (car (car v)) 'var)
-						      (nth 2 (car v))
-						    (car (car v)))
-						  type)
-					    math-decls-cache)))))
-		      (error nil)))))
+		    (ignore-errors
+		      (let ((v (nth 1 (car p))))
+			(setq type nil range nil)
+			(or (eq (car-safe vec) 'vec)
+			    (setq vec (list 'vec vec)))
+			(while (and (setq vec (cdr vec))
+				    (not (Math-objectp (car vec))))
+			  (and (eq (car-safe (car vec)) 'var)
+			       (let ((st (assq (nth 1 (car vec))
+					       math-super-types)))
+				 (cond (st (setq type (append type st)))
+				       ((eq (nth 1 (car vec)) 'pos)
+					(setq type (append type
+							   '(real number))
+					      range
+					      '(intv 1 0 (var inf var-inf))))
+				       ((eq (nth 1 (car vec)) 'nonneg)
+					(setq type (append type
+							   '(real number))
+					      range
+					      '(intv 3 0
+						(var inf var-inf))))))))
+			(if vec
+			    (setq type (append type '(real number))
+				  range (math-prepare-set (cons 'vec vec))))
+			(setq type (list type range))
+			(or (eq (car-safe v) 'vec)
+			    (setq v (list 'vec v)))
+			(while (setq v (cdr v))
+			  (if (or (eq (car-safe (car v)) 'var)
+				  (not (Math-primp (car v))))
+			      (setq math-decls-cache
+				    (cons (cons (if (eq (car (car v)) 'var)
+						    (nth 2 (car v))
+						  (car (car v)))
+						type)
+					  math-decls-cache)))))))))
 	(setq math-decls-all (assq 'var-All math-decls-cache)))))
 
 (defun math-known-scalarp (a &optional assume-scalar)
@@ -2892,7 +2891,7 @@
 				      (eq a b))
 				 (list 'calcFunc-exp sumpow))
 				(t
-				 (condition-case err
+				 (condition-case nil
 				     (math-pow a sumpow)
 				   (inexact-result (list '^ a sumpow)))))))))
 	    (and math-simplifying-units
@@ -2927,7 +2926,7 @@
 			(math-div 1 (list 'calcFunc-sqrt (math-mul a b))))
 		       (t
 			(setq a (math-mul a b))
-			(condition-case err
+			(condition-case nil
 			    (math-pow a apow)
 			  (inexact-result (list '^ a apow)))))))))))