/RECOVER

 /RECOVER
 /NORECOVER (default)

 Determines whether TPU recovers your edits by reading the journal
 file from the interrupted editing session.  (See help on /JOURNAL.)

 There are two ways to recover your edits, depending on the type of
 journaling you used:

 o  If you used buffer-change journaling, which is the EVE default,
    you can recover one or more buffers at a time and you can recover
    buffers from different editing sessions.  For example, the
    following command invokes EVE to recover the text of a file named
    JABBER.TXT:

       $ EDIT/TPU jabber.txt /RECOVER

    This is the same as invoking EVE and using the following command:

       Command:  RECOVER BUFFER jabber.txt

    If there is more than one buffer-change journal file with the same
    name---for example, you may have two or more MAIN.TPU$JOURNAL
    files from different editing sessions---the recovery uses the
    highest version number available.  To recover several text
    buffers, one after another, use the RECOVER BUFFER ALL command.

    Recovery with a buffer-change journal file restores only your text
    ---it does not restore settings, key definitions, and other
    customizations and it does not restore the contents of the Insert
    Here buffer or other system buffers.  The recovery is usually
    quite fast.  New text or other changes are then journaled.

    The recovery does not re-create deleted files.  If you deleted or
    renamed the source file associated with a buffer-change journal,
    the recovery fails.  The source file is either the file initially
    read into the buffer (if any), or the last version of the file
    written from the buffer before the system failure.

    If you specify multiple input files on the EDIT/TPU command line,
    EVE tries to recover each file.

 o  If you used keystroke journaling, you recover your editing session
    by reissuing the same command for the original, aborted editing
    session---including all qualifiers---and adding /RECOVER.  EVE
    then recovers your editing session in a "player piano" fashion.
    For example, the following commands invoke TPU creating a
    keystroke journal file, and then, after a system failure, recover
    the editing session:

       $ EDIT/TPU /JOURNAL=myjournal.tjl
                  .
                  .
       ***  system failure  ***
                  .
                  .
       $ EDIT/TPU /JOURNAL=myjournal.tjl /RECOVER

    Typically, after the recovery, you exit to save your edits.

 Keystroke journaling does not work on DECwindows and has other
 restrictions, as follows.  These restrictions do NOT apply to buffer-
 change journaling.

 o  To recover your edits with a keystroke journal file, all relevant
    files must be in the same state as at the start of the session
    being recovered---including any files you wrote out (saved) before
    the system failure.  Therefore, before doing the recovery, you
    should rename the saved versions or move them to a different
    directory, to ensure that the recovery uses the original versions
    of the files.  You must specify multiple input files in the same
    order as in the original command line.

 o  Check that any logical names for your section file, command file,
    and initialization file are defined as for the original editing
    session, and that the recovery will use the correct version of
    these files.

 o  Check that the following terminal settings are the same as when
    you began the original editing session, because they may affect
    how your keystrokes are replayed:

       Device_Type
       Edit_mode
       Eightbit
       Page
       Width

 o  Recovery with a keystroke journal file may fail or may not work
    properly if you used CTRL/C during the original editing session.
    CTRL/C is not recorded in the keystroke journal file.  Therefore,
    during recovery, an operation that was canceled with CTRL/C is
    replayed without interruption; this is likely to affect how the
    remaining keystrokes are replayed.

 o  If you used EVE in a subprocess (as a "kept" editor), the
    keystroke journal file records ATTACH, DCL, and SPAWN commands in
    EVE, but does not record operations done in the other process or
    subprocess.  If these other operations affected any files used in
    the original editing session---for example, if you spawned a
    subprocess from EVE and then purged, renamed, deleted, or modified
    any relevant files---the recovery may fail or may not work
    properly.

 o  If you used the EVE command DCL, the recovery with a keystroke
    journal file may fail or may not work properly, particularly if
    you cut a file name from a directory list in the DCL buffer, and
    pasted it into an EVE command line.  The keystroke recovery
    replays the operations, but the directory list or the file name
    may not be the same as in the original session.

 For more information about journaling and recovery, see the
 Extensible Versatile Editor Reference Manual or use the online help
 in EVE and read the topic called Journal Files.

 +-----------------------------  NOTE  ------------------------------+
 | Although journaling and recovery are quite reliable, the last few |
 | edits before a system failure may be lost.  The safest way to     |
 | protect your work against a system failure is to write out your   |
 | edits frequently---particularly during all-day editing sessions.  |
 +-------------------------------------------------------------------+