Google
 

Trailing-Edge - PDP-10 Archives - 6.1_emacs_manuals_1er - manuals/tv.man
There is 1 other file named tv.man in the archive. Click here to see a list.











                           CHAPTER 1

                          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.











                           CHAPTER 2

           CONVENTIONS AND TERMS USED IN THIS MANUAL






The following terms are used frequently in this manual:

     BUFFER

     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
editing session.


     ESCAPE (ALTMODE)

     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.


     CHARACTER

     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.


     STRING

     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
single string.


     ARGUMENT

     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.


     COMMAND STRING

     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.











                           CHAPTER 3

                      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
Samuel Butler.

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


@TV

     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:

WVT52$$

     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:

WVT05$$

     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.

--SAMUEL BUTLER
$$

     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
buffer.

     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:

;X$$

     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.
It types

OUTPUT 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:

OUTPUT FILE:FAMOUS.QUOTE

     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.











                           CHAPTER 4

                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:

@TV FAMOUS.QUOTE

     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:

*;Y$$

     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:

INPUT FILE:FAMOUS.QUOTE.1

     This shows you what file is being read  in,  in  this  case
version one of FAMOUS.QUOTE.  The next line will look like this:

108 CHARS

     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
like this:

/\ALL THE ANIMALS EXCEPT MAN KNOW THAT THE PRINCIPLE BUSINESS OF
LIFE IS TO ENJOY IT.

--SAMUEL BUTLER

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
example.

     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:

SCIP$$

     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.

--SAMUEL BUTLER

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:

2D$$

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.

--SAMUEL BUTLER

Notice how the 2D$$ caused the "le" get deleted from the buffer.
Now insert the correct letters like this:

IAL$$

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.

--SAMUEL BUTLER



     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:

SCIP$2DIAL$$

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
executing it.
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):

*;X$$

     TV asks what name to save the file as by typing:

OUTPUT FILE:

     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:

SBOARD$IWALK$$

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:

SBOARDIWALK$$

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
printed.











                           CHAPTER 5

               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
                                the screen.

ZJ                              Moves the pointer to the end of the
                                buffer

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
                                the buffer

-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
                                the right

-C                              Moves pointer one character to the left

nC                              Moves the pointer n characters to
                                the right

-nC                             Moves the pointer n characters to
                                the left

Z=                              Prints out the number of characters in
                                the buffer

.=                              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


                           ;Y command
                          --- --------

     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:

*;Y$$

TV asks you which file you want to edit like this:

INPUT FILE:

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
this:

1435 CHARS

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

INPUT FILE:

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 Command
                          -- --------

     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

J$$

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

3J$$

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

J$$

puts the pointer at the beginning.  It's exactly as  though  you
typed

0J$$


     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
screen.



     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

ZJ$$

If there were 318 characters in the buffer, ZJ$$ has exactly the
same effect as typing

318J$$
FREQUENTLY USED TV COMMANDS                             Page 5-5


                           I Command
                          -- --------

     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.

                           S Command
                          -- --------

     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

SU'R$$,

TV searches for  the  next  occurence  of  the  string  U'R  and
positions  the pointer after it.  The buffer and pointer are now
like this:

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

-SWAY$$

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


S$$,

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 Command
                          -- --------

     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
this:

THE FIR/\ST LINE
AND ONE MORE
AND ANOTHER FOR GOOD LUCK

The command string

L$$

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

-L$$

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

2L$$

produces

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

0L$$,

the pointer moves to the beginning of the line yielding

THE FIRST LINE
/\AND ONE MORE
AND ANOTHER FOR GOOD LUCK


                           K Command
                          -- --------

     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

the command

K$$

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

K$$
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

0LK$$

to put the pointer at the beginning of the line  before  erasing
it, to assure that the whole thing gets erased.

     If you type

-K$$

one line before the pointer gets erased.  Hence  if  the  buffer
and pointer are like this:

THIS TIME
KILL A
LINE FOR
/\EXAMPLE

the command

-K$$

leaves the buffer like this:

THIS TIME
KILL A
/\EXAMPLE

     The K command  may  take  a  specified  numerical  argument
designating how many lines to kill.  For instance, the command

-3K$$

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:

WATCH HOW
THE B/\EGINNING
OF A LINE MAY BE ERASED

and you type

0K$$

the buffer will now look like this:
FREQUENTLY USED TV COMMANDS                             Page 5-9


WATCH HOW
/\EGINNING
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

3,7K$$

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:

ABCD/\EFGHIJKLMNOPQ

You give the command

10,12K$$

The buffer now looks like this:

ABCDEFGHIJ/\MNOPQ

     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

HK$$

                           C Command
                          -- --------

     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

C$$,

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

-2C$$,

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:

HERE'S ONE LINE/\
WATCH THE POINTER




                           = Command
                          -- --------

     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
by typing

Z=$$

     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

3+2*5=$$

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

Z-.=$$


                           ;X Command
                          --- --------

     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

;X$$,

TV usually will ask you what file to save  the  buffer  as.   It
types

OUTPUT FILE:

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

OUTPUT FILE:

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.











                           CHAPTER 6

          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
are:

     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
you did.

At this point, you should type:

;G$$

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:

COMMANDS.TV.100023

The version number of the file is always 100000  plus  your  job
number.

     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
your editing.
UNDOING BIG MISTAKES                                    Page 6-3


                           ;E Command
                          --- --------

The command

;Efilename$

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
23 again.

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
COMMANDS.TV.100014.

     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 command:

@VDIRECTORY (OF FILES) COMMANDS.TV

   <OSMAN>
 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
crashed.

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:

*;EFOO.BAR$$

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
generated on.
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
follows:

     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
command

HK$$

This command means kill the whole buffer, and hence your  entire
buffer  is  now  gone.  Here's how to get back your work without
repeating it:

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:

*^C
@

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
COMMANDS.TV.100016.

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
like:

@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:

@TV FOO.BAR

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:

*;U$$

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
mistake

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:

*;EFOO.BAR$$

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:

Method 1:

     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.


Method 2:
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.











                           CHAPTER 7

                       MORE ON SEARCHING



     Here are more details about the search facilities in TV:
Backwards searches:

     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:

-3rthis$that$$

instructs TV to replace the last three occurences of "this" with
"that"  and leave the pointer just before the first of the three
"that"'s.



Default arguments:

     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

Sthis$$,

then the command

S$$

Will advance  the  pointer  forward  to  just  beyond  the  next
occurence  of  the  string  "this" as though you had again typed
sthis$$.

     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


-r$$.

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

-S$$

Will do it.



     Colon search

     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

:nrstring1$string2$$.

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:

Zj-z:rrecieve$receive$$.

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:

3@r/a/$/$$
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

0^X$$

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

1^X$$.


     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
typing:

^X=$$.

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.











                           CHAPTER 8

                  COMPLETE LIST OF TV COMMANDS



     Notes:

     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
         lower case.)

     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.

Control-B

     Not used.

Control-C

     Not used.
COMPLETE LIST OF TV COMMANDS                            Page 8-2


Control-D

     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

     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.

Control-F

     Not used.

Control-G

     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
command string.

Control-H

     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.]

Tab (Control-I)

     Inserts itself and text following it  to  the  next  escape
into the buffer.
COMPLETE LIST OF TV COMMANDS                            Page 8-3


LF (Control-J)

     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

     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
same effect.

FF (Control-L)

     Control-L (Formfeed) Clears screen.

CR (Control-M)

     (Carriage return) Clears any current value.

Control-N

     Means "not" within search strings.  See the s command.

Control-O

     Control-O causes  output  to  be  discarded  until  another
control-O is typed.

Control-P

     Not used.

Control-Q

     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


Control-R

     During command typin, control-r causes the current line  to
be retyped.

Control-S

     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,
then reenter.)

Control-T

     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.

Control-U

     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
erased.

Control-V

     Not used.

Control-W

     Not used.

Control-X

     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-Y

     Not used.

Control-Z

     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
command string.

Escape

     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.

Control-\

     Not used.

Control-]

     Not used.

Control-^

     Sets the current value to the ascii value of next character
in the command string.

Control-_

     Not used.

Space

     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
work.

#

     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
printed out.

&

     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


(

     This and

)

     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
printed out.

-

     Subtraction.

.

     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.

/

     Division operator.

:

     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.

;C

     Closes the output file, without causing any more output  to
it.

;D

     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.

;E

     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).

;F

     This is the same as _(left arrow or underscore).

;G

     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.

;H

     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


;I

     Not used.

;J

     Not used.

;K

     Not used.

;L

     Not used.

;M

     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.

;N

     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.

;O

     Not used.

;P

     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:
0U1JZ<;P+Q1U1>Q1=.
COMPLETE LIST OF TV COMMANDS                           Page 8-10


;Q

     Not used.

;R

     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.

;S

     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.

;T

     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.

;U

     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


;V

     Not used.

;W

     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.

;X

     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.

;Y

     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.

;Z

     Not used.

;<space

     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
search fails.

=

     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.

A

     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


B

     Stands for the number 0, the  mneumonic  "beginning";   for
instance the command BJ puts the pointer at the beginning of the
buffer.

C

     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.

E

     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
on.

F

     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
command.

G

     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).

H

     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.

HP

     This is the same as the PW  command.   It  writes  out  the
entire buffer and waits.

I

     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.

J

     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.

K

     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.

L

     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
current line.
COMPLETE LIST OF TV COMMANDS                           Page 8-15


M

     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

     N is just like S except if the search fails, a P command is
executed, and the search continues.

O

     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.

P

     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.

PW

     Is the same as HP, it writes  the  entire  buffer  out  and
waits (as opposed to changing the buffer like P would).

Q

     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


R

     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
negative.

     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,
type   Rstring$$.

S

     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.

T

     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.

U

     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


V

     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.

W

     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:

WLIST$

     To get a list of all the currently defined words, use  this
command.

WVT05$

     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.

WVT50$

     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.

WVT52$

     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.

WBACKUP$

     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
command list.
COMPLETE LIST OF TV COMMANDS                           Page 8-19


WNOBACKUP$

     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.

WSAVLEN$

     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.

WFLAGLOWERS$

     Issuing this command causes all lower case characters to be
flagged with an apostrophe when they are displayed.

WFLAGUPPERS$

     This causes uppers to be flagged (see WFLAGLOWERS$).

WNOFLAG$

     This command causes no characters to ever be  flagged  with
an apostrophe when they are displayed.

WLOWER$

     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.

WRAISE$

     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.

WNOSHIFT$

     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


WWIDTH$

     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.

WSCREENSIZE$

     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,
use WWINSIZ$.

WWINSIZ$

     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.

WEDITBASIC$

     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.

WEDITREGULAR$

     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.

X

     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.

Y

     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

     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
printed.

[

     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
command I-45$.
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
could do
0US100<%S_\i
$_>.
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


linefeed.

]

     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 [9]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
[A[B]A]B.

^

     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.

Delete (Rubout)

     To delete the most recent character typed into the  command
string,  type  a  delete  or rubout (depending on the terminal's
keyboard lableing).











                          APPENDIX A

                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
         their description.

     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
features.]

     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
         with "q".











                          APPENDIX B

                     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

                        177.i$$.

To ask TV what 2 to the nineteenth is, you may ask

                        2000000.=$$.

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.











                          APPENDIX C

              MORE INFORMATION ON SCREEN HANDLING



     Arrows:

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.

     Left arrow:

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.

     Right arrow:

The right arrow is the same as "+C$$";  the pointer is moved one
character to "the right".

     Down arrow:

Down arrow is the same as "1L$$".  The pointer  is  put  at  the
beginning of the next line.

     Up arrow:

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


     "Reenter":

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
updated screen.


     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
    ^J.
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.
                                                    Page Index-1


                            TV INDEX




" (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