(calc-do-quick-calc): Use kill-new to append string to kill-ring.

(calc-alg-exp, math-toks, math-exp-pos,math-exp-old-pos)
(math-exp-token, math-exp-keep-spaces, math-exp-str):  New variables.

(calc-do-alg-entry, calcAlg-equals, calcAlg-edit, calcAlg-enter):  Use
declared variable calc-alg-exp.

(math-build-parse-table, math-find-user-token):  Use declared variable
math-toks.

(math-read-exprs, math-read-token, calc-check-user-syntax,
calc-match-user-syntax, match-factor-after, math-read-factor):  Use
declared variables math-exp-pos math-exp-old-pos.

(math-read-exprs, math-read-token, math-read-expr-level)
(calc-check-user-syntax, calc-match-user-syntax, match-factor-after)
(math-read-factor):  Use declared variable math-exp-token.

(math-read-exprs, math-read-expr-list, math-read-token,
math-read-factor):  Use declared variable math-exp-keep-spaces.

(math-read-exprs, math-read-token):  Use declared variable
math-exp-str.

(calc-match-user-syntax):  Made m a local variable.

1 files changed, 177 insertions, 158 deletions

diff --git a/lisp/calc/calc-aent.el b/lisp/calc/calc-aent.el
index fef561742dc..182b3b0635c 100644
--- a/lisp/calc/calc-aent.el
+++ b/lisp/calc/calc-aent.el
@@ -101,10 +101,7 @@
           (message "Result: %s" buf)))
       (if (eq last-command-char 10)
           (insert shortbuf)
-        (setq kill-ring (cons shortbuf kill-ring))
-        (when (> (length kill-ring) kill-ring-max)
-          (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil))
-        (setq kill-ring-yank-pointer kill-ring)))))
+        (kill-new shortbuf)))))
 
 (defun calc-do-calc-eval (str separator args)
   (calc-check-defines)
@@ -301,10 +298,12 @@
 (defvar calc-alg-ent-esc-map nil
   "The keymap used for escapes in algebraic entry.")
 
+(defvar calc-alg-exp)
+
 (defun calc-do-alg-entry (&optional initial prompt no-normalize)
   (let* ((calc-buffer (current-buffer))
          (blink-paren-function 'calcAlg-blink-matching-open)
-         (alg-exp 'error))
+         (calc-alg-exp 'error))
     (unless calc-alg-ent-map
       (setq calc-alg-ent-map (copy-keymap minibuffer-local-map))
       (define-key calc-alg-ent-map "'" 'calcAlg-previous)
@@ -328,13 +327,13 @@
     (let ((buf (read-from-minibuffer (or prompt "Algebraic: ")
                                      (or initial "")
                                      calc-alg-ent-map nil)))
-      (when (eq alg-exp 'error)
-        (when (eq (car-safe (setq alg-exp (math-read-exprs buf))) 'error)
-          (setq alg-exp nil)))
+      (when (eq calc-alg-exp 'error)
+        (when (eq (car-safe (setq calc-alg-exp (math-read-exprs buf))) 'error)
+          (setq calc-alg-exp nil)))
       (setq calc-aborted-prefix "alg'")
       (or no-normalize
-          (and alg-exp (setq alg-exp (mapcar 'calc-normalize alg-exp))))
-      alg-exp)))
+          (and calc-alg-exp (setq calc-alg-exp (mapcar 'calc-normalize calc-alg-exp))))
+      calc-alg-exp)))
 
 (defun calcAlg-plus-minus ()
   (interactive)
@@ -364,8 +363,8 @@
   (interactive)
   (unwind-protect
       (calcAlg-enter)
-    (if (consp alg-exp)
-        (progn (setq prefix-arg (length alg-exp))
+    (if (consp calc-alg-exp)
+        (progn (setq prefix-arg (length calc-alg-exp))
                (calc-unread-command ?=)))))
 
 (defun calcAlg-escape ()
@@ -383,8 +382,8 @@
           (calc-minibuffer-contains
            "\\`\\([^\"]*\"[^\"]*\"\\)*[^\"]*\"[^\"]*\\'"))
       (insert "`")
-    (setq alg-exp (minibuffer-contents))
-    (and (> (length alg-exp) 0) (setq calc-previous-alg-entry alg-exp))
+    (setq calc-alg-exp (minibuffer-contents))
+    (and (> (length calc-alg-exp) 0) (setq calc-previous-alg-entry calc-alg-exp))
     (exit-minibuffer)))
 
 (defun calcAlg-enter ()
@@ -402,7 +401,7 @@
           (calc-temp-minibuffer-message
            (concat " [" (or (nth 2 exp) "Error") "]"))
           (calc-clear-unread-commands))
-      (setq alg-exp (if (calc-minibuffer-contains "\\` *\\[ *\\'")
+      (setq calc-alg-exp (if (calc-minibuffer-contains "\\` *\\[ *\\'")
                         '((incomplete vec))
                       exp))
       (and (> (length str) 0) (setq calc-previous-alg-entry str))
@@ -460,27 +459,36 @@
 
 ;;; Algebraic expression parsing.   [Public]
 
-(defun math-read-exprs (exp-str)
-  (let ((exp-pos 0)
-        (exp-old-pos 0)
-        (exp-keep-spaces nil)
-        exp-token math-expr-data)
+;;; The next few variables are local to math-read-exprs (and math-read-expr)
+;;; but are set in functions they call.
+
+(defvar math-exp-pos)
+(defvar math-exp-str)
+(defvar math-exp-old-pos)
+(defvar math-exp-token)
+(defvar math-exp-keep-spaces)
+
+(defun math-read-exprs (math-exp-str)
+  (let ((math-exp-pos 0)
+        (math-exp-old-pos 0)
+        (math-exp-keep-spaces nil)
+        math-exp-token math-expr-data)
     (if calc-language-input-filter
-        (setq exp-str (funcall calc-language-input-filter exp-str)))
-    (while (setq exp-token (string-match "\\.\\.\\([^.]\\|.[^.]\\)" exp-str))
-      (setq exp-str (concat (substring exp-str 0 exp-token) "\\dots"
-                            (substring exp-str (+ exp-token 2)))))
+        (setq math-exp-str (funcall calc-language-input-filter math-exp-str)))
+    (while (setq math-exp-token (string-match "\\.\\.\\([^.]\\|.[^.]\\)" math-exp-str))
+      (setq math-exp-str (concat (substring math-exp-str 0 math-exp-token) "\\dots"
+                            (substring math-exp-str (+ math-exp-token 2)))))
     (math-build-parse-table)
     (math-read-token)
     (let ((val (catch 'syntax (math-read-expr-list))))
       (if (stringp val)
-          (list 'error exp-old-pos val)
-        (if (equal exp-token 'end)
+          (list 'error math-exp-old-pos val)
+        (if (equal math-exp-token 'end)
             val
-          (list 'error exp-old-pos "Syntax error"))))))
+          (list 'error math-exp-old-pos "Syntax error"))))))
 
 (defun math-read-expr-list ()
-  (let* ((exp-keep-spaces nil)
+  (let* ((math-exp-keep-spaces nil)
          (val (list (math-read-expr-level 0)))
          (last val))
     (while (equal math-expr-data ",")
@@ -496,20 +504,23 @@
 (defvar calc-user-tokens nil)
 (defvar calc-user-token-chars nil)
 
+(defvar math-toks nil
+  "Tokens to pass between math-build-parse-table and math-find-user-tokens.")
+
 (defun math-build-parse-table ()
   (let ((mtab (cdr (assq nil calc-user-parse-tables)))
         (ltab (cdr (assq calc-language calc-user-parse-tables))))
     (or (and (eq mtab calc-last-main-parse-table)
              (eq ltab calc-last-lang-parse-table))
         (let ((p (append mtab ltab))
-              (toks nil))
+              (math-toks nil))
           (setq calc-user-parse-table p)
           (setq calc-user-token-chars nil)
           (while p
             (math-find-user-tokens (car (car p)))
             (setq p (cdr p)))
           (setq calc-user-tokens (mapconcat 'identity
-                                            (sort (mapcar 'car toks)
+                                            (sort (mapcar 'car math-toks)
                                                   (function (lambda (x y)
                                                               (> (length x)
                                                                  (length y)))))
@@ -517,7 +528,7 @@
                 calc-last-main-parse-table mtab
                 calc-last-lang-parse-table ltab)))))
 
-(defun math-find-user-tokens (p)   ; uses "toks"
+(defun math-find-user-tokens (p)
   (while p
     (cond ((and (stringp (car p))
                 (or (> (length (car p)) 1) (equal (car p) "$")
@@ -528,9 +539,9 @@
                  (setq s (concat "\\<" s)))
              (if (string-match "[a-zA-Z0-9]\\'" s)
                  (setq s (concat s "\\>")))
-             (or (assoc s toks)
+             (or (assoc s math-toks)
                  (progn
-                   (setq toks (cons (list s) toks))
+                   (setq math-toks (cons (list s) math-toks))
                    (or (memq (aref (car p) 0) calc-user-token-chars)
                        (setq calc-user-token-chars
                              (cons (aref (car p) 0)
@@ -542,35 +553,35 @@
     (setq p (cdr p))))
 
 (defun math-read-token ()
-  (if (>= exp-pos (length exp-str))
-      (setq exp-old-pos exp-pos
-            exp-token 'end
+  (if (>= math-exp-pos (length math-exp-str))
+      (setq math-exp-old-pos math-exp-pos
+            math-exp-token 'end
             math-expr-data "\000")
-    (let ((ch (aref exp-str exp-pos)))
-      (setq exp-old-pos exp-pos)
+    (let ((ch (aref math-exp-str math-exp-pos)))
+      (setq math-exp-old-pos math-exp-pos)
       (cond ((memq ch '(32 10 9))
-             (setq exp-pos (1+ exp-pos))
-             (if exp-keep-spaces
-                 (setq exp-token 'space
+             (setq math-exp-pos (1+ math-exp-pos))
+             (if math-exp-keep-spaces
+                 (setq math-exp-token 'space
                        math-expr-data " ")
                (math-read-token)))
             ((and (memq ch calc-user-token-chars)
                   (let ((case-fold-search nil))
-                    (eq (string-match calc-user-tokens exp-str exp-pos)
-                        exp-pos)))
-             (setq exp-token 'punc
-                   math-expr-data (math-match-substring exp-str 0)
-                   exp-pos (match-end 0)))
+                    (eq (string-match calc-user-tokens math-exp-str math-exp-pos)
+                        math-exp-pos)))
+             (setq math-exp-token 'punc
+                   math-expr-data (math-match-substring math-exp-str 0)
+                   math-exp-pos (match-end 0)))
             ((or (and (>= ch ?a) (<= ch ?z))
                  (and (>= ch ?A) (<= ch ?Z)))
              (string-match (if (memq calc-language '(c fortran pascal maple))
                                "[a-zA-Z0-9_#]*"
                              "[a-zA-Z0-9'#]*")
-                           exp-str exp-pos)
-             (setq exp-token 'symbol
-                   exp-pos (match-end 0)
+                           math-exp-str math-exp-pos)
+             (setq math-exp-token 'symbol
+                   math-exp-pos (match-end 0)
                    math-expr-data (math-restore-dashes
-                             (math-match-substring exp-str 0)))
+                             (math-match-substring math-exp-str 0)))
              (if (eq calc-language 'eqn)
                  (let ((code (assoc math-expr-data math-eqn-ignore-words)))
                    (cond ((null code))
@@ -582,121 +593,128 @@
                               (setq math-expr-data (format "%s %s"
                                                      (car code) math-expr-data))))
                          ((eq (nth 1 code) 'punc)
-                          (setq exp-token 'punc
+                          (setq math-exp-token 'punc
                                 math-expr-data (nth 2 code)))
                          (t
                           (math-read-token)
                           (math-read-token))))))
             ((or (and (>= ch ?0) (<= ch ?9))
                  (and (eq ch '?\.)
-                      (eq (string-match "\\.[0-9]" exp-str exp-pos) exp-pos))
+                      (eq (string-match "\\.[0-9]" math-exp-str math-exp-pos) 
+                          math-exp-pos))
                  (and (eq ch '?_)
-                      (eq (string-match "_\\.?[0-9]" exp-str exp-pos) exp-pos)
-                      (or (eq exp-pos 0)
+                      (eq (string-match "_\\.?[0-9]" math-exp-str math-exp-pos) 
+                          math-exp-pos)
+                      (or (eq math-exp-pos 0)
                           (and (memq calc-language '(nil flat big unform
                                                          tex eqn))
                                (eq (string-match "[^])}\"a-zA-Z0-9'$]_"
-                                                 exp-str (1- exp-pos))
-                                   (1- exp-pos))))))
+                                                 math-exp-str (1- math-exp-pos))
+                                   (1- math-exp-pos))))))
              (or (and (eq calc-language 'c)
-                      (string-match "0[xX][0-9a-fA-F]+" exp-str exp-pos))
-                 (string-match "_?\\([0-9]+.?0*@ *\\)?\\([0-9]+.?0*' *\\)?\\(0*\\([2-9]\\|1[0-4]\\)\\(#\\|\\^\\^\\)[0-9a-dA-D.]+[eE][-+_]?[0-9]+\\|0*\\([2-9]\\|[0-2][0-9]\\|3[0-6]\\)\\(#\\|\\^\\^\\)[0-9a-zA-Z:.]+\\|[0-9]+:[0-9:]+\\|[0-9.]+\\([eE][-+_]?[0-9]+\\)?\"?\\)?" exp-str exp-pos))
-             (setq exp-token 'number
-                   math-expr-data (math-match-substring exp-str 0)
-                   exp-pos (match-end 0)))
+                      (string-match "0[xX][0-9a-fA-F]+" math-exp-str math-exp-pos))
+                 (string-match "_?\\([0-9]+.?0*@ *\\)?\\([0-9]+.?0*' *\\)?\\(0*\\([2-9]\\|1[0-4]\\)\\(#\\|\\^\\^\\)[0-9a-dA-D.]+[eE][-+_]?[0-9]+\\|0*\\([2-9]\\|[0-2][0-9]\\|3[0-6]\\)\\(#\\|\\^\\^\\)[0-9a-zA-Z:.]+\\|[0-9]+:[0-9:]+\\|[0-9.]+\\([eE][-+_]?[0-9]+\\)?\"?\\)?" 
+                               math-exp-str math-exp-pos))
+             (setq math-exp-token 'number
+                   math-expr-data (math-match-substring math-exp-str 0)
+                   math-exp-pos (match-end 0)))
             ((eq ch ?\$)
              (if (and (eq calc-language 'pascal)
                       (eq (string-match
                            "\\(\\$[0-9a-fA-F]+\\)\\($\\|[^0-9a-zA-Z]\\)"
-                           exp-str exp-pos)
-                          exp-pos))
-                 (setq exp-token 'number
-                       math-expr-data (math-match-substring exp-str 1)
-                       exp-pos (match-end 1))
-               (if (eq (string-match "\\$\\([1-9][0-9]*\\)" exp-str exp-pos)
-                       exp-pos)
+                           math-exp-str math-exp-pos)
+                          math-exp-pos))
+                 (setq math-exp-token 'number
+                       math-expr-data (math-match-substring math-exp-str 1)
+                       math-exp-pos (match-end 1))
+               (if (eq (string-match "\\$\\([1-9][0-9]*\\)" math-exp-str math-exp-pos)
+                       math-exp-pos)
                    (setq math-expr-data (- (string-to-int (math-match-substring
-                                                     exp-str 1))))
-                 (string-match "\\$+" exp-str exp-pos)
+                                                     math-exp-str 1))))
+                 (string-match "\\$+" math-exp-str math-exp-pos)
                  (setq math-expr-data (- (match-end 0) (match-beginning 0))))
-               (setq exp-token 'dollar
-                     exp-pos (match-end 0))))
+               (setq math-exp-token 'dollar
+                     math-exp-pos (match-end 0))))
             ((eq ch ?\#)
-             (if (eq (string-match "#\\([1-9][0-9]*\\)" exp-str exp-pos)
-                     exp-pos)
+             (if (eq (string-match "#\\([1-9][0-9]*\\)" math-exp-str math-exp-pos)
+                     math-exp-pos)
                  (setq math-expr-data (string-to-int
-                                 (math-match-substring exp-str 1))
-                       exp-pos (match-end 0))
+                                 (math-match-substring math-exp-str 1))
+                       math-exp-pos (match-end 0))
                (setq math-expr-data 1
-                     exp-pos (1+ exp-pos)))
-             (setq exp-token 'hash))
+                     math-exp-pos (1+ math-exp-pos)))
+             (setq math-exp-token 'hash))
             ((eq (string-match "~=\\|<=\\|>=\\|<>\\|/=\\|\\+/-\\|\\\\dots\\|\\\\ldots\\|\\*\\*\\|<<\\|>>\\|==\\|!=\\|&&&\\||||\\|!!!\\|&&\\|||\\|!!\\|:=\\|::\\|=>"
-                               exp-str exp-pos)
-                 exp-pos)
-             (setq exp-token 'punc
-                   math-expr-data (math-match-substring exp-str 0)
-                   exp-pos (match-end 0)))
+                               math-exp-str math-exp-pos)
+                 math-exp-pos)
+             (setq math-exp-token 'punc
+                   math-expr-data (math-match-substring math-exp-str 0)
+                   math-exp-pos (match-end 0)))
             ((and (eq ch ?\")
-                  (string-match "\\(\"\\([^\"\\]\\|\\\\.\\)*\\)\\(\"\\|\\'\\)" exp-str exp-pos))
+                  (string-match "\\(\"\\([^\"\\]\\|\\\\.\\)*\\)\\(\"\\|\\'\\)" 
+                                math-exp-str math-exp-pos))
              (if (eq calc-language 'eqn)
                  (progn
-                   (setq exp-str (copy-sequence exp-str))
-                   (aset exp-str (match-beginning 1) ?\{)
-                   (if (< (match-end 1) (length exp-str))
-                       (aset exp-str (match-end 1) ?\}))
+                   (setq math-exp-str (copy-sequence math-exp-str))
+                   (aset math-exp-str (match-beginning 1) ?\{)
+                   (if (< (match-end 1) (length math-exp-str))
+                       (aset math-exp-str (match-end 1) ?\}))
                    (math-read-token))
-               (setq exp-token 'string
-                     math-expr-data (math-match-substring exp-str 1)
-                     exp-pos (match-end 0))))
+               (setq math-exp-token 'string
+                     math-expr-data (math-match-substring math-exp-str 1)
+                     math-exp-pos (match-end 0))))
             ((and (= ch ?\\) (eq calc-language 'tex)
-                  (< exp-pos (1- (length exp-str))))
-             (or (string-match "\\\\hbox *{\\([a-zA-Z0-9]+\\)}" exp-str exp-pos)
-                 (string-match "\\(\\\\\\([a-zA-Z]+\\|[^a-zA-Z]\\)\\)" exp-str exp-pos))
-             (setq exp-token 'symbol
-                   exp-pos (match-end 0)
+                  (< math-exp-pos (1- (length math-exp-str))))
+             (or (string-match "\\\\hbox *{\\([a-zA-Z0-9]+\\)}" 
+                               math-exp-str math-exp-pos)
+                 (string-match "\\(\\\\\\([a-zA-Z]+\\|[^a-zA-Z]\\)\\)" 
+                               math-exp-str math-exp-pos))
+             (setq math-exp-token 'symbol
+                   math-exp-pos (match-end 0)
                    math-expr-data (math-restore-dashes
-                             (math-match-substring exp-str 1)))
+                             (math-match-substring math-exp-str 1)))
              (let ((code (assoc math-expr-data math-tex-ignore-words)))
                (cond ((null code))
                      ((null (cdr code))
                       (math-read-token))
                      ((eq (nth 1 code) 'punc)
-                      (setq exp-token 'punc
+                      (setq math-exp-token 'punc
                             math-expr-data (nth 2 code)))
                      ((and (eq (nth 1 code) 'mat)
-                           (string-match " *{" exp-str exp-pos))
-                      (setq exp-pos (match-end 0)
-                            exp-token 'punc
+                           (string-match " *{" math-exp-str math-exp-pos))
+                      (setq math-exp-pos (match-end 0)
+                            math-exp-token 'punc
                             math-expr-data "[")
-                      (let ((right (string-match "}" exp-str exp-pos)))
+                      (let ((right (string-match "}" math-exp-str math-exp-pos)))
                         (and right
-                             (setq exp-str (copy-sequence exp-str))
-                             (aset exp-str right ?\])))))))
+                             (setq math-exp-str (copy-sequence math-exp-str))
+                             (aset math-exp-str right ?\])))))))
             ((and (= ch ?\.) (eq calc-language 'fortran)
                   (eq (string-match "\\.[a-zA-Z][a-zA-Z][a-zA-Z]?\\."
-                                    exp-str exp-pos) exp-pos))
-             (setq exp-token 'punc
-                   math-expr-data (upcase (math-match-substring exp-str 0))
-                   exp-pos (match-end 0)))
+                                    math-exp-str math-exp-pos) math-exp-pos))
+             (setq math-exp-token 'punc
+                   math-expr-data (upcase (math-match-substring math-exp-str 0))
+                   math-exp-pos (match-end 0)))
             ((and (eq calc-language 'math)
-                  (eq (string-match "\\[\\[\\|->\\|:>" exp-str exp-pos)
-                      exp-pos))
-             (setq exp-token 'punc
-                   math-expr-data (math-match-substring exp-str 0)
-                   exp-pos (match-end 0)))
+                  (eq (string-match "\\[\\[\\|->\\|:>" math-exp-str math-exp-pos)
+                      math-exp-pos))
+             (setq math-exp-token 'punc
+                   math-expr-data (math-match-substring math-exp-str 0)
+                   math-exp-pos (match-end 0)))
             ((and (eq calc-language 'eqn)
                   (eq (string-match "->\\|<-\\|+-\\|\\\\dots\\|~\\|\\^"
-                                    exp-str exp-pos)
-                      exp-pos))
-             (setq exp-token 'punc
-                   math-expr-data (math-match-substring exp-str 0)
-                   exp-pos (match-end 0))
-             (and (eq (string-match "\\\\dots\\." exp-str exp-pos) exp-pos)
-                  (setq exp-pos (match-end 0)))
+                                    math-exp-str math-exp-pos)
+                      math-exp-pos))
+             (setq math-exp-token 'punc
+                   math-expr-data (math-match-substring math-exp-str 0)
+                   math-exp-pos (match-end 0))
+             (and (eq (string-match "\\\\dots\\." math-exp-str math-exp-pos) 
+                      math-exp-pos)
+                  (setq math-exp-pos (match-end 0)))
              (if (memq (aref math-expr-data 0) '(?~ ?^))
                  (math-read-token)))
-            ((eq (string-match "%%.*$" exp-str exp-pos) exp-pos)
-             (setq exp-pos (match-end 0))
+            ((eq (string-match "%%.*$" math-exp-str math-exp-pos) math-exp-pos)
+             (setq math-exp-pos (match-end 0))
              (math-read-token))
             (t
              (if (and (eq ch ?\{) (memq calc-language '(tex eqn)))
@@ -705,9 +723,9 @@
                  (setq ch ?\)))
              (if (and (eq ch ?\&) (eq calc-language 'tex))
                  (setq ch ?\,))
-             (setq exp-token 'punc
+             (setq math-exp-token 'punc
                    math-expr-data (char-to-string ch)
-                   exp-pos (1+ exp-pos)))))))
+                   math-exp-pos (1+ math-exp-pos)))))))
 
 
 (defun math-read-expr-level (exp-prec &optional exp-term)
@@ -728,16 +746,16 @@
                                   (setq op op2))
                              t))
                     (and (or (eq (nth 2 op) -1)
-                             (memq exp-token '(symbol number dollar hash))
+                             (memq math-exp-token '(symbol number dollar hash))
                              (equal math-expr-data "(")
                              (and (equal math-expr-data "[")
                                   (not (eq calc-language 'math))
-                                  (not (and exp-keep-spaces
+                                  (not (and math-exp-keep-spaces
                                             (eq (car-safe x) 'vec)))))
                          (or (not (setq op (assoc math-expr-data math-expr-opers)))
                              (/= (nth 2 op) -1))
                          (or (not calc-user-parse-table)
-                             (not (eq exp-token 'symbol))
+                             (not (eq math-exp-token 'symbol))
                              (let ((p calc-user-parse-table))
                                (while (and p
                                            (or (not (integerp
@@ -790,9 +808,9 @@
                                     (equal math-expr-data
                                            (car (setq rule (cdr rule)))))
                              (equal math-expr-data (car rule)))))
-                    (let ((save-exp-pos exp-pos)
-                          (save-exp-old-pos exp-old-pos)
-                          (save-exp-token exp-token)
+                    (let ((save-exp-pos math-exp-pos)
+                          (save-exp-old-pos math-exp-old-pos)
+                          (save-exp-token math-exp-token)
                           (save-exp-data math-expr-data))
                       (or (not (listp
                                 (setq matches (calc-match-user-syntax rule))))
@@ -856,19 +874,20 @@
                             (if match
                                 (not (setq match (math-multi-subst
                                                   match args matches)))
-                              (setq exp-old-pos save-exp-old-pos
-                                    exp-token save-exp-token
+                              (setq math-exp-old-pos save-exp-old-pos
+                                    math-exp-token save-exp-token
                                     math-expr-data save-exp-data
-                                    exp-pos save-exp-pos)))))))
+                                    math-exp-pos save-exp-pos)))))))
       (setq p (cdr p)))
     (and p match)))
 
 (defun calc-match-user-syntax (p &optional term)
   (let ((matches nil)
-        (save-exp-pos exp-pos)
-        (save-exp-old-pos exp-old-pos)
-        (save-exp-token exp-token)
-        (save-exp-data math-expr-data))
+        (save-exp-pos math-exp-pos)
+        (save-exp-old-pos math-exp-old-pos)
+        (save-exp-token math-exp-token)
+        (save-exp-data math-expr-data)
+        m)
     (while (and p
                 (cond ((stringp (car p))
                        (and (equal math-expr-data (car p))
@@ -895,7 +914,7 @@
                                          (cons 'vec (and (listp m) m))))))
                        (or (listp m) (not (nth 2 (car p)))
                            (not (eq (aref (car (nth 2 (car p))) 0) ?\$))
-                           (eq exp-token 'end)))
+                           (eq math-exp-token 'end)))
                       (t
                        (setq m (calc-match-user-syntax (nth 1 (car p))
                                                        (car (nth 2 (car p)))))
@@ -903,21 +922,21 @@
                            (let ((vec (cons 'vec m))
                                  opos mm)
                              (while (and (listp
-                                          (setq opos exp-pos
+                                          (setq opos math-exp-pos
                                                 mm (calc-match-user-syntax
                                                     (or (nth 2 (car p))
                                                         (nth 1 (car p)))
                                                     (car (nth 2 (car p))))))
-                                         (> exp-pos opos))
+                                         (> math-exp-pos opos))
                                (setq vec (nconc vec mm)))
                              (setq matches (nconc matches (list vec))))
                          (and (eq (car (car p)) '*)
                               (setq matches (nconc matches (list '(vec)))))))))
       (setq p (cdr p)))
     (if p
-        (setq exp-pos save-exp-pos
-              exp-old-pos save-exp-old-pos
-              exp-token save-exp-token
+        (setq math-exp-pos save-exp-pos
+              math-exp-old-pos save-exp-old-pos
+              math-exp-token save-exp-token
               math-expr-data save-exp-data
               matches "Failed"))
     matches))
@@ -946,10 +965,10 @@
     (list 'calcFunc-if cond then (math-read-expr-level (nth 3 op)))))
 
 (defun math-factor-after ()
-  (let ((exp-pos exp-pos)
-        exp-old-pos exp-token math-expr-data)
+  (let ((math-exp-pos math-exp-pos)
+        math-exp-old-pos math-exp-token math-expr-data)
     (math-read-token)
-    (or (memq exp-token '(number symbol dollar hash string))
+    (or (memq math-exp-token '(number symbol dollar hash string))
         (and (assoc math-expr-data '(("-") ("+") ("!") ("|") ("/")))
              (assoc (concat "u" math-expr-data) math-expr-opers))
         (eq (nth 2 (assoc math-expr-data math-expr-opers)) -1)
@@ -957,11 +976,11 @@
 
 (defun math-read-factor ()
   (let (op)
-    (cond ((eq exp-token 'number)
+    (cond ((eq math-exp-token 'number)
            (let ((num (math-read-number math-expr-data)))
              (if (not num)
                  (progn
-                   (setq exp-old-pos exp-pos)
+                   (setq math-exp-old-pos math-exp-pos)
                    (throw 'syntax "Bad format")))
              (math-read-token)
              (if (and math-read-expr-quotes
@@ -990,7 +1009,7 @@
                            (equal (car op) "u-"))
                       (math-neg val))
                      (t (list (nth 1 op) val))))))
-          ((eq exp-token 'symbol)
+          ((eq math-exp-token 'symbol)
            (let ((sym (intern math-expr-data)))
              (math-read-token)
              (if (equal math-expr-data calc-function-open)
@@ -999,11 +1018,11 @@
                    (if (consp (cdr f))
                        (funcall (car (cdr f)) f sym)
                      (let ((args (if (or (equal math-expr-data calc-function-close)
-                                         (eq exp-token 'end))
+                                         (eq math-exp-token 'end))
                                      nil
                                    (math-read-expr-list))))
                        (if (not (or (equal math-expr-data calc-function-close)
-                                    (eq exp-token 'end)))
+                                    (eq math-exp-token 'end)))
                            (throw 'syntax "Expected `)'"))
                        (math-read-token)
                        (if (and (eq calc-language 'fortran) args
@@ -1053,7 +1072,7 @@
                          (math-read-token)
                        (throw 'syntax "Expected ']'")))
                    val)))))
-          ((eq exp-token 'dollar)
+          ((eq math-exp-token 'dollar)
            (let ((abs (if (> math-expr-data 0) math-expr-data (- math-expr-data))))
              (if (>= (length calc-dollar-values) abs)
                  (let ((num math-expr-data))
@@ -1063,7 +1082,7 @@
                (throw 'syntax (if calc-dollar-values
                                   "Too many $'s"
                                 "$'s not allowed in this context")))))
-          ((eq exp-token 'hash)
+          ((eq math-exp-token 'hash)
            (or calc-hashes-used
                (throw 'syntax "#'s not allowed in this context"))
            (calc-extensions)
@@ -1074,13 +1093,13 @@
                  (nth (1- num) calc-arg-values))
              (throw 'syntax "Too many # arguments")))
           ((equal math-expr-data "(")
-           (let* ((exp (let ((exp-keep-spaces nil))
+           (let* ((exp (let ((math-exp-keep-spaces nil))
                          (math-read-token)
                          (if (or (equal math-expr-data "\\dots")
                                  (equal math-expr-data "\\ldots"))
                              '(neg (var inf var-inf))
                            (math-read-expr-level 0)))))
-             (let ((exp-keep-spaces nil))
+             (let ((math-exp-keep-spaces nil))
                (cond
                 ((equal math-expr-data ",")
                  (progn
@@ -1109,7 +1128,7 @@
                    (math-read-token)
                    (let ((exp2 (if (or (equal math-expr-data ")")
                                        (equal math-expr-data "]")
-                                       (eq exp-token 'end))
+                                       (eq math-exp-token 'end))
                                    '(var inf var-inf)
                                  (math-read-expr-level 0))))
                      (setq exp
@@ -1119,11 +1138,11 @@
                                  exp2)))))))
              (if (not (or (equal math-expr-data ")")
                           (and (equal math-expr-data "]") (eq (car-safe exp) 'intv))
-                          (eq exp-token 'end)))
+                          (eq math-exp-token 'end)))
                  (throw 'syntax "Expected `)'"))
              (math-read-token)
              exp))
-          ((eq exp-token 'string)
+          ((eq math-exp-token 'string)
            (calc-extensions)
            (math-read-string))
           ((equal math-expr-data "[")