/RECOVER
  /NORECOVER (default)

  Determines whether DECTPU 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 DECTPU 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.  |
  +-------------------------------------------------------------------+