perm filename FOO[NET,GUE] blob
sn#019415 filedate 1973-05-12 generic text, type T, neo UTF8
This file is intended to teach the use of the "TV" editor. If
you read everything sequentially (or in the order specified),
and do everything several times, you should become proficient
at using TV very quickly.
NOTATION:
α means <control>
β means <meta>
⊗ means αβ.
>> indicates a line which is present for you to play with.
! indicates that you should follow the instruction in that
line (it's usually best to read ahead a few lines first).
<cr> means carriage return.
<lf> means line feed.
<alt> means altmode.
<bs> means backspace.
<form> means form-feed.
always read down unless otherwise instructed.
CURRENT means the current line (the one with the arrow on the left).
If you get into a state you don't understand, type <alt> first,
ask questions later.
! Type ⊗P to go on to page 2.
Good for you.
TV has "LINE mode" commands (like ⊗P given above, and more given below),
"INTRA-line" commands (really the system line editor), and some other
(INSERT, EXTEND, ATTACH) modes which we'll get to. All LINE mode commands
may be invoked using ⊗-modified characters, except for <cr> and <vt>,
where all α-β combinations are legal, each modifying the meaning of the
basic command. So these are the only hard ones to get straight.
Almost any LINE command may be preceded by a repeat argument,
any number of ⊗<digit>s.
Usually a null repeat argument implies a repeat argument of 1.
Exceptions will be explicitly noted.
Repeat arguments will be indicated by <rept>
An arrow (← or ↔) in the leftmost column on the screen indicates CURRENT,
the line you can currently change. It's probably on the top line now.
<rept><cr> (no α, no β) is the main way of moving the arrow (CURRENT) down.
It moves CURRENT down <rept> lines, if possible (1 if <rept> is left out).
<rept><vt> (with any combination (including none) of α or β) moves CURRENT
back up <rept> (or 1) lines.
*** REMEMBER, "!" in column 1 means that you should do this now.
!Type <cr> a few times (NO CONTROL BITS ON THE <cr>!) to see what it does.
! Try <rept><vt> and <rept><cr>, to observe the effect of <rept>.
! Then type ⊗P to go on to page 3.
The ⊗P (Page) command, without a repeat argument, goes on to the next
page. If a repeat argument is present, the page with that number is
read. It is only when changing pages (or finishing the edit) that
changes you have made to this page (with commands to be discussed)
are recorded in the disk file. When the new page appears, the file
has been completely updated, and is safe over any catastrophe short
of earthquake. Any catastrophe you inflicted on the previous page is
cast in concrete.
So far, the pages have been short. It's good to keep them
fairly short (50-75 lines is a good number), but you can safely
edit pages up to about 200 lines. When too many are present,
TV gracefully collapses, hopefully without ruining the file.
This page is presented to demonstrate more operations which are
useful on pages longer than 30 lines or so (one screenful).
The ⊗W (Window) command moves the bottom line on the screen to
the top line, thereby displaying the next screenful of the
current page. The top line becomes CURRENT.
!Type ⊗W to WINDOW the bottom line (down there↓) to
! the top of the screen.
This line is meaningless, and is included to avoid dead air.
This line is meaningless, and is included to avoid dead air.
This line is meaningless, and is included to avoid dead air.
This line is meaningless, and is included to avoid dead air.
This line is meaningless, and is included to avoid dead air.
This line is meaningless, and is included to avoid dead air.
This line is meaningless, and is included to avoid dead air.
This line is meaningless, and is included to avoid dead air.
This is the bottom line (down here←) (or was).
Thus opening up a whole new world.
!Now type <cr> a few times
! Down to here.
The ⊗J (Jump) command is like ⊗W (Window), except that it doesn't move
the bottom line to the top, but instead moves CURRENT to the top. The
next screenful, starting at CURRENT (which becomes line 1) will be
visible. If there are not enough lines left in the page, both ⊗W and
⊗J will move lines up only far enough to display the rest of the page
below CURRENT.
!Type <cr> enough times to reach the line following this one, then
! type ⊗J to JUMP this line to the top.
⊗L (Last) moves the top line to the bottom, displaying the previous screenful.
It is the inverse of ⊗W. The bottom line becomes CURRENT.
!READ THE next 2 lines before doing anything!
! Type ⊗L to move the top line to the LAST, then ⊗J or
! ⊗W to get back. Then type <cr> until you pass this line again.
Notice that the asterisks at the top or bottom of the screen
are replaced by dashes if there are lines in that direction which
you can't see. So you can always tell if you are at the beginning,
at the end, or in the middle of the page.
⊗W and ⊗L accept <rept> arguments. The command is repeated <rept> times.
Whenever a <cr> or similar command attempts to move to a line
not on the screen, a few more lines appear at that end of the screen
so the arrow will have somewhere to go. Of course, some lines disappear
from the other end.
!Try it by going to the top or bottom of the page, then go a little further.
! Come back here after you're done.
The following commands move the arrow (CURRENT) to visible lines. They differ
from W and friends, in that the lines attached to the arrow don't move
with it. They are more like <cr> or <vt> than ⊗W.
⊗T (Top) moves the arrow to the top line, then moves down a few lines if possible.
⊗B (Bottom) moves the arrow to the bottom line, glitching up if possible.
⊗<, ⊗>, ⊗≤, ⊗≥ move the arrow up and down by varying amounts.
!Try all these arrow-moving things, and return to the lines below.
!Type ⊗1⊗P to look at page 1 again (pure nostalgia), then ⊗P your way
! back to page 4 (the next one)
Type <alt>, inside a line or out, whenever you get into
trouble. This will attempt to nullify whatever dumb thing
you or I did, and get you into a state where you might
expect to recover. You will probably soon need this lifesaver.
Now to edit some lines. Characters, which when typed, cause the line
editor to activate include non-control characters, along with α<space>,
α<digit>, α<tab>, αI, αS, αK, or αD, and almost all β characters. These
characters should be recognizable as those familiar to the line editor
(some additional α characters also trigger line editing in TV -- these
are discussed below).
Typing one of these "line-entering" characters (call it `C') causes the text
of CURRENT to be sent to the line editor (in situ). It then applies the
`C' character you typed to the line. The effect is very much like that of
the system's <ctrl><cr> (get my last line back): it is as if you had
typed the text of CURRENT, then <ctrl><cr>, then `C'.
***************************************************************************
*WARNING!!!!! UNLESS THE LINE TO BE CHANGED IS EMPTY (OLD OR BRAND NEW), *
* ALWAYS WAIT FOR THE LINE EDITOR CURSOR (UNDERLINE) TO APPEAR AFTER YOU *
* TYPE THE FIRST LINE-ENTERING CHARACTER, AND BEFORE TYPING THE SECOND. *
* OTHERWISE TIMING PROBLEMS WILL SCREW UP THE EDIT OF THAT LINE. *
***************************************************************************
!Get the arrow down to the data (>>) line below, then type any alphabetic
! character, do some line editing if you wish, followed by a <cr>.
>> The first character is not ">" any longer, but " " (fill in the blank)
As you can see, <cr> gets you out of the line, accepts the changes, and
goes on to the next line.
!Now change the following data line, terminating with <alt>.
>> This line remains invariant under all legal transformations!!
If you type a <rept> before entering the line editor with one of these
commands, the first non-<rept> character (the line-entering character)
will be transmitted <rept> times (e.g., ⊗2⊗0α<space> will space out 20
columns). This allows you to simulate the system line editor's repeat
feature, even before the line editor has been invoked.
!Practice starting a line edit with αS, β<char>, αD, αK, αI, α<tab>,
! etc. Get out of αI mode (with α<space> or something) before typing <cr>.
! Use any line for practice, but there are some just below which you can change
! without destroying the lesson for tomorrow.
>> One fine high quality practice line.
>> Two fine high quality practice line.
>> Three fine high quality practice line.
>> Four fine high quality practice line.
>> Five fine high quality practice line.
There are some other things you can do while editing a line.
α<cr> terminates the edit of this line, leaves any (inter or intraline) insert
modes.
β<cr> inserts a carriage return and terminates the line-edit, leaving CURRENT
pointed at the (new) next line. Some adjustment of spaces and tabs in the
vicinity is made.
αD, when typed at the end of a line has the effect of deleting the carriage
return between this line and the next. WAIT FOR THE CURSOR TO SET UP
AGAIN BEFORE CONTINUING! Some adjustment of spaces and tabs in the
vicinity is made.
If you are in αI insert mode and type <cr>, the <cr> will be inserted
(like β<cr>), and you will be in insert mode, editing the (new) line
(unlike β<cr>).
⊗<vt> terminates the edit, then does a <vt>.
⊗↑ terminates the line edit, then <tab>s to the end of the previous line.
⊗↓ terminates the line edit, then <tab>s to the end of the next line.
Thus you can get out of a line, accepting the changes and proceeding to
the beginning or end of the next or previous line.
(The last two also work when you're not editing a line).
⊗V redraws the entire screen.
Try these:
! Go about halfway into a practice line, and type β<cr>.
! α<tab> out to the end of the first of 2 lines, and type αD. Wait.
! After the cursor sets up, terminate the edit
! Get into a line, then type αI, some characters, <cr>, **WAIT!** and
! some more characters. Then type α<space>, followed by <cr>.
! Get into the second of 3 lines, and type ⊗<vt>.
! Ditto with ⊗↑.
! Ditto with ⊗↓.
If you are editing a line and type a α character which the line editor
doesn't understand, or a ⊗ character which TV doesn't understand when
you are not editing a line, the character will be ignored by re-editing
the line, automatically spacing back out to the column where the illegal
character was typed. ** WAIT FOR THE CURSOR TO RESET WHEN THIS HAPPENS! **
! Get into a line, and type α# or αA or αJ or something. Wait for the
! cursor to stabilize again (if it doesn't show up, type <esc>R), and
! observe the result).
If you type a legal ⊗ character while line-editing, however, the line
will be accepted as edited. Then the command will be carried out.
Certain legal commands, (⊗E, ⊗P, ⊗D) are ignored anyway (too dangerous).
! Get into a line, and type ⊗J, or ⊗W, or ⊗≥. Also try ⊗E, ⊗P, ⊗D.
⊗<cr> puts the editor into line-insert mode.
In this mode the arrow (over there←) is a double arrow (↔) instead of a
single one (→). The previous CURRENT has moved down one line,
creating a vacuum, which you can fill by typing into it. Each time
you type <cr>, a new vacuous line will appear, and you will already be
editing the empty line. YOU NEED NOT WAIT FOR THE CURSOR TO APPEAR BEFORE
TYPING IN LINE INSERT MODE. JUST DON'T GET TOO FAR AHEAD.
To leave line-insert mode, type α<cr> to accept the line you're on and
get out. α<cr> is also good to terminate αI mode inside a line without
inserting the carriage return.
You may also leave line-insert mode by typing <alt> (good old <alt>).
If there is nothing in the line when you type <alt>, the line is deleted
completely (the next line moves up). If there are characters in the line
when you type <alt>, the line will remain, but be empty (the value of that
line before you started editing it, as usual.
⊗<cr> is legal while line-editing. It causes the current line to be accepted,
the arrow to move to the next line, and line-insert mode to be entered.
! Try all this somewhere.
>> perhaps between here
>> and here
! Continued on page 6.
(Unbridled, continued from page 47)
Mark sighed breathlessly.
"But we must not go on meeting like this", Mary replied
in a non-sequiturial manner he had long since learned to expect.
(continued on page 115, column 3).
(TV teacher -- continued from page 4).
<rept>⊗<cr> is different from ⊗<cr>. <rept>⊗<cr> inserts <rept> blank
lines below the arrow, never actually entering insert mode. This is
more efficient than insert mode, when you know about how many new lines
there will be.
! Try it.
>> Perhaps between here
>> and here.
When you <cr> past the end of a page, new lines are created just ahead of
you, so you won't fall off. This is almost, but not quite like insert mode.
! Try it here, then advance to the next page.
The ⊗E command terminates the edit by updating
the current page if necessary, then blanking the screen
and exiting. Don't try it now, unless you want to waste
some time getting back here.
(page)
Welcome back.
<rept>⊗D is fun -- try it on the practice line below.
>> This line doesn't exist.
You are not currently allowed to delete more lines than you can see.
⊗. writes the current page into the disk file, if it has changed. This
has the same effect as, but is faster than, the sequence -⊗P⊗P. It
is the equivalent of, but again is faster than, the W command in SOS.
⊗Z joins CURRENT with the line after it (deletes the <cr> between them),
then advances to the line beyond both of the original lines.
⊗Q causes the line just above CURRENT to be duplicated. The duplicate
line is then opened for editing. The effect is similar to that obtained
by α<cr> when you are not using TV.
SEARCHING
The Repeat argument <rept> may, in most cases, be obtained associatively:
that is, by specifying some text string to be searched for in order
to specify a range of lines to be affected.
⊗F, followed by a string of non-activation characters, specifies a search
string. This string is used by different commands in different ways:
⊗Fsmith<cr> computes the number of lines from the arrow to a line containing
"smith", using that count as the <rept> factor-- in other words, the arrow
moves to the line containing "smith". (⊗↓ can replace <cr>).
⊗Fsmith⊗D computes the number of lines as above, then uses the count to
delete all lines down to, but not including the line with the match.
⊗Fsmith⊗<vt> looks backwards in the page, going up rather than down to the
line with the match. (⊗↑ will also work here).
⊗Fsmith⊗J is the same as ⊗Fsmith<cr>⊗J.
⊗Fsmith⊗S searches forward, as with ⊗Fsmith<cr>, but starting on the current
line. If it finds the string, it moves CURRENT to that line and does
a ⊗S (see below). You will be editing the line, with the cursor under
the "s" in "smith".
⊗Fsmith⊗F will find the first subsequent line which matches, then display
a double arrow (↔) there. If the line is not on the screen, that line will
appear at the bottom of the screen, complete with double arrow. Continued
⊗F's will find subsequent matches, or will inform you that none exist.
The next command (<cr>, αβD, etc.), if it accepts an associative repeat
argument, will use the number of lines between the current one and
the last successful match.
Thus, ⊗Fsmith⊗F⊗F⊗F<cr> will advance the arrow (→) to the line containing
the third "smith".
In other words, ⊗Fstring⊗F gives a preview of what will happen when you
actually execute the command which will use the string for a search arg.
<alt> cancels the current search string, and cancels any repeat factor already
calculated. Otherwise, ⊗F with a null string causes the previous value
to be used.
⊗F never crosses page boundaries.
! Use ⊗F<string>⊗<vt> to find some line above this one. Then experiment with
! the other ⊗F goodies.
There is one special use for ⊗F. TV keeps in a core array the first line
of each page (with "COMMENT", ";", and "⊗" removed). If you know the
contents (or part of it) of the first line of some page, you can type
⊗Fcontents⊗P. This in-core directory will be searched rather than the
current page. If a match occurs, the page whose first line matches will
be read and displayed. Otherwise nothing at all happens. If a new page
is read, ⊗F<cr> will find the next match after the first line (since the
search string is retained).
This feature is more useful when you have a directory for your file. This
will be explained later.
⊗S tries to find (in the CURRENT line) the string (e.g., smith) used in the
last ⊗F search. If it finds it, it enters line-edit mode, with the cursor
positioned under the first character of that string.
Go on to page 9.
<rept>⊗A (ATTACH) causes <rept> lines (where <rept> may be specified
with ⊗F) to be deleted from the page, from CURRENT to CURRENT+
<rept>-1 (up to 50 lines) and placed in a special array, safe from
harm. Up to 8 of these lines are also displayed (with "|" along the
left margin) at CURRENT. These lines remain "ATTACHed", no matter where
the arrow (which has become a "|" for clarity) is moved.
When lines are attached, a large subset of commands are illegal; Remaining
legal commands are ⊗A, ⊗C, and arrow-moving commands, for the most part.
Legal commands may be experimantally discovered. In addition, there
are a few commands which are redefined or unique to ATTACH mode:
⊗E -- EXIT Attach mode, and restore the lines to the current page
(which may be different from the original) in the position they
occupy on the screen.
⊗K -- exit ATTACH mode, and KILL the attached lines -- they go away.
⊗R -- exit ATTACH mode, and REPLACE the attached lines in their original
page and line.
<rept>β<space> -- move the entire attached complex right <rept> spaces
(using tabs and spaces for max efficiency)
<rept>αD -- move the entire attached complex left <rept> spaces, or until
a printing character would be deleted in some line.
!Attach some lines and move them around. Try detaching from them in any of
! the ways indicated.
>> a practice line.
>> a practice line.
>> a practice line.
>> a practice line.
>> a practice line.
>> a practice line.
<rept>⊗C is identical to ⊗A, except the original lines are not removed from
the file. The lines have been COPYd.
⊗R (when no lines are attached) has an effect only if the last ATTACHed
lines were αK'd out of existence. This command puts them back where
they were originally.
!Try it if you must.
The next page describes EXTEND mode.
⊗X enters EXTEND mode for one extend-mode command line.
Extend mode commands are complete words, which may be
abbreviated as can commands to the TS monitor (that is,
you have to type enough characters). If any parameters
are required for a command, they should be separated from
the command by a space. <cr> terminates a command line.
After the command has been executed, TV reverts to LINE mode.
Extend-mode commands:
DRAW -- Use this when your screen is covered with glitches, garbage,
etc., after doing an <esc>C to clear it. All segments of the TV
screen will be re-displayed. Otherwise, only those things which
change are redrawn. This command will happen automatically as soon
as possible after an <esc> C is typed.
When editing a line, typing <esc>C, followed by ⊗V, will cause a DRAW
to happen (may not be implemented yet).
! Type <esc>C, <esc>P, ⊗XDRAW<cr>
DDT -- If RAID is present in this version, branches to RAID. Execute
BACKαG to return.
DELETE -- deletes the page mark between this page and the next.
! Back up a few pages and try it.
MARK -- inserts a page mark between CURRENT and the line above
it. Displays the page on which CURRENT appears.
! Restore the page mark which you deleted.
READONLY -- if in read/write mode, writes the current page if any changes
were made, then inhibits further writing. You can modify a page in core,
but not on the disk.
READWRITE -- if in readonly mode, disables the write-inhibit.
CANCEL -- Reads the current page from the disk, without writing anything
out. Cancels any changes to the page since the last time it was written.
FIND -- Follow by space, then a string, then a <cr>.
This is like ⊗Fstring<cr>, except it will cross page boundaries to find
the line. The search string for FIND is remembered independently of
that for ⊗F.
If, during a FIND search, you decide that you don't want the search to
be completed, type the sequence "<esc>I". The search will be terminated
as soon as possible. You will be editing some page down the line from
the original one. If you have typed something else before the <esc>I, it
will be treated as the next input -- so it is best in this case to type
<call>, then CONTINUE, before typing the "<esc>I" sequence.
GO -- Does what ⊗E does, except that, instead of exiting,
it repeats the last RPG command. It is like the G command of
SOS.
SWITCHTO -- This feature was added to allow copying data from one file
to another. Follow SWITCHTO with a space, then an argument string:
Filename -- TV will begin editing that file. If lines were attached
to the cursor, they still are -- this allows "copy" or
"transfer" operations, so be careful. You can use "/R",
"/nP", "/nL", etc., switches after the file name (see next
page and the TVED manual), to further specify the destination.
#number -- TV has been saving the file names you typed. #0 will switch
to the most recent one, #1 to the next most recent, etc. #99,
or anything greater than have been saved, will edit the least
recently edited one.
<empty> -- SWITCHTO with a blank argument is the same as #0.
? -- Your screen will be replaced by a display of the current stack of
saved file names, and a description of SWITCHTO commands.
It will then wait for any SWITCHTO command to complete the
operation.
π -- no operation -- normally used after ? to avoid switching.
This document has not been entirely honest in describing the commands.
It has made available all the features of the editor, but has not
necessarily described all the ways in which these features may be
invoked. Many commands have optional codings -- most may be called
using fewer control bits than we have required here. A complete
description of TV features is available in the TV manual,
TVED.DCS[S,DOC]. It is the reference of record for TV.
One page remains (the next one). On it is described the various commands
one can give to begin editing a file.
Start an edit by typing:
TV filespec<cr>
A <file spec> is:
<file name, including extensions, p,pns and stuff>{switch}
where switch can be /R only, for now.
/R means readonly -- it should be given only if the file has a directory.
If a p,pn is specified, and not /R, the file will be copied to your area
(same name). This is the file you will be editing.
CTV filespec<cr>
will create a file of the given name (omit p,pn and /R). It will have
a directory page, and one more, blank, page.
________
N.B. A directory is a special first page, which is tacked on to the file
before the first actual data page (unless inhibited), the first time the
file is edited. You can edit much faster if you have a directory.
If the directory is no good (marked invalid, SOS line numbers seen, you
said /N on input side), you'll get the opportunity to fix it.
--------
!Type ⊗E, then type TV FOO<cr> (or whatever you called this file). This will
create a version of FOO which has a directory. Then come back to page 12
(this will be page 12 by then).
! Now you have all the information you need to decide whether you want a
! directory or not.
More complicated commands, including the one you used to start this edit, are
described in the TV manual.
-30-