not Vi compatible.  For example "dwdwu." in Vi deletes two
	    words, in Nvi it does nothing.

==============================================================================
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.

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 a "u" command will undo the delete command and the previous
change.
					*undo-break* *undo-close-block*
To do the opposite, use a new undo block for the next change, 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 closes the undo block.  Even when the
new value is equal to the old value.  Use `g:undolevels` to explicitly read
and write only the global value of 'undolevels'. >
	let &g:undolevels = &g:undolevels

Note that the similar-looking assignment `let &undolevels=&undolevels` does not
preserve the global option value of 'undolevels' in the event that the local
option has been set to a different value.  For example: >
	" Start with different global and local values for 'undolevels'.
	let &g:undolevels = 1000
	let &l:undolevels = 2000
	" This assignment changes the global option to 2000:
	let &undolevels = &undolevels

==============================================================================
4. Undo branches				*undo-branches* *undo-tree*

Above we only discussed one line of undo/redo.  But it is also possible to
branch off.  This happens when you undo a few changes and then make a new
change.  The undone changes become a branch.  You can go to that branch with
the following commands.

This is explained in the user manual: |usr_32.txt|.

							*:undol* *:undolist*
:undol[ist]		List the leafs in the tree of changes.  Example:
			   number changes  when               saved ~
			       88      88  2010/01/04 14:25:53
			      108     107  08/07 12:47:51
			      136      46  13:33:01             7
			      166     164  3 seconds ago

			The "number" column is the change number.  This number
			continuously increases and can be used to identify a
			specific undo-able change, see |:undo|.
			The "changes" column is the number of changes to this
			leaf from the root of the tree.
			The "when" column is the date and time when this
			change was made.  The four possible formats are:
			    N seconds ago
			    HH:MM:SS             hour, minute, seconds
			    MM/DD HH:MM:SS       idem, with month and day
			    YYYY/MM/DD HH:MM:SS  idem, with year
			The "saved" column specifies, if this change was
			written to disk and which file write it was. This can
			be used with the |:later| and |:earlier| commands.
			For more details use the |undotree()| function.

							*g-*
g-			Go to older text state.  With a count repeat that many
			times.
							*:ea* *:earlier*
:ea[rlier] {count}	Go to older text state {count} times.
:ea[rlier] {N}s		Go to older text state about {N} seconds before.
:ea[rlier] {N}m		Go to older text state about {N} minutes before.
:ea[rlier] {N}h		Go to older text state about {N} hours before.
:ea[rlier]