How to suspend VIM history?

Question

When we edit a file, we usually do many UNDO in a row, say, 20 times. In VIM, that is usually performed by pressing u 20 times, and that makes VIM go "up" in the history stack 20 positions. If you then make a certain change, all those last 20 history commands are lost, and replaced by change. I would like to make the change without loosing those 20 positions. So I guess I would like to tell VIM to stop recording history before I do change, and resume history afterwards (don't want change in history).

EDIT Trying to be more clear: I have a function FF that updates the last lines of a file when the buffer is written. So, if I perform 20 undos + write, the last write opens a new undo branch. I tried adding undojoin inside FF (trying to follow a suggestion by jlmg below), but a sequence write-undo-write gives an error: undojoint not allowed after undo. I could instead do some sed .... after leaving vim instead, but since I use this through SSH I prefer a vim-only solution (execute a command after unloading the buffer does not write to the file).

EDIT 2 Try to do this in VIM: open a blank file, and do:

i1<ESC>:wa2<ESC>:wa3<ESC>:wa4<ESC>uu:w

If now you do a <CTRL>R, VIM will write the '3' back, a further <CTRL>R you get the 4. This happens EVEN if you do a:w after each <CTRL>R. However, if each time you do a :w you execute a fuction via BufWritePre, the <CTRL>R will not write the 3 back. And this is what I want to do, that's why I wrote to 'suspend hisotry', but maybe what I am asking is not possible, besides working with the full undotree().

Answer 1

You don't need to suspend Vim history. The actual data forms a tree, and you can retrieve it with the undotree() function. There are, of course, a number of plugins that turn that into something more user-friendly, f.i. gundo, mundo, and undotree. If you also enable undo persistence (cf. :h undo-persistence) you can easily navigate through the entire change history of a file.

Answer 2

If I understand you correctly what you want is that afterwards doing an undo should undo that change and the 20 undos.

When vim executes a function or command, all actions that it does are undone together. I'm not sure if those actions may include undos. Maybe this part of the documentation can help:

3. Undo blocks                      *undo-blocks*

One undo command normally undoes a typed command, no matter how many changes
that command makes.  This sequence of undo-able changes forms an undo block.
Thus if the typed key(s) call a function, all the commands in the function are
undone together.

If you want to write a function or script that doesn't create a new undoable
change but joins in with the previous change use this command:

                        *:undoj* *:undojoin* *E790*
:undoj[oin]     Join further changes with the previous undo block.
            Warning: Use with care, it may prevent the user from
            properly undoing changes.  Don't use this after undo
            or redo.
            {not in Vi}

This is most useful when you need to prompt the user halfway through a change.
For example in a function that calls |getchar()|.  Do make sure that there was
a related change before this that you must join with.

This doesn't work by itself, because the next key press will start a new
change again.  But you can do something like this: >

    :undojoin | delete

After this an "u" command will undo the delete command and the previous
change.

To do the opposite, break a change into two undo blocks, in Insert mode use
CTRL-G u.  This is useful if you want an insert command to be undoable in
parts.  E.g., for each sentence.  |i_CTRL-G_u|
Setting the value of 'undolevels' also breaks undo.  Even when the new value
is equal to the old value.

Alas, I tried using :undo 2 | undojoin | normal ohi, but I got the error message E790: undojoin is not allowed after undo.

However, if the actions are done in a function like this:

function F()
  undo 2
  normal ohi
endfunction

then calling it with :call F() does perform the undo and other action in one undo block. Note that because you're using undo you're creating a new undo branch. After it's done you can use the normal mode command g-, to undo F(); using u will be like having done :undo 3 at the beginning.