X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/09d9db2c4921cb2eb0974892164dd03d6bffdd80..3698c4e475fb59730626af5d001599785ef5ef9e:/lisp/repeat.el diff --git a/lisp/repeat.el b/lisp/repeat.el index b33039b609..d116ec6bda 100644 --- a/lisp/repeat.el +++ b/lisp/repeat.el @@ -1,6 +1,6 @@ -;;; repeat.el --- convenient way to repeat the previous command +;;; repeat.el --- convenient way to repeat the previous command -*- lexical-binding: t -*- -;; Copyright (C) 1998, 2001-2011 Free Software Foundation, Inc. +;; Copyright (C) 1998, 2001-2016 Free Software Foundation, Inc. ;; Author: Will Mengarini ;; Created: Mo 02 Mar 98 @@ -26,7 +26,7 @@ ;; Sometimes the fastest way to get something done is just to lean on a key; ;; moving forward through a series of words by leaning on M-f is an example. -;; But 'forward-page is orthodoxily bound to C-x ], so moving forward through +;; But 'forward-page is orthodoxly bound to C-x ], so moving forward through ;; several pages requires ;; Loop until desired page is reached: ;; Hold down control key with left pinkie. @@ -109,9 +109,11 @@ (defvar repeat-message-function nil "If non-nil, function used by `repeat' command to say what it's doing. Message is something like \"Repeating command glorp\". -To disable such messages, set this variable to `ignore'. To customize -display, assign a function that takes one string as an arg and displays -it however you want.") +A value of `ignore' will disable such messages. To customize +display, assign a function that takes one string as an arg and +displays it however you want. +If this variable is nil, the normal `message' function will be +used to display the messages.") (defcustom repeat-on-final-keystroke t "Allow `repeat' to re-execute for repeating lastchar of a key sequence. @@ -123,7 +125,9 @@ if `repeat' is bound to C-x z, typing C-x z z z repeats the previous command only occurs if the final character by which `repeat' was invoked is a member of that sequence. If this variable is nil, no re-execution occurs." :group 'convenience - :type 'boolean) + :type '(choice (const :tag "Repeat for all keys" t) + (const :tag "Don't repeat" nil) + (sexp :tag "Repeat for specific keys"))) ;;;;; ****************** HACKS TO THE REST OF EMACS ******************* ;;;;; @@ -154,15 +158,6 @@ member of that sequence. If this variable is nil, no re-execution occurs." ;; `repeat' now repeats that command instead of `real-last-command' to ;; avoid a "... must be bound to an event with parameters" error. -(defvar repeat-last-self-insert nil - "If last repeated command was `self-insert-command', it inserted this.") - -;; That'll require another keystroke count so we know we're in a string of -;; repetitions of self-insert commands: - -(defvar repeat-num-input-keys-at-self-insert -1 - "# key sequences read in Emacs session when `self-insert-command' repeated.") - ;;;;; *************** ANALOGOUS HACKS TO `repeat' ITSELF **************** ;;;;; ;; That mechanism of checking num-input-keys to figure out what's really @@ -197,20 +192,12 @@ this function is always whether the value of `this-command' would've been (defvar repeat-previous-repeated-command nil "The previous repeated command.") -;; The following variable counts repeated self-insertions. The idea is -;; that repeating a self-insertion command and subsequently undoing it -;; should have almost the same effect as if the characters were inserted -;; manually. The basic difference is that we leave in one undo-boundary -;; between the original insertion and its first repetition. -(defvar repeat-undo-count nil - "Number of self-insertions since last `undo-boundary'.") - ;;;###autoload (defun repeat (repeat-arg) "Repeat most recently executed command. -With prefix arg, apply new prefix arg to that command; otherwise, -use the prefix arg that was used before (if any). -This command is like the `.' command in the vi editor. +If REPEAT-ARG is non-nil (interactively, with a prefix argument), +supply a prefix argument to that command. Otherwise, give the +command the same prefix argument it was given before, if any. If this command is invoked by a multi-character key sequence, it can then be repeated by repeating the final character of that @@ -252,7 +239,7 @@ recently executed command not bound to an input event\"." (let ((repeat-repeat-char (if (eq repeat-on-final-keystroke t) last-command-event - ;; allow only specified final keystrokes + ;; Allow only specified final keystrokes. (car (memq last-command-event (listify-key-sequence repeat-on-final-keystroke)))))) @@ -267,90 +254,49 @@ recently executed command not bound to an input event\"." (setq current-prefix-arg repeat-arg) (repeat-message "Repeating command %S %S" repeat-arg last-repeatable-command)) - (if (eq last-repeatable-command 'self-insert-command) - (let ((insertion - (if (<= (- num-input-keys - repeat-num-input-keys-at-self-insert) - 1) - repeat-last-self-insert - (let ((range (nth 1 buffer-undo-list))) - (condition-case nil - (setq repeat-last-self-insert - (buffer-substring (car range) - (cdr range))) - (error (error "%s %s %s" ;Danger, Will Robinson! - "repeat can't intuit what you" - "inserted before auto-fill" - "clobbered it, sorry"))))))) - (setq repeat-num-input-keys-at-self-insert num-input-keys) - ;; If the self-insert had a repeat count, INSERTION - ;; includes that many copies of the same character. - ;; So use just the first character - ;; and repeat it the right number of times. - (setq insertion (substring insertion -1)) - (let ((count (prefix-numeric-value repeat-arg)) - (i 0)) - ;; Run pre- and post-command hooks for self-insertion too. - (run-hooks 'pre-command-hook) - (cond - ((not repeat-undo-count)) - ((< repeat-undo-count 20) - ;; Don't make an undo-boundary here. - (setq repeat-undo-count (1+ repeat-undo-count))) - (t - ;; Make an undo-boundary after 20 repetitions only. - (undo-boundary) - (setq repeat-undo-count 1))) - (while (< i count) - (repeat-self-insert insertion) - (setq i (1+ i))) - (run-hooks 'post-command-hook))) - (let ((indirect (indirect-function last-repeatable-command))) - ;; Make each repetition undo separately. - (undo-boundary) - (if (or (stringp indirect) - (vectorp indirect)) - ;; Bind real-last-command so that executing the macro does - ;; not alter it. Do the same for last-repeatable-command. - (let ((real-last-command real-last-command) - (last-repeatable-command last-repeatable-command)) - (execute-kbd-macro last-repeatable-command)) - (run-hooks 'pre-command-hook) - (call-interactively last-repeatable-command) - (run-hooks 'post-command-hook))))) + (when (eq last-repeatable-command 'self-insert-command) + ;; We used to use a much more complex code to try and figure out + ;; what key was used to run that self-insert-command: + ;; (if (<= (- num-input-keys + ;; repeat-num-input-keys-at-self-insert) + ;; 1) + ;; repeat-last-self-insert + ;; (let ((range (nth 1 buffer-undo-list))) + ;; (condition-case nil + ;; (setq repeat-last-self-insert + ;; (buffer-substring (car range) + ;; (cdr range))) + ;; (error (error "%s %s %s" ;Danger, Will Robinson! + ;; "repeat can't intuit what you" + ;; "inserted before auto-fill" + ;; "clobbered it, sorry"))))) + (setq last-command-event (char-before))) + (let ((indirect (indirect-function last-repeatable-command))) + (if (or (stringp indirect) + (vectorp indirect)) + ;; Bind last-repeatable-command so that executing the macro does + ;; not alter it. + (let ((last-repeatable-command last-repeatable-command)) + (execute-kbd-macro last-repeatable-command)) + (call-interactively last-repeatable-command)))) (when repeat-repeat-char - ;; A simple recursion here gets into trouble with max-lisp-eval-depth - ;; on long sequences of repetitions of a command like `forward-word' - ;; (only 32 repetitions are possible given the default value of 200 for - ;; max-lisp-eval-depth), but if I now locally disable the repeat char I - ;; can iterate indefinitely here around a single level of recursion. - (let (repeat-on-final-keystroke - ;; Bind `undo-inhibit-record-point' to t in order to avoid - ;; recording point in `buffer-undo-list' here. We have to - ;; do this since the command loop does not set the last - ;; position of point thus confusing the point recording - ;; mechanism when inserting or deleting text. - (undo-inhibit-record-point t)) - (setq real-last-command 'repeat) - (setq repeat-undo-count 1) - (unwind-protect - (while (let ((evt (read-key))) - ;; For clicks, we need to strip the meta-data to - ;; check the underlying event name. - (eq (or (car-safe evt) evt) - (or (car-safe repeat-repeat-char) - repeat-repeat-char))) - (repeat repeat-arg)) - ;; Make sure `repeat-undo-count' is reset. - (setq repeat-undo-count nil)) - (setq unread-command-events (list last-input-event)))))) - -(defun repeat-self-insert (string) - (let ((i 0)) - (while (< i (length string)) - (let ((last-command-event (aref string i))) - (self-insert-command 1)) - (setq i (1+ i))))) + (set-transient-map + (let ((map (make-sparse-keymap))) + (define-key map (vector repeat-repeat-char) + (if (null repeat-message-function) 'repeat + ;; If repeat-message-function is let-bound, preserve it for the + ;; next "iterations of the loop". + (let ((fun repeat-message-function)) + (lambda () + (interactive) + (let ((repeat-message-function fun)) + (setq this-command 'repeat) + ;; Beware: messing with `real-this-command' is *bad*, but we + ;; need it so `last-repeatable-command' can be recognized + ;; later (bug#12232). + (setq real-this-command 'repeat) + (call-interactively 'repeat)))))) + map))))) (defun repeat-message (format &rest args) "Like `message' but displays with `repeat-message-function' if non-nil." @@ -361,7 +307,7 @@ recently executed command not bound to an input event\"." ;; OK, there's one situation left where that doesn't work correctly: when the ;; most recent self-insertion provoked an auto-fill. The problem is that -;; unravelling the undo information after an auto-fill is too hard, since all +;; unraveling the undo information after an auto-fill is too hard, since all ;; kinds of stuff can get in there as a result of comment prefixes etc. It'd ;; be possible to advise do-auto-fill to record the most recent ;; self-insertion before it does its thing, but that's a performance hit on