Remove XEmacs compat code from calc

* lisp/calc/calc.el (calc-read-key-sequence)
(calcDigit-start, calc-read-key, calc-unread-command)
(calc-clear-unread-commands):
* lisp/calc/calc-misc.el (calc-dispatch-help):
* lisp/calc/calc-help.el (calc-help-for-help)
(calc-describe-key):
* lisp/calc/calc-ext.el (calc-fancy-prefix, calc-user-key-map):
Remove XEmacs compat code.

diff --git a/lisp/calc/calc-ext.el b/lisp/calc/calc-ext.el
index 1456fb28570677f2bd8148c0967512ecd1f3725e..4cc6b224226005c55c1efd58807882bae6e00fc2 100644 (file)
--- a/lisp/calc/calc-ext.el
+++ b/lisp/calc/calc-ext.el
@@ -1487,14 +1487,14 @@ calc-kill calc-kill-region calc-yank))))
         (not calc-is-keypad-press)
         (if (boundp 'overriding-terminal-local-map)
             (setq overriding-terminal-local-map calc-fancy-prefix-map)
-          (let ((event (calc-read-key t)))
-            (if (eq (setq last-command-event (car event)) ?\C-u)
+          (let ((event (read-event)))
+            (if (eq (setq last-command-event event) ?\C-u)
                 (universal-argument)
               (if (or (not (integerp last-command-event))
                       (and (>= last-command-event 0) (< last-command-event ? )
                            (not (memq last-command-event '(?\e)))))
                   (calc-wrapper))  ; clear flags if not a Calc command.
-               (setq last-command-event (cdr event))
+               (setq last-command-event event)
               (if (or (not (integerp last-command-event))
                       (eq last-command-event ?-))
                   (calc-unread-command)
@@ -1915,8 +1915,6 @@ calc-kill calc-kill-region calc-yank))))
 ;;; User menu.
 
 (defun calc-user-key-map ()
-  (if (featurep 'xemacs)
-      (error "User-defined keys are not supported in XEmacs"))
   (let ((res (cdr (lookup-key calc-mode-map "z"))))
     (if (eq (car (car res)) 27)
        (cdr res)

diff --git a/lisp/calc/calc-help.el b/lisp/calc/calc-help.el
index d9e8fe779bf19b637e0252b0560ed16cadaf9487..3b8bfda4a02b75412967f2b0c4f5a3d1b4c65524 100644 (file)
--- a/lisp/calc/calc-help.el
+++ b/lisp/calc/calc-help.el
@@ -77,14 +77,14 @@ C-w  Describe how there is no warranty for Calc."
          (select-window (get-buffer-window "*Help*"))
          (while (progn
                   (message "Calc Help options: Help, Info, ...  press SPC, DEL to scroll, C-g to cancel")
-                  (memq (car (setq key (calc-read-key t)))
+                  (memq (setq key (read-event))
                         '(?  ?\C-h ?\C-? ?\C-v ?\M-v)))
            (condition-case err
-               (if (memq (car key) '(?  ?\C-v))
+               (if (memq key '(? ?\C-v))
                    (scroll-up)
                  (scroll-down))
              (error (beep)))))
-       (calc-unread-command (cdr key))
+       (calc-unread-command key)
        (calc-help-prefix nil))
     (let ((calc-dispatch-help t))
       (calc-help-prefix arg))))
@@ -255,8 +255,8 @@ C-w  Describe how there is no warranty for Calc."
                           msg
                           (if (equal notes "") ""
                             (format "  (?=notes %s)" notes)))
-                 (let ((key (calc-read-key t)))
-                   (if (eq (car key) ??)
+                 (let ((key (read-event)))
+                   (if (eq key ??)
                        (if (equal notes "")
                            (message "No notes for this command")
                          (while (string-match "," notes)
@@ -280,7 +280,7 @@ C-w  Describe how there is no warranty for Calc."
                                (princ (buffer-substring pt (point))))
                              (setq notes (cdr notes)))
                            (help-print-return-message)))
-                     (calc-unread-command (cdr key)))))
+                     (calc-unread-command key))))
              (if (or (null defn) (integerp defn))
                  (message "%s is undefined" desc)
                (message "%s runs the command %s"

diff --git a/lisp/calc/calc-misc.el b/lisp/calc/calc-misc.el
index aedb68726a5c2c7aa782131893f4518347cb055e..5fd8d07da5756c5549e341a74205577c67cd7cfa 100644 (file)
--- a/lisp/calc/calc-misc.el
+++ b/lisp/calc/calc-misc.el
@@ -116,14 +116,14 @@ Calc user interface as before (either C-x * C or C-x * K; initially C-x * C).
                  (while (progn
                           (message "Calc options: Calc, Keypad, ...  %s"
                                    "press SPC, DEL to scroll, C-g to cancel")
-                          (memq (car (setq key (calc-read-key t)))
+                          (memq (setq key (read-event))
                                 '(?  ?\C-h ?\C-? ?\C-v ?\M-v)))
                    (condition-case err
-                       (if (memq (car key) '(?  ?\C-v))
+                       (if (memq key '(?  ?\C-v))
                            (scroll-up)
                          (scroll-down))
                      (error (beep))))
-                     (calc-unread-command (cdr key))))))
+                     (calc-unread-command key)))))
        (calc-do-dispatch nil))
     (let ((calc-dispatch-help t))
       (calc-do-dispatch arg))))

diff --git a/lisp/calc/calc.el b/lisp/calc/calc.el
index 1496a741abde600d01954510cccd23fb209e6e24..2136a099eeda205e05f353973bb8157760f7197e 100644 (file)
--- a/lisp/calc/calc.el
+++ b/lisp/calc/calc.el
@@ -1113,15 +1113,7 @@ Used by `calc-user-invocation'.")
        (ignore-errors
           (define-key calc-digit-map x 'calcDigit-backspace)
           (define-key calc-mode-map x 'calc-pop)
-          (define-key calc-mode-map
-            (if (and (vectorp x) (featurep 'xemacs))
-                (if (= (length x) 1)
-                    (vector (if (consp (aref x 0))
-                                (cons 'meta (aref x 0))
-                              (list 'meta (aref x 0))))
-                  "\e\C-d")
-              (vconcat "\e" x))
-            'calc-pop-above)))
+          (define-key calc-mode-map (vconcat "\e" x) 'calc-pop-above)))
       (if calc-scan-for-dels
          (append (where-is-internal 'delete-backward-char global-map)
                  (where-is-internal 'backward-delete-char global-map)
@@ -1230,9 +1222,9 @@ Used by `calc-user-invocation'.")
   (let ((glob (current-global-map))
        (loc (current-local-map)))
     (or (input-pending-p) (message "%s" prompt))
-    (let ((key (calc-read-key t))
+    (let ((key (read-event))
          (input-method-function nil))
-      (calc-unread-command (cdr key))
+      (calc-unread-command key)
       (unwind-protect
          (progn
            (use-global-map map)
@@ -2333,21 +2325,14 @@ the United States."
            (calc-prev-char nil)
            (calc-prev-prev-char nil)
            (calc-buffer (current-buffer))
-           (buf (if (featurep 'xemacs)
-                    (catch 'calc-foo
-                      (catch 'execute-kbd-macro
-                        (throw 'calc-foo
-                               (read-from-minibuffer
-                                "Calc: " "" calc-digit-map)))
-                      (error "XEmacs requires RET after %s"
-                             "digit entry in kbd macro"))
-                  (let ((old-esc (lookup-key global-map "\e")))
-                    (unwind-protect
-                        (progn
-                          (define-key global-map "\e" nil)
-                          (read-from-minibuffer
-                            "Calc: " (calc-digit-start-entry) calc-digit-map))
-                      (define-key global-map "\e" old-esc))))))
+           (buf
+            (let ((old-esc (lookup-key global-map "\e")))
+              (unwind-protect
+                  (progn
+                    (define-key global-map "\e" nil)
+                    (read-from-minibuffer
+                      "Calc: " (calc-digit-start-entry) calc-digit-map))
+                (define-key global-map "\e" old-esc)))))
        (or calc-digit-value (setq calc-digit-value (math-read-number buf)))
        (if (stringp calc-digit-value)
           (calc-alg-entry calc-digit-value)
@@ -3883,29 +3868,16 @@ See Info node `(calc)Defining Functions'."
   (require 'calc-ext)
   (math-do-defmath func args body))
 
-;;; Functions needed for Lucid Emacs support.
-
-(defun calc-read-key (&optional optkey)
-  (cond ((featurep 'xemacs)
-        (let ((event (next-command-event)))
-          (let ((key (event-to-character event t t)))
-            (or key optkey (error "Expected a plain keystroke"))
-            (cons key event))))
-       (t
-        (let ((key (read-event)))
-          (cons key key)))))
+(defun calc-read-key (&optional _optkey)
+  (declare (obsolete read-event "27.1"))
+  (let ((key (read-event)))
+    (cons key key)))
 
 (defun calc-unread-command (&optional input)
-  (if (featurep 'xemacs)
-      (setq unread-command-event
-           (if (integerp input) (character-to-event input)
-             (or input last-command-event)))
-    (push (or input last-command-event) unread-command-events)))
+  (push (or input last-command-event) unread-command-events))
 
 (defun calc-clear-unread-commands ()
-  (if (featurep 'xemacs)
-      (setq unread-command-event nil)
-    (setq unread-command-events nil)))
+  (setq unread-command-events nil))
 
 (defcalcmodevar math-2-word-size
   (math-read-number-simple "4294967296")