(universal-argument-map): New var.

(universal-argument, negative-argument, digit-argument):
Use overriding-terminal-local-map.
(prefix-arg-internal, describe-arg): Functions deleted.
(universal-argument-more, universal-argument-minus): New functions.
(universal-argument-other-key): New function.

diff --git a/lisp/simple.el b/lisp/simple.el
index e29c1d4e29b01ed8a588b1b37949ec4ae5644f95..52d9290fd6789bb12bc9230a9635b54c1193458b 100644 (file)
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -935,6 +935,25 @@ In either case, the output is inserted after point (leaving mark after it)."
                (t 
                 (set-window-start (display-buffer buffer) 1))))))))
 \f
+(defconst universal-argument-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map [t] 'universal-argument-other-key)
+    (define-key map [switch-frame] nil)
+    (define-key map [?\C-u] 'universal-argument-more)
+    (define-key map [?-] 'universal-argument-minus)
+    (define-key map [?0] 'digit-argument)
+    (define-key map [?1] 'digit-argument)
+    (define-key map [?2] 'digit-argument)
+    (define-key map [?3] 'digit-argument)
+    (define-key map [?4] 'digit-argument)
+    (define-key map [?5] 'digit-argument)
+    (define-key map [?6] 'digit-argument)
+    (define-key map [?7] 'digit-argument)
+    (define-key map [?8] 'digit-argument)
+    (define-key map [?9] 'digit-argument)
+    map)
+  "Keymap used while processing \\[universal-argument].")
+
 (defun universal-argument ()
   "Begin a numeric argument for the following command.
 Digits or minus sign following \\[universal-argument] make up the numeric argument.
@@ -942,69 +961,59 @@ Digits or minus sign following \\[universal-argument] make up the numeric argume
 \\[universal-argument] without digits or minus sign provides 4 as argument.
 Repeating \\[universal-argument] without digits or minus sign
  multiplies the argument by 4 each time."
-  (interactive nil)
-  (let ((factor 4)
-       key)
-;;    (describe-arg (list factor) 1)
-    (setq key (read-key-sequence nil t))
-    (while (equal (key-binding key) 'universal-argument)
-      (setq factor (* 4 factor))
-;;      (describe-arg (list factor) 1)
-      (setq key (read-key-sequence nil t)))
-    (prefix-arg-internal key factor nil)))
-
-(defun prefix-arg-internal (key factor value)
-  (let ((sign 1))
-    (if (and (numberp value) (< value 0))
-       (setq sign -1 value (- value)))
-    (if (eq value '-)
-       (setq sign -1 value nil))
-;;    (describe-arg value sign)
-    (while (equal key "-")
-      (setq sign (- sign) factor nil)
-;;      (describe-arg value sign)
-      (setq key (read-key-sequence nil t)))
-    (while (and (stringp key)
-               (= (length key) 1)
-               (not (string< key "0"))
-               (not (string< "9" key)))
-      (setq value (+ (* (if (numberp value) value 0) 10)
-                    (- (aref key 0) ?0))
-           factor nil)
-;;      (describe-arg value sign)
-      (setq key (read-key-sequence nil t)))
-    (setq prefix-arg
-         (cond (factor (list factor))
-               ((numberp value) (* value sign))
-               ((= sign -1) '-)))
-    ;; Calling universal-argument after digits
-    ;; terminates the argument but is ignored.
-    (if (eq (key-binding key) 'universal-argument)
-       (progn
-         (describe-arg value sign)
-         (setq key (read-key-sequence nil t))))
-    (setq unread-command-events (listify-key-sequence key))))
-
-(defun describe-arg (value sign)
-  (cond ((numberp value)
-        (message "Arg: %d" (* value sign)))
-       ((consp value)
-        (message "Arg: [%d]" (car value)))
-       ((< sign 0)
-        (message "Arg: -"))))
+  (interactive)
+  (setq prefix-arg (list 4))
+  (setq overriding-terminal-local-map universal-argument-map))
 
-(defun digit-argument (arg)
-  "Part of the numeric argument for the next command.
-\\[universal-argument] following digits or minus sign ends the argument."
+;; A subsequent C-u means to multiply the factor by 4 if we've typed
+;; nothing but C-u's; otherwise it means to terminate the prefix arg.
+(defun universal-argument-more (arg)
   (interactive "P")
-  (prefix-arg-internal (char-to-string (logand last-command-char ?\177))
-                      nil arg))
+  (if (consp arg)
+      (setq prefix-arg (list (* 4 (car arg))))
+    (setq prefix-arg arg)
+    (setq overriding-terminal-local-map nil)))
 
 (defun negative-argument (arg)
   "Begin a negative numeric argument for the next command.
 \\[universal-argument] following digits or minus sign ends the argument."
   (interactive "P")
-  (prefix-arg-internal "-" nil arg))
+  (cond ((integerp arg)
+        (setq prefix-arg (- arg)))
+       ((eq arg '-)
+        (setq prefix-arg nil))
+       (t
+        (setq prefix-arg '-))))
+
+(defun digit-argument (arg)
+  "Part of the numeric argument for the next command.
+\\[universal-argument] following digits or minus sign ends the argument."
+  (interactive "P")
+  (let ((digit (- (logand last-command-char ?\177) ?0)))
+    (cond ((integerp arg)
+          (setq prefix-arg (+ (* arg 10)
+                              (if (< arg 0) (- digit) digit))))
+         ((eq arg '-)
+          ;; Treat -0 as just -, so that -01 will work.
+          (setq prefix-arg (if (zerop digit) '- (- digit))))
+         (t
+          (setq prefix-arg digit)))))
+
+;; For backward compatibility, minus with no modifiers is an ordinary
+;; command if digits have already been entered.
+(defun universal-argument-minus (arg)
+  (interactive "P")
+  (if (integerp arg)
+      (universal-argument-other-key arg)
+    (negative-argument arg)))
+
+;; Anything else terminates the argument and is left in the queue to be
+;; executed as a command.
+(defun universal-argument-other-key (arg)
+  (interactive "P")
+  (setq prefix-arg arg)
+  (setq unread-command-events (list last-input-event))
+  (setq overriding-terminal-local-map nil))
 \f
 (defun forward-to-indentation (arg)
   "Move forward ARG lines and position at first nonblank character."