6.13 /INTERFACE
/INTERFACE[={CHARACTER_CELL (default) | DECWINDOWS |MOTIF}]
Same as /DISPLAY---determines the interface or screen display you
want. For example, the following command invokes TPU with the
DECwindows Motif interface:
$ EDIT/TPU /INTERFACE=DECWINDOWS
Then, if DECwindows Motif is available, TPU displays the editing
session in a separate window on your workstation screen and enables
DECwindows features---for example, the EVE screen layout includes a
menu bar and scroll bars, and you can use M1 to move the cursor and
select text. If DECwindows Motif is not available, TPU works as
if on a character-cell terminal. For information about using EVE on
DECwindows, use the online help in EVE and read the topic called
DECwindows Differences.
6.14 /JOURNAL
/JOURNAL[=journal-file] (default)
/NOJOURNAL
Determines the type of journaling, if any. Journaling records your
edits so that if a system failure interrupts your editing session,
you can recover your work. Processing this qualifier depends on the
TPU application you are using.
Normally, journal files are deleted when you exit or quit. If a
system failure occurs during your editing session, such as a break in
communications between your terminal and computer, the journal files
are saved. For information about recovering your work, see help on
/RECOVER.
+-------------------------- NOTE --------------------------+
| Journal files record information about the text you edit. |
| Therefore, if you are editing confidential data, make sure |
| the journal files, as well as the text files, are secure. |
+------------------------------------------------------------+
There are two types of journaling, as follows:
o Buffer-change journaling creates a journal file for each text
buffer. This is the EVE default. Buffer-change journaling works
on DECwindows or character-cell terminals. The journal file name
derives from the name of the file or buffer being edited and the
file type .TPU$JOURNAL---for example:
Text buffers Buffer-change journal files
-------------------------------------------------
MAIN MAIN.TPU$JOURNAL
JABBER.TXT JABBER_TXT.TPU$JOURNAL
GUMBO_RECIPE.RNO GUMBO_RECIPE_RNO.TPU$JOURNAL
NEW TEST DATA NEW_TEST_DATA.TPU$JOURNAL
* TEMP * __TEMP__.TPU$JOURNAL
Buffer-change journal files are created in the directory defined
by the TPU$JOURNAL logical name. Default is SYS$SCRATCH, which is
usually your top-level, login directory. Because buffer-change
journal files may be quite large---even larger than the files you
edit---you may want to define TPU$JOURNAL as a different disk and
directory.
Some editing operations may be slower because of buffer-change
journaling, depending on the type or extent of changes, such as
cutting a large box, or pasting a large amount of text from the
DECwindows clipboard.
o Keystroke journaling creates a single journal file for the editing
session, regardless of the number of buffers you create. The
journal file records every keystroke in the editing session,
whether text or commands. To enable keystroke journaling, use
/JOURNAL= and specify the journal file you want created. You
cannot use wildcards to specify the keystroke journal file.
Default file type is .TJL.
For example, the following command invokes TPU creating a
keystroke journal file named MYJOURNAL.TJL in your current,
default directory:
$ EDIT/TPU /JOURNAL=myjournal
Keystroke journaling does NOT work on DECwindows and has other
restrictions affecting recovery (see help on /RECOVER). Keystroke
journaling is useful to reproduce a problem (for example, if you
want to submit an SPR) or to journal an editing session in which
you create LEARN sequences and define keys interactively.
If you use keystroke journaling, EVE also creates a buffer-change
journal file for each text buffer. This double journaling may slow
performance, depending on the kind of edits you make. To disable
buffer-change journaling for a particular buffer or for all your
buffers, use SET NOJOURNALING commands during your editing session.
If you do not want any journaling, use /NOJOURNAL, which disables
both keystroke journaling and buffer-change journaling. This may
make startup and some editing operations faster but risks losing your
work if a system failure occurs during the editing session.
Typically you use /NOJOURNAL if you are also using /NOMODIFY,
/NOOUTPUT, /READ_ONLY, or /NOWRITE to view a file without making any
changes. If you invoke EVE with /NOJOURNAL, you can enable buffer-
change journaling during your editing session by using SET JOURNALING
commands.
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. |
+-------------------------------------------------------------------+
6.15 /MODIFY
/MODIFY (default)
/NOMODIFY
Determines whether you can modify the main (or first) buffer. If you
specify multiple input files on the EDIT/TPU command line, this
qualifier applies to each buffer. Does not affect other buffers you
create during the editing session.
By default, TPU lets the buffer be modified---you can edit text in
the buffer, and exiting writes out the buffer to a file, if the
buffer has been modified (unless you used /NOWRITE or /READ_ONLY).
Use /NOMODIFY to view a file without making any changes. You can
then use cursor-movement commands but cannot change the text. If you
do not specify /MODIFY or /NOMODIFY, the application is expected to
determine the default behavior. For EVE, the main buffer is made
modifiable (as well as buffers initially created from your input
files).
For EVE, using /READ_ONLY or /NOWRITE makes the buffer unmodifiable
unless you also use /MODIFY. For example, the following command
edits a file named PRACTICE.TXT, making the buffer read-only and
making it modifiable, so you can practice editing or test procedures
without writing a file:
$ EDIT/TPU practice.txt /READ_ONLY /MODIFY
In EVE, the status line shows whether the buffer is unmodifiable. If
the buffer is modifiable, the status line shows the mode (insert or
overstrike). You can change the modification attribute of the buffer
during your editing session by using the SET BUFFER command.
6.16 /OUTPUT
/OUTPUT[=output-file] (default)
/NOOUTPUT
Determines the output file, if any, for the main (or first) buffer.
If you specify multiple input files on the EDIT/TPU command line,
this qualifier applies to each buffer. Does not affect other buffers
you create during the editing session.
By default, the output file has the same specifications as the input
file with a version number one higher than the highest version of the
input file, or version 1 if you are creating a new file.
Use /OUTPUT= and specify a file if you want the output file written
in a different directory or to have a different name or file type.
For example, the following command edits a file named ROUGH.LIS in
your current directory and, on exiting, writes the output file to
FINAL.TXT in your top-level, login directory:
$ EDIT/TPU rough.lis /OUTPUT=sys$login:final.txt
You cannot use wildcards to specify the output file---you specify one
output file at a time. There is no default file type. If you omit
the file type or other parts of the output file specification, such
as the device (disk) or directory, EVE uses the corresponding parts
of the input file specification, if there is one.
In EVE, using /OUTPUT= and specifying an output file modifies the
buffer, so that even if you make no changes to the text, exiting
writes the buffer to the specified output file.
In EVE, using /NOOUTPUT sets the MAIN (or first) buffer to read-only
(sometimes called write-locked), so that exiting does not write out
that buffer to a file. This is useful to view a file without making
any changes. If you change your mind and want to write out the
buffer before exiting, use the WRITE FILE, SAVE FILE, or SAVE FILE AS
command. Also, you can change the read/write attribute of the buffer
during your editing session by using the SET BUFFER command.
Be careful using the /OUTPUT qualifier when you specify multiple
input files because the qualifier applies to all input files on the
EDIT/TPU command line. If you specify an output file name and type,
each buffer created from an input file would have the same output
file name and type.
You can use the /OUTPUT qualifier with multiple input files to write
the output files to a different disk or directory. For example, the
following command invokes EVE such that each output file has the same
name as the original input file but is written to the [.NEW]
directory:
$ EDIT/TPU /OUT=[.NEW] a.txt,b.txt,c.rno,d.tmp
6.17 /READ_ONLY
/READ_ONLY
/NOREAD_ONLY (default)
Determines whether exiting writes the main (or first) buffer to a
file. If you specify multiple input files on the EDIT/TPU command
line, this qualifier applies to each buffer. Does not affect other
buffers you create during the editing session.
/READ_ONLY is the same as /NOWRITE. For EVE, this makes the MAIN (or
first) buffer write-locked and also makes it unmodifiable, unless you
used /MODIFY. Use /READ_ONLY to view a file without making any
changes. For example, the following command lets you view a file
named MEMO.TXT, so you can use cursor-movement commands but cannot
change the text:
$ EDIT/TPU memo.txt /READ_ONLY
/NOREAD_ONLY is the same as /WRITE---on exiting, EVE writes out the
MAIN (or first) buffer to a file if the buffer has been modified, and
if necessary, EVE prompts you for the output file name.
In EVE, the status line shows whether the buffer is read-only or
write. Also, you can change the read/write and modification
attributes of the buffer during your editing session by using the SET
BUFFER command.
6.18 /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. |
+-------------------------------------------------------------------+
6.19 /SECTION
/SECTION[=section-file] (default)
/NOSECTION
Determines the section file you want to use, if any. A section file
contains, in binary form, key definitions, compiled procedures, and
other extensions. Effectively, the section file is the TPU
application you run---whether a customized version of EVE or an
application you have created.
TPU assumes the section file is in SYS$SHARE. If your section
file is stored elsewhere, specify the device (disk) and directory of
that file. You cannot use wildcards to specify the section file.
You use only one section file at a time. Default file type is
.TPU$SECTION.
The default section file is defined system-wide by the logical name
TPU$SECTION, which specifies the standard EVE section file---
EVE$SECTION.TPU$SECTION.
There are two ways to specify the section file you want to use:
o Define the TPU$SECTION logical name to specify the section file.
This lets you use that section file for all editing sessions---
including when you invoke TPU within MAIL or other utilities.
Your definition overrides the system-wide default. You can put
the definition in your LOGIN.COM file. For example, the following
commands define the default section file as MYSECTION.TPU$SECTION
in your top-level, login directory and invoke TPU using that
section file instead of the standard EVE section file:
$ DEFINE TPU$SECTION sys$login:mysection
$ EDIT/TPU
o Use /SECTION= and specify the section file on the command line.
This overrides any definition of the TPU$SECTION logical name,
whether a definition of your own or the system-wide default. For
example, the following command invokes TPU, using a section
file named MYSECTION.TPU$SECTION in your top-level, login
directory:
$ EDIT/TPU /SECTION=sys$login:mysection
If you do not want TPU to use any section file, use /NOSECTION.
This prevents even the default EVE interface from being used. TPU
will be unusable unless you specify a command file with TPU
procedures and executable statements that set up a text-processing
environment. Use /NOSECTION when you are creating your own
application without using EVE as a base or if you are using
/NODISPLAY for batch editing. For example, the following command
invokes TPU without a section file, using a command file named
USER_APPL.TPU:
$ EDIT/TPU /NOSECTION /COMMAND=user_appl /NODISPLAY
At startup, TPU first loads a section file, if one is being used,
before compiling and executing a command file (if any) and before EVE
executes an initialization file (if any). Thus, procedures,
settings, and key definitions in a command file (.TPU) or
initialization file (.EVE) override those in a section file.
To create a section file, do either of the following:
o In EVE, use the SAVE EXTENDED EVE command. For example, the
following command creates a section file named
MYSECTION.TPU$SECTION in your current, default directory:
Command: SAVE EXTENDED EVE mysection
DISK$1:[USER]MYSECTION.TPU$SECTION;1 created
903 procedures, 1168 variables, 621 keys saved
o In a TPU command file, use the SAVE built-in, usually at the
end of the command file. For example, the following statements
create a section file named MYSECTION.TPU$SECTION in your top-
level, login directory:
SAVE ("sys$login:mysection"); ! Create the section file
EXIT; ! Done---end of command file
A section file is cumulative; it saves the current key definitions
and other customizations---and those already in the section file you
are using. In EVE, the section file saves the following:
* Compiled procedures (your own and EVE's)
* Global settings ("attributes")
* Key definitions and LEARN sequences
* Menu definitions for the DECwindows interface
A section file usually does NOT save the following:
* Margins, tab stops, and other buffer settings
* Width or number of windows
* Contents of EVE system buffers, such as the Insert Here buffer
A section file created with the DECwindows interface will work on
character-cell terminals and conversely. However, some DECwindows
features are not available on character-cell terminals (such as
shifted function keys and the clipboard).
+----------------------------- NOTE -----------------------------+
| A section file created on OpenVMS will work on ULTRIX and |
| conversely so long as the procedures and statements saved do not |
| involve system-specific features and differences, such as file |
| names, directories, and so on. |
+------------------------------------------------------------------+
For more information, see the VSI Text Processing Utility Reference
Manual or Extensible Versatile Editor Reference Manual, or use the
online help in EVE and read the topic called Section Files.
6.20 /START_POSITION
/START_POSITION=(row[,column])
Determines the row and column where the cursor first appears in the
main (or first) buffer. If you specify multiple input files on the
EDIT/TPU command line, this qualifier applies to each buffer. Does
not affect other buffers you create during the editing session.
For EVE, the default start position is 1,1, which is the upper left
corner of the MAIN (or first) buffer---row 1, column 1. Does not
affect the initial cursor position when you create other buffers
during the editing session and does not limit the buffer size.
Use /START_POSITION to begin editing at a particular line (or row) or
at a particular character position (or column), such as when you want
to skip over a standard heading in a file, or if a batch log file or
error message tells you there is an error on a given line of a
program, you can specify that line number as the starting row, so
that when you edit the program source file, the cursor moves directly
to that line. For example, the following command edits a file named
TEST.COM, putting the cursor on line 10, column 5:
$ EDIT/TPU test.com /START_POSITION=(10,5)
If you simply want to begin editing at the start of a particular line
in the buffer or input file, you can omit the second parameter (the
column) and you need not use parentheses. For example, the following
command edits a file named MEMO.TXT putting the cursor at the start
of line 10:
$ EDIT/TPU memo.txt /START_POSITION=10
6.21 /WORK
/WORK[=work-file] (default)
/NOWORK
Determines the work file, if any, that TPU uses to swap memory for
editing very large files. The work file is automatically deleted
when you exit. If you invoke TPU and disable the /WORK qualifier,
TPU does not have a work file. In this case, the amount of memory
available to TPU limits the size of the files you can edit.
You cannot use wildcards to specify the work file. There is one work
file per editing session. Default file type is .TPU$WORK.
By default, TPU creates a work file named TPU$WORK.TPU$WORK in
SYS$SCRATCH, which is usually your top-level, login directory. There
are two ways to specify a different work file:
o Define the TPU$WORK logical name to specify the work file.
This is useful if you want the work file created in an area other
than SYS$SCRATCH, such as on a larger disk. You can put the
definition in your LOGIN.COM file.
o Use /WORK= and specify the work file you want created.
This overrides any definition of the TPU$WORK logical name. For
example, the following command invokes TPU, specifying the work
file to be MYWORK.TPU$WORK:
$ EDIT/TPU /WORK=mywork
To create the work file in an area other than SYS$SCRATCH, specify
the device (disk) and directory of the work file.
If you not want TPU to create a workfile, use /NOWORK. This
reduces consumption of system resources and makes startup faster.
Generally, you can use /NOWORK unless your system has limited memory
or unless you edit very large files or large numbers of files.
6.22 /WRITE
/WRITE (default)
/NOWRITE
Determines whether exiting writes the main (or first) buffer to a
file. If you specify multiple input files on the EDIT/TPU command
line, this qualifier applies to each buffer. Does not affect other
buffers you create during the editing session.
/WRITE is the same as /NOREAD_ONLY---on exiting, EVE writes out the
MAIN (or first) buffer to a file if the buffer has been modified, and
if necessary, EVE prompts you for the output file name.
/NOWRITE is the same as /READ_ONLY. For EVE, this makes the MAIN (or
first) buffer write-locked and also makes it unmodifiable, unless you
used /MODIFY. Use /NOWRITE to view a file without making any
changes. For example, the following command lets you view a file
named STAFFMEMO.TXT, so you can use cursor-movement commands but
cannot change the text:
$ EDIT/TPU staffmemo.txt /NOWRITE
In EVE, the status line shows whether the buffer is read-only or
write. Also, you can change the read/write and modification
attributes of the buffer during your editing session by using the SET
BUFFER command.