;;; repeat.el --- convenient way to repeat the previous command
-;; Copyright (C) 1998 Free Software Foundation, Inc.
+;; Copyright (C) 1998, 2001, 2002, 2003, 2004, 2005,
+;; 2006, 2007 Free Software Foundation, Inc.
;; Author: Will Mengarini <seldon@eskimo.com>
;; Created: Mo 02 Mar 98
;; This file is part of GNU Emacs.
-;; This program is free software; you can redistribute it and/or modify
+;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 2, or (at your option)
+;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.
-;; This program is distributed in the hope that it will be useful,
+;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING. If not, write to the
-;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
;;; Commentary:
;;; Code:
-(eval-when-compile (require 'cl))
-
;;;;; ************************* USER OPTIONS ************************** ;;;;;
(defcustom repeat-too-dangerous '(kill-this-buffer)
member of that sequence. If this variable is nil, no re-execution occurs."
:group 'convenience
:type 'boolean)
-
+
;;;;; ****************** HACKS TO THE REST OF EMACS ******************* ;;;;;
;; The basic strategy is to use last-command, a variable built in to Emacs.
;; true-last-command by putting something in post-command-hook, but that
;; entails a performance hit; the approach taken below avoids that.
-;; First cope with (kill-region). It's straightforward to advise it to save
-;; the true value of this-command before clobbering it.
-
-(require 'advice)
-
-(defvar repeat-last-kill-command nil
- "True value of `this-command' before (`kill-region') clobbered it.")
-
;; Coping with strings of self-insert commands gets hairy when they interact
;; with auto-filling. Most problems are eliminated by remembering what we're
;; self-inserting, so we only need to get it from the undo information once.
+;; With Emacs 22.2 the variable `last-repeatable-command' stores the
+;; most recently executed command that was not bound to an input event.
+;; `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.")
;;;;; ******************* THE REPEAT COMMAND ITSELF ******************* ;;;;;
+(defvar repeat-previous-repeated-command nil
+ "The previous repeated command.")
+
;;;###autoload
(defun repeat (repeat-arg)
"Repeat most recently executed command.
-With prefix arg, apply new prefix arg to that command; otherwise, maintain
-prefix arg of most recently executed command if it had one.
-This command is named after the `.' command in the vi editor.
-
-If this command is invoked by a multi-character key sequence, it can then
-be repeated by repeating the final character of that sequence. This behavior
-can be modified by the global variable `repeat-on-final-keystroke'."
+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 this command is invoked by a multi-character key sequence, it
+can then be repeated by repeating the final character of that
+sequence. This behavior can be modified by the global variable
+`repeat-on-final-keystroke'.
+
+`repeat' ignores commands bound to input events. Hence the term
+\"most recently executed command\" shall be read as \"most
+recently executed command not bound to an input event\"."
;; The most recently executed command could be anything, so surprises could
;; result if it were re-executed in a context where new dynamically
;; localized variables were shadowing global variables in a `let' clause in
;; "repeat-" prefix, reserved by this package, for *local* variables that
;; might be visible to re-executed commands, including this function's arg.
(interactive "P")
- (setq this-command real-last-command
- repeat-num-input-keys-at-repeat num-input-keys)
- (when (eq real-last-command 'mode-exit)
- (error "real-last-command is mode-exit & can't be repeated"))
- (when (memq real-last-command repeat-too-dangerous)
- (error "Command %S too dangerous to repeat automatically" real-last-command))
+ (when (eq last-repeatable-command 'repeat)
+ (setq last-repeatable-command repeat-previous-repeated-command))
+ (cond
+ ((null last-repeatable-command)
+ (error "There is nothing to repeat"))
+ ((eq last-repeatable-command 'mode-exit)
+ (error "last-repeatable-command is mode-exit & can't be repeated"))
+ ((memq last-repeatable-command repeat-too-dangerous)
+ (error "Command %S too dangerous to repeat automatically"
+ last-repeatable-command)))
+ (setq this-command last-repeatable-command
+ repeat-previous-repeated-command last-repeatable-command
+ repeat-num-input-keys-at-repeat num-input-keys)
(when (null repeat-arg)
(setq repeat-arg last-prefix-arg))
;; Now determine whether to loop on repeated taps of the final character
;; needs to be saved.
(let ((repeat-repeat-char
(if (eq repeat-on-final-keystroke t)
- ;; allow any final input event that was a character
- (when (eq last-command-char
- last-command-event)
- last-command-char)
+ ;; The following commented out since it's equivalent to
+ ;; last-comment-char (martin 2007-08-29).
+;;; ;; allow any final input event that was a character
+;;; (when (eq last-command-char
+;;; last-command-event)
+;;; last-command-char)
+ last-command-char
;; allow only specified final keystrokes
(car (memq last-command-char
(listify-key-sequence
repeat-on-final-keystroke))))))
- (if (memq real-last-command '(exit-minibuffer
- minibuffer-complete-and-exit
- self-insert-and-exit))
+ (if (memq last-repeatable-command '(exit-minibuffer
+ minibuffer-complete-and-exit
+ self-insert-and-exit))
(let ((repeat-command (car command-history)))
(repeat-message "Repeating %S" repeat-command)
(eval repeat-command))
(if (null repeat-arg)
- (repeat-message "Repeating command %S" real-last-command)
- (setq repeat-num-input-keys-at-prefix num-input-keys
- current-prefix-arg repeat-arg)
- (repeat-message "Repeating command %S %S" repeat-arg real-last-command))
- (if (eq real-last-command 'self-insert-command)
+ (repeat-message "Repeating command %S" last-repeatable-command)
+ (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)
(setq repeat-last-self-insert
(buffer-substring (car range)
(cdr range)))
- (error (error "%s %s %s" ;Danger, Will Robinson!
+ (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)
- (loop repeat (prefix-numeric-value repeat-arg) do
- (repeat-self-insert insertion)))
- (call-interactively real-last-command)))
+ ;; 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)
+ (while (< i count)
+ (repeat-self-insert insertion)
+ (setq i (1+ i)))
+ (run-hooks 'post-command-hook)))
+ (let ((indirect (indirect-function last-repeatable-command)))
+ (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 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'
;; 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)
+ (setq real-last-command 'repeat)
(while (eq (read-event) repeat-repeat-char)
+ ;; Make each repetition undo separately.
+ (undo-boundary)
(repeat repeat-arg))
(setq unread-command-events (list last-input-event))))))
(provide 'repeat)
+;;; arch-tag: cd569600-a1ad-4fa7-9062-bb91dfeaf1db
;;; repeat.el ends here
HCoop / bpt / emacs.git / blobdiff