There is 1 other file named tv.man in the archive. Click here to see a list.
WHAT IS TV ?
TV is a general purpose text editor. Text editors are used
to create and modify files containing text. The files you edit
with TV may be used for virtually any purpose you want, for
which a human-readable file is desired. For example, the file
you edit with TV may be a list of good restaurants, a COBOL
program, words to all the Paul McCartney songs written after
1967, or anything else you may want to store on a file.
In many ways, TV is identical to TECO, another text editor.
If you know nothing about TECO, have no fear, because this
manual does not assume you are familiar with TECO. If you are
already a TECO user, learning TV will not be like learning a new
editor, as the similarity is so great. TV is actually a
modification of TECO, including many improvements and new
features not offered by TECO. For details on differences
between TV and TECO, see the appendix.
CONVENTIONS AND TERMS USED IN THIS MANUAL
The following terms are used frequently in this manual:
While you are editing a file, you are reading and modifying
a copy of the file rather than the real file. This copy is
called the BUFFER. Before you start editing your file, TV
copies the file into the buffer, and after you've finished
editing, the buffer is copied out to the new version of the
file. Usually, the buffer will contain the entire file you're
currently working on. However, there are commands directing TV
to only put part of your file into the buffer. Note that since
editing only modifies a copy of the file rather than the real
thing, it is a simple matter to decide in the middle of an
editing session not to do any editing at all, in which case the
file hasn't changed from the way it was at the beginning of the
This is the name of the key on your terminal which means
special things to TV. On some terminals, it is labeled ALTMODE
instead of ESCAPE. When you press ESCAPE, it'll appear on your
terminal as a $, which is the same as a dollar sign. Whenever
the symbol $ appears in this manual, it stands for an ESCAPE,
unless specifically stated otherwise.
Any key you press on your terminal sends a character to the
system. For instance, the RETURN key sends the character
carriage return. the A key sends the character A to the system.
The space bar sends the character called SPACE, etc. Characters
are the smallest unit a file may be broken up into. For
instance, this sentence contains 135 characters in it, the first
CONVENTIONS AND TERMS USED IN THIS MANUAL Page 2-2
being the letter F, and the last being its terminating period.
A contiguous group of characters is often referred to as a
STRING. Strings are usually more specifically defined in some
context. For instance, Each sentence in this paragraph may be
considered a string, or the entire paragraph may be considered a
Many commands in TV need to know more about what they
should do than is inherent in their name. For instance, the K
command in TV is used to kill or delete some lines from the
buffer. You would type 3K to get rid of (Kill) three lines, or
2K to erase only two lines. In this example, the numbers 3 and
2 appearing in front of the K are refered to as arguments to the
K command. In these examples, we say the K command was given
one argument, which designated how many lines to delete.
Very often, when you type commands to TV, you'll want to
type more than one command at a time, and not have TV do any of
them until all are entered. This string of characters that you
type before TV starts working on the commands is called a
COMMAND STRING. Hence a command string includes as many or as
few commands as you like.
HOW TO CREATE A FILE
TYPING COMMANDS TO TV
Unlike most programs, which start executing your commands
when you type a RETURN, TV waits for you to type two consecutive
ESCAPEs. So if you type in many characters, including returns,
TV will not interpert these as commands, until you type two
ESCAPEs. Then, TV starts from the beginning of the command
string just completed, and begins interpreting each character in
the command string in order. When TV gets to the end of the
command string, or encounters an error, it again waits for you
to type in another command string.
HOW TO START A NEW FILE
If you're just learning TV, it is strongly suggested that
you do it from a screen terminal. This is because the screen
terminal can always show you what's going on much better than a
hard copy terminal can. The following explanation assumes you
are working from a screen terminal, although the effect of the
various commands will be the same on any terminal.
The following example shows you how to create a file on the
disk called FAMOUS.QUOTE. This file will contain a quote by
The first step is to tell the system you want to run TV. Get
out of any other program you may be running at the time. If the
program doesn't have some official exiting command, or you don't
know, you can probably get out by typing two control-C's.
You'll know you're out if you see an atsign at the left margin.
It'll look like this:
Now tell the system you want to run TV by typing TV and
press the RETURN key. the line should look like this:
HOW TO CREATE A FILE Page 3-2
When TV starts, it should clear your screen. It will print
a star to signal you that it is ready for your first command
string. You'll probably also see a caret looking like this:
in the upper left corner of the screen. Don't worry about
this quite yet.
If TV doesn't clear your screen when it starts, it is
probably because it doesn't understand what type of terminal you
are on. You can tell it with a command string like this:
The W tells TV that you are about to type a word, and the
word you type after the W is the type of terminal you are on, in
this example a VT52. the $$ are the two ESCAPEs needed to tell
TV to start executing the command string. Remember not to type
a return after them, as TV is already executing the command as
soon as you type $$. As another example, if you are on a VT05,
you would type:
Assuming that TV knows what type of terminal you're on, you
are ready to tell TV what to put into the file. In this
example, you want to put a quote said by Samuel Butler into the
file, so this is what you type:
IALL THE ANIMALS EXCEPT MAN KNOW THAT THE PRINCIPLE BUSINESS OF
LIFE IS TO ENJOY IT.
The first character typed was an I. that is to say, you're
telling TV to execute an INSERT command. The way the I command
works is that every character typed after the I until an ESCAPE
gets inserted literally into the buffer. When you type the two
ESCAPEs at the end, TV executes the command string, and hence
inserts the entire quote and the name Samuel Butler into the
You will see the quote that you have just inserted appear
on the screen at the top.
HOW TO CREATE A FILE Page 3-3
The next step is to tell TV to save the buffer away on a
file called FAMOUS.QUOTE. You type this:
That is, you type a semi-colon, an X, and two ESCAPEs. The
two ESCAPEs as usual tell TV to start executing the command
string. As TV does so, the first character TV sees is a
semi-colon. Semi-colon is a special character which tells TV to
look at the next character in the command string and do
different things depending on what that character is. In this
example, the next character is X, which stands for EXIT. TV
knows you want to exit, and should save the buffer in a file.
This is asking you what to call the file you're making.
Type the file name FAMOUS.QUOTE and press RETURN. The line now
looks like this:
TV now writes out the buffer into the file FAMOUS.QUOTE and
exits. As it exits, it clears the screen. You'll know it's
through when you see an atsign at the left margin. You are now
back at TOPS-20 command level.
EDITING AN EXISTING FILE WITH TV
HOW TO EDIT A FILE THAT ALREADY EXISTS
Looking back at the quote you put into the file called
FAMOUS.QUOTE, you may notice that the word "PRINCIPAL" has been
misspelled. Here is how you may use TV to edit an existing
file. In this example, the existing file is called
FAMOUS.QUOTE, and you're editing it for the purpose of
correcting the spelling mistake.
The first thing to do is tell the TOPS-20 command language
that you want to run TV to edit FAMOUS.QUOTE. You type TV
followed by a space and the name of the file you want to edit,
and a return. The line will look like this:
As TV starts, it reads the entire file called FAMOUS.QUOTE
into the buffer for editing. The first line you'll see printed
out will look like this:
That tells you that TV is doing a ;Y command. The Y stands
for YANK and means that TV is yanking an entire file into the
buffer. The next line will say:
This shows you what file is being read in, in this case
version one of FAMOUS.QUOTE. The next line will look like this:
That line tells you how many characters have just been read
in, which is exactly how many you inserted into the file up
above when you typed it in.
Assuming TV knows you are on a screen terminal, it will now
show you as much of the buffer as it can fit on the screen. In
this case the whole buffer fits, because it's only a few lines
EDITING AN EXISTING FILE WITH TV Page 4-2
long. So at the top of your screen, you'll see lines looking
/\ALL THE ANIMALS EXCEPT MAN KNOW THAT THE PRINCIPLE BUSINESS OF
LIFE IS TO ENJOY IT.
The caret appearing as /\ shows the location of the BUFFER
POINTER or just the POINTER. Whenever you're editing a file, TV
always remembers where the pointer is in the buffer. When you
insert text in the buffer, it always gets put just before the
pointer. This will become clearer as you read the following
To get TV to correct the misspelled word, you must first
tell TV to position the pointer to the location in the buffer
where the change is to be made. The correction to be made in
this case is just after the letters "cip" of the word
"principal". So tell TV to search for the string "cip" by
typing the following:
The S stands for SEARCH and tells TV you want to search for
a string of characters. When TV sees the S in the command
string, it uses all the characters in the command string
following the S as the string to search for, until an ESCAPE is
seen. In this case, the characters "CIP" follow the S, and then
there is an ESCAPE, so TV searches for "CIP" in the buffer.
When TV finds the string, it leaves the pointer after it. So
now the top of the screen looks like this:
ALL THE ANIMALS EXCEPT MAN KNOW THAT THE PRINCIP/\LE BUSINESS OF
LIFE IS TO ENJOY IT.
Notice that the pointer has been moved from the beginning of the
buffer to just after the "CIP".
The next thing you want to do is change the "LE" that sits
just to the right of the pointer to an "AL". First, tell TV to
delete the "LE" by typing this:
The D stands for DELETE, and the number in front of the D, in
this case 2, tells TV how many characters to delete. So this
command directs TV to delete 2 characters to the right of the
pointer. The screen, as usual, shows you the change caused to
the buffer and now looks like this:
EDITING AN EXISTING FILE WITH TV Page 4-3
ALL THE ANIMALS EXCEPT MAN KNOW THAT THE PRINCIP/\ BUSINESS OF
LIFE IS TO ENJOY IT.
Notice how the 2D$$ caused the "le" get deleted from the buffer.
Now insert the correct letters like this:
This is the INSERT command. It's the same one originally used
to type in the quotation . The way the insert command works is
that TV takes all the characters following the I up to the next
ESCAPE, and inserts them in the buffer to the left of the
pointer. IN this case, the characters being inserted are "AL".
The screen shows this change by now appearing thusly:
ALL THE ANIMALS EXCEPT MAN KNOW THAT THE PRINCIPAL/\ BUSINESS OF
LIFE IS TO ENJOY IT.
In this example, three separate command strings were used
to achieve the purpose of correcting the word. The first
command string was a SEARCH to put the pointer at the location
where the change was to be made. The second was a DELETE to
delete the wrong letters, and the last was an INSERT to put the
correct spelling in. This could have all been done as one
command string looking like this:
Look at it piece by piece to see what it means. the S means TV
should search for something and put the pointer just after it.
The ESCAPE following the CIP tells TV that the string to search
for ends there. If that ESCAPE were left out, TV would not
search for just CIP, but would look for CIP2DIAL, which of
course it would fail to find, and an error message would get
printed. The D after the 2 tells TV to delete some characters,
and the 2 in front of the D is an argument to the D command that
tells TV how many characters to delete. The I instructs TV to
insert some new characters into the buffer, and the AL are the
characters to insert. The two ESCAPEs at the end of the command
string actually serve two purposes. The first one delimits the
string being inserted. That is, it ends it, just as the ESCAPE
after the CIP delimited the string to be searched for. Also,
the fact that there are two ESCAPEs in a row tells TV that you
have typed the entire command string, and TV should now start
GENERAL COMMAND SYNTAX Page 4-4
The point of this example is to show you that it doesn't
matter how many commands you type at once to TV. The effect of
doing it all in one command string is the same as doing it in
three separate strings as was illustrated up above.
The last step in fixing this file is to tell TV to save the
fixed version away. As before, the command to type is ;X$$.
The line will look like this (including TV's prompt character):
TV asks what name to save the file as by typing:
Since this isn't a new file, TV remembers the name of the
file we read in. So you needn't retype the file name. Instead,
type an ESCAPE. This causes TV to prove to you that it
remembers the file name, by typing it out at you. The line now
looks like this:
OUTPUT FILE: FAMOUS.QUOTE.2 [NEW GENERATION]
Notice that the ESCAPE you typed after you saw OUTPUT FILE:
appear doesn't show up. That's all right. The message in
square brackets shows you that the corrected version is
superceding another file with the same name. That's what you
want, since the old one has "principal" misspelled. Just hit a
carriage return now, and TV saves away the the new file, and
returns you to TOPS20 command level. Just as before, you'll
know TV is done because the screen will clear and you'll see an
atsign appear in the upper left.
GENERAL COMMAND SYNTAX
The above examples showed the use of four TV commands, the
I command for inserting text, the S command for searching for
text, the D command for deleting characters, and the ;X command
for exiting and saving away the edited file. Almost all TV
commands are very similar to these in the way you type them.
For instance, almost all commands may be preceded by a numerical
argument. You saw that in the use of the D command where an
argument of 2 was supplied directing TV to delete 2 characters.
It was typed as 2D. Some commands take a string after them as
an argument. For instance, the I command for inserting text,
and the S command for searching for text both take a string
argument. The I command uses the string argument as the actual
text to be inserted into the buffer. The S command uses the
string argument as the text to be searched for. Commands taking
string arguments in this fashion usually must include an ESCAPE
to tell TV where the end of the string is. For instance,
suppose you wanted to tell TV to find the word BOARD and append
WALK to it making it say BOARDWALK. One way to do this is to
GENERAL COMMAND SYNTAX Page 4-5
type a command string looking like this:
That command string tells TV to search for the string BOARD and
then insert the string WALK after it. Suppose the ESCAPE in the
middle were left out; that is, you typed this instead:
This command string would cause TV not to know that the I is
meant as an insert command. Instead, TV would attempt to find
the string BOARDIWALK in the buffer. Such a string probably
isn't to be found in the buffer, so an error message would get
THE MOST FREQUENTLY USED COMMANDS
This chapter describes the most frequently used commands
and their most common uses.
The following table lists the commands described in this
chapter and a short functional description of each command:
FREQUENTLY USED TV COMMANDS
COMMAND NAME WHAT IT DOES
;Y Yanks (reads) an entire file into the
buffer so that it may be edited
J Jumps (moves) the POINTER
to the beginning of the buffer
@J Moves the pointer to the center of
ZJ Moves the pointer to the end of the
I Inserts new text into the buffer
S Searches for text in the buffer
L Moves the pointer to the beginning
of the next line
-L Moves the pointer to the beginning
of the last line
0L Moves the pointer to the beginning
of the current line
nL Moves the pointer down n lines
-nL Moves the pointer up n lines
FREQUENTLY USED TV COMMANDS Page 5-2
K Kills (erases) the current line from
-K Erases the last line (the one
before the pointer)
nK Erases n lines after the pointer
-nK Erase n lines before the pointer
m,nK Erases characters m through n-1
HK Erases the whole buffer
C Moves the pointer one character to
-C Moves pointer one character to the left
nC Moves the pointer n characters to
-nC Moves the pointer n characters to
Z= Prints out the number of characters in
.= Prints out the position of the pointer
(I.E. the number of characters in the
buffer ahead of the pointer.)
;X Finishes the edit by saving the entire
buffer away in a file and exits
;U Finishes the edit by saving the entire
buffer away in a file but doesn't exit
FREQUENTLY USED TV COMMANDS Page 5-3
This command loads an entire file into the buffer for
editing. If you are editing a previously created file, this
should almost always be the first command you type to TV.
However, often you won't have to type this command, if you've
started TV by telling the TOPS20 command language which file you
want to edit. In that case, TV automatically does the ;Y for
you. The most common use of ;Y works like this: First you
issue a ;Y command to TV. Your line may look like this:
TV asks you which file you want to edit like this:
At this point just type the file name of the file name you want
to read in for editing. If the file's name is LIFE.MAC, the
line will now look similar to this:
INPUT FILE: LIFE.MAC
Hit a return, and TV will read the entire file into the buffer,
and tell you the total number of characters in the buffer like
You are now ready to start editing the file.
If you've already got characters in the buffer when you do
a ;Y command, the file the ;Y command reads in gets put after
the already existing characters in the buffer.
Occasionally you may unintentionally issue a ;Y command,
causing TV to type
and be waiting for you to type in a file name, but you really
didn't want to even do the ;Y command at all. If this is the
case, instead of complying by typing a file name, type two
control-G's. TV will abort the command and go back to waiting
for your next command string.
FREQUENTLY USED TV COMMANDS Page 5-4
J stands for jump. If this command is issued without an
argument, the pointer is positioned at the beginning of the
buffer. For instance, if you type
the pointer is put at the beginning of the buffer.
The J command may be preceded by a numerical argument, in
which case the pointer is positioned after the number of
characters in the buffer specified by the argument. For
instance, the command string
puts the pointer after the third character in the buffer.
Actually, TV always uses an argument to this command. In the
case where you issue a J command without supplying an argument,
TV assumes an argument of 0, which is why
puts the pointer at the beginning. It's exactly as though you
Another argument that can be used with the J command is @.
Typeing @J causes the pointer to be placed in the center of your
display screen if you are using a display terminal. This is
useful if you have been scanning through a file and you find
something that you want to change. Just type @J and, regardless
of where the pointer was, it is moved to the center of your
A special argument useful for many commands is the letter
Z. TV understands the letter Z as standing for the total number
of characters in the buffer. Hence an easy way to get the
pointer to the end of the buffer is by typing
If there were 318 characters in the buffer, ZJ$$ has exactly the
same effect as typing
FREQUENTLY USED TV COMMANDS Page 5-5
I stands for INSERT. This command, in its most common
form, takes a string argument following it, and inserts that
string into the buffer just before the pointer. The text ends
at the next ESCAPE seen by TV in the command string. For
instance, to insert a line at the end of the buffer saying ONE
MORE LINE, you could do it this way:
ZJIONE MORE LINE
The ZJ puts the pointer at the end of the line, and the I causes
the text string following it to be inserted literally into the
buffer before the pointer, which is now at the end of the
buffer. Notice that a return was typed before hitting the
ESCAPEs, since a return was desired to actually be in the buffer
after the line.
The S stands for SEARCH. This command takes a string after
it terminated by an ESCAPE, and moves the pointer forward to
just after the next occurence of that string in the buffer. For
instance, if the buffer and pointer are like this:
ALWAYS ASK I/\F YOU'RE NOT SURE
and you issue the command
TV searches for the next occurence of the string U'R and
positions the pointer after it. The buffer and pointer are now
ALWAYS ASK IF YOU'R/\E NOT SURE
If you precede the S command with a minus sign, TV searches
toward the beginning of the buffer instead of the end and leaves
the pointer immediately before the string specified. Assuming
the buffer and pointer are as shown above, the command string
would move the pointer to here:
AL/\WAYS ASK IF YOU'RE NOT SURE
A search command given with no specific string uses the last
string specified. So if the next search command you issue after
that last one is
FREQUENTLY USED TV COMMANDS Page 5-6
TV notices that you haven't supplied a string to search for, so
it uses the string WAY just as before. Notice that no minus
sign was given this time, so TV searches toward the end of the
buffer, leaving the pointer as shown here:
ALWAY/\S ASK IF YOU'RE NOT SURE
L stands for line. This command given without a numerical
argument before it assumes an argument of 1, and moves the
pointer down one line. Suppose the buffer and pointer are like
THE FIR/\ST LINE
AND ONE MORE
AND ANOTHER FOR GOOD LUCK
The command string
would leave the pointer here:
THE FIRST LINE
/\AND ONE MORE
AND ANOTHER FOR GOOD LUCK
A minus sign causes the pointer to be moved up, so the command
would now leave the pointer like this:
/\THE FIRST LINE
AND ONE MORE
AND ANOTHER FOR GOOD LUCK
To move more than one line at a time, a numerical argument
may be specified. For instance, the command string
THE FIRST LINE
AND ONE MORE
/\AND ANOTHER FOR GOOD LUCK
FREQUENTLY USED TV COMMANDS Page 5-7
An argument of 0 is a special case, and causes the pointer
to be positioned at the beginning of the current line. If the
pointer is like this:
THE FIRST LINE
AND O/\NE MORE
AND ANOTHER FOR GOOD LUCK
and you issue the command
the pointer moves to the beginning of the line yielding
THE FIRST LINE
/\AND ONE MORE
AND ANOTHER FOR GOOD LUCK
K stands for KILL and the K command is used for killing,
(erasing or deleting) lines. Without an argument, it assumes 1,
so if the buffer and pointer are like this:
THIS LINE BELONGS
/\WE'LL ERASE THIS ONE
BUT KEEP THIS
AND ALSO THIS ONE
would erase one line leaving it like this:
THIS LINE BELONGS
/\BUT KEEP THIS
AND ALSO THIS ONE
The K command kills a line including its carriage return
and line feed. It also assumes that the line begins where the
pointer is. Be careful if the pointer is in the middle of a
line like this:
HERE'S A SITUATION
THAT YOU OU/\GHT TO
BE CAREFUL ABOUT
In this case, the command
FREQUENTLY USED TV COMMANDS Page 5-8
would leave the buffer and pointer like this:
HERE'S A SITUATION
THAT YOU OU/\BE CAREFUL ABOUT
In that last example, if you meant to erase the entire line
saying THAT YOU OUGHT TO, you should have done
to put the pointer at the beginning of the line before erasing
it, to assure that the whole thing gets erased.
If you type
one line before the pointer gets erased. Hence if the buffer
and pointer are like this:
leaves the buffer like this:
The K command may take a specified numerical argument
designating how many lines to kill. For instance, the command
will erase three lines before the pointer.
An argument of 0 causes the beginning of the current line
to be erased. If the buffer and pointer look like this:
OF A LINE MAY BE ERASED
and you type
the buffer will now look like this:
FREQUENTLY USED TV COMMANDS Page 5-9
OF A LINE MAY BE ERASED
There's another way of using the K command, which isn't as
common. If you supply two numerical arguments in front of it,
TV erases the portion of the buffer in the character position
range you've specified. For instance, the command
causes four characters to be erased. The four that are erased
in this case are the fourth, fifth, sixth, and seventh. This
form of the command also leaves the pointer at the position
where the characters were deleted from. Here's an example: the
buffer and pointer are like this:
You give the command
The buffer now looks like this:
TV understands the special letter H as meaning the wHole
buffer. Actually, typing H is like typing 0,Z. Hence a
convenient way to erase the entire buffer is to type
The C stands for Character. This command is used to move
the pointer a specific number of characters relative to where it
is. In its simplest form, it assumes an argument of 1 and moves
the pointer one character forward. For example if the buffer
and pointer are as shown:
WINKEN, BLINKEN/\, AND NOD
and you give the command
TV moves the pointer one character to the right yielding
WINKEN, BLINKEN,/\ AND NOD
Similarly, -C moves the pointer one character to the left.
FREQUENTLY USED TV COMMANDS Page 5-10
A specific number as an argument to the C command causes
the pointer to be moved that many characters. For instance, if
the buffer and pointer are like this:
HERE'S ONE LINE
/\WATCH THE POINTER
and you do
the pointer was at the beginning of a line, and hence after the
carriage return and linefeed of the last line. Moving back two
characters leaves the pointer before the carriage return and
linefeed hence putting it at the end of the last line as shown
HERE'S ONE LINE/\
WATCH THE POINTER
The = command is used to ask TV to print out the value of
numerical quantities or expressions. For instance, since TV
always understands Z as standing for the number of characters in
the buffer, you can ask TV how many characters are in the buffer
Similarly, since TV understands the special symbol "dot" as
standing for the value of the pointer, you can ask TV how many
characters preceded the pointer is the buffer by typing
If TV responds by typing 34, you'll know there are 34 characters
before the pointer in the buffer. If TV responds by typing 0,
you'll know there are no characters before the pointer in the
buffer, or in other words, the pointer is at the beginning of
the buffer. Notice that if the pointer is at the end of the
buffer, the commands .= and Z= produce the same result, namely
the number of characters in the buffer.
The = command is also useful for printing out the value of
integer arithmetic expressions. For instance, typing
produces the reponse 13 from TV. To find out how many
characters are between the pointer and the end of the buffer,
FREQUENTLY USED TV COMMANDS Page 5-11
you could type
The X stands for EXIT. This command is used for finishing
an edit by saving the new file away and exiting from TV. When
you type the command
TV usually will ask you what file to save the buffer as. It
Now type the name of the file onto which you want the buffer
saved, hit RETURN, and TV writes the buffer to the file, and
exits. If you're working from a screen terminal, TV clears the
screen as it exits.
TV remembers the name of the file originally read into the
buffer for editing. Most often, when you are finished editing,
you want to save the new version as the same file name as it was
saved as before. The simplest way to do this is to respond to
by typing an ESCAPE instead of a file name. TV will type out
the name of the file onto which it is about to save the buffer.
Check it and make sure it's the name you expected, and then hit
RETURN. TV will now create the new file version and exit.
UNDOING BIG MISTAKES, YOURS OR THE SYSTEM'S
This chapter tells how to avoid having to retype lots of
work, after big mistakes. The most common of these mistakes
1. The system crashes and is restarted.
2. You try to insert lots of text, and after typing for
awhile, you realize you forgot the I command required
to insert text.
3. You accidently issue a command which drastically
changes the contents of the buffer in a way you didn't
want. (For instance, you type HK$$ by accident, which
erases the entire buffer.
4. You try to write out a file and TV gets an error
because the directory that you are CONNECTed to is over
it's disk space quota.
Commands often useful for Undoing big Mistakes
COMMAND NAME WHAT IT DOES
_______ ____ ____ __ ____
;G Gets the last command string that was
longer than 15 characters, and inserts
it into the buffer
;E Causes typein to come from a file
instead of the terminal.
What to do if you've forgotten to type I in front of a long
insertion- The ;G Command:
Consider the following situation: You are typing in a report,
and have been typing in a part of it, let's say a page or so.
Your typing starts like this (TV's prompt shown too):
*ANIMAL LIFE WAS SCARCE IN THIS PART OF THE WORLD.
UNDOING BIG MISTAKES Page 6-2
After typing for a while, you decide to stop work for a
while, so you type two ESCAPEs, preparing to exit from TV.
However, as soon as you type the two ESCAPEs to end the
insertion, you get an error message saying:
?NO FILE FOR INPUT: A
The reason for this is that at the beginning of your long
insertion, the first thing you typed was ANIMAL. You meant to
be inserting everything you were typing, but you forgot to
precede the insertion with the letter I to tell TV you are doing
an insertion. Hence, when you typed the two ESCAPEs, TV started
executing the command string with the letter A from ANIMAL,
rather than I, which should have preceded it. The letter A as a
command tells TV to append a page from a file into the buffer.
Since there was no file from which to read anything, TV gave the
error message that it did, and immediately started waiting for a
new command, rather than even executing the rest of the typing
At this point, you should type:
The ;G command inserts the entire last command string into the
buffer that was longer than 15 characters. Hence by typing
;G$$, you tell TV to insert the pages you just finished trying
to insert, but failed because you forgot the I.
How to avoid repeating the editing you were doing, if the
system crashes before you've saved your work - the ;E Command.
Every character you type to TV from the time you start editing
to the time you finish, gets saved by TV on a special file.
This commands file is kept by TV on your own disk area (the one
you are connected to when you log in). The file has a name,
extension, and version number very similar to this:
The version number of the file is always 100000 plus your job
If the system crashes, and has been restarted, you can get
back to where you were in your editing session by telling TV to
use the contents of the commands file as typein. The main
command involved is the ;E command, but the entire procedure
requires some care. The following is a definition of what the
;E command does, followed by detailed instruction on how to get
back to where you were if the system crashes in the middle of
UNDOING BIG MISTAKES Page 6-3
causes the specified file to be read as typein instead of the
terminal, until the end of the file is reached, at which point
typein is redirected back to where it was before the ;E command
was given (usually back to your terminal).
Example of getting back to where you were after the system
has crashed and been restarted:
Steps in restoring after a crash:
1. DON'T START TV!!
2. Find out which commands file has the commands in it you
want to repeat
3. Rename the commands file to something else
4. Start TV
5. Tell TV to reread all the typing you had done before
the system crashed
Detailed explanation of the steps:
1. DON'T START TV!!
The first step in restoring, is not to run TV. Here's why:
Suppose that before the system crashed, you were logged in as
job 23. This means that the precious commands file you want to
have TV restore from is COMMANDS.TV.100023. When TV starts, it
erases the old commands file and starts a new one, so if you
just start TV, you will lose that commands file, if you are job
2. Find out which commands file has the commands in it you
want to repeat.
If you know what job number you were logged in as before the
system crashed, then you know which commands file is the
pertinent one. It's merely COMMANDS.TV.100000+n where n is the
job number. For instance, if you were job 14, the file is
In the more likely case that you don't happen to remember
what job number you were logged in as, the commands file is
probably the version of COMMANDS.TV in your area, which has the
most recent date and time associated with it. To figure out
UNDOING BIG MISTAKES Page 6-4
which that is, give the TOPS-20 VDIRECTORY command to see the
dates and times of all the commands files in your area. A quick
scan of the dates and times will show which file is the one
you're interested in. Here's an example:
The following shows what gets printed when you give the
@VDIRECTORY (OF FILES) COMMANDS.TV
COMMANDS.TV.100013;P777752;T 3 6710(7) 24-JUL-76 15:09:49
.100015;P777752;T 1 100(7) 24-JUL-76 15:10:53
TOTAL OF 4 PAGES IN 2 FILES
As you can easily see, COMMANDS.TV.100015 is more recent than
COMMANDS.TV.100013 (although in this case only by a minute and
four seconds!). Hence COMMANDS.TV.100015 is the file containing
the commands you want TV to repeat. If you're still not sure
it's the right one, issue the TOPS20 TYPE command to type out
the file. You should recognize its contents as looking much
like what you were typing before the system crashed.
3. Rename the commands file to something else.
The next step in restoring is to rename the commands file to
another name. The reason for this is to make sure that when TV
starts, it doesn't erase the commands file you want to restore
from. In this example, you rename it to FOO.BAR. The
typescript will look similar to this:
@RENAME (EXISTING FILE) COMMANDS.TV.100015 (TO BE) FOO.BAR
COMMANDS.TV.100015 => FOO.BAR.8 [OK]
Now file FOO.BAR contains the typein you want to to rehappen.
4. Start TV
Now that the typing to be redone is safely in a file that isn't
called COMMANDS.TV, you can safely start TV without fear of it
erasing the commands you want to have retyped. You should start
TV without specifying any file for editing, since the file you
really want to edit is named in the file FOO.BAR. Your
typescript for starting TV should look similar to this:
@R TV *
Tell TV to reread all the typing you had done before the system
The last step in restoring is to cause all that typing that you
did before the system crashed to rehappen. Give TV the ;E
UNDOING BIG MISTAKES Page 6-5
command like this:
That command tells TV to read FOO.BAR as typein. As it does so,
you'll see all the commands appear as they happen. When
commotion stops, it's probably done. To tell if it is, type the
letter A(or any other letter). If the letter you type appears,
then the restoring is done. If the letter you type doesn't
appear, then the commotion stopped only temporarily, and isn't
really done, and the letter should appear when it is.
When the restoring is done, you should probably type two
ESCAPEs, exit from TV with the ;X command, and restart by
running TV again. The reason for this is that the procedure for
restoring may be very complicated if another crash were to
happen before you've saved your work. When you do the ;X
command and TV types OUTPUT FILE:, type the correct file name of
the file you were originally working on. That probably ISN'T
FOO.BAR! Before typing the file name after OUTPUT FILE:, try
typing an ESCAPE. Very often that will cause the correct file
name to be typed for you. If it's wrong, type a Control-U and
type the correct name. Also, if the ESCAPE just causes the
terminal bell to ring, type the name yourself.
Note: There are two situations where the above procedure
is not sufficient to accurately reconstruct your work. The
first is if you have written out any files with a ;U or ;S
command during the edit. If this is so, you must edit the
renamed COMMANDS.TV file so that the latest copy of the file is
read in and then edited by the commands in the file. Also, if
there is Q register usage and a ;U or ;S command, the renamed
COMMANDS.TV file must be edited very carefully to make sure that
the Q registers are properly loaded. The second problem is that
some command characters sent to TV are interpreted differently
based on what video terminal type is being used. Therefore,
when using the ;E command, be sure that the terminal that you
are using is the same as the one which the ;E command's data was
UNDOING BIG MISTAKES Page 6-6
How to undo the mistake of accidently issuing a command
which wipes out the buffer, or otherwise destroys your work:
An overview of the steps involved to undo a mistake is as
1. Type Control-C to get out of TV.
2. Find the correct commands file.
3. Rename the correct commands file to another name.
4. Edit the commands file with TV to remove the erroneous
command(s) from the end of it.
5. Use ;E command to cause TV to quickly repeat all the
editing you had done before the mistake.
Now here's a detailed example. Suppose you have been editing a
file for awhile, and at some point you unintentionally issue the
This command means kill the whole buffer, and hence your entire
buffer is now gone. Here's how to get back your work without
1. Type Control-C:
The first step is to get out of TV WITHOUT causing the file
you've been working on to get updated. Control-C will get you
quickly back to TOPS20 command level. Your typescript will look
very much like this:
2. Find out the name of the commands file
Everything you've typed to TV since you started running it
(including the commands that you didn't really want to do) is in
a commands file called COMMANDS.TV.nnn where nnn is the version
number. To find out what nnn is, issue the TOPS20 INFO
FILE-STATUS command. The typescript should look like this:
@INFORMATION (ABOUT) FILE-STATUS (OF JFN)
CONNECTED TO <OSMAN>. JFNS:
4 COMMANDS.TV.100016;T NOT OPENED APPEND, EOF
3 TTY: APPEND, 0.(8)
2 <SUBSYS>TV.EXE.3 READ, EXECUTE
1 <SYSTEM>EXEC.EXE.305 READ, EXECUTE
DEVICES ASSIGNED TO/OPENED BY THIS JOB: TTY104
UNDOING BIG MISTAKES Page 6-7
From the output, you can see the correct commands file is
3. Rename the commands file.
Before restarting TV, it is important to rename the commands
file so that TV doesn't change it. For this example, assume you
rename it to FOO.BAR. Here's what the typescript should look
@RENAME (EXISTING FILE) COMMANDS.TV.100016 (TO BE) FOO.BAR
COMMANDS.TV.100016 => FOO.BAR.8 [OK]
4. Edit the commands file
You eventually want TV to reread almost all the stuff you
typed to it before. The part you don't want TV to read is the
bad command that caused the buffer to get ruined. So the next
step in recovery is to edit the commands file to remove the bad
command. Start editing it like this:
Don't forget the carriage return at the end of the line. After
TV has read in FOO.BAR, look at the end of the buffer for the
bad command you typed. It may not even be there, since when you
typed Control-C, TV may not yet have gotten a chance to save the
last few commands in COMMANDS.TV. If you find the bad command,
delete it and everything after it from the buffer.
Now save the buffer back into FOO.BAR with the ;U command. The
typescript is something like this:
OUTPUT FILE: FOO.BAR
Now FOO.BAR contains pretty much everything you typed before
making the big mistake (typing HK$$ or whatever it was you did).
5. Do a ;E command to get back to where you were before the
The last step is to tell TV to read FOO.BAR as typein, in order
to repeat everything you had done before your mistake. Type
;EFOO.BAR$$. The typescript should look like this:
You'll see everything being redone right before your eyes.
UNDOING BIG MISTAKES Page 6-8
At this point, you should probably type two ESCAPEs, exit
with a ;X command, and restart TV. The reason for this is that
the recovery for second and subsequent errors is more
complicated. When you do the ;X command and TV types OUTPUT
FILE:, type the correct file name of the file you were
originally working on. That probably ISN'T FOO.BAR! Before
typing the file name after OUTPUT FILE:, try typing an ESCAPE.
Very often that will cause the correct file name to be typed for
you. If it's wrong, type a Control-U and type the correct name.
Also, if the ESCAPE just causes the terminal bell to ring, type
the name yourself.
How to recover from running out of disk space quota when
writing out a file with a ;X or ;U command:
1. Get under quota by either "expunging" your directory or
by deleting some files that you no longer need and then
expunging them (especially multiple generations of
files). Or, by connecting to another directory in your
user group that has some spare file space.
2. Type "CONTINUE" to TOPS-20. TV will then finish
writing out the file.
Rename your COMMANDS.TV file and arrange to get more quota, then
follow the procedures mentioned earlier in this chapter and use
the ;E command to repeat your work.
MORE ON SEARCHING
Here are more details about the search facilities in TV:
TV allows the search (S) and replace (R) commands to take
negative arguments. A negative argument tells TV to search from
the pointer towards the beginning of the buffer rather than the
end for the given string, and to leave the pointer in front of
the string if it finds it. example:
instructs TV to replace the last three occurences of "this" with
"that" and leave the pointer just before the first of the three
TV remembers the last string searched for by any of the
following commands: S, R, _ (backarrow), and N.
If any of these commands are issued with a null string
argument, the remembered string is used. For instance, if the
last search command was
then the command
Will advance the pointer forward to just beyond the next
occurence of the string "this" as though you had again typed
If you have just searched for a string and the pointer is
now sitting just beyond it, you may cause the string to be
deleted with the command
MORE ON SEARCHING Page 7-2
This works because the null first argument to the replace
command tells TV to default it to the last string searched for,
and the null second argument says that the new string to replace
the first is an empty string.
If you have just searched for a string so that the pointer
sits to the right of it, and you'd like to back the pointer up
to before the string, the command
Will do it.
The colon modifier allows the replace and search commands
to complete multiple searches or replacements without aborting
them all when the command fails due to having run past the end
of the buffer. The general form is
This command replaces n occurences of "string1" by "string2",
searching forward for positive n and backward(towards the
beginning of the buffer) for negative n. The entire command
returns a value of -1 if it succeeds and 0 if it fails. As an
example, if you want to correct all the mispellings of the word
"receive" in your buffer, you could do it by issuing:
This command string tells TV to position the pointer at the end
of the buffer and search backwards changing "recieve" to
"receive" every place it occurs. The numerical argument in this
case is z which stands for the number of characters in the
buffer, so is guaranteed to be large enough to cause every
occurence to be found.
Atsign delimiter modifier
The atsign modifier indicates that you want to use a string
delimiter other than escape for this replace command, probably
because escape is to be one of the characters in one or both of
the replace string arguments. As an example, to ask TV to
change the next three occurences of the letter "a" in the buffer
to escapes, the following command string will work:
MORE ON SEARCHING Page 7-3
In the above command string, the slash is the string delimiter
instead of escape. Whichever character is placed immediately
after the @R command is used as the replacement delimiter
instead of escape.
The control-X command in TV selects whether character
strings should match without regard to their case. The command
Sets the search mode to "don't care" which means that the case
of letters doesn't matter in searching. For instance, if you
ask TV to search for a capital "d" in "don't care mode", a small
"d" will match the search also. This is the default mode when
TV is started. To cause only exact case matching, change the
search mode to "exact" with the command
The control-X command issued without an argument returns
the current value of the search mode (which will never change
except by way of a control-X command issued with 0 or 1). So if
you forget which search mode is prevailing, you may ask TV by
One warning about this command; Don't try typing the control-X
as the first character in the command string because it is the
same code as the right arrow button on the VT05, and will move
the buffer pointer to the right one character.
COMPLETE LIST OF TV COMMANDS
1. The abbreviation "arg" stands for argument. Commands
taking arguments use the current value as their first
argument if there is no other specific argument given.
2. Commands are listed in ASCII code numerical order.
3. Uparrow (^) in front of a character (^a for example)
represents the character sent to TV when you press the
"Control" key and a letter key at the same time.
4. Lower case and capital letters as commands are
equivalent. For instance, a lower case g is the same
command as an upper case g, and SG$$ gives the same
result as Sg$$. (See the control-X command for
information on how to differentiate between upper and
5. Commands when used in this chapter are capitalized.
Small n represents an arbitrary number.
Control-A Takes text after it and types it out. Use an escape
as the text terminator.
COMPLETE LIST OF TV COMMANDS Page 8-2
Causes control to be transfered to location 770000, which
is should be the starting address of DDT. If DDT has not been
preloaded, this command will cause TV to get an error.
Control-e sets the current value to that of the Formfeed
switch. The switch is -1 if the last character read in from an
input file was a Formfeed (control-L), and the switch is 0 if
that last character was anything else.
If you type two control-g's during command string typin,
the entire command string typed so far is deleted, and you may
start it over. Typing control-g during command string execution
aborts that command string. as a command, typed in as
uparrow-g, control-g causes control to return to TOPS-20. If
you then type "continue" to TOPS-20, you may type in another
Sets the current value to that of the high precision system
realtime clock. For instance, Control-H=$$ causes a value of
the clock to be printed on the console.
[Control-H has a second interpertation if it is the first
character typed in a command string; If the editor does not
think it is running on a VT05 terminal, typing control-H (which
is probably more conveniently the backspace key) as the first
character in the command, causes a "-LT" command to be
immediately simulated. If the editor thinks it is running on a
VT05, control-H causes a "-C" command to be immediately
simulated, again only if the control-H is the first character in
the command string. The reason for this difference is that the
large left-arrow button on the VT05 sends the same code as
backspace, and the four buttons are convenient for moving the
pointer. The effect is to move the pointer on the screen one
character to the left.]
Inserts itself and text following it to the next escape
into the buffer.
COMPLETE LIST OF TV COMMANDS Page 8-3
Linefeed typed immediately after the prompt causes an LT$$
command to immediately be executed. If a non-zero window size
is in effect, as is probably the case if you are on a video
terminal, the "T" part doesn't happen, which is fine because you
will see the pointer on the screen. As a command, linefeed
erases any current value.
Control-K is only meaningful as a command if the editor
thinks it is running on a VT05. If so, typing the large
downarrow button as the first character of a command string
causes an immediate "L" command to be executed, the effect of
which is to move the pointer one line down on the screen. the
downarrow button happens to send the ASCII code for control-K,
and thus control-K may be typed instead of downarrow for the
Control-L (Formfeed) Clears screen.
(Carriage return) Clears any current value.
Means "not" within search strings. See the s command.
Control-O causes output to be discarded until another
control-O is typed.
The Q stands for quote. control-Q typed during command
string typin causes the next character typed not to have certain
effects it may otherwise have during command string typin. For
instance, to prevent an escape from immediately starting command
execution, precede it by a control-Q. as another example, to
cause a control-Q to get into the command string, type two of
them! A control-Q in a search string causes the next character
not to have some magic meaning that it might. Some characters
to watch out for in this respect are control-S, control-X,
control-N, escape. See the description of the S command.
COMPLETE LIST OF TV COMMANDS Page 8-4
During command typin, control-r causes the current line to
Means "separator" in search strings. See the s command.
Note: if terminal page is set by TOPS-20, control-S will stop
all output from being sent to your terminal. To use this
command, type "terminal no page" to TOPS-20 before running TV.
(OR, if in TV already, type control-C, then terminal no page,
This is control-T, but you have to type it in as uparrow
followed by a t, or else TOPS-20 will immediately intercept it.
Control-t waits for a character to be typed and sets the current
value to that character's ASCII value.
A control-U typed during command string typin causes the
current line being typed in to be erased. If you type it when
already at the beginning of a line (usually because you just
typed a return or another control-U), the previous line is
Control-X is a string match character and a command. As a
command with no argument, it sets the current value to the value
of the search mode. The search mode defaults to zero which
means letters in searches match to either case. A non-zero
setting causes searches to only match to the exact case.
If TV is running on a VT05, control-X as the first
character in the command string causes an immediate "C" command
to be executed. On the screen, the effect is for the pointer to
be moved one character position to the right. the reason for
the obscure control letter, is that the VT05 large right-arrow
button sends the ASCII code for control-X.
COMPLETE LIST OF TV COMMANDS Page 8-5
Control-z is only meaningful on VT05s, on which the is the
large up-arrow button. If the editor thinks it is running on a
VT05, hitting the large up-arrow button causes an immediate "-L"
command to be executed, the effect of which is to cause the
pointer to move one line up on the screen. This only works,
however, if the up-arrow is the very first character in the
If you merely type two escapes, it causes command execution
to start immediately. escape ends text strings for the many
commands that take a text string argument. escape echos as a
dollar sign. as a command, escape clears the current value.
Sets the current value to the ascii value of next character
in the command string.
Space is the same as +. It performs Addition. For
instance, the command string 3 4= causes 7 to be printed. (that
was "three space four equals").
Characters between exclamation points as a command does
nothing. hence this is a way to insert comments into command
strings (for instance if the command string is to be saved for
future execution, this is a useful way to document it. Also see
the O command (the letter).
COMPLETE LIST OF TV COMMANDS Page 8-6
This is a double quotemark, and is used for conditionally
executing portions of command strings. It takes a letter after
it, and an argument before itself, and if the argument meets the
conditions imposed upon it by that letter, the portion of the
command string after the letter is executed. If the argument
does not meet the conditions imposed by the letter, the part of
the command string after the letter up to and including a
matching apostrophe is not executed, and command execution
continues after the apostrophe. The matching feature is that a
quote-apostrophe pair may appear "nested" inside another one,
and the apostrophe refering to the inner quote is not confused
with the one ending the outer quote. The implemented letters
are: l e g n which stand for "less than zero ", "equal to
zero", "greater than zero", and "not equal to zero. So for
instance, to kill the next character in the buffer only if it is
a capital letter, the command string 1A-100."G1A-133."lD'' would
This means inclusive or. For instance, the string 1#5 sets
the current value to 5.
Dollar sign clears the current value.
Percent sign takes a Q-register name after it, causes the
numerical contents of that Q-register to be increased by one and
stored back into that Q-register. The current value is set to
the new contents. for instance, %T= causes the contents of
Q-register T to be increased by 1, and the new value to be
This is logical and. It causes the value of the
expressions on each side of it to be anded bitwise and sets the
current value to the result. For instance, the command 2&1UE
causes the contents of Q-register E to be set to zero.
This is an apostrophe. If executed as a command, it just
clears the current value, but see the " command for more.
COMPLETE LIST OF TV COMMANDS Page 8-7
Are both used for the "regular" mathematical purpose, that
of changing the order of execution of a string of functions.
for instance, 2+3*4 represents 20, but 2+(3*4) represents 14.
This means multiplication.
Addition operator. Also see space.
This is a comma, and you use it to separate the arguments
for commands that use two arguments. For instance, the command
.,.+5T causes the first five characters after the pointer to be
This is a dot or period and as a command sets the current
value to the character position of the pointer. For instance,
the command .= causes the position to be printed out; the
command .U1ZJIfoo$Q1J causes the string foo to be appended to
the end of the buffer, and the pointer to not change positions.
A dot at the end of an integer causes the digits of the integer
to be interpreted as octal digits. For instance, the command
10.= causes 8 to be printed.
A colon preceding certain commands slightly changes their
funcion. see specific explanations under the S, R, K commands.
COMPLETE LIST OF TV COMMANDS Page 8-8
This is a semicolon, and its function depends on what
character follows it in the command string.
Closes the output file, without causing any more output to
Causes a heading to be put at the beginning of the buffer,
and then does a ;U. The heading shows the name and version
number of the file being written, who you are that is creating
the new version, and the current date and time. This entire
header line is prefixed with a semi-colon, so that the macro
assembler and other programs that use semicolons for comments
will ignore it.
This is the "execute" command. It must be followed by a
file name of an existing file, and then one or two escapes. It
causes the contents of the file to be used as the type-in to TV
until the end of the file, at which point the type-in again
comes from wherever it did before the ;E command was issued
(probably your terminal).
This is the same as _(left arrow or underscore).
This command gets the last command string that was longer
than 15 characters and inserts it into the buffer immediately
before the pointer. This is often useful if you have just
attempted to insert a large amount of text, and you terminate
the command string and receive some error message which causes
you to realize that you forgot to type an I before the text. At
this point you can do a ;G command to retrieve the text.
This command causes an immediate exit back to the TOPS-20.
If you then type "CONTINUE" to the TOPS-20, you will be back at
command string input level.
COMPLETE LIST OF TV COMMANDS Page 8-9
The M stands for "macro". This command causes a file's
contents to be loaded into a Q-register. The Q-register name
must follow the ;M in the command string, and the file name
followed by an escape must follow the Q-register name. For
instance, to load the file foo.tec into Q-register P, you
execute ;MPfoo.tec$. Also see the Q, X, M, G, and U commands.
This picks up a number from the buffer and sets the current
value to that number. If an argument precedes ;N, the number is
interpreted in the base of that argument. The pointer is
repositioned immediately after the number. If no number is
immediately after the pointer when the ;N command is
encountered, the pointer is not moved, and the current value is
set to zero.
The P stands for "pick up". This command causes the
current value to be set to the ASCII value of the character
immediately after the pointer, and then the pointer is moved one
character towards the end of the buffer. As an example, the
following is a command string which will print out the sum of
the ASCII values of all the characters in the buffer:
COMPLETE LIST OF TV COMMANDS Page 8-10
This command causes a file to be open for reading. That
is, it causes a file to become the input file, the one open for
input. The file actually opened is the one with the file name
specified immediatelyafter the ;R in the command string and
followed by an escape. For instance, ;Rfoo.bar$ opens the file
foo.bar for input.
If issued without arguments, the ;S command saves the
entire buffer in a file without changing the buffer or the
pointer. it may also take arguments like the T, K, X etc.
commands in which case only the specified portion of the buffer
is saved. for instance, the command 4;S saves four lines of
text starting from the pointer. If a file is open, TV
automatically uses that file. Usually this command is issued
without an output file already being open, in which case you are
asked for which file name to use. ;S closes the output file
after it is through.
This command types out text. If the letter Q followed by a
Q-register name precedes the ;T in the command string, the
contents of that Q-register is typed. If not, the text
immediately after the ;T in the command string up to the next
escape is typed. for example, the command string QW;T causes
the text in Q-register W to be typed out. The command string
;Thello there$ causes "hello there" to be typed.
The U stands for unget or unload. This command causes the
entire buffer to be written on the file open for writing, and
that file is then closed, and the buffer is cleared. If no file
is open for writing when this command is encountered, you are
asked for which one to use. Your answer is remembered, so on
successive ;U or ;Y or ;D commands, if you want to use the same
file name as last time, you may answer the question with an
escape or a carriage return. the difference between escape and
carriage return is that the escape causes the name that will be
used to be typed out to you to prove to you that it was really
remembered. however, you will still have to type a carriage
return after that to make the buffer get stored away.
COMPLETE LIST OF TV COMMANDS Page 8-11
This command takes an immediately following file name
followed by an escape and opens that file for output. That is,
the supplied file name is used to open a file for writing. For
instance, ;Wbar.foo$ causes the output file to be bar.foo.
The X stands for exit. This command causes a ;U to happen,
and then an exit back to the EXEC happens. If you then type
"continue", any commands originally typed after the ;X in the
command string are executed.
The Y stands for yank. This command causes an entire file
to be read into the buffer, and for that file to then be closed.
if no file is open for reading when this command is executed,
you are asked which one to use. See the ;U command for more
details about answering the question. The file read in is
appended to the end of any previously existing text in the
buffer. After the file is read in, you are informed of the new
total number of characters of the buffer.
This is a semi-colon followed by a real space, not the word
space. This command is only legal inside iteration brackets.
(see "<" below).
With a non-negative argument, it causes command execution
to be diverted out of the current iteration loop to the command
immediately after the closed interation bracket. A negative
argument causes nothing to happen. This definition makes it
convenient to use the ;<space command as a means of exiting from
an indefinite iteration loop if a search or replacement fails.
For instance, here is a command string which will type out all
the lines in the buffer containing the word love: 0J<:Slove$;
L-T>. If there is no argument for the ;<space command, the
value of the last "colon" search or replacement is used.
COMPLETE LIST OF TV COMMANDS Page 8-12
This is a less-than sign, and starts an iteration loop. It
causes the entire command string portion following it and before
a matching greater-than sign to be executed a multiple number of
times. If an argument precedes the less-than, the loop is
executed that many times. Without an argument, the loop is
executed an indefinite number of times, and thus will never stop
unless some command within the loop causes execution flow to
leave the loop or the command gets an error, for example, when a
This is an equals sign. As a command it causes the current
value to be typed out in decimal. For example, the command Z=
causes the number of characters in the buffer to be typed out.
This is two equal signs right next to each other. It
causes its argument (the current value) to be typed out in octal
(base 8), with an octal point to remind you that the number is
an octal one. for example, to find out what 1000 in octal is,
you could type 1000==.
This is a greater-than sign. It stands for the end of an
iteration loop. See the < command above for more details.
This is a question mark. This command toggles trace mode.
Trace mode is initially off. (toggles means if trace mode is
on, then ? turns it off, and if it is off, then ? turns it
on.) in trace mode, commands are typed out as they are executed.
This is an atsign, and it may precede an R, I, S, J and
maybe other commands, in order to modify these commands. See
each individual command for more info.
With an argument, "A" sets the current value to the ASCII
value of the character immediately after the pointer. Without
an argument, "A" appends some more of the file open for input on
to the end of the buffer. Data is appended until either a
control-L is read (end of page), or the buffer is within 128
characters of being full and a linefeed (end of line) has been
read in, or the buffer is two thirds full or end of file is
reached, or the buffer is completely full.
COMPLETE LIST OF TV COMMANDS Page 8-13
Stands for the number 0, the mneumonic "beginning"; for
instance the command BJ puts the pointer at the beginning of the
Moves the pointer argument characters to the right, with
argument equals 1 implied if none supplied. -C means -1C and
moves the pointer one character to the left and so on.
D Deletes argument characters. Positive argument deletes to the
right of the pointer, and negative deletes to the left of the
pointer. D and -D mean 1D and -1D respectively.
Puts the pointer at the end of the n-th line before the
carriage return (where n is the argument) from the current line.
No argument implies zero which puts the pointer at the end of
the current line. -1E puts the pointer at the end of the last
line. 1E puts the pointer at the end of the next line and so
F is just like S except if the search fails, a P command is
executed, and the search continues. This is the same as the N
Takes a Q-register name after it and inserts before the
pointer the text that was previously stored in that Q-register
(gets the text out of the Q-register).
Stands for B,Z which if used in front of many commands
references the whole buffer. For instance HK to kill the whole
buffer or HV to display the whole buffer.
This is the same as the PW command. It writes out the
entire buffer and waits.
With an argument, I inserts the character with the ASCII
value of argument into the buffer. For instance, 177.I inserts
a rubout; 3I inserts a control-C. With no argument, I inserts
before the pointer all of the text following the I up to but not
including the next escape. @I (atsign I) lets you use a
COMPLETE LIST OF TV COMMANDS Page 8-14
character other than escape as the delimiter. @I takes the
character after the I as the text delimiter and inserts before
the pointer all the text after that character and before the
next one. For instance @I/X$X/ states that the three characters
X, escape, X are to be inserted, assuming $ is an escape.
nJ puts the pointer after the n-th character in the buffer
(jumps to the n-th character) where n is the value of the
argument. J and 0J and BJ all put the pointer at the beginning
of the buffer. ZJ puts the pointer at the end. If the J is
preceded by @, and you are using the screen window facility, the
@J command moves the pointer in the buffer such that it is
positioned in the middle of the current window.
Kills text from the buffer. K implies 1K. nK kills n
lines from the buffer. Specifically, nK kills characters from
the one after the pointer through the nth linefeed after that
inclusive if n is positive. If n is negative, nK kills the text
from the character after the one plus minus Nth one before the
pointer through the character before the pointer inclusive.
With standard text organized as lines, if the pointer is at the
beginning of a line, this all means nK kills the next n lines
after the pointer if n is positive, and the n lines right before
the pointer if n is negative. As examples, 0K kills the current
line through the character before the pointer; 0LK kills the
current line; 3K kills the rest of the current line after the
pointer and two more lines after that. The command n:K causes
one less crlf (carriage return and linefeed) than nK would kill,
to be killed. Hence just executing :K causes the rest of the
current line not including the crlf to be killed.
With two arguments, (n and m for this example), n,mK kills
the n-th character through the m-th character in the buffer.
For instance, B,1K kills the first two characters in the buffer,
HK kills the whole buffer, .,.+5K kills the first five
characters after the pointer.
Takes one argument interpreted like the K command and moves
the pointer. For instance, 0L puts the pointer at the beginning
of the current line; L or 1L puts the pointer at the beginning
of the next line, -L or -1L puts the pointer at the beginning of
the last line, 3L moves the pointer down three lines, -5L moves
the pointer up 5 lines. :L puts the pointer at the end of the
COMPLETE LIST OF TV COMMANDS Page 8-15
Stands for macro. It takes the next character as a
Q-register name (see X command) and causes the text in that
Q-register to be executed as a TV command string. An argument
is passed through to the command string being executed, so if
for instance Q-register Y contained the command K, then the
command 4M would kill four lines.
N is just like S except if the search fails, a P command is
executed, and the search continues.
The O command stands for goto, takes a tag name after it
ended with an escape, and causes command execution to go to the
command following the occurence of the named tag in the buffer.
Tags in the buffer are characters delimited before and after
with exclamation marks. For instance, the command string
!foobar!Ia$Ofoobar$ is a way to insert an infinite number of a's
into the buffer.
Stands for page. With one argument, does argument<PWHKY>.
With two arguments, n,m for example, writes out the characters
from the n-th one through the m-th one in the buffer inclusive.
As examples, HP writes the whole buffer out, 3P writes the page
that is in the buffer out, and also writes the next two pages
after that out; the page after those is left in the buffer. No
argument implies that the argument equals 1, so just issuing P
causes the page in the buffer to be written out and the next one
to replace it in the buffer.
Is the same as HP, it writes the entire buffer out and
waits (as opposed to changing the buffer like P would).
Takes a Q-register name after it and sets the current value
to the number stored in that Q-register. (see the U and %
commands). for instance Q6= causes the contents of Q-register 6
to be printed out. QSL would move the pointer forward (down the
screen) a number of lines equal to the number in Q-register S.
COMPLETE LIST OF TV COMMANDS Page 8-16
This is the replace command. It takes two text strings
after it, each delimited by escapes, and replaces occurences of
the first string by the second string. The assumed argument
when none is supplied is 1, and the number of replacements that
are made is the absolute value of the argument. Positive
arguments cause occurences after the pointer to be replaced, and
negative arguments cause occurences before the pointer to be
replaced. The pointer is left after the last replacement if the
argument was positive, and before it if the argument was
A delimiter other than escape may separate the two strings
by typing an @ (that's an atsign) before the R command, and
designating the delimiter of your choice immediately after the
R. To allow your command string to do its own replacement
failure handling, put a :(colon) before the R command. Without
the colon, if the replacement fails (because it couldn't find
enough occurences of the given first string), an error message
is printed and command execution ceases just like a failing
search command. The colon causes the R command to set the
current value to -1 if it succeeded, and 0 if it failed.
Here are some examples:
Rmake war$make love$ will replace the first occurence after
the pointer of the string "make war" by "make love".
J:ZRrecieve$receive$ will correct all of this spelling error
in the buffer.
-R,$$ will delete the first comma found scanning towards the
beginning of the buffer from the pointer.
In general, to delete a particular string from the buffer,
This is the search command. It searches for the string
supplied after the S and delimited by escape. The S command
searches for the N-th occurence of the specified string, where N
is the absolute value of the numerical argument in front of the
S. One is implied if no number is specified. The sign of the
numerical argument determines which direction to look from the
pointer for the string. Positive argument means search towards
the end of the buffer, and negative means search towards the
beginning. if the search fails (because the string couldn't be
found the requested number of times), the pointer is left as it
was. If the search succeeds, the pointer is positioned after
the string found if the argument was positive, and before the
string if the argument was negative. If no text string is
supplied, as in S$ or @Saa for instance, the same text string as
in the last search is used. So for instance, if you just said
Sfor$, and you decide that wasn't the "for" you were looking
for, and you think you are actually looking for one that's
before where the pointer was when you originally said Sfor$, you
COMPLETE LIST OF TV COMMANDS Page 8-17
can now say -2S$ to find a for before where the pointer was.
The character control-N in a search string means not, and causes
any character that isn't equal to the character after the
control-N to match. So for instance to find the third occurence
of an x that is not followed by a z, you could issue 3SxNz$.
The character control-S stands for separator, and matches to any
separator character. Separators are items such as puncuation,
carriage returns, parentheses, and most other non-digit or
non-Letter characters. So to search for an occurence of the
letter a that isn't part of a longer word, you could do SSaS$.
Or to search for a four-Letter word starting with t and ending
with e, try SStNSNSeS$. This asks for a separator followed by t
followed by two non-Separators followed by e to be sought.
Control-X stands for any character.
If you want to delimit the string with a character other
than escape, put an @ (atsign) before the S and your desired
delimiter after the S, then your string, and then your delimiter
again. For instance, the command @S=$= will search for an
escape. The search command may also be preceded by a colon.
The colon prevents failing searches from typing an error
message. Instead, the current value is set to -1 or 0 depending
on whether the search succeeded or failed respectively. This is
convenient in iteration loops in conjunction with the semi-colon
command. (see them both). as an example, the command
-3@:S]fat]$= will cause the pointer to be positioned before the
third fat searching towards the beginning of the buffer if three
are to be found. If so, -1 is printed on the teletype. If
three are not there to be found, the pointer is not moved and
zero is printed.
This command interprets its arguments like the K command,
but types part of the buffer rather than deleting it. This
command is not often needed while the screen is being used,
since the buffer is automatically displayed.
This command takes a Q-register name after it and stores
the current value in that Q-register. The Q-registers are named
with single letters or digits, and each may contain an integer
number or a piece of text. For instance, the command 3ue stores
the number 3 in Q-register E. The command .UA causes the
location within the buffer of the pointer to be remembered in
Q-register A. ZU1 causes the total number of characters within
the buffer to be remembered in Q-register 1. (see the percent
command, the Q command, the X command, and the G command for
more Q-register commands.)
COMPLETE LIST OF TV COMMANDS Page 8-18
This command takes arguments like T and causes part of the
buffer to be displayed on the screen. This is usually
implicitly done in some sense following execution of command
strings to show you the final state of the buffer. For
instance, HV will cause the whole buffer to be displayed. .,ZV
will cause all the buffer from the pointer to the end to be
displayed. -5V will cause the last 5 lines to be displayed.
This is the word command. The W may be preceded by an
argument if the word following the W may optionally take an
argument. The general form of the command is nWsomething$ where
$ is escape, something is any of the words defined below, and n
is an optional argument. Actually, only enough of the word must
be typed to cause it to be unique. Here are the currently
defined word commands:
To get a list of all the currently defined words, use this
This command tells the editor that you are working on a
VT05. The command isn't needed if the system already knows you
are, which it will if you type the "TERMINAL VT05" TOPS-20
command before running the editor.
This command tells the editor that you are working on a
VT50. the command isn't needed if the system already knows you
are, which it will if you type the "TERMINAL VT50" TOPS-20
command before running the editor.
This command tells the editor that you are working on a
VT52. the command isn't needed if the system already knows you
are, which it will if you type the "TERMINAL VT52" TOPS-20
command before running the editor.
This turns on the backup system. This command isn't
necessary unless the backup system has been turned off by
WNOBACKUP$. See the description of the backup system after the
COMPLETE LIST OF TV COMMANDS Page 8-19
This turns off the backup system. From the point this
command is given until the next time the WBACKUP$ command is
issued, no type-in logging is done.
When backing up is in effect, this command may be used to
set or determine how many characters TV lets you type before it
appends them to the backup file. If you precede the command
with an argument, the command sets the number of characters to
that amount. If you don't supply an argument, the current
setting is returned.
Issuing this command causes all lower case characters to be
flagged with an apostrophe when they are displayed.
This causes uppers to be flagged (see WFLAGLOWERS$).
This command causes no characters to ever be flagged with
an apostrophe when they are displayed.
This command causes all typed in upper case letters to be
turned into lower case ones as they are typed. While in this
mode, letters typed in preceded by an uparrow (the character
with ASCII value 137, which looks something like ^) will be
regarded as upper case letters.
Causes all lower case letters typed in to be raised to
upper case as they are typed. This setting is usually the
default setting, as the settings default to whatever TOPS-20 has
them set to (see the "information about terminal-mode command in
the TOPS-20 User's Guide). TV reads whether or not to raise
characters when you initially start running it, which is why
typing control-C and then "TERMINAL RAISE" and "CONTINUE" will
not have the desired effect.
This command causes all upper case and lower case
characters to be accepted as is; they are not converted at all.
COMPLETE LIST OF TV COMMANDS Page 8-20
This command anounces by way of a preceding argument how
many characters physically fit across your terminal. If you
don't supply an argument, this command returns the number of
characters that currently fit on one terminal line.
This command returns the current screen size setting, if
issued without an argument. With a preceeding argument, it sets
the screen size. Be careful not to set the screen size to
anything other than the true number of lines that fit on your
screen before scrolling occurs, or screen updating will not
happen properly. Normally, this command is not needed. Note:
for setting the number of lines used for displaying the buffer,
To set the number of lines used to display the buffer, use
nWWINSIZ$ where n is the desired number. WWINSIZ$ without an
argument returns the current setting.
This command causes line numbers not to be stripped from a
file as it is read into the buffer. If you wish this option,
you must issue this command before instructing TV to open your
file. The command is mainly provided for editing programs for
"BASIC", for which the line numbers are part of the program.
This command is only necessary if a previous WEDITBASIC$
command has been issued. WEDITREGULAR$ puts the file read-in
mode back into regular mode, which causes line numbers in files
to be stripped off as the file is read into the buffer.
This command takes arguments like T or K and stores that
portion of the buffer in the Q-register whose name follows the X
in the command string, and then deletes that portion of the
buffer. This is useful for moving text from one part of the
buffer to another. For instance, 5XC stores 5 lines of text in
Q-register c and deletes them from the buffer; 0lXA stores the
entire current line in Q-register c and deletes it from the
buffer; .,.+20XA takes the next 20 characters after the pointer
from the buffer and inserts them into Q-register A. Using : in
front of an X command in addition to a numeric argument causes
the rest of the line that the pointer is on except the carriage
return to be deleted from the buffer and inserted into the named
Q-register. For example, :XA takes the remaining part of the
buffer from the pointer up to the carriage return, and puts it
COMPLETE LIST OF TV COMMANDS Page 8-21
in Q-register A, deleting it from the buffer.
This is the yank command. It does an HK (clears the entire
buffer), and then reads the next page from the input file into
the buffer. More precisely, data is read until any one of the
following things happens:
1. An end of page (Formfeed, which is control-L) is read.
2. The end of the input file is reached.
3. An end of line (linefeed) is read in and the buffer is
within one third or 128 characters of being full.
4. The buffer is full.
Z stands for the number of characters in the buffer. So
for instance, ZJ will jump the pointer to the end of the buffer,
and Z= will cause the number of characters in the buffer to be
This causes the contents of the Q-register named by the
next character in the command string to be pushed onto the
Q-register pushdown stack. The stack is always cleared at the
end of a command string execution, so if you plan to retrieve
any data that was pushed with [, you must pop it with ] before
the end of the command string.
This is the integer to text conversion command and vice
versa. With an argument, it causes the argument to be inserted
as text into the buffer. Without an argument, it causes the
part of the buffer immediately after the pointer to be read as
an integer, and the pointer is positioned after the integer, and
the integer is stored as the current value. For example, the
command -45\ will cause the three characters -,4, and 5 to be
inserted into the buffer just as though you had issued the
Q3\ will insert into the buffer the integer stored in Q-register
3. To insert a column of integers from 1 to 100 inclusive, you
This command string says store 0 in Q-register s, then iterate
100 times on the command string which says increment the
contents of Q-register s, leave the new value in s, insert the
value into the buffer, and insert a carriage return and
COMPLETE LIST OF TV COMMANDS Page 8-22
This command pops the top entry in the Q-register pushdown
stack back into a Q-register, the name of which is specified as
the character after the ] in the command string. So one way to
move the text from Q-register 9 into Q-register 8 is to do the
command 8, which says push what's in 9, and pop it into 8.
You could exchange the contents of Q-register's A and B with
This is an uparrow. If typed as the first character after
the prompt, it causes a -LT$$ command to be executed. However,
if a non-zero window size is in effect, as is probably the case
if you are editing on a video terminal, the "T" doesn't happen,
but you will see the screen be updated in response to the ^. If
followed in the command string by a letter, it causes the
control character of that letter to be executed. For instance,
an uparrow followed by an A is the same as a control-A. If you
are in wlower$ mode (you might look that one up !), letters
typed in preceded by an uparrow are regarded as upper case
letters. while in this mode, to actually indicate an up-arrow,
type two of them.
This is a backarrow. It is a search command and works just
like the N command except that pages are not written out into
the output file as they are passed over.
To delete the most recent character typed into the command
string, type a delete or rubout (depending on the terminal's
DIFFERENCES BETWEEN TECO AND TV
Here are the main differences between TECO and TV:
1. TV has a screen window feature. This means that while
you're editing on a screen terminal, the screen shows
your work as you do it. Hence you rarely need to issue
any special command directing TV to type out a portion
of the work. When working on computer programs, you'll
find yourself making far fewer lineprinter listings of
the program, since the screen is showing you the
program's current state.
2. Usually, when editing a file with TV, the entire file
is read into the editing buffer at once, as opposed to
TECO, in which pages are edited one at a time. An
advantage of having the file completely in the buffer
at once is that no commands for doing file I/O are used
during editing. This means that it's very difficult to
accidentally make a page or more inaccessible for
editing. Also, the file can be edited in any order you
like; you needn't edit the first page first, etc.
3. TV features a backup system which allows you to never
lose more than 50 characters of typing in even the most
catastrophic situations, the most common of which
include the system crashing or you accidentally erasing
a large portion of the buffer.
4. The R command means replace. Use -C to move the
pointer "left" one character.
5. Most of the standard TECO "e" commands are implemented
as ";" commands in TV. The standard TECO ";" command
is entered as a semicolon followed by a space in TV.
6. The X command causes the text stored in the Q-register
to be deleted from the buffer, because usually you do
an X command because you want to move text to somewhere
else in the buffer.
DIFFERENCES BETWEEN TECO AND TV Page A-2
7. The S and R commands may take negative arguments. See
8. If a search fails, the pointer is not moved.
9. Searches within iterations are not colon searches by
default. so use the colon if you plan to use the
semicolon-space command within iterations.
10. The semicolon command in TECO is replaced by ;<space.
Incompatibilities with VTECO:
[VTECO is an earlier version of TV without screen
1. TV uses two escapes to end command strings, whereas
VTECO requires you type only one.
2. Control-V: In VTECO, control-V is the quoting
character. In TV, control-Q is the corresponding
quoting character. This is mnemonic as "quote" begins
OCTAL INPUT AND OUTPUT
Typeing two equal signs after a value-returning command
causes the value to be typed out in octal instead of decimal.
In TV, orthagonal to the rest of the world, octal numbers are
followed by an octal point, and decimal numbers have no point at
all. As an example, to ask TV for the ascii value of the
character "*", the following command string will do it:
That's "control-uparrow star equals equals escape". Remember,
the control- uparrow command takes the next character from the
command string and returns that character's ascii value.
Knowing that the ASCII value for rubout is 177, you can
easily put one in your buffer with the command
To ask TV what 2 to the nineteenth is, you may ask
The octal point tells TV that you are typing in an octal
integer, and the single equal sign asks for that integer to be
printed out in decimal.
MORE INFORMATION ON SCREEN HANDLING
These correspond to the four arrow buttons way over on the right
on the VT05, VT50 and VT52. They are only meaningful if typed
as the first character of a command string, which causes them to
have im- mediate effect rather than the usual "wait for escape"
before "doing" anything.
The left arrow is equivalent to "-C$$". The pointer is moved
one character position "to the left" and the consequences will
be seen immediately on the screen.
The right arrow is the same as "+C$$"; the pointer is moved one
character to "the right".
Down arrow is the same as "1L$$". The pointer is put at the
beginning of the next line.
Up arrow is equivalent to "-L$$". The pointer is moved to the
beginning of the last line.
MORE INFORMATION ON SCREEN HANDLING Page C-2
If control-C is typed interrupting TV, TV may be reentered with
the TOPS-20 "reenter" command. When TV is reentered, it assumes
no knowledge of the current status of the display screen, and
thus refreshes the entire screen. However, if you were in the
middle of an I command, you should use the "continue" command
and then type two escapes to finish the insert and see the
About the display:
After most TV commands, TV attempts to display the buffer from a
few lines before the pointer until the end of the buffer. When
a displayful is done, TV types --more-- at which point
you may see more of the buffer by typing a space causing TV to
start at the top of the screen again and continue displaying the
buffer. If you don't want to see more, just type in your
command string. Any non- space you type during displaying will
cause the screen update to cease, hence display updating needn't
slow you down, and should actually speed you up! If TV is
displaying a carriage return or linefeed that is not part of a
carriage return linefeed pair, it shows carriage return as
^M And linefeed as
Lines longer than the width of your terminal are continued on a
new line and the end of the previous line has a ! To show
that it is being continued on the next display line.
" (Doublequote) . . . . . . . . 8-6
"!" command . . . . . . . . . . 8-5
"=" command . . . . . . . . . . 5-10
"A" Command . . . . . . . . . . 8-12
"B" Command . . . . . . . . . . 8-13
"C" Command . . . . . . . . . . 8-13
"D" Command . . . . . . . . . . 8-13
"E" Command . . . . . . . . . . 8-13
"F" Command . . . . . . . . . . 8-13
"G" Command . . . . . . . . . . 8-13
"H" Command . . . . . . . . . . 8-13
"I" Command . . . . . . . . . . 8-13
"J" Command . . . . . . . . . . 8-14
"K" Command . . . . . . . . . . 8-14
"L" Command . . . . . . . . . . 8-14
"M" Command . . . . . . . . . . 8-15
"N" Command . . . . . . . . . . 8-15
"O" Command . . . . . . . . . . 8-15
"P" Command . . . . . . . . . . 8-15
"Q" Command . . . . . . . . . . 8-15
"R" Command . . . . . . . . . . 8-16
"S" Command . . . . . . . . . . 8-16
"T" Command . . . . . . . . . . 8-17
"U" Command . . . . . . . . . . 8-17
"V" Command . . . . . . . . . . 8-18
"W" command . . . . . . . . . . 8-18
"X" Command . . . . . . . . . . 8-20
"Y" Command . . . . . . . . . . 8-21
"Z" Command . . . . . . . . . . 8-21
"[" Command . . . . . . . . . . 8-21
"\" Command . . . . . . . . . . 8-21
"]" Command . . . . . . . . . . 8-22
"^" Command . . . . . . . . . . 8-22
"_" Command . . . . . . . . . . 8-22
# . . . . . . . . . . . . . . . 8-6
$ . . . . . . . . . . . . . . . 8-6
% Command . . . . . . . . . . . 8-6
& . . . . . . . . . . . . . . . 8-6
' . . . . . . . . . . . . . . . 8-6
( . . . . . . . . . . . . . . . 8-7
) . . . . . . . . . . . . . . . 8-7
* . . . . . . . . . . . . . . . 8-7
TV INDEX Page Index-2
+ . . . . . . . . . . . . . . . 8-7
, . . . . . . . . . . . . . . . 8-7
- . . . . . . . . . . . . . . . 8-7
. . . . . . . . . . . . . . . . 8-7, A-2
/ . . . . . . . . . . . . . . . 8-7
: . . . . . . . . . . . . . . . 8-7
:R Command . . . . . . . . . . . 8-16
:S Command . . . . . . . . . . . 8-16
; . . . . . . . . . . . . . . . 8-8
;C . . . . . . . . . . . . . . . 8-8
;D . . . . . . . . . . . . . . . 8-8
;E . . . . . . . . . . . . . . . 8-8
;E command . . . . . . . . . . . 6-1, 6-3
;E command. . . . . . . . . . . 6-2
;F . . . . . . . . . . . . . . . 8-8
;G . . . . . . . . . . . . . . . 8-8
;G command . . . . . . . . . . . 6-1 to 6-2
;H . . . . . . . . . . . . . . . 8-8
;I . . . . . . . . . . . . . . . 8-9
;M . . . . . . . . . . . . . . . 8-9
;N . . . . . . . . . . . . . . . 8-9
;P . . . . . . . . . . . . . . . 8-9
;R . . . . . . . . . . . . . . . 8-10
;S . . . . . . . . . . . . . . . 8-10
;T . . . . . . . . . . . . . . . 8-10
;U . . . . . . . . . . . . . . . 8-10
;U command . . . . . . . . . . . 5-2
;W . . . . . . . . . . . . . . . 8-11
;X . . . . . . . . . . . . . . . 8-11
;X command . . . . . . . . . . . 5-2, 5-11
;Y . . . . . . . . . . . . . . . 8-11
;Y command . . . . . . . . . . . 5-1, 5-3
< . . . . . . . . . . . . . . . 8-12
= . . . . . . . . . . . . . . . 8-12
= command . . . . . . . . . . . 5-2
== Command . . . . . . . . . . . 8-12
> . . . . . . . . . . . . . . . 8-12
? . . . . . . . . . . . . . . . 8-12
@ . . . . . . . . . . . . . . . 8-12
@J command . . . . . . . . . . . 5-1, 5-4
@R Command . . . . . . . . . . . 8-16
@S Command . . . . . . . . . . . 8-16
Aborting a command in execution 8-2
TV INDEX Page Index-3
Addition . . . . . . . . . . . . 8-5, 8-7
Advanced searching . . . . . . . 7-1
Altmode . . . . . . . . . . . . 8-5
Altmode (Escape) . . . . . . . . 2-1
Apostrophe . . . . . . . . . . . 8-6
Argument . . . . . . . . . . . . 2-2
ASCII Character, value of . . . 8-9
Atsign . . . . . . . . . . . . . 8-12
Atsign command . . . . . . . . . 7-2
Automatic file heading . . . . . 8-8
Backarrow search . . . . . . . . 7-1
Backspace key, uses . . . . . . 8-2
Beginning . . . . . . . . . . . 8-13
Buffer . . . . . . . . . . . . . 2-1
C command . . . . . . . . . . . 5-2, 5-9
Carriage Return. . . . . . . . . 2-1
Character . . . . . . . . . . . 2-1
Character command . . . . . . . 5-9, 8-13
Character value . . . . . . . . 8-12
Characters, number of in buffer 8-21
Clearing current value . . . . . 8-3, 8-5 to 8-6
Closing an output file . . . . . 8-8
Colon . . . . . . . . . . . . . 8-7
Colon search . . . . . . . . . . 7-2
Comma . . . . . . . . . . . . . 8-7
Command string . . . . . . . . . 2-2
COMMANDS.TV file . . . . . . . . 6-3
Comment character . . . . . . . 8-5
Conditional operation . . . . . 8-11
Control-A . . . . . . . . . . . 8-1
Control-D . . . . . . . . . . . 8-2
Control-E . . . . . . . . . . . 8-2
Control-G . . . . . . . . . . . 8-2
Control-H . . . . . . . . . . . 8-2
Control-I . . . . . . . . . . . 8-2
Control-J . . . . . . . . . . . 8-3
Control-K . . . . . . . . . . . 8-3
Control-L command . . . . . . . 8-3
Control-M . . . . . . . . . . . 8-3
Control-N . . . . . . . . . . . 8-3, 8-16
Control-O . . . . . . . . . . . 8-3
Control-Q . . . . . . . . . . . 8-3
Control-R . . . . . . . . . . . 8-4
Control-S character . . . . . . 8-4
Control-T . . . . . . . . . . . 8-4
Control-U . . . . . . . . . . . 8-4
Control-X . . . . . . . . . . . 8-4, 8-16
Control-X command . . . . . . . 7-3
Control-Z . . . . . . . . . . . 8-5
Control-^ . . . . . . . . . . . 8-5
Conversion, integer to text . . 8-21
Current value . . . . . . . . . 8-9, 8-12, 8-15
Current value, storing . . . . . 8-17
TV INDEX Page Index-4
Current value, type out . . . . 8-12
Current value, type out-octal . 8-12
DDT . . . . . . . . . . . . . . 8-2
Decimal Point . . . . . . . . . 8-7
Delete . . . . . . . . . . . . . 8-22
Delete command . . . . . . . . . 8-13
Differences from TECO . . . . . A-1
Dot . . . . . . . . . . . . . . 8-7
Doublequote . . . . . . . . . . 8-6
End of line command . . . . . . 8-13
Equal sign . . . . . . . . . . . 8-12
Erase line . . . . . . . . . . . 8-4
Escape . . . . . . . . . . . . . 8-5
Escape (Altmode) . . . . . . . . 2-1
Execute command . . . . . . . . 8-8
Executing a Q register . . . . . 8-9
Exit command . . . . . . . . . . 5-11, 8-11
File read in . . . . . . . . . . 8-11
File, open for reading . . . . . 8-10
File, open for writeing . . . . 8-11
File, writing out . . . . . . . 8-10
Formfeed command . . . . . . . . 8-3
Formfeed switch . . . . . . . . 8-2
General command syntax . . . . . 4-4
Get Command . . . . . . . . . . 8-13
Global search . . . . . . . . . 8-15
Global search command . . . . . 8-13
Goto command . . . . . . . . . . 8-15
HK Command . . . . . . . . . . . 8-13
HP Command . . . . . . . . . . . 8-13
I command . . . . . . . . . . . 5-1, 5-5
Insert command . . . . . . . . . 4-3, 8-2, 8-13
Integer arithmetic expressions . 5-10
Integer to text conversion . . . 8-21
Iteration loop . . . . . . . . . 8-12
Iteration loops . . . . . . . . 8-12
J command . . . . . . . . . . . 5-1, 5-4
Jump Command . . . . . . . . . . 8-14
K command . . . . . . . . . . . 2-2, 5-1 to 5-2, 5-7
Kill Command . . . . . . . . . . 8-14
Kill command . . . . . . . . . . 5-7
L command . . . . . . . . . . . 5-1, 5-6
LF Command . . . . . . . . . . . 8-3
Line Command . . . . . . . . . . 8-14
Line command . . . . . . . . . . 5-6
Loading current value . . . . . 8-9
TV INDEX Page Index-5
Loading Q registers . . . . . . 8-13, 8-17
Logical and . . . . . . . . . . 8-6
Loops and exiting . . . . . . . 8-11
Loops, iteration . . . . . . . . 8-12
Lower case . . . . . . . . . . . 8-1
Macro Command . . . . . . . . . 8-15
Macro, Q register . . . . . . . 8-9
Moving text . . . . . . . . . . 8-13, 8-20
Multiplication operator. . . . . 8-7
N search . . . . . . . . . . . . 7-1
Number, loading current value . 8-9
Octal input and output . . . . . B-1
Octal typeout . . . . . . . . . 8-12
Opening a file for read . . . . 8-10
Opening a file for write . . . . 8-11
Page Command . . . . . . . . . . 8-15
Parenthesis, use . . . . . . . . 8-7
Period . . . . . . . . . . . . . 8-7
Pointer positioning . . . . . . 8-14
Pop command . . . . . . . . . . 8-22
Push command . . . . . . . . . . 8-21
PW Command . . . . . . . . . . . 8-15
Q registers . . . . . . . . . . 8-9, 8-13, 8-15, 8-17,
8-20 to 8-22
Q registers, incrementing . . . 8-6
Quoting character . . . . . . . 8-3
Reading value of a q register . 8-15
Realtime clock value . . . . . . 8-2
Reentering TV . . . . . . . . . C-2
Replace Command . . . . . . . . 8-16
Replace command . . . . . . . . 7-1
Returning control to TOPS-20 . . 8-2
Rubout . . . . . . . . . . . . . 8-22
S command . . . . . . . . . . . 5-1, 5-5
Search command . . . . . . . . . 5-5, 7-1, 8-16
Search, backarrow . . . . . . . 8-22
Searching, advanced . . . . . . 7-1
Semicolon . . . . . . . . . . . 8-8
Semicolon <space> . . . . . . . 8-11
Separators . . . . . . . . . . . 8-16
Setting current value . . . . . 8-5
Space command . . . . . . . . . 8-5
Stack pop command . . . . . . . 8-22
Stack push command . . . . . . . 8-21
Starting a new file . . . . . . 3-1
Storing current value . . . . . 8-17
String . . . . . . . . . . . . . 2-2
String matching characters . . . 7-3, 8-4
TV INDEX Page Index-6
String separator in searches . . 8-4
String substitution . . . . . . 8-16
Subtraction operator. . . . . . 8-7
Tab . . . . . . . . . . . . . . 8-2
Tags . . . . . . . . . . . . . . 8-15
Taking input from a terminal . . 8-4
TECO . . . . . . . . . . . . . . 1-1, A-1
Text typeout . . . . . . . . . . 8-10
Text typeout in command strings 8-1
Text, moving . . . . . . . . . . 8-13, 8-20
Trace mode . . . . . . . . . . . 8-12
Type out current value . . . . . 8-12
Type out current value-octal . . 8-12
Typeout command . . . . . . . . 8-17
Typeout of text . . . . . . . . 8-10
Undoing big mistakes . . . . . . 6-1
Uparrow . . . . . . . . . . . . 8-22
Uparrow T command . . . . . . . 8-4
Upper and lower case . . . . . . 7-3
View Command . . . . . . . . . . 8-18
VT05 . . . . . . . . . . . . . . 3-2, 8-2 to 8-5
VT05 cursor commands . . . . . . C-1
VT50 and VT52 cursor commands . C-1
VT52 . . . . . . . . . . . . . . 3-2
VTECO . . . . . . . . . . . . . A-2
WBACKUP Command . . . . . . . . 8-18
WEDITBASIC command . . . . . . . 8-20
WEDITREGULAR command . . . . . . 8-20
WFLAGLOWERS Command . . . . . . 8-19
WFLAGUPPERS Command . . . . . . 8-19
WLIST Command . . . . . . . . . 8-18
WLOWER Command . . . . . . . . . 8-19
WNOBACKUP Command . . . . . . . 8-19
WNOFLAG Command . . . . . . . . 8-19
WNOSHIFT command . . . . . . . . 8-19
Word command . . . . . . . . . . 8-18
WRAISE command . . . . . . . . . 8-19
WSAVLEN Command . . . . . . . . 8-19
WSCREENSIZE command . . . . . . 8-20
WVT05 Command . . . . . . . . . 8-18
WVT50 Command . . . . . . . . . 8-18
WVT52 Command . . . . . . . . . 8-18
WWIDTH command . . . . . . . . . 8-20
WWINSIZ command . . . . . . . . 8-20
Yank command . . . . . . . . . . 8-21
Z command . . . . . . . . . . . 5-4
Zero . . . . . . . . . . . . . . 8-13
ZJ command . . . . . . . . . . . 5-1, 5-5
^T command . . . . . . . . . . . 8-4