Backup-restore the current repeat action (.) in VIM

Question

I'd like to save the current single-repeat action (this is what happens when you press .), then run a macro, and then restore the . action (because macros usually change it).

Is this possible?

Alternatively, is it possible to write a macro without changing the current . action? I guess I could try to do everything in Command Mode, but I'm not sure if that's possible.

Background: I'm writing a file browser function (like command-T in TextMate, see http://github.com/mdemare/fuzzy_file_finder), and I want to make as few changes as possible to the user's environment, so the changes have to occur in the function. Currently, when you switch files using this function, your . action is overwritten, which is very unwelcome.

Answer 1

You can record an action into a register to be used later. Press q followed by a register (a-z, A-Z, 0-9 or " are valid register identifiers), apply the desired command/actions and the press q to stop the recording. The command can be recalled by pressing @ followed by the register.

For more detailed instructions, see the complex repeat section of the Vim documentation.

NOTE: Unfortunately, the sequence qa.qu will not do exactly what you want since the . command will repeat the current last action and not the last action at the time the command was recorded.

Answer 2

The only way I can think of to help you out: Remap '.' to save a history of actions, which you could then recall if needed. For ideas on these lines, see the repeat.vim plugin.

Answer 3

In VIM you can create a macro that will execute any edits you would typically do in normal mode without disturbing the redo [.] functionality by wrapping those edits in a user defined :function and then executing that function with a :mapped key.

Example

The best way to see it is with an example. Suppose you want to add the text yyy to the end of the current line every time you hit the F2 key, but you don't want this to interfere with the redo command [.].

Here's how to do it:

1. Open a new vim window and execute the following commands:

   :fu JL()
       normal Ayyy
       endfu
   :map <F2> :call JL()<Enter>
   

2. Now add some text, let's say xxx, by typing Axxx<Esc>

3. Now press the [F2] key and you should see xxxyyy

4. Finally, press the [.] key and you should see xxxyyyxxx

Just what you wanted!

Why this works

This works because of the nature of the way VIM executes the redo command. VIM keeps track of the characters of a command as you type it. When you press the [.] key, it stuffs those characters back into the keyboard buffer to re-execute them. Unfortunately, a simple q macro works the same way -- it stuffs characters into the buffer and by doing so overwrites the redo buffer. The :normal command does this as well, but when placed inside a user defined function we get around this limitation because the code that executes the user defined function saves and restores the redo buffer during the user defined function.

This all happens in eval.c and getchar.c in the VIM source code. Search for saveRedobuff to see what's going on.