Invokes the VSI Text Processing Utility (TPU). By default, this
runs an editor called EVE (for Extensible Versatile Editor).
Format:
EDIT/TPU[/qualifier...] [input-file,...]
For example, the following command invokes TPU (running EVE) to
create or edit a file named JABBER.TXT in your current, default
directory:
$ EDIT/TPU jabber.txt
For information about TPU programming, see the VSI Text Processing
Utility Reference Manual. For information about EVE, see the
Extensible Versatile Editor Reference Manual or use the online help
in EVE.
1 – EVE Editor
The Extensible Versatile Editor (EVE) is a general-purpose text
editor created with TPU---in effect, the default TPU
application. You can use EVE on DECwindows or character-cell
terminals (VT400, VT300, VT200, or VT100 series). EVE reads and
writes standard ASCII text files.
Using EVE, you can do the following:
o Perform basic text editing and formatting operations
o Create or edit one or more files in an editing session
o Use multiple buffers and windows, and resize the windows
o Set EDT or WPS keypad, define keys, and create learn sequences
o Select boxes or linear ranges for cut-and-paste or other edits
o Use either OpenVMS- or ULTRIX-style wildcards to search text
o Execute DCL commands, such as DIRECTORY, from within the editor
o Run DECspell to check selected text or an entire buffer
o Spawn subprocesses or attach to other processes
o Compile and execute TPU procedures to extend EVE
o Add or delete menu items for the DECwindows interface
o Save your customizations for future sessions
o Use initialization files at startup or during an editing session
o Recover your work in case of a system failure during a session
o Get online help on commands, keys, menu items, and other topics
To invoke EVE, use the EDIT/TPU command. By default, this runs the
standard EVE section file---EVE$SECTION.TPU$SECTION (see help on
/SECTION). You may want to create a symbol for invoking EVE, by
putting the following line in your LOGIN.COM file:
$ eve :== EDIT/TPU ! My symbol to invoke EVE
If you specify an input file on the EDIT/TPU command line, EVE
creates a buffer using the file name and file type for the buffer
name, copies the file into that buffer, and displays it in the main
window. If the file does not exist---for example, if you are
creating a new file---the buffer is empty. If you do not specify an
input file, EVE creates an empty buffer named MAIN. See help on
Parameters.
By default, EVE tries to execute an initialization file named
EVE$INIT.EVE in your current directory or in SYS$LOGIN (your top-
level, login directory). See help on /INITIALIZATION.
Also, by default, EVE creates a buffer-change journal file for each
buffer you create, so that if a system failure occurs during your
editing session, you can recover your text. See help on /JOURNAL and
/RECOVER.
To enter EVE commands, press DO or PF4, type a command, and press
RETURN. For a keypad diagram and help on defined keys, press HELP
(on VT100-series terminals, press PF2). To exit from EVE, press F10
or CTRL/Z.
For more information, see the Extensible Versatile Editor Reference
Manual or use the online help in EVE, which provides informational
topics on various features in addition to help on EVE commands and
keys. In particular, you may want to read the following
informational topics:
New Features
New User
EDT Conversion
EDT Differences
WPS Differences
For information about using EVE on DECwindows, use the online help in
EVE and read the topic called DECwindows Differences.
TPU and EVE run on both OpenVMS and ULTRIX operating systems. Thus,
you can use the same editor on both systems, allowing for differences
in the way files and directories are specified.
2 – Examples
1. $ EDIT/TPU
Invokes TPU. By default, this runs EVE, creating an empty
buffer named MAIN. You can then simply start typing and editing,
or you can specify the file you want to edit by using the GET
FILE, OPEN, or OPEN SELECTED command.
2. $ EDIT/TPU /INTERFACE=DECWINDOWS
Invokes TPU, running EVE, with the DECwindows Motif interface.
For more information, see help on /DISPLAY or /INTERFACE.
3. $ EDIT/TPU jabber.txt
Edits a file named JABBER.TXT in your current, default directory.
If the file exists, EVE displays the text in the main window; if
you are creating a new file, the main window and buffer empty.
4. $ EDIT/TPU *.txt
EVE lets you use logical names and wildcards (such as *) to
specify the input file. If more than one file matches your
request, EVE shows a list of the matching files to choose from---
in this case, a list of files with the type .TXT. If no file
matches, EVE creates an empty buffer named MAIN.
5. $ EDIT/TPU jabber.txt,*.mail,*.lis,memo.txt
Edits files named JABBER.TXT and MEMO.TXT, and displays a list of
files matching *.MAIL. If more than one file matches *.LIS, EVE
issues a warning message that only one ambiguous file name is
allowed on the EDIT/TPU command line. If only a single file
matches *.LIS, EVE opens that file. If only a single file
matches *.MAIL, EVE opens that file and displays the list of any
files matching *.LIS.
EVE displays the first file in the main window. If JABBER.TXT
exists, EVE displays the text in the main window; if you are
creating a new file, the main window is empty.
6. $ EDIT/TPU memo.txt /RECOVER
Recovers the text of MEMO.TXT by using a buffer-change journal
file named MEMO_TXT.TPU$JOURNAL. See help on /RECOVER.
7. $ DEFINE TPU$SECTION sys$login:mysection
$ EDIT/TPU
Defines the TPU default section file as MYSECTION.TPU$SECTION
in your top-level, login directory and then invokes TPU using
that section file instead of the standard EVE section file. See
help on /SECTION.
3 – Logical Names
You can define the following logical names for TPU and EVE startup
files and other features instead of having to use command-line
qualifiers:
Logical names Definitions and usage
---------------------------------------------------------------------
EVE$INIT EVE initialization file, typically to set
margins, tab stops, and other attributes, or
to define keys. See help on /INITIALIZATION.
EVE$KEYPAD EVE keypad. This logical lets you choose
between the various keypads. Valid
equivalence names are EDT, EVE, NUMERIC,
VT100, and WPS. If the logical name is not
defined, the keypad defaults to EVE which
gives the VT100 keypad on VT100 terminals or
the NUMERIC keypad on VT200 and later
terminals. This logical name overrides any
keypad setting saved in a section file. Users
can override the effect of this logical name
by setting the keypad in their initialization
file or command file. This logical name has
no equivalent qualifier.
If you extend EVE with your own keypad, you
can also define the logical name to be the
name of your keypad. For example, assume you
have created a keypad named SIMPLE, and have a
procedure named EVE_SET_KEYPAD_SIMPLE that
sets the keypad. If you define the logical
name to be SIMPLE, EVE will invoke your keypad
during startup.
TPU$CHARACTER_SET Character set to use to display characters
having the 8th bit set. This affects how
TPU converts text to lowercase or
uppercase, and how it removes diacritical
marks from text. See help on /CHARACTER_SET.
TPU$COMMAND TPU command file to extend EVE, set up a
special text-processing environment for batch
editing, or create your own application. See
help on /COMMAND.
TPU$DEBUG TPU debug file to be compiled and executed
when you use /DEBUG. Defining TPU$DEBUG does
not automatically run the debug file when you
invoke TPU.
TPU$DISPLAY_MANAGER Screen display or interface. See help on
/DISPLAY or /INTERFACE.
TPU$JOURNAL Directory for buffer-change journal files.
Does not apply to keystroke journal files.
Default is SYS$SCRATCH. See help on /JOURNAL.
TPU$SECTION Section file---either a customized version of
EVE or an application you created. Default is
EVE$SECTION.TPU$SECTION, the standard EVE
section file. See help on /SECTION.
TPU$WORK Work file which TPU uses to swap memory for
editing very large files. See help on /WORK.
Defining TPU$COMMAND or EVE$INIT makes startup faster than having the
editor search for the respective default file. For example, if there
is an EVE initialization file you want to use for all or most editing
sessions, you should define EVE$INIT to specify that file, rather
than have EVE search for the EVE$INIT.EVE file. You can put the
definitions in your LOGIN.COM file.
To override a definition, use the relevant command-line qualifier.
For example, if you defined TPU$COMMAND but want to use a different
command file for a particular editing session, use /COMMAND= and
specify the command file; or if you do not want a command file used
for a particular editing session, use /NOCOMMAND.
4 – Parameters
[input-file,...]
The names of one or more text files you want to edit or create. The
files must be disk files on a Files-11 formatted volume. There is no
default file type---if you do not specify a file type, the file type
is null. Processing the input file depends on the TPU application
you are using. EVE handles the input file as follows:
o EVE uses the input file name and file type for the buffer name.
If the input file exists, EVE copies it into the buffer and
displays the text in the main window. A message tells you the
number of lines in the file. For example, the following command
edits a file named JABBER.TXT:
$ EDIT/TPU jabber.txt
24 lines read from DISK$1:[USER]JABBER.TXT;4
If the file does not exist---if you are creating a new file---the
buffer is empty.
o If you do not specify an input file, EVE creates an empty buffer
named MAIN. You can then simply start typing and editing, or you
can specify the file you want to edit or create by using the GET
FILE, OPEN, or OPEN SELECTED command.
o EVE lets you specify more than one file name on the EDIT/TPU
command line. EVE reads each file, and applies the file related
qualifiers to each file.
o EVE lets you use logical names and wildcards, to specify the file
---for example, *.TXT. You can create and edit more than one file
in an editing session.
o If more than one file matches your wildcard input file---for
example, if there are two or more files matching *.TXT or other
wildcard abbreviation---EVE displays a list of the matching files
so you can choose the one you want. For more information, use the
online help in EVE and read the topic called Choices Buffer.
o If you specify more than one wildcard input file, EVE displays the
list of matching files only for the first wildcard input file.
For other wildcard input files having more than one matching file,
EVE issues a warning message that only one ambiguous file name is
allowed on the EDIT/TPU command line.
o If more than one file matches your wildcard file name, EVE delays
applying the following qualifiers (or their defaults) until after
you resolve the file name:
/[NO]MODIFY
/[NO]OUTPUT
/[NO]READ_ONLY
/START_POSITION
/[NO]WRITE
If you specify multiple input files on the EDIT/TPU command line,
these qualifiers apply to each buffer. They do not affect buffers
you create during the editing session.
o If you use a search list to specify the input file or use
wildcards for the device (disk) or directory (such as [...]), EVE
gets the first matching file in the search list or directory tree.
If none of the files in the search list exists, EVE creates an
empty buffer using the first file name in the search list (unless
you used /NOCREATE).
5 – Programming
The VSI Text Processing Utility (TPU) provides a structured
progamming language with an interpreter, compiler, and other software
components, for creating text editors and other applications. TPU
has a callable interface so you can call editing functions from a
program written in BLISS, C, FORTRAN, or other language.
EVE (Extensible Versatile Editor) is the default TPU application.
You can use TPU to customize EVE or to create your own
applications. The EVE source files are available online as examples
of TPU programming and as a kind of run-time library of TPU
procedures. For a list of the EVE source files, use the following
DCL command:
$ DIRECTORY SYS$EXAMPLES:EVE$*.TPU
6 – Qualifiers
Qualifier formats Defaults
---------------------------------------------------------------------
/CHARACTER_SET[=character_set] /CHARACTER_SET=DEC_MCS
/[NO]COMMAND[=command-file] /COMMAND=TPU$COMMAND.TPU
/[NO]CREATE /CREATE
/[NO]DEBUG[=debug-file] /NODEBUG
/[NO]DISPLAY[=interface] /DISPLAY=CHARACTER_CELL
/[NO]INITIALIZATION[=init-file] /INITIALIZATION=EVE$INIT.EVE
/INTERFACE[=interface] /INTERFACE=CHARACTER_CELL
/[NO]JOURNAL[=journal-file] /JOURNAL
/[NO]MODIFY /MODIFY
/[NO]OUTPUT[=output-file] /OUTPUT
/[NO]READ_ONLY /NOREAD_ONLY
/[NO]RECOVER /NORECOVER
/[NO]SECTION[=section-file] /SECTION=TPU$SECTION
/START_POSITION=(row[,column]) /START_POSITION=(1,1)
/[NO]WORK[=work-file] /WORK=SYS$SCRATCH:TPU$WORK.TPU$WORK
/[NO]WRITE /WRITE
NOTE: Some qualifiers and their defaults are EVE-specific. Other
TPU applications may handle some qualifiers differently.
For more information, see the VSI Text Processing Utility
Reference Manual.
7 /CHARACTER_SET
/CHARACTER_SET[={DEC_MCS (default) | ISO_LATIN1 | GENERAL}]
Determines the character set you want TPU to use to display 8-bit
characters. The choice of character set affects how TPU performs
the following operations on characters:
o Converting to lowercase
o Converting to uppercase
o Inverting case
o Removing diacritical marks
o Converting to uppercase and removing diacritical marks
The choice of character set also affects how your text appears when
printed. For the text displayed in TPU to look the same when
printed, you must choose the same character set for both TPU and
the printer.
There are two ways to specify the character set you want to use:
o Define the TPU$CHARACTER_SET logical name to specify the character
set.
This lets you use that character set for all editing sessions---
including when you invoke TPU within MAIL or other utilities.
You can put the definition in your LOGIN.COM file. For example,
the following commands define TPU$CHARACTER_SET as ISO_LATIN1, and
then invoke TPU using that character set:
$ DEFINE TPU$CHARACTER_SET iso_latin1
$ EDIT/TPU
o Use /CHARACTER_SET= and specify the character set on the command
line.
This overrides any definition of the TPU$CHARACTER_SET logical
name. By default, TPU uses the DEC_MCS character set. For
example, the following command invokes TPU, using the GENERAL
character set:
$ EDIT/TPU /CHARACTER_SET=general
If the character set you specify either with /CHARACTER_SET or by
defining TPU$CHARACTER_SET is invalid, the editing session is
aborted, returning you to the DCL level.
8 /COMMAND
/COMMAND[=command-file] (default)
/NOCOMMAND
Determines the TPU command file you want to use, if any. A
command file contains TPU procedures and executable statements to
extend the editor. For example, you can use a command file to create
additional EVE commands, define keys, or set attributes. You can
also use a command file to set up a special text-processing
environment for creating your own TPU application or for batch
editing.
You cannot use wildcards to specify the command file. You can
specify only one command file at a time. Default file type is .TPU.
There are three ways to specify the command file you want to use:
o Name the command file TPU$COMMAND.TPU.
By default, TPU looks for this command file in your current
directory. Thus, you can have a different command file for each
directory or subdirectory without having to specify the command
file each time.
o Define the TPU$COMMAND logical name to specify the command file.
This lets you use that command file for all editing sessions---
including when you invoke TPU within MAIL or other utilities---
and lets you keep that file in any convenient directory or
subdirectory. The logical name overrides the search for the
TPU$COMMAND.TPU file. You can put the definition in your
LOGIN.COM file. For example, the following commands define
TPU$COMMAND as MYPROCS.TPU in your top-level, login directory and
then invoke TPU using that command file:
$ DEFINE TPU$COMMAND sys$login:myprocs
$ EDIT/TPU
o Use /COMMAND= and specify the command file on the command line.
This overrides any definition of the TPU$COMMAND logical name and
overrides the default search for the TPU$COMMAND.TPU file. For
example, the following command invokes TPU, using a command
file named MYPROCS.TPU in your current, default directory:
$ EDIT/TPU /COMMAND=myprocs
If the command file you specify either with /COMMAND or by defining
TPU$COMMAND is not found, the editing session is aborted, returning
you to the DCL level.
If you do not want a command file executed, use /NOCOMMAND---
typically if you defined the TPU$COMMAND logical name or created a
TPU$COMMAND.TPU file but do not want it used for a particular editing
session. Also, /NOCOMMAND makes startup faster because TPU then
does not search for a command file and does not have to compile and
execute code at startup.
At startup, TPU compiles and executes the command file, if one is
being used, after loading a section file (if any) and before EVE
executes an initialization file (if any). Thus, you can use a
command file in conjunction with a section file and an initialization
file. Procedures, settings, and key definitions in a command file
override those in the section file. For more information about
command files, see the VSI Text Processing Utility Reference Manual
or use the online help in EVE and read the topic called Command
Files.
In EVE, you can create or update a command file by using the SAVE
ATTRIBUTES command to save menu definitions for the DECwindows
interface and most global settings ("attributes"). For more
information, see the Extensible Versatile Editor Reference Manual or
use the online help in EVE and read the topic called Attributes.
9 /CREATE
/CREATE (default)
/NOCREATE
Determines whether a buffer is created when the input file is not
found. Processing this qualifier depends on the TPU application
you are using.
For EVE, the default is /CREATE. If any input file specified on the
command line does not exist, EVE creates a buffer using the file name
and file type as the buffer name; or if you do not specify an input
file, EVE creates an empty buffer named MAIN.
Use /NOCREATE to edit only existing files. Thus, if none of the
input files are found, the editing session is aborted returning you
to the DCL level, as in the following example:
$ EDIT/TPU old.dat,new.dat /NOCREATE
Input file or files do not exist: OLD.DAT,NEW.DAT
$
10 /DEBUG
/DEBUG[=debug-file]
/NODEBUG (default)
Determines whether you run a TPU debug file to test procedures for
an application you are creating. TPU compiles, and executes the
debug file---before executing TPU$INIT_PROCEDURE.
Using /DEBUG without specifying a debug file runs the default TPU
debugger---TPU$DEBUG.TPU, which provides commands to manipulate
variables and to control program execution. To start editing the
code in the file you are debugging, use the GO command. For more
information about the debugger, read the comments in the
TPU$DEBUG.TPU source file in SYSSHARE, or see the VSI Text Processing
Utility Reference Manual or use the online help in EVE as follows:
Command: HELP TPU Debugger
There are two ways to specify a debug file of your own:
o Define the TPU$DEBUG logical name to specify the debug file, and
then use EDIT/TPU/DEBUG.
Defining the logical name does NOT by itself run the debugger when
you invoke TPU. It only specifies which debug file is run when
you use /DEBUG. You can put the definition in your LOGIN.COM
file.
o Use /DEBUG= and specify the debug file on the command line.
For example, the following command edits a file named MYPROCS.TPU,
using a debug file named MYDEBUG.TPU:
$ EDIT/TPU myprocs.tpu /DEBUG=mydebug
TPU assumes the debug file is in SYSSHARE. If your debug file is
stored elsewhere, specify the device (disk) and directory of that
file. You cannot use wildcards to specify the debug file. You can
use only one debug file at a time. Default file type is .TPU.
11 /DISPLAY
/DISPLAY[={CHARACTER_CELL (default) | DECWINDOWS | MOTIF}]
/NODISPLAY
Determines the type of screen display, if any. /DISPLAY is the same
as /INTERFACE.
For example, the following command invokes TPU with the Motif
DECwindows interface:
$ EDIT/TPU /DISPLAY=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 then
includes a menu bar and scroll bars, and you can use M1 to move the
cursor and select text. If DECwindows 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.
To specify your preferred display, you can define the logical name
TPU$DISPLAY_MANAGER as CHARACTER_CELL, DECWINDOWS, or MOTIF.
Use /NODISPLAY for batch jobs or when you are using an unsupported
terminal. For batch jobs, you typically use a TPU command file or
EVE initialization file, as in the following example, which uses a
command file named BATCH.TPU:
EDIT/TPU /NODISPLAY /COMMAND=batch
This batch file should comprise a complete editing session, including
EXIT or QUIT. Note that some EVE commands cannot be used in batch
because they prompt for a key press or other interactive response.
12 /INITIALIZATION
/INITIALIZATION[=init-file] (default)
/NOINITIALIZATION
Determines the initialization file you want to use, if any.
Processing this qualifier depends on the TPU application you are
using. An EVE initialization file contains a list of EVE commands
you want executed, typically to set margins, tab stops, and other
attributes, or to define keys that you do not otherwise save in a
section file.
You cannot use wildcards to specify the initialization file. You can
specify only one initialization file at a time. Default file type is
.EVE.
There are three ways to specify the EVE initialization file you want
to use:
o Name the initialization file EVE$INIT.EVE.
By default, EVE first looks for this initialization file in your
current directory. If the file is not found there, EVE then looks
for it in SYS$LOGIN (your top-level, login directory). Thus, you
can have different initialization files for different directories
or subdirectories, and you can have a "standard" initialization
file in SYS$LOGIN for editing in directories that do not have an
EVE$INIT.EVE file.
o Define the EVE$INIT logical name to specify the initialization
file.
This lets you use that initialization file for all editing
sessions---including when you invoke TPU within MAIL or other
utilities---and lets you keep that file in any convenient
directory or subdirectory. Defining the logical name overrides
the search for the EVE$INIT.EVE file. If you omit parts of the
file specification from the logical name definition---for example,
if you do not specify a device (disk)---EVE supplies them from
SYS$DISK:EVE$INIT.EVE or SYS$LOGINEVE$INIT.EVE. You can put the
definition in your LOGIN.COM file. For example, the following
commands define EVE$INIT as MYINIT.EVE in your top-level, login
directory and then invoke EVE using that initialization file:
$ DEFINE EVE$INIT sys$login:myinit
$ EDIT/TPU
o Use /INITIALIZATION= and specify the initialization file on the
command line.
This overrides any definition of the EVE$INIT logical name and
overrides the default search for the EVE$INIT.EVE file. If you
omit parts of the file specification---for example, if you do not
specify a device (disk)---EVE supplies them first from the logical
name (if defined), and then from SYS$DISK:EVE$INIT.EVE or
SYS$LOGINEVE$INIT.EVE. For example, the following command invokes
EVE, using an initialization file named MYINIT.EVE in your
current, default directory:
$ EDIT/TPU /INITIALIZATION=myinit
If you do not want an initialization file executed, use
/NOINITIALIZATION---typically if you defined the EVE$INIT logical
name or created an EVE$INIT.EVE file but do not want it executed for
a particular editing session. Also, /NOINITIALIZATION makes startup
faster because EVE then does not search for an initialization file
and does not have to parse commands at startup.
At startup, EVE executes an initialization file (if any) after TPU
loads the section file and executes a command file (if any). Thus,
you can use an initialization file in conjunction with a TPU
command file. Settings and key definitions in an initialization file
override those in a section file or command file. When you invoke
EVE, commands in an initialization file for margins, tab stops, and
other buffer settings apply to the MAIN buffer (or buffers initially
created from your input files) and to an EVE system buffer named
$DEFAULTS$. Buffers created during the session will have the same
settings as $DEFAULTS$. For more information, use the online help in
EVE and read the topic called Defaults.
If a command in an initialization file is incomplete---for example,
if a command requires a file name, search string, or other parameter
---EVE prompts you for the required information before going on. You
can also execute an initialization file during an EVE session by
using the @ command (at sign). This is useful to execute a series of
related commands or to set attributes or define keys for particular
kinds of editing.
An initialization file is somewhat slower than a section file or
TPU command file, depending on the number of commands to be
executed. If you want to define several keys, you should save them
in a section file. For more information, see the Extensible
Versatile Editor Reference Manual or use the online help in EVE and
read the topic called Initialization Files.
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.
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. |
+-------------------------------------------------------------------+
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.
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
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.
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. |
+-------------------------------------------------------------------+
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.
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
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.
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.