Trailing-Edge
-
PDP-10 Archives
-
BB-M836C-BM
-
tools/sed/sed.mem
There are 14 other files named sed.mem in the archive. Click here to see a list.
INSTALLATION MANUAL
HOW TO ADAPT A TERMINAL TO THE SED SCREEN EDITOR
BY A CHRISTOPHER HALL
July 1983
ADAPTING SED TO A TERMINAL
This is a step-by-step description of how to build the tables
for SED, for your terminal.
First, look at SEDTTY.MAC and see if your terminal is one of
the ones which already has tables defined. If so, read Appendix B.
Then set the right FXXXXX to 1 (for example, for the VT100, set
FVT100==1), and compile and load SED by typing the following
commands:
on TOPS-10: on TOPS-20:
.LOAD SEDSYM,SEDTTY,SED @LOAD SEDSYM,SEDTTY,SED
.SS SED @SA SED
Beware of using terminal tables which were written for a
terminal which is similar to, but not the same as, your own.
Terminals are sickeningly different, and it's likely that the tables
will not quite be right. However, if you keep this warning in mind,
you can use an existing set of terminal tables as a starting point.
If any of your terminal types are not defined in SEDTTY.MAC you
will need to write the terminal tables to support them. There are
two tables: one tells SED what to output to the terminal to get
certain things to happen (such as clearing the screen or moving the
cursor); the other tells which control characters and sequences
invoke which editor commands. There also must be two subroutines
which move the cursor, and maybe other routines to do
terminal-dependent things, like special stuff on entry to and exit
from SED.
The materials you will need to write these tables and routines
are the file SEDX.MAC, which serves as the framework to build upon,
and the terminal manual which describes which character sequences
move the cursor, clear the screen, and do the other terminal
functions. Also, you can use the program SEDECO (as in SED ECHO) to
make the terminal echo back the characters that are output by its
special keys, or to see how the terminal behaves when certain
sequences are typed in. See Appendix A for information on how to
run SEDECO.
If you have more than one type of terminal you will probably
want to put your new terminal modules in SEDTTY.MAC, since it
contains code to read the type from the monitor and set up the right
tables. See Appendix B and the information at the start of
SEDTTY.MAC, in addition to the rest of this manual.
Page 2
You can also use the other terminal definitions in SEDTTY.MAC
to provide a lot of guidance as to how your tables should look.
Page 3
THE TERMINAL OUTPUT TABLE
After the initial stuff in SEDX.MAC is the terminal output
table. It contains the sequences which SED must send to the
terminal in order to get things to happen. The bare table looks
like this:
ONAME: BYTE (7) 0 ;CURSOR UP
BYTE (7) 0 ; DOWN
BYTE (7) 0 ; RIGHT
BYTE (7) 0 ; LEFT
BYTE (7) 0 ; HOME
BYTE (7) 0 ;CLEAR TO END OF PAGE
BYTE (7) 0 ;CLEAR TO END OF LINE
BYTE (7) 0 ;ROLL UP AND CLEAR LINE
BYTE (7) 0 ;ROLL DOWN AND CLEAR LINE
BYTE (7) 0 ;PROTECT ON (CPOPJ IF NONE)
BYTE (7) 0 ;PROTECT OFF (CPOPJ IF NONE)
BYTE (7) 0 ;INSERT LINE (0 IF NONE)
BYTE (7) 0 ;INSERT SPACE (0 IF NONE)
BYTE (7) 0 ;DELETE LINE (0 IF NONE)
BYTE (7) 0 ;DELETE SPACE (0 IF NONE)
BYTE (7) 0 ;MOVE TO BOTTOM
BYTE (7) 0 ;HOME AND CLEAR ENTIRE PAGE
CPOPJ ;ROUTINE TO POSITION TO CHARACTER
CPOPJ ;ROUTINE TO POSITION TO START OF LINE
^D24 ;LINES PER PAGE
^D80 ;CHARACTERS PER LINE
0 ;TERMINAL-DEPENDENT FLAGS
CPOPJ ;ROUTINE TO CALL ON ENTRY
CPOPJ ;ROUTINE TO CALL ON EXIT
0,,0 ;NUMBER OF NULLS TO OUTPUT,,NULL CHARACTER
ITABLE ;ADDRESS OF INPUT CHARACTER TABLE
IFN FTIMD,<
0 ;START INSERT MODE
0 ;END INSERT MODE
>
0 ;MARK TO DISPLAY ON ENTER (OMIT IF MRK NOT SET)
There's not much there, since filling it in is what this
cookbook is all about.
CURSOR MOVEMENT
First, look in the terminal manual to find which character
sequences move the cursor up, down, right, left, and home (the upper
left corner). Put each sequence is the appropriate slot of the
table.
If the sequence is five characters or less, put the sequence
itself in the table. For example if CURSOR-UP were "ESCAPE A" the
first word of the table should contain
Page 4
ONAME: BYTE (7) 33,"A"
If the character sequence is longer than 5 characters, use the
following format:
ONAME: 37777,,[BYTE (7) 33,"A","B","C","D","E","F"]
If the sequence depended on something variable, like, say, the
current cursor position, you would need to write a subroutine to
handle the operation. Then put the label of the routine in the
appropriate slot of the table, thusly:
ONAME: MOVRGT
Usually the cursor positioning sequences are short enough to be
done the first way. The terminal may not be able to move the cursor
home (the upper left corner) in a single command; in that case put
the sequence to position to (0,0) or (1,1) in the CURSOR-HOME slot
of the table.
CLEAR TO END OF PAGE
The next table entry is the sequence which clears the screen
from the cursor position to the end of the page. Note: this is NOT
the sequence to clear the entire screen. Not all terminals can
clear to end of screen. If yours does, enter the sequence in the
table in one of the three formats described above. If your terminal
can't clear to end of screen, put a zero in the table position. The
zero tells SED to find some other way of clearing, and nothing else
is required from you.
CLEAR TO END OF LINE
Next comes the sequence which clears from the cursor position
to the end of the line. Set this up as above. If your terminal
can't do it put a zero in the table (which tells SED to simulate the
clear by outputting spaces. Hope your baud rate is high).
ROLL SCREEN UP AND CLEAR LINE
This is the sequence which will cause the terminal to move
every line on the screen up one, make the top line disappear, and
clear out the bottom line. You can assume that the cursor is at the
bottom left of the screen when this sequence is output.
For most terminals, this operation is done by outputting a
linefeed (Octal 12). Some terminals can do it other ways, too, but
if linefeed works use it. Put the linefeed or the sequence in the
table in the usual way.
Page 5
Beware: on some terminals the bottom line is not cleared, but
is actually the old top line wrapped around. If this happens, you
will need to put in the sequence to clear to end of line after the
sequence to roll. If that's more than 5 characters use the long
(second) format described in the cursor movement section.
If your terminal can't roll up (and some can't), put a zero in
the table. Then if SED wants to roll it will rewrite the screen.
ROLL SCREEN DOWN AND CLEAR LINE
This is similar to the above, except movement is in the
opposite direction. You can assume that the cursor is home when
this sequence is output. Handle this the same way as the ROLL UP
sequence. Put in a zero if you ain't got it.
Many terminals can roll up but cannot roll down, so it's common
to see a zero here and a sequence in the ROLL-UP position. Then SED
will roll up but rewrite the screen if it has to roll down, which is
the best it can do under the circumstances.
TURN HIGHLIGHTING ON AND OFF
Highlighting is anything which makes some characters on the
screen stand out from the rest. Reverse video, blinking, and half
brightness are the most common examples. Not many terminals can
highlight, so I'll take the negative case first.
If all you can get are normal vanilla characters, put a zero in
each of these two table positions. Then write down two things to do
later: set the MRK flag when you come to the flag word, and define
a mark in the last word of the terminal table. Both of these will
be taken up below.
SED uses highlighting in the following manner: it outputs the
sequence to turn highlighting on, then the highlighted characters
(which will always be on the same line), then the sequence to turn
highlighting off. Check to make sure your terminal's highlighting
works that way; most do; some don't. If yours doesn't work that
way, don't highlight.
Put the sequences which turn on and turn off highlighting in
the two table positions. The choice of what kind of highlighting is
done is up to you. Reverse video is usually the most noticeable and
least irritating.
INSERT AND DELETE LINES AND SPACES
The next four functions, INSERT-LINE, INSERT-SPACE,
DELETE-LINE, and DELETE-SPACE, are found only on fairly
sophisticated terminals, but they save SED a lot of work when they
Page 6
exist. If they don't exist put zeros in the table positions (it's
quite permissible to have zeros in some positions and sequences in
others).
INSERT-LINE puts a blank line above the line where the cursor
is, moves the rest of the screen down one line, and the bottom line
goes off the screen. DELETE-LINE removes the entire line where the
cursor is and moves everything beneath up a line. The new bottom
line is blank.
INSERT-SPACE puts a space where the cursor is and moves the
rest of the line one space to the right. Characters which go off
the right of the screen must go away, not wrap around to the next
line. DELETE-SPACE removes the character (not necessarily a space)
beneath the cursor and moves the rest of the line one space to the
left. The new rightmost character on the line is a space.
If your terminal has any of these, enter the appropriate
sequence or subroutine label in the table. Beware: the four
functions must behave as described above. Almost all do, but some
don't.
Terminals work in wondrous ways. The VT100, for example,
cannot do any of these things, but it can limit it's scrolling
region. It turns out that that capability can be used to simulate a
hardware INSERT- and DELETE-LINES. See the file SEDV10.MAC to see
how it's done. The moral is that there's more than one way to skin
a cat; be creative.
Also, some terminals can insert a space and some have insert
mode (which you turn on, output the characters you want to insert,
and then turn off). If your terminal has the only latter, simulate
the former by putting in that slot "START-INSERT-MODE, SPACE,
END-INSERT-MODE".
A final note: Some terminals can insert or delete any number
of lines or spaces in one sequence. You
MOVE TO THE BOTTOM OF THE SCREEN
The next function is something which terminals usually can't do
in one operation, but which SED finds useful. You can move to the
bottom left of the screen in a number of ways: for example, move
HOME and UP (if the cursor does not stick to the margins of the
screen), or position the cursor absolutely.
Whatever way you choose to reach the bottom of the screen, put
that sequence in the table. You must have something in this table
position, a short or long character sequence or a subroutine label.
Not a zero.
Page 7
HOME AND CLEAR ENTIRE PAGE
Almost every terminal can clear its entire screen. That
sequence goes here. Sometimes the cursor is moved HOME
automatically when the clear occurs, sometimes it is left wherever
it is. In that latter case, you must include the sequence to move
the cursor home, before or after the clear.
This table position can't contain a zero either.
CURSOR POSITIONING ROUTINES
The next two table positions contain the addresses of
subroutines which move the cursor to absolute positions on the
screen. The first routine moves to the row contained in accumulator
RW and the column contained in CM. The second moves the cursor to
the start of the row contained in AC T4.
The cursor positioning subroutines themselves are part of the
terminal module you are writing. Unfortunately there are nearly as
many cursor movement algorithms as there are terminals, so I can't
help you much here. Find out from your handy terminal manual how to
move the cursor around, and write the routines.
The file SED.POS contains sample cursor movement subroutines,
ones which are used in SEDTTY.MAC If your algorithm is included
among them, just copy the routines into your terminal module.
Otherwise you're on your own, but you can use the routines in
SED.POS as guides.
LINES PER PAGE AND CHARACTERS PER LINE
The next two table positions contain values: the number of
lines on the screen and the number of characters per line.
TERMINAL-DEPENDENT FLAGS
There are a number of flags which alter SED'S performance.
Most deal with terminal characteristics, and must be set in the
right way for SED to work right.
The flags are:
TBS HARDWARE TABS EXIST (AND ARE PRE-SET)
WRP LONG LINES WRAP AROUND TO NEXT LINE OF SCREEN
MRK NO PROTECTED FIELDS; THUS, MARK NEEDED ON ENTER
NEL DON'T BOTHER RE-WRITING LAST LINE OF SCREEN
SLW SLOW TERMINAL: WRITE ERROR MSGS ON BOTTOM LINE
NLP SEND NULLS AFTER ABSOLUTE CURSOR POSITIONING
NPG DON'T SET TTY NO PAGE (^S AND ^Q REMAIN XOFF AND XON)
Page 8
Explanations:
(TBS) If hardware tabs do not exist they must be simulated
using CURSOR-RIGHT's. Beware: a lot of terminals have hardware
tabs, but they must be set up by someone. If SED expects tabs but
they are not set up it will go bananas, so don't set the TBS flag
for these terminals (or enable the tabs in the terminal-specific
entry subroutine, described below).
(WRP) Lines in the file which are too long for the screen will
either lock on the right margin or wrap around to the next line,
depending on the terminal. SED's display routine needs to know
which one the terminal does, or else long lines will not display
properly. Note: some terminals, such as the VT100 (in wrap mode)
will wrap before the 81st character is typed, rather than after the
80th. Do not set the WRP flag for those terminals and they will
work o.k.
(MRK) A protected field is one which SED wants to highlight.
For example, when you type ENTER, SED will highlight the character
at the cursor position (by making it reverse video, for example).
It's useful to mark that cursor location, so if the terminal does
not have any highlighting features, the MRK flag indicates that a
certain mark should be put at the cursor location when ENTER is
typed. The character code for that mark is contained in the last
word of this table (if MRK is not set that mark word can be
omitted).
(NEL) Make SED not care about keeping the bottom line of the
screen up to date. If your terminal runs at a slow speed, but has
enough lines on the screen that it can afford to give one away, then
some re-write time can be saved by setting the NEL flag.
(SLW) Causes error messages to be written on the bottom line of
the screen. The remainder of the screen is not affected (normally
the whole screen is erased and re-done). You can save SED a lot of
rewriting by setting the SLW flag; set it if your terminal is slow.
In fact, set SLW anyway; it's error display is more fun than the
default way.
(NLP) If your terminal needs to idle a while after positioning
the cursor, set the NLP flag, and set the NUL word of the table to
the number of nulls to send and the character to use.
(NPG) Some terminals that run at 9600 baud (and others) will
send CONTROL-S (XOFF) to the computer to tell it to stop
transmitting and CONTROL-Q (XON) to tell the computer to resume.
SED cannot distinguish XOFF and XON from DELETE-SPACES and
ROLL-BACK-PAGES, so if the terminal persists in sending XON's and
XOFF's set the NPG flag and don't use CONTROL-S and CONTROL-Q as
editor commands.
Page 9
Some terminal modules in SEDTTY.MAC have a switch which
contains the word "FAST", and then duplicate table definitions (in
some cases, entire duplicate tables) which implement SED with
XON-XOFF either on or off. The VT100 family tables are an example.
This was usually done because if the terminal is run at slow speeds
(less than 4800), CONTROL-S and CONTROL-Q can be used as editor
commands, but if they are run at 4800 or 9600 then those characters
must be used as XON-XOFF.
ENTRY AND EXIT ROUTINES
If your terminal needs to be initialized (TABS set up, for
example), write a subroutine to do whatever is necessary and put its
address in the appropriate table position. That routine will be
called just before SED reads in the file you want to edit.
Similarly, if you need to reset things before exiting from SED,
write a subroutine and put its address in the next table position.
That routine is called just before SED exits.
If nothing special needs to be done put a CPOPJ in these
positions.
Page 10
NUMBER AND TYPE OF NULLS TO OUTPUT
There are a number of situations where SED needs to delay and
let the terminal finish what it is doing. The most reliable delay
tactic is to send some nulls to the terminal. A null is any
character which causes no action from the terminal. 000 is the
classic null, but beware: some terminals or communication lines
ignore 000's, and the desired delay does not occur. Suggestions:
RUBOUT (177) or CONTROL-F (006). Anyway, the situations which need
a delay are set up in the terminal characteristics flags, described
elsewhere, and the number of nulls to output for each delay and the
null character are defined in the NUL word of the terminal output
table. If no delay is ever required (the "usual" case) set the NUL
word to 0 and don't set any of the NL? characteristics flags.
ADDRESS OF THE TERMINAL INPUT TABLE
The terminal input table tells which sequence of characters
coming from the terminal invoke which commands. The next section of
this manual describes how to write the input table.
Put the address of the input table in this position.
START OR END INSERT MODE
These two table slots are under a feature test switch, FTIMD,
which is defined in SEDSYM.MAC. Its default value is on (==1).
Start/end insert mode are new entries in the terminal output table,
and the FTIMD switch is included for compatibility with older
versions of SED. If you are installing SED for the first time,
leave FTIMD set and include these two table slots, even if your
terminal doesn't have insert mode. If you are re-installing SED,
please modify your terminal modules to include the insert mode
slots, and leave FTIMD on.
If your terminal has insert mode SED can output
START-INSERT-MODE. Then any characters (on the same line) be
"inserted" into the line - existing characters will be pushed to the
right; not overwritten. Outputting END-INSERT-MODE will return the
terminal to normal replace mode. If your terminal does not have
insert mode, put zeroes in both slots.
If the sequences for START-INSERT-MODE and END-INSERT-MODE are
the same, no sweat. Put the same sequence in both table slots. SED
will understand.
MARK TO DISPLAY ON ENTER
If you do not have the MRK flag set, skip this. You don't even
need to include this word in the table, and it will be ignored if it
is there.
Page 11
If you have MRK set (usually because your terminal cannot
highlight characters), put in this table position the single
character which you would like to be displayed as a place marker in
your file. Any character will do, but a little experimentation may
be needed to decide on one which is easy to locate on the screen.
Page 12
THE TERMINAL INPUT TABLE
The terminal input table tells what you type at the terminal to
invoke which commands. Building this table takes a little more work
than building the output table, because you can set up the editor
commands on the keyboard just about any way you want.
ARRANGING THE COMMANDS
The first step is to find out what things on your terminal
keyboard can be used to invoke commands. Control characters should
be used for most of the commands, as they are the easiest to type.
Any special keys can also be used as commands; look in your
terminal manual to find out what sequences of characters those keys
transmit.
There are 55 commands. If you don't have enough control
characters and special keys to take care of them all you can set up
the remainder as control sequences (a control character followed by
one or more characters). For example, you might define the <WINDOW>
command as ESCAPE W, <MARK> as ESCAPE M, and <CASE> as ESCAPE C.
The SED user would be expected to type those two-character sequences
in order to invoke those commands (so set up the less frequently
used commands this way).
Note that if you use a control character as the start of a
sequence it cannot also be used by itself to invoke a command. If
CONTROL-A L is <SLIDE-LEFT>, then CONTROL-A alone cannot be a
command.
When you have a list of the available control characters and
sequences, link them up with ther editor commands. Use the
worksheet on the next page, if you like.
Page 13
WORKSHEET (PAGE 1)
WHICH COMMANDS ARE INVOKED BY WHICH TERMINAL SEQUENCES
COMMAND NORMAL YOUR COMMAND NORMAL YOUR
NAME AND TITLE SEQUENCE SEQUENCE NAME AND TITLE SEQUENCE SEQUENCE
Cursor Movement Inserting and Deleting
$CURUP CURSOR-UP ______ $INSSP INSERT-SPACES ^A ______
$CURDN CURSOR-DOWN ______ $DELSP DELETE-SPACES ^S ______
$CURLF CURSOR-LEFT ______ $INSLN INSERT-LINES ^D ______
$CURRT CURSOR-RIGHT ______ $DELLN DELETE-LINES ^F ______
$CURHM CURSOR-HOME ______ $PICK PICK ^V ______
$RETRN CARRIAGE-RETURN ^M ______ $PUT PUT ^G ______
$TAB TAB ^I ______ $MARK MARK ______
$BKTAB BACKTAB ^U ______ $DELCH DELETE-CHARACTER ^H ______
$BLINE BEGIN-LINE ______ $ERSWD ERASE-WORD ______
$ELINE END-LINE ______ $ERSLN ERASE-LINE ^J ______
$UPTAB UP-TAB ______ Searching
$DNTAB DOWN-TAB ______ $SRCFW SEARCH-FORWARD ^R ______
Screen Motion $SRCBK SEARCH-BACKWARD ^E ______
$ROLBP ROLL-BACK-PAGES ^Q ______ $SUBST SUBSTITUTE ______
$ROLFP ROLL-FORWARD-PAGES ^Y ______ File Control
$ROLBL ROLL-BACK-LINES ^W ______ $EXIT EXIT ^Z ______
$ROLFL ROLL-FORWARD-LINES ^T ______ $ABORT ABORT ^C ______
$SLDLF SLIDE-LEFT ^K ______ $STFIL SET-FILE ^B ______
$SLDRT SLIDE-RIGHT ^L ______ $SAVE SAVE-FILE ______
$GOTO PERCENT-GOTO ^P ______
Page 14
WORKSHEET (PAGE 2)
WHICH COMMANDS ARE INVOKED BY WHICH TERMINAL SEQUENCES
COMMAND NORMAL YOUR
CODE AND NAME SEQUENCE SEQUENCE
Parameter Control
$ENTER ENTER-PARAMETER ______
$RESET RESET RUBOUT ______
$RECAL RECALL ______
Miscellaneous
$SWTCH SWITCH ^N ______
$ENTCC ENTER-CONTROL-CHAR ^O ______
$EXEC EXECUTE ^X ______
$INMOD INSERT-MODE ______
$RLTAB REAL-TAB ______
$CASE CASE ______
$WINDO WINDOW ______
$RWRIT RE-WRITE ______
$HELP HELP ______
$TBSET TAB-SET ______
$JUSTI JUSTIFY ______
$MARKR MARKER ______
$ERROR ILLEGAL-COMMAND ______
$PUSH PUSH (TOPS-20 ONLY) ______
Page 15
If the "normal" sequences given above seem a little chaotic it
is because the commands are arranged on the keyboard so that similar
commands are nearby. The name of the key has nothing to do with the
nature of the command invoked. Most SED users agree that this
system is better than having commands linked to keys which are
mnemonic but which are located far apart (like CONTROL-F and
CONTROL-B for <SEARCH-FORWARD> and <SEARCH-BACKWARD>, for example).
The general layout is:
.____.____.____.____.____.____.____.____.____.____.
! Q W ! E R ! T Y ! U I ! O ! P !
! ROLLS AND SEARCHES ! !ENTR!PERC!
! BACK FORWARD ! TABS !CCH !GOTO!
!_.__!____!____!____!_.__!_.__!_.__!_.__!____!_.__!
! A S D F ! G ! H ! J ! K L !
! ! !CUR !ERAS! !
! INSERT/DELETE !PUT !LEFT!LINE! SLIDES !
!_.__!_.__!_.__!_.__!_.__!_.__!_.__!_.__!____!
! Z ! X ! C ! V ! B ! N ! M !
! ! ! ! !SET ! !RE- !
!EXIT!EXCT!ABRT!PICK!FILE!SWCH!TURN!
!____!____!____!____!____!____!____!
Also, RESET is invoked by the RUBOUT (DELETE) key.
Most terminals have special keys with arrows on them which can
be used for the cursor movement commands. The terminal manual will
tell you what sequences they send. If there is no key for
<CURSOR-HOME>, locate it near the arrow keys.
SETTING UP THE TABLE
Now it's time to introduce you to the terminal input table
itself. In SEDX.MAC the table looks like:
EXP $RESET ;RUBOUT
IVT52: EXP $RECAL, $INSSP, $SETFI ; 0, A, B
EXP $ABORT, $INSLN, $SRCBK, $DELLN ;C, D, E, F
EXP $PUT, $DELCH, $TAB, $ERSLN ;G, H, I, J
EXP $SLDLF, $SLDRT, $RETRN, $SWTCH ;K, L, M, N
EXP $ENTCC, $GOTO, $RLBKP, $SRCFW ;O, P, Q, R
EXP $DELSP, $RLFWL, $BKTAB, $PICK ;S, T, U, V
EXP $RLBKL, $EXEC, $RLFWP, $EXIT ;W, X, Y, Z
-SV52.S,,SV52.T ;ESCAPE
EXP $PUSH, $CURRT, $SUBST, $SAVE ;\, ], ^, _
The 5th slot in the table, for example, tells what happens when
the user types a CONTROL-E (which has Octal code 5); the 34th slot
tells what happens to a CONTROL-\ (which might be invoked by a
special or cursor movement key); and so forth.
Page 16
The command which is invoked by the RUBOUT (or DELETE) key is
given by the location just ahead of the table (in this case $RESET).
If a control character invokes a command directly the
corresponding slot in the table contains the name of that command.
If CONTROL-B invokes the <SET-FILE> command then slot 2 of the table
contains $SETFI. If CONTROL-B invoked <SEARCH-FORWARD> then slot 2
would contain $SRCFW.
Things get more complicated when it comes to control sequences.
In this example, ESCAPE (slot 33) is the start of a number of
control sequences (the example is based on a VT52 terminal, where
ESCAPE is the first character sent out by all the cursor movement
and special keys). Slot 33 contains not a value but a pointer to a
subtable. The right half of the pointer is the address of the
subtable and the left half is the negative of its length.
The subtable might look like:
SV52.T: $CURUP,,"A"
$CURDN,,"B"
$CURRT,,"C"
$CURLF,,"D"
-SV52.S==.-SV52.T
Here, <CURSOR-UP> is invoked by Escape-A, <CURSOR-DOWN> by
Escape-B, <CURSOR-RIGHT> by Escape-C, and <CURSOR-LEFT> by Escape-D.
More details about subtabled are given in the next section.
Page 17
PROCEDURE FOR WRITING THE TERMINAL INPUT TABLE
A) Look in the terminal's manual to see which sequences are output
by cursor movement keys and any other special keys which you want
SED to use. Note that the first character of those sequences
cannot be used for commands. For example, if the cursor movement
keys are Control-D A, Control-D B, Control-D C, and Control-D D,
then don't make Control-D by itself invoke a command (on most
terminals, these sequences start with Escape, but there are lots
of exceptions).
Also note special keys which send control characters. If the
Cursor-Down key sends Control-J, then Control-J on the keyboard
must also mean Cursor-Down. SED can't tell the what key was
typed, just what sequence was sent. In the standard layout,
Control-J is <ERASE-LINE>, but in this case you will have to find
some other sequence for that command.
B) Fill in the command worksheets with the control characters and
sequences you want to invoke each command. Note that Control-\,
Control-], Control-^, and Control-_ (Octal codes 34-37) can all
be commands (sometimes they're easy to type, sometimes not).
Rubout is legal, too. Control-Space (Octal 0) is legal on
TOPS-10, but not on TOPS-20.
You're on your own as to which special keys to assign to which
commands. If your terminal doesn't have special keys, here's
your chance to be really creative. The usual cop-out is to
define Escape-Character to mean a command which is hinted at by
the Character (Escape-C for <CASE>, for example). Escape-Escape
can mean <ENTER>.
C) Build the terminal tables, as follows:
1) Put command invoked by Rubout (which is normally $RESET. $DELCH
(<DELETE-CHARACTER>) is also a possibility) in location -1 of the
table.
2) For every control character which invokes a single command, put
in the command's name (A==$INSSP, B==$SETFI, etc).
3) For every control character which invokes more than one command,
put in a subtable pointer entry. That entry looks like
-LENGTH,,TABLE-ADDRESS
There can be more than one subtable.
Do steps 2) and 3) for each of the 32 control characters.
4) Now build the subtables. Each subtable looks like:
SUBTB: TABLE-ENTRY
TABLE-ENTRY
Page 18
...
SUBTL==.-SUBTB
the pointer in 3) to this subtable is -SUBTL,,SUBTB.
TABLE-ENTRY's in the subtable can take a number of forms:
a) If the command is 2 characters long, put in an entry like:
COMMAND,,CHARACTER (example: $CASE,,"C")
b) If it's 2 long but it doesn't matter what the second character
is:
COMMAND,,0
c) If it's longer than two characters:
SSTABLE-ADDRESS,,CHARACTER (example: SSBTAB,,"[")
SSTABLE is a sub-subtable. It's format is the same as that of
the subtable, with one additional thing: the last entry must be
a 0 word, which tells SED when to stop looking down the table
(since it doesn't have a table length to tell it when to stop).
There can be any number of levels of sub-subtables. The number
of levels depends on the number of characters in the sequence
that invokes the command.
For example, suppose <CURSOR-UP> is invoked by Escape-[-A (and
there are other commands which start with Escape-[). Then the
33rd location of the input table would contain "-SUBTL,,SUBTB".
There'd be a subtable labeled SUBTB: containing the entry
"SSTAB,,"[" ", and a sub-subtable labeled SSTAB: looking, in
part, like:
SSTAB: $CURUP,,"A"
...
0
That's all there is to it.
SUMMARY: WHAT KINDS OF BEASTS LIVE IN THE TERMINAL INPUT TABLE:
DESCRIPTION EXAMPLE WHATZIT
command-name $SWTCH name of the command invoked
-length,,address -4,,SUBTAB subtable pointer for sequences
which begin with this control
character
-big,,address -100,,SUBTAB ditto, if subtable ends with a
zero
Page 19
BEASTS LIVING IN SUBTABLES:
name,,character $CURHM,,"H" code of command whose invoking
sequence ends with the given
character
address,,character SSUBTB,,"O" sub-subtable pointer for given
character
code,,0 24,,0 command code which will match
on anything
0 0 optional end-of-table word
Page 20
APPENDIX A - SEDECO
SEDECO is a tool to tell you 1) what character sequences are
sent by a terminal's special keys, or 2) shows you what the terminal
does when some character sequence is typed in.
LOOKING AT WHAT THE TERMINAL SENDS
To check out the special keys, edit SEDECO.MAC and set CONV==1.
Also, if you are running TOPS-10, set TOPS10==1. If it's TOPS-20,
set TOPS10==0. Then assemble SEDECO (LOAD SEDECO ... SAVE).
Then run SEDECO. If you type, for example, "ESCAPE A
CONTROL-A" SEDECO will echo "CTRL-[(033)A(101)CTRL-A(001)". That's
the name of the character with its octal code in parentheses. All
characters will echo this way, except that Carriage Return will also
move to a new line, and Control-C will exit from SEDECO. When you
push a special terminal key, the characters it sends will be echoed
as above. Most such keys send escape (or some other control
character) followed by a number of printing characters.
Beware: if your terminal keyboard needs to be set up in a
special mode (for example, the VT52 and VT100 needs to be set in
alternate keypad mode) you will have to set it yourself somehow.
One good way is to run SEDECO in its other mode (CONV==0, described
below) and type the character sequence that sets that mode.
SEEING WHAT HAPPENS WHEN YOU TYPE THINGS
If you want to see what the terminal does when you type certain
character sequences (for example to verify that the sequence that
the terminal manual says will clear the screen really does so), edit
SEDECO.MAC and set CONV==0. Also, if you are running TOPS-10, set
TOPS10==1. If it's TOPS-20, set TOPS10==0. Then assemble SEDECO
(LOAD SEDECO ... SAVE).
Then run SEDECO. Your type-in will be sent to the terminal
exactly as you type it. Printing characters will echo. Escape- (or
control character-) sequences will probably not echo, but will do
special things as described in the terminal manual.
To exit SEDECO, type Control-C.
Page 21
APPENDIX B - SEDTTY
SEDTTY contains all the tables and routines for the terminals I
know about. It may interest you for three reasons: 1) if some of
your terminals are defined in SEDTTY it will save you most of the
trouble of writing them yourself; 2) if you have more than one type
of terminal, SEDTTY contains code to read the terminal type from the
monitor and decide which tables to use (if you have only one type of
terminal then that code is not assembled, thus saving the wasted
space and overhead); and 3) the tables and routines in SEDTTY can
serve as guidelines for writing your own module(s).
If you have only one terminal type, and it's not included in
SEDTTY, you can either modify SEDX.MAC and load it with SED (as
described in SEDX), or add your stuff to SEDTTY, under the
appropriate switch, and load SED with SEDTTY. SEDTTY contains
guidelines for defining labels and symbols in order to make sure
they are not multiply defined. However, with one terminal type,
there's not much advantage in using SEDTTY.
If any of your terminals are defined in SEDTTY, please look
over their input tables to make sure that they do the right things
(the output tables are probably O.K.). Most of the input tables are
not up to date, and some are real old. Most were sent by the people
who wrote them so I could include them in my distribution - they are
for terminals I have never seen. I have not modified them, since I
have found that changing something I can't test is very risky. If
you improve an out-of-date terminal tables and send them to me I'll
update my copy of SEDTTY.
The tables for the VT52 and VT100 family of terminals are
up-to-date. I use those terminals every day.
There are two things to be careful of if you want to use the
tables for some terminal other than the VT52 or VT100 family: 1)
there may be no sequences defined to invoke SED's newest commands,
and 2) the keyboard definitions may vary greatly from the standard
layout.
Here are SED's newest commands, oldest first. If one of them
is missing from the terminal module, probably the ones newer than it
are also missing.
Page 22
CODE NAME DESCRIPTION
50 $ERSLN Erase from cursor to end of line
52 $UPTAB Up-tab (up 6 lines)
53 $DNTAB Down-tab (down 6 lines)
54 $REWRT Rewrite screen
55 $SAVE Save file
56 $HELP Give on-line help
57 $BLINE Move to start of line
60 $ELINE Move to end of line
61 $ERSWD Erase previous word
62 $PUSH Push to EXEC (TOPS-20 only)
63 $SUBST Substitute
51 $TBSET Set/clear tab stops (NOTE: out of sequence)
64 $ERROR Illegal command (gives an error)
65 $JUSTI Justify text
None of these commands have any "standard" invocation, so
you're on your own as to how to implement them. The $BLINE and
$ELINE commands supercede the $LINE command, which is now obsolete.
Page 23
APPENDIX C - MISCELLANEOUS INFORMATION
There are a number of assembly parameters at the beginning of
the editor program:
STKSIZ==20 ;SIZE OF PUSH-DOWN STACK
MAXSIZ==^D1200 ;MAXIMUM FILE SIZE (BLOCKS) THAT CAN BE EDITED
PCBSIZ==600 ;SIZE OF PICK AND CLOSE BUFFER
PARBLN==40 ;SIZE OF PARAMETER BUFFER
NOBYTE==140 ;LENGTH OF LOOK-AHEAD WHEN SEARCHING FOR NULLS
SQZVAL==100 ;NUMBER OF DELETE COMMANDS BETWEEN SQUEEZES
XBFNUM==50 ;NUMBER OF EXECUTE BUFFERS
XCFSIZ==XBFNUM*3 ;SIZE OF EXECUTE BUFFER FREE SPACE
TYPSIZ==40 ;SIZE OF TYPE BUFFER
JRNSIZ==26 ;SIZE OF JOURNAL BUFFER
None of these except MAXSIZ, XBFNUM, and NOBYTE should need to
be modified unless the spirit moves you.
MAXSIZ: SED will not try to edit a file which is longer than
MAXSIZ. It is set as large as it should be. Make it smaller
if you want to prevent large files from being edited.
XBFNUM: tells how many different execute buffers a user can have at
the same time. It can't be larger than 64 (octal 100). The
only reason to make XBFNUM small is is to save memory;
however, it won't save much, so don't bother unless memory is
really a problem at your site (Note: XCFSIZ used to be the
size of each buffer, now it determines the size of free space
area from which buffers are allocated dynamically. Three words
per buffer may seem small, but I've found it to work out well.
If a user creates 40 buffers most of them are smaller than
three words, so he can afford a couple of long ones.
NOBYTE: tells how far SED looks for nulls when it wants to open a
hole in the file. SED will first look NOBYTE non-zero bytes
forward from the cursor position to see if it can find enough
nulls. If it can't find enough it will then move everything
from the cursor position to the end of the file forward.
NOBYTE should be large enough that the desired nulls will be
found often, but small enough that time is not wasted searching
for nulls that are not there. Its optimal value depends on the
individual user and what he is doing to the file. The given
value works O.K., whatever O.K. means. If you want to change
NOBYTE, study the results carefully, as it can affect SED's
performance noticeably.
Quick descriptions of the other parameters:
STKSIZ: Size the the push-down stack. This only affects the number
of levels you can stack execute constructs, and 16 is plenty.
Page 24
PCBSIZ: if a pick or delete is done longer than 5*PCBSIZ characters
the buffer will be written to disk. That costs overhead, so
PCBSIZ should be high. On the other hand, 2*PCBSIZ words of
memory total are used for the pick and delete buffers, so lower
it if memory is a problem.
PARBLN: the longest parameter allowed is 5*PARBLN characters. The
only large parameters are search keys (which can be long but
usually won't be) and execute buffers (when read or listed with
the R or L formats).
SQZVAL: every SQZVAL times a large delete is done SED passes
through the file and removes null words. Otherwise SED likes
to keep nulls around so it can use them for later inserting.
But too many nulls will slow SED down, since it has to pass
over them while looking for other things.
TYPSIZ: Text is output to the terminal when necessary or when SED
has 5*TYPSIZ characters to output. A large value saves
overhead, a small one makes SED easier to interrupt while it is
re-displaying the screen.
JRNSIZ: If you are writing a journal, your commands are appended to
the journal every 5*JRNSIZ "characters". A command counts as
three of these characters. A small value means the journal is
updated more frequently, so less is lost on a crash; but it
costs more overhead. And journaling overhead is high.
SEDSYM.MAC has a number of switches, some independent of
operating system, and some specific to TOPS-10 or to TOPS-20. They
are described below.
TOPS10: set to one if your operating system is TOPS-10, to 0 if
it's TOPS-20.
FTIMD: Two words were added to the terminal output table, telling
how to enter and exit insert mode. For compatibility with
older versions they are under the FTIMD feature test. My
advice is to set FTIMD and add those words to your table(s).
NEWTAB: A very old version of SED had a slightly different
arrangement of commands. If you don't know what it was,
consider yourself lucky and leave NEWTAB set.
FTJOUR: Journaling is under this feature test switch, and is turned
OFF on the distribution tape. That's because journaling is an
expensive operation and it takes a lot of code. It can be a
lifesaver, however, and worth the cost. If you want your users
to be able to journal, set FTJOUR to 1.
Page 25
FTTST: This switch surrounds code which I am testing, but for some
reason do not want to release. If you're curious go ahead and
set it. But don't say I didn't warn you (I can't describe what
things are under FTTST because they are constantly changing.
Look at the sources).
FTDDT: If you're debugging SED a lot, set this switch to 1. It
causes the symbols to stay around.
The following switches are meaningful only on TOPS-10:
FTKA10: Set this if your processor is a KL-10. Then KI-KL-only
instructions are simulated for the KA.
FTTMPC: If set, FTTMPC causes the information about the previous
two files edited to be written to TMPCOR. If cleared, the it's
written to nnnSED.TMP. Clear it if you don't have much TMPCOR
FTSFD: If FTSFD is 0 SED will not allow sub-file directories on
filespecs. If it's 1, then set SFDLVL to the number of SFD
levels that are allowed on your system.
The following switches are meaningful only on TOPS-20:
FTSTSN: If FTSTSN is 1, statistics on SED will be entered in the
monitor's subsystem tables. These are possibly useful if you
want to track SED's performance (but I find that an essential
datum is missing: what the users are doing during their
editing sessions).
FTECHO: If FTECHO is 0, SED turns off echo and reads characters one
by one. SED outputs printing characters itself. If it's 1 SED
allows the monitor to echo printing characters and terminate on
control characters. When SED is reading a command sequence it
puts the terminal in no-echo, single character read mode. The
==1 method probably puts less of a strain on the system than
the older ==0 method, but it's still experimental. If you like
trying new things, set FTECHO and see how you like it. Ideally
there should be no difference in the way SED acts (in fact,
there are a couple of minor differences), but performance
should be better.