E.ALS[UP,DOC] - www.SailDart.org

perm filename E.ALS[UP,DOC] blob sn#870344 filedate 1989-02-24 generic text, type C, neo UTF8

COMMENT ⊗ VALID 00043 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00007 00002 Recent NEWS about E, newest news first.
C00080 00003 INDEX of commands.
C00123 00004 Abbreviations and explanation of E documentation. Credits.
C00130 00005 General remarks.
C00143 00006 PAGE CHANGING, APPENDING, DIVIDING, COMBINING, CANCELLING: XAPPEND XTHISPAGE β<ff> XMARK XDELETE XCANCEL
C00156 00007 windowful and ARROW moving commands.
C00176 00008 LINE MARKING commands.
C00183 00009 LINE-EDIT commands.
C00208 00010 Attach and Copy commands: A C E αβK αβR
C00222 00011 LINE INSERT mode.
C00236 00012 Handling very long lines. XBREAK XJOIN
C00243 00013 Search commands: F XFIND * XEXACT F<string>P F<string>: XSSLINE XSSPAGE
C00275 00014 SUBSTITUTION commands: \
C00290 00015 FILE-SWITCHING and text transfering commands: ε λ ∃ ? XPOINTER
C00310 00016 Justification: XJFILL XJUST XJGET XSJFILL XSJUST
C00334 00017 Commands for tabular material: XTABLE XTJFILL XTJUST XTJGET XTGET
C00351 00018 MARGIN CONTROL commands: XALIGN XINDENT → ← XCENTER
C00363 00019 Other EXTENDED commands: X<cmd> Xα<cr>
C00404 00020 System commands and file SWITCHES.
C00441 00021 Using E from a non-display (TTY). XTYPE XNUMBERS XHEADER XTRAILER XCONTROL XMETACONTROL
C00459 00022 PARENTHESIS finding/matching commands: ( ) XLPAREN XRPAREN ↔ XPAREN XPINFO
C00474 00023 Swapping To and From E via RPG startups: XRSYS XRUN XGORPG XDRD XTV
C00484 00024 Message and paragraph handling commands: ∂<cmd> 0∂ !<cmd> 0!
C00501 00025 Macros: XDEFINE Z Y ≡ ∩ ∪ ⊂ ⊃ $ % ~ _ XCASE XRESUME XABORT # XSTOPALL XSTOPONE XSTOPZERO XSTOPHOW XSILENT XRAPID XMALTMODE XPRINT XYSET XRAPID XLETEST
C00543 00026 Numeric Macros and Readonly Variables: XSET XARGUMENT XMULTIPLY XDIVIDE XREMAINDER XADD XSUBTRACT XMINIMUM XMAXIMUM XIFLT XIFLE XIFGE XIFGT XIFEQ XIFNE XCHARACTER
C00575 00027 Macros and Command Files: XEXECUTE PUTDEFS XCOMMENT XATTACH XREDEFINE
C00594 00028 Debugging macros: XSAY XAUTOSTEP XSTEP &
C00604 00029 BOOK MODE (/B) and the BOOK command
C00614 00030 E files extended by other programs. XUPDATE -XUPDATE
C00622 00031 Filenames, PPNs, file copying, numeric extensions, and filehacks
C00638 00032 Generating a new directory line: XNDFAIL XNDSAIL XNDBBOARD
C00653 00033 Altering the use of the display screen: XTOPSET XBOTSET XATTSET XHEIGHT
C00661 00034 αβS. N,O,H: Line, Page & File stacks. XHOME XBACKGO XZFILES XZPAGES XZLINES
C00685 00035 Undeleting lines of text: XUNDELETE
C00693 00036 Lisp code indenting commands: α/ αβ/ XLISPSYNTAX
C00706 00037 Case-changing commands: XUPPERCASE XLOWERCASE XOTHERCASE
C00713 00038 Use of PTY and Lisp subjobs from E: = XEECHO XEVAL XIECHO XINTERRUPT XLATTACH XLFILE XLPEND XLRECEIVE XLTYPE XRECONNECT XREEVAL XSCREEN XSLISP XSUBDETACH SUBECHO XSUBFIND XSUBJOB XSUBKILL XSUBLINK XSUBWAIT XSULISP
C00774 00039 Multiple Windows: π G ≠ XCONTINUE XEXIT XQUIT XBOTSET XTOPSET XRAISEWINDOW XTRADEWINDOW
C00815 00040 Header flags and their meanings
C00818 00041 What to do if E can't open your file to write it out
C00823 00042 File renaming or deleting: XRENAME XFILEDELETE
C00827 00043 Sending message to users and/or terminals from E: XMAIL XSEND XREMIND
C00840 ENDMK
C⊗;
Recent NEWS about E, newest news first.
Index of E commands is on p. 3; table of contents is on p. 1.
A history of older E changes is in E.UPD[UP,DOC].

[Note: Some news below hasn't yet been incorporated into the rest of this file.]

∂23 Feb 89 -- New STRING readonly variables, useful with ⊗XATTACH, ⊗XSET, ⊗0⊗Z.

There is now a new type of readonly variable, namely one whose value is
a string (rather than a number). The string may contain any characters
necessary to represent the variable's value. As with other readonly
variables, the names of string readonly variables consist of up to six
letters followed by a dot (.). For instance, the string readonly variable
DAY. contains the day of the week, e.g., Thursday.

String readonly variables can only be used in three commands: (1) the
⊗XATTACH command, (2) the ⊗XSET command, and (3) the ⊗0⊗Z command. For
instance, ⊗XATTACH DATE.<cr> will attach a line containing the current
date, ⊗XSET X←FILE.<cr> puts the current filename into macro X, and
⊗0⊗ZTIME.<cr> will type out the current time.

Note that ⊗XATTACH can be used with numeric, as well as string, readonly
variables. It will attach a line containing the variable's value (e.g.,
⊗XATTACH LINES.). Formerly, ⊗XATTACH only worked for actual macros.

Here are the available string readonly variables.

String
Readonly
Variable Value Example

FILE. Name of the current file E.ALS[UP,DOC]
FILEPL. Name of file, with /P and /L switches E.ALS[UP,DOC]/2P/31L
indicating the current location

TIME. Current time, in 24 hour format 18:09
TIMSEC. Current time in seconds 18:09:23
DAY. Current day of the week Thursday
DATE. Current date 02-Feb-89
DATTIM. Date and time 02-Feb-89 18:09
DATSEC. Date and time in seconds 02-Feb-89 18:09:23
DAYTIM. Day of week, date and time Thursday 02-Feb-89 18:09
DAYSEC. Day of week, date and time in seconds Thursday 02-Feb-89 18:09:23

∂2 Feb 89 -- Modification to ⊗#⊗ε and ⊗#⊗λ commands to match ⊗∃ commands.

The ⊗#⊗ε and ⊗#⊗λ commands now takes arguments of from 1 to 8 instead of
from 0 to 7, in order to match the new file numbers typed out by ⊗∃ (see
20 Jan 89 below). Also, ⊗0⊗ε and ⊗0⊗λ simply type out the list of files,
just like ⊗∃ and ⊗0⊗∃ do. The ⊗ε and ⊗λ commands with no arguments are
unchanged -- they still ask for the name of a file to edit.

∂20 Jan 89 -- Fix to NFOUND. readonly variable; modification to ⊗∃ commands.

The NFOUND. readonly variable now properly returns 0 if no search was done
because you haven't given a search string yet. Also, NFIND. returns 0 in
this case so that macros can detect this situation.

The ⊗∃ command and the seldom-used ⊗#⊗∃ command (which switches to file
number #) now count file numbers from 1 to 8 (instead of 0 to 7). As a
result, ⊗0⊗∃ now means the same as ⊗∃ (just report names and numbers of
files). Correspondingly, FINDEX. (see just below) returns 1 to 9 (with 9
meaning the "?" file, E.ALS[UP,DOC]).

∂4 Jan 89 -- New readonly variable FINDEX.

The new readonly variable FINDEX. has a value of from 0 to 8 indicating the
index of the current file in the "∃" file list (type ⊗∃ to see the list,
and ⊗#⊗∃ to go to file number # in the list). The value 8 means you're in
E.ALS[UP,DOC]. (See above entry: FINDEX. now runs from 1 to 9.)

∂24 Jan 88 -- E updates display when starting to ripple for α∂αβD or ⊗XDelete.

This is particularly helpful when you've deleted a new page from your
message file and E has to ripple to make room in the directory for other
new pages. During such a ripple, you get to look at the next new page.

Also, α∂αβD now avoids rippling the file unnecessarily when the directory
line for the page you're deleting was all that would have caused a ripple.

∂28 Jun 87 -- Old E bug fixed ("WRITE CODE ERROR FOR OBLK") -- details below.

This bug used to strike if you tried to write out text containing an
incore pagemark that ended a page needing more than 256 disk records
(32768 characters). For instance, an ⊗XMARK command given at the end of a
very big page would cause E to issue the above error message and stop with
the warning, "FILE MAY HAVE JUST BEEN CLOBBERED ON PAGE BEYOND FINAL
INCORE TEXT." However, the file generally wasn't clobbered at all.

(Turns out that E had only an 8-bit field for the number of records used
by an incore page that is followed by another incore page. Now the field
is 18 bits, so you can use ⊗XMARK (etc.) after a page that is up to 262144
disk records (167,772,160 characters -- about 1/5 of SAIL's file system
space). However, E has at most 131072 words of core in which to store
incore data, so you'll hit that limit (655360 chars max, usually much
lower) before hitting the record limit.)

∂21 Apr 87 -- α<cr> to "File?" prompt loads line editor with last file's name.

When you're switching files, you can type α<cr> to get E to load the line
editor with the name of the last file edited (the file you're coming
from). You can then edit the filename and type <cr> to switch to a file
with a similar name. Note that this works even if the α<cr> is preceded
by (part of) a filename (which is then ignored).

∂17 Feb 87 -- Incore pagemarks can be created and deleted even in /R mode.

You can now use β<form> to insert a pagemark even in readonly mode. And
you can use αβD to delete a pagemark in readonly mode. And ⊗XAPPEND works
now even on unformatted files. (If any of these cause E to crash for you,
please send a note to that effect via GRIPE E. It is hard to test all
possible cases, but these should work.)

∂2 Sep 86 -- ⊗XPOINTER command mods.

The ⊗XPOINTER command will no longer detect "filenames" that have switches
following them but with no explicit extension or PPN. This is to avoid
considering certain forms as filenames, e.g., "foo(bar)".

Also, ⊗XPOINTER no longer accepts switches in parentheses following
the filename. Switches must be in slash form (e.g., /E).

∂7 Aug 86 -- ⊗XPOINTER command accepts device names.

You can now give an ⊗XPOINTER command to follow a filename like
UDP1:FOO[1,3]. Formerly device names were not allowed, since UDP packs
are not always on the same UDP drive (i.e., a given pack doesn't always
have the same device name). This is mainly implemented for use at CCRMA
where various "UDPs" are permanently mounted.

∂29 Jul 86 -- [BB,DOC] added to directory list for READ command (and /D switch).

[BB,DOC] holds bulletin board files, such as ETC.TXT, JOBS.TXT, COMPUT.TXT.

∂27 Apr 86 -- ⊗#⊗XALIAS command sets alias to the PPN of the #th home file.

(The list of home files and their positions in the stack is given by ⊗0αH.)

For instance, ⊗0⊗XALIAS sets your alias to the PPN of the current file and
⊗1⊗XALIAS sets your alias to the PPN of the home file. (Negative
arguments have same effect as corresponding positive arguments.)

If a project is given, ⊗#⊗XALIAS PRO<cr> sets the alias project to that
given and the alias programmer name to the programmer name of the #th file
down in the file stack.

∂19 Jul 85 -- New ⊗XROVER command up, spools to Rover-Dover in MJH 433.

See the documentation of the spooler commands on p. 19.

∂22 Mar 85 -- Fix to ⊗XRSYS that follows an ⊗XRENAME command.

⊗XRSYS (e.g., to swap to MAIL with ⊗XRS MAIL to send a message) used to
cause MAIL to crash if you had done an ⊗XRENAME. But now it's fixed.
(It was starting MAIL at the wrong address.)

∂3 Jan 85 -- New features in manipulating search and substitution strings.

First, if you use ⊗Z to call a macro, but type the name wrong, you can now
type ⊗Zα<cr> to get back the name you last typed, so you can edit it and
enter the edited name. This also works for readonly variables (with
⊗0⊗Z), where you might actually use it to repeatedly get at the same
variable while moving the cursor around.

In a similar (but not identical!) way, you can edit the current local or
extended search string and then search for the edited version. Just give
a search command and type α<lf> instead of a search string. This will
load the old search string into your line editor, where you can edit it.
Then type one of the usual search-string-ending commands (e.g., <cr> or
α<cr>) to begin a search for the new string. (After saying α<lf>, you can
even CLEAR the line editor and type α<lf> again to get the old string back
once again, in case you've screwed it up.) Thus ⊗Fα<lf> and ⊗XFα<lf> will
allow you to edit the local and extended search strings, respectively.

You can also edit the current substitution strings (local and extended) in
exactly the same way, by beginning a substitution command but typing α<lf>
instead of the substitution string. That is, ⊗F...⊗\α<lf> and
⊗XF...α\α<lf> will allow you to edit the local and extended substitution
strings, respectively. Note that although the ⊗\ command repeats only the
local or the extended substitution that you've typed in most recently,
both substitution strings (local and extended) are editable with α<lf>, so
the one inaccessible from ⊗\ can be "reactivated" by editing it with
α<lf> and simply not altering it.

The reason α<lf> is used instead of α<cr> for editing search and
substitution strings is that α<cr> is used for something else at those
points, namely to put you into the line editor after the search or
substitution. The more common α<cr> IS used to edit the last extended
command (⊗Xα<cr>) or the name of the last ⊗Z macro called (⊗Zα<cr>).

The new command ⊗X FFind is used to do an extended search using the local
search string. This command (which can be abbreviated ⊗X FF<cr>) actually
EXCHANGES the local and extended search (and substitution) strings, and
then does an extended (multipage) search (searching for what USED TO be
the local search string). Note that if it finds a string and you want to
continue the extended searching, you should use ⊗* (or ⊗X Find) to
continue, not ⊗X FFind again; the latter would re-exchange the local and
extended strings before searching more.

For completeness, the command ⊗X FXFind exchanges the local and extended
search (and substitution) strings and then does a LOCAL search. This is
probably not as useful as ⊗X FFind, since you can use ⊗X Find to search
the incore text for the extended search string without needing this new
command.

The way to remember which of the above two commands does which is: ⊗X FF
is the main one you'll want and is the easiest to type (double "F").
Also, what these commands do is search (first "F") for the string
indicated by the rest of the command name (fFind uses local search string,
fXFind uses extended string).

These commands ⊗X FFind and ⊗X FXFind interpret any given repeat argument
and the CONTROL and/or META bits on the ⊗X exactly the same as the ⊗*
command. Thus, ⊗9αX FFind<cr> will take the old local search string and
do an extended search for 9 copies of it, leaving you in the line editor
(αX) at the 9th copy (if found). αβX would have avoided putting you in
the line editor after the search. ⊗0⊗X FFind will exchange the search
strings, set up the default search to extended, and type out the (new)
extended search string, without doing a search.

The above two commands, ⊗X FFind and ⊗X FXFind, exchange the local and
extended substitution strings, as well as the search strings. Thus, right
after either of these commands, the range of any active ⊗\ substitution
will have changed between local and extended (if ⊗\ was local before, it
becomes extended, and vice versa). For instance, if you do a local
substitution and then an ⊗X FFind to find the same string on another page,
you can then do ⊗\ to continue the same substitution (but doing it with
extended, i.e., multipage, searches). (Of course, if you follow the ⊗X FF
with ⊗\, you will have skipped the substitution at the first offpage
string found by the ⊗X FF. A <cr> and then a <bs> before the ⊗\ will make
the ⊗\ find that same first offpage string again and to do the
substitution for it. Or you could have done a ⊗0⊗X FF after the local
substitution, and then a ⊗\ to continue the same substitution with an
extended search.)

∂28 Dec 84 -- New readonly variables for checking subjob situation.

The following new readonly variables have been added, allowing you
to figure out what subjobs you might have and what the mode is for
subjob output text.

SUBOUT. output mode for subjob text: -1 means LATTACH,
0 LTYPE, 1 LFILE, 2 LPEND.
SUBJOB. job number of the first PTY subjob in the subjob stack;
this number will be the positive PTY number of a currently
connected PTY subjob, or the negated PTY number of the
first PTY subjob found below the top of the stack, or zero
if you have no PTY subjobs; the positive version of this
number can be applied to the ⊗XSUBJOB command to connect
to the given job. [NOTE: PTY numbers are treated as if
they were decimal (although they are normally displayed in
octal by the system). This is so that they can be typed
in as (decimal) arguments to E commands. This won't
affect you unless you somehow use such a PTY number to
index into a PTY table in the system, in which case it
won't work without appropriate "back to octal"
conversion; see a wizard for more details.]
SLISP. job number of the first Lisp subjob in the subjob stack;
this number will be the positive number of a currently
connected Lisp subjob, or the negated job number of the
first Lisp subjob found below the top of the stack, or
zero if you have no Lisp subjobs; the positive version of
this number can be applied to the ⊗XSLISP command to
connect to the given job.
SUBTOP. number of the subjob at the top of the subjob stack (this
is the currently connected subjob): this value will be the
positive job number of a connected Lisp subjob, the
negated PTY number of a connected PTY job, or zero (if
there is no currently connected subjob). [See note under
SUBJOB. about "decimalized" PTY numbers.]
SUBSTK. total number of Lisp and PTY subjobs in your subjob stack,
including any currently connected job.

Also, .SAM has been added to the bad extension list.

∂9 Nov 84 -- ⊗XIMPRINT command spools on the IMPRINT/Canon printer.

See p. 19 for details about how much text gets spooled.

∂4 Sept 84 -- Second /N confirmation not needed for file on previous PPN.

When E finds a requested file on a previously-used PPN (different from the
implicit PPN of your current alias), it requires confirmation before
reformatting that file (since it isn't the file you asked for). Now, if
you say /N to the confirmation question (that is, you want it reformatted,
but without a directory), E will no longer require a second confirmation
(since you've had a chance to see the actual PPN the file was on).

Also, when E is checking to see if a file to be created already exists, it
now always checks the right device. (It sometimes used to check the wrong
device if you tried to create a new file on a new device.)

∂16 July 84 -- Fixes to /-U (⊗-⊗XUPDATE) mode and ⊗XUPDATE command.

E no longer ripples unnecessarily in /-U mode when writing out a directory
(e.g., when deleting a new page that is among several new messages that have
arrived and extended the directory). Also, the ⊗XUPDATE command now correctly
works even when given from the directory page (this command manually updates
the directory on the disk, if it is different from the one in core -- usually
because a message file has been extended with new messages).

E's filename scanner now allows spaces between the filename and any switches.

Attempts to edit a file on an unassigned UDP will now get an E error message
instead of a system error message (the latter used to kick you out of E).

∂5 July 84 -- E handles CKSUM's infinite-line end-of-page marks better.

E now handles correctly the case where you have multiple incore pages, at
least one of which contains a mark on a non-existent line beyond the last
line on that page. For example, if you use CKSUM's mark-end-of-page
feature (CKSUM marks the infinity-numbered line) and then use ⊗XAPPEND to
bring several pages into core at the same time, E will now correctly move
to the end-of-page marks with αM.

∂25 Mar 84 -- PTY subjob now referred to by PTY line number, not job number.

PTY subjobs are now remembered by their PTY line numbers rather than their
job numbers (which could change in certain circumstances). Thus, various
commands that used to type out the PTY subjob's job number and name now
type out the PTY line number and the subjob name. This fixes a bug in
⊗XSUBKILL wherein it used to loop indefinitely if a disconnected PTY
subjob had been killed, e.g., by autologout. (Lisp type subjobs are still
remembered and listed by their job numbers.)

Because of the above, the probably rarely-used command ⊗#⊗XSUBJOB now
interprets its argument differently. This argument is now taken as the
PTY line number of the PTY subjob of interest instead of the number of the
job on the PTY subjob of interest. The user generally found out what to
type for this argument from some command like ⊗0⊗XRECONNECT, but subjobs
displayed by those commands now show PTY line numbers, not job numbers;
hence ⊗#⊗XSUBJOB now uses such a PTY line number as its argument (e.g.,
⊗1⊗6⊗2⊗XSUBJOB). (Technical detail for interested viewers: The system
reports line numbers in octal, but since numeric arguments to E are read
in decimal, the line numbers typed out by E should be treated as if
decimal. If ever there is a readonly variable to report the current PTY
subjob's line number, it will report it as if decimal, so that the same
number applied as an argument to ⊗#⊗XSUBJOB will find the right PTY. This
command, of course, has to convert from decimal to octal to connect to the
proper PTY subjob.)

∂6 Mar 84 -- ⊗XFileDelete no longer requires confirmation (unless protected).

The command ⊗XFileDelete, which tells E to delete the current file when
you leave that file, no longer requires confirmation. However, if the
file is delete-protected (200 bit on in the file's protection), then E
will require confirmation before marking the file to be deleted. Also,
the message "File XXXXXX is marked for deletion" is suppressed in terse
mode (this message is output from a successful ⊗XFileDelete command).

Also new: If E can't edit the file you name in a monitor command (e.g.,
because the file is busy or non-existent), then E will immediately exit
back to the monitor so that you can use control-return to edit your
command and try again. Remember that if you want to edit some previous
file, you can say ET/?<cr> to have E list the files it remembers; then
you can say ET/nH<cr> for some number n.

∂26 Jan 84 -- Fix to rare display screwup in ⊗XRDFail command.

∂8 Jan 84 -- Fixes to ⊗XGORPG and ⊗0⊗XCvtAltmodes commands.

The ⊗XGORPG, ⊗XDIRED, ⊗XDRD, ⊗XRUN and ⊗XRSYS commands have been fixed
to remember the file stack correctly, as of the moment the command was
given, even if multiple windows are open at that time. (It used to
screw up the remembered stack for the multiple-window case.)

The command ⊗0⊗XCvtAltmodes reports whether or not each altmode in a
file being edited is currently automatically converted to a right
brace ("}"). Non-conversion mode can be selected with the /-V switch
or with the ⊗-⊗XCvtAltmodes command; the default is to convert
altmodes so that the lines the altmodes appear in can be edited.

∂1 Dec 83 -- ⊗XBOISE command added for spooling to the BOISE printer.

You can now spool to the BOISE printer from within E by using the
⊗XBOISE command. This command takes an optional argument just
like the other spooling commands ⊗X XSPOOL and ⊗X DOVER (which see
for details).

∂20 Jun 83 -- Bug fixed in ⊗XRENAME; more good and bad extensions.

A bug has been fixed in the ⊗XRENAME command; it previously cleared
a high-order bit in the file's date-written.

The extensions .LOG and .SLO have been added to E's good extensions list.
The extension .DVI has been added to the list of bad extensions.

∂13 Jun 83 -- Cleanup to ⊗XRDFAIL; .PAC added to bad extension list.

The ⊗XRDFAIL command has been cleaned up a bit so that it no longer
spuriously sets the D flag in the header when the directory line is
unchanged. Also, it no longer spuriously redraws the header line or the
directory line in that case.

To make ⊗XRDFAIL conversion of old-style ⊗XNDFAIL'd pages easier, ⊗XRDFAIL
warns you if the old directory line did not already have ";⊗" in it -- in
this case ⊗XRDFAIL says: (appending ";⊗..."). In such cases, you might
flush the old directory line text if all it previously contained was the
⊗XNDFAIL list (if you don't flush the old text, that list will now appear
twice on the new directory line, once before and once after the new ";⊗").
This is easily done by now doing a new ⊗XNDFAIL and then deleting the old
directory line (now on line 2).

(For details on the recently added ⊗XRDFAIL command, see its documentation
in the entries for 23 Mar 83 and 24 Mar 83 on this page.)

The extension .PAC (for packed file) has been added to the bad extension list.

∂2 Apr 83 -- Slight mods to fix /H and /nH switches.

The switch /nH (which means: fill in the rest of the filename from the name
of the nth previous file) has been fixed up a little. First, it now fills in
even the extension from the given previous filename (provided no extension is
given explicitly). Secondly, with no argument, /H now means either:

(1) /1H if no partial filename whatsoever precedes it (e.g., ET/H or ⊗ε/H), or
(2) /-H (use latest file's name) if any part of a filename precedes it (e.g.,
ET FOO/H).

This allows ET/H<cr> to mean edit the next-to-last file you were in, while
ET FOO/H means edit a file named FOO but with the device, extension, and
PPN of the most recently edited file.

You can still say ET/?<cr> to see what files you've been editing lately.

∂30 Mar 83 -- Copying files with E.

You can copy E-format files with E, very quickly. This is an old feature
formerly not generally documented. You can say ET NEW←OLD<cr> or
⊗εNEW←OLD<cr>. For details, see "file copying" on p. 31.

∂28 Mar 83 -- Minor fixups and additional documentation of recent features.

The ⊗XRDFail command, besides updating the directory line in place without
generating a new line, avoids turning on the W (and D) flags if the new line
has the same text as the old (although the command will presently redraw the
directory line if it is on the screen, even if it is unchanged). So a macro
which goes through all pages of a file doing ⊗XRDFail on each page will be
very fast if most of the pages already have their directory lines up to date
-- it will only have to write out the pages whose directory lines had to be
corrected.

The ⊗XRENAME <new-filename) command parses the <new-filename> essentially
the same way the αR (rename) command in DIRED does; namely, any part of the
<new-filename> that you do not specify explicitly will be retained from the
<old-filename> of the file. Thus, if the current file is called FOO.1 and
you say ⊗XREN BAZ<cr>, then the new name will be BAZ.1. If you want to
clear the extension, then you must specify a null extension explicitly by
typing the dot, as in ⊗XREN FOO.<cr>, which would rename FOO.1 to FOO. And,
of course, if you're trying to rename the file to a new PPN, then you have
to specify the new PPN explicitly, as the old PPN (and NOT your current
alias!) will be the default for the new filename.

⊗XRENAME has been fixed to be legal from the directory page.

∂24 Mar 83 -- File renaming/deleting. New ⊗XRDFail command. Some bugs fixed.

It is now possible within E to rename or delete the file you are editing.

The command ⊗XFileDelete marks the current file for deleting. The file
will be deleted as soon as you exit from it -- that is, when you cause E
to close that file completely (e.g., with ⊗H, ⊗E, ⊗XEXIT, ⊗ε, ⊗λ, etc.).
Note that simply changing to another window (say, with αG) after giving
the ⊗XFileDelete command does not cause E to close the file and therefore
will not cause E to delete it at that time (although E will still remember
that the file is to be deleted later). Any altering of the incore text,
switching to another page, or changing to ⊗XReadOnly mode will
automatically remove the deletion mark, preventing the file's deletion
(except by a later ⊗XFileDelete cmd). Thus, the ⊗XFileDelete command
should generally be given just before you leave the file. When the file
is actually deleted, E will type out a message to that effect (both at the
bottom of the screen and on the page printer that you see when you exit
from E) and will move that filename to the bottom of the file stack. The
command ⊗0⊗XFileDelete will tell you if the current file has been marked
for deleting, and with a negative argument ⊗-⊗XFileDelete will remove the
deletion mark, to avoid deleting the file. As a safety precaution,
⊗XFileDelete will require confirmation immediately that you really want to
delete the file -- the confirmation question must be answered from the
terminal, even if the file is being deleted inside a macro. Finally, the
⊗XFileDelete command cannot be abbreviated to less that six letters
(⊗XFileDe) and is not legal in ReadOnly mode (except in the forms with
zero and negative args: ⊗0⊗XFileDelete and ⊗-⊗XFileDelete).

- - -

The command ⊗XRDFail generates a list of labels from a FAIL source file
page on the page's directory line (line 1). But unlike its cousin command
⊗XNDFail (note the first letters "R" and "N" of these commands), which
adds a new line at the top of the page, ⊗XRDFail replaces (updates) the
page's old directory line, retaining any text on that line that precedes
the two-character sequence ";⊗". If that sequence does not appear on the
old directory line, then that line's entire text will be retained and the
new list of labels will be appended to it, preceded by ";⊗". This is
intended to allow a constant comment (or other text) to be kept on the
directory line ahead of the list of labels generated (and updated) by this
command. Both ⊗XNDFail and ⊗XRDFail will now begin their lists of labels
with ";⊗" in order to facilitate this feature of allowing constant leading
text. The ⊗XRDFail command does NOT move the arrow to the directory line;
⊗XNDFail still does (it still adds a new line at that point). NDFail
stands for New Directory-line (FAIL source), and RDFail stands for Replace
Directory-line (FAIL source). In the future, other similar RDxxxx
commands may be added for xxxx = SAIL and/or BBOARD.

If you simply begin using ⊗XRDFail in place of ⊗XNDFAIL (and the normally
accompanying delete of the old directory line), then you will end up with
two copies of labels from the page -- first the old copy (now treated as
constant text) and then the new copy (updated by each ⊗XRDFail command).
The reason for this is that old files' directory lines that were generated
with the old ⊗XNDFail command do not start with ";⊗", so using ⊗XRDFail on
such pages will APPEND the new list of labels to the old list (only the
first time, since the new list will begin with ";⊗"). Since generally the
old list won't be wanted, you can simply delete it (the list, but not the
line), or change its leading ";" to ";⊗", before using ⊗XRDFail; that will
avoid duplicating the list of labels. It is recommended that you convert
a whole file at a time to the new format (using a macro containing
⊗XRDFail or ⊗XNDFail), but don't bother converting files that aren't being
changed. This way there is less chance that you may be confused by a now
out-of-date "old" label still appearing in constant text on the directory
line.

On the other hand, generating labels on the directory lines of a file not
already containing such labels is straightforward; simply do an ⊗XRDFail
command on each page of the file. (You might want to add tabs at the end
of the old directory lines in order to move the label lists away from the
constant text of each line, to make that text more readable.)

- - -

The commands αβ<ff> and ⊗<vt> are now legal from the line editor, but given
from there these commands will not move past the end of the incore text.

To prevent an all-too-frequent accidental SENDing of a whole page of text
to another user's terminal, the ⊗XSEND command without a numeric repeat
argument has been made illegal, except in attach mode. You now must
specify the number of lines of text to send (except in attach mode, where
no arg means send the whole attach buffer). If you really want to send
the whole page, then you have to go to line 1 and give a large repeat
argument (e.g., ⊗∞⊗XSEND).

A bug has been fixed in the ⊗≠ command, where E sometimes crashed because
of a mistaken attempt to switch to a window that had been closed.

The command ⊗-⊗#⊗π has been fixed to do the documented thing (make new
window # lines smaller than half the old window) instead of doing the
same as ⊗+⊗#⊗π (makes new window bigger than half of old one).

The maximum number of windows you can have open has been reduced by one to
7, to avoid a bug that happens when you run out of windows and file-list
entries at the same time.

∂18 Jan 83 -- Misc. minor features for macros.

The command ⊗XYSET <macro name><cr> sets up the named macro as that to be
called currently by the ⊗Y command. Thus ⊗Y will now call the last macro
either (1) defined by the user, (2) called by the user via ⊗Z<macro> or
(3) named in an ⊗XYSET command. Note that the latter has this effect
(setting which macro is called by ⊗Y) even when executed inside a macro,
whereas (1) and (2) do not have this effect from inside a macro. ⊗0⊗XYSET
types the name of the macro that ⊗Y currently would call (no macro name
argument is used with a zero repeat argument, and, unlike the ⊗0⊗Y
command, no macro definition is typed out).

The ⊗-⊗XIECHO command turns off all echoing of input to E; this is
intended to allow you to type commands that call macros (that may deal
with subjobs) that type out text that you don't want broken up with the
echo of what was actually typed to E. ⊗XIECHO turns echoing back on, and
⊗0⊗XIECHO reports the state of such input echoing. Note that ⊗XIECHO is
different from the ⊗XECHO command, which only affects echoing of text
edited with the line editor. The new readonly variable IECHO. will be
negative iff input echoing is disabled.

The command ⊗#⊗XPRINT types out # lines of text (without any page numbers
and with or without line numbers as controlled by the ⊗XNUMBERS command);
after typing out the text of the line(s), this command moves down to the
line beyond those typed (on non-displays, this new current line will be
typed out as a consequence of being the new current line). The default
argument to ⊗XPRINT is ⊗1 (on both displays and non-displays). This
command is designed for use in macros, so it avoids typing any leading
carriage return and it avoids saying OK; it is also generally useful from
a display to see a long line's text. For typing out text normally on a
non-display the ⊗XTYPE command is recommended instead of ⊗XPRINT.

∂14 Jan 83 -- What to do if E can't open your file to write it out.

If you try to write out a file, either explicitly with ⊗. or implicitly by
doing something like trying to switch pages, then E may abort your command
saying "Can't open file now". This happens if someone else is reading the
file that you are trying to write, or if you have the file open in two
windows; the system won't permit one process to write a file (the way E
does, in Read-Alter mode) while another is reading it. If you get the
message "Can't open file now", you have lots of alternatives available for
saving your edited incore text; you in fact have the whole power of E at
your disposal.

The recommended thing to do in this case is simply to use the ⊗XSEND
command to ask the other user(s) of the file to let you have unique access
to it; then you can just sit there typing ⊗. until it works, if you expect
the other user(s) to get out of the file (e.g., after you've sent them a
message). The "Can't open file now" message is preceded by a list of the
people who have the file open, so that you know whom to send messages to
requesting sole access. Of course, if you have the file open in two or
more windows, then you yourself are preventing the file from being opened
for writing -- in this case you should close all of the windows you have
the file open in except for the one that you want to write out.

Alternatively, you can attach your text and move it to another file; this
will generally require either that you open the second file is another
window (so that E won't try to write out the original window when you are
moving the text to the new file), or that you use ⊗XCANCEL after attaching
your text(!), again to avoid any attempt to write out the first file.

Sending messages asking for write access is the obvious choice for this
situation, as almost everyone will immediately let you have unique access
so you can write out the file. Moving your text to another file is
basically a last resort, but another possibility is to KILL or RESET the
offending user's job if he doesn't respond to a message from you, for
instance if his job has been idle for a while, suggesting that he isn't
paying attention to his terminal. KILL or RESET should not, however, be
used without careful thought to what you are doing; if in doubt, don't use
these.

Of course, with all of E available, there are lots of other things you
could do to save your text, such as mailing it to yourself (from E).

At any rate, E won't let you leave a page that has been changed unless:
(1) E can write it out, or (2) you're in ReadOnly mode and re-confirm it,
or (3) you ⊗X CANCEL the changes, or (4) you are going to a new window
(the latter retains the changed page in core, for writing out later, while
at the same time allowing you to edit other files).

∂9 Jan 83 -- Automatic ⊗XOPEN on write attempt; Abort option in Readonly mode.

E now effectively does an automatic ⊗XOPEN command for you whenever you
try to write out a file in any way. As a result, you no longer need to
use the ⊗XOPEN command to ensure private access to a file that you want to
modify (such as the \BBOARD file). When you simply try to write out the
file the first time, if it cannot be opened, E will abort the command in
progress, rather than dumping you to the monitor (like it used to with a
"file in use" message). This means that all the commands that can write
out text have a new potential error message: "Sorry -- Can't open file
now"; this message will be preceded by a list of other jobs that have the
file open and/or a mention that you have the file open in 2 or more
windows. E does not clear typeahead when this error happens, so you
should make sure you haven't accidentally altered the page (further) when
you get this message (of course the page won't have been written out).

This "automatic ⊗XOPEN" means that certain commands may do part but not
all of their expected work. For instance, the αβE command to write out
all windows and exit will stop if it reaches a window that needs to be
written out but whose file cannot be opened. Commands like ⊗., ⊗P, αM,
⊗<ff>, ⊗<vt>, ⊗O, ⊗ε and ⊗λ will do nothing if the current page needs to
be written but the file cannot be opened because it is being read
elsewhere. The command α∂αβD, given to delete an entire page, will delete
the text but not the page if the file cannot be opened for writing. The
extended search command ⊗XFIND will do its search but not switch pages in
this situation; it will, however, report what page it found the given
string on.

Also, when E requests confirmation of ReadOnly/ReadWrite mode upon an
attempt to write out a page from ReadOnly mode, if you respond with ABORT
instead of READONLY or READWRITE, then E will abort the latest command at
the current point within that command (in exactly the same manner that E
would have aborted the command if it had found it couldn't open the file
for writing). Finally, if you confirm with READONLY in this case (instead
of READWRITE or ABORT), E now says "OK, text Not written out".

∂30 Oct 82 -- Moving between terminals handled better, esp. wrt windows.

When an E user switches from one terminal to another (by DETACHing the
job from one terminal and ATTACHing to it from a new one), E now tries
hard to make reasonable adjustments to the sizes and positions of all of
the user's window. Full screen windows should remain full screen (for
whatever height the new display terminal has). However, what may have
been non-overlapping windows before such a terminal change may end up
overlapping because of a reduced screen size. Of course, the sizes and
positions of any windows can be manually adjusted by the user (e.g., with
⊗XBOTSET and ⊗XTOPSET) after the terminal change.

∂25 Sept 82 -- "h" or "hw" on hdr line for hidden windows; αβE exits.

The current window's header line now displays "h" if there are any hidden
windows open or "hw" if any hidden window has the W flag set (its page
needs to be written out). (A hidden window is one that is completely
obscured by one or more other windows.) Thus "hw" means one or more
hidden windows need their pages written out, whereas just "h" means there
are hidden windows but none needs to be written out. This way, you can
always see on the screen whether any windows haven't yet been written out
(any partially visible window will always have a header line displayed on
which any W flag will be clearly visible).

Also, the αβE command (note CONTROL and META) now exits just like the
⊗XEXIT command, writing out all open windows. This command, like αE to
exit or close a window, is not legal inside a macro (where you must use
⊗XEXIT instead).

∂20 Sept 82 -- Minor display bug fixed.

E now correctly notices and redraws appropriate text in certain additional
cases of the line editor wrapping around and erasing the following text line.

∂9 Aug 82 -- Multiple windows. Datamedia display improvements. More.

Using E's multiple windows, a user can keep several files open for editing
at once, making it fast as well as easy to move from file to file.
Furthermore, the display screen can be set up to make any number of these
files all visible at the same time. Those two facilities -- rapid
switching and simultaneous viewing of multiple files -- make multiple
windows very useful. For complete details, see p. 39.

- - - - -

There are several improvements in display output to individual display
terminals (e.g., Datamedias), namely:

(1) Previous output is flushed if all of the lines being drawn will be
redrawn anyway. Formerly this was the case only if the whole screen would
be redrawn. An example of this improvement can be seen if you attach some
lines of text and then wander around in a file (say with <formfeed> or
αP). This feature was necessary to make multiple window display updates
reasonable, but it makes editing much nicer for Datamedia users.

(2) The line after the line editor is no longer redrawn after you edit a
line unless that following line was actually erased by a wrapped-around
line editor. (This is actually true on DD terminals too, but has more
significant effect on individual displays. A new feature was added to the
monitor to allow E to detect when a line editor line has wrapped around.)

(3) When everything but the trailer is being redrawn, the trailer is
redrawn too, in order to allow flushing previous output.

(4) Shifting lines around in a short window (e.g., by deleting some lines)
no longer needlessly redraws certain lines at the bottom.

(5) Header and trailer lines are included in the set of lines to
potentially shift.

(6) Unnecessary deletion of random old text lines during text shifting has
been eliminated.

- - - - -

The /nH switch can be used in place of or with the name of a file to edit.
This switch means fill in the missing parts of the filename with those
from the nth file on the stack (the nth home file). This is useful, for
instance, when you've omitted the PPN of a file on the same area as some
earlier file you've edited. It is also useful with the monitor ETV
command when you want to go into E not on the latest file you were
editing, but on a previous one (e.g., ET/H<cr>).

The /? switch makes E type out the file stack, so that you can select the
proper "n" to use in the /nH switch above. E completely ignores any
filename or other switches that /? appears with, since /? is purely an
informational switch.

The command ⊗#⊗∃ switches to the file with the given number (0 to 7) as
indicated in the ⊗∃ command. Thus, ⊗#⊗∃ is similar to ⊗#⊗ε and ⊗#⊗λ
except that it preserves the old value of the readonly/readwrite state
for the given file.

The /-V switch or the ⊗-⊗XCVTALTMODES command will make E retain altmodes
that occur in a file being edited. This is not recommended and is
included only to allow editing of non-WAITS-ASCII files that have been
FTP'd to WAITS without conversion from ASCII to WAITS ASCII. The command
⊗XCVTALTMODES restores the normal E mode in which altmodes found in the
file are converted to an editable charaber, namely right brace. Using the
line editor on a line with an altmode in it will convert the altmode
anyway (a warning is given when editing such a line), unless such editing
of the line is aborted (with altmode, of course).

The extensions .PSC and .PL have been added to E's good extension list;
.TFD has been removed from that list. Also, .SPI has been added to the
bad extension list.

The ⊗XSUBKIL, ⊗-⊗XSLISP and ⊗-⊗XSULISP commands give a special warning
about killing the subjob manually if E's kill message fails to get to a
Lisp subjob (for instance, if the subjob is hung or looping).

E no longer loops forever if you try to edit a file named without explicit
extension when that file is being concurrently created (written) by
another job.

The ⊗XHEADER command has been fixed to make sure all the header flags have
been updated before the header line is typed out.

∂2 Apr 82 -- Bug fix to running PTY subjobs from PTYs (e.g., network servers).

Formerly, LFs were not inserted correctly when a network user running
a PTY subjob under E typed a CR in Eval mode. Now it all works correctly.

∂14 Feb 82 -- Subjob output mode displayed.

E now indicates the subjob text-output mode on the header line whenever
you have a subjob (Lisp or PTY) connected. The header line will display
one of the following lower-case letters when you have a subjob:

t Type out subjob text
a Attach subjob text
f File subjob text at (above) arrow line
e put subjob text at End of given page

Also, Terse mode now suppresses the message "(incore page)" from in
the find commands.

∂8 Dec 81 -- Two minor changes.

Added .PRF to bad extension list, and .PPR to good list, both for EKL.

Doing a monitor REENTER command to save your incore text now also detaches
any PTY subjobs you have (otherwise they would get killed), so that you
can re-attach them (directly or through a new E) in order to continue
using their core images. Fatal E crashes also detach PTY subjobs.

∂5 Nov 81 -- Improved E/Lisp interface.

E's internal handling of messages from a Lisp subjob has been improved
to avoid deadlocks that used to happen when many large messages were
flying back and forth. (This does NOT affect potential PTY subjob
deadlocks.)

The new ⊗XSUBWAIT command causes E to be willing to wait forever for a
required response from a Lisp-type subjob, in case Lisp is slow in
responding, for instance because of a high system load or long calculation
by Lisp. Waiting forever is the default mode. The alternative mode is
set by ⊗-⊗XSUBWAIT, which will limit E's wait in such cases to about 30
seconds. With a zero argument, ⊗0⊗XSUBWAIT will report the current mode.
In ⊗XSUBWAIT (forever) mode, after about 30 seconds of waiting, E will
report that it is still waiting for a Lisp response and will remind you
that ESC I will abort the wait. No other commands can be executed while E
is waiting for a required response from Lisp.

∂10 Oct 81 -- .WEB added to good extension list.

∂27 Sept 81 -- .NS added to good extension list, .CRU added to bad list.

∂31 July 81 -- Bug fix to subjob interface for typeout of subjob text.

∂ *** A HISTORY OF OLDER E CHANGES IS CONTAINED IN: E.UPD[UP,DOC] ***
All information in E.UPD has been merged into this manual.

INDEX of commands.

Read α as CONTROL, β as META, and ⊗ as either CONTROL or both CONTROL and META.

Modes: N=Normal, E=line-Edit, A=Attach
I=command explicitly affects LINE INSERT mode
L=command is a Line editor command,
S=command takes arg from Search distance.

# stands for any decimal number (in a repeat argument ⊗#).

Note: In general, a repeat argument ⊗# can be given preceding
any command. Unless otherwise specified, a repeat argument of
⊗# means repeat the command # times. A very few commands ignore
the repeat argument, and some commands (explicitly mentioned)
take the repeat argument to mean modify the command in some
uniform fashion (with respect to the repeat argument's value).

Note also that when a repeat argument ⊗# is given from the line
editor, the form αβ# must be used instead of α#, since the
latter would be taken as a line editor repeat count instead of
an E-command repeat arg.

Page Modes Command Meaning

27 startup arbitrary Automatic execution of EIN tmpcor file

7 N,A,E <form> Go forward one windowful among incore text
7 N,A,E ⊗0<form> Go forward a half windowful among incore text
7 N,A,E ⊗#<form> Go forward # windowfuls among incore text
7 N,A ⊗<form> Go forward one windowful, changing pages if necessary
9 E,L α<form> Move cursor to beginning of line
6 N β<form> Insert an incore pagemark
7 N,A,E <vt> Go back one windowful among incore text
7 N,A,E ⊗0<vt> Go back a half windowful among incore text
7 N,A,E ⊗#<vt> Go back # windowfuls among incore text
7 N,A ⊗<vt> Go back a windowful, changing pages if necessary
7 N,A β<vt> Go back a windowful, changing pages if necessary
7 N,A <cr> Move arrow to next line
9 E <cr> Close line and move arrow to next line
7 N,A,E ⊗#<cr> Close line (if necessary) and move down # lines
9 E α<cr> Leave LINE-EDIT mode, stay on same line
11 I α<cr> Leave LINE INSERT mode, stay on same line
13 N α<cr> Position cursor at found string (after find)
9 N β<cr> Insert <cr>
9 E β<cr> Close line and insert <cr>
9 I β<cr> Insert <cr> but don't leave LINE INSERT mode
11 N,I αβ<cr> Enter LINE INSERT mode and insert a blank line
11 E,I αβ<cr> Enter LINE INSERT mode breaking current line at cursor
11 N,E ⊗#αβ<cr> Insert # blank lines
7 N,A <bs> Move arrow up a line
7 N,A ⊗#<bs> Move arrow up # lines
9 E,L <bs> Move cursor left a char, deleting if at end of line
9 E,L α<bs> Move cursor to left (never deleting char)
7 N,A β<bs> Move arrow up a line
9 E,L β<bs> Delete char to left
7 N,A ⊗<bs> Move arrow up a line (see also ⊗U cmd)
9 E,L αβ<bs> Repeatedly move cursor to left (as long as held down)
9 N,E,L α<tab> Go to end of current line
11 N,E,I αβ<tab> Go to end of current line and enter line insert mode
N,A <alt> Abort command
9 E <alt> Restore line to original condition
11 I <alt> Close line, leave LINE INSERT mode, delete line if empty
13 <ESC>I Terminate multi-page FIND
14 <ESC>I Terminate multiple substitution
25 <ESC>I Terminate macro expansion
7 <ESC>I Terminate wait on delayed ⊗V command
10 N,A,E,S ⊗#⊗A Attach # lines (first putting down any attached lines)
10 N,A,E,S ⊗+⊗#⊗A Attach # more lines to end of buffer
10 A ⊗-⊗#⊗A Put down last # lines in buffer, move above them
10 N,E ⊗-⊗#⊗A Attach # lines above current line (not in att mode)
7 N,A ⊗B Glitch screen up from Bottom
7 E αβB Glitch screen up from Bottom
7 N,A,E ⊗#⊗B Glitch screen up # times from Bottom
9 E,L αB Move backwards in line editor to next char typed
10 N,E,S ⊗#⊗C Copy # lines into attach buffer (not in att mode)
10 A ⊗#⊗C Put down whole attach buffer, then copy # lines
10 A ⊗C Put down copy of whole attach buffer
10 A,S ⊗+⊗#⊗C Copy # more lines into end of buffer
10 A ⊗-⊗#⊗C Kill last # lines in attach buffer
10 N,E ⊗-⊗#⊗C Copy # lines just above current line (not in att mode)
9 E,L αD Delete char (if at end of line, delete CRLF)
7 N,S αβD Delete line
7 N,S ⊗#αβD Delete # lines
7 N,S ⊗-αβD Delete previous line
7 N,S ⊗-⊗#αβD Delete # previous lines
39 N αE Write out the current window, close it (exit if only window)
39 N αβE Write out all windows and exit to the monitor
10 A ⊗E Leave ATTACH mode by putting down all attached lines
10 A ⊗#⊗E Put down first # lines in buffer, move past them
10 N,A ⊗-⊗#⊗E Attach # more lines at front of buffer from above
13 N,A,E αF Find string (delimiters not required)
13 N,A,E αβF Find delimited string
13 N,A,E ⊗#⊗F Find # occurrences of string (delimited if αβF)
39 N,A αG Go to previous window in window stack
39 N,A αβG Go to Nth previous window, where N is current default arg
39 N,A ⊗0αG Type out window stack
39 N,A ⊗0αβG Type out default arg for αβG command
39 N,A ⊗#αG Go to #th previous window
39 N,A ⊗#αβG Go to #th previous window and set default arg to #
39 N,A ⊗-⊗#⊗G Go to #th previous window and pop # windows off top of stack
39 N,A ⊗+⊗#⊗G Re-push # windows back onto top of stack and go to new top
34 N,A αH Go to previous file in file stack (Home)
34 N,A αβH Go to Nth previous file, where N is current default arg
34 N,A ⊗0αH Type out file stack
34 N,A ⊗0αβH Type out default arg for αβH command
34 N,A ⊗#αH Go to #th previous file
34 N,A ⊗#αβH Go to #th previous file and set default arg to #
34 N,A ⊗-⊗#⊗H Go to #th previous file and pop # files off top of stack
34 N,A ⊗+⊗#⊗H Re-push # files back onto top of stack and go to new top
9 N,E,L αI Enter Insert mode (at end of line, enter LINE INSERT mode)
11 N,I αβI Enter LINE INSERT mode and insert a blank line
11 E,I αβI Enter LINE INSERT mode in current line (new line if at end)
11 N,E ⊗#αβI Insert # blank lines at arrow (don't enter LINE INSERT mode)
7 N,A,E ⊗J Jump the arrow line to the top of the screen
7 N ⊗-⊗J Jump the arrow line to the bottom of the screen
7 N,A,E ⊗0⊗J Jump the arrow line to the center of the screen
7 N ⊗#⊗J Jump the arrow line up # lines
7 N ⊗-⊗#⊗J Jump the arrow line down # lines
9 N,E,L αK Kill characters forward up to next char typed
10 A αβK Kill all attached lines
10 A ⊗#αβK Kill first # lines in attach buffer
10 N,A ⊗-⊗#αβK Copy # more lines to front of attach buffer from above
9 E,L αL Kill characters backward up to next char typed
7 N,A αL Go to first line of current page
7 N,A,E αβL Go to first line of incore text
7 N,A,E ⊗#αL Go to Line # of current page
7 N,A,E ⊗#αβL Go to Line # of all incore text
8 N,A αM Go forward to next Mark
8 N,A ⊗-αM Go backward to previous Mark
8 N,A ⊗#αM Go forward # Marks
8 N,A ⊗-⊗#αM Go backward # Marks
8 N,A αβM Place a Mark on current line
8 N,A ⊗-αβM Clear Mark on current line
8 N,A ⊗0⊗M Report the number of Marks in current file
34 N,A αN Go to previous line in line stack
34 N,A αβN Go to Nth previous line, where N is current default arg
34 N,A ⊗0αN Type out line stack
34 N,A ⊗0αβN Type out default arg for αβN command
34 N,A ⊗#αN Go to #th previous line
34 N,A ⊗#αβN Go to #th previous line and set default arg to #
34 N,A ⊗-⊗#⊗N Go to #th previous line and pop # lines off top of stack
34 N,A ⊗+⊗#⊗N Re-push # lines back onto top of stack and go to new top
34 N,A αO Go to previous page in page stack
34 N,A αβO Go to Nth previous page, where N is current default arg
34 N,A ⊗0αO Type out page stack
34 N,A ⊗0αβO Type out default arg for αβO command
34 N,A ⊗#αO Go to #th previous page
34 N,A ⊗#αβO Go to #th previous page and set default arg to #
34 N,A ⊗-⊗#⊗O Go to #th previous page and pop # pages off top of stack
34 N,A ⊗+⊗#⊗O Re-push # pages back onto top of stack and go to new top
6 N,A αP Go to next Page
6 N,A αβP Go to next Page that is not in core
6 N,A ⊗-αP Go to previous Page
6 N,A ⊗-αβP Go to previous Page that is not in core
6 N,A ⊗#αP Go to Page #
6 N,A ⊗#αβP Go to Page #, retaining only it in core
9 N,E ⊗Q Copy line above, and enter copy in line-edit mode
9 N,E,L αR Repeat line editor αS or αK or αB or αL cmd
10 A αβR Put attached lines back where they were picked up
9 N,E,L αS Skip to next char typed
34 N,E αβS Re-edit the last line edited, at column were activated it
7 N,A ⊗T Glitch screen down from Top
7 E αβT Glitch screen down from Top
7 N,A,E ⊗#⊗T Glitch screen down # times from Top
9 E,L αT Transpose the previous two chars in the line editor
7 N,A,E ⊗U Move arrow Up a line (recommended cmd for non-displays)
7 N,A,E ⊗#⊗U Move arrow Up # lines
7 N,A,E αV Redraw screen (without clearing)
7 N,A,E αβV Clear and then redraw screen
7 N,A,E ⊗#⊗V Redraw screen and then wait # seconds; ESC I ends wait
38 N,A,E ⊗-αV Update screen, then Disable screen updates until ⊗V typed.
38 N,A,E ⊗-αβV Clear and redraw screen, then Disable screen updates.
7 N,A,E ⊗W Go forward one windowful among incore text
7 N,A,E ⊗0⊗W Go forward a half windowful among incore text
7 N,A,E ⊗#⊗W Go forward # windowfuls among incore text
19 N,A,E ⊗X Enter eXtended command next
19 N,A,E ⊗Xα<cr> Load line editor with previous extended cmd line to retry
19 N,A,E ⊗#⊗X Enter eXtended command next, with arg of #
25 N,A,E ⊗Y Call current macro (# times if arg given)
25 N,A,E ⊗Z Call a named macro (# times if arg given)
25 N,A,E ⊗# (Actually the "#" char) Pass macro call arg to next cmd
28 N,A,E ⊗& Step macro execution once
28 N,A,E ⊗#⊗& Step macro execution # steps
25 N,A,E ⊗≡ Call the macro named "≡" (# times if arg given)
25 N,A,E ⊗∩ Call the macro named "∩" (# times if arg given)
25 N,A,E ⊗∪ Call the macro named "∪" (# times if arg given)
25 N,A,E ⊗⊂ Call the macro named "⊂" (# times if arg given)
25 N,A,E ⊗⊃ Call the macro named "⊃" (# times if arg given)
25 N,A,E ⊗$ Call the macro named "$" (# times if arg given)
25 N,A,E ⊗% Call the macro named "%" (# times if arg given)
25 N,A,E ⊗~ Call the macro named "~" (# times if arg given)
25 N,A,E ⊗_ Call the macro named "_" (# times if arg given)
24 N,A,E ⊗∂ Operate on message with next cmd
24 N,A,E ⊗#⊗∂ Operate on # messages with next cmd
24 N,A,E ⊗! Operate on paragraph with next cmd
24 N,A,E ⊗#⊗! Operate on # paragraphs with next cmd
15 N,A ⊗ε Switch in READWRITE mode to file to be named
15 N,A ⊗#⊗ε Switch in READWRITE mode to file number # in "∃" filelist
15 N,A ⊗0⊗ε Show names and numbers of files in fileswitch list
15 N,A ⊗λ Switch in READONLY mode to file to be named
15 N,A ⊗#⊗λ Switch in READONLY mode to file number # in "∃" filelist
15 N,A ⊗0⊗λ Show names and numbers of files in fileswitch list
15 N,A,E ⊗∃ Show names and numbers of files in fileswitch list
15 N,A,E ⊗0⊗∃ Show names and numbers of files in fileswitch list
15 N,A ⊗#⊗∃ Switch to file number # in "∃" filelist
13 N,A,E ⊗* Repeat last ⊗F or ⊗XFIND command (# times if arg given)
14 N,E ⊗\ Repeat last substitution command (# times if arg given)
7 N,A α. Write out current page (not including attach buffer)
7 N,A,E αβ. Write out current page (including current line editor)
15 N,A ⊗? Switch to the file E.ALS[UP,DOC]/R
15 N,A ⊗#⊗? Go to page # in E.ALS
15 N,A ⊗+⊗#⊗? Go to E.ALS, # pages beyond where last left it
15 N,A ⊗-⊗#⊗? Go to E.ALS, # pages before where last left it
9 N,E αβ; Set col of interest to current col and move straight up
9 N,E ⊗#αβ; Set col of interest to current col and move up # lines
9 N,E α; Move up to next line at old column of interest
9 N,E ⊗#α; Move up # lines at old column of interest
9 N,E αβ: Set col of interest to current col and move straight down
9 N,E ⊗#αβ: Set col of interest to current col and move down # lines
9 N,E α: Move down to next line at old column of interest
9 N,E ⊗#α: Move down # lines at old column of interest
22 N,E ⊗( Find (
22 N,E ⊗#⊗( Find ( # levels down from current location
22 N,E ⊗) Find matching )
22 N,E ⊗#⊗) Find ) # levels down (sic) from current location
22 N,E ⊗↔ Return to place ⊗(, ⊗) or ⊗↔ was given
36 N,E,S α/ Lisp-indent current line by context above it
36 N,E,S αβ/ Lisp-indent next line by context above it
36 N,E,S ⊗#α/ Lisp-indent # lines from arrow by context above
36 N,E,S ⊗#αβ/ Lisp-indent # lines from next by context above
36 A,S α/ Lisp-indent first attached line (no-op!)
36 A,S αβ/ Lisp-indent first attached line in context of page
36 A,S ⊗#α/ Lisp-indent first # attached lines
36 A,S ⊗#αβ/ Lisp-indent first # attached lines in context of page
9 N,E α↑ Move to end of line above
9 N,E ⊗#α↑ Move to end of line # lines above
11 N,E,I αβ↑ Move to end of line above and enter line insert mode
11 N,E,I ⊗#αβ↑ Move to end of line # lines above and enter line insert mode
9 N,E α↓ Move to end of line below
9 N,E ⊗#α↓ Move to end of line # lines below
11 N,E,I αβ↓ Move to end of line below and enter line insert mode
11 N,E,I ⊗#αβ↓ Move to end of line # lines below and enter line insert mode
18 N,A,S ⊗← Shift line or attach buffer left by current indent default
18 N,A,S ⊗#⊗← Shift # lines left by current indent default
18 N,A,S ⊗→ Shift line or attach buffer right by current indent default
18 N,A,S ⊗#⊗→ Shift # lines right by current indent default
7 N,A,E ⊗> Move arrow down 4 lines (# times if arg given)
7 N,A,E ⊗< Move arrow up 4 lines (# times if arg given)
7 N,A,E ⊗≥ Move arrow down half a screen (# times if arg given)
7 N,A,E ⊗≤ Move arrow up half a screen (# times if arg given)
7 N,A,E ⊗∧ Move arrow to top of screen
7 N,A,E ⊗#⊗∧ Move arrow to line # from top of screen
7 N,A,E ⊗0⊗∧ Move arrow to middle of screen
7 N,A,E ⊗∨ Move arrow to bottom of screen
7 N,A,E ⊗#⊗∨ Move arrow to line # from bottom of screen
7 N,A,E ⊗0⊗∨ Move arrow to middle of screen
38 N,A,E ⊗= Send current line or whole attach buffer to subjob.
38 N,A,E ⊗#⊗= Send # lines to subjob from page or attach buffer.
38 N,A,E ⊗0⊗= Send subsequently-typed line to subjob.
39 N,A ⊗π Open new current-size window (if next cmd switches files).
39 N,A ⊗#⊗π Open a #-line new window (if next cmd switches files).
39 N,A ⊗0⊗π Open a half-size new window (if next cmd switches files).
39 N,A ⊗≠ Go to next window lower on screen (wrapping around).
39 N,A ⊗#⊗≠ Go to #th window lower on screen (wrapping around).
39 N,A ⊗-⊗≠ Go to next window higher on screen (wrapping around).

Page Modes ⊗X Command Meaning

25 N,A,E ABORT Abort one or more macro levels in progress
26 N,A,E ADD Add given repeat arg to macro's value
19 N,A AL Change your job's ALIAS
19 N,A ALIAS Change your job's ALIAS
18 N,A,S ALIGN Align left margins of text
6 N APPEND Add # following pages to incore text
26 N,A,E ARGUMENT Set up repeat argument from value of numeric macro
27 N ATTACH Place an editable macro definition in the attach buffer
33 N,A,E ATTSET Set max number of lines used to display attach buffer
19 N,A,E AUTOBURP Set or read autoburping threshold
28 N,A,E AUTOSTEP Set or read autostepping time for macros
11 N,A,E,I AUTOWRITE Set or read autowriting threshold for line insert mode
34 N,A BACKGO Go back to page that you last came from (see ⊗O cmd)
19 N,A,E BEEPME Beep the user's terminal now
19 N,A BLOAT Add extra records of nulls to current page
39 N,A BOTSET Position bottom edge of current window
12 N,A,S BREAK Break line(s) at given column position
19 N,A BURP Burp current page of extraneous records of nulls
6 N,A,E CA Flush unwritten changes to incore page(s)
6 N,A,E CANCEL Flush unwritten changes to incore page(s)
25 N,A,E CASE Select and call a macro from a list of macro names
18 N,A,S CENTER Center text of given lines between margins
26 N,A,E CHARACTER Generate the next command character from numeric value
19 N,A,E CHECK Enable free storage checking within E
19 N,A CLOSE Close the file, but allow further editing
27 N,A,E COMMENT No-op, useful for putting comments in command files
21 N,A,E CONTROL Make next cmd char have only the CONTROL bit
39 N,A CONTINUE Re-open last previously closed window
19 N,A CORCHK Try to core down if possible (done automatically)
19 N,A,E CVTALTMODES Convert altmodes to right braces, in files edited
19 N,A,E DDTGO Call RAID, if available (ERAID only)
25 N,A DEFINE Define a macro
6 N DELETE Delete the next (not-incore) pagemark
19 N,A,E DFIND Run FIND program on another job to do file search
23 N DIRED Swap to the DIRED directory editor
26 N,A,E DIVIDE Divide macro's numeric value by given repeat arg
19 N,A,S DOVER Spool incore page(s) on the Dover printer
19 N,A DPYALWAYS Update the display after every command
19 N,A DPYSKIP Only update the display when no typeahead
7 N,A,E DRAW Redraw the screen now
23 N DRD Swap to the DIRED directory editor
19 N,A,E ECHO Turn on/off echoing of text edited in line editor
38 N,A,E EECHO Enable or disable E Eval loop echoing
19 N,A,E EMPTY Move to next empty line on page
21 N,A ENTER Switch to given file in READWRITE mode
21 N,A EPSILON Switch to given file in READWRITE mode
13 N,A,E EXACT Distinguish case of letters in searches
27 N,A,E EXECUTE Read and execute commands from a file
21 N,A,E EXIST Type out fileswitch list
39 N EXIT Exit to monitor (or close # windows if more present)
38 N,A,E EVAL Enter Eval loop talking to current subjob.
13 N,A,E F Do a multipage search for a given string
42 N,E FILEDELETE Mark the current file to be deleted when closed
13 N,A,E FIND Do a multipage search for a given string
23 N GORPG Swap to SNAIL (RPG) to reexecute last cmd
21 N,A HEADER Type out the header line (from top of window)
33 N,A HEIGHT Set the number of lines used for text display
34 N,A HOME Go to relative or absolute page in Home file
38 N,A,E IECHO Control Input Echo of all E type-in
26 N,A,E IFEQ Error unless repeat arg = macro value
26 N,A,E IFGE Error unless repeat arg ≥ macro value
26 N,A,E IFGT Error unless repeat arg > macro value
26 N,A,E IFLE Error unless repeat arg ≤ macro value
26 N,A,E IFLT Error unless repeat arg < macro value
26 N,A,E IFNE Error unless repeat arg ≠ macro value
19 N,A,S IMPRINT Spool incore page(s) on the IMPRINT/Canon printer
18 N,A,S INDENT Indent lines by given amount
6 N INSERT Insert an incore pagemark before current line
38 N,A,E INTERRUPT Send an ESC I interrupt to the current subjob.
16 N,A,S JFILL Justify paragraphs w/out aligning right margin
16 N,A,S JGET Get justification margins from text
12 N,A,S JOIN Join two or more lines by deleting CRLFs
16 N,A,S JUST Justify paragraphs and align at right margin
21 N,A LAMBDA Switch to given file in READONLY mode
38 N,A,E LATTACH Make subjob output text get attached by E
25 N,A LETEST Generate macro error if line too long to edit
38 N,A,E LFILE Make subjob output text get put into current page
19 N,A LINCNT Type length of current line, plus more info
36 N,A,E LISPSYNTAX Examine and/or modify char interpretation by ⊗/ cmd
21 N,A LOOKUP Switch to given file in READONLY mode
37 N,A,E,S LOWERCASE Make all letters in given range be lower case
22 N,E LPAREN Search for next "(", crossing page boundaries
38 N,A,E LPEND Make subjob output text go at end of current page
38 N,A,E LRECEIVE Enable or disable reception of text from subjob
38 N,A,E LTYPE Make subjob output text simply get typed out
6 N,A M Make the current line start a new page
43 N,A,S MAIL Mail a message to someone
25 N,A,E MALTMODE Enable/disable altmode insertion at end of macro
6 N,A MARK Make the current line start a new page
26 N,A,E MAXIMUM Set macro's value to MAX(<old value>,<repeat arg>)
21 N,A,E METACONTROL Make next cmd char have both META and CONTROL bits
26 N,A,E MINIMUM Set macro's value to MIN(<old value>,<repeat arg>)
21 N,A,E MSG Operate on current message with next command
26 N,A,E MULTIPLY Multiply macro's numeric value by given repeat arg
32 N NDBBOARD Make a New Directory line for a page in \BBOARD
32 N NDFAIL Make a New Directory line (FAIL type) for page
32 N NDSAIL Make a New Directory line (SAIL type) for page
19 N,A,E NONEMPTY Move to next non-empty line on page
21 N,A,E NUMBERS Enable or disable typing of line numbers with text
19 N,A OPEN Open the current file in Read-Alter mode
37 N,A,E,S OTHERCASE Invert the case of every letter in the given range
22 N,A,E PAREN Set the chars searched for by parenthesis cmds
21 N,A,E PARTIAL Operate on current message with next command
22 N,A,E PINFO Type out info about last parenthesis command
15 N,A POINTER Switch to a file named in the incore text
19 N,A PPSET Ensure that the page printer is positioned ok
25 N,A,E PRINT Print the current line(s) on the terminal
19 N,A PROTECTION Set or read the protection key of the file
27 N,A,E PUTDEFS Append all current macro definitions to a cmd file
39 N,A,E QUIT Exit (or close # windows) w/o writing out file
39 N,A RAISEWINDOW Raise the current window # lines on the screen
25 N,A,E RAPID Enable line editor simulator for use in macros
32 N RDFAIL Update the directory line with the page's FAIL labels
19 N,A READONLY Disallow changing the file
19 N,A READWRITE Allow changing the file
38 N,A,E RECONNECT Re-connect to a previous Lisp or PTY subjob.
27 N,A,S REDEFINE Define a macro from incore page or attach buffer
38 N,A REEVAL Send macro-format text (e.g., ⊗C for <cr>) to subjob.
26 N,A,E REMAINDER Set macro to remainder of <old value> / <repeat arg>
43 N,A,S REMIND Enter a REMIND-system reminder
42 N,E RENAME Rename the current file to the new name given
25 N,A,E RESUME Resume expansion of a macro that was stopped early
19 N,A,S ROVER Spool incore page(s) on the Rover printer
22 N,E RPAREN Search for next ")", crossing page boundaries
23 N,A,E RSYS Run a given system program, with RPG startup
23 N,A,E RUN Run a given user program, with RPG startup
19 N,A SAVE Write out incore page(s) in E$SAVE.TXT
28 N,A,E SAY Type out text and/or decimal number
38 N,A,E SCREEN Begin Screen Editing with PTY subjob, ⊗XLPEND mode
43 N,A,S SEND Send a message to someone logged in
26 N,A,E,S SET Set the value of a numeric macro
25 N,A,E SILENT Suppress error messages while inside macros
19 N,A,S SIN Replace tabs with equivalent numbers of spaces
16 N,A,S SJFILL Separate text into justified sentences
16 N,A,S SJUST Separate into justified right-aligned sentences
38 N,A,E SLISP Start up a Lisp subjob from [1,3]
19 N,A,S SPOOLC Spool incore page(s) on the line printer
13 N,A,E SSLINE Set or report the search limiting line number
13 N,A,E SSPAGE Set or report the search limiting page number
28 N,A,E STEP Step macro execution # steps
25 N,A,E STOPALL Set action on macro error to stop all macros
25 N,A,E STOPHOW Find out setting of macro error action
25 N,A,E STOPONE Set action on macro error to stop just one macro
25 N,A,E STOPZERO Set action on macro error to ignore errors
38 N,A,E SUBDETACH Detach current PTY subjob, and then flush the PTY
38 N,A,E SUBECHO Enable or disable echoing on current PTY subjob
38 N,A,E SUBFIND Find a PTY subjob and connect to it
38 N,A,E SUBJOB Start up a PTY subjob
38 N,A,E SUBKILL Kill all Lisp and PTY subjobs
38 N,A,E SUBLINK Enter Eval loop with PTY subjob, do ⊗1⊗0⊗XBOTSET
26 N,A,E SUBTRACT Subtract given repeat arg from macro's value
38 N,A,E SUBWAIT Allow E to wait forever for required Lisp response
38 N,A,E SULISP Start up a Lisp subjob from your alias
17 N,A,S TABLE Line up entries in a table
19 N,A,E TELLME Report the latest commands to person maintaining E
19 N,A,E TERSE Enter terse mode--suppresses some typed info
17 N,A,S TGET Same as TJGET command (see below)
6 N,A THISPAGE Write out incore page(s) and read back only current page
19 N,A,S TIN Replace multiple spaces with equivalent tabs
17 N,A,S TJFILL Justify paragraphs that begin with a table
17 N,A,S TJGET Get margins for TJFILL/TJUST from text
17 N,A,S TJUST Justify & R-align paragraphs beginning w/table
19 N,A,E TMPCOR Write out (now and on exit) TMPCOR file used by E
39 N,A TOPSET Position top edge of current window
39 N,A TRADEWINDOW Close current window and re-open previously closed one
21 N,A TRAILER Type out the trailer line (from bottom of window)
21 N,A,S TYPE Type out line(s) of text
35 N,A UNDELETE Restore recently deleted or changed text
30 N,A UPDATE Write out the updated incore directory
37 N,A,E,S UPPERCASE Make all letters in given range be upper case
19 N,A,E VERBOSE Enter verbose mode--types out extra info
19 N,A,E WRITTEN Type out who previous wrote the file and when
19 N,A,S XSPOOL Spool incore page(s) on the XGP
25 N,A,E YSET Set the macro to be called by the ⊗Y command
34 N,A ZFILES Zero (clear) the file stack (and filelist)
34 N,A ZLINES Zero (clear) the line stack
8 N,A ZMARKS Zero (clear) all line marks
34 N,A ZPAGES Zero (clear) the page stack
Abbreviations and explanation of E documentation. Credits.

This version of the E manual is intended for on-line use by the normal
user. It may be referenced at any time while editing another file
simply by typing a <CONTROL>? command. One may always return to one's
original file by typing the <CONTROL>H command.

A simplified form of this manual for the beginner is available by
typing HELP ETEACH with a carriage return to the system. This copies a
file named TEACH into one's file area and allows one to read it and
modify it for practice.

Another simplified E manual, "Essential E" by Arthur Samuel, is a good
document for the beginning user to read. It is CSD report number
STAN-CS-80-796, available from CSD Publication Services. It is the only
printed E manual and it is available only in printed form.

This is p. 4 of E.ALS[UP,DOC] (see the top line with asterisks).
Page 1, the "directory" page, is automatically prepared by E, and in
this case has been planned to be of maximum help to the user. There is
also an Index of Commands on p. 3.

ABBREVIATIONS used in this manual and in TEACH to characterize commands.

α means hold the "CONTROL" key down while typing a character.
β means hold the "META" key down while typing a character.
αβ means hold both "CONTROL" and "META" keys down while typing.
⊗ means use either α or αβ with the next character.

Most commands are single characters with one or both of the two keys.

Additional abbreviations
<cr> carriage RETURN key. <lf> LINE feed key.
<tab> TAB key. <alt> ALT-mode key.
<bs> Back-Space key. <form> FORM-feed key.
<vt> the VT key. <clear> the CLEAR key.
CURRENT means the current line (normally with an → or ↔ on the left).

Credits.

Dan Swinehart wrote TV, the original version of the display editor,
and created the original version of TEACH. Fred Wright then wrote E,
implementing essentially the same commands as TV had. TV was written
in SAIL, E in FAIL. Brian Harvey modified TEACH to reflect
differences between E and TV. Arthur Samuel and Martin Frost also
made improvements in TEACH.

Disclaimer.

An attempt has been made to present a coordinated view of E. To this
end some simplications have been made. The experienced user may develop
techniques that are not described in this manual. Any outright errors
should, however, be called to our attention (report any errors to BUG-E).
General remarks.

E is a fast display-oriented text editor for disk files. By using
random access to individual pages, E can move around quickly within a
file without having to be continually recopying the file; and only those
pages whose texts are changed are ever written out to the disk. E keeps
one or more contiguous pages in core and, on display terminals, shows to
the user a portion of this text as if through a window, thus showing
lines of text in context rather than isolated. Various commands are
available for moving the window from place to place in the file and for
moving around within the window. (Normally only one page is kept in
core, but the user can cause several contiguous pages to be kept in core
to provide even faster movement among those pages.) On displays, a line
pointer (arrow) and an underscoring cursor are used to mark the position
in the text where editing is to occur. On non-display terminals, text
is typed out instead of displayed.

Note: On Datamedia terminals (DMs), no arrow is used to indicate the
current line. Instead, the terminal's cursor is left under the first
character of the current line.

The window of text on a display screen is bordered above and below
by lines consisting mainly of asterisks or dots but which also include
information about the editing. A top or bottom border will be mostly
ASTERISKS when the last text line in that direction is visible
ON-SCREEN, and the border line will be mostly DOTS when there is more
text OFF-SCREEN in that direction.

The border line at the top is called the header line, and the border
line at the bottom is called the trailer line. The information on the
header line includes:
(1) the number of the text line just below the header,
(2) the number(s) of the incore page(s),
(3) the name of the file, and
(4) the editing modes.
The trailer line reports:
(1) the number of the current line,
(2) the total number of lines on the current page,
(3) the number of the current page,
(4) the total number of pages in the file, and
(5) some information about the size of the page(s) in core.
This last item tells the page's size with respect to the number of
records that it currently occupies on the disk. The amount of room the
page currently uses on the disk is given in records followed by the
letter "R". Following this is a number that shows how much spare room
there is for this page on the disk or how much extra room the page needs
in order to write it out to the disk. The amount of spare room or extra
room needed is reported in characters and is followed by the letter "C"
provided the number is 640 characters or less. In this case, a negative
number means there is that much room to spare and a positive number
means that much extra room is needed. If the amount of spare or extra
room is more than 640 characters, it will be reported in records (640
characters/record) and will be followed either by the letter "B" (for
Bloated) if there is room to spare or by the letter "X" (for eXpand) if
more room is needed.

If the file is not formatted, only a "?R" will appear where normally
the R and C/B/X fields appear.

Extra records indicated by a "B" on the trailer line will never be
removed automatically, although they can be removed by the ⊗XBURP
command.

E does not make a separate disk copy of the file being edited unless
that is requested by the use of a special command (described later), so
take care--when you write out a page, the former contents of that page
are lost.

Basic editing in E (on displays) utilizes the system line editor for
editing a single line at a time. E loads text from the current version
of a text line into the display's line editor and then lets you edit it
with the usual system line editor commands. When you are done with the
line, you type <cr> (or some other command) to give the edited text back
to E.

E achieves its speed (1) by using the system's line-editor and only
changing the core copy of the text on the completion of a line edit, and
(2) by updating the disk copy of the page only on the completion of a
page edit (automatically effected by moving to another page). You can
undo an entire page of incorrectly made modifications by cancelling an
update, but unfortunately, you can also lose an entire page of desired
modifications or additions if the system should go down unexpectedly.

E is best understood by recognizing that it operates in a few
different modes and that many commands are appropriate only to certain
modes. In fact, a couple of commands have quite different effects
depending upon the mode that E is in at the time when the command is
given.

The dominant mode is the NORMAL mode. This allows for page, window
and line pointer movement commands and commands which enter the other
modes.

ATTEMPT TO MINIMIZE FREQUENCY OF DISPLAY LOSSAGE ON Data Disc TERMINALS

To reduce the frequency of half-field display trouble on Data Disc (DD)
terminals, a slight compromise was needed for DD displaying. Namely, if a
line has 9 or 10 tabs in the first 80 columns, then the characters in
columns 81 to 84 may not get displayed by E (they will of course appear in
the line editor, as do characters beyond column 84). In particular, with
9 tabs in the first 80 columns, characters in columns 83 and 84 will not
be displayed, and with 10 tabs in the first 80 columns, characters in
columns 81 through 84 will not be displayed. This change seems to have
cut the frequency of DD display trouble by a factor of 10 (a system mod
has lessened the problem further still), but DON'T BE SURPRISED BY E'S
FAILURE TO DISPLAY CHARACTERS THAT ARE IN COLUMNS 81 to 84 on text
lines with lots of tabs; the characters are still there and they will
appear in the line editor if you edit such a given line.
PAGE CHANGING, APPENDING, DIVIDING, COMBINING, CANCELLING: ⊗XAPPEND ⊗XTHISPAGE β<ff> ⊗XMARK ⊗XDELETE ⊗XCANCEL

Modes Command Meaning
N β<form> Insert an incore pagemark
N,A αP Go to next Page
N,A αβP Go to next Page that is not in core
N,A ⊗-αP Go to previous Page
N,A ⊗-αβP Go to previous Page that is not in core
N,A ⊗#αP Go to Page #
N,A ⊗#αβP Go to Page #, retaining only it in core
N APPEND Add # following pages to incore text
N,A,E CA Flush unwritten changes to incore page(s)
N,A,E CANCEL Flush unwritten changes to incore page(s)
N DELETE Delete the next (not-incore) pagemark
N INSERT Insert an incore pagemark before current line
N,A M Make the current line start a new page
N,A MARK Make the current line start a new page
N,A THISPAGE Write out incore page(s) and read back only current page

PAGE CHANGING commands.

PAGE-CHANGING commands are single characters typed with the CONTROL key
held down or with both the CONTROL and the META keys held down. They may
take modifiers as shown below. Note: if you have more than one page in
core, then there is a slight difference between the commands αP and αβP.

αP Go to the next Page.
αβP Go to the next Page that is not already in core.

⊗7αP Go to page 7.
⊗7αβP Go to page 7, retaining only it in core.

⊗+⊗4αP Go forward 4 pages.
⊗+⊗4αβP Go forward 4 pages from the last page in core.

⊗-αP Back up to the previous page.
⊗-αβP Back up to the previous page that is not already in core.

⊗-⊗3αP Back up 3 pages.
⊗-⊗3⊗P Back up 3 pages from the first page in core.

It is good practice to limit the page size to less than 150 lines.
This eases the load on the editor and makes the directory of more use.
The directory will be much more useful if you also make it a practice to
start each page with a suitable comment, in the case of code perhaps
containing a list of all labels to be found on the page. You can than
use a special directory search procedure (explained on p. 13) to expedite
the location of any desired item that is so listed.

PAGE APPENDING and UNAPPENDING commands.

It is possible to have more than one page in core at the same time. This
technique makes it possible for two pages to be edited together at the
same time while retaining all of advantages of short pages, as noted above.
To do this one makes use of the ⊗XAPPEND command.

⊗#⊗XAPPEND Read in # additional pages after the current one(s) so
that two or more contiguous pages may be edited together.
If no arg (#) is given, one additional page is read in.
This command is not legal from the directory page or in
an unformatted file. The arrow may be moved up and down
freely on the combined incore pages and the αP command
(with an argument if desired) may be used to switch
between the incore pages, without affecting the APPEND
status. αβP commands will, however, write out all incore
pages and read in only the one specified. The ⊗XCANCEL
command (below) cancels all corrections on all of the
incore pages and reads in the previous version of the
first incore page.

⊗XTHISPAGE This command is useful for going from multipage mode (two
or more pages in core, from having done an ⊗XAPPEND or a
β<ff>) to single page mode (one page in core). This
command writes out the incore text and then reads in only
the page where the arrow is. The position of the arrow
and (when possible) the windowful are preserved. However,
the line stack is currently cleared.

PAGE DIVIDING commands

A page may be split into two pages in either of two ways, one way
leaving only the newly created page in core and the second way leaving
both pages in core together.

⊗XMARK
or
⊗XM Split the current page into two pages with the arrow line
as the first line of a new page. Write out the incore
pages and retain in core only the page containing the
arrow line.

If this command is given when there is some text attached,
the attached lines are first put down and then the page is
divided in two and written out. The division occurs at
the beginning of the formerly-attached lines unless those
lines are already at the top of a page, in which case the
division occurs after the formerly-attached lines. The
arrow is left at the top of the formerly-attached lines,
whose page is the only one retained in core.

β<form> Split the current page into two pages with the arrow line
as the first line of the newly created page and retain
both pages in core without writing out anything.

⊗XINSERT Exactly the same as β<form>.

PAGE COMBINING commands

Two pages may be combined into one page in either of two ways.

⊗XDELETE<cr> Delete the pagemark at the end of the last incore page
and add the text that was formerly on the next page to
the present in-core page, writing out the resultant page.

To delete a page mark that divides two pages that are already in core
togather, one moves the arrow to the on-screen representation of the
page mark separating the two pages and gives the following command.

αβD When this command is given with the arrow pointing to an
on-screen page mark, the page mark is deleted and the two
adjoining pages are combined into one page. Thus, this
command will delete either regular text lines or pagemark
lines (without writing out any pages).

PAGE RESTORING command

⊗XCANCEL Do not write out the current page but instead reread it in
or from the disk. If several pages are in core, only the
⊗XCA first of those is reread from the disk. See p. 8 for the
effect ⊗XCANCEL has on line marks.
windowful and ARROW moving commands.

Modes Command Meaning
N,A,E <form> Go forward one windowful among incore text
N,A,E ⊗0<form> Go forward a half windowful among incore text
N,A,E ⊗#<form> Go forward # windowfuls among incore text
N,A ⊗<form> Go forward one windowful, changing pages if necessary
N,A,E <vt> Go back one windowful among incore text
N,A,E ⊗0<vt> Go back a half windowful among incore text
N,A,E ⊗#<vt> Go back # windowfuls among incore text
N,A ⊗<vt> Go back a windowful, changing pages if necessary
N,A β<vt> Go back a windowful, changing pages if necessary
N,A <cr> Move arrow to next line
N,A <bs> Move arrow up a line
N,A β<bs> Move arrow up a line
N,A ⊗<bs> Move arrow up a line (see also ⊗U cmd)
<ESC>I Terminate wait on delayed ⊗V command
N,A ⊗B Glitch screen up from Bottom
E αβB Glitch screen up from Bottom
N,S αβD Delete line
N,S ⊗#αβD Delete # lines
N,S ⊗-αβD Delete previous line
N,S ⊗-⊗#αβD Delete # previous lines
N,A,E ⊗J Jump the arrow line to the top of the screen
N ⊗-⊗J Jump the arrow line to the bottom of the screen
N,A,E ⊗0⊗J Jump the arrow line to the center of the screen
N ⊗#⊗J Jump the arrow line up # lines
N ⊗-⊗#⊗J Jump the arrow line down # lines
N,A αL Go to first line of current page
N,A,E αβL Go to first line of incore text
N,A,E ⊗#αL Go to Line # of current page
N,A,E ⊗#αβL Go to Line # of all incore text
N,A ⊗T Glitch screen down from Top
E αβT Glitch screen down from Top
N,A,E ⊗U Move arrow Up a line (recommended cmd for non-displays)
N,A,E αV Redraw screen (without clearing)
N,A,E αβV Clear and then redraw screen
N,A,E ⊗#⊗V Redraw screen and then wait # seconds; ESC I ends wait
N,A,E ⊗W Go forward one windowful among incore text
N,A,E ⊗0⊗W Go forward a half windowful among incore text
N,A,E ⊗#⊗W Go forward # windowfuls among incore text
N,A α. Write out current page (not including attach buffer)
N,A,E αβ. Write out current page (including current line editor)
N,A,E ⊗> Move arrow down 4 lines
N,A,E ⊗< Move arrow up 4 lines
N,A,E ⊗≥ Move arrow down half a screen
N,A,E ⊗≤ Move arrow up half a screen
N,A,E ⊗∧ Move arrow to top of screen
N,A,E ⊗0⊗∧ Move arrow to middle of screen
N,A,E ⊗∨ Move arrow to bottom of screen
N,A,E ⊗0⊗∨ Move arrow to middle of screen
N,A,E DRAW Redraw the screen now

These are Normal-mode commands. The CURRENT line is marked by an arrow
and is the line that would be processed if one were to enter the line-
editor. In the descriptions below it will be referred to as the arrow
line.

The first set of commands control the position of the window on the page.
The arrow is usually repositioned by these commands.

<form> Advance the window, that is, move the last line to the top. This
command (without control bits) does not advance the window beyond
the range of the in-core text.
An argument may be used (typed with control bits and preceding
the <form) to define the number of windowfuls to be advanced.
⊗W This is an older (still functioning) command to do the same thing.

⊗4<form> Advance 4 windowfuls among the incore text.
⊗4⊗W Same thing.

⊗0<form> Advance half a windowful.
⊗0⊗W Same thing.

⊗<form> Advance the window as defined above but move to beginning of the
next page if the the end of the in-core text is already within
the window.

β<form> This command is NOT a window moving command (see p. 6 for its
explanation). Do not confuse it with <form> or ⊗<form>.

<vt> Move the window up so that the first line becomes the LAST. This
is the reverse of <form>. This command without control bits does
not back up beyond the range of the in-core text.

⊗3<vt> Back up 3 windowfuls among the incore text.

⊗0<vt> Back up half a windowful.

⊗<vt> Move the window up so that the first line becomes the LAST. This
or command (with any control bits), will move to the end of the
β<vt> preceding page if the start of the in-core text is already within
window. If any arg is given, that many windowfuls are backed up,
but only among the incore text.

The following commands leave the page, window and arrow unchanged but
they refresh the screen. If any of these commands is typed ahead, the
screen will be redrawn immediately when the command is encountered,
despite any further type-ahead.

αV Redraw the screen WITHOUT first clearing it (the fastest).

αβV Clear the screen and then redraw it (this is slower on Data Discs).

⊗3⊗V Redraw screen as above then wait 3 seconds before continuing.
<esc>I will terminate the wait.

⊗XDRAW Exactly the same as ⊗V (in various forms explained above).

The following commands move the position of the window on the page, leaving
the arrow so that it still points to the same line of the text, if this is
possible, otherwise causing it to point to the first or last line on the
window.

⊗J Move (JUMP) the window so that the arrow line is at the top.
⊗0⊗J Move (JUMP) the window so that the arrow line is at the middle.
⊗-⊗J Move (JUMP) the window so that the arrow line is at the bottom.

⊗3⊗J Move (JUMP) the window so that the arrow line is 3 lines higher
in the window (with the top as the limit).
⊗-⊗7⊗J Move (JUMP) the window so that the arrow line is 7 lines lower
in the window (with the bottom as the limit).

Note that the default argument for the J commands is, in
effect, infinity, with the argument 0 having a special meaning
rather than being a undefined.

⊗T Glitch the screen so that 4 additional lines are displayed at the
or top (⊗T) or bottom (⊗B) of the screen. An argument, if used, is
⊗B in multiples of 4 lines of glitching. If either of these
commands is given from the line editor, then αβ must be used
(the α version will be a line editor command instead) and the
the arrow is maintained on the same text line, which is not
permitted to move beyond the edge of the screen, and you are
left still in the line editor.

The following commands move the arrow with respect to the window, without
moving the window.
⊗∧ Move the arrow to the top line in the window.
⊗3⊗∧ Move the arrow to the line that is 3 down from the top of the
window.
⊗9⊗9⊗∧ Since this would be off of the window the arrow is simply moved to
the bottom of the window. (The next command does this more easily).
⊗∨ Move the arrow to the bottom line in the window.
⊗4⊗∨ Move the arrow to the line that is 4 up from the bottom of the
window.

⊗0⊗∧ Move the arrow to the middle of the window.
⊗0⊗∨ Move the arrow to the middle of the window.

The following commands move the arrow with respect to the text. Should this
require the arrow to leave the currently displayed windowful, the window is
shifted, usually so that the arrow line will be in the middle of the window.

<cr> Move the arrow down a line, unless at row of stars.
⊗> Move the arrow down 4 lines.
⊗≥ Move the arrow down 1/2 screen.

<bs> Move the arrow up a line (cannot be typed ahead on non-displays).
⊗U Move the arrow up a line (works better than <bs> on non-displays).
⊗< Move the arrow up 4 lines.
⊗≤ move the arrow up 1/2 screen.

αL Move the arrow to the first line of the current page.
αβL Move the arrow to the first line of all the incore text.
⊗5αL Move the arrow to the 5th line of the current page.
⊗5αβL Move the arrow to the 5th line of all the incore text.
⊗∞αL Move the arrow to the end of the current page.
⊗∞αβL Move the arrow to the end of all the incore text.

The following comands move the arrow with respect to the text, as above,
AND they enter the LINE-EDIT mode. They may also be given when in the
LINE-EDIT mode (see p. 9) but they then require αβ with the arguments.

α↑ Enter the LINE-EDIT mode with the cursor at the end of the
previous line.
αβ↑ Enter LINE INSERT mode with the cursor at the end of the
previous line. See also p. 11.
⊗3α↑ Enter the LINE-EDIT mode with the cursor at the end of the
third previous line.
α↓ Enter the LINE-EDIT mode with the cursor at the end of the
next line.
αβ↓ Enter LINE INSERT mode with the cursor at the end of the
next line. See also p. 11.
⊗6α↓ Enter the LINE-EDIT move with the cursor at the end of the
sixth line forward.

The following commands remove text lines from the page.

αβD DELETE the entire CURRENT line.
This takes both α and β since αD has a different meaning.
To undo this command, use the ⊗XUNDELETE command (see p. 35).
Alternatively, you can use the ⊗XCANCEL command (see p. 6),
but that may have a larger effect than you want.

⊗4αβD Delete 4 lines starting with CURRENT.

Here are some commands that save the currently edited page on the disk.
Note: the current page is saved automatically whenever you change pages.
Also, whenever the page is written out, any text in the attach buffer
is excluded from that being written out.

α. Write the current page (as corrected) into the disk file.
This command is legal only from NORMAL MODE.
αβ. This command also writes out the current page, but it works
from NORMAL, LINE-EDIT and LINE INSERT modes. Thus it can be
given from within the line editor to write out the page
(including the current version of the arrow line) without
having to get out of the line editor.
αE Do a α. and then close the current file and window, exiting
to the monitor if no other windows open. This is not a legal
command to execute during macro expansion because the same
command is used to put down any attach buffer (see p. 10).
After you exit from E, you can get back into E at the same
place by immediately using the system command CONTINUE.
αβE Write out the text in all windows and exit to the monitor.
(Not legal inside a macro, but see ⊗XEXIT.) For use of αE
and αβE with multiple windows, see p. 39.

Most of the NORMAL-MODE commands require the use of the CONTROL key (α)
and perhaps the META key (β). Exceptions are <cr>, <bs>, <form> and <vt>.
LINE MARKING commands.

Modes Command Meaning
N,A αM Go forward to next Mark
N,A ⊗-αM Go backward to previous Mark
N,A ⊗#αM Go forward # Marks
N,A ⊗-⊗#αM Go backward # Marks
N,A αβM Place a Mark on current line
N,A ⊗-αβM Clear Mark on current line
N,A ⊗0⊗M Report the number of Marks in current file
N,A ZMARKS Zero (clear) all line marks

E provides the facility of marking up to 23 line locations with a rapid
way to return to these locations by using the following commands.

Marks are relative with respect to the line locations on the page but the
stored values are corrected for line and page insertions and deletions so
that the marks appear to stick with particular text lines. However, the
justification commands and the line-breaking and line-joining commands do
not adjust marks properly, so those commands may cause the marks to move
slightly from the originally marked text lines.

Marks do not accompany attachments and they do not disappear when lines
are deleted. Instead, marks on lines that are attached or deleted are
moved to the first remaining line after the attachment or the deletion.

The ⊗XCANCEL command resets the marks for the page being cancelled to the
values they had when this page was last saved by an αβ. or page changing
command. Incidentally, if all marks, including those on other than the
current page, are removed by an ⊗XZMARKS command, they may all be restored
by the ⊗XCANCEL command, (if this is done before any page saving command)
with, of course, the accompanying restoring of the text of the current
page.

Marks are saved during ⊗ε, ⊗λ, ⊗? and ⊗H file-switching operations and are
restored on returning to a previously marked file.

αβM Plant a line mark at the current line on the current page.
⊗-αβM Clear the line mark (if any) on the current line.

αM Go forward to the next line mark (cyclicly).
α2αM Go forward to the second line mark found (cyclically).
α-αM Go backward to the first previous line mark (cyclicly).
α-α3αM Go backward to the third line mark found (cyclically).

⊗XZMARKS Clear all line marks.
⊗-⊗XZMARKS Clear all line marks on the current page.
LINE-EDIT commands.

Modes Command Meaning
E,L α<form> Move cursor to beginning of line
E <cr> Close line and move arrow to next line
E α<cr> Leave LINE-EDIT mode, stay on same line
N β<cr> Insert <cr>
E β<cr> Close line and insert <cr>
I β<cr> Insert <cr> but don't leave LINE INSERT mode
E,L <bs> Move cursor left a char, deleting if at end of line
E,L α<bs> Move cursor to left (never deleting char)
E,L β<bs> Delete char to left
E,L αβ<bs> Repeatedly move cursor to left (as long as held down)
N,E,L α<tab> Go to end of current line
E <alt> Restore line to original condition
E,L αB Move backwards in line editor to next char typed
E,L αD Delete char (if at end of line, delete CRLF)
N,E,L αI Enter Insert mode (at end of line, enter LINE INSERT mode)
N,E,L αK Kill characters forward up to next char typed
E,L αL Kill characters backward up to next char typed
N,E ⊗Q Copy line above, and enter copy in line-edit mode
N,E,L αR Repeat line editor αS or αK or αB or αL cmd
N,E,L αS Skip to next char typed
E,L αT Transpose the previous two chars in the line editor
N,E αβ; Set col of interest to current col and move straight up
N,E α; Move up to next line at old column of interest
N,E αβ: Set col of interest to current col and move straight down
N,E α: Move down to next line at old column of interest
N,E α↑ Move to end of line above
N,E α↓ Move to end of line below

E uses the line-editing commands that are a part of the operating
system. There is a limit (usually 133) to the number of characters that
the line editor can handle.

Typing a character without a CONTROL or META key will normally invoke
the line editor and the character is typed into the CURRENT line. A
cursor will appear under the first character in the line and in that
position where the next typed character will go. A character so typed
overwrites the character that was at the cursor's position. E will be
in the LINE-EDIT mode.

A word of caution--it is usually safe to continue typing on entering
the LINE-EDIT mode without waiting for the system to catch up. Most of
the earlier bugs that caused this to fail have been fixed but it is wise
to look before giving a carriage return and if anything is amiss to type
<alt> and start over again.

When the arrow appears to point at the bottom row of asterisks
(which, of course, is not in the text) E will accept anything that is
typed as an added line of text. The asterisks temporarily disappear
only to reappear below the new line on the completion of the addition,
and E reverts to the NORMAL mode.

When in the LINE-EDIT mode a <cr> will terminate the mode and move
CURRENT to the next line. A α<cr> will terminate the LINE-EDIT mode
without moving CURRENT. Remember that the line corrections do not
appear in the core image until you leave the line-editor mode.

Also remember that the version on the disk still does not show your
corrections until a disk update has been initiated. When in this
intermediate state the letter W will appear at the end of the title line
(with asterisks or dots at the top of the window, meaning that something
is yet to be written.

If your change will require the directory to be changed, this will be
shown by the letter D in this top line. The letter X can also appear if
the change requires an extension in the space on the disk assigned to
the current page. The letter X also appears on the trailer line with a
number specifying the number of extra records (of 128 words) that will
be required. If no extra records are required this X is replaced by the
letter R following a number specifying the number of records that the
page occupies or will occupy on the disk. After a deletion the letter B
may appear in place of this R or X, again preceded by a number that
specifies the number of all-null records that the page will contain.

By the way, window moving commands do not automatically update the
disk, whereas page changing commands always do an update.

Most of the line editing commands listed below will also enter the
LINE-EDIT mode from the NORMAL mode, except when the arrow is pointing
either at the row of asterisks (at the end of the page) or at an incore
pagemark. However, the following line editor commands will not enter
LINE-EDIT mode from NORMAL mode, where they have different meanings:
αT, αB, αL, α<form>, <bs> and ⊗<bs>.

If you make a mistake and perhaps lose some valuable information hit
<alt> rather than <cr> and your data will reappear as if by magic.

The following commands move the cursor without changing the line.

α<space> Move the cursor to the right 1 space.
α4α<space> Move the cursor 4 spaces to the right.
α<bs> Move the cursor to the left 1 space.
α5α<bs> Move the cursor 5 spaces to the left.
α<tab> Move the cursor to the end of the line.
α<form> Move the cursor to the start of the line.

αS then <char> Move the cursor to the next occurrence of <char>.
α3αS then <char> Move the cursor to the 3rd next occurrence of <char>.

αB then <char> Move cursor backwards to nearest occurrence of <char>.
This command will not enter the line editor from NORMAL
mode, where it has a different meaning.
α3αB then <char> Move cursor backwards to 3rd nearest occurrence of <char>.

The following commands allow you to insert or delete characters.

β<char> Make room and insert <char> ahead of the cursor
position.

αD DELETE a character and move the rest of the line to the
left. If at the end of the line, this will append the
next line to the current one. E will prevent this from
being done if the resulting line would be too long for
the line editor.
α4αD Delete 4 characters starting at the cursor position but do not
append the next line should the count exceed the number of
remaining characters in the line (unless command is given when
cursor is at the end of the line).

αK<char> KILL the line starting with the cursor position up to but
not including the character typed. Do nothing if the no
such character is found.
αK<cr> Kill the rest of the line starting with the cursor position.

α4αK<char> KILL the line up to the 4th occurrance of the character.

αL<char> KILL BACKWARDS starting with the previous character on back to but
not including the character typed. Do nothing if the no
such character is found before the cursor. This command will
not enter the line editor from NORMAL mode, where it has a
different meaning.
αL<cr> Kill BACKWARDS everything before the current character.

α4αL<char> KILL backwards everyting back to the 4th occurrance of the character.

The following command allows you to correct one of the most common typing errors.

αT Reverse the order of the two characters just ahead of the cursor.
This command will not enter the line editor from NORMAL mode,
where it has a different meaning.

The following commands allow you to leave the LINE-EDIT mode.
α<cr> Accept the line, leave LINE-EDIT mode but do not move the arrow.
<cr> Accept the line, leave LINE-EDIT mode and move the arrow down.
⊗U Accept the line, leave the line-edit mode and move arrow up
one line.

For completeness the <cr> and <bs> commands are listed togather to
remind you that they do quite different things depending upon the
associated control keys.

<cr> Accept the line, leave LINE-EDIT mode and move arrow down.
α<cr> Accept the line, leave LINE-EDIT mode but do not move arrow.
β<cr> Insert a <cr> before the cursor position; leave LINE-EDIT mode
(unless in LINE INSERT mode) but do not leave LINE INSERT mode.
αβ<cr> Break line at cursor and enter LINE INSERT mode (see p. 11).

<bs> BACK SPACE, deletes like β<bs> if at the end of the line,
otherwise just moves the cursor to the left like α<bs>.
α<bs> Move cursor to the left WITHOUT deleting.
β<bs> Delete the character to the left of the cursor position.
αβ<bs> Repeatedly move cursor to left (as long as held down).

The following commands allow you to enter or leave the INSERT mode.

αI Enter INSERT mode (like holding META down continuously).
Everything that you type (including carriage returns) will
be inserted until you type another line editor command. If
you give this command while at the end of a line, you will
enter LINE INSERT mode (see p. 11) instead of INSERT mode.
αβI Enter LINE INSERT mode (see p. 11).
α<cr> Accept the line, leave Insert or LINE INSERT mode but do not
move arrow.
<alt> Restore the line to it original condition and leave the
LINE-EDIT mode. (See p. 11 for its action when in
LINE INSERT mode.)

The following commands allow you to leave the line-edit mode, move to
another line and reenter the line-edit mode, all with one command.

α↑ Accept the line, then move to the end of the previous line.
αβ3α↑ Accept the line, then move to the end of the third previous
line.
α↓ Accept the line, then move to the end of the next line.
αβ6α↓ Accept the line, then move to the end of the sixth line
forward.

αβ↑ Enter LINE INSERT mode with the cursor at the end of the
previous line. See p. 11.
αβ↓ Enter LINE INSERT mode with the cursor at the end of the
next line. See p. 11.

α; Accept the line, then edit the PREVIOUS line at the "column of
interest" defined by the last αβ; or αβ: command.
αβ; Set the "column of interest" (for the α; and α: commands) to
the current column, then accept the current line and edit the
PREVIOUS line at the new "column of interest".
αβ3α; Accept the line, then edit the third PREVIOUS line at the
"column of interest" defined by the last αβ; or αβ: command.
αβ3αβ; Like αβ3α; after setting the column of interest to current column.

α: Accept the line, then edit the NEXT line at the "column of
interest" defined by the last αβ; or αβ: command.
αβ: Set the "column of interest" (for the α; and α: commands) to
the current column, then accept the current line and edit the
NEXT line at the new "column of interest".
αβ6α: Accept the line, then edit the sixth line forward from the same
display position as that from which this command was given.
αβ6αβ; Like αβ6α; after setting the column of interest to current column.

The above commands work in both NORMAL and LINE-EDIT modes, as does
the following command which allows you to copy a line and then edit it.

⊗Q Insert a copy of the line just above CURRENT and open it
for editing (i.e., enter LINE-EDIT mode in new line).

If you are editing a line and type something that the line editor
does not understand it will usually ignore the error (after thinking
about it for a moment) but don't bank on this too heavily because it can
fail.

If you type a legal ⊗ command (some are forbidden) when in LINE-EDIT mode
the line will be accepted as edited and the command will be carried out.
(Typing α. in LINE-EDIT mode returns to LINE-EDIT mode automatically without
writing the page because this command is illegal in LINE-EDIT mode.)

The α<cr> command, that works to recall a line from the system buffer
in the system's monitor mode, is replaced by the ⊗Q command as described
above.

COMMANDS GIVEN WHILE IN LINE-EDIT MODE

Many, but not all, of E's commands can be given when the user is
editing the current line in the system line editor. The command index on
p. 3 indicates for each command whether it is legal from the line editor.
The letter "E" in the "mode" column indicates a command legal from the
line editor.

When you activate the line editor with part of a command that might end
up returning you to the line editor without having accepted the edited
version of the line, E will redraw the line editor text while awaiting the
rest of the command. This currently applies to the following partial
commands: ⊗X ⊗Z. Also drawn will be a special cursor to indicate where in
the line you are giving the command from. (The cursor is the same one
you'll see when stepping macros -- wider than the normal ones on DDs and
IIIs.) However, if the line is longer than the screen width, the wrapped
around part of the line will not be displayed, nor will the cursor if it
is in that part.

LINE-EDITOR-ENTERING COMMANDS GIVEN FROM THE LINE EDITOR

E commands that normally cause the current line to be edited with the line
editor are legal even when given from within the line editor itself. Most
of these commands are usually handled directly by the line editor, without
E ever seeing them. But if such a command is generated in a way that
causes activation of the line editor, for instance, by preceded it with a
repeat argument using both CONTROL and META, then E figures out how to
carry out the command, usually including reloading the line editor with
the resultant text. Thus the command αβ8G will type eight G's into the
line editor, and αβ8βH will insert 8 H's.

Attach and Copy commands: ⊗A ⊗C ⊗E αβK αβR

Modes Command Meaning
N,A,E,S ⊗#⊗A Attach # lines (first putting down any attached lines)
N,A,E,S ⊗+⊗#⊗A Attach # more lines to end of buffer
A ⊗-⊗#⊗A Put down last # lines in buffer, move above them
N,E ⊗-⊗#⊗A Attach # lines above current line (not in att mode)
N,E,S ⊗#⊗C Copy # lines into attach buffer (not in att mode)
A ⊗#⊗C Put down whole attach buffer, then copy # lines
A ⊗C Put down copy of whole attach buffer
A,S ⊗+⊗#⊗C Copy # more lines into end of buffer
A ⊗-⊗#⊗C Kill last # lines in attach buffer
N,E ⊗-⊗#⊗C Copy # lines just above current line (not in att mode)
A ⊗E Leave ATTACH mode by putting down all attached lines
A ⊗#⊗E Put down first # lines in buffer, move past them
N,A ⊗-⊗#⊗E Attach # more lines at front of buffer from above
A αβK Kill all attached lines
A ⊗#αβK Kill first # lines in attach buffer
N,A ⊗-⊗#αβK Copy # more lines to front of attach buffer from above
A αβR Put attached lines back where they were picked up

The attach (⊗A) and copy (⊗C) commands permit blocks of lines or
copies of them to be moved up and down on the page or from page to page,
or from file to file, as desired. The additional commands αβK, αβR and
⊗E are also used to manipulate the attached lines.

The ⊗A command removes one or more contiguous lines of text from the
core image of the page and places them in a special attach buffer. The
lines are still displayed on the screen in their original position, and
an "A" is displayed at the top of the screen to indicate that you are
now in attach mode.

The ⊗C command makes a copy or one or more contiguous lines and
places the copied lines in the attach buffer. An "A" is displayed at
the top of the screen, indicating that you are now in attach mode.

The ⊗E command puts the attached lines back down into the incore page
at the location where they are currently displayed. Note that this
command has a different meaning (namely, "exit from E") when you are not
in attach mode (i.e., when you have no lines attached), so be careful
not to type it twice in a row unless you do want to get out of E.

The αβK command kills the entire attach buffer, thus deleting the
lines from the attach buffer without replacing them on the page. (Note
that this command requires typing αβK, since αK is a line editor
command.) The ⊗XUNDELETE command can, as usual, retrieve the text of
recently deleted lines; see p. 35.

The αβR command replaces the attached lines back on the page at the
point where they were attached (first moving to the appropriate page if
necessary), provided the lines were attached rather than copied and
provided the file they came from is the current file being edited.
(Again, note that this command requires αβR to be typed, since αR is a
line editor command.) If all of the lines were copied (or created by
some other command(s) that create attached lines) rather than attached,
then the αβR command deletes the copies (just like αβK would); thus even
in this case the αβR command sort of puts the lines back where they came
from (NeverNever Land). If the attach buffer has been built up from
lines taken from various places, with at least one being attached rather
than copied, then the αβR command will put the lines back at the spot
where the last group of lines was attached to the buffer.

For adding or removing lines at the beginning or end of the attach
buffer, some variations of the above commands are available, all of which
use a repeat argument (possibly signed) to specify the action and the
number of lines to be affected. All of these commands are detailed in the
summary table at the beginning of this page. In that table, except where
a command without argument is described explicitly, an omitted argument ⊗#
is taken as ⊗1. The letters N, A and E at the left of a command indicate
the modes in which that command is legal: N is normal mode (no lines
attached), A is attach mode (some lines attached), E is line editor mode
(text of current line is in the line editor). The letter S means that
the argument to the command can be specified with a search command (or
with the ⊗! or ⊗∂ command).

Attached lines are marked on the display by vertical bars (|) at the
left, except on Datamedias (and similar displays supported by WAITS),
where they are indicated by being displayed in BOLD rather than
lightface (this makes attached blank lines somewhat hard to detect on
Datamedias).

There is a maximum number of attached lines that E will display at
any given time. This number is initially 8 but can be changed with
the ⊗XATTSET command, explained on p. 33. If there are more lines
attached than E can currently display, then the first and last few
lines of the buffer will be displayed, separated by a line containing
an ellipsis (. . .) indicating where the non-displayed lines belong.

The attached lines can be moved around on the page, or from page to
page, or even from file to file, with the usual CURRENT-moving commands.
In this way, the attached lines can be positioned so that a final ⊗E
command will deposit them back into the core image of the text at the
desired position. E always displays the attach buffer in the position
where the lines would go were a ⊗E command to be given immediately.
Note that while in attach mode, the line displayed immediately below
the attach buffer is the line designated as the CURRENT line.

Note that a single attach command is not allowed to cross a page
boundary (in particular, it can't cross an incore pagemark). And
attached text itself never contains a pagemark.

A word of warning, a hazard is involved in using ⊗A to move lines
from page to page. The attached lines can be lost if the system should
crash during the interval between the removal of the attached lines from
one page and the final updating of the page to which they are moved.
This hazard can be avoided by copying the lines rather than attaching
them and then going back and deleting the original copy. This
precaution is hardly necessary for a line or two but it is a wise one
when you are moving large blocks of text.

Moving lines from page to page takes time, so don't get impatient.

This is a good place to comment on the RIPPLING report, that you may
have noticed in the scratch-pad lines at the bottom of the screen. This
notice appears when a major rearrangement of the text between records
becomes necessary. This also takes time.
LINE INSERT mode.

Modes Command Meaning
I α<cr> Leave LINE INSERT mode, stay on same line
N,I αβ<cr> Enter LINE INSERT mode and insert a blank line
E,I αβ<cr> Enter LINE INSERT mode breaking current line at cursor
N,E ⊗#αβ<cr> Insert # blank lines
N,E,I αβ<tab> Go to end of current line and enter line insert mode
I <alt> Close line, leave LINE INSERT mode, delete line if empty
N,I αβI Enter LINE INSERT mode and insert a blank line
E,I αβI Enter LINE INSERT mode in current line (new line if at end)
N,E,I αβ↑ Move to end of line above and enter line insert mode
N,E,I αβ↓ Move to end of line below and enter line insert mode
N,A,E,I AUTOWRITE Set or read autowriting threshold for line insert mode

While one can add text at the bottom of a page by simply moving the
CURRENT marker so that it points at the bottom row of asterisks (not the
dots), a special mode is used to insert lines of text at other points.
As a matter of fact it is usually better to enter this special
LINE INSERT mode if one is to type several lines even when at the end of
a page. Users on non-displays can only enter text in LINE INSERT mode.

When in the LINE INSERT mode, typing a carriage return inserts the text
of that line into the page (in core, not on the disk yet), creates a new
blank line below, and leaves you editing the new blank line. Each
carriage return in LINE INSERT mode thus creates a new blank line.
Various commands will get you out of LINE INSERT mode, usually keeping
the text of the last line inserted.

The only command that gets you out of line insert mode without accepting
the last line inserted is altmode, and even then the line's text will be
accepted unless the line is empty. Typing an altmode on an empty line
while in line insert mode will restore the line to its state as of the
time you entered line insert mode. In particular, either the line will be
deleted (e.g., if you typed <cr><altmode> while in line insert mode) or
the line's previous text will be restored (e.g., if you had entered line
insert mode on that line by typing ⊗I from within the line editor).

The fact that E is in the LINE INSERT mode is signalled by a double arrow
(↔) pointing to the current line instead of the usual right arrow (→) and
by an "I" appearing on the header line at the top of the screen. (On
Datamedias, neither the double arrow nor the right arrow is used. Only
the terminal's cursor marks the current line and the "I" at the top is
the only indicator of LINE INSERT mode.)

To enter the LINE INSERT mode:

αβ<cr> Given from normal mode (not editing a line), this command enters
LINE INSERT mode on a blank line inserted ahead of the current
line. Given from the middle of a line, this command will break
the line where the command was given into two separate lines and
leave you in line insert mode at the end of the first part. If
you were at the end of a line when you gave this command, you will
enter line insert mode on a new blank line inserted just below.
In any case, a double arrow (↔) and an "I" at the top will
indicate that you are in LINE INSERT mode.

αβI This command is the same as αβ<cr> except when given from the
line editor, in which case it enters line insert mode but leaves
you editing that line without either breaking it in two or
inserting a blank line. The next carriage return will, as
usual, insert a blank line.

αI This command enters line insert mode only when given at the end
of the line editor (otherwise, this is a line editor command).
From the end of the line editor, this command is just like αβI
given from the same place (enters line insert mode on a blank
line inserted below).

I This is the normal command for entering line insert mode on a
non-display; the effect is exactly the same as that of αβ<cr>.

αβ↑ Enter line insert mode at the end of the line above. No new
blank line is inserted by this command, but subsequently typing
<cr> will insert a new blank line (as usual in line insert mode.)

αβ↓ Enter line insert mode at the end of the line below. No new
blank line is inserted by this command, but subsequently typing
<cr> will insert a new blank line (as usual in line insert mode.)

αβ<tab> Enter line insert mode at the end of the current line. No new
blank line is inserted by this command, but subsequently typing
<cr> will insert a new blank line (as usual in line insert mode.)

While in LINE INSERT mode:

<cr> Accept the line and move down, inserting another new blank line.

α<cr> Accept the line and leave LINE INSERT mode, staying at the same line.

β<cr> Insert a <cr> but stay in line insert mode.

⊗U Leave LINE INSERT mode and move the arrow back to the line above
the accepted line.

<alt> Leave LINE INSERT mode without moving the arrow. If the last line
inserted is empty, then that line will be deleted provided that it
didn't exist when you entered line insert mode, but if it did
already exist, then its previous text will be restored. Typing
<alt> on a non-empty line while in line insert mode always keeps
the final text of that line.

AUTOWRITER FOR LINE INSERT MODE:

E can be made to automatically write out the incore text after a given
number of lines have been inserted in line insert mode; this is called
autowriting with a given threshold number of lines. The default is NEVER
to write out the text automatically.

When autowriting is enabled, it occurs only upon a CR given in line insert
mode, and then only every N lines, where N is the current threshold. When
autowriting occurs, a message to that effect is typed out and you are then
left still in line insert mode. Only lines created with line insert mode
are included in the autowrite line counter, and the counter is reset to
zero whenever the page is written out (by any means) and whenever you
switch pages or ⊗XCANCEL.

Here are the commands to set and inquire about the autowrite mode status.

⊗#⊗XAUTOWRITE Sets to # the threshold number of inserted lines after
which E will automatically write out the page.

⊗-⊗XAUTOWRITE Disables autowriting (the default state).

⊗XAUTOWRITE or ⊗0⊗XAUTOWRITE Reports the current status and (if
enabled) the threshold of the autowriter.

Handling very long lines. ⊗XBREAK ⊗XJOIN

Modes Command Meaning
N,A,S BREAK Break line(s) at given column position
N,A,S JOIN Join two or more lines by deleting CRLFs

The commands ⊗XBREAK and ⊗XJOIN can be used to manipulate, and to allow
editing of, very long lines because these commands do not change any text
in affected lines except for the deletion or insertion of CRLFs. ⊗XBREAK
breaks long lines by inserting CRLFs where necessary, and ⊗XJOIN joins two
or more more lines together by removing CRLFs. Each of these commands
take a numeric repeat argument which specifies how many lines are to be
affected. If the repeat argument is negative, then the command affects
the given number of lines preceding the current line and the arrow is left
pointing to the first line affected. Repeat arguments are limited to the
number of lines on the current page in the given direction from the arrow.
If there are any lines attached when ⊗XBREAK or ⊗XJOIN is given, then
lines from the attach buffer are broken or joined instead of lines from
the page. A repeat argument of zero will affect no lines, but in the case
of ⊗0⊗XBREAK, the break column will be reported, and it can be set in the
same command, e.g., ⊗0⊗XBREAK 72.

⊗XJOIN joins the given number of lines (without introducing spaces for
the deleted CRLFs). If no repeat argument is given, two lines are joined.

⊗XBREAK will break lines at any specified column position by inserting
CRLFs. The column position may be specified by a numeric argument
following BREAK; the default BREAK column is originally 80 but any
typed-in column argument overrides this and is sticky. Breaks occuring
within a TAB are assumed to precede the TAB, that is, the TAB goes at the
start of the text on the next line. There is an exception to this if the
break is set at 8 or less and if a TAB occurs at the start of a line, when
the TAB will be placed on the first line.

If ⊗XBREAK is given WITH a preceding numeric argument, then that many
lines are broken (not, however, extending beyond the end of the current
page or the attach buffer) and each line is broken as many times as
necessary to prevent any resulting line from being longer than the
specified column argument.

If ⊗XBREAK is given WITHOUT a preceding numeric argument, then the
current line (or the first attached line) is broken AT MOST ONCE, at the
specified (or default) column position.
Search commands: ⊗F ⊗XFIND ⊗* ⊗XEXACT ⊗F<string>⊗P ⊗F<string>⊗: ⊗XSSLINE ⊗XSSPAGE

Modes Command Meaning
N α<cr> Position cursor at found string (after find)
<ESC>I Terminate multi-page FIND
N,A,E αF Find string (delimiters not required)
N,A,E αβF Find delimited string
N,A,E ⊗* Repeat last ⊗F or ⊗XFIND command
N,A,E EXACT Distinguish case of letters in searches
N,A,E F Do a multipage search for a given string
N,A,E FIND Do a multipage search for a given string
N,A,E SSLINE Set or report the search limiting line number
N,A,E SSPAGE Set or report the search limiting page number

SEARCHING -- SPECIFYING THE SEARCH STRING

The search can be for an alphameric string that is separated from
the rest of the text by non-alphameric characters or it may be for any
string regardless of its surroundings. Note that the FIND commands
normally make no distinction between upper and lower case, but the
⊗XEXACT command can be used to force such a distinction.

⊗XEXACT<cr> Distinguish between upper and lower case in subsequent
FIND commands of all kinds. FIND commands will only
find string occurrences whose cases exactly match
those given in the search string.
⊗-⊗XEXACT<cr> Do not distinguish between upper and lower case in
subsequent FIND commands. This is the default.
⊗0⊗XEXACT<cr> Report the current condition of case-checking.

For incore text searches the commands are:

αβFSmith<cr> Find just plain Smith or smith but not this string in
in $smith, in blacksmith or in Smithsonian. Note that
% and _ and $ are accepted as alphamerics.
αFSmith<cr> Find smith as an isolated word or as part of a longer
string (in blacksmith for example). The string will
be found even where not delimited by non-alphamerics.
⊗0⊗F Type out the search string used in the last incore
text search command (⊗F). No search is done.

Note that no space is used between the ⊗F and the start of the string.

The repeat arg (default 1) in a search command specifies which occurrence
to find. A negative repeat arg specifies a reverse search, but reverse
searches are not implemented.

⊗3⊗Fsmith<cr> Find the 3rd occurrence of "smith".

The following extended search commands first search the incore text and
then (if necessary) continue the search through the rest of the file.

αβXFIND Smith<cr> Find a delimited string ("Smith" here).
αXFIND Smith<cr> Find the string ("Smith") regardless of surroundings.
⊗0⊗XFIND<cr> Type out the search string used in the last extended
search (⊗XFIND). No search is done.

Note that exactly one space is required between the command "FIND"
and the search string. Commands starting with the letter ⊗X are EXTEND
commands which permit more than a single character to be used for the
command name, hence the need for the space to mark its end. In this
case the complete command name is FIND, but an identical command with
name F exists, allowing FIND to be abbreviated to one letter (despite
there being another extended command starting with F). Thus, only the F
needs to be typed, as αXF Smith<cr>.

Extended searches made in unformatted files are carried only as far
as the core directory has been extended. To search the entire file, one
should first complete the directory by switching to the last page and
then switch back to the desired starting page for the search. The fact
that the directory is incomplete is evidenced by the use of the "?" in
the trailer line, in lieu of the usual number, to show the total page
count (thus, "Page 13 of ?").

The delimited find command (αβF or αβXF) will not find an occurrence
of the search string that starts in column 1 of the current line, but
the non-delimited command (αF or αXF) will find such an occurrence.

A string, once specified, is sticky; that is, one need not retype the
search string for a repeat of the command. The search string for an
incore text search (⊗F command) is remembered independently from that
for an extended search (⊗XFIND). For a repeat one repeats the command
up to the string itself and then types the desired termination (a <CR>
as shown above, or any termination listed below).

Special repeat commands exist which simplify the repeated search.
These are easier to use than the regular repeat command, described
above, but only the last executed type of FIND can be repeated. Two of
the more commonly used terminations are simulated by using different
control keys with the ⊗* command.

αβ* Find the next occurrence of the string specified by the last
FIND command (whether an incore text search (⊗F) or an extended
search (⊗XFIND)). Move the line cursor to the found line but
do not enter the LINE EDITOR, that is, duplicate a normal
FIND command that is terminated by a <CR> only. An argument
may be used (such as αβ1αβ3αβ*) to find the Nth occurrence.

α* Find the next occurrence of the string specified by the last
FIND command (whether an incore text search (⊗F) or an
extended search (⊗XFIND)). Leave the line in the LINE EDITOR
as it would be for a normal FIND command terminated by a
α<CR>. If there is something in the ATTACH buffer, this is
interpreted as an αβ* command. See below for method of using
an argument.

⊗4α* Find the fourth occurrence of the string specified by the
last FIND command (whether an incore text search (⊗F) or an
extended search (⊗XFIND)) and position the cursor under the
first character of the found string (as it would be for a
normal FIND command that is terminated by a α<CR>). If this
command is given from the line editor, the argument must be
typed with both control keys (αβ) to force activation of the
line editor.

⊗0⊗* Type out the search string used in the last FIND command
executed, and indicate whether it was an incore text search
(⊗F) or an extended search (⊗XFIND). No search is done.

⊗∞⊗* Report the number of occurrences of the search string that
can be found. Actually, this is a request to find a very
large number of occurrences, but a failure to find enough
will cause the number actually found to be typed out. Thus
the ⊗∞ repeat argument can be used to make the search
commands count the number of string occurrences.

SPECIAL CHARACTERS IN THE SEARCH STRING

The following special symbols may be used in the search string with
the meanings noted. If these characters are desired as ordinary
characters in the searched-for string they must be preceded by the
identity symbol ≡.

Symbol Meaning

¬ The character that follows must not be in the string at
this point but any other character will be accepted.
| Any delimiter (not one of $_% nor a letter nor a digit).
∀ Any character.
≡ The character that follows immediately after this symbol
is not to be treated as a special symbol but it is to be
included as a character in the searched-for string. Use
this to quote any of these special characters.
∞ Not at present implemented, but still must be quoted.
⊂ Not at present implemented, but still must be quoted.

SEARCHING FOR STRINGS THAT INCLUDE <cr>

To search for a string that contains one or more <cr>s, you must
surround the entire string with <lf>s and quote each <cr> with an
equivalence sign (≡). Each <crlf> (carriage-return & linefeed) in the
text is considered during searches to be one character, namely a <cr> --
the <lf> is ignored. E.g., to search for X<crlf>Y type:

⊗F<lf>X≡<cr>Y<lf><cr>

SEARCH-STRING ENDING COMMANDS -- Normal, Search-distance, Directory, Reverse

The action to be taken for a search is specified by the command used
to activate the search string, and there are four general possibilities,
depending on what the string-ending command is.

(A) Most commands first allow the search to move to the line where
the string is found, and then the string-ending command is
executed normally.

(B) Certain commands use as their repeat arg the search distance
(in lines) between the original line and the line where the
string is found (inclusive), and this type of command is
executed with that arg FROM THE LINE WHERE THE SEARCH STARTED.
Thus commands in this class are able to utilize the search as a
means of specifying the number of lines to operate on. The
commands in this class are indicated in the index on p. 3 by an
"S" in the modes field. Included among these commands are: ⊗A,
⊗C, αβD, ⊗XJUST (and the other justify commands), and many
others that take a number of lines as a repeat argument.
Certain of these commands actually subtract one from the
resultant search distance, in order not to affect the line
where the string is found; this is done in order to make the
command do the "right" thing. The user can experiment to find
out which commands these are.

(C) Some commands used to end a search-string cause the directory
to be searched instead of the normal text. If the string is
found in the directory, then E moves to the page on whose
directory line the string is found and then does some
command-specific action. (See individual commands below.)

(D) Ending a search string with ⊗U indicates that you want to do a
reverse search; that is, you want to search the text backwards
from the current line. Unfortunately, reverse searches are not
implemented.

The command most commonly used to activate the search string is <cr>, which
simply causes the arrow to be moved to line where the string is found.

If the command ending the search string is another search commmand, then
the arrow will be moved to the line where the string is found and then E
will wait for you to complete the second search command.

Whenever a search is initiated from the line where the previous search
found its string, the new search will start from the position in the line
just beyond the beginning of the previously found string, so that
successive searches for the same string will find different instances of
that string.

The only line editor commands that can end a search string are αD and αI,
both of which are in class (A) above. These line editor commands are
executed after moving into the line at the position where the string is
found.

Here are the most important search-string-ending commands and their effects:

<cr> Move CURRENT to the found line or report failure.

α<cr> Terminate, as with <cr>, but move the cursor until it is
under the first character of the string. Note that this
leaves E in the LINE-EDIT mode. A second FIND command can
however be given and the next occurrence will be found. If
a FIND command is terminated with <cr>, a α<cr> will still
move the cursor to the string.

⊗J JUMP the line with the found string to the top of the
window.

αβ<cr> Enter the LINE INSERT mode with the ↔ at a newly inserted
blank line ahead of the found line.

αP Make the search over the directory page and then display
the referenced page with the line pointer at the top line.
Note that one can give this command without having to
give an explicit command to go to the directory page.
If the search fails, the arrow is not moved.
If the search command is preceded with a repeat argument, as
in α#αF...αP, then the command will search the directory
for the #th occurrence of the string and go to the page on
whose directory entry the #th occurrence is found. If not
enough occurrences are found, then the number found will be
reported.

αβP Make the search over the directory page and then display the
referenced page with the line pointer at the second
occurrence of the referenced string on that page (the first
will be in the first line of the page).

α: Find the given string used as a label somewhere in the file,
and position the line containing the label in the MIDDLE of
the screen (if possible and if that line was not already on
the screen). This is done by first searching the directory
page for the string and then searching the page on whose
directory entry the string occurs. That page is searched for
the first occurrence of the the string that is followed by
":", "=" or "←".

αβ: Just as with α:, do a directory search to find the given
string used as a label, but POSITION THE RESULTING LINE NEAR
THE TOP OF THE SCREEN, unless it was already on the screen.

⊗+αP Just like the command without the ⊗+, except that only
⊗+αβP pages after the current one are searched in the directory.
⊗+α: This is a very useful command when a string occurs on
⊗+αβ: several directory lines (i.e., on the first line of
several pages).

All of the above directory searching commands point
out when the resultant page turns out already to have
been in core by saying "(incore page)". This lets
you know whether to use αN or αO to get back where
you came from.

⊗A ATTACH all lines starting with CURRENT up to and including
the line with the specified string. If used with the
extended search command (⊗XFIND) and if the string is not
amoung the incore text, this command will attach text
starting at the top of the page on which the string is
found. Attachments do not cross page boundries.

⊗C COPY all lines starting with CURRENT up to and including the
line with the specified string. See ⊗A above for
restriction with extended search command.

αβD DELETE all lines beginning with CURRENT up to but NOT INCLUDING
the line with the specified string. See ⊗A above for
restriction with extended search command. This is a very
dangerous command so use it with caution. A safer command
sequence to use when you are unsure where the search string will
be found involves using the ⊗A search string terminator to
attach the text first (to make sure it is the right text), then
if necessary to attach a few more lines or unattach a few lines,
and finally to delete the attached text with αβK.

⊗\ Terminate the searched-for string and prepare to accept a
substitution string. The substitution string is then typed
in and may be terminated in any one of several ways. For
details see String Substitution Commands on the next page.
Note that there is a special repeat command for this case so
do not try to use the repeat conventions that are used for
simple searches.

<alt> Abort the present command. When <alt> ends an incore text
search string (⊗F), the string ahead of the <alt> is retained as
the new default incore text search string (unless that string is
empty) although no search is done. When the <alt> ends an
extended command search string (⊗XFIND), the previous default
extended search string is retained.

ESC I TO ABORT AN EXTENDED SEARCH COMMAND OR A MULTIPLE SUBSTITUTION

The <ESC>I command will terminate any extended search command in
progress at the end of the page currently being searched (unless the
string is found before the end of that page); <ESC>I will report the page
number where searching was interrupted.

The <ESC>I command will also terminate any multiple substitution
(even the one-page type) after the next substitution is done; see p. 14.

SEARCH LIMITING: ⊗XSSLINE ⊗XSSPAGE

The commands ⊗XSSLINE and ⊗XSSPAGE set or report the limit line number and
limit page number for searches and substitutions. These commands can be
used to keep searches and substitutions from going beyond a given incore
line or a given page; search limiting affects these commands:

⊗F ⊗XFIND ⊗* ⊗\ ⊗( ⊗) ⊗XLPAREN ⊗XRPAREN

The ⊗#⊗XSSLINE command sets the search-limiting incore LINE number to the
given argument (#), and similarly ⊗#⊗XSSPAGE sets the search-limiting PAGE
number to the argument (#). In both cases, if the argument is relative
(⊗+ or ⊗- used), then the limit is set by the command at the given
distance (lines or pages) from the current place (line or page) (but is
fixed once set by the command; that is, it is not permanently relative to
the arrow's position). If the argument is omitted entirely, then the
corresponding type of search limiting is disabled. A zero argument will
cause E simply to report the given search-limit.

Search-limiting stops any search (except a directory search, see below)
that encounters the given limit line or the beginning of the given limit
page; for instance, ⊗5⊗XSSPAGE will stop any search that encounters the
beginning of page 5, so page 5 will NOT be searched (but a search started
already on page 5 won't be limited). As another example, ⊗+⊗XSSLINE will
limit any search to the current line, since it will stop any search upon
reaching the following line. The search-limiting LINE number applies only
to incore text and is cleared when you flush all incore text (e.g., by
going to another page or by doing an ⊗XCANCEL command). The
search-limiting PAGE number applies both to incore pagemarks and to
not-in-core pages (the latter reached only by the ⊗XFIND, ⊗XLPAREN, and
⊗XRPAREN commands); the limiting page number is cleared when you change
files. Search limiting is always completely disabled during directory
searches (e.g., ⊗F...⊗P and ⊗F...⊗:).

Any incore limit line number set up is adjusted for text insertion and
deletion, to preserve the point in the text at which searches will stop.
Currently, however, any limit page number is NOT adjusted for page
insertion/deletion. The two readonly variables SSLINE. and SSPAGE. are
available for macros to find out the current search limits; a negative or
zero value means the corresponding type of search limiting is disabled.
Note that the limit LINE number is counted from the beginning of ALL
incore lines, not just relative to the current page if you have more than
one page in core.

SUBSTITUTION commands: ⊗\

Modes Command Meaning
N,E ⊗\ Repeat last substitution command
<ESC>I Terminate multiple substitution

String substitution commands are initiated by first giving a normal FIND
command but using one of the two special string terminating characters,
⊗\ (back-slash) or <lf> (linefeed). This is then followed by the
substitution string which, in turn, is terminated by either a simple
carriage return (which may be preceeded by an argument, typed with
control keys) or by α<CR>. Note, many of the otherwise acceptable Find
command terminations are not meaningful with the substitution commands
and are not allowed.

Please observe that an argument before the initial FIND command means
find the specified occurrence before making the substitution while an
argument before the final termination means make the substitution the
specified number of times starting with the initial arrow position (or
with the initially specified occurrence, if there is an initial
argument).

The prefered method for making repeated substitutions is to request an
initial single substitution and then to ask for the desired remaining
substitutions by the αβ\ command prefaced by an argument specifying the
remaining number of times the substitution is to be made.

Characters in the searched-for string that are preceeded by the special
control symbols ¬ and ≡ and all characters that are represented by the
special symbol ∀ or by the symbol | (see p. 13 for the explanation of
these symbols) are treated as any other character and are deleted and
replaced by the substitution string. The "partial definition feature"
as implemented in SOS is not at present available. The | symbol in the
searched-for string can not be used to replace a carriage return.

Note: The FIND command does not find the very first delimited
string on the line to which the cursor is pointing (unless it is
in fact preceeded by delimiter). This limitation is of little
consequence for the simple FIND but it is an annoyance if one
wants to replace all occurrences of a symbol (or string) which
happens to be the very first symbol (or string) on a page. One
can introduce an initial space into the first line or one can
introduce an initial blank line temporarily and have the cursor
at this line. The space or line can then be removed after the
substitution.

In the rest of this write-up "all occurrences" means "all except the
very first character or string on the line to which the cursor is
pointing at the time that the command is given when the search request
is for a delimited string".

Also, the remaining descriptions assume that the ⊗XEXACT command has NOT
been given. If ⊗XEXACT has been given, then substitutions will be made
only for occurrences with the Exact case of letters given in the search
string.

Sample commands.

αβFSTRINGαβ\"String"<CR> Find the first occurrence of the
string STRING, whether typed in lower or upper
case letters and replace it by the substitution
string as typed, that is, enclosed in quotes and
with the initial letter only in CAPS. Limit the
search to the incore text starting at the cursor
location.

αβFSTRING<LF>"String"<CR> Same as the above example, but
typeable on a non-display because of the linefeed
that is used instead of αβ\ to end the search
string.

αβFSTRINGαβ\"String"αβ∞<CR> Find all occurrences of the
string STRING, whether typed in lower or upper
case letters and replace them by the substitution
string as typed, that is, enclosed in quotes and
with the initial letter only in CAPS. Limit the
search to the incore text starting at the cursor
location.

⊗9αβFSTRINGαβ\"String"αβ∞<CR> Find all occurrences of the string
STRING, as above, but start the substitution with
the 9th occurrence.

αXFIND ←αβ\ <BACK ARROW> α<CR> Find the first occurrence
of the character ← whether among incore text or
on a subsquent page and replace it by the string
<BACK ARROW> (including the < and >) and with
spaces introduced before and after these
characters. Leave the resulting line in the line
editor.

The <CR> termination is the faster mode of operation in that it does not
use the the line editor and it is not subject to any effective
limitation as to the length of lines that may be handled. This mode
does have one defect in that the substitution is completed and is not
subject to the simple <ALT> method of aborting a single line correction.
When the α<CR> termination is used the substitution is made via the line
editor and the results are left in the line editor's buffer so that the
substitution may still be aborted by the usual <ALT> command.

The usual rules apply to the specification of the searched-for string.
The substitution string may, however, contain certain delimiters (spaces
in particular) whether or not the search is for a delimited string and a
distinction is made between upper and lower case letters. Only the
searched-for characters without delimiters are replaced. To be
specific, if one were to replace a delimited string by a null
substitution string, the two delimiters would remain in the corrected
text.

Currently, substitution cannot be done for the CR (or LF) at the end of
any line of text. A warning message will be issued when you try to
make such a substitution. Also, no substitution can be done for
pagemarks (formfeeds).

The substitution string is sticky, so that a substitution command, when
successfully executed for a single occurrence, may be repeated for the
next occurence by typing αβ\ only. The typing of a new string for the
searched-for string destroys the record of the previously saved
substitution string and the entire request must be retyped before this
command will be honored.

A null substitution string may be used and no longer reguires
confirmation.

Extended substitutions are useful but potentially dangerous as the
substitutions made on any one page are, of course, written out onto the
disk file when ever a new page is entered.

As noted earlier, typing αβ\ after a legal substitution command will repeat
the substitution. This command may be preceeded by an argument (with
control bits) and the substitution will be repeated the specified number of
times. Should substitutions occur on more than one page, all substitutions
on pages earlier than the last page will have been written out (except when
all occur on the incore text, which might be several pages).

The use of the command α\ rather than αβ\ causes the altered line to be
left in the line editor with the possibility of an <ALT> abort.

Sample repeat commands.

αβ\ Repeat the previously made substitution at the next
occurrence of the searched-for string.

αβ6αβ\ Repeat the substitution for the next 6 occurrences.

α\ Repeat the substitution once but leave the results in
the line editor buffer.

⊗0⊗\ Type out the search and substitute strings last used in a
substitute command, and indicate whether it was an incore
text substitution or an extended substitution.

The <ESC>I command will terminate any multiple substitution (even the
incore type) after the next substitution is done.
FILE-SWITCHING and text transfering commands: ⊗ε ⊗λ ⊗∃ ⊗? ⊗XPOINTER

Modes Command Meaning
N,A ⊗ε Switch to given file in READWRITE mode
N,A ⊗#⊗ε Switch in READWRITE mode to file number # in "∃" filelist
N,A ⊗0⊗ε Show names and numbers of files in fileswitch list
N,A ⊗λ Switch to given file in READONLY mode
N,A ⊗#⊗λ Switch in READONLY mode to file number # in "∃" filelist
N,A ⊗0⊗λ Show names and numbers of files in fileswitch list
N,A,E ⊗∃ Show names of files in fileswitch list
N,A,E ⊗0⊗∃ Show names and numbers of files in fileswitch list
N,A ⊗#⊗∃ Switch to file number # in "∃" filelist
N,A ⊗? Switch to the file E.ALS[UP,DOC]/R
N,A ⊗#⊗? Go to page # in E.ALS
N,A ⊗+⊗#⊗? Go to E.ALS, # pages beyond where last left it
N,A ⊗-⊗#⊗? Go to E.ALS, # pages before where last left it
N,A POINTER Switch to a file named in the incore text

The file switching commands ⊗ε and ⊗λ cause E to close the current
file being edited (writing out the current page if necessary) and then
to ask for the name of another file to be edited. That file is opened
for editing, with any ATTACH buffer maintained while switching files.
Thus you can switch back and forth, editing different files, and easily
moving or copying text from one file to another simply by attaching the
lines desired. The ε command (ENTER) opens the new file in read-write
mode while the λ command (LOOK) opens the file in read-only mode.

All of the usual switches may follow the filename typed with these
commands; for example, you can use /8P to go to page 8 in the new file,
/E to go to the end of the file, /N to open the new file in no-directory
mode, /C to create the file you want to switch to, etc. See p. 20 for
more details.

If the filename requested by ⊗ε or ⊗λ is omitted, and if one or more
switches are included, then the file assumed by the command will be the
one you were editing just prior to giving the command. Only the same
filename is implied by this mechanism; no modes are assumed for the new
edit. This makes switching major modes (like /N) easier; the filename
doesn't have to be retyped. Also, this makes it easier to burp a whole
file; ⊗ε/∞F<cr> will burp the current file.

As different files are referenced, each file is assigned a number
which can be used thereafter as an argument to the ε or λ command to
call the desired file without retyping its name. Also, a stack is kept
of the files you have been in recently and you can return to a file that
is a particular distance down in the stack. See p. 34 for the file
stack manipulation command ⊗H. Whenever you return to a file, any
previously existing line marks and the top part of that file's page
stack are restored.

The names of up to eight different files edited are remembered by E.
When you try to edit a 9th file, the file at the bottom of the file
stack is forgotten to make room for the new file's name. The user is
warned of this replacement.

The list of files with their referencing numbers is typed out by the
command ⊗∃. The command ⊗0αH types out the file stack.

The command ⊗#⊗∃ switches to the given numbered file, restoring
the value of the readonly/readwrite state for the given file.

Finally it is possible to reference the E-manual file, E.ALS[UP,DOC],
by typing the ⊗? command. The first reference to this manual will be to
page 2 which contains information on recently made changes to E.
Thereafter the manual file is opened at the last referenced page and
line. One may, however, override these default values by typing an
absolute or relative argument to specify the absolute or relative number
of the page to go to.

E is smart enough to detect most cases when one tries to format a
binary file or an XGP file and it will tell you this and give you
another chance to say No.

⊗ε<file name><cr> Close the current file and open the specified
file in read-write mode. The usual switches /#P, /#L and
/C may be used.The new file is assigned a serial number by
which it may be called later. (The initial file is
numbered 0). When called by number the display is
returned to the last referenced page and with the arrow on
the last referenced line and all previously set line marks
restored.

⊗3⊗ε Reopen the file assigned the serial mumber 3 in read-write
mode. Note that no carriage return is used in this case.
Return the display to the last referenced page. Return the
arrow to the last referenced line and restore all previous
line marks. (Use the ⊗∃ command, below, to find numbers).

⊗λ<file name><cr> Close the current file and open the specified
file in read-only mode. The usual switches /#P and /#L
may be used. The new file is assigned a serial number by
which it may be called later. (The initial file is
numbered 0).

αβ3⊗λ Reopen the file assigned the serial mumber 3 in read-only
mode.

⊗∃ List the previously referenced files with their serial
numbers. For convenience the letter H accompanies the number
in the listing of the "HOME" file and a "]" is used rather
than a ")" for the file currently being edited.

⊗XZFILES<cr> Move the current-file listing to location zero and clear
the remainder of the filelist. Clear the file stack.

αH Return (Home) to the last referenced file. The E-manual
file is never considered a home file. See p. 34 for more
details on the various forms of the very useful ⊗H command.

⊗? Close the current file and open the E manual file
E.ALS[UP,DOC] on page 2, (for changes) or, if it has been
referenced earlier, to the last referenced page and line.
page and line.

⊗1⊗? Close the current file and open the E manual file
E.ALS[UP,DOC] on page 1, the directory page.

⊗8⊗? Close the current file and open the E manual file
E.ALS[UP,DOC] on page 8.

⊗-⊗2⊗? Close the current file and open the E manual file
E.ALS[UP,DOC] at 2 pages before the previously referenced
page.

SWITCHING TO A FILE NAMED IN THE TEXT:

The ⊗XPOINTER command is used to switch to a file whose name is found in
the text of the page you are editing, at or below the current line.
With an argument of zero, the command ⊗0⊗XPOINTER will merely move to
the line containing the filename found (if any) and type out the
filename, but will not switch files. The command with no argument moves
the arrow to the line containing the filename found (if any) before
attempting to switch files.

Furthermore, a numeric argument can be given to the ⊗XPOINTER command to
have it find the nth filename in the text; thus it is possible to switch
to any of several files all named on a given line. An arg of the form ⊗#
will make E merely type out the #th filename, without moving the arrow and
without switching files. An arg of the form ⊗+⊗# means switch to the #th
file named in the text; this is conveniently done right after the ⊗# form
has verified that the filename found was the one you wanted to switch to.
Since ⊗# doesn't normally move the arrow (so that you can then say ⊗+⊗#
without having changed the significance of the number), an arg of the form
⊗-⊗# finds the #th filename and moves the arrow to that line but doesn't
switch files.

Summary of meanings of ⊗XPOINTER args:

Arg Meaning

(none) Switch to first file named in the text at or below current line.
⊗0 Type out the first filename in the text, and move to its line.
⊗-⊗# Type out the #th filename in the text, and move to its line.
⊗# Type out the #th filename in the text (without moving).
⊗+⊗# Switch to the #th file named in the text.

A filename in the text will not be recognized unless it is preceded by a
space, a tab, a double quote ("), a number-sign (#), or an at-sign (@) or
occurs at the beginning of a line. Furthermore, to be accepted by this
command, a filename must have at least one of these: (1) an explicit
(non-null) extension, (2) an explicit (complete) PPN, or (3) a valid
filehack. Spaces are permitted only as leading spaces in PPNs for blank
characters in the project or programmer name, and a filename with its
switches must occur all on one line. The extension ".>" is allowed, but
it must not immediately be followed by another ">". Finally, a filename
of less than four characters (like "A.I" or "F/X") will not be recognized
by E unless it contains a filehack (which can be any length). Thus the
following filenames will be recognized:

FILE/-R, FILE.>, FILE[J,G], FILE.EXT[J,G](R9P7L), FILE.[ J, G], \GRIPES.

The following will NOT be accepted: FILE., FILE[X], FILE/6PR, F[ ABC,D].
The only characters permitted in names within the filename are letters
(case of letters is ignored), digits, the ">" character (only as the
entire extension), and the underbar character (which represents a quoted
space). In particular, the down-arrow construction, the partial-sign
name, and the question-mark name are not permitted in filenames.

Any switches following a filename in the text will be observed in
switching to that file. In addition, any text following the extended
command name will be appended to the filename after any switches found in
the text. Thus additional (or overriding) switches can be specified, or
if no PPN or switches appear in the text, an explicit PPN can be added.
(If the text says READ NOTICE/231P, you can use ⊗XPOINTER/D to get the
READ facility into a switch.) Switches in the text must be perfectly
well-formed or the filename they are applied to will not be recognized;
also, the parenthesis form of switches cannot be used. No letter or digit
can immediately follow the letter of a slash-type switch. However, the
actual letters of switches are not checked for validity (as indeed they
never are by E -- undefined switches are completely ignored).

This command's default mode for switching to a file is readonly (/R).
However, this can be overriden with an explicit /-R occurring among the
switches in the text or typed in the command line after the extended
command name (e.g., ⊗XPOINTER /-R<cr>).

When you attempt to switch files with this command, if the file named in
the text cannot be edited because it does not exist, is busy, etc., E will
abort the fileswitching operation automatically (nevertheless having
written out the current page before attempting to switch files). If,
however, the combined (text and command line) filename with switches has
an illegal syntax, E will say so and then load your line editor (on
displays) with the combined text so that you can correct it and try again.

Justification: ⊗XJFILL ⊗XJUST ⊗XJGET ⊗XSJFILL ⊗XSJUST
(See p. 17 for ⊗XTJUST ⊗XTJFILL ⊗XTABLE and ⊗XTJGET)
(See p. 18 for ⊗XALIGN, ⊗XINDENT, ⊗XJCENTER)

Modes Command Meaning
N,A,S JFILL Justify paragraphs w/out aligning right margin
N,A,S JGET Get justification margins from text
N,A,S JUST Justify paragraphs and align at right margin
N,A,S SJFILL Separate text into justified sentences
N,A,S SJUST Separate into justified right-aligned sentences

TEXT JUSTIFICATION

E has several justification commands. The basic commands are ⊗XJFILL
and ⊗XJUST -- the former fills lines as much as possible without
inserting extra spaces, and the latter justifies the right margin by
inserting extra spaces where needed. The commands ⊗XSJFILL and ⊗XSJUST
are similar but make each Sentence start on a new line. The command
⊗XJGET is useful for setting up the margins from already-justified text
on the page. These commands (JFILL, JUST, SJFILL, SJUST, JGET) all use
the same set of margins. The commands ⊗XTJFILL, ⊗XTJUST and ⊗XTJGET can
do the same things as the same commands without the leading "T" in the
name, but the "T" commands use a different set of margins (so you can
have two sets of margins in effect at a given time) and they are
designed to handle a special form of paragraph -- one that has zero or
more "Tab fields" preceding the text in the first line of each
paragraph. The "T" commands can align these tab fields and
simultaneously justify the remaining text of each paragraph. The "T"
commands are described on p. 17.

The range of application of any justification command may be limited by
a prefixed decimal argument. If no argument is specified, the command
affects the entire page. If there is an attachment, the command works
on the ATTACH buffer instead of the page. When the range is limited by
a positive argument, the command starts with the arrow line and goes
forward whereas for a negative argument the command works on the
specified number of lines before (but not including) the arrow line.

There is no effective limit to the length of lines or the margins that
can be handled by the justication commands.

If you're not sure what a justification command will do, you should
execute the ⊗. command to write out the page before the justification so
that you can undo any undesired effect with the ⊗XCANCEL command.

BASIC JUSTIFYING COMMANDS: ⊗XJFILL and ⊗XJUST

The line filling command ⊗XJFILL adjusts the lengths of lines by moving
words from line to line as required to achieve the specified maximum line
length (right margin). At the same time this command permits the left
margin to be fixed at any desired position with a separate settable
indentation for the first line of each paragraph (crown margin), and it
allows one either to preserve blank lines or to specify the desired number
of blank lines preceding each paragraph (blanklines margin). The ⊗XJUST
command does the same things as the ⊗XJFILL command but also justifies the
right margin by distributing additional spaces between words. Both of
these commands put two spaces after each sentence, where the end of a
sentence is indicated by one of the characters .?!: followed by either two
spaces or the end of the line, optionally with any of the characters >]}")'
occurring between the .?!: and the spaces or end of line.

SETTING THE MARGINS

The margins can be changed by giving a justification command and
following the command name with a space and then the desired new margins,
separated by commas. The margins are always given in the same order,
namely, Crown, Left, Right, Blanklines. Any margin that is not being
changed can be omitted but its comma must appear if any subsequent
margins are being specified. For instance, ⊗XJFILL ,,70,2<cr> will set
the Right margin to 70 and the Blanklines margin to 2, leaving the other
margins unchanged. The margins are normally specified as decimal numbers,
but octal numbers, numeric macros, and readonly variables can also be used
to specify margins; for example, you can say
⊗XJFILL AA, LINE., 88, '10
which will set the Crown margin to the current value of the numeric macro
AA, the Left margin to the current value of the readonly variable LINE.,
the Right margin to 88 (decimal), and the Blanklines margin to '10 octal.
(The space after the command name is required, but the ones adjacent to
commas are optional and ignored.) Any margins set remain in force until
explicitly changed. The meanings of the various margins are explained
below.

The Crown margin is the indentation used for the first line (crown
line) of each paragraph.

The Left margin is the indentation used for all non-crown lines.

The Right margin is the maximum length of a line, including any
indentation.

The Blanklines margin is the number of blank lines desired ahead of
each paragraph -- setting this margin to -1 will cause E to
preserve exactly the number of blank lines found in the text.

The margins are initially set to 0,0,74,-1 (C,L,R,B). This means that
the crown margin (paragraph indent) is 0, the left margin (non-crown
indent) is 0, the rightmost character is not to go beyond column 74, and
the distribution of blank lines is to be the same in the resulting text
as found in the original text.

To find out the current margins, use a repeat argument of zero with any
justification command, for example ⊗0⊗XJFILL<cr>. A zero argument is
also useful for setting the margins without doing any justification.

DETECTING PARAGRAPHS IN INPUT TEXT

A simple procedure is used to determine where paragraph breaks occur in
the input text being justified. For justification purposes, a new
paragraph is indicated by (1) an empty line or (2) a line indented
exactly the right amount (that is, a line having the right number of
leading blank columns, whether tabs or spaces or both are used to make
the indentation).

The amount of indentation that indicates a paragraph in the input text
will be called the DETECT-PARAGRAPH margin, or simply the DETECT margin.
Note: If you haven't set the detect margin explicitly (see below), and
if the crown margin and the left margin are the same, then only blank
lines will indicate new paragraphs in the input text (otherwise every
line would become a separate paragraph).

The detect margin is normally the same as the crown margin. However,
for changing the crown margin of justified text that has no blank lines
between paragraphs, the detect margin can be set explicitly to any
value. Furthermore, it may be necessary to set the detect margin to
some non-occurring value (e.g., 99) to prevent paragraph detection from
occurring on lines that are already indented by the amount that you want
paragraphs to be indented (that is, the (new) crown margin). For
instance, when changing from 0,0,74 to 0,8,74 you'll need to set the
detect margin to a non-zero value (e.g, use 99/0,8,74).

The detect margin can be set in any justification command by
typing its value immediately after the extended command name and
following it with a slash ("/"). After the slash, the normal margins
(crown, left, right, blanklines) can be specified, separated by commas.
For instance, the command ⊗XJUST 8/7<cr> would set the detect margin to
8 (for paragraphs indented with one tab or eight spaces) and then would
rejustify the text so that each paragraph was indented only 7 spaces.
Note that the detect margin remains in effect until you change either
the crown margin, the left margin, or the detect margin itself. Thus
after the above command, E would no longer recognize the new crown lines
(now indented 7 spaces) as such since the detect margin would still be
8. The detect margin can be set without changing any of the other
margins, as in ⊗XJUST 7/<cr>. The command ⊗XJUST 8<cr> explicitly sets
the crown margin to 8 and implicitly also sets the detect margin to the
same value (8).

SEPARATING SENTENCES WITHIN PARAGRAPHS: ⊗XSJFILL and ⊗XSJUST

The task of rearranging sentences within a paragraph or of moving
sentences from one paragraph to another is simplified by the use of the
⊗XSJFILL and ⊗XSJUST commands. These commands separate all sentences in
the specified text so that each sentence starts on a different line. The
first sentence in each paragraph will be indented by the crown margin and
all other sentences will be indented by the left margin. Within each
sentence, the text is justified exactly as it would be by the ⊗XJFILL and
⊗XJUST commands. These commands accept new margins following the command
name just like the other justification commands.

The end of a sentence is indicated by one of the characters .?!: followed
by either two spaces or the end of the line, optionally with any of the
characters >]}")' occurring between the .?!: and the spaces or end of line.

FIGURING OUT JUSTIFICATION MARGINS FROM TEXT ON THE PAGE: ⊗XJGET

The ⊗XJGET command causes E to scan a specified section of text and to
determine the indents of crown lines and non-crown lines and the column
position of the rightmost character. This command sets these values
into the crown margin, left margin and right margin for subsequent use
by the ⊗XJUST, ⊗XJFILL, ⊗XSJUST and ⊗XSJFILL commands. ⊗XJGET normally
sets the blank-line parameter to its initial default value of -1 (which
means that all blank lines encountered during justification will be
preserved and no new blank lines will be generated). However, any
margins given explicitly in the ⊗XJGET command will override the
corresponding margins determined from the text. This command types out
the resultant settings of the margins.

By using this command one can redetermine the parameters that were used
when the text was justified, presumably at some earlier editing session
or perhaps by someone else and one can do this without having to make
the determination by visual inspection.

Here is the algorithm used by E to determine the margins from the text.
First, the length (in columns, not characters) of the longest line in
the range becomes the right margin. Second, the text is scanned to find
the first blank line. If a blank line is found, then the next non-blank
line is assumed to be a crown line and its indent is stored as the crown
margin; the indent of the following line is stored as the left margin.
If no blank lines are found within the specified text, then the indents
of the first two lines are compared. If these two indents are not the
same, the first is taken as the crown margin and the second as the left
margin. If the first two line indents are the same, these lines are
taken to be non-crown lines and the rest of the text is scanned for the
first line with a different indent; if one is found its indent becomes
the crown margin and the next line's indent becomes the left margin. If
all lines in the range have the same indentation, then that indentation
becomes both the crown margin and the left margin. The practical effect
of all of this is that one should not execute a ⊗XJGET command starting
with a line that is the last line of a paragraph (but even that is ok if
a blank line follows).

SOME TYPICAL JUSTIFICATION COMMANDS:

⊗XJUST<cr> Justify the current page (or the ATTACH buffer if in
ATTACH mode) using the current margins. The right
margin will be justified.

⊗XJU 0,4,66,0<cr> Justify the current page or the ATTACH buffer using
the new margins given. The crown lines will all have a
0 indent, the left indent for the rest of the text will
be 4, the last occupied column will be 66, and there are
to be no blank lines between paragraphs.

⊗XJFILL 8/10,10,,1<cr> Justify (left margin only) the current page,
which has been previously edited so that each paragraph
starts with 8 spaces (or a tab). Note that this command
calls for the indents of all lines (crown and non-crown)
to become the same (10) and that paragraphs are now to
be separated by single blank lines. The right margin is
unchanged since no new value was given for it.

⊗0⊗XJF ,,72<cr> Change the right margin to 72 and then type out the
margins, including the detect margin if applicable.

⊗XJGET 4<cr> Set the margins to those found by examining the entire
incore text, then set the crown margin to 4, and finally
type out the new margins.

⊗!⊗XJG<cr> Set the margins to those found by examining the current
set of contiguous non-empty lines (⊗! command). This is
a very useful command to execute before rejustifying an
edited paragraph. However, the ⊗! command is only
useful for this if you have blank lines between
paragraphs. Also, the ⊗! command is not useful as an
argument to justify commands when you have text
attached, since the ⊗! command always counts lines on
the page itself, never in the attach buffer.

⊗6⊗XJG<cr> Set the margins to those found in the 6 lines starting
at the arrow (or at the beginning of the attach buffer,
if any).

⊗!⊗XSJFILL<cr> Separate the sentences in the current set of contiguous
non-empty lines (⊗! command).
Commands for tabular material: ⊗XTABLE ⊗XTJFILL ⊗XTJUST ⊗XTJGET ⊗XTGET
(See p. 16 for basic justification information and other commands.)

Modes Command Meaning
N,A,S TABLE Line up entries in a table
N,A,S TGET Same as TJGET command (see below)
N,A,S TJFILL Justify paragraphs that begin with a table
N,A,S TJGET Get margins for TJFILL/TJUST from text
N,A,S TJUST Justify & R-align paragraphs beginning w/table

There are five commands that permit one to handle tabular material in
a manner analogous to way in which normal text can be justified.

Two types of commands are provided to take care of the two classes of
input data that are most apt to be encountered, these being:

1) Tabular material that is in proper columnar alignment but that may have
missing entries.

The ⊗XTABLE command is intended for use with such material.

2) Tabular material that may not be in proper columnar alignment, but
where the entries are separated by at least 2 spaces or by TABs.
There may also be normal text associated with each tabular line which
is to be justified. Of course, in this case there can be no missing
entries.

The ⊗XTJFILL and ⊗XTJUST commands are designed for these conditions.

These Tabular commands require the specification of additional values
in addition to the C,L,R,B margins specified with the ⊗XJUST and ⊗XJFILL
commands. Of course, just as for these older commands, default values may
be used and only those values that are to be changed need to be specified.
The margins (C,L,R,B) are specified as usual.

When new tabular-field values are to be typed, these must start with a
semicolon ";" and they are to be separated by commas. Values not otherwise
marked are taken to be field lengths, that is the string ;5,8,9<CR> is
taken to mean that there are to be three columns, the first one starting
with an indent as specified by the C margin and with a field length of 5
character positions, this is to be followed by a second field of 8
character positions, then one with a field length of 9. These values
supersede the field lengths that had previously been specified for the
first three fields and if still additional fields had been specified, they
will be retained and shifted to the right or left as required by the
changes to the first three fields.

When specifying changes in fields, it is only necessary to type values
for those fields that are to be changed and to indicate preceding fields
by commas. Fields after those typed are retained unless a negative field
width (e.g, -1) is encountered, which means forget about all the remaining
old fields. Should there be more fields specified for output than are
specified for input, E warns the user at the time of execution of the
TABLE or TJ command and ignores the extra fields; should there be fewer
output fields than input fields, the command is aborted.

When several fields are to have the same length, these fields may be
specified by the use of an at-sign (@); thus 9@5,7 means that there are
to be 9 fields of length 5 followed by a field of length 7. Unchanged
fields may be indicated by commas without numbers, or with a length of
zero; thus ,,7 means leave the first two fields' lengths unchanged and
give the third field a length of 7. Similarly 4@0,3@5 means leave the
first 4 fields unchanged and make the next 3 fields with lengths of 5.

A field can be specified by giving its right-most column number
rather than its width. This is indicated by preceding the value by an
exclamation point (!). For instance, ⊗XTJF ;!10,4 means the first tab
field ends in column 10, and the second field is 4 characters wide.
Note that it is not possible to specify the starting column as this is
set by the cumulative lengths of the preceding fields.

Fields must have widths of 3 or more to permit a single character and
to allow for there to be two spaces between the characters in different
columns. Should any particular entry be too long for the width
specified, the next entry is preceded by two spaces and automatically
moved to the right. Such overflows may propagate.

As with the margins for both the JUST and TJUST series of commands,
tab field values can be specified with decimal numbers, octal numbers,
numeric macros, and/or readonly variables.

A fourth command ⊗XTJGET has been provided to perform the same
function for tabular material that is performed for ordinary text by the
⊗XJGET command. It should be noted that this command must determine the
positions of each column as well as the left margins and so it must be
given when the designated text is restricted to start with a tabular
line in which there are no missing entries.

The ⊗XTGET command does the same thing as ⊗XTJGET.

The specifications for these tabular commands will be listed below.

⊗XTABLE

This command must be given either 1) after a prior execution of the
⊗XTJGET command, 2) with the entire set of tab fields specified, or 3)
after some combination of commands satisfying 1 or 2. In effect, one
must provide E with information as to the existing state of the input
textual material since there does not exist any "Normal" set of
conditions that can be assumed. While, in principle, it is possible to
provide this information by typing it in, it is thought that this task
can best be handled by E with ⊗XTJGET.

Information regarding the desired new format must also be provided
and this will usually be done by typing the needed information as a
suffixed string as described below. This information is sticky and it
need not be retyped. If there exists a sample of tabular material that
is already in the desired format even this second task may be left to E
by again using the ⊗XTJGET command as explained below. Note that the
⊗XTJGET command changes the parameters as they relate to the conditions
to be established.

This command will accept a prefix argument defining the number of
lines to be processed and a series of suffixed arguments as explained
above. The general form is ⊗#⊗XTABLE C,L,R,B;T1,T2,...Tn where # is
the number of text lines to be affected, C,L,R,B are the usual margins,
and T1 through Tn specify the tab fields.

For example, the command αβ7αβXTABLE 4;10,6@5,!60<CR> would specify
that there be 8 fields: the first one occupying 10 columns starting at
an indent of 4, then 6 fields each occuping 5 columns, and a final field
ending at column 60. The starting indent for this last field is
obtainable by adding up the columns already accounted for (44) and so
the last field is to be 16 columns wide. Note that it is only necessary
to type a single number before the semicolon as the ⊗XTABLE commands
starts all lines with the crown or new paragraph indent. The normal
left and right margins are not used by this command.

⊗XTJFILL and ⊗XTJUST

As mentioned earlier these commands are for use with tabular data
that have no missing entries but do have with them some associated text
that one wants justified. The listings of commands with explanations,
as used in this manual is an example of such material. The original
material need not be aligned into columns.

The methods for specifying the various parameters is similar in all
respects to that described for the ⊗XTABLE command. Especial care must
be used in establishing these parameters particularly as regards the
number of fields. The signal for a new field is taken to be the
presence of 2 or more spaces between entries (3 spaces if the entry ends
with a sentence-terminating punctuation mark) and if the textual
material has already been justified and padded there may be cases where
these conditions are met in the associated textual material. The
program differentiates between these entirely on the basis of the number
of tabular entries that are expected and that have been found.

CAUTION: It is unwise to use ⊗XTJUST on text that one may want to
re-⊗XTJUST or ⊗XTJFILL later, since any additional spaces at word breaks
which the first ⊗XTJUST introduces will be taken as a tabular field
indicators during the execution of the subsequent commands.

⊗XTJGET

The command ⊗XTJGET determines the margin values of a designated portion
of text in a manner similar to that used by the ⊗XJGET command, except
that in addition to the crown, left, right and blanklines margins, the
positions and widths of tab fields are also set by ⊗XTJGET. The command
⊗XTGET does exactly the same thing as ⊗XTJGET.

MARGIN CONTROL commands: ⊗XALIGN ⊗XINDENT ⊗→ ⊗← ⊗XCENTER
(See p. 16 for basic justification information and other commands.)

Modes Command Meaning
N,A,S ⊗← Shift line or attach buffer left by current indent default
N,A,S ⊗#⊗← Shift # lines left by current indent default
N,A,S ⊗→ Shift line or attach buffer right by current indent default
N,A,S ⊗#⊗→ Shift # lines right by current indent default
N,A,S ALIGN Align left margins of text
N,A,S CENTER Center text of given lines between margins
N,A,S INDENT Indent lines by given amount

These commands preserve the identity of the text lines while
preforming certain operations on their left margins.

⊗XALIGN moves all lines defined by the location of the arrow line and
a prefixed argument (with 1 line or the entire ATTACH buffer as the
default option) so that all lines start with a specified (or default)
indentation. The command uses initial TABs to the extent possible. The
command can take a single suffixed decimal (sticky) argument to specify
the desired indentation. The initial default value is set at 0.

The command ⊗XALIGN may be set to operate in one of two different
modes with respect to the treatmant of interior TABs. The initial
default mode is for all interior TABs to be replaced by the equivalent
number of spaces that they produced before the alignment was effected.
The other mode is entered by typing the letter T (for TAB) as a suffixed
letter (after the command name and separated from it by a space). This
mode leaves all interior TABs untouched. The mode as so changed is
sticky and applies for all subsequent ALIGN and INDENT commands. The
initial default mode may be restored by typing the letter S (for Spaces)
in an ALIGN or INDENT command. Note, although the ALIGN and INDENT
commands allow numeric macros to be used in place of an explicit number
specifying the indentation, the first occurrence of the delimited letter
"S" or "T" will be taken as a flag as explained above, not as a numeric
macro to be evaluated.

INDENT simply moves the specified number of lines (default is 1 line
except that in ATTACH mode the default is the entire ATTACH BUFFER) to the
right or left by the specified amount independent of their original
starting positions. This permits blocks of code to be moved right or left
while preserving their original relative indentations. INDENT will takes
one suffixed numerical argument specifying the desired indentation, (a
positive number if to the right or a negative number if to the left).
Motion to the left is limited by the edge of the page but there is no
practical limit to the motion to the right so take care when changing the
indent value. The initial default indent value is 4. See the above
paragraph for the handling of interior tabs by the INDENT and ALIGN
commands.

The commands ⊗→ and ⊗← are special cases of INDENT. They move the
specified lines to the right or left by the (absolute) amount that had
been set previously by the ⊗XINDENT command. The default number of
lines is one if not in ATTACH mode or it is the entire ATTACH buffer,
and the initial default indentation is 4. Unlike ⊗XINDENT, these arrow
commands do not require a ⊗X or a carriage return. Like ⊗XINDENT they
limit the text motion to the left edge of the page. These commands do
not take suffixed arguments.

Typical commands.

⊗XALIGN<cr> ALIGN the earrow line (or entire ATTACH buffer if in
ATTACH mode) with all lines moved to start with the
default ALIGN indentation (originally set to 0).

⊗4⊗XALIGN 5<cr> ALIGN 4 lines starting with the arrow line (or with the
start of the ATTACH buffer if in ATTACH mode) so that they
are indented by 5.

⊗XINDENT<cr> INDENT the arrow line (or the entire ATTACH buffer if in
the ATTACH mode) by the default value (set to 4
initially), but do not let any line move far enough to the
left to lose any non-space characters.

⊗8⊗XINDENT 3<cr> INDENT 8 lines starting with CURRENT by 3, that is, move
the 8 lines to the right by 8 positions, with the new
default value being set to 3.

⊗6⊗XIND T 3<cr> INDENT 6 lines, starting with the arrow line, by 3 after
changing the mode so that interior TABs are kept as TABs.

⊗6⊗XINDENT -3<cr> INDENT 6 lines starting with CURRENT by -3, (that is
move them to the left by 3 positions).

⊗→ Move the CURRENT line or the ATTACH buffer contents to the
right by the previously established amount.

⊗← Move the CURRENT line or the ATTACH buffer contents to the
left by the previously established amount.

⊗6⊗→ Move 6 lines starting with the CURRENT line or with the
start of the ATTACH buffer to the right by the previously
established amount.

⊗XCENTER centers all lines defined by the location of the arrow line
and a prefixed argument (with 1 line or the entire ATTACH buffer as the
default option) so that all lines are individually centered between the
left and right margins as previously specified for the ⊗XJUST or ⊗XJFILL
commands, or desired values may be typed with the center command itself
and these new values will then be the default values for the ⊗XJUST and
⊗XJFILL commands. See these other commands for full details.

The command uses initial TABs to the extent possible. Interior TABs
are replaced by spaces before the centering is effected.
Other EXTENDED commands: ⊗X<cmd> ⊗Xα<cr>

Modes Command Meaning
N,A,E ⊗X Enter eXtended command next
N,A,E ⊗Xα<cr> Load line editor with previous extended cmd line to retry
N,A AL Change your job's ALIAS
N,A ALIAS Change your job's ALIAS
N,A,E AUTOBURP Set or read autoburping threshold
N,A,E BEEPME Beep the user's terminal now
N,A BLOAT Add extra records of nulls to current page
N,A BURP Burp current page of extraneous records of nulls
N,A,E CHECK Enable free storage checking within E
N,A CLOSE Close the file, but allow further editing
N,A CORCHK Try to core down if possible (done automatically)
N,A,E CVTALTMODES Convert altmodes to right braces, in files edited
N,A,E DDTGO Call RAID, if available (ERAID only)
N,A,E DFIND Run FIND program on another job to do file search
N,A,S DOVER Spool incore page(s) on the Dover printer
N,A DPYALWAYS Update the display after every command
N,A DPYSKIP Only update the display when no typeahead
N,A,E ECHO Turn on/off echoing of text edited in line editor
N,A,E EMPTY Move to next empty line on page
N,A LINCNT Type length of current line, plus more info
N,A,E NONEMPTY Move to next non-empty line on page
N,A OPEN Open the current file in Read-Alter mode
N,A PPSET Ensure that the page printer is positioned ok
N,A PROTECTION Set or read the protection key of the file
N,A,S ROVER Spool incore page(s) on the Rover printer
N,A,E QUIT Exit to monitor without writing out the file
N,A READONLY Disallow changing the file
N,A READWRITE Allow changing the file
N,A SAVE Write out incore page(s) in E$SAVE.TXT
N,A,S SIN Replace tabs with equivalent numbers of spaces
N,A,S SPOOLC Spool incore page(s) on the line printer
N,A,E TELLME Report the latest commands to person maintaining E
N,A,E TERSE Enter terse mode--suppresses some typed info
N,A,S TIN Replace multiple spaces with equivalent tabs
N,A,E TMPCOR Write out (now and on exit) TMPCOR file used by E
N,A,E VERBOSE Enter verbose mode--types out extra info
N,A,E WRITTEN Type out who previous wrote the file and when
N,A,S XSPOOL Spool incore page(s) on the XGP

Certain commands are either potentially too dangerous to be safely
evoked by a single character or too rarely used to waste a
single-character command on. There are also more commands than can be
obtained with single characters. These contingencies are handled by the
EXTEND command specified as follows:

⊗X Execute the following extended command, which starts with
the command name and normally ends with a <cr>. The
command name may be abbreviated as long as no ambiguity
results. The command name must be terminated by a space
if parameters follow it, or by a <cr> or some other
activating character.

⊗Xα<cr> Load the line editor (displays only) with the last ⊗X command
line typed (whether valid or nor), to let you edit it and try
again. The α and β bits that you get on the edited command
are precisely what you type on the X in ⊗Xα<cr>; also any
numeric arg typed to the ⊗Xα<cr> is applied to the edited
command. This command is a no-op when executed inside a macro
or on a non-display.

Some EXTENDED commands (usually ended with carriage return):

⊗XALIAS <project>,<programmer>
or
⊗XAL <project>,<programmer>
This command can be used to change your alias PPN. It
takes a following text argument in exactly the same form
as the system ALIAS command: 1) PRJ to set project to PRJ
and programmer to logged in name, 2) PRJ, to set project
to PRJ and retain previous alias programmer name, and 3)
PRJ,PRG to set both project and programmer. Note that
this command cannot be abbreviated beyond ALIA. This
command types out your new ALIAS on both the current piece
of paper and PP 0 so that you will see your changed alias
when you exit.

⊗XAUTOBURP This command can be used to set or read the threshold
number of records of nulls for autoburping. If no numeric
arg is given or if a zero arg is given, E will simply type
out the current threshold. A positive arg to this command
sets the threshold to that many records. A negative arg
(e.g., just ⊗-) disables autoburping entirely. An arg of
just "+" sets the threshold to its default value, which is
currently 19. While autoburping is disabled, the header
line will display "/-A" after the filename. (A page to be
written out that has the threshold number of records of
nulls, or more, will be automatically burped to delete all
records of nulls from that page.)

⊗XBEEPME Beep me now. This may be typed ahead whenever desired and
you will be beeped when this command is reached.

⊗#⊗XBLOAT Write out the current page with at least # records of nulls
to provide space for text to be added later. This command
is useful if you are preparing to add a lot of text to a
page and you don't want E to have to ripple every time you
need one more record for the page's text. If you have the
last page of the file in core, then this command will not
write out any extra records of nulls since they aren't
needed to avoid rippling. If you have more than one page
in core, the extra space is allocated to the last incore
page. This command disables autoburping if # exceeds the
current autoburp threshold, in order to avoid having the
new bloatedness autoburped away in the near future.

⊗XBURP Write out the current page and in the process reduce the
disk space for that page to a minimum by deleting any
all-null records from the current page. To burp the
entire current file, don't use ⊗XBURP -- instead give
the command ⊗ε/∞F<cr>.

⊗XCHECK Enable checking of free storage (currently the default);
⊗-⊗XCHECK disables free storage checking; ⊗0⊗XCHECK
reports the current condition of free storage checking.
Macros which are to be executed many times (e.g., 100 or
more) will often be executed significantly faster if free
storage checking has been disabled. It is recommended,
however, that free storage checking normally be left
enabled (except when you are repeatedly executing a macro)
because internal E errors are detected much faster that
way, with less chance for clobberage of your file.

⊗XCLOSE Close the file. This allows others to read it if you had
modified it.

⊗XCORCHK Make E try to core down if possible. There may be
certain situations where E doesn't automatically core
down as much as possible immediately, but this
command will force it to core down if appropriate.
Users NEVER REALLY NEED to use this command.

⊗XDDT Branch to RAID if it is present. αP returns.

⊗XDFIND Starts up the FIND program on another job and passes it
the entire extended command line (starting with the DFIND)
to have it search a given file for some string(s). When
the FIND program finishes, it will report the results of
the search by typing out a special message on the
initiating terminal. This can be useful for having FIND
look up a suspected word spelling in the unabridged
dictionary (the default file to search); however, note
that searching the unabridged dictionary takes about 12.5
seconds of (wholine-type) runtime. You can use DFIND to
search any given file by using the standard syntax of the
FIND program, which is documented in FIND.DON[UP,DOC].
(Note that you cannot run the FIND program with command
FIND or OFIND; only the DFIND command is available for
running the FIND program from E.)

The ⊗XDFIND command starts up a phantom job to do the
search, and a summary of the results are sent to your
terminal. The summary includes the number of hits, as
well as the first, last, and (if different) shortest "hit"
lines. The syntax of the DFIND command in E is the same
as that of the monitor command, with the same defaults for
the WITHIN, OMIT, and IN clauses. (If you specify a
WITHIN other than the default of WITHIN LINE, only the
lines containing the hit will be reported. This isn't
quite the same as WITHIN LINE, since a text unit
containing several matches yields only one hit.)

If you type just ⊗XDFIND<cr>, the current line of text (or
the first line of attached text, if any) will be used to
specify the search parameters.

⊗XECHO Turn ON the echoing of text edited in the line editor
(displays only); this is the default mode. The command
⊗-⊗XECHO turns OFF echoing of text edited in the line
editor, but causes the activator of such edited text to be
typed out so that you can tell what it is (although this
typeout will occur late since it is done by E, not the
system). The command ⊗0⊗XECHO reports the current state
of echoing.

⊗XFIND Do a search or substitution; see p. 13 for details.

⊗XGORPG Exit from E and repeat the last RPG command.

⊗XJUST Justify the current page (or the ATTACH buffer if in ATTACH
mode) using the default values for the paragraph, left and
right margins. Margins are initially set to 1,1,69. For
elaborations on this basic command, see p. 16.

⊗XLINCNT Type out (1) the number of the current line, (2) the
number of lines on the current page, (3) the number of
columns in the current line, (4) the number of characters
on the page, (5) the current page number, and (6) the
number of lines attached, if any.

⊗XOPEN Open the current file in Read-Alter (RA) mode (not legal
in Readonly mode). You should only use this command if
you intend to make some change to the current file, since
such opening of the file in RA mode will update the
date/time written to the present. THIS COMMAND IS NEVER
NEEDED -- E will open the file in RA mode automatically
when you first try to write out a page -- but ⊗XOPEN may
be useful if you intend to make some changes to a file and
you want to open the file now so that no one else can grab
it until you are done.

The ⊗XOPEN command first finds out if anyone else is
already using the file. If so, then ⊗XOPEN will fail and
will report who is using the file.

With a zero argument, ⊗0⊗XOPEN simply tells you who else,
if anyone, is using the file that you are currently
editing. That is, the zero argument suppresses the actual
attempt to open the file, but it tells you whether you
could open the file successfully if you wanted to.

E now effectively does an automatic ⊗XOPEN command for you
whenever you try to write out a file in any way. As a
result, you no longer need to use the ⊗XOPEN command to
ensure private access to a file that you want to modify
(such as the \BBOARD file). When you simply try to write
out the file the first time, if it cannot be opened, E
will abort the command in progress, rather than dumping
you to the monitor (like it used to with a "file in use"
message). This means that all the commands that can write
out text have a new potential error message: "Sorry --
Can't open file now"; this message will be preceded by a
list of other jobs that have the file open and/or a
mention that you have the file open in 2 or more windows.
E does not clear typeahead when this error happens, so you
should make sure you haven't accidentally altered the page
(further) when you get this message (of course the page
won't have been written out).

This "automatic ⊗XOPEN" means that certain commands may do
part but not all of their expected work. For instance,
the αβE command to write out all windows and exit will
stop if it reaches a window that needs to be written out
but whose file cannot be opened. Commands like ⊗., ⊗P,
αM, ⊗<ff>, ⊗<vt>, ⊗O, ⊗ε and ⊗λ will do nothing if the
current page needs to be written but the file cannot be
opened because it is being read elsewhere. The command
α∂αβD, given to delete an entire page, will delete the
text but not the page if the file cannot be opened for
writing. The extended search command ⊗XFIND will do its
search but not switch pages in this situation; it will,
however, report what page it found the given string on.

Also, when E requests confirmation of ReadOnly/ReadWrite
mode upon an attempt to write out a page from ReadOnly
mode, if you respond with ABORT instead of READONLY or
READWRITE, then E will abort the latest command at the
current point within that command (in exactly the same
manner that E would have aborted the command if it had
found it couldn't open the file for writing). Finally,
if you confirm with READONLY in this case (instead of
READWRITE or ABORT), E will say "OK, text Not written
out", but the command will otherwise continue.

⊗XPROTECTION Type out the protection key for the file being edited.

⊗XPROTECTION nnn Change the protection of the file being edited to the
octal value nnn. Only 3 octal numbers may be given. An
attempt to change the protection of a file that is
protection protected againt the user will not work.

⊗XREADONLY Inhibit any further writing of the file. You can leave
readonly mode with the ⊗XREADWRITE command (if the file is
formatted). If you try to write out a changed page while
you are in readonly mode in a formatted file, E will
demand that you respecify the mode (readonly or readwrite)
that you want. If you choose readwrite, the changed page
will be written out.

⊗XREADWRITE Enable writing (modifying) the file. The file must be
formatted for this command to work. However, if you are
editing a one-page unformatted file, this command will
still work by changing you to /N mode (no directory on the
disk).

⊗XXSPOOL
and
⊗XSPOOL These commands spool text to the indicated printer; the
and text is from the current page, or the ATTACH buffer if
⊗XDOVER something is attached (this command does NOT write out the
and current disk file). If a numeric arg is given with one
⊗XBOISE of these commands, only that many lines of text are
and spooled (they are spooled from the attach buffer if
⊗XIMPRINT anything is attached). This allows you to spool a copy of
and changes that you have made whether or not you intend to
⊗XROVER incorporate them into the disk copy of the file that is
being edited. The spooled copy carries the same header
information as it would have carried had it been spooled
in the usual way. For spooling on the XGP, the Dover,
BOISE, the IMPRINT/Canon printer or the Rover, the
default font and page margins are used.

⊗XSIN Put Spaces IN, in place of TABS, for example, so that the
actual spacings will be preserved when extra characters
are added ahead of TABs. This command may take a prefixed
argument specifying the number of lines to be operated on.
Without an argument it is applied to the entire page or to
the entire ATTACH buffer.

This command will, of course, increase the space occupied
by the text on the disk. The inverse command, ⊗XTIN,
should be used to replace spaces by TABs, and then, this
should be followed by an ⊗XBURP before saving the page.
Note that TIN will not restore previous tabs that took up
only one space.

SINning without TINning and BUrping is bad.

⊗XTIN Put Tabs IN, in place of spaces, when this will result in
a net saving in the space occupied by the text on the
disk. Extra spaces and/or TABs at the end of lines are
also deleted. No change is made in the way the text is
displayed. This command may take a prefixed argument, to
specify the number of lines to be processed. Without an
argument it is applied to the entire page or the ATTACH
buffer. The inverse command is ⊗XSIN; however, SIN will
not restore tabs and spaces at the ends of lines.

While this command reduces the number of spaces used in
the text, it does not necessarily reduce the space that
the text will occupy on the disk. The command ⊗XBURP
should be used after the ⊗XTIN command, for this purpose.

monitor command REENTER
or
⊗XSAVE Write out the current incore page(s) and any attach buffer
in the file E$SAVE.TXT on your LOGIN disk area. This is
done automatically for almost all fatal errors detected by
E; when it happens as a result of such an error, a message
to that effect is typed out. (The file E$SAVE.TXT may NOT
be written out successfully if the error is detected again
while writing this file.) Note that any previous
E$SAVE.TXT file is superseded (replaced) by the new file.
Note also that this command (and its automatic call upon
error detection) does NOT touch the file you currently
have open for editing. Whenever the E$SAVE.TXT file is
written, E's TMPCOR file is also written so that the
monitor command ET<cr> will get you back to that point.

⊗XTELLME Make a standard "E error report" to report the last
several commands executed and some internal E data.
This command should only be used if you think you have
just seen a bug occur in E. This command provides
valuable information for tracking down possible bugs.
If you use this command, you should shortly afterward
mail a message to the E maintainers (BUG-E) explaining
what sort of bug you think you just saw.

⊗XTMPCOR Write out the TMPCOR file now to remember the current
state of the edit stacks. Also, this also causes the
TMPCOR file to be written out whenever you subsequently
leave a file, as if you had given as standard E monitor
command originally. This is sometimes useful to remember
your place if you did something funny originally that
normally inhibits use of the TMPCOR file (like, saying "R
E;<file>" instead of "ETV file"). See the description of
what goes in the TMPCOR file on p. 20.

⊗XWRITTEN Type out the date and time at which the current file was
previously written and the PPN and jobname of the person
who did it. This information is saved even after you have
modified the file, that is, even after the system has lost
this data; however, once you switch away from a file this
data is lost for that file.

⊗XTERSE
and
⊗XVERBOSE E can be in any one of three possible report states. The
reporting state determines how much information E types
out a various times. The three states are: (1) the
normal default state, (2) a verbose state achieved by the
command ⊗XVERBOSE and (3) a terse state achieved by the
command ⊗XTERSE. The normal state can be restored by
giving either ⊗-⊗XVERBOSE or ⊗-⊗XTERSE. You can find out
the current state by giving either ⊗0⊗XVERBOSE or
⊗0⊗XTERSE. The normal state now does somewhat less
reporting (that is, less typeout) than formerly. No error
messages are ever suppressed by the terse state.

The following remarks are currently suppressed only in the
Terse state.

Only one MARK and you are there!
There are no marks!
Already marked!
Not marked!
All marks have been cleared.
Removing last MARK on this page.
MARKS on this page only have been cleared.
Page is empty. (⊗XNDFAIL, ⊗XNDSAIL cmds)
Aborting macro ... (error occurred in macro)
Abort of # macros requested from ... (⊗#⊗XABORT cmd given)
No lines broken (⊗XBREAK command).
Free storage checking is now disabled/enabled. (⊗XCHECK)
Deleted text saved up to nnnn chars. (⊗-⊗#⊗XUNDELETE)
Calls on stack deleted for macro ...
Using symbol pair .. (⊗XPAREN)
Searches will now match only exact (ignore) case of letters.
Current file record shifted to 0, rest flushed.
Fileswitch list full -- replacing FILE.EXT
Auto Burp threshold is nn records of nulls.
Auto Burping is disabled.
Disconnecting (subjob)
Connecting (subjob)
Auto Write threshold is nn lines.
Auto Write is disabled.
(incore page) (find commands)

The following remarks are typed out only in the Verbose
state.

N characters added/removed (justify commands)
Line now has N chars. (join)
You have replaced XXX with YYY (substitute)
(detailed info of the parenthesis commands)
The new line of N chars lists M items (⊗XNDFAIL/SAIL commands)
Calling ... (calling a macro)
Ending ... (a macro has finished)

⊗XNONEMPTY
and
⊗XEMPTY Move to the next empty or non-empty line. A repeat
argument will cause these commands to look for that many
empty or non-empty lines. A negative arg will cause the
search to go backwards. A positive arg (or default of 1)
will ignore the current line and search from the next
line, but will not cross a subsequent incore pagemark;
hence the search is of only one page. These commands can
also be used, both inside and outside macros, to tell if
the current line is empty--use a zero arg: ⊗0⊗XEMPTY is a
no-op if the current line is empty, but will generate a
SORRY-type error otherwise; ⊗0⊗XNONEMPTY is a no-op if the
current line is non-empty, but will generate a SORRY-type
error otherwise. An incore pagemark and the end of the
incore page are considered neither empty nor non-empty
lines by these two commands, so the ⊗0 argument forms of
both these commands will generate an error when pointing
to such an end-of-page "line".

⊗XDPYALWAYS Always re-display text after each command.

⊗XDPYSKIP Don't re-display text if there are typed-ahead commands to
be executed. (normal mode)

⊗XPPSET Reset screen position of page printer (the three lines at
the bottom of the screen which echo commands).

⊗XQUIT Exit WITHOUT writing out to the disk any text changes.
All other commands that exit write out any changes first.

⊗XCVTALTMODES Enable conversion of altmodes in a file being edited;
this is the default mode, in which altmodes (octal 175)
found in the file are converted to an editable character,
namely right brace ("}", octal 176 in WAITS ASCII). The
command ⊗-⊗XCVTALTMODES, or the fileswitch /-V, will make
E retain altmodes when reading in a file to edit. This is
not recommended and is included only to allow editing of
non-WAITS-ASCII files that have been FTP'd to WAITS
without conversion from ASCII to WAITS ASCII. Even in /-V
mode, using the line editor on a line with an altmode in
it will convert the altmode anyway (a warning is given
when editing such a line), unless such editing of the line
is aborted (with altmode, of course).
System commands and file SWITCHES.

(See also "Filenames, PPNs, numeric extensions, and filehacks" on p. 31.)

There are five main monitor commands available that run E in
various modes (for the first file edited). These monitor commands
are: ETV, EREAD, CETV, READ and BOOK. All of these commands restore
(upon startup) the list of the last few files you have edited along
with related information about each file. When you exit from E, this
information is saved in a TMPCOR file (see details below) for later
restoration. The meanings of these monitor commands are as follows.

ETV Edit a file normally.

EREAD Edit a file in readonly mode. An E command is available to
change from readonly mode to readwrite mode. In readonly mode
you cannot change the file. See the /R switch later.

CETV Create a new file with one empty text page and begin editing it.
See also the /C switch. If no filename occurs with this command,
then the result is the same as if you had said ETV, not CETV.
If you want to create a new file without a directory, then use
the CETV command with the /N switch following the filename.

READ Read a documentation file. This command will attempt to find
the file on one of several system documentation disk areas and
will then edit it in readonly mode. See also the /D switch.

BOOK Read a book file. This command provides for keeping your place
in the book over long periods of time (while you read it) but
always edits the book in readonly mode without letting you
change to readwrite mode. See also the /B switch.

Any of these monitor commands can be followed by zero, one, or
more filenames. If no filename is given, then E edits the last file
previously edited. If one filename is given, that file is edited.
Two filenames can be given to have E copy one file to another and
then edit either file; a left- or right-arrow is placed between the
filenames to indicate which file is to be copied, with the first file
listed always being the one edited. Additional filenames can follow
the initial one (or two), preceded by commas -- such filenames
indicate files to be placed on E's file stack for editing later; this
mechanism is mainly used by E itself to remember the last few files
edited but is also available to the user for entering several
filenames.

Any filename can be followed by switches that tell E the mode(s) in
which to edit the given file. Also, if the first filename is omitted,
switches can still be inserted where that filename would be; such
switches apply to the last file previously edited (which will be edited
again). The available switches are explained later.

One more monitor command can be used to run E. This one is different
from those listed above in that the use of it suppresses the normally
automatic remembering of the names of files edited.

R E; Run E but don't restore information about previous files edited
and don't remember information about current files edited.
This command has little usefulness, especially since E normally
remembers not just the last one, but the last three files you
have edited. Note that the filename(s) must be preceded by a
semicolon.

THE TMPCOR FILE -- SAVING AND RESTORING YOUR
EDITING STACKS, LINE MARKS, AND MODES

If you run E normally (by using any of the monitor commands listed
above except "R"), then when you exit, E saves information about the files
you have been editing. (Actually, the information is saved each time you
leave a file, not just when you exit.) When you return to E with one of
the same monitor commands, this information is restored. The information
is remembered in a TMPCOR file (a temporary file in system core that goes
away when you log out). When you leave a file, E remembers the names (and
stack positions) of the top three files in your file stack, and for each
file remembered, E also remembers the following: (1) the top part of the
page stack (including the final page, line and window position), (2) all
line marks, and (3) the current modes, including the settings of the /R,
/N and /F switches. If auto burping is disabled, this fact is also
remembered in the TMPCOR file; note that the state of auto burping is
global to all files edited.

When you return to E with one of the standard E monitor commands,
the TMPCOR file is read and the information there is stored by E
internally so that if you edit any of the same files again, the stacks,
line marks and modes for that file are restored to their previous
values. For example, when you give the "ETV<cr>" monitor command with
no filename, E will edit the last file you were in and restore the
saved information for that file; in particular, E will start up editing
the file at the same page and line where you were when you left that
file. Also, if you return to E with the monitor command "ETV
<filename><cr>", and if the file named was remembered in the TMPCOR
file, then the saved information for that file will be restored. In
either of these example cases, other remembered files will have their
corresponding data saved, and the files will automatically be entered
in E's file stack; switching to such a file will cause the saved
information about that file to be restored.

Whenever you edit a file by explicitly giving that file's name
(with or without an explicit filename extension), the state of the /R
flag is determined by the command you gave rather than by the previous
state of this flag. If you edit a file without giving its name
explicitly, the /R flag is restored to its previous value unless the
command itself specifies a particular state for the /R flag (e.g.,
both the ⊗λ command and the EREAD monitor command specify /R).

SWITCHES

A switch consists of an optional decimal number followed by a single
letter, all either preceded by a slash or enclosed in parentheses. Any
number of switches may follow the filename that the switches are to
modify. The infinity character "∞" may be used as the decimal number
for a switch, as in /∞F; "∞" represents a large positive value. Using
a number of 0 in any switch is exactly equivalent to omitting the
number completely. Some switches actually take two decimal numbers,
separated by a comma -- for example, /3,5M. In such cases, if the
second number and the comma are omitted, zero is used for the second
number (which is usually a line number).

Here are a couple of equivalent commands.

ET E.ALS/R/7P/2L ET E.ALS(R7P2L)

Switches are NOT ALLOWED in front of a filename. "ET /R FOO" is illegal.

The available switches are listed below. The inverse of any switch
can be specified by inserting a minus sign "-" between the slash
and the letter, as in /-R. This is useful when you want to override
a positive switch default.

Note that if two switches specify conflicting conditions, the latter
switch overrides the switch occurring earlier.

/C Create a new file with the specified name. This is of
most use when one wishes to create a new file with
the file switching command ⊗ε, perhaps to hold some
attached text from the current file. If you want
the newly created file NOT to have a directory,
then use both /C and /N.
/R Open the file in the read-only mode. This is useful
if one wants to examine a file without any danger
of inadvertently modifying it. For example:
ETV TEACH.TXT[UP,DOC]/R<cr>
You can leave read-only mode by using the ⊗XREADWRITE
command. You enter read-only mode with ⊗XREADONLY.
/B Book mode. Edit the file in book mode. In this mode
you are never permitted to alter the file nor are you
permitted to leave this mode. See the explanation of
book mode on p. 29.
/N No Directory. Edit the file without writing a directory
on page one. The directory must be generated from
scratch and the file reformatted each time you edit
the file. The directory is kept in core by E but
never written in the file. To force E to put a
directory on a file that you have edited /N (or any
file that simply has no directory page), edit the file
with the /Q switch (and omit the /N switch of course).
/F Repage and reformat the file with the maximum page size
limited to the default value of 33 (one screenful on
Data Disc terminals). The F may be preceeded by a
decimal argument to use any desired number instead of
33. Old page marks are retained, so it is not
possible to increase the page size by this switch and
some pages may be shorter than the specified length.
This switch is particularly useful for getting long
unformatted files into a shape where they can be
handled safely and easily. Also, when this switch is
used with an argument of infinity ("∞"), the effect
will simply be to reformat the file, during which
process E "burps" the file by removing unneeded nulls
(except from the directory page).
/F/R (This is a combination of two switches.) Repage and
reformat the core version only without changing the
disk copy. The new directory will be on page 0 and
the old directory (if there is one) will be kept as a
part of the text starting on page 1. Do not try to
use the old directory as it is invalid. This switch
combination is particularly useful for examining
(without altering) unformatted files that have been
produced by programs other than E.
/nH Take the name of the file to be edited from that of the
nth file down in the file stack. This switch can be
used with or without explicit parts of a filename.
This switch makes E fill in the missing parts of the
filename with those from the nth file on the stack
(the nth home file). This is useful, for instance,
when you've omitted the PPN of a file on the same area
as some earlier file you've edited. It is also useful
with the monitor ETV command when you want to go into
E not on the latest file you were editing, but on a
previous one (e.g., ET/H<cr>).
/? Type out the file stack, so that you can select the
proper "n" to use in the /nH switch above. E
completely ignores any filename or other switches that
/? appears with, since /? is purely an informational
switch.
/nX Reformat the file and bloat each page (except the
directory and the last page) by # records of nulls
(after discarding previous records of nulls (except on
the directory page)). This switch also disables auto
burping. Thus this switch is useful when you are
about to perform a large amount of editing which might
have otherwise caused rippling several times. If the
number n is omitted (i.e., "/X"), then the default
bloat amount is used, which is currently 3 (records).
The bloat amount is limited to prevent the resulting
file from becoming bigger than 256K or more than twice
its previous size; however, since this switch can
still make a file very big, care should be taken to
avoid wasting disk space unnecessarily. Note that you
can unbloat (i.e., burp) a file with /∞F.
/nA Set the auto burp threshold to n records of nulls. If n
is omitted, auto burping is enabled with the default
threshold. The switch /-A disables auto burping. The
effect of this switch is global; i.e., it applies to
all files edited until changed by another /nA switch or
by the ⊗XAUTOBURP command (which see). While auto
burping is disabled, the header line will display "/-A"
following the filename.
/nP Open the file at page n, where n is a decimal number.
/mL Open the file with the arrow at line m (m is decimal).
/x,yZ Open the file at page x and line y.
/E Open the file at the End of the last page.
/nE Open the file at the End of page n (decimal).
/S Open the file at the Same page and line the last file
was open at.
/nW Open the file with the window initially positioned so
that line n of the initial page is at the top of the
screen. This does not affect the initial setting of
the arrow line, which has priority over this switch.
Therefore E will not obey the /nW switch if it
conflicts with the starting line number.
/Q Quietly assume a Yes answer to any questions E would
otherwise ask about formatting or replacing an
existing file or about discarding any invalid or
undesired directory.
/x,yM Place a line-mark on page x at line y. Note that this
switch takes two decimal arguments separated by a
comma. See the line marking commands on p. 8. This
switch is a no-op when switching to the ? file or to a
file that you have already been in because previous
line marks in such a file are restored automatically.
/x,yO Push the position consisting of page x and line y on
the page stack for this file. This switch also is a
no-op when switching to the ? file or to a file that
you have already been in because the previous page
stack in such a file is restored automatically.
/D Search the system documentation disk areas for the file
specified and then edit in Readonly mode whatever file
was found. Thus you don't need to specify either the
extension or the PPN of documentation files. If no
extension is given, then files with extensions other
than UPD will be found before UPD files. However, any
explicit extension, project, or PPN given will be
observed. If an extension is given but no PPN, E will
look for the particular file on any of the
documentation areas. If a project is given, say PRJ,
then E will look for the file on [PRJ,DOC]. If a
programmer name is given, then no searching of
documentation areas will be done and normal PPN
scanning applies and the /D will merely force the file
to be edited in Readonly mode. The monitor command
READ runs E and implies /D. Here are some examples of
the monitor command READ and the /D switch.
READ UUO Edits the UUO Manual file in readonly mode.
READ UUO.UPD Edits the update file for the UUO Manual in readonly mode.
⊗εMONCOM/D Switches to the Monitor Command Manual in readonly mode.
READ NOTICE/E Edits the NEWS program's text file of notices in readonly
mode, starting at the End.
/-U Suppress updating the directory whenever possible. In
particular, this switch is the DEFAULT when you are
editing SOMEONE ELSE'S MESSAGE FILE (on 2,2 -- this
default does NOT apply to MSG.MSG files, but an explicit
/-U will work on such files). Thus if you go edit a
message that you sent someone, your edit will not screw
up his "place" in the file because E will retain the
non-updated directory for him.
The maintaining of the owner's "place" (last previously
existing page) in the file works under virtually all
conditions of editing a file in /-U mode, even if it
ripples or if you burp it -- however, autoburping is
never done while in /-U mode. Although the /-U switch
is not displayed to the user, its presence will be noted
(on displays) when you write out a page -- the "U" flag
on the header line will appear (or not disappear if it
was already there) if the incore version of the
directory didn't get completely written on the disk.
One particular effect of /-U mode is that changing the
first line of a page will not force the directory to be
written out (although it will still cause the "D" to
appear in the header, and when the page is written out a
"U" will appear in place of the "D"); thus the directory
can become inconsistent with the TEXT of the first line
of each page (and if you leave such a file without doing
an ⊗XUPDATE and come back to that file later, E won't
know that the directory does not reflect the actual
first line of each page). However, the record numbers
on the directory page are NOT allowed to become invalid
or inconsistent. As usual, the ⊗XUPDATE command will
write out the directory (if necessary to update the disk
version), and in addition, this command will take you
out of /-U mode.
The default /-U mode that occurs when editing another
person's message file cannot be overriden with the /U
switch; you must actually give the ⊗XUPDATE command to
leave /-U mode, but YOU SHOULDN'T DO ⊗XUPDATE WHILE IN
SOMEONE ELSE'S FILE. (The /U switch has no use except
to override an earlier /-U switch in the same command
line!)
The /-U switch applies only to the file with whose name it
is given, and then only until you switch to another
file (unless /-U is given again). That is, it is NOT
a permanent mode, even for the particular file.
/I The switch /I given after the name of a file to be edited
forces E to execute the EIN file after it has opened the
next file. This has two main uses, given that /I is the
default when E starts up. First, you can prevent the
execution of EIN upon startup by specifying the switch
/-I. And you can give /I when switching files,
particularly if you said /-I when starting up.
/nK The switch /nK, where n is an octal number, specifies
the disk protection key to be given to a file being
CREATED in the current command. That is, the command
ET FILE1←FILE2/5K will create FILE1 and give it a disk
protection code of 005, no matter what the protection
of FILE2 is (of course, if FILE2 is read protected
from you, then this command still won't work).
Similarly CE FILE3/77K will give FILE3 a protection of
077. If the octal value n of the switch is omitted or
illegal, then a protection value of 000 is used. When
E copies a file without this switch being used, the
protection of the old file is copied to that of the
new one. This can sometimes cause the new file to be
write-protected from its creator; to avoid this, a /K
can be used with the E file copy command (/K means
protection 0).
/nJ The switch /nJ is used by E to remember Lisp subjobs in
the TMPCOR file. It can also be typed by the user.
For details, see the /nJ switch on p. 38.
/-V Suppress the normal conversion of altmodes to right
braces that happens when E sees altmodes in a file
being edited. For details, see the ⊗XCVTALTMODES
command on p. 19.

Alphabetical switch summary (for details, see above):
/? type the filestack contents, to allow use of /nH.
/nA set the Autoburp threshold to n records.
/B edit the file in Book mode (no changes permitted).
/C Create the given file.
/D read a file from one of the Documentation file directories.
/nE edit the file at the End of page n (or end of file if no "n").
/nF pretend that the file has a Formfeed (pagemark) every n lines.
/G (unused)
/nH edit the nth previous file (from the stack).
/I execute commands from EIN tmpcor file after opening next file.
/nJ Job n is a Lisp-type subjob.
/nK if creating a new file, give it protection n (octal).
/nL edit the file starting at line n.
/x,yM place a line Mark on page x at line y.
/N edit the file in no-directory mode.
/nO push page n onto the page stack for this file.
/nP edit the file starting on Page n.
/Q Quietly assume a Yes answer to file formatting questions.
/R edit the file in Readonly mode.
/S edit the file at the Same page and line as in the previous file.
/T (unused)
/-U suppress directory Updating in the new file.
/-V don't conVert altmodes in the file to right braces.
/nW edit the file with line n at the top of the Window.
/nX reformat the file leaving n empty records on each page.
/Y (unused)
/x,yZ edit the file starting on page x, line y.

NEED TO REFORMAT FILE, or WOULD YOU SETTLE FOR /R MODE, or FOR /N MODE?

If you try to edit, in readwrite mode, a file that does NOT have a
valid E directory and that does have more than one page, E will tell you
that the file needs to be reformatted and will ask if that is OK. If you
say Yes (just Y), then E will format the file and add a directory page at
the beginning of the file. If you say No (just N), E will ask if you will
settle for editing the file in readonly mode (/R) (for which E does not
need a formatted file). If you say No to each of these questions, E will
ask for a new filename. If you type <altmode> in place of Y or N for any
question, E will not ask any more questions but will immediately let you
give a new filename.

To either of the Yes or No questions about formatting, you can respond
/R to tell E to edit the file in Readonly mode, or you can respond /N to
tell E to edit the file in No-directory mode. Like the normal responses
(Y or N), the special responses /R and /N do NOT take a carriage return.

When you try to edit a one-page directoryless file not in /R mode, E
will NOT ask you about formatting the file (provided the file contains no
rubouts). Instead, E will automatically open the file in /N mode, but
WITHOUT RECOPYING THE FILE. This works for one-page files because they
are always formatted properly (each page beginning on a record boundary).
This free /N feature for one-page files is suppressed if E finds any
rubouts (octal 177) in the file; this is to prevent accidental clobberage
of special files written by non-editor programs, since E normally
discards 177s on input.

HANDLING OF A BAD FILENAME FROM A MONITOR COMMAND

When E is given a bad filename (e.g, no such file, or bad name) from a
monitor command, the user can use α<cr> to restore to the line editor a
line containing only the filename part of the monitor command. I.e.,
α<cr> at that point will omit any leading "ET" or "ER", etc., of the
original monitor command. This makes α<cr> consistent for filename
errors whether from a monitor command or from a ⊗λ or ⊗ε command.

DIRECTORY ERRORS DETECTED WHILE EDITING A FILE

If E detects any inconsistency between a file's directory and the location
of individual pages in the file, an error message will be typed out. If
the user is in /R mode, he will be allowed to continue reading the file
(but will not be permitted to change it). If the file is not being edited
in Readonly mode, then the directory error will cause E to stop (with its
usual saving of incore text in E$SAVE.TXT). Directory errors SHOULD never
occur, unless perhaps the file has been messed up with some program other
than E or unless there is some problem with the disk.

Using E from a non-display (TTY). XTYPE XNUMBERS XHEADER XTRAILER XCONTROL XMETACONTROL

Modes Command Meaning
N,A,E CONTROL Make next cmd char have only the CONTROL bit
N,A ENTER Switch to given file in READWRITE mode
N,A EPSILON Switch to given file in READWRITE mode
N,A,E EXIST Type out fileswitch list
N,A HEADER Type out the header line (from top of window)
N,A LAMBDA Switch to given file in READONLY mode
N,A LOOKUP Switch to given file in READONLY mode
N,A,E METACONTROL Make next cmd char have both META and CONTROL bits
N,A,E MSG Operate on current message with next command
N,A,E NUMBERS Enable or disable typing of line numbers with text
N,A,E PARTIAL Operate on current message with next command
N,A TRAILER Type out the trailer line (from bottom of window)
N,A,S TYPE Type out line(s) of text

It is possible to use E from a non-display terminal. Of course, some of
the advantages of E over, say, SOS are lost but one may not want to go
to the trouble of having to switch editors in mid-stream. As partial
compensation for the lack of display features, E provides the
non-display user with optional line numbers. See the MONITOR COMMAND
MANUAL sections 3 and 4.7 for other information of interest to
non-display users.

No special action is required of the non-display user to tell E that
a non-display is being used. E figures that out automatically.

An important and useful command on non-displays is ⊗XTYPE, which types out
a number of lines. (See also the similar ⊗XPRINT command on p. 25.)

⊗#⊗XTYPE<cr> Types # lines starting at CURRENT and moves CURRENT
past those lines. If # is omitted, 10 lines are
typed if on a non-display terminal, but only 1 line
is typed if on a display terminal (useful for seeing
long lines that go beyond right edge of display).

The following command can be used to enable or disable the typing
of a line number and tab at the start of each text line typed out.

⊗XNUMBERS<cr> E lets you select whether or not you want line numbers
typed out. The command ⊗XNUMBERS enables typing out
line numbers and the command ⊗-⊗XNUMBERS disables
typing line numbers. In ⊗-⊗XNUMBERS mode on a
non-display, when you go into line insert mode, E types
out a once-only prompt and tells you the line number of
the first line you are about to insert. The current
initial default is ⊗-⊗XNUMBERS (no line numbers). The
command ⊗0⊗XNUMBERS restores the line numbers mode to
its initial default (currently ⊗-⊗XNUMBERS).

Here are some arguments for using each mode:

XNUMBERS: In this mode you always know where you are on a page; and
when you are in line insert mode, you get a prompt (of the
line number) to remind you that you are inserting text.
Blank lines are obvious because of the leading line number,
unlike in -XNUMBERS mode where a blank line of text typed out
may go unnoticed.

-XNUMBERS: In this mode, typeout of lines is a little faster, since the
leading line number and tab are omitted. Also, the resultant
typeout of each line is 8 spaces shorter, thus making fewer
long lines wraparound on each given-width terminal.
Furthermore, in line insert mode, a one-time prompt tells you
at what line number on the page you begin inserting text, and
the text that you insert is flush with the left margin. Thus
a ↑U (clear input line) command to the monitor (which puts
you back at the left margin on the next line) leaves you
still properly lined up with text from previous lines.

The ⊗XTRAILER and ⊗XHEADER commands type out the header and trailer lines,
respectively, which normally delimit the windowful of text shown on display
terminals. These commands are useful on non-displays for getting some of
the information that is not otherwise obtainable, such as the record and
character counts at the end of the trailer line and the mode letters at
the end of the header line. These lines contain dots (...) when there are
more lines beyond the current windowful in the given direction and stars
(***) when the windowful includes the last line in the given direction. Note
that the line number (if any) typed out by ⊗XHEADER is the line number of
the first line in the window, NOT the line number of the current line.
The ⊗XTRAILER command types the number of the current ("arrow") line.

TYPING COMMANDS FROM NON-DISPLAYS:

Initially, each character typed to E from a non-display is assumed
to be a command; that is, the character is read by E as if it had
been typed with the CONTROL key depressed. One can, however, enter
LINE INSERT mode by typing the character I and then everything
thereafter is accepted as text to be inserted until ALTMODE (ESC on
some terminals) is typed. Of course, when the non-display user
types the command character X, E waits for an extended command
name to be typed followed by a carriage return.

The LINE EDITOR is not available on non-displays, so it is not
possible to arbitrarily edit an existing line on a non-display.
However, it is possible to use the substitution commands (using the
linefeed delimiter at the end of the search string) to change part
of one or more lines. Also, the ⊗XBREAK and ⊗XJOIN commands can be
used to separate out part of a line that you want to change.

The following two extended commands allow the user on a non-display
to execute commands that require precisely just the CONTROL bit or
precisely both the CONTROL and META bits. These are prefix commands
which affect the following command.

⊗XMETACONTROL This causes the next character to be interpreted
as if it had both the META and CONTROL bits.
This is useful on a non-display when you want to
use a command that requires both META and CONTROL.

⊗XCONTROL This causes the next character to be interpreted
as if it had the CONTROL bit but NOT the META bit.

If neither of the above two commands is used on a non-display, a
command that makes a distinction between CONTROL and META-CONTROL
will execute the CONTROL version; and a command that distinguishes
between any bits and none at all will execute the no-bit version.

The control key on a non-display is not at all the same as the
Stanford-keyboard CONTROL key referenced in most of this manual.

Some characters cannot be typed from a non-display to a user program
(like E) because their use has been preempted by the system. Thus
it is impossible to input those characters as text in E. However,
where such characters are used as commands by E, there is an
alternative extended command that does exactly the same thing as the
single-character command which the system intercepts. The table
below lists these extended commands and the single-character
commands they represent. For details on what these extended
commands do, see the writeups in this manual for the corresponding
single-character commands.

Extended Equivalent Single-Character Command
Command

⊗XEXIST ⊗∃ (there-exists sign, octal 025, ↑U (intercepted by system))
Types out file-switch list.
⊗XPARTIAL ⊗∂ (partial-sign, octal 017, ↑O (intercepted by system))
Carries out next command on current message.
⊗XMSG ⊗∂ (partial-sign, octal 017, ↑O (intercepted by system))
Carries out next command on current message.
⊗XLAMBDA ⊗λ (lambda, octal 010, ↑H) Switches files.
⊗XLOOKUP ⊗λ (lambda, octal 010, ↑H) Switches files.
⊗XEPSILON ⊗ε (epsilon, octal 006, ↑F) Switches files.
⊗XENTER ⊗ε (epsilon, octal 006, ↑F) Switches files.

Stanford characters that cannot be sent as text or as E control
characters are:

Octal Usual Prints Typed Preempted as a system
name out as in as command used for

002 alpha α <ctr>B type-out pause (toggles)
003 beta β <ctr>C monitor call
017 delta ∂ <ctr>O flush type-out (toggles)
025 there exists ∃ <ctr>U clear input line
032 tilde ~ <ctr>Z end of file
033 not equal ≠ <ctr>[ altmode

Character equivalences, Stanford AI Lab character set:

Code Name Prints Typed Preempted
octal out as in as for

000 null
001 down arrow ↓ <ctr>A
002 alpha α <ctr>B
003 beta β <ctr>C monitor call
004 logical and ∧ <ctr>D
005 logical not ¬ <ctr>E
006 epsilon ε <ctr>F
007 pi π <ctr>G

010 lambda λ <ctr>H
011 TAB
012 LF
013 VT
014 FF
015 CR
016 infinity ∞ <ctr>N
017 delta ∂ <ctr>O flush type-out (toggles)

020 containment ⊂ <ctr>P
021 implication ⊃ <ctr>Q
022 intersection ∩ <ctr>R
023 union ∪ <ctr>S
024 for all ∀ <ctr>T
025 there exists ∃ <ctr>U clear input line
026 circle times ⊗ <ctr>V
027 double-arrow ↔ <ctr>W

030 underbar _ <ctr>X
031 right-arrow → <ctr>Y
032 tilde ~ <ctr>Z end of file
033 not equal ≠ <ctr>[ altmode
034 less or equal ≤ <ctr>\
035 greater or eq ≥ <ctr>]
036 equivalence ≡ <ctr>↑
037 logical or ∨ <ctr>←

040 SP
041 exclamation ! !
042 double quote " "
043 number sign # #
044 dollar sign $ $
045 percent % %
046 ampersand & &
047 close s. quote ' '

050 left paren ( (
051 right paren ) )
052 asterisk * *
053 plus + +
054 comma , ,
055 minus - -
056 point . .
057 slash / /

060 digits 0 0
...
071 9 9
072 colon : :
073 semicolon ; ;
074 left broket < <
075 equal = =
076 right broket > >
077 question mark ? ?

100 at sign @ @
101 upper-case A A
...
132 Z Z
133 left bracket [ [
134 back slash \ \
135 right bracket ] ]
136 up¬arrow ↑ ↑
137 left-arrow ← ←

140 open s. quote ` `
141 lower case a a
...
172 z z
173 left brace { {
174 vertical bar | |
175 ALT ALT or ESC
176 right brace } }
177 BS or DEL BS or DEL
PARENTHESIS finding/matching commands: ⊗( ⊗) ⊗XLPAREN ⊗XRPAREN ⊗↔ ⊗XPAREN ⊗XPINFO

Modes Command Meaning
N,E ⊗( Find (
N,E ⊗) Find matching )
N,E ⊗↔ Return to place ⊗(, ⊗) or ⊗↔ was given
N,E LPAREN Search for next "(", crossing page boundaries
N,A,E PAREN Set the chars searched for by parenthesis cmds
N,A,E PINFO Type out info about last parenthesis command
N,E RPAREN Search for next ")", crossing page boundaries

This set of commands allows one to check nested sets of bracketing
symbols for matching pairs and for related properties. The search may
be restricted to the current page by using the ( and ) forms or it may
be extended over the rest of the file by the extended commands ⊗XLPAREN
and ⊗XRPAREN. It always starts from the location of the cursor at the
time the command is given and proceeds in the forward direction. The
nesting level is re-assigned the value 0 at the cursor's current
position for each new command (see special conventions below).

The default symbols are the normal parentheses ( and ). An EXTEND
command ⊗XPAREN allows one to define any desired set. The command
itself must be delimited by a space and followed by the desired two
characters and a carriage return. If the desired pair is from the set
→←, ⊂⊃, `', ≤≥, {}, <>, [], then only the first of the set and a
carriage return should be typed. If another set had been chosen the
default set may be reset by typing the setting command with a carriage
return only.

Note, that a space is an acceptable symbol and for this reason extra
spaces are not permitted in the command string. A distinction is also
made between upper and lower case characters so that both may be used.
In the special case when the same character is assigned to both symbols,
the concept of nesting has no meaning and the commands are interpreted
differently, as noted in the special section below.

In what follows, the two symbols of the chosen set will be referred
to as the left-symbol and the right-symbol respectively.

The normal commands are then ⊗( and ⊗). Each of these may take an
argument which specifies the sought-for nesting level for the region
defined by the bracketing symbol. The default argument is 1 for both
commands. The corresponding extend commands are ⊗XLPAREN and ⊗XRPAREN.
These commands may be given both when not in the line editor and when in
the line editor. If given when in the line editor the line will not be
written out should the search be unsuccessful or should the search be
successful with the found symbol in the same line. A successful search
that results in leaving the line editor to go to another line will cause
the original line-editor contents to be written.

There is one additional command ⊗↔ which, in effect, un-does the last
⊗(, ⊗), ⊗XLPAREN, ⊗XRPAREN or ⊗↔ command and returns the cursor to its
former position.

Note that the most frequent use of these command will be in LISP
where one wants to find matching parentheses, and hence the use
of ( and ) for the commands and for the default symbols.

SAIL users may find it useful to define an otherwise unused set
of symbols to mean BEGIN and END (some people already use ⊂ and
⊃ for this purpose), and to use these symbols in their stead, at
least while debugging.

Special conventions

A special convention has been adopted to avoid ambiguity for those cases
in which these commands are given while the line-editor cursor is under
one of the searched-for bracketing symbols. This convention is that a
cursor under a left-symbol is presumed to be actually to its left, that
is, outside of the symbol (as it appears) and a cursor under a
right-symbol is presumed to be actually to its right, again outside of
the symbol (and again as it appears).

Arguments, when used with these commands refer to the desired nesting
level within the region defined by the nesting pairs. If no argument is
given, the default value is 1, in accordance with the usual convention
for most E commands. As a mnemonic aid, the sought-for symbol is
reported with the argument shown after left-symbols and before
right-symbols although the argument must always be typed before the
command (to permit the command character, itself, to be used as the
activator).

By convention the starting level is always re-assigned the value 0.
Left-symbols increase the nesting level and right-symbols decrease the
level.

Typical commands

⊗4⊗( Move the cursor to that left-symbol which would cause the
nesting to reach a level of 4, considering the present cursor
position to be at level 0. Do not move the cursor if this level
is not found and report the deficiency. This request is
reported as (4 for the reasons noted above.

⊗( With no argument, this command finds the very first left-symbol.
If the cursor is already at a left-symbol this command is a
NO-OP. This is in consequence of the convention that a cursor
under a left-symbol actually refers to the situation just ahead
of the symbol.

⊗XLPAREN This is the same as ⊗( except that the search is permitted to
continue past the end of the current incore page(s).

⊗) If the cursor is already positioned under a left-symbol, move
the cursor to the matching right-symbol. If the cursor is not
under a left-symbol, then search for that right-symbol that
returns the nesting level to its initial value of 0. Should the
cursor be under a right-symbol, the initial level is taken to be
that at its right. Note that this command is a NO-OP only for
the case where the desired level cannot be found. This request
is reported as 1).

If the end of the text is reached before a transition from level 1 to
level 0 is found, the cursor is left in its original position and the
deficiency is reported along with the other data. Deficiencies, in this
case can be of two sorts, either a level of 1 is never reached or having
been reached and possibly exceeded as a result of left-symbols, a
right-symbol is never encountered while at this level. In the first
case, the deficiency figure is reported following a down arrow (meaning
always below).

⊗XRPAREN This is the same as ⊗) except that the search is permitted to
continue past the end of the current incore page(s).

⊗3⊗) Search through the text as just described but stop at the first
right-symbol that reduces the nesting-level from the specified
level, in this case 3. This request is reported as 3).

Interpretation when the same character is used for both symbols:

Both the ( and the ) command, in this case, ignore the symbol that is
above the cursor at the time the command is given and search for the Nth
next example of the specified symbol, where N is the argument that is
used with the command. The ( command is not a NO-OP in this special
case.

INFORMATION ABOUT PARENTHESIS SEARCHES

In the Terse or normal reporting states, E does not type out all the
possible information when a parenthesis search is done. To find out
all this information, use the following command, or be in Verbose
mode when the search is done.

⊗XPINFO Type out information about the last parenthesis
search done.

Swapping To and From E via RPG startups: ⊗XRSYS ⊗XRUN ⊗XGORPG ⊗XDRD ⊗XTV

Modes Command Meaning
N DIRED Swap to the DIRED directory editor
N DRD Swap to the DIRED directory editor
N GORPG Swap to SNAIL (RPG) to reexecute last cmd
N,A,E RSYS Run a given system program, with RPG startup
N,A,E RUN Run a given user program, with RPG startup

A user program can start up E and have it automatically edit a
particular file at a specific place, with the capability of returning to
the original program or to any other particular program. Furthermore, E
has commands that cause it to swap to certain system programs or to any
named system or user program.

In each of these cases, whether coming from E or going to E, the new
program is started up at the so-called "RPG startup address", namely, at
1 beyond the normal starting address. This is usually done with the
SWAP UUO by specifying a starting-address increment of 1.

The commands to start up another program from E are listed below.
Each of these first puts down any attach buffer and writes out to the
disk any changes on the page before swapping to another program.

⊗XRSYS <program> This runs the given system program (device SYS:)
with an RPG startup. See also next paragraph.

⊗XRUN <program> This runs the given user program (device DSK:)
with an RPG startup. See also next paragraph.

⊗XGORPG This runs the system program SNAIL (formerly RPG)
with an RPG startup.

⊗XDRD Either of these runs the system program DIRED
or with an RPG startup.
⊗XDIRED

If the <program> is omitted from the ⊗XRSYS or ⊗XRUN command, and if E was
originally run with an RPG startup, then the program run by the command
will be the program whose name was in ACs 0-3 when E was started up (see
below for the AC contents expected by E on an RPG startup). Thus a
program that wishes to swap to E and to have E swap back to it can set up
the ACs as described below and swap to E using the RPG startup (starting
address plus 1).

When E is run via an RPG startup, it expects certain data to be in the ACs
(placed there before the SWAP was done). When E starts up another program
via the ⊗XRSYS or ⊗XRUN command, it leaves this same data in the ACs.
This data is listed in the table below. (RH means "right half" of the
AC, and LH means "left half".)

AC Data in AC upon RPG startup (starting address + 1)

0 Name of program file
1 LH Extension of program file
2
3 PPN of program file
4
5
6 Device of program file
7
10
11 PPN of edit file
12 Device of edit file or zero for DSK:
13 LH Extension of edit file
RH Mode bits (see below)
14 Name of edit file
15 LH Attached-line count+400000, or column position within line, or zero
RH Line number in edit file
16 Page number in edit file
17

Coming from E (⊗XRSYS or ⊗XRUN), ACs 0-6 will contain the name of the
program that E is swapping to, and ACs 11-16 will contain the name of the
edit file that was being edited by E.

In swapping to E, ACs 0-6 contain the name of the program that E should
swap back to upon an ⊗XRSYS or ⊗XRUN command given without a program name,
and ACs 11-16 contain the name of the file E should edit. If AC 14 (name
of edit file) contains zero, E will read the name and starting page and
line of the edit file from the normal editor TMPCOR file (ED), and the
TMPCOR file will be updated upon exit. Otherwise, the TMPCOR file is
neither read nor written for an RPG startup.

The mode bits in the right half of AC 13 are:

Bit Octal Meaning

18 400000 Create this file.
19 200000 Edit in readonly mode (/R).
20 100000 Edit in no-directory mode (/N).

Message and paragraph handling commands: ⊗∂<cmd> ⊗0⊗∂ ⊗!<cmd> ⊗0⊗!

Modes Command Meaning
N,A,E ⊗∂ Operate on message with next cmd
N,A,E ⊗! Operate on paragraph with next cmd

MESSAGE HANDLING COMMANDS: α∂ and αβ∂

The partial-sign (∂) command is designed for easy handling of
messages in mail files, but it can be used on any file regardless of
whether the file contains mail-like messages. For instance, this
command is capable of attaching (or deleting) a whole page of text at
once and simultaneously deleting the (not in core) pagemark for that page.

The α∂ and αβ∂ commands are search commands used to find the beginnings of
"messages." A message is defined as the largest contiguous set of lines
of which only the first starts with a partial-sign (∂) and the last of
which is followed either by another line starting with partial-sign or by
the end of the page. The current message is defined as the message
containing the current line (the arrow line). If the arrow is on the row
of stars that marks the end of the page, then the current message is the
one that contains the last real line of the page.

The only difference between α∂ and αβ∂ is that the αβ∂ version considers
the current line to be the beginning of a message, even if the line
doesn't start with a "∂". Thus the α∂ version works on the whole real
current message, whereas the αβ∂ version works on only that part of the
message from the current line forward.

Messages are never considered to extend across page boundaries. If
neither the current line nor any of the lines preceding it on the
current page starts with a partial-sign, then the current "message"
starts with the first line of the current page. If none of the lines
(on the current page) below the current line starts with a
partial-sign, then the last line of the current "message" is the last
line on the page. Thus, if there are no lines on the current page
that start with ∂, then the current "message" is the whole page.

Like the ⊗F commands, the ⊗∂ commands require a following command before
any action is taken (with one exception, which is noted below). However,
the ⊗∂ commands do not accept a search string before the second command;
⊗∂ always searches for lines beginning with a partial-sign. If the
command following is one of the special commands that use the number of
lines searched (for instance, by the ⊗F command) as the argument to the
command, then that command will be carried out for the entire current
message. If the command is not one of these special ones, then it will be
executed at the beginning of the next message. The special commands that
use the number of lines searched as the command argument are indicated in
the index on p. 3 by the letter "S" in the modes column.

The ⊗∂ commands may be preceded by a numeric argument which specifies
the number of messages (starting with the current one) which the
command is to affect. If that number is negative, then the messages
just before the current one are the ones effected, with the absolute
value of the argument specifying how many messages. Note that ⊗-αβ∂
considers the current line to start a message, and so it will work on
the message text immediately before the current line.

N.B.: A zero argument to the ⊗∂ commands means move to the beginning
of the current message WITHOUT WAITING FOR A SECOND COMMAND. This is
the only case where a second command is not used by the ⊗∂ command.

!!!!! SPECIAL FEATURE OF THE PARTIAL-SIGN COMMAND !!!!! N.B.: If the
partial-sign command is used with ⊗A (attach) or αβD (delete) to attach
or delete all of the incore text, then the pagemark for that text will
also be deleted. In particular, if the current page is not the last
page in the file, then the following pagemark will be deleted, leaving
you at the top of that page; if the current page is the last page in the
file, then the preceding pagemark will be deleted and you will be left
at the bottom of the previous page. No pagemark deleting will be done
if the file has only one page besides the directory, but in this case,
if the file is a message file (extension .MSG) on [2,2], then a flag is
set which will cause the file to be deleted (since there is no text in
it) when you leave it unless you do something to change the file (add
text or pages) before then. And note that the page deleting only
happens when the entire incore text is either deleted or attached using
the partial-sign command! Note that since the partial-sign command will
not cross an incore pagemark, this feature cannot apply when you have
two or more pages in core.

If there are already some lines in the attach buffer at the time you
give an ⊗∂⊗A command, the new messages being attached are added at
the end of the attach buffer. If you give a ⊗-⊗∂⊗A command when
there are already lines in the attach buffer, the new messages being
attached are inserted at the beginning of the attach buffer, ahead of
the text already there.

Here are some example uses of the partial-sign command. The ones marked
with an asterisk (*) all involve either αβD or ⊗A and will delete a
pagemark in addition to the action noted if the action results in
deleting or attaching all the incore text, unless the current page is
the only page (besides any directory) in the file.

α∂αβD ;* Deletes the current message.
α∂⊗A ;* Attaches the current message.
α∂⊗C ;Copies the current message into the attach buffer.

⊗0⊗∂ ;Moves to beginning of current message.
⊗∂<cr> ;Moves to beginning of next message.
⊗-α∂<cr> ;Moves to beginning of previous message.

⊗∂<bs> ;Moves to end of current message.
⊗∂⊗J ;Moves to beginning of next message and jumps screen up.
⊗∂αβ<cr> ;Enters LINE INSERT mode between the end of the
;current message and the beginning of the next one.

⊗3α∂αβD ;* Deletes three messages starting with the current one.
⊗3α∂⊗A ;* Attaches three messages starting with the current one.
⊗3α∂⊗C ;Copies three messages starting with the current one.

⊗-⊗2α∂αβD ;Deletes the two messages preceding the current one.
⊗-⊗2α∂⊗A ;Attaches the two messages preceding the current one.
⊗-⊗2α∂⊗C ;Copies the two messages preceding the current one.

αβ∂⊗XTYPE<cr> ;Types out text from current line to end of message
αβ∂⊗XJUST<cr> ;Justifies text from current line to end of message
αβ∂⊗D ;Deletes text from current line to end of message

⊗-αβ∂⊗XTYPE<cr> ;Types out text from beginning of message thru line
; just before current arrow.

PARAGRAPH HANDLING COMMAND: α! and αβ!

The exclamation-point (!) command operates on PARAGRAPHS in the same way
that the partial-sign (∂) command operates on messages. Thus α! works on
the whole current paragraph, and αβ! interprets the current line to be the
beginning of a paragraph and therefore effectively works on only the part
of the current paragraph from the current line on.

However, UNLIKE the ⊗∂ command, the ⊗! command never deletes a pagemark.

NOTE: "PARAGRAPH" here means a contiguous group of non-empty lines
plus certain surrounding empty lines (if any). Included in the
paragraph of the ! command are: one empty line (if any) at the
beginning of the paragraph and all but one of any empty lines at the
end of the paragraph. However, if the last line of a page is blank,
it is considered part of the paragraph containing the previous line.

The two commands ! and ∂ don't actually do anything until you type another
command. If that following command accepts a search distance argument,
then the effective argument will be the number of lines in the current
paragraph (! command) or message (∂ command); for example, α!⊗XJUST<cr>
will justify the current "paragraph" and αβ!⊗XJUST<cr> will justify lines
from the current line to the first blank line following. If the command
that follows ⊗! or ⊗∂ does NOT accept a search distance argument, then
that command is carried out after moving to the beginning of the next
paragraph (!) or message (∂). The one case in which the ! and ∂ commands
don't take a following command is when a preceding zero argument has been
supplied (that is, ⊗0⊗! or ⊗0⊗∂), in which case the command immediately
moves to the beginning of the current paragraph (!) or message (∂).
Macros: ⊗XDEFINE ⊗Z ⊗Y ⊗≡ ⊗∩ ⊗∪ ⊗⊂ ⊗⊃ ⊗$ ⊗% ⊗~ ⊗_ ⊗XCASE ⊗XRESUME ⊗XABORT ⊗# ⊗XSTOPALL ⊗XSTOPONE ⊗XSTOPZERO ⊗XSTOPHOW ⊗XSILENT ⊗XRAPID ⊗XMALTMODE ⊗XPRINT ⊗XYSET ⊗XRAPID ⊗XLETEST
(See following three pages for more about macros.)

Modes Command Meaning
<ESC>I Terminate macro expansion
N,A,E ⊗Y Call current macro
N,A,E ⊗Z Call a named macro
N,A,E ⊗# (Actually the "#" char) Pass macro call arg to next cmd
N,A,E ⊗≡ Call the macro named "≡"
N,A,E ⊗∩ Call the macro named "∩"
N,A,E ⊗∪ Call the macro named "∪"
N,A,E ⊗⊂ Call the macro named "⊂"
N,A,E ⊗⊃ Call the macro named "⊃"
N,A,E ⊗$ Call the macro named "$"
N,A,E ⊗% Call the macro named "%"
N,A,E ⊗~ Call the macro named "~"
N,A,E ⊗_ Call the macro named "_"
N,A,E ABORT Abort one or more macro levels in progress
N,A,E CASE Select and call a macro from a list of macro names
N,A DEFINE Define a macro
N,A LETEST Generate macro error if line too long to edit
N,A,E MALTMODE Enable/disable altmode insertion at end of macro
N,A,E PRINT Print the current line(s) on the terminal
N,A,E RAPID Enable line editor simulator for use in macros
N,A,E RESUME Resume expansion of a macro that was stopped early
N,A,E SILENT Suppress error messages while inside macros
N,A,E STOPALL Set action on macro error to stop all macros
N,A,E STOPHOW Find out setting of macro error action
N,A,E STOPONE Set action on macro error to stop just one macro
N,A,E STOPZERO Set action on macro error to ignore errors
N,A,E YSET Set the macro to be called by the ⊗Y command

DEFINING AND CALLING MACROS--MACRO NAMES

Macros are provided in E to save the user the effort of typing the same
things over and over again. A macro represents any number of characters
that should be "typed" to E as commands and text whenever that macro is
called. A macro is defined with the command

⊗XDEFINE <macro name><cr>

where <macro name> can contain letters and digits (it can even start with
a digit or contain only digits), or it can be entirely blank, or it can
consist of exactly one of the nine characters below (which characters
appear on the top of the digit keys on DD and III keyboards at SU-AI):
≡ ∩ ∪ ⊂ ⊃ $ % ~ _
Only the first six characters of a <macro name> are significant, but
beyond that a <macro name> can NEVER be abbreviated. After giving the
⊗XDEFINE command, the user types the characters (commands and/or text)
which the macro is to represent. The definition is ended by typing αβ<lf>
on displays or ↑Z on non-displays. When you end the definition, the
macro's name and definition will be typed out unless the definition was
made during macro expansion (i.e., by another macro).

A macro can be called by either

⊗Z<macro name><cr>
or
⊗Y

where the latter calls the last macro either defined or called by the user
(i.e., not just defined or called from within another macro), except that
a macro whose name is one of the nine special characters (≡∩∪⊂⊃$%~_) can
NEVER be called with the ⊗Y command. These nine macros, however, can
ALWAYS be called with the corresponding one of the nine single-character
commands

⊗≡ ⊗∩ ⊗∪ ⊗⊂ ⊗⊃ ⊗$ ⊗% ⊗~ ⊗_

Each of the macro-calling commands causes the macro definition to be
expanded by treating the commands and text of the definition as if they
were being typed in by the user. The ⊗Y command allows the user to
repeatedly call the same macro with a single keystroke each time, but
only until the user either calls (with ⊗Z) or defines another macro.
Named macros and the ⊗Z command allow the user to define and use as many
macros as he wants.

While macro expansion is in progress, there are no prompts given (like
"Command?"), "OK" is never typed out, and the display is not updated.
However, the ⊗V command given inside a macro causes the display to be
updated immediately. Thus you can put ⊗V commands into a macro definition
to let you watch the progress of the macro. Also, you can have a macro
pause for # seconds by putting ⊗#⊗V into the macro at the desired
place(s).

SELECTIVE MACRO CALLING

The following command can be used to select and call one macro from a
list. In this case the repeat argument to the command determines which of
several possible macros is to be called. This command is normally used
inside a macro that might want to call some other macro(s).

⊗#⊗XCASE <macro name> <macro name> ... <macro name><cr>

This command executes the #th macro in the list of macro names, where the
counting of # starts at zero (0); the selected macro is executed with a
repeat arg of 1. For instance, ⊗2⊗XCASE A B C D<cr> will execute macro C.
The macro names should be separated with spaces. No macro name in the
middle can be omitted, and the null (blank) macro name cannot be used
here; however, any non-blank names can be supplied, since E does not check
that all such names represent currently defined macros. If the repeat arg
given to ⊗XCASE is negative, then the command will be aborted. Since the
extended command line is buffered in E, and since the buffer has a fixed
size, there is an effective limit to the number of macro names that can be
listed in the command line; the current maximum command line length is
about 119 characters -- characters beyond that are ignored. An error will
occur if there are not enough macro names in the command for the given
repeat arg.

MACRO EXPANSION ENDING -- ALTMODE INSERTED

When all macro expansion is terminated for any reason, an ALTMODE
character is used as the next input character to force completion of any
partially-typed command. However, there are two major exceptions to this
rule.

(1) If the macro expansion runs to completion and the effect of the last
characters in the macro is to leave a line of text (from the file) in
the line editor, then the normally-inserted ALTMODE is omitted and the
text is left in the line editor.

(2) If the command ⊗-⊗XMALTMODE is given inside a macro, then when macro
expansion finishes normally (finishing the top-level macro), no altmode
will be inserted. The command ⊗XMALTMODE restores the default mode
(enables altmode insertion), and ⊗0⊗XMALTMODE reports the current state
state. Calling a top level macro resets this mode to the default, so
⊗-⊗XMALTMODE doesn't have much effect when used outside of a macro.
This command is especially useful if your macro ends with the ⊗XEVAL or
⊗XSUBLINK command, but it can also be useful if the macro ends with any
partially entered command, like ⊗F.

ITERATIVE AND RECURSIVE MACRO EXPANSION

Iteration: A positive repeat argument on a macro call will cause the
macro to be expanded a number of times. For example,

⊗3⊗Z<macro name><cr>
or
⊗3⊗Y

will cause the macro to be expanded three times. Negative arguments to
macro calls are reserved for future use, although they currently result
in making a macro call a no-op. A zero argument will cause the macro
name and definition to be typed out, as explained below.

Recursion: A macro can call other macros or even itself. When a called
macro finishes, control returns to the calling macro, which then continues
its own expansion. A pushdown stack is used to keep track of the macro
calls (expansions) currently in progress. This macro stack currently has a
length of about 48, thus allowing nested macro calls up to that depth. Any
attempt to call a macro beyond that depth will immediately terminate all
macros in progress; however, ⊗XRESUME (see below) can be used to continue
macro expansion by skipping the macro call that caused the overflow.

FINDING OUT MACRO NAMES AND DEFINITIONS--STANDARD REPRESENTATION OF DEFINITIONS

Arguments of zero are used to have macros and their definitions typed
out. The command

⊗0⊗XDEFINE<cr>

will type out the names of all defined macros. A zero argument to a
macro call will simply cause the macro's name and definition to be typed
out; that is, use

⊗0⊗Z<macro name><cr>
or
⊗0⊗Y
or
⊗0⊗≡ ⊗0⊗∩ ⊗0⊗∪ ⊗0⊗⊂ ⊗0⊗⊃ ⊗0⊗$ ⊗0⊗% ⊗0⊗~ ⊗0⊗_

with the second form also being useful for finding out which macro the
next ⊗Y command would call.

Macro definitions are always typed out using a text representation which
allows for the CONTROL and META bits and non-printing characters (such
as formfeed). This same representation is used when reading or writing
macro definitions from or to the incore page and command files--see p. 27
for those commands.

Actually, there are two representations available, the standard
representation and the alternate representation. The standard version
is always used for typing out definitions, but either or both can be
used when reading definitions from the incore page or from a command
file. These representations involve three special escape characters and
several ignored characters. The characters ignored are

TAB,ALT,CR,LF,BS,VT, and FF.

The three escape characters are

"⊗", "α" and "β".

To represent any of the seven ignored characters or any of the three
escape characters, two characters are used, namely, the character "⊗"
(circle-x) followed by a character specifying which special character
you want. These representations are listed in the table below.

The character alpha (α) causes the next command to have the CONTROL bit
added. The character beta (β) causes the next command to have the META
bit added. Thus "αβV" represents CONTROL-META-V.

Representations Corresponding commands to E
Standard Alternate
⊗⊗ ⊗⊗ ⊗ circle-x
⊗; ⊗; Ignore text from here to end of line (to CR, LF or FF).
⊗⊂ ⊗⊂ Ignore text from here to first right-horseshoe (⊃).
⊗= ⊗T TAB horizontal tab
⊗≠ ⊗A ALT altmode
⊗↔ ⊗C CR carriage return
⊗↓ ⊗L LF linefeed
⊗↑ ⊗B BS backspace
⊗← ⊗V VT vertical tab
⊗→ ⊗F FF formfeed
⊗α ⊗X α alpha
⊗β ⊗Y β beta
α ⊗1 Add CONTROL bit to next command
β ⊗2 Add META bit to next command

For example, CONTROL-META-LINEFEED is represented by "αβ⊗↓" or "αβ⊗L" or
"αβ⊗l". The case of a letter following "⊗" is irrelevant, but
otherwise, if a "⊗" is followed by a character other than those listed
above, an error will result and the command will not be completed.

The escape sequences ⊗; and ⊗⊂ are useful for putting comments into E
command files (e.g., EINIT.CMD) without having the comments taken as part
of the commands to be executed. The form ⊗; allows you to put a comment
at the end of a line, and the form ⊗⊂ allows you to have partial-line or
multi-line comments. The ⊗XCOMMENT command can also be used for comments,
but it is actually stored (e.g., in macro definitions) and executed, so it
can only occur where a normal command can occur; furthermore its use
should be avoided inside a macro definition, since it needlessly increases
the size of the macro and slows it down a little. Note that since TABs
are ignored, you can use them to set off comments or actual commands from
other text in a command file.

Note: These representations are NOT usable in the ⊗XDEFINE command when
defining a macro from the terminal. Definitions typed in from the
terminal are entered verbatim--no character conversion.

THE ⊗Y COMMAND FOR CALLING MACROS

As mentioned above, the ⊗Y command is used to call the last macro defined
or called by the user (not counting the macros ⊗≡ ⊗∩ ⊗∪ ⊗⊂ ⊗⊃ ⊗$ ⊗% ⊗~ ⊗_
which can always be called with their own single character commands).

However, the macro that will be called by ⊗Y can be explicitly specified by
using the command ⊗XYSET <macro name>, without actually defining or calling
that macro. For example, ⊗XYSET START<cr> would cause subsequent ⊗Y
commands to call the macro START. Thus ⊗Y will actually call the last
macro either (1) defined by the user, (2) called by the user via ⊗Z<macro>
or (3) named in an ⊗XYSET command. Note that the latter has this effect
(setting which macro is called by ⊗Y) even when executed inside a macro,
whereas (1) and (2) do not have this effect from inside a macro. ⊗0⊗XYSET
types the name of the macro that ⊗Y currently would call (no macro name
argument is used with a zero repeat argument, and, unlike the ⊗0⊗Y command,
no macro definition is typed out).

UNDEFINING MACROS

A macro can be undefined by giving the ⊗XDEFINE command with a negative
argument. Thus the command

⊗-⊗XDEFINE <macro name><cr>

makes E completely forget about the named macro.

ERRORS DURING MACRO EXPANSION

The user can select the action to be taken when an error ("SORRY --
...") occurs inside a macro. The default action is to stop all macro
expansion, but the user can give any of three extended commands to
select the current error action from three possibilities.

⊗XSTOPALL On error, stop all macro expansion. This is the default.

⊗XSTOPONE On error, stop the current macro and return control to any
higher level calling macro as if the current macro had
finished.

⊗XSTOPZERO On error, ignore the error and let macro expansion continue.

There is one additional extended command to find out what the currently
selected error action is.

⊗XSTOPHOW Report which of the above three actions is currently selected.

Also, any argument given with any of the three previous commands will
suppress selecting an action, but will report the current error action.

When E needs an answer to a Yes or No question while processing some
command, it will get the answer FROM THE USER'S TERMINAL, NEVER FROM A
MACRO DEFINITION. Unless the answer is Yes, macro expansion is treated
as if a command error had occurred, and the current error action is
taken.

Certain errors that E detects always cause stopping of all macros in
progress, regardless of the current STOPxxx setting. These errors are
never expected to occur deliberately inside macros, and so they stop all
macro execution as an aid to macro debugging and as a safety feature. The
current such permanent-STOPALL errors for macro execution are:

Unrecognized command character
Ambiguous (extended) command
Unknown (extended) command
Syntax error in extended command line
Can't exit while expanding a macro
Command illegal from line editor here
Macro pushdown list overflow
(Syntax error in LISPSYNTAX command)
Cannot execute a readonly variable
Invalid macro name
Attempt to write out text that cannot be written out (from
directory page, unformatted file, or /B mode)
Macro text for line editor is too long
No such readonly variable
Line too long, prints nn columns

Note that for the error involving text too long for the line editor, E's
line editor buffer is considerably bigger than the real line editor's
buffer, so it is still possible to lose some text (without stopping any
macro) if a macro's line editor text is slightly too long for the line
editor.

The ⊗XSILENT command suppresses error messages that are generated inside
macros except when such an error would stop all macros. Thus SILENT mode
can be used to speed up execution (by suppressing the error typeout) in
macros that deliberately cause errors to happen in order to abort one
level of macro execution (in ⊗XSTOPONE mode). The command ⊗-⊗XSILENT
disables this mode. The commands ⊗0⊗XSILENT, ⊗0⊗XVERBOSE, and ⊗0⊗XTERSE
all type out the status of SILENT mode (when enabled) in addition to the
status of the TERSE/NORMAL/VERBOSE mode.

ABORTING AND RESUMING MACRO EXPANSION

Four ESCAPE commands are available for interrupting macro expansion.
These are ESC I, ESC 1 I, BRK I, and BRK 1 I. Two of these, ESC 1 I and
BRK 1 I, affect only macro expansion. ESC I and BRK I interrupt macro
expansion as well as other E processes, such as multipage searches.
Thus ESC 1 I or BRK 1 I can used when you want to stop a macro but don't
want to interrupt a search in progress.

Typing BRK I or BRK 1 I will terminate the current macro and return
control to any higher level calling macro.

Typing ESC I or ESC 1 I will terminate all macro expansion. When this
mechanism is used to stop macro expansion, the user can have the
expansion resumed where it left off by giving the command ⊗XRESUME.

The ⊗XABORT command can be used to explicitly abort any number of levels
of macro expansion by popping a number of calls off the macro stack.
This command can be included in a macro definition to automatically end
one or more macro calls, or it can be given from the terminal to cause
the next ⊗XRESUME command to resume macro expansion one or more levels
up from the current macro stack location. When given WITHOUT an
argument, ⊗XABORT stops all macro expansion--this form is meaningless
except inside a macro. The ⊗#⊗XABORT command WITH an argument pops the
specified number (#) of macro calls off the macro stack (whether the
macro stack is actively being used or just being maintained for a later
⊗XRESUME).

Whenever all macros have been aborted before completion, the command

⊗XRESUME<cr>

will resume macro expansion where it left off. Also, the command

⊗#⊗XRESUME<cr>

can be given with a decimal argument (#) to find out what macros are in
progress and what text and repeat arguments remain to be processed. An
argument of ⊗# finds the element which is # calls from the top of the
macro stack and types out the remaining repeat count, the macro call
level, the name, and the remaining text of that macro call. Thus ⊗0 types
the top of the stack, ⊗1 types the next element on the stack, etc.

PASSING REPEAT ARGUMENTS TO COMMANDS INSIDE MACROS: THE ⊗# COMMAND

The number-sign command, ⊗#, allows one or more commands inside a macro
to access and use the repeat argument given to a macro call. (In this
paragraph and the table below, "#" represents the number-sign character
itself, NOT an arbitrary number.) Inside a macro, each occurrence of
the ⊗# command passes the macro call's argument to the next command and
inhibits the repeated expansion of the macro (clearing the effective
repeat count of the macro call). The actual argument passed to the
command following the ⊗# depends on the arguments given to (1) the macro
call and (2) the ⊗# command itself. In the simplest case, if one of
these two arguments is omitted, the other is used. If the argument to
⊗# is relative (preceded with ⊗+ or ⊗-), then the two (signed) arguments
are added together. The following table shows the resulting argument as
a function of the two "input" arguments, with examples given in
parentheses. Note that the macro call argument (if any) is always
positive; however, the ⊗# command can be followed by ⊗- to invert the
sign of the resulting argument. Outside of macro expansion, the ⊗#
command is treated as if you had NOT typed it!

Arg to Arg to Resulting arg passed
macro call ⊗# command to command following ⊗#
------------ ------------- -------------------------
none anything Arg to ⊗# command
(none) (⊗-⊗2) (⊗-⊗2)

relative none Arg to macro call
or absolute or absolute
(⊗+⊗5) (none) (⊗+⊗5)
(⊗5) (⊗2) (⊗5)

relative relative Relative sum of the two arguments
(⊗+⊗5) (⊗-⊗2) (⊗+⊗3)

absolute relative Absolute sum of the two arguments,
except negative sum is relative
(⊗5) (⊗+⊗2) (⊗7)
(⊗5) (⊗-⊗7) (⊗-⊗2)

REQUESTING/SUPPRESSING INFORMATIONAL MESSAGES: ⊗XVERBOSE AND ⊗XTERSE

Certain informational messages will be either typed out or suppressed
depending on the reporting state that E is in: Terse, Normal, or
Verbose. The reporting state can be set with the ⊗XVERBOSE and ⊗XTERSE
commands, which are described elsewhere. The Verbose state is useful
during debugging of macros that call other macros.

The following messages are typed out only in Verbose mode.

Calling ... ;A macro is being called.
Ending ... ;A macro call has just finished.

The following messages are suppressed only in Terse mode.

Aborting macro ... ;An error has caused aborting of one
; macro call while in ⊗XSTOPONE mode.
Abort of # macros requested from ...
;A ⊗#⊗XABORT command has been given.

FORMAT OF NAME TYPEOUT FOR MACRO CALL

When a macro call is mentioned in an error or informational message, the
form typed out is usually

[nX](m)macname

where n is the remaining repeat count for this macro call, m is the
level of this macro call, and macname is the name of the macro. The
form [nX] will be omitted if n is 1. A level (m) of 1 represents the
bottom of the macro stack, that is, the level called from the terminal.
Note that macname might be blank, since the blank macro name is
perfectly legal.

LINE EDITING IN MACROS: Beware of αD and αI; test length with ⊗XLETEST

Line editor commands may be used inside macros, and they will have their
normal effects except that the αD command, when intended to delete the
CRLF at the end of a line (thus joining two lines), MUST be preceded in
the macro definition either with α<tab> or with αK<cr> so that E will be
sure that the αD will be given at the end of the line. The effect of a
bad use of αD is that characters after the αD in the macro definition
up through the first activation character following are not "typed"
until the macro expansion ends, which can be particularly noticeable if
you use a repeat argument on the macro call.

The above rule about αD also applies to αI, which also should be preceded
by α<tab> when intended to be given at the end of the line editor in a
macro.

The ⊗XLETEST command (stands for Line Editor TEST) is used to tell if the
current line would be too long to edit with the line editor. This command
does nothing unless the line is too long, in which case it generates a
macro error (normal non-fatal kind). This command is provided for use in
macros, since attempting to enter the line editor (e.g., with a line
editor command) on a line that is too long results in a permanent STOP-ALL
macro error. With this command, macros can avoid such a fatal error.

LINE EDITOR SIMULATOR FOR MACROS: ⊗XRAPID

In order to reduce execution time for macros that use the line editor, E
uses a line editor simulator whenever possible during macro expansion.
This means that E itself handles certain line editor functions (see
limitations below) to avoid the time-consuming process of shipping text
and commands to and from the line editor. This should not effect the
results of any macro, but it can speed up certain types of macros by a
factor of 10.

Macros that do not use the line editor are not affected by the existence
of the simulator.

The line editor simulator is fairly primitive in that it can only do a
limited number of line editor operations, but when the simulator cannot
handle a line editor command, the real line editor is used instead. Thus
macros will work the same with or without the simulator, but execution
time will be reduced if the simulator can handle all the line editor
operations in a given sequence. Since the simulator avoids doing any UUOs
that invoke the real line editor, line editor simulation is up to 10 times
as fast as real line editor use.

The line editor simulator in E handles almost all commands that do not
change the number of characters in the line. This includes all cursor
movement commands plus most attempts to overtype characters in the line.
E does NOT handle the following cases: (1) typing over a tab or typing a
tab (because of the variable width of tabs) and (2) insertions and
deletions. Any time a macro attempts a line editor function that the
simulator cannot handle, E gives the text and commands to the line editor
to let it carry out the editing on that line (thus ensuring that the
commands get the right result).

Between the time that any new feature gets added to the real line editor
and the time the same feature gets programmed into E's simulator, it is
possible that the simulator will give incorrect results. Therefore the
simulator can be disabled and re-enabled with the commands shown below.
(Of course, it is fairly rare that new features are added to the line
editor.)

⊗-⊗XRAPID Disable the line editor simulator which is
normally used during macro expansion.

⊗XRAPID Enable the line editor simulator. This is
the default.

⊗0⊗XRAPID Report whether the line editor simulator
is enabled or disabled.

As the command name suggests, macros involving line editor commands will
usually execute more RAPIDly when the simulator is enabled.

PRINTING CLEAN LINES OF TEXT FROM A MACRO

The command ⊗#⊗XPRINT types out # lines of text (without any page numbers
and with or without line numbers as controlled by the ⊗XNUMBERS command);
after typing out the text of the line(s), this command moves down to the
line beyond those typed (on non-displays, this new current line may be
typed out as a consequence of being the new current line). The default
argument to ⊗XPRINT is ⊗1 (on both displays and non-displays). This
command is designed for use in macros, so it avoids typing any leading
carriage return and it avoids saying OK; it is also generally useful from
a display to see a long line's text. For typing out text normally on a
non-display the ⊗XTYPE command is recommended instead of ⊗XPRINT.

EXITING NOT ALLOWED DURING MACRO EXPANSION

The normal command used to exit from E (namely, ⊗E) is not legal coming
from a macro expansion. This is disallowed to prevent accidental exiting
while using attach mode inside macros, since the command to put down the
attach buffer is the same as that to exit, ⊗E. You can, however, exit
from E during macro expansion by using the ⊗XEXIT command (see p. 39).

*** MORE COMMANDS RELEVANT TO MACROS ARE EXPLAINED ON THE NEXT 3 PAGES. ***

Numeric Macros and Readonly Variables: ⊗XSET ⊗XARGUMENT ⊗XMULTIPLY ⊗XDIVIDE ⊗XREMAINDER ⊗XADD ⊗XSUBTRACT ⊗XMINIMUM ⊗XMAXIMUM ⊗XIFLT ⊗XIFLE ⊗XIFGE ⊗XIFGT ⊗XIFEQ ⊗XIFNE ⊗XCHARACTER
(See previous page and following two pages for more on macros.)

Modes Command Meaning
N,A,E ADD Add given repeat arg to macro's value
N,A,E ARGUMENT Set up repeat argument from value of numeric macro
N,A,E CHARACTER Generate the next command character from numeric value
N,A,E DIVIDE Divide macro's numeric value by given repeat arg
N,A,E IFEQ Error unless repeat arg = macro value
N,A,E IFGE Error unless repeat arg ≥ macro value
N,A,E IFGT Error unless repeat arg > macro value
N,A,E IFLE Error unless repeat arg ≤ macro value
N,A,E IFLT Error unless repeat arg < macro value
N,A,E IFNE Error unless repeat arg ≠ macro value
N,A,E MAXIMUM Set macro's value to MAX(<old value>,<repeat arg>)
N,A,E MINIMUM Set macro's value to MIN(<old value>,<repeat arg>)
N,A,E MULTIPLY Multiply macro's numeric value by given repeat arg
N,A,E REMAINDER Set macro to remainder of <old value> / <repeat arg>
N,A,E,S SET Set the value of a numeric macro
N,A,E SUBTRACT Subtract given repeat arg from macro's value

INTEGER-VALUED NUMERIC MACROS

For doing arithmetic operations and applying their results to various
commands in E, there are numeric macros and readonly variables.

A numeric macro is any macro that starts with an (optionally signed)
string of digits. The numeric value of such a macro is just the decimal
interpretation of the (signed) string of digits. Numeric macros can be
defined, redefined, executed, etc., just like other macros. However,
there are some special commands to create, operate on, and test numeric
macros (for arithmetic manipulations) and for applying a numeric macro's
value as the repeat argument to an arbitrary command.

A readonly variable can be used in place of a numeric macro in commands
that test or apply the value of the macro or variable. Readonly variables
provide access to current parameters in the state of the edit, such as the
current line number or the current page number. As the name implies, a
readonly variable cannot have its value explicitly set by the user
(although its values will change implicitly as the user edits a file).
The current list of readonly variables is given a little ways below.
Note that each readonly variable name ends with a period (.), to prevent
any ambiguity with macro names.

The only operational difference between numeric and non-numeric macros is
that evaluating (not to be confused with executing) a non-numeric macro
will result in an error. When a macro is being evaluated for its numeric
value, an error will result if the macro definition doesn't start with a
string of digits (optionally preceded by + or -); the evaluation is
terminated by any non-digit (not including a leading + or -). The maximum
absolute value that can be generated without error during evaluation of a
numeric macro is 2↑35 - 1. Larger numeric values will give undefined
results. The largest possible absolute value of the repeat argument for
any command, however, is 2↑17 - 8; larger repeat arguments will be limited
to this maximum absolute value (with proper sign preserved). This limits
the calculations that can be done, since most operations are done using a
repeat argument.

The CONTROL and META bits are ignored when evaluating a numeric macro and
are left OFF when E generates a numeric macro.

Here are some commands that use numeric macros and/or readonly variables.

⊗XARGUMENT <macro> Sets up a repeat argument for the following
command from the named numeric macro. Any arg
given to the ⊗XARGUMENT command itself is added to
the value from the macro before setting the
resultant argument. If the macro's definition
starts with "+", the resultant argument will be
relative, as if ⊗+ were typed. The largest
possible absolute value of the repeat argument is
2↑17 - 8; larger repeat arguments will be limited
to this maximum absolute value (with proper sign
preserved). For example,
⊗XARGUMENT PAGES.<cr>αP
will go to the last page of the current file.
(Note that PAGES. is a readonly variable, not a
macro; readonly variables are explained later.
Note also that following a filename with the /E
switch is a better way to get to the end of a file
if you are already switching files.)

⊗XSET <macro> Sets the named macro to the string of decimal
digits (possibly preceded by + or -) that
represents the command's numeric repeat argument.
This command accepts a search distance as the
repeat argument.

⊗XSET <macro1> ← <macro2>
Copies the definition of <macro2> into <macro1>.
The FIRST macro name CANNOT be blank when this
form of ⊗XSET is used, but the SECOND name CAN be
blank (meaning the blank-named macro). The second
name can be that of a readonly variable (ending
with "."), in which case the first macro gets
defined as the string of digits that represents
the readonly variable's current decimal value.
This command is needed to copy large-valued
numeric macros, since
⊗XARGUMENT <macro2><cr>⊗XSET <macro1><cr>
will truncate <macro2>'s absolute numeric value
to 2↑17 - 8, which is the maximum legal repeat
argument. The ⊗XSET command will be aborted if E
can't figure out what you want. Equals-sign (=)
can be used in place of the left-arrow (←).

Of course, all the commands that work on macros work just as well on
numeric macros, but the following commands deserve particular mention here
since they are important in conjunction with the commands for numeric
macros.

⊗0⊗Z <macro> Types macro's definition.
⊗Z <macro> Executes the macro.
⊗-⊗XDEFINE <macro> Undefines the macro.

The following commands operate on the numeric value of a given macro. If
the macro's old value started with "+", then the new value will start with
"+" unless the new value is negative. CONTROL and META bits are ignored
in the macro's old value and are left OFF in the new value. As usual, if
no repeat argument is given, ⊗1 is assumed; thus ⊗XADD TOTAL<cr> adds 1 to
TOTAL. In the ⊗XDIVIDE and ⊗XREMAINDER commands, the remainder has the
same sign as the dividend and the quotient is not rounded.

⊗XMULTIPLY <macro> Multiply macro's numeric value by given repeat arg.
⊗XDIVIDE <macro> Divide macro's numeric value by given repeat arg.
⊗XREMAINDER <macro> Make macro's new value be the remainder from the old
value divided by the given repeat arg.
⊗XADD <macro> Add given repeat arg to the macro's value.
⊗XSUBTRACT <macro> Subtract given repeat arg from the macro's value.
⊗XMAXIMUM <macro> Set macro's value to MAX(<old value>,<repeat arg>).
⊗XMINIMUM <macro> Set macro's value to MIN(<old value>,<repeat arg>).

Each of the following "IF" commands compares the command's repeat argument
against the value of a given numeric macro. If the test proves true,
nothing happens, but if the test fails, then an error will result (which
can be used to terminate macro expansion). As usual, if the repeat
argument is omitted, ⊗1 is assumed.

⊗XIFLT <macro> Error unless repeat arg < macro value
⊗XIFLE <macro> Error unless repeat arg ≤ macro value
⊗XIFGE <macro> Error unless repeat arg ≥ macro value
⊗XIFGT <macro> Error unless repeat arg > macro value
⊗XIFEQ <macro> Error unless repeat arg = macro value
⊗XIFNE <macro> Error unless repeat arg ≠ macro value

READONLY VARIABLES

There are certain always-defined readonly variables whose values can be
accessed with most of the numeric macro handling commands. These
variables include the current page number, the current line number, the
current column position, etc. The complete list of variables is given
below (more can be added if necessary).

Here are the commands that accept either a readonly variable name or a
macro name. See the individual command descriptions for what these
commands do with the value of the variable or macro. Commands in the
second and third columns below (like ⊗XMULTIPLY) normally set (in addition
to using) a numeric macro value; when given a readonly variable name those
command merely type out the resultant value.

⊗XARGUMENT ⊗XMULTIPLY ⊗XADD ⊗XIFLT
⊗0⊗Z ⊗XDIVIDE ⊗XSUBTRACT ⊗XIFLE
⊗XREMAINDER ⊗XMAXIMUM ⊗XIFGE
⊗XMINIMUM ⊗XIFGT
⊗XIFEQ
⊗XIFNE

Here are the current readonly variables. The names of readonly variables
CANNOT be abbreviated; and they all end with dot (.) to distinguish them
from macro names (which can occur wherever readonly variable names can).
For the purpose of these variables, the current character is the first
character on a line unless the command (from the above list) was given
from the line editor, in which case the current character is the one the
cursor was under when the command was given. The variables below that are
marked with an asterisk (*) do not take into account any changes so far in
the current line if the variable is being evaluated from the line editor;
thus these variables return the value that would result if <altmode> were
typed immediately (this effect may or may not be changed). The remaining
variables return the current accurate value even when given from the line
editor.

READONLY
VARIABLE VALUE
-------- ------
LINE. Number of the current line within the current page.
* LINES. Number of lines on the current page.
PAGE. Number of the current page.
PAGES. Number of pages in the file.
COL. Number of the current column, where 0 is the left margin.
COLS. Number of columns taken up by the current line.
COLINT. The current "column of interest" for the α; and α: commands.
CHAR. Number of the current character within the current line, where
0 is the first character in a line. There is a difference
between CHAR. and COL. if and only if there are tabs ahead of
the cursor in the current line.
CHARS. Number of characters in the current line, not counting the
CRLF at the end of the line. This value will be 0 if the
current line is empty and -2 if the current "line" is the end
of a page.
CORLIN. Number of the current line among all incore text.
* CORLNS. Number of lines of incore text (including incore pagemarks).
* CORCHS. Number of characters of space taken up by the incore text, not
counting nulls at the end of the final incore page.
* ROOM. Number of additional characters there is room for among the
incore text before expanding ("X") the page(s) is needed. The
sum of CORCHS. and ROOM. is the amount of disk space, in
characters, currently allocated to the incore text.
CORBEG. Number of the first incore page.
COREND. Number of the last incore page.
ASCII. Ascii character code for the current character. This will be
13 (decimal code for <cr>) if the current line is empty or if
the cursor is positioned at the end of the line. This value
will be 12 (decimal code for <ff>) if the current "line" is
the end of a page.
SIXBIT. Sixbit character code for the current character. This is made
from the ascii value by subtracting 64 (decimal) from ascii
character codes from 96 to 127 (decimal, inclusive) or 32
(decimal) from ascii character codes from 0 to 95 (decimal,
inclusive). Thus, the characters with ascii codes 0 through
31 (decimal) have negative sixbit codes.
TOPSIZ. Number of screen lines not used at top of screen (normally 2,
to allow for wholine).
BOTSIZ. Number of screen lines used at bottom of screen for typeout
and echoing (in the page printer).
WINSIZ. Number of screen lines used to display text (does not include
lines used for the header and trailer).
ATTSIZ. Number of lines currently attached.
ATTMAX. Maximum number of attached lines that will be displayed.
SSLINE. Current search limiting line number, for all incore text.
SSPAGE. Current search limiting page number.
SRCHAR. The character position of the place where the last search
string was found on the current line; this is the position
where the α<cr> command will take you if you aren't already in
the line editor. A value of 0 represents the first character
in the line, and a value of -1 means no successful search was
recently done ending on the current line.
WINTOP. The number of the top line in the current window, relative to
the first incore line (NOT relative to the current page).
STEP. The number of seconds per pause in autostepping of macros,
or a zero or negative number if autostepping is disabled.

EDLINE. This flag is 1 iff you are in the line editor editing a line
of text.
WFLAG. This flag is 1 iff the W flag in the header is on (page
changed).
NMODE. This flag is 1 iff the file is being edited in /N mode.
RMODE. This flag is 1 iff the file is being edited in /R mode.
IMODE. This flag is 1 iff you are currently in line insert mode.
RAPID. This flag is negative iff RAPID simulation of the line editor
by macros is disabled.
TERSE. This three-state flag is -1 when in TERSE mode, 0 in NORMAL
mode, and 1 when in VERBOSE mode.
SILENT. This flag is positive iff macro error messages are suppressed.
STOPHO. This three-state flag is -1 when in STOPALL mode, 0 in
STOPZERO mode, and 1 when in STOPONE mode.
CHECK. This flag is negative iff internal error checking of free
storage is disabled.
UNDMAX. This is the maximum number of characters that will be saved in
lines that can be undeleted.
UNDCHS. This is the current number of characters in lines that can be
undeleted.
UNDLNS. This is the current number of lines that can be undeleted.
AUTOBU. This is the current threshold of null records for autoburping.
This number is non-positive if autoburping is disabled.
BRKCOL. This is the current default column at which ⊗XBREAK will break
lines.
ECHO. This flag is negative if echoing of line editor input is
disabled.
MDEPTH. This is the current macro depth.
EXACT. This flag is positive iff searches will match only exact case
for letters (⊗XEXACT mode).
ALIGN. This is the default indentation to be used by ⊗XALIGN.
INDENT. This is the default indentation to be used by ⊗XINDENT; note
that this value can be negative, which means ⊗XINDENT
would un-indent text it was applied to.

The following readonly variables can be used to examine the justification
margins. Those with the initial letter T are the margins for the ⊗X TJxxx
commands; those without the T are for the normal ⊗X Jxxx commands.

CMAR. TCMAR. Crown line indent (first line of paragraph).
LMAR. TLMAR. Left margin (amount of indentation for body of paragraph).
RMAR. TRMAR. Right margin; last column that will be used for text.
BNUM. TBNUM. Blank line count; number of blank lines between paragraphs.
CMARO. TCMARO. Old crown indent; a line with CMARO indentation is taken as
LMARO. TLMARO. starting a new paragraph, unless CMARO = LMARO.

There are three readonly variables for finding out how many occurrences of
the current search string were
(1) searched for: NFIND.
(2) found: NFOUND.
(3) substituted for: NSUBST.
in the last search (or substitution) command. If that search included at
least one successful substitution, then NFOUND. will be zero and NSUBST.
will be positive. If the last search did not do (but maybe tried and
failed) any substitutions, then NSUBST. will be zero and NFOUND. will be
the number of occurrences found (possibly zero). NFIND. contains the
requested number of search or substitution repeats. The only slightly
obscure case is a command like ⊗4⊗F...⊗\...αβ9<cr>, which asks to do 9
substitutions starting with the 4th occurrence; if less than 4 occurrences
are found, then NFIND. will be 4, NFOUND. will be less than 4, and NSUBST.
will be zero, but if 4 or more occurrences are found, then NFIND. will be
9 (NOT 4), NFOUND. will be zero (meaning we did some substitutions), and
NSUBST. will be the number of substitutions done.

GENERATING CHARACTERS FROM NUMERIC VALUES

The command ⊗#⊗XCHARACTER <numeric code for character> <cr> has the same
effect as typing ⊗#<character>. Note that any repeat arg for the extended
command is passed to the indicated character, which should be between '001
and '777 inclusive (and the low-order 7 bits must not be zero); thus the
CONTROL ('200) and META ('400) bits can be included in the character. The
⊗XCHARACTER command is primarily for macros that want to generate text
and/or commands from numeric calculations, but it can also be used to type
any command character(s) that your keyboard cannot otherwise input (e.g.,
if some key is broken). (Note that ⊗XCHARACTER isn't legal in the middle
of another command, so you can't always avoid typing a certain character.)

The character's numeric code can be entered as a constant (decimal, unless
preceded by right single quote (') which makes it octal); or it can be
entered as the name of a numeric macro or readonly variable, in which case
the value of the named entity will be used. Thus, the command
αβ2⊗XCHARACTER ASCII.<cr> will cause the current character to be typed
twice.

SPECIFYING FOLLOWING NUMERIC ARGUMENTS TO EXTENDED COMMANDS WITH
NUMERIC MACROS, READONLY VARIABLES, AND OCTAL CONSTANTS

Certain extended commands that normally take one or more decimal numbers
following the command name will accept the name of a numeric macro or
readonly variable in place of the decimal constant. For instance,
⊗XBREAK RMAR.<cr> will break the current line at the column that is the
right margin for the normal justification commands.

The same extended commands (see list below) will also accept an octal
constant instead of decimal. Octal is indicated by preceding the number
with a right single quote ('); for instance, ⊗XBREAK '177<cr>.

The commands that currently accept these alternative forms for a number
following the command name are:
⊗XBREAK
⊗XCHARACTER
Eventually almost all extended commands will accept these alternative forms.

*** ADDITIONAL COMMANDS RELEVANT TO MACROS ARE EXPLAINED ON THE NEXT 2 PAGES. ***

Macros and Command Files: ⊗XEXECUTE ⊗PUTDEFS ⊗XCOMMENT ⊗XATTACH ⊗XREDEFINE
(See previous two pages and following page for more on macros.)

Modes Command Meaning
N ATTACH Place an editable macro definition in the attach buffer
N,A,E COMMENT No-op, useful for putting comments in command files
N,A,E EXECUTE Read and execute commands from a file
N,A,E PUTDEFS Append all current macro definitions to a cmd file
N,A REDEFINE Define a macro from incore page or attach buffer
startup arbitrary Automatic execution of EIN tmpcor file

EXECUTING COMMANDS FROM A FILE

To allow macro definitions and other often used commands to be carried
out automatically, the ⊗XEXECUTE command causes a set of commands to be
read in from a specified command file and then executed. The form of
this command is

⊗XEXECUTE <filename> ( <page range> ) <cr>

where <filename> and the parentheses and <page range> are optional. This
causes the selected pages in the named file to be read into a macro whose
name is the file's primary name preceded by a dot; then this "file macro"
is expanded just like any other macro. (See note below on automatic use
of a leading character other than dot for the macro name, if the macro
name with a dot already exists.) If the <filename> is omitted, the
default filename is used: EINIT.CMD on your LOGIN disk area (not your
ALIAS!). If a <filename> without an extension is given in the ⊗XEXECUTE
command, the default extension .CMD is used. With a zero argument, this
command

⊗0⊗XEXECUTE<cr>

will just type the name of the default execute file. The <page range> can
be either a single decimal page number, or a pair of numbers separated by
a colon, (for example, 3:4). Note that multiple page ranges (such as COPY
allows) are not permitted. In the filename, it is legal to omit any parts
and have the defaults used; for instance, you can specify just the PPN
or just the extension or just the primary name or just the device, or any
combination of these.

The ⊗XEXECUTE command ignores E directories and SOS line numbers and
accepts the standard and alternate representations to allow for input of
the CONTROL and META bits and non-printing characters from command files.
These representations, which use "⊗" as an escape character, are explained
on p. 25.

To avoid having the ⊗XEXECUTE of one file aborted when a command file
executes another command file of a similar name, the ⊗XEXECUTE command
tries to avoid duplicating a macro name that already exists. This command
makes up a name for the macro to represent the file being executed,
normally by inserting a dot (".") in front of the the primary name of the
file (e.g., ".EINIT"). But if that macro name already exists (because you
are executing one file from another, both with the same primary file
name), then, in order to generate a unique macro name, the leading
character is incremented from "." to "/", and then, if still necessary,
through the characters "./0123456789:;<=>?@".

WRITING MACRO DEFINITIONS INTO COMMAND FILES: THE ⊗XPUTDEFS COMMAND

The extended command

⊗XPUTDEFS <filename><cr>

writes all macro definitions into the file given, or into the default file
if no filename is specified. If the file already exists, it is extended
with a new page added. If the file doesn't exist, it is created with an E
directory. This command has the same default file (EINIT.CMD on your
LOGIN disk area) and default file extension (.CMD) as the ⊗XEXECUTE
command. The definitions are written out using the standard
representation, which is explained on p. 25.

COMMENTS IN COMMAND FILES

The recommended way of including comments in a command file is to use one
of the escape sequences "⊗;" and "⊗⊂" to indicate that the text following
is to be ignored as the file is read. In this way, the comments can be
included without having to be taken as commands to be executed. The form
"⊗;" allows you to put a comment at the end of a line, and the form "⊗⊂"
allows you to have partial-line or multi-line comments (see p. 25 for
details).

Note that since TABs are ignored, you can use them to set off comments or
commands from other text in a command file. However, spaces are not
ignored, so if you use them (outside a comment), they will appear in the
text to be executed.

The ⊗XCOMMENT command can also be used for inclusion of comments in a
command file, but it is actually stored (e.g., in macro definitions) and
executed, so it can only occur where a normal command can occur;
furthermore its use should be avoided inside a macro definition, since it
needlessly increases the size of the macro and slows it down a little.
The ⊗XCOMMENT command does nothing; it ignores the entire command line.
Thus the following command does nothing inside a command file.

αβXCOMMENT This is a bunch of text that can occur on many lines in
a command file. It might, for example, document what nearby text
does. This command should be ended with a carriage return, which
in a command file must occur as the two characters circle-x and
double arrow! Any ALPHA character inside a COMMENT command line
in a command file must be quoted (as "⊗α") or it will generate the
CONTROL bit on the next character and terminate the COMMENT
extended command line. Similarly any other character combination
that generates an activation character (like linefeed or altmode)
will terminate the COMMENT command. ⊗↔

AUTOMATIC EXECUTION upon E startup: EINIT option for LOGIN, EIN tmpcor file

E provides for automatic execution of selected commands when E starts.
For speedy checking for these commands, a TMPCOR file called EIN is used.
When E starts up, if the EIN tmpcor file exists, then it is executed just
like it were a piece of an EINIT file (see the ⊗XEXECUTE command above).
Since TMPCOR space per job is somewhat limited, the idea is to place in
the EIN file an ⊗XEXECUTE command that specifies what EINIT file page(s)
should be executed. The automatically executed commands can define macros
that you want always to have around, they can set up desired operating
modes, etc. One technique is: instead of loading all the macro
definitions you'll ever need every time E starts up (since that may take a
noticeable amount of time), just have the automatically executed commands
define a few macros that will themselves, when executed, cause further
selected groups of macros to be defined (and/or modes set up) from
particular pages of your EINIT file.

The EIN file itself can be set up automatically by use of the LOGIN option
EINIT. (It can also be set up manually using, for instance, the system
program TMPCOR -- R TMPCOR;?<cr> for details.) There are three forms for
the LOGIN option EINIT.

(1) The simplest option form says just "EINIT" and causes the EIN file
to be set up with "αXEXECUT⊗C", which will make E execute your
entire EINIT.CMD file upon startup. (Note that ⊗C represents a
carriage return when seen in a command file like this.)
(2) To have E execute only a certain range of pages from EINIT.CMD, use
the option form "EINIT(x:y)", meaning execute pages x through y of
EINIT.CMD (the ":y" can be omittted to execute only page x). This
causes the EIN file to contain "αXEXECUT (x:y)⊗C"; note that login
merely copies chars until it sees the right parenthesis -- the
syntax will be checked by E when it executes the EIN file.
(3) The most general form of this login option is "EINIT=\...\", where
"..." is the text of the command string to be executed and "\" is an
arbitrary delimiter not occurring in "...". This option form causes
the text string "..." to be written into the EIN tmpcor file,
provided the string is not longer than the maximum allowable length
(currently 50 characters).

For example, consider the OPTION.TXT lines:

Either of these writes an EIN tmpcor file containing "αXEXECUT (2)⊗C".
Then whenever E is started up, it will find this EIN file and execute it,
which in turn will execute page two of the EINIT.CMD file on the user's
login disk area. Note that the PPN of the tmpcor file is always that of
the login disk area, so this feature is not affected by the user aliasing
to different areas.

The switch /I given after the name of a file to be edited forces E to
execute the EIN file after it has opened the next file. This has two
main uses, given that /I is the default when E starts up. First, you
can prevent the execution of EIN upon startup by specifying the switch
/-I. And you can give /I when switching files, particularly if you said
/-I when starting up.

ATTACHING/EDITING/REDEFINING MACROS

The ⊗XATTACH and ⊗XREDEFINE commands can be used to edit and redefine
macros. The ⊗XATTACH command loads the attach buffer with the definition
of a macro in standard representation (see p. 25), thus allowing you to
put the text into the current file and edit it. The ⊗XREDEFINE command
(re)defines a macro from incore text, using the standard and alternate
representations. The forms of these commands are

⊗XATTACH <macro name><cr>

⊗#⊗XREDEFINE <macro name><cr>

where the blank macro name will be used if <macro name> is omitted and the
argument (#) to ⊗XREDEFINE determines how many lines (starting at the
current line or at the first line of the attach buffer) are used as the
source of the macro definition. As usual, a negative argument represents
lines before the current line. If no argument is given to ⊗XREDEFINE, the
whole page or whole attach buffer is used as the macro definition source.
The ⊗XATTACH command cannot be given when there is already some text
attached.

*** ADDITIONAL COMMANDS RELEVANT TO MACROS ARE EXPLAINED ON THE NEXT PAGE. ***

Debugging macros: ⊗XSAY ⊗XAUTOSTEP ⊗XSTEP ⊗&
(See previous three pages for more on macros.)

Modes Command Meaning
N,A,E ⊗& Step macro execution # steps
N,A,E AUTOSTEP Set or read autostepping time for macros
N,A,E SAY Type out text and/or decimal number
N,A,E STEP Step macro execution # steps

TYPING OUT INFORMATION (E.G., FROM WITHIN A MACRO)

The command ⊗XSAY simply types out (1) the text on the command line after
"SAY " and then (2) the decimal repeat arg, if any. The typeout is ended
with a <crlf> if and only if αβX is used in the command. This command can
be useful inside macros to report the status of the macro execution, but
it works outside of macros as well.

UPDATING THE DISPLAY DURING MACRO EXECUTION

The ⊗#⊗V command causes E to update the display immediately and then pause
# seconds. If the ⊗# is omitted, then E will merely update the display
without pausing. These commands can be useful for watching the progress
of a macro.

DEBUGGING MACROS BY STEPPING

Some facilities are provided to allow the user to debug even complicated E
macros. With these facilities, it is possible to step through macro
expansion (possibly pausing a little at each step) while having the
display updated to see the result of each step or of selected steps in the
macro expansion. While E is stepping a macro, it will type out the
characters of each step just before that step is carried out. Whenever E
is pausing at a certain macro step, ESC I will, as usual, immediately
abort all macros in progress. When a macro step pause occurs from the
line editor, the display of the line editor text will be done by E and a
cursor will be displayed at the proper character within the line. This
pausing in the "line editor" can be identified on DDs and IIIs by the
slightly wider cursor and on DMs by the "line editor" text NOT being
displayed in BOLD; this is to avoid fooling you into thinking that the
macro has ENDED in the line editor.

A macro step generally involves one complete E command -- for instance not
just ⊗X but a whole extended command line when ⊗X is encountered.
However, any sequence of all line editor commands given from WITHIN the
line editor, none of which would activate the line editor, is treated as a
single step along with the first (complete) command that does activate the
line editor. Such a sequence does not include the command that made E
enter the line editor; that command is taken as a separate step.
Exception: If the command that enters the line editor is α<tab> or αI,
then no step occurs at that point because it would cause loss of line
editor status (being at end of line or in line editor insert mode).

The ⊗#⊗XAUTOSTEP command enables a mode in which EVERY macro called is
executed by pausing # seconds after each step. See the paragraph above
for what constitutes a single step. The command ⊗-⊗XAUTOSTEP disables
this mode of automatic stepping of macros, and ⊗0⊗XAUTOSTEP reports the
status of this mode. The readonly variable STEP. contains the number of
seconds per pause, or a zero or negative number if autostepping is
disabled.

For manually stepping macros, there are two commands available:
⊗#⊗XSTEP <optional macro name> <cr>
⊗#⊗&
The extended command version optionally takes a macro name following the
command name; if a macro name is given (the blank name is not permitted),
then this command will call that macro and execute # steps before
stopping (a repeat arg of 1 will be used for this macro call). If no
macro name is given with ⊗XSTEP, or if the command ⊗& is used, then macro
execution is RESUMED (where it previous left off) for # steps (where # is
the argument to the command); thus when macro execution has been
interrupted, you can single step the remainder of the macro(s) with the
⊗& command. Another difference between ⊗& and ⊗XSTEP is that the latter
will cause an explicit message to be typed out when the given number of
steps have been executed -- "Stepping done, in <macro name>"; this
message is always suppressed for the ⊗& command and by Terse mode with
the ⊗XSTEP command. Note that if you give one of the stepping commands
while in AUTOSTEP mode, E will still pause after each step, but it will
quit stepping when the stepping count has been exhausted.
BOOK MODE (/B) and the BOOK command

Book mode (/B) in E provides some special features for editing files,
especially files which are really books in disguise. The main feature
of book mode is that you cannot alter a file open in this mode. In
addition, the BOOK command allows you to read a file in book mode over a
long period of time without having to explicitly remember your place in
the file. Your place will be saved in a .BKP file.

You get into book mode by following the filename with /B when you are
starting to edit, or by using the BOOK command to edit the file.

1. In /B mode, E will never permit you to alter the file you are
editing; you cannot change to READONLY mode or READWRITE mode from /B
mode. In /B mode, if you change part of a page and try to write out
the new version, E will simply remind you that you cannot alter the
file.

2. To help you keep your place in a book-file you are reading, E
keeps a special psuedo-SNAIL file on your area. This file will have
the name <filnam>.BKP, where <filnam> is the primary name of the
book-file. Note that the .BKP file is NOT a SNAIL file (although it
is in SNAIL file format), and thus will never be deleted by LOGOUT.
This .BKP file will contain the page number and line number at which
you were editing the book-file the last time you exited from E. E
will neither look for nor write a .BKP file unless you have started E
with the monitor command BOOK, which automatically starts E in /B
mode looking for a .BKP file. Furthermore, when you start E with the
BOOK command, if you use either of the /L or /P switches, E will
not read or write any .BKP file. And if you start E with just the
BOOK command without any argument, then unless there already is
a .BKP file on your area, no new .BKP file will be written.

3. The BOOK command with an argument (and without either of the /L
and /P switches) will look for a .BKP file with the given name and
PPN. If that .BKP file is not found, E will look for the .BKP file
on your current ALIAS area and then on your logged-in area. If a .BKP
file is found, it is used and updated when you exit. Otherwise, a
new .BKP file will be written onto your (ALIAS) area when you exit.

4. Whenever you use E in /B mode, it will reference TMPCOR files with
the name BK instead of ED. Thus you can switch back and forth
between editing some program and reading a book by alternately giving
the no-argument monitor commands ETV and BOOK (provided you have once
given the filenames). In /B mode, E will display "/B" following the
filename at the top of the screen.

5. When you have finished reading a book-file, E will delete the
<filnam>.BKP file automatically. E will think you have finished
reading the book if and only if you are on the last page of the file
when you exit.

- - - - -

The complete book WUTHERING HEIGHTS by Emily Bronte is available for
general reading in the file WUTHER[LIB,DOC]. To begin reading it,
simply give the monitor command:

.BOOK WUTHER[LIB,DOC]

Then when you exit from E, the file WUTHER.BKP will have been written
onto your (ALIAS) disk area with the numbers of the page and line
where you were last reading. To continue reading the file later
during the same login session (and with the same ALIAS as before),
simply say:

.BOOK

which will read in the TMPCOR file BK for your current ALIAS. When
you exit again, the TMPCOR file and the .BKP file will be updated.

To continue reading after you have logged out and back in, say:

.BOOK WUTHER

which will cause E to find your .BKP file, which itself will contain
the name of the book-file WUTHER[LIB,DOC].

Some other book-files will be found on the [LIB,DOC] disk area, including
GRIMM which is Grimm's Fairy Tales.

- - - - -

To read a file in /B mode without having the <filnam>.BKP file read
or written, use the /B switch explicitly:

.ETV <filename>/B

E files extended by other programs. ⊗XUPDATE ⊗-⊗XUPDATE

Modes Command Meaning
N,A UPDATE Write out the updated incore directory

E can handle easily almost any file that has been extended by another
program even though the directory has not been updated by that program.
The single restriction is that the file must remain in correct E format
with Formfeeds occurring only as the first character in a record. MAIL
extends E-format files in this way.

When E encounters a file that is longer than the directory indicates, the
file is read from the last indicated page to the end of the file to make
sure that the file is properly formatted. If the file is formatted ok,
then E generates in core an updated version of the directory, including
directory lines for any new pages added to the file. The updated
directory is normally not written out onto the disk until some command
forces one or more other pages to be written on the disk. Furthermore,
in /-U mode (see the /-U switch on p. 20), the writing out of the updated
directory is suppressed even when normal text is being written out.

When E opens a file that has been properly extended in the above manner,
it reports the number of pages that have been added to the file, or, if
none, the number of records by which the last page has been extended.
Also, if any pages have been added, the default position within the file
(at which E will place you if you gave no specific page number in a /#P
switch) is the first newly added page.

As long as an updated directory remains not written out onto the disk, a
"U" (for update) is displayed on the top line of the screen. The first
time any page is changed and written out when not in /-U mode, or if the
⊗XUPDATE command is given, the updated directory will be written out and
the "U" will disappear.

⊗XUPDATE Go into /U mode (if formerly in /-U mode); see the /-U
switch on p. 20. Also, if the directory needs updating on
the disk, then write it out now; and in that case, also
write out the current page if it has changed since it was
last written out.

⊗-⊗XUPDATE Go into /-U mode. This disables normal updating of the
directory that would occur when (1) a directory line
changes or (2) the file is extended beyond what the
directory page formerly indicated. This command applies
only to the current file, and then only until you switch
to another file (unless /-U is given again). That is, it
is NOT a permanent mode, even for the particular file.
See the /-U switch on p. 20 for details of /-U mode.

⊗0⊗XUPDATE Just report whether or not /-U mode is in effect.
Filenames, PPNs, file copying, numeric extensions, and filehacks

FILENAMES

If the filename you select to edit does not include an extension, then
E will first look for the file with the null extension. If that file
does not exist, E will edit the file (with the given primary name and
PPN) that has the "best" extension. The "best" extension is found by
checking extensions against E's ordered list of good extensions (see
the good list below). If no good extension is found, E will edit the
first file it finds in the UFD that has the right primary name and any
extension except those in E's bad extension list (see bad list below).
To edit a file with a "bad" extension, you must type the extension
explicitly unless the file with the "bad" extension is the only file in
that disk area with the given primary name.

If you omit the programmer name from the PPN in a filename, E will use
your current alias programmer name. If you omit the project name, E
will use your current alias project name.

Good extension list: FAI,S1,SAI,FOR,F4,LSP,WEB,PUB,POX,TEX,MSS,MAC,
MID,VLI,LAP,PAL,AL,MF,PL,MIC,SLO,WRU,NSA,OSA,PSC,
PAS,LST,PPR,LOG,CMD,MSG,TXT,DO,INI,NS,DIS

Bad extension list: REL,DMP,XGP,FNT,CFT,TFX,DRW,WD,PC,WPC,PLT,
PCP,PLX,DVI,PAC,SPI,TFM,VNT,ANT,PXL,LDI,RIM,FAS,
VRN,PIC,BIN,WL,WLS,PRE,PRS,CRU,PRF,SAM

(If you want some extension added to either list above, mail a message
to BUG-E, describing what kind of files the extension is used on.)

ALTERNATE PPN SEARCHING

When the specified edit file doesn't exist, E will try to find the file
on the PPN other than your alias where you last edited a file. Whatever
device that PPN was on (e.g., DSK or UDP) will be checked for the
currently specified file. This feature applies only if: (1) there was
no PPN specified in the current filename; AND (2) the file-switching is
not being done inside a macro. If the current filename included a
device, then only that device will be examined. Note that there is no
such help in finding the first file E is to edit, whose name is given in
a monitor command.

If E finds a file on a previously used PPN when you didn't specify a PPN,
any reformatting requested will require confirmation from you, even though
such confirmation is not normally required (i.e., when you give the
correct PPN). This is to prevent accidental reformatting of a file you
didn't really mean to reformat.

COPYING FILES WITH E

E is capable of copying E-format files and is usually much faster than
COPY at doing so. You can request file copying when you specify what file
to edit: Instead of just giving one filename, you give two names
separated by a left- or right-arrow (← or →). E will copy the file named
"behind" the arrow into the file named "in front of" the arrow, and then
it will edit the first file named. Thus, ET FOO←BAR will copy BAR into
FOO and then edit FOO, whereas ET BAR→FOO will also copy BAR into FOO but
then edit BAR. Thus, which arrow is used indicates whether you want to
edit the original file or the copy. The two-filename format can just as
well be used when switching files with ⊗ε or ⊗λ, as in ⊗εNEW←OLD. As
usual, if the output file already exists, E will ask you if you want to
replace it.

Note that the output file will be formatted for editing with E, although
it can be with or without a directory (if you want no directory, specify
/N on the output filename, as if ⊗εNEW/N←OLD). Thus the copy will
probably introduce padding with nulls at the end of each page (up to a
record boundary), will ensure that every line ends with a CRLF, and will
turn each altmode into a right brace ("}") (unless you use /-V). So of
course E cannot be used to copy binary files, nor text files that you want
copied EXACTLY, character by character.

The one copying mode not implemented is copying a file with an E directory
into one without a directory (/N). This of course can be done in two
steps, by first copying the file with a directory and then switching to
the new file (from itself) with /N to remove the directory.

NUMERIC FILENAME EXTENSIONS

You can ask E to edit the file with a given primary name and the
greatest numeric extension by giving the extension consisting of just a
greater-than sign (">"). For example,

ET FOO.>

will edit the file (with primary name FOO) whose extension is the
largest (purely) numeric value. E.g., if only FOO.20 and FOO.100 exist,
then ET FOO.> will edit FOO.100. If no file is found with a numeric
extension, then ET FOO.> will report File Not Found: FOO.>.

When the filename extension .> is given for a file that has to be created,
the extension of the newly created file will be generated by incrementing
the largest previously existing numeric extension found (with the given
primary file name). That is, if you say, for example, ⊗ε FOO/C or
⊗ε FOO.> ← BAZ and if you already have files FOO.1 and FOO.2, then the
new file created (or copied from BAZ) will be called FOO.3. If leading
zeroes were present in the previous largest numeric extension, then they
will be present in the new extension. If the previous extension was .999,
then the new extension will be .000. If you say ⊗ε FOO.> ← FOO.> and
if you already have FOO.1 and FOO.2, then FOO.2 will be copied to FOO.3
and E will then edit FOO.3. If you say ET FOO.>/C (create file) and no
old numeric extensions of FOO exist, then FOO.1 will be created.

FILEHACKS

The following filehacks, also usable with the COPY program, are
available in E as filenames. The file represented by each is indicated
below; most of these files are on the [2,2] disk area. A filehack consists
of a backslash followed by a name from the list below; the name may be
abbreviated by as many letters as necessary to identify it uniquely
(current abbreviations are given below). A filehack takes the place of
the filename and can be followed by the usual switches. Note that some
of the files below are not usually maintained in E format; beware.

Some of these filehacks imply /R mode. These are indicated in the list.
To override a default /R mode, you can explicitly specify /-R after the
filehack.

FILEHACK ABBR /R? FILE
\MAIL \M No The current user's mail file.
\MSG \M No The current user's mail file.
\PLAN \P Yes The current user's plan file.
\PLN \P Yes The current user's plan file.
\NAP \NA Yes The current user's NS notifications file.
\NS \NS Yes The current user's NS notifications file.
\BBOARD \B No The system bulletin board file: BBOARD.TXT[2,2].
\GRIPES \G No The system gripe file: GRIPES.TXT[2,2].
\GOLD \GO No The file of old system gripes: GRIPES.OLD[2,2].
\NOTICE \NO Yes The system message file: NOTICE.TXT[2,2].
\NEWS \NE Yes The current NYT news summary.
\DIGEST \DI Yes The current AP news digest.
\DOWN \DO Yes The system downtime forecast file.
\DAY \DA Yes The message-of-the-current-day file.
\FORWARD \F Yes The forwarding file for the MAIL system.

The filehacks \MAIL, \MSG, \PLAN, \PLN, \NAP and \NS can have an
explicit programmer name specified, in which case the mail, plan, or
notification file for the named programmer is read instead of your own.
To specify a programmer name, follow the filehack name immediately with
a colon (:) followed by the desired programmer name. For instance,
\MAIL:FOO represents FOO's mail file, and \PLAN:BAZ is BAZ's plan file.
The ⊗XPOINTER command will recognize these programmer-name filehacks (as
well as the normal filehacks). The filehack names themselves can be
abbreviated as usual (e.g., \M:FOO is FOO's mail file). The
programmer-name filehack facility is designed for non-display users,
since display users could already enter a filename like ∂FOO or
∂BAZ.PLN.

EDITING THE E MANUAL FILE, E.ALS[UP,DOC]

The special filename consisting of just a question mark ("?")
represents the name of the E manual (this file). Thus the monitor
command

ETV ?<cr>

will cause E to edit this manual file in readonly mode. When you are
already in E, the command ⊗? will switch to the E manual file; see p. 15.
Generating a new directory line: ⊗XNDFAIL ⊗XNDSAIL ⊗XNDBBOARD

Modes Command Meaning
N NDBBOARD Make a New Directory line for a page in \BBOARD
N NDFAIL Make a New Directory line (FAIL type) for page
N NDSAIL Make a New Directory line (SAIL type) for page
N RDFAIL Update the directory line with the page's FAIL labels

The commands ⊗XNDFAIL and ⊗XNDSAIL generate and insert a new first line of
the page (called the directory line) in appropriate FAIL and SAIL formats
for labels and for specified categories.

The command ⊗XRDFAIL replaces the current page's directory line with an
updated list of labels, possibly retaining some text from the old directory
line.

The command ⊗XNDBBOARD inserts a new first line of the page for a page
in the file \BBOARD.

These commands apply to the current page. If more than one page is in
core (through the use of ⊗XAPPEND or β<ff> commands) then the information
will be gathered only from the page containing the arrow line and the new
line will appear at the start of this page. Other pages in core at the
time will be unaffected.

The ⊗XNDSAIL command may be used as an information source in a variety of
different ways. It is not intended for use with text material.

⊗XNDFAIL Generate a New Directory line for the current page for a
FAIL-type (or MACRO-type) source file. All symbols
defined on the current page will be listed in the new
directory line, with the following restrictions:

(1) The symbol definition must be the first thing on a
line (not counting spaces and tabs). Thus only one
definition per line will be noted.

(2) The symbol itself must not be over 20 characters long,
can contain only letters, digits and the characters
".%_$", and must be followed by colon (:), left-arrow
(←) or equals-sign (=). Thus, normal labels and
assignments (in either FAIL or MACRO) will be noted.
A space appearing between the label and (say) a
following left-arrow will prevent E from listing that
label; this can be useful for limiting directory-line
information.

This command ignores down-arrows (↓) at the beginning of a
symbol and can be made to list only symbols defined with
a certain number of up-arrows (↑), depending on what
activation character ends the ⊗X command line.

Activator Symbols listed

<cr> All symbols detected (as described above).
α<cr> Symbols defined with at least one up-arrow (↑).
αβ<cr> Symbols defined with at least two up-arrows (↑↑).

The ⊗XNDFAIL command does not take a repeat argument
(unlike ⊗XNDSAIL below). The command ⊗0⊗XNDFAIL (with a
zero repeat argument) will issue a warning message (not an
error) without doing anything else.

⊗XRDFAIL (note the "R", for "replace", in the command name)
The command ⊗XRDFail generates a list of labels from a
FAIL source-file page on the page's directory line (line
1). But unlike its cousin command ⊗XNDFail (note the
first letters "R" and "N" of these commands), which adds a
new line at the top of the page, ⊗XRDFail replaces
(updates) the page's old directory line, retaining any
text on that line that precedes the two-character sequence
";⊗". If that sequence does not appear on the old
directory line, then that line's entire text will be
retained and the new list of labels will be appended to
it, preceded by ";⊗". This is intended to allow a
constant comment (or other text) to be kept on the
directory line ahead of the list of labels generated (and
updated) by this command. ⊗XRDFAIL will retain such text
preceding ";⊗" each time, while updating the label list
following. Both ⊗XNDFail and ⊗XRDFail begin their lists
of labels with ";⊗" in order to facilitate this feature of
allowing constant leading text. The ⊗XRDFail command does
NOT move the arrow to the directory line; ⊗XNDFail does
(it adds a new line at that point). NDFail stands for New
Directory-line (FAIL source), and RDFail stands for
Replace Directory-line (FAIL source).

Note: If you simply begin using ⊗XRDFail in place of ⊗XNDFAIL (omitting
the delete of the old directory line that is usually done after
⊗XNDFAIL), then you will end up with two copies of labels from the
page -- first the old copy (now treated as constant text) and then
the new copy (updated by each ⊗XRDFail command). The reason for
this is that old files' directory lines that were generated with
the old ⊗XNDFail command do not start with ";⊗", so using ⊗XRDFail
on such pages will APPEND the new list of labels to the old list
(only the first time, since the new list will begin with ";⊗").
Since the old list won't generally be wanted, you can simply
delete it (the list, but not the line), or change its leading ";"
to ";⊗", before using ⊗XRDFail; that will avoid duplicating the
list of labels. Or you can use ⊗XNDFail and delete the old line
manually (if it contained nothing but a list of labels); this is
a natural way to convert a directory line to the new format that
includes the ";⊗". It is recommended that you convert a whole file
at a time to the new format (using a macro containing ⊗XRDFail or
⊗XNDFail), but don't bother converting files that aren't being
changed. This way there is less chance that you may be confused
by a now out-of-date "old" label still appearing in constant text
on the directory line.

When you use ⊗XRDFAIL, E aids you in detecting old-format directory
lines by telling you it is `appending ";⊗..."' to the old line; this
should signal you to go back and do a ⊗XNDFAIL, unless you already
know that there was no old list of labels in the old format.

Much simpler is generating labels on the directory lines of a file
not already containing such labels; simply do an ⊗XRDFail command
on each page of the file. (You might want to add tabs at the end
of the old directory lines in order to move the label lists away
from the constant text of each line, to make that text more
readable.)

⊗XNDSAIL Generate a New Directory line for the current page for a
SAIL-type source file.

Given with a <cr> termination, this command lists all
words that are preceded by certain category words, the
default words being RECORD!CLASS, RECORD_CLASS and
PROCEDURE.

Having found a category word, E lists the first word
following the category word and then ignores any following
text until either a comma or a semicolon is encountered.
When a semicolon is encountered, the search for a new
category word is resumed. If, on the other hand, a comma
is encountered (not however within parentheses) then the
next word is taken as another example of the category and
it is listed, preceded by a comma. Listings following
different category words are separated by spaces.

The default categories may be augmented or replaced by any
desired categories up to the limit of 4 categories, as
outlined below.

(1) One additional category may be specified by typing its
name after a space following the command name and
terminating it by a <cr>.

(2) Up to 4 new categories may be specified (separated by
commas) with the categories after the first one
replacing the default categories, one by one. To
retain some default categories the list is terminated
by a <cr>.

(3) If the typed list of categories is terminated by ⊗<cr>
then only the typed categories are used, and the
default ones are eliminated.

(4) If the command is terminated by ⊗<cr> without any
typed category names then the original default
categories are reinstated.

The command ⊗0⊗XNDSAIL (with a zero repeat argument) will
accept any typed categories and then will list the
categories that are in effect without generating a text
line.

UPDATING EDIT DATE IN \BBOARD FILE: ⊗XNDBBOARD

The command ⊗XNDBBOARD (New Directory-line for \BBOARD) generates a new
directory line for the current page from the old directory line, assuming
it is in the MAIL message header format or the ⊗XNDBBOARD format. These
two formats are distinguished by whether the first space in the line is
followed by a second space. If so, then is MAIL format and this command
flushes the original time from the header and inserts the current date and
the current user's programmer name after the original programmer name. If
the old directory line was already in ⊗XNDBBOARD format, then the update
date is replaced by the current date and the updating programmer name is
replaced with the current user's programmer name. No guarantees are made
about what this command will do with a page whose first line is in any
other format. Note that this command does not delete the old header line
(the user should do that himself), but it does replace any initial
partial-sign (∂) in that line with a greater-than sign (>) to make sure
the ⊗∂ command will still work on the whole message.
Altering the use of the display screen: ⊗XTOPSET ⊗XBOTSET ⊗XATTSET ⊗XHEIGHT

Modes Command Meaning
N,A,E ATTSET Set max number of lines used to display attach buffer
N,A BOTSET Set number of lines used at bottom for page printer
N,A HEIGHT Set the number of lines used for text display
N,A TOPSET Set number of lines E skips at top (e.g., for wholine)

The four commands ⊗XTOPSET, ⊗XBOTSET, ⊗XATTSET and ⊗XHEIGHT determine how
E allocates areas on a display terminal's screen. Each of these commands
sets one display size parameter from the numeric argument to the command,
as follows: (1) if an unsigned argument is given, the parameter is set to
the given value; (2) if a relative argument is given (⊗-⊗# or ⊗+⊗#), then
the corresponding parameter is changed by the given amount; and (3) if the
command is given without any argument, the corresponding parameter is
reset to it default value. However, the various display size parameters
must fall within certain ranges; any attempt to set a parameter outside
its range will set that parameter to the nearest limit of the range.

The range for a given parameter is generally dependent on the current
settings of the other parameters. In particular, the ⊗XHEIGHT setting
must be at least two lines bigger than the current ⊗XATTSET value (so that
at least two non-attached lines can be displayed at any time); and since
⊗XTOPSET and ⊗XBOTSET implicitly change the ⊗XHEIGHT setting (see
descriptions below), ⊗XTOPSET and ⊗XBOTSET are limited by the restriction
that the ⊗XHEIGHT area must be at two lines bigger than the current
⊗XATTSET value.

Now here are the commands to set the display size parameters.

⊗#⊗XTOPSET Set the number of lines E skips at the top of the screen
(e.g., to leave room for the wholine). Any decrease
(increase) in the number of lines skipped at the top
results in a corresponding increase (decrease) in the
number of lines used to display incore text (see ⊗XHEIGHT
below). Thus, ⊗0⊗XTOPSET can be used to make E utilize
the 2 lines normally left for the wholine. Whenever the
number of lines skipped at the top becomes less than two,
E turns off your wholine to avoid having it overwrite E's
display, but E remembers that it has turned the wholine
off and will turn it back on when the top two lines are no
longer in use (e.g., upon exit, or upon ⊗2⊗XTOPSET).

⊗#⊗XBOTSET Set the number of lines E uses at the bottom of the screen
for the page printer (where typeout and echo of input go).
Any decrease (increase) in the number of lines used for
the page printer results in a corresponding increase
(decrease) in the number of lines used to display incore
text (see ⊗XHEIGHT below). This command is useful, for
example, when you are debugging some macros that cause
various things to be typed out which you don't want to go
quickly off the top of the page printer (use, say,
⊗9⊗XBOTSET). This command is also useful for getting one
more line for incore text display (use ⊗2⊗XBOTSET -- 2 is
minimum size; however, this may cause some of E's
occasional information typeout to go off the page printer
immediately upon being typed out. The default is 3 lines.

⊗#⊗XATTSET Set the maximum number of lines E will use for displaying
the attach buffer. This is useful when you want to
examine more of the text in the attach buffer than is
normally displayed, without putting the attach buffer down
on the page (use, say ⊗∞⊗XATTSET). This is also useful
when you have several lines attached, but you don't want
their display to distract you from the display of the
normal text on the page (use ⊗1⊗XATTSET, but notice that
if there is more than one line attached, E will display
the attach buffer only as one line of ". . ." without even
a vertical bar to remind you of the attach buffer). The
default maximum attach buffer display is 8 lines, and the
biggest allowed maximum attach buffer display size is 2
lines smaller than the current incore text display area
(see ⊗#XHEIGHT below).

⊗#⊗XHEIGHT Set the maximum number of lines E will use for displaying
incore text (including any attach buffer), not counting
the header and trailer lines. This command is sometimes
useful for reducing the time taken to display a full
window on a Datamedia (⊗XBOTSET can also be used for that
purpose), but it can also be useful if part of your
display's screen doesn't work properly (use this command
to shrink the size of the area used for incore text, and
possibly use ⊗XTOPSET to position E's display in the
working part of your screen); this command can sometimes
be used to reduce flicker on your III by reducing the size
of the text display area. The text display area must be
at least 2 lines bigger than the current maximum attach
buffer display size (see ⊗XATTSET above). The default is
to display as much text as will fit on your screen.
αβS. ⊗N,⊗O,⊗H: Line, Page & File stacks. ⊗XHOME ⊗XBACKGO ⊗XZFILES ⊗XZPAGES ⊗XZLINES

Modes Command Meaning
N,A αH Go to previous file in file stack (Home)
N,A αβH Go to Nth previous file, where N is current default arg
N,A ⊗0αH Type out file stack
N,A ⊗0αβH Type out default arg for αβH command
N,A ⊗#αH Go to #th previous file
N,A ⊗#αβH Go to #th previous file and set default arg to #
N,A ⊗-⊗#⊗H Go to #th previous file and pop # files off top of stack
N,A ⊗+⊗#⊗H Re-push # files back onto top of stack and go to new top
N,A αN Go to previous line in line stack
N,A αβN Go to Nth previous line, where N is current default arg
N,A ⊗0αN Type out line stack
N,A ⊗0αβN Type out default arg for αβN command
N,A ⊗#αN Go to #th previous line
N,A ⊗#αβN Go to #th previous line and set default arg to #
N,A ⊗-⊗#⊗N Go to #th previous line and pop # lines off top of stack
N,A ⊗+⊗#⊗N Re-push # lines back onto top of stack and go to new top
N,A αO Go to previous page in page stack
N,A αβO Go to Nth previous page, where N is current default arg
N,A ⊗0αO Type out page stack
N,A ⊗0αβO Type out default arg for αβO command
N,A ⊗#αO Go to #th previous page
N,A ⊗#αβO Go to #th previous page and set default arg to #
N,A ⊗-⊗#⊗O Go to #th previous page and pop # pages off top of stack
N,A ⊗+⊗#⊗O Re-push # pages back onto top of stack and go to new top
N,E αβS Re-edit the last line edited, at column were activated it
N,A BACKGO Go back to page that you last came from (see ⊗O cmd)
N,A HOME Go to relative or absolute page in Home file
N,A ZFILES Zero (clear) the file stack (and filelist)
N,A ZLINES Zero (clear) the line stack
N,A ZPAGES Zero (clear) the page stack

RE-EDITING THE PREVIOUSLY-EDITED LINE: αβS

The αβS command returns you to the last line you edited, if it is still
on the incore page at the place where you edited it. This command
positions you at the column where you were when you left that line and
can be given from the line editor to take you back to a previously edited
line; thus it can be used to alternate between line editing of two
different incore lines. Note also that this command is useful if you
left the line editor accidentally. However, if you left the line editor
with <cr> or α<cr>, then this command will position you at the end of
that line, since it appears to E that that is where you typed the <cr>
(the system places such a <cr> at the end of the line). Also, line edits
that you flushed with <altmode> cannot be gotten back into with αβS; only
line edits whose final text is accepted by E can be re-entered this way.
Any altering (such as by substitution or justification) of the last line
edited prevents this command from getting back into that line.

The position of the last line edited is updated for all line insertions
and deletions, but if you have since attached the last line edited, then
this command will succeed only if you have put that line back where it
came from (e.g., with αβR). If you have deleted the last line edited,
then you cannot get into it with this command even if you have undeleted
it and placed it back where it came from.

On non-displays, this command goes back to the last line typed in
(inserted) but of course doesn't edit it.

THE LINE, PAGE, AND FILE STACKS

The commands ⊗N,⊗O,⊗H make use of three corresponding "stacks" of places
you've been at recently: the LINE STACK (⊗N) of lines currently in core,
the PAGE STACK (⊗O) of pages NOT currently in core, and the FILE STACK
(⊗H). Each of the ⊗N,⊗O,⊗H commands works with the corresponding stack;
all of these commands interpret arguments in the same way and all
distinguish between α<cmd> and αβ<cmd>. You can return to the #th
previous place, and/or you can "Pop" # places off the stack, and/or you
can "re-Push" # places back on the stack.

The ⊗XBACKGO command is identical with the ⊗O command.

In the descriptions that follow, any sentence referring to "the stack"
should be taken as applying to each of the three stacks. The word
"place" is used to mean "line", "page", or "file", depending on which
stack is being considered. The current place is always at the top of
the stack.

The basic forms of these three stack commands are the "single-bucky" (α)
commands αN, αO, and αH, which, respectively, will take you back to the
previous line, page, or file. If a simple numeric argument ⊗# is added,
then you will go back to the #th previous line, page, or file (e.g.,
⊗3αH will take you to the third previous file). If you give an argument
greater than the current size of the stack, then you will end up at the
place formerly on the bottom of the stack.

The double-bucky (αβ) forms of these commands (without arguments: αβN,
αβO, and αβH) are just like the single-bucky forms except that the
current default argument for the command is used. The default arguments
(kept separately for each of the three commands) are all initially 2.
Thus, for example, αβO will initially take you back to the second
previous page. The default argument for a double-bucky command is
changed by typing the double-bucky command with the desired future
default. Note that this both sets the default argument and executes it!
For example, ⊗5αβH takes you to the fifth previous file and sets the
default arg for subsequent αβH commands to 5.

Note that with the default argument set to some number J, repeated use
of the double-bucky command with no argument will cause you to loop
through J+1 places. Thus when you are working on J+1 pages (or lines
or files) which you want to loop through, it is useful to set the
default arg to J.

You can find out what is on any of the stacks or what the default arg is
for any of the double-bucky commands by using an argument of zero (⊗0).
A zero arg with a double-bucky command types out the default arg for the
double-bucky command. A zero arg with a single-bucky command types out
the corresponding stack, including the current place (which is at the
top of the stack). Thus ⊗0αN types out the line stack and ⊗0αβO types
out the default arg for the αβO command (without executing it). The
⊗0αH command also types the stack level of each file so that you know
what argument to give the αH command to get to any file listed.

Since the lists of recently visited places have been called stacks,
there must be some stack adjusting operations -- and there are. Except
when one of the below stack adjusting operations has been used, the
"stack" is really an ordered list of the most recently visited DISTINCT
places. The list is ordered by the recentness of your being at each
place, and the places are kept distinct by removing from the middle of
the stack any entry for the place you are currently at. The current
place is always the top entry in the stack.

The STACK ADJUSTING OPERATIONS all involve a RELATIVE argument being
given to one of the ⊗N,⊗O,⊗H commands. There are two possibilities:
the relative argument can be negative (⊗-⊗3) or positive (e.g., ⊗+⊗4)
(note that ⊗5 is not a relative argument). Negative arguments cause
"Popping" of places off the stack and positive arguments cause
"re-Pushing" of places back on the stack. The default value for a
relative arg is one (i.e., ⊗+⊗N means ⊗+⊗1⊗N, and ⊗-⊗O means ⊗-⊗1⊗O).
You cannot pop or re-push more places than there are on the stack.

A NEGATIVE RELATIVE argument causes the given number of places to be
"Popped" off the top of the stack and the user is moved to the new top
of the stack. This is useful if, having gotten somewhere, you decide
you're not interested in remembering that place on the stack and you
want to go back to some previous place. For example, ⊗-⊗N (default
number is 1) will take you back to the previously remembered line and
not leave an entry for the current line just one below the new top of
the stack (as αN would). Actually, when you "pop" a place off the
stack, it is remembered (for the "re-push" command) by putting it on the
bottom of the stack.

A POSITIVE RELATIVE argument (e.g., ⊗+⊗4) causes the given number of
places to be "re-Pushed" onto the top of the stack from the bottom of
the stack and you are then moved to the new top of the stack. This is
mainly useful if you have just popped one or more places off the stack
and then decide you want another look at such a place. For example, if
you do a ⊗-⊗N, then doing a ⊗+⊗N immediately will undo the ⊗-⊗N
(including both returning you to a particular line and restoring the
stack to its previous state). Of course, if you haven't popped anything
off the top of the stack, then what gets pushed onto the top isn't
really "re"pushed after all, but is just whatever happened to be sitting
at the bottom of the stack.

Now for some details pertaining to particular stacks.

The line stack:

The line stack only remembers lines that are more than four (4) lines
away from each other. (Remember, the current line is the top of the
stack.) Thus moving down the page by ⊗> does not leave a trail of
remembered places, but in fact flushes from the middle of the line stack
the entries for any lines that are approached (within four lines).

When you go to a different page (not already in core), your line stack
is lost irretrievably. It is not restored when you return to a
previous page.

Entries in the line stack are corrected for line insertions and
deletions, including those resulting from the attach and justification
commands. The ⊗XCANCEL command preserves the current line stack without
attempting to un-correct entries for lines previously inserted or
deleted, but it flushes entries for lines that no longer exist (i.e.,
are beyond the new last line in core).

Multiple consecutive FF and VT (and ⊗W) commands do NOT remember (on the
line stack) intermediate stopping places. But ANY command besides FF,
VT, ⊗W, and ⊗0⊗N will cause the current line to get remembered. While
you are FF/VTing around a page, the αN command will take you back where
you started the current string of FF/VT commands (even if you are
already there!) and will remember, of course, the line you are leaving.

With each line in the line stack, E remembers the window position that
existed when you left that line. When you return to a line via ⊗N, the
old window position associated with that line is restored unless the line
was already on the screen, in which case the window is not changed.

The page stack:

Each entry in the page stack contains not only a page number, but also
the line number and window you were at when you left that page. The
⊗O command restores this line number and window.

When you return to a previous file (whether by number or by explicit
filename), the top part of your page stack from that file is restored
along with all line marks from that file.

If you ⊗XAPPEND to the current incore page(s) a page that was remembered
on the page stack, its entry in the stack is flushed since the page is
now in core.

The file stack:

Whenever you return to a previous file with one of the ⊗H, ⊗ε, ⊗λ and ⊗?
commands, the file is opened in the mode that you were in when you left it
(e.g., /N), and at the page and line where you were when you left it. The
window position is also restored. Whenever you return with the ⊗H
command, your Readonly/Readwrite mode is restored to its previous state
for that file. If you return to a previous file by using the ⊗ε or ⊗λ
command without an arg (and typing the filename explicitly), you can
override the default starting page and line with switches.

The E manual (this file) is never remembered in the file stack if you
get to it via the ⊗? command or the ? filename. Thus when you say ⊗?,
the first subsequent αH command will take you back to the file you
previously were in and a second αH will take you back, not to E.ALS,
but to the second previous file you were in prior to entering E.ALS.

The (⊗+ or ⊗-) ⊗#⊗XHOME command:

You can get back to the previous file in the stack AND AT THE SAME TIME
TO A SPECIFIC ABSOLUTE OR RELATIVE PAGE by using the ⊗XHOME command. An
absolute argument will position you to that page as you return to the
file, and a relative argument will position you that many pages from the
page where you would have otherwise returned. Thus ⊗4⊗XHOME will return
you to the previous file on page 4.

CLEARING THE STACKS:

The extended commands ZFILES, ZPAGES and ZLINES clear the file, page
and line stacks respectively.

⊗X ZFILES Zero (clear) the file stack.
⊗X ZPAGES Zero (clear) the page stack.
⊗X ZLINES Zero (clear) the line stack.

Undeleting lines of text: ⊗XUNDELETE

Modes Command Meaning
N,A UNDELETE Restore recently deleted or changed text

Deleted lines are saved (up to a certain limit) in the delete
stack and can be undeleted with the ⊗XUNDELETE command. Virtually every
time one or more lines of incore text are changed, the previous versions
of the changed lines are preserved in the delete stack. Thus the delete
stack includes not only lines that have been explicitly deleted, but also
lines that have been changed with the line editor, with a substitution
command, with a justification command, etc. Only the ⊗XCANCEL command
does away with incore text without the ability to retrieve it (if you
explicitly want to save some text over a ⊗XCANCEL command, you can either
attach that text or explicitly delete it for undeleting later).

The limit of deleted lines saved is indicated by a (settable)
maximum number of deleted characters; this limit is initially 5000
characters (approximately 1K of core). However, this limit is allowed to
be surpassed by a single command that itself deletes more than the current
limit of deleted characters. Thus the text deleting of any command
(except ⊗XCANCEL, which doesn't save in the delete stack the text being
cancelled) can be undone immediately, provided that no other command that
deletes lines is executed first. And, of course, even if another deleting
command is executed, the earlier deleted lines can still be undeleted if
the maximum character count for deleted lines is not exceeded. Lines are
undeleted in the opposite order from their deletion; that is, deleted
lines go into a stack. When the maximum deleted character count is caused
to be exceeded by a newly deleted line, one or more of the oldest deleted
lines (on the bottom of the stack) are flushed (forever) until the
character count is brought back within the limit, but lines deleted by the
current command are never flushed until another command deletes some more
lines.

When text is undeleted, the undeleted lines are removed from the
delete stack and inserted at the beginning of the attach buffer (even if
no lines were previously attached). (Note therefore that an undeleted line
cannot be undeleted again (unless it is re-deleted first)). Now here are
the descriptions of the various forms of the ⊗XUNDELETE command.

⊗XUNDELETE Undeletes (into the attach buffer) the last group
of lines that was deleted by a single command,
unless those lines have already been undeleted, in
which case this command (with no argument) won't
do anything (but complain).
⊗#⊗XUNDELETE Undeletes # lines (into the attach buffer).
⊗0⊗XUNDELETE Tells how many lines and characters can currently
be undeleted, and it will also tell what the
current deleted character limit is.
⊗-⊗#⊗XUNDELETE Sets the deleted character limit to # characters
(note the negative argument).
Lisp code indenting commands: α/ αβ/ ⊗XLISPSYNTAX

Modes Command Meaning
N,E α/ Lisp-indent current line by context above it
N,E αβ/ Lisp-indent next line by context above it
N,E ⊗#α/ Lisp-indent # lines from arrow by context above
N,E ⊗#αβ/ Lisp-indent # lines from next by context above
A α/ Lisp-indent first attached line (no-op!)
A αβ/ Lisp-indent first attached line in context of page
A ⊗#α/ Lisp-indent first # attached lines
A ⊗#αβ/ Lisp-indent first # attached lines in context of page
N,A,E LISPSYNTAX Examine and/or modify char interpretation by ⊗/ cmd

The α/ and αβ/ commands parse Lisp S-expressions and indent lines
accordingly (with tabs and spaces as needed). Text is never moved from
one line to another; only the indentation of each line is subject to
change. The ⊗#α/ command indents # lines (default is one line) starting
at the current line. Except in attach mode (see below), the ⊗#αβ/ does
the same thing as ⊗#α/ but first moves down a line (keeping you in line
insert mode if you are already in it). Both α/ and αβ/ without an arg
indent one line and leave you in the line editor positioned just after the
indentation (αβ/ moves down a line first, of course). When an explicit
arg is given, neither command leaves you in the line editor. All forms of
⊗/ can be given from within the line editor.

The ⊗/ command recognizes "super-brackets". This makes ] in the
text equivalent to enough )'s to close back to the matching [, or to close
all hanging ('s if no hanging [ is present to match.

The indentation set up is determined by examining the S-expression
which starts at or just before the current line, where that S-expression
is defined to begin at the nearest line that starts with either a left
parenthesis or a left square bracket (or their equivalents), or at the
beginning of the current page if no initial left parenthesis or left
bracket is found. However, the current line is not so checked for the
beginning of an S-expression when the command is given without an argument
nor when the command is given while in attach mode.

In attach mode, the α/ command does not look for any context
before the first line of the attach buffer, but the αβ/ command looks back
into the normal page text just ahead of the attach buffer to allow you to
indent the attach buffer while positioned at the proper place on the page.

A negative argument to either command means to indent the given
number of lines before the current line (without ever moving down a line);
in attach mode a negative argument makes the command a no-op.

The parsing of S-expressions is by MacLisp character set
interpretation, but the command ⊗XLISPSYNTAX described below allows
different character interpretations. For more details, see GLS.

MODIFYING LISP CHARACTER INTERPRETATIONS: ⊗XLISPSYNTAX

The command ⊗XLISPSYNTAX can be used to examine and/or modify the
syntax table which drives the ⊗/ (LISP indentation) command. This table
has one entry for each of the 128 (200 octal) characters. Each entry
consists of one or two characters which describe a LISP character syntax
category. The second (or only) character is a mnemonic for the role
played in the syntax of LISP S-expressions. The first character of two is
an auxiliary character used for certain kinds of matching, e.g. of string
quotes or super- brackets. The syntax types are:

TYPE NAME AUX? CHARACTERS WHICH INITIALLY HAVE THAT SYNTAX
( left paren no (
) right paren no )
[ left super no [
] right super yes ]
/ char quoter no / %
' quote macro no ` ' ,
| string quoter yes | "
↔ carriage return no CR
; semicolon yes ;
space no NULL TAB LF VT FORM SPACE BS
A letter no all others (e.g. A-Z a-z 0-9 + - * @ # ...)

(This initial arrangement represents a compromise between MacLISP and
InterLISP syntax. In MacLISP, there are no superbrackets, and only /
(and not %) is a character quoter. In InterLISP, only % (and not /)
is a character quoter; | does not serve as a string-like atom delimiter;
and semicolon is not a comment character.)

The auxiliary character is used for only a few special cases.
For a right superbracket, it is the character which is the matching
left superbracket. (Thus one can have several independent pairs of
superbrackets, in principle. This may not square with InterLISP
superbracket semantics, however.) For a comment character, it is the
character which terminates the comment. For a string quoter it is the
character which terminates the string (normally the same one which
begins it, but this extra flexibility is provided anyway).

The syntax table can be modified using the command:

⊗XLISPSYNTAX<space><octal of char to be affected><space>
<optional auxiliary char in octal, followed by space>
<representative mnemonic syntax char><CR>

Examples: to make < and > be parentheses, one would do:
⊗XLISPSYNTAX 74 (
⊗XLISPSYNTAX 76 )
To make % not be a character quoter, but only a letter:
⊗XLISPSYNTAX 45 A
To make ⊂ and ⊃ be superbrackets, one would say:
⊗XLISPSYNTAX 20 [
⊗XLISPSYNTAX 21 20 ]
The extra "20 " in the second one is needed to specify that ⊃ is
matched by ⊂. However, the first command is also needed explicitly
to define ⊂ as a left superbracket.

The command
⊗-⊗XLISPSYNTAX<CR>
resets all the interpretations to their initial default.

Finally, the command
⊗XLISPSYNTAX<space><octal of char><CR>
will merely cause E to type out the current interpretation of the char
given in octal.

In Terse mode (see ⊗XTERSE command), the typeout resulting from the
⊗XLISPSYNTAX command is suppressed except in the last case shown (which
is an explicit request for this typeout).

Case-changing commands: ⊗XUPPERCASE ⊗XLOWERCASE ⊗XOTHERCASE

Modes Command Meaning
N,A,E,S LOWERCASE Make all letters in given range be lower case
N,A,E,S OTHERCASE Invert the case of every letter in the given range
N,A,E,S UPPERCASE Make all letters in given range be upper case

The commands ⊗XUPPERCASE, ⊗XLOWERCASE and ⊗XOTHERCASE are available for
changing the case of letters in a file. Each of these three commands
takes a repeat argument that determines how much text is affected. If no
argument is given, an argument value of one (⊗1) is assumed. The commands
do what you might expect them to do: ⊗XUPPERCASE makes all letters in the
given range be upper case, ⊗XLOWERCASE makes letters be lower case, and
⊗XOTHERCASE changes the case of every letter in the range.

If any of these commands is given when NOT in the LINE EDITOR and NOT in
ATTACH MODE, then the command affects the specified number of lines of
text on the page. In this case, it is sometimes convenient to specify
the repeat argument by a search distance. This means that the prefix
command ⊗! can be used to make any of these commands work on the entire
current paragraph, and ⊗F...⊗XUPPERCASE<cr> makes the case-changing
command work on text from the current line up to (but not including) the
line containing the first occurrence of "...").

Any of these commands given from the LINE EDITOR affects the specified
number of WORDS starting at the word the cursor is under. A word is any
contiguous string of LETTERS and DIGITS plus any immediately preceding
string of characters containing no letters or digits (thus the space
between words is considered as part of the following word).

If the command is given while in ATTACH MODE, then it affects the
specified number of LINES in the ATTACH BUFFER.

A negative argument specifies words or lines preceding the cursor or
arrow, except when in attach mode, in which case a negative argument
specifies the given number of lines at the END of the attach buffer
instead of at the BEGINNING.

Neither the cursor nor the arrow is moved by any of these commands.
Use of PTY and Lisp subjobs from E: ⊗= ⊗XEECHO ⊗XEVAL ⊗XIECHO ⊗XINTERRUPT ⊗XLATTACH ⊗XLFILE ⊗XLPEND ⊗XLRECEIVE ⊗XLTYPE ⊗XRECONNECT ⊗XREEVAL ⊗XSCREEN ⊗XSLISP ⊗XSUBDETACH ⊗SUBECHO ⊗XSUBFIND ⊗XSUBJOB ⊗XSUBKILL ⊗XSUBLINK ⊗XSUBWAIT ⊗XSULISP

Modes Command Meaning
N,A,E ⊗-αV Update screen, then Disable screen updates until ⊗V typed.
N,A,E ⊗-αβV Clear and redraw screen, then Disable screen updates.
N,A,E ⊗= Send current line or whole attach buffer to subjob.
N,A,E ⊗#⊗= Send # lines to subjob from page or attach buffer.
N,A,E ⊗0⊗= Send subsequently-typed line to subjob.
N,A,E EECHO Enable or disable E Eval loop echoing
N,A,E EVAL Enter Eval loop talking to current subjob.
N,A,E IECHO Control Input Echo of all E type-in
N,A,E INTERRUPT Send an ESC I interrupt to the current subjob.
N,A,E LATTACH Make subjob output text get attached by E
N,A,E LFILE Make subjob output text get put into current page
N,A,E LPEND Make subjob output text go at end of current page
N,A,E LRECEIVE Enable or disable reception of text from subjob
N,A,E LTYPE Make subjob output text simply get typed out
N,A,E RECONNECT Re-connect to a previous Lisp or PTY subjob
N,A REEVAL Send macro-format text (e.g., ⊗C for <cr>) to subjob
N,A,E SCREEN Begin Screen Editing with PTY subjob, ⊗XLPEND mode
N,A,E SLISP Start up a Lisp subjob from [1,3]
N,A,E SUBDETACH Detach current PTY subjob, and then flush the PTY
N,A,E SUBECHO Enable or disable echoing on current PTY subjob
N,A,E SUBFIND Find a PTY subjob and connect to it
N,A,E SUBJOB Start up a PTY subjob
N,A,E SUBKILL Kill all Lisp and PTY subjobs
N,A,E SUBLINK Enter Eval loop with PTY subjob, do ⊗1⊗0⊗XBOTSET
N,A,E SUBWAIT Allow E to wait forever for required Lisp response
N,A,E SULISP Start up a Lisp subjob from your alias

Controlling subjobs from E

It is possible to use E to control one or more subjobs, with text and
commands sent back and forth between the jobs. There are two ways that
E can work with a subjob: (1) the subjob can be on a PTY which is owned
and controlled directly by E, with E effectively typing text at the PTY
and receiving typeout back; or (2) the subjob can be an arbitrary program
which implements the E-MacLisp protocol (described later), whereby text,
commands and other special information can be passed back and forth. As
you might guess, the protocol was invented so that E can control a MacLisp
subjob, sending it expressions to evaluate and getting back answers, with
the capability of putting text from Lisp into the file being edited. Lisp
can even give E commands to execute and can ask E to report the values of
readonly variables. At the moment, only MacLisp understands this
protocol, but any other program could be made to interact with E using the
same primitives. For simplicity, in the descriptions here we'll refer to
any subjob as being either a PTY job or a Lisp job, instead of "a PTY job
or an arbitrary program implementing the E-MacLisp protocol". The term
"subjob" applies to both PTY jobs and Lisp jobs controlled from E. Again
note that currently only MacLisp implements this protocol. For more
details on the MacLisp implementation, READ EMACLSP.

The commands for sending text to a subjob are exactly the same, whether the
subjob is a PTY job or a Lisp job. Only for starting up subjobs are there
distinct commands for the two kinds of subjobs. (There are a few extra
commands, however, that for obvious reasons apply to only one of the two
subjob types.)

Starting up a Lisp subjob

The extended commands ⊗XSLISP and ⊗XSULISP start up Lisp-type subjobs (the
names stand for Start LISP and Start User LISP, respectively). The
general forms for these commands, with default filenames indicated, are:

⊗X SLISP DSK:MACLSP.DMP[1,3] ( ELISP.INI[alias] )

⊗X SULISP DSK:MACLSP.DMP[alias] ( ELISP.INI[alias] )

where each of these commands can specify either, both or neither of the
two indicated filenames. The first filename tells which Lisp-type program
to start up on a subjob, and the file named in parentheses is the init
file for Lisp to use to initialize itself. If Lisp cannot find the init
file (default or named), then it will use ELISP.INI[MAC,LSP]. Note that
the difference between the two commands shown is that SLISP uses a default
program PPN of [1,3], whereas SULISP (Start User LISP) takes the user's
current alias as the default program PPN. The program started by these
commands should be one that implements the E-MacLisp protocol (currently
only MacLisp and friends).

When working with a subjob (either PTY or Lisp), E is spoken of as being
connected to that subjob. If a new subjob is started up (e.g., with
⊗XSLISP) when E is already connected to a subjob, E will disconnect from
the old one and connect to the new one. It is possible to change back and
forth among multiple subjobs, being connected to at most one subjob at a
time. E keeps a stack of your subjobs; to re-connect to a detached subjob
according to its position in the stack, you can give the command

⊗#⊗XRECONNECT

which interprets its numeric argument and combination of CONTROL and META
bits (on the ⊗X) in exactly the same was as the ⊗N, ⊗O, and ⊗H commands
do (for handling the line, page, and file stacks). In particular:

αXRECONNECT Reconnects to the disconnected subjob on top of the stack
(the previous subjob); this treats the stack like αH.
αβXRECONNECT Reconnects to the nth previous subjob in the stack,
where n defaults to 2 and is set by the next command.
⊗#αβXRECONNECT Reconnects to the #th previous subjob and sets the
default in the above command to the given number #.
⊗#αXRECONNECT Reconnects to the #th previous subjob in the stack.
⊗-⊗#⊗XRECONNECT Rotate the subjob stack by -#, reconnecting the #th
job from the top of the previous stack.
⊗+⊗#⊗XRECONNECT Rotate the subjob stack by +#, reconnecting the #th
job from the bottom of the previous stack.
⊗0αβXRECONNECT Type out the default argument for the αβXRECONNECT command.
⊗0αXRECONNECT Type out the contents of the subjob stack.

Note that the ⊗XRECONNECT commands treat PTY and Lisp jobs alike in the
subjob stack, where such jobs can be freely mixed.

To re-connect to an existing Lisp job by its job number, the command

⊗#⊗XSLISP

is given with a preceding argument that specifies the number of the job to
connect to. This command will disconnect from any previously connected
subjob (PTY or Lisp), but it will connect only to a Lisp job. For
instance, ⊗4⊗XSLISP connects to Lisp job 4 (after disconnecting from any
previously connected subjob).

To find out what Lisp subjob you are currently connected to, if any,
give the command

⊗0⊗XSLISP

which will type out the wholine of any connected Lisp subjob of yours.

Subjob output text can be directed to any of three places, but all of the
commands to start up or reconnect a subjob always causes the subjob output
disposition to be reset to the default of simply typing out the subjob
text. See ⊗XLTYPE and related commands below.

To kill a connected Lisp subjob, give the command

⊗-⊗XSLISP

which will make E forget about that subjob after telling the subjob to go
away. If perchance the Lisp job has never finished initializing (never
told E it was ready), then E will warn you that you might want to kill the
subjob manually. This can easily be done by typing

ESC . to be able to type to the monitor, then
KILL nn<cr> where nn is the subjob number, and then
BREAK . to make subsequent typein go once again to E.

If you exit from E without having killed all your Lisp subjobs, E will
warn you of that as it exits, so that you don't end up leaving one or more
unused detached Lisp jobs lying around. E doesn't kill such jobs
automatically upon exit, since you might want to reconnect to such a job
later, after running some program besides E. In fact, E remembers such
Lisp subjobs in the TMPCOR file, so that, upon restarting E, you will
automatically be reconnected to them. And LOGOUT will warn you about your
detached Lisp jobs with its usual message "You are still logged in
elsewhere". At any rate, please try not to fill the world with forgotten
detached jobs!

Starting up a PTY subjob

To start up a PTY-type subjob, use the extended command

⊗XSUBJOB

which will first disconnect any previous subjob. A PTY (pseudo-terminal)
subjob can be used to type commands to the monitor and/or to other jobs
without ever having to exit from E, and with the capability of putting the
resulting typeout into an E file.

The forms of ⊗XSUBJOB with preceding arguments are completely analogous
to the forms of ⊗XSLISP with preceding arguments as described above:

⊗#⊗XSUBJOB connects to subjob on PTY line # (disconnecting previous job)
⊗0⊗XSUBJOB types wholine of any PTY job connected to
⊗-⊗XSUBJOB kills any connected PTY job

Note that the various ⊗XSUBJOB commands work only for PTY subjobs. To
do the corresponding things with Lisp subjobs, use the ⊗XSLISP commands.

For re-connecting to previous PTY (or Lisp) subjobs, you can use the
⊗XRECONNECT commands, which were described earlier.

When you exit from E, any connected or disconnected PTY subjobs will
continue to exist until you run a different program, but then they will go
away automatically since they are running on PTYs created by E and the
PTYs go away when E does. So you can't logout and leave any PTY subjobs
lying around, but as long as you stay in E (and through exiting and
continuing back into E), PTY subjobs will continue to exist unless killed
with ⊗-⊗XSUBJOB. Be aware of this in time of any system job slot
shortage, which could happen if everyone always has an E subjob hanging
on (if that happens a lot, maybe we'll increase the number of job slots).
Also note that idle PTY subjobs are eligible for autologout just like normal
jobs, except that since they are normally GAGged, they won't see the
autologout warning (and currently the PTY autologout resets your E display
-- don't be fooled into thinking that E has been autologged out when this
happens!).

The ⊗XSUBDETACH command detaches the current PTY subjob and then flushes
the (now jobless) PTY. This can be useful is you want to start up some
sort of phantom or background job using E but don't want to stay connected
to that job.

Doing a monitor REENTER command to save your incore text also detaches
any PTY subjobs you have (otherwise they would get killed), so that you
can re-attach them (directly or through a new E) in order to continue
using their core images. Fatal E crashes also detach PTY subjobs.

**** One word of warning about sending text to a PTY: If you try to send
more text than fits in the PTY's input buffer (about 95 characters), and
if the PTY then refuses to empty its input buffer for some reason (e.g.,
it is waiting for its output buffer to be emptied (by E!) so that it can
type out some more text), then E will hang waiting for the PTY to make
room to accept the text that you directed to the PTY; this can result
in a deadlock situation which you cannot get out of, even by typing ESC I!
Perhaps someday this situation will be cleaned up so that you can "type
ahead" arbitrary amounts to the PTY, but for now it is best not to "type
ahead" very much text to the PTY unless you are sure you know exactly what
the PTY job is going to do (e.g., not type out much stuff).

Sending text to Lisp or a PTY

There are several commands available for sending text to a subjob.
These commands will work with either a Lisp or a PTY subjob, and they
are generally valid even when given from the line editor. When sending
characters to a PTY, the character "β" represents deferred CALL and
two β's an immediate call. That is to say, for purposes of terminal
input, the PTY is (by default) a non-display and uses non-display
input sequences (including the non-display escape character ↑←, which
is the same as "∨").

⊗= Sends the current line, or the whole attach buffer
if any lines are attached.

⊗#⊗= Sends # lines of text from the page or the top of the
attach buffer. If the repeat argument ⊗# is negative,
then # lines above the current line are sent.

⊗0⊗= Prompts for one separate line of text to be typed in by
the user and sent to the subjob along with the line's
activation character, except that altmode aborts the
command. This is one way of sending αβ<lf> to a PTY,
since you can't send it with ⊗XEVAL below.

αXEVAL These two commands put you into an "Eval loop" to
and αβXEVAL communicate with your subjob. In this loop, everything
you type, including activators like altmode, is
transmitted to your Lisp or PTY subjob until you type
αβ<lf> (on a display) or ↑Z (on a non-display). The
difference between αX EVAL and αβX EVAL is this: for αX
EVAL, terminal input is done in line mode (letting you
edit each line before it is sent); but for αβX EVAL,
terminal input is in character mode (each character is
sent to the subjob as soon as you type it). While in the
Eval loop, you can change between line and character input
by typing ESC I (to select character input) or BREAK I
(for line input). In any case, a backspace typed with an
empty input line will activate and be sent to the subjob.
While you are in the Eval loop, an "E" will be displayed
on the header line to remind you that you are in the Eval
loop, effectively talking to the subjob instead of to E.
To send a αβ<lf> (or non-display ↑Z) to your subjob, you
must use some command other than ⊗XEVAL; for instance ⊗0⊗=
(see above) or ⊗XREEVAL (see below). Note: no extra <cr>
is inserted when you type αβ<lf> to end Eval mode. If you
want a <cr> there, then you should type it before the
αβ<lf>.

⊗#⊗XREEVAL Interprets page or attach buffer text that uses E macro
text representation format (see p. 25) and sends the
resulting interpreted text to your subjob. The repeat
argument in this command specifies the number of lines to
be interpreted and sent; a negative argument means send
the given number of lines above the current line.

⊗0⊗XREEVAL <text><cr or lf>
Interprets text to be sent to the subjob, but instead of
taking the text from the page or attach buffer, this
command uses the text from the command line itself
(following the "REEVAL"). If that line ends with <lf>,
then the command will continue reading text from the
terminal until αβ<lf> (displays) or ↑Z (non-displays) is
typed; while this additional text is being typed, an "R"
will appear on the header line and <altmode> can be typed
to abort the entire command.

⊗XINTERRUPT <char><cr>
Causes an ESC I <char> interrupt of a Lisp subjob, or a
simple ESC I interrupt for a PTY subjob. Note that for
the Lisp version, the <char> should follow exactly one
space after the command name.

Receiving output from Lisp or a PTY

Text sent back from a Lisp or PTY subjob can be directed to any one of
three places: (1) it can simply be typed out, (2) it can be put into the
attach buffer, or (3) it can be put into the current page just above the
current line. The default is (1), having the text typed out, but there
are three commands to select the desired disposition, namely:

⊗X LTYPE Type out text that is output by the subjob.
⊗X LATTACH Put subjob output text into the attach buffer at the end.
⊗X LFILE Put subjob output text into the current page just above
the current (arrow) line.
⊗X LPEND Put subjob output text at the end of the last page that is
in core when you give this command. You must be on that
page (and file) to receive text while in this mode;
otherwise subjob text will be held up. Of course, you can
change modes at any time; and you can give the ⊗XLPEND
command again at any time to select the (end of the) then
current page for subjob output.

A zero repeat argument on any of these commands, e.g., ⊗0⊗XLTYPE, makes
the command only report and not change the currently selected disposition.
The commands that start up or reconnect to a subjob all reset the subjob
output disposition to typeout (that is, to ⊗XLTYPE mode -- the commands
that do this are ⊗XSLISP, ⊗XSULISP, ⊗XSUBJOB, ⊗XSUBFIND and ⊗XSUBLINK
(when creating a subjob), including the forms with positive arguments).

E indicates the subjob text-output mode on the header line whenever you
have a subjob (Lisp or PTY) connected. The header line will display one
of the following lower-case letters when you have a subjob:

t Type out subjob text (LTYPE)
a Attach subjob text (LATTACH)
f File subjob text at (above) arrow line (LFILE)
e put subjob text at End of given page (LPEND)

If you are in ⊗XLFILE mode but have some text attached at the time your
subjob tries to send you some text, then E will hold up subjob output
because it cannot put text into the page while you are in attach mode.
Similarly, if you have given the ⊗XEVAL command from the line editor and
are in either ⊗XLFILE or ⊗XLATTACH mode, then E will hold up subjob output
received at that time. In either of these cases, to get subjob output
going again after this happens, you must give the ⊗X LRECEIVE command (see
below).

In ⊗XLFILE or ⊗XLATTACH mode, when E receives from your subjob some text
that does not end with a <cr><lf>, E is forced to insert a <cr><lf> at
that point, since every line of text must end with a <cr><lf>. However,
E remembers that it inserted a <cr><lf> in that particular line, and if
the next text arriving from the subjob would have gone into the same line,
then E will at that time discard the inserted <cr><lf> and append the new
text there. This allows individual lines output by Lisp or a PTY to be
broken across two (or more) outputs to E without affecting the result.

The E-MacLisp protocol requires E to discard a leading <cr><lf> coming from
Lisp (this does not apply to PTY subjobs), so that the resulting text
will appear correctly.

Suspending Lisp or PTY output, & Getting output while in a macro

It is sometimes convenient or necessary to stop the output coming from a
subjob so that you can get E into the right state for receiving the text.
The following commands allow you to hold up subjob output and later resume
it.

⊗-⊗XLRECEIVE Hold up subjob output such that a message will be typed
out when output arrives. Thus you will know when your
subjob has done something, but subjob output won't be
processed until an ⊗XLRECEIVE command is given. It
doesn't matter whether you are in ⊗LTYPE, ⊗XLATTACH,
⊗XLFILE or ⊗XLPEND mode. As well as preventing Lisp from
sending any text, this prevents Lisp from sending E any
commands to execute or any readonly variables to evaluate.
This manual holding, as well as automatic holding, is
cleared upon switching subjobs.

⊗XLRECEIVE Un-hold subjob output. This re-enables reception and
appropriate disposition of subjob output. If there is any
such output waiting when you give this command, then it
will be processed immediately. This command is necessary
to get subjob output going again after text has arrived
from Lisp while you were in a disposition mode (e.g,
⊗XLPEND) that couldn't be provided in E's current state
(e.g., wrong page in core).

Three special forms of the ⊗XLRECEIVE command are used to get E to process
text from a subjob while in the middle of a macro. These three forms all
have arguments preceding the command, and all of them enable receiving
subjob text (like the regular ⊗XLRECEIVE command does). Here they are.

⊗+⊗XLRECEIVE Process text from the subjob immediately (even in a
macro) if there is anything ready to be processed. This
command never waits for text to arrive, however.

⊗#⊗XLRECEIVE Read exactly # lines from the subjob now, waiting if
necessary until those lines (ended with CRLFs) have been
received.

⊗+⊗#⊗XLRECEIVE Read # or more lines from the subjob now, waiting if
necessary until at least # lines (with CRLFs) have been
received; if more text is ready at the same time, it too
will be read. This can be useful for trying to swallow the
final prompt character ("." or "*", etc.) from a subjob that
is finishing a command; note that if that prompt isn't
followed by a CRLF, you can't read that "line" with
⊗#⊗XLRECEIVE or E will wait forever for the missing CRLF.

To find out whether subjob output is being held up, use this command:

⊗0⊗XLRECEIVE Report the status of subjob output holding.

Echoing of text being sent to a subjob

Normally, E turns off echoing on a PTY subjob so that text sent to the
PTY will not come back as echo (it is normally echoed when typed to E).
However, in certain instances, such as using E to make a transcript of
input and output text, it is desirable to have the PTY input text echoed.
The following commands enable the user to turn PTY echoing on or off. The
default is off.

⊗XSUBECHO Turn on PTY subjob echoing of text sent from E.
⊗-⊗XSUBECHO Turn off PTY subjob echoing of text sent from E (default).
⊗0⊗XSUBECHO Report the state of PTY subjob echoing.

However, if your subjob is somehow doing its own "echoing" (despite
⊗-⊗XSUBECHO), for instance because it is a TELNET connected to a remote
host, then you may want to turn off echoing of characters typed to E
while in the Eval loop (note the difference between echoing of characters
typed to E and echoing of characters typed to the PTY). The following
commands deal with echoing of characters typed to E while in the Eval loop.

⊗-⊗X EECHO Turn off E echo for Eval loop.
⊗X EECHO Turn on E echo for Eval loop (the default).
⊗0⊗X EECHO Report the state of E Eval loop echoing.

Note that you have to get out of the Eval loop to give any of these
commands. Also note that there are two E's in EECHO -- don't confuse
⊗X EECHO with ⊗X ECHO!

Another command controlling echo in E is the ⊗-⊗XIECHO command, which turns
off all echoing of input to E.

⊗-⊗X IECHO Turn off all Input Echoing in E.
⊗X IECHO Turn Input Echoing back on.
⊗0⊗X IECHO Report the state of Input Echoing.

The ⊗-⊗XIECHO command is intended to allow you to type commands that call
macros that may deal with subjobs and that type out text that you don't
want broken up with the echo of what was actually typed to E. Note that
⊗X IECHO is different from the ⊗X ECHO, ⊗X EECHO and ⊗X SUBECHO commands.

Also, the PTY is by default gagged against messages from other users
(e.g., SENDs), but transmitting TTY NO GAG to the monitor via the PTY will
ungag the PTY and allow SENDs to it, etc. None of this affects the
potential gagging of SENDs to the user's real terminal.

One command does all for PTYs: ⊗XSUBLINK

When you want to talk to a PTY through E, you normally have to do three
things: set the page printer area to a reasonable size so you can see your
PTY interaction, start up a PTY subjob, and begin communication with the
PTY. These three things can be done in three commands: ⊗XSUBJOB,
⊗1⊗0⊗XBOTSET, and ⊗XEVAL. But that's a lot of trouble, so here's one
command that does it all.

⊗XSUBLINK Set the page printer size (a la ⊗XBOTSET) to 10 lines,
unless it is already bigger than the default size; then
connect to an existing PTY subjob, if any, else start up a
PTY subjob; then enter the Eval loop (a la ⊗XEVAL). Any
positive numeric argument to ⊗#⊗XSUBLINK will be applied
to an ⊗XBOTSET command to determine the page printer size
at the bottom of the screen, and the CONTROL and META bits
of the ⊗X are applied to the ⊗XEVAL command, so that αX
selects line mode input and αβX selects character mode
input (as usual ESC I and BREAK I can be used to switch
between character and line input modes).

And here are two special results from using this command with a zero
or negative argument.

⊗0⊗XSUBLINK Type out the wholine of your current subjob.

⊗-⊗XSUBLINK Kill the current subjob and normalize the page printer's
size (provided it was previously bigger than normal).

For example, ⊗1⊗2αβXSUBLINK sets the page printer area to 12 lines,
connects to a PTY subjob (starting one if necessary), and enters the Eval
loop in character mode. After you've left the Eval loop (with αβ<lf>), you
can give ⊗-⊗XSUBLINK to flush the subjob and shrink the page printer size.

Finding a PTY subjob to use

To find a PTY subjob to use, creating one if necessary, use the command

⊗XSUBFIND

which connects to the PTY subjob nearest the top of the subjob stack, or,
if there are no such jobs, creates one and connects to it. Thus this
command is similar to the ⊗XSUBLINK command except that ⊗XSUBFIND doesn't
change the page printer size or enter the Eval loop.

Killing all your subjobs

To kill all your Lisp and PTY subjobs at once, use the command

⊗XSUBKILL

which names the jobs as it goes along killing them. Since this is a
dangerous command if given by accident, it cannot be abbreviated shorter
than ⊗XSUBKIL and it cannot be given any "repeat" argument.

The Screen Editor

Since you can go into the Eval loop with a PTY and have all the echo
(⊗XSUBECHO mode) and output immediately saved in your file (⊗XLPEND mode),
ready to be picked up or pointed to and re-sent to the PTY, you now have
the Screen Editor! Admittedly it does use two jobs instead of one, and
you may sometimes have to manually change between character and line input
mode (with ESC I and BRK I while in the Eval loop) instead of having the
(PTY job) program do that for you automatically. But it does allow you to
use E's editing and macro capabilities while talking to the monitor and to
user programs, without having to change your basic context to switch
among these, and that's basically the screen editor. A future capability
that may be added is the ability to retrieve earlier subjob output text
that was typed out (and that has since scrolled off the screen).

To make it easy to start up screen editing, here is a special command.

⊗XSCREEN

This puts you in the Screen Editor: that is, it finds and connects to a PTY
subjob (a la ⊗XSUBFIND), turns on subjob echoing (⊗XSUBECHO), moves to end
of the incore text, selects ⊗XLPEND mode, and enter the Eval loop. The
CONTROL and META bits on the ⊗X in ⊗XSCREEN select between character and
line mode, just as they do in ⊗XEVAL and ⊗XSUBLINK.

General information concerning subjobs and E

With a subjob in use, it is often convenient to have more than the normal
three lines of typeout space at the bottom of the display, especially to
make room for typeout from Lisp or a PTY. The ⊗#⊗XBOTSET command can be
used to provide this room, with the numeric argument specifying the number
of lines to be devoted to typeout (and echo) at the bottom. About 8 or 10
lines may be enough; ⊗8⊗XBOTSET gives you 8 lines. As mentioned above,
the ⊗XSUBLINK command can be used to set the amount of typeout space while
at the same time entering an Eval loop with a PTY subjob.

E normally doesn't update the display whenever a user command has been
typed ahead to E. This display update suppression is now extended also to
work if either Lisp or a PTY has output (or other E-MacLisp protocol commands)
already waiting for E to read it. E will update the display when it has
nothing else to do and would have to wait. (As has always been true, this
display update suppression can be disabled with the ⊗XDPYALWAYS command
and/or re-enabled with the ⊗XDPYSKIP command. In ⊗XDPYALWAYS mode, E will
update the display (if it has changed) after every command and after every
subjob output processing.)

When E is connected to a subjob but is idle, it goes into interrupt-wait
(INTW queue) so that it will wake up with either subjob activity or user
typein. However, whenever E is in the middle of reading or executing
a command, it will not listen for subjob output (the sole exception is
that in the ⊗XEVAL command, E is always ready for either typein or subjob
output). In particular, this means that if you have typed even just a
repeat argument (e.g., ⊗5) (or an ⊗X, or an ⊗!, or an ⊗F, etc.), then
while E is waiting for you to finish typing the command, it will not
listen for any subjob activity. This provides a reasonable way to quickly
stop subjob output while you think about what you want to do about it:
just type αX and it will stop temporarily.

E and Lisp communicate by interjob mail and by reading each other's core
image upon command. As a result, E will sometimes have to wait for a
required response from Lisp (e.g., one that indicates that Lisp has
accepted some command from E) before E can finish what it is doing and
return to idle state. When E has to wait this way, it normally waits
forever for Lisp's response. However, when E is waiting for Lisp, the
user can type ESC I to abort whatever E is doing (e.g., trying to send
text to Lisp).

If you think there may be something wrong with your Lisp subjob, and you
don't want E normally to wait forever for Lisp, then you can use the
command ⊗-⊗XSUBWAIT, which will limit E's waiting time to about 30
seconds, after which E will automatically abort. The command ⊗XSUBWAIT
restores the default, making E willing to wait forever for a required
response. With a zero argument, ⊗0⊗XSUBWAIT will report the current mode.
In ⊗XSUBWAIT (forever) mode, after about 30 seconds of waiting, E will
report that it is still waiting for a Lisp response and will remind you
that ESC I will abort the wait. No other commands can be executed while E
is waiting for a required response from Lisp.

When E first starts up Lisp, the E-MacLisp protocol prohibits E from
sending Lisp anything until Lisp reports that it is ready (finished
its initialization). You can try to send Lisp text before that point,
but if you do, then E will wait (indefinitely) for Lisp to become ready,
after reporting that fact to you. As usual, you can abort the wait by
typing ESC I.

You can use E to edit a program source file while you are debugging the
program itself through an E PTY job. However, a couple of words of
warning are due. If you are debugging a display program that tries to
shift the page printer geometry, even when being run merely on a PTY under
a display (as many display programs do), then you'll notice that E insists
on positioning the page printer exactly where it wants it, whenever it
gets a chance to. If you are using RAID to debug your (otherwise non
display-oriented) program through an E PTY, then you may want to set $M-3
nonzero to suppress RAIDs diddling of the page printer. Note that RAID
will indeed display its text on your terminal despite actually being on a
non-display PTY under your E job. Also, if you type αβE to RAID, then
RAID will end up de-activating your page printer, so that you won't see
what you type to E (or the PTY). This can be fixed by typing ⊗V to E
(remember that if you type αβE to RAID while in EVAL mode, then you are
still talking to RAID, so you can't type the ⊗V to E until you leave Eval
mode).

Things that Lisp can do to E

The E-MacLisp protocol allows the Lisp end to initiate two more types of
action, besides that of sending plain text to E (which is normally
actually a response to some command from E). These two other actions
are: (1) telling E to execute a set of E commands that Lisp specifies
(the commands are executed from inside a special macro called something
like ..LISP); and (2) asking E to tell Lisp the values of requested
readonly variables. These two capabilities give Lisp the opportunity to
take control of the editing; this is done by use of special MacLisp
functions. For details, see the MacLisp documentation of the E-MacLisp
connection, via READ EMACLSP, or consult your local MacLisp guru.

Display-update suppression

Sometimes many commands will be given to E by Lisp, so that, for instance,
Lisp can find a particular piece of an expression. While Lisp is moving
around in the file, it can be distracting (especially on DMs) to have E
often updating the display. To avoid this distracting screen updating,
you can use the command

⊗-⊗V

which updates the screen once and then suppresses further updates until
the ⊗V command is given. As in the normal ⊗V command, ⊗-αβV will erase
the screen and redisplay everything, whereas ⊗-αV will just update the
display (without necessarily redrawing everything). In a macro (e.g., in
commands from Lisp), αβV and ⊗-αβV never erase the screen -- they just
update the screen and then enable or disable further display updates.
In the explicit screen update done by ⊗-⊗V, a "V" is displayed on the
header line to remind you that a ⊗V command needs to be done to validate
the screen's display again. Note that ⊗-⊗V can be given while display
updating is suppressed, in which case its effect will be to update the
screen once and leave further updates suppressed.

Remembering Lisp jobs in TMPCOR: /nJ switch

If you exit from E without killing all of your Lisp subjobs, then E will
remember such jobs in the TMPCOR file that it uses to remember your edit
file(s) and position(s). To do this, E uses the /nJ switch, which means
job n is a Lisp-type subjob to connect to. You can of course use this
switch manually also. However, to avoid connecting to the wrong job, E
will check to see that the given job has the same login PPN as your job.
If the PPNs don't match, then E will ignore the /nJ switch. If the subjob
was started with an E command, then the PPNs will be the same. This PPN
check allows you to kill Lisp subjobs with the monitor command KILL before
returning to E (for example, if you meant to kill the subjob before
exiting but forgot, whereupon E reminded you that the subjob still exists).

The E-MacLisp protocol

The E-MacLisp protocol is based on use of interjob mail (see the MAIL UUO
in the UUO Manual). The mail contains commands and replies sent by the
two connected jobs. Small data transfers use the mail block to contain
the data, but large transfers are done by having the receiving job read
the data directly out of the sending job's core image (using the JOBRD
UUO). This provides fairly fast communication between the two jobs.

The actual startup of Lisp from E is done by starting Lisp at a special
address, namely, one less than its normal starting address. This allows
Lisp to realize that it is in communication with E. Upon being started up
this way, Lisp's initial ACs will contain the Lisp .INI filename and the E
job number, as shown below.

AC Contents
-- --------
0 Primary name of the Lisp INI file to use for initialization.
1 Left half has the INI file's extension.
3 PPN of the INI file.
6 Device of the INI file.
7 Number of the E job to communicate with.

Interjob mail provides transmission of 32-word blocks between jobs, along
with interrupt capability at the time of mail reception. The format of a
mail command or response in this protocol is as follows (this describes
the contents of the 32-word block):

Word 0: Left half contains 'EPR' in sixbit (protocol name).
Right half contains the job number of the sending job.
Word 1: Left half contains flag bits modifying the command.
Right half contains the command, represented by a small integer.
Word 2: Left half contains the negative byte count for the transfer, if any.
Right half contains the location in the sending job of the data.
Words 3 thru 31: Data bytes for the command, if they fit in 29 words.

Here are the possible commands (right half of word 1):

0 No-operation.
1 (undefined)
2 OK: finished initialization, or finished reading your core image.
3 From E: here is some input text for Lisp, in 9-bit bytes.
From Lisp: here is some output text from Lisp, in 7-bit bytes.
4 From E: explicit eof for input (currently unused in E).
5 From Lisp: here are some commands to execute in a macro.
The commands are in 7-bit text using standard and/or
alternate macro definition representations (see p. 25).
6 From E: simulate ESC I <char>, where <char> is right adjusted in word 2.
7 From E: close the connection and go away (kills Lisp job).
8 From Lisp: please report the values of the named readonly variables,
the names are in SIXBIT, one per 36-bit byte (no dots
in the names).
8 From E: here are the values of the named readonly variables;
the data alternates, starting with a readonly variable
name then the corresponding value, each in a 36-bit byte.
Undefined names will not be acknowledged by E.

And here are the command flags (left half of word 1):

1,,0 This is a short transfer, contained entirely in the mail block.
2,,0 This is a long transfer that cannot be done in a single JOBRD;
sender will send more continued data after receiver acknowledges
receipt of current data (i.e., finishes current JOBRD). Sender
must NOT try to send more than one piece of the transfer before
getting the resulting OK response (type 2 -- core image read done).
Multiple Windows: ⊗π ⊗G ⊗≠ ⊗XCONTINUE ⊗XEXIT ⊗XQUIT ⊗XBOTSET ⊗XTOPSET ⊗XRAISEWINDOW ⊗XTRADEWINDOW

Modes Command Meaning
N αE Write out the current window, close it (exit if only window)
N αβE Write out all windows and exit to the monitor
N,A αG Go to previous window in window stack
N,A αβG Go to Nth previous window, where N is current default arg
N,A ⊗0αG Type out window stack
N,A ⊗0αβG Type out default arg for αβG command
N,A ⊗#αG Go to #th previous window
N,A ⊗#αβG Go to #th previous window and set default arg to #
N,A ⊗-⊗#⊗G Go to #th previous window and pop # windows off top of stack
N,A ⊗+⊗#⊗G Re-push # windows back onto top of stack and go to new top
N,A ⊗π Open new current-size window (if next cmd switches files).
N,A ⊗#⊗π Open a #-line new window (if next cmd switches files).
N,A ⊗0⊗π Open a half-size new window (if next cmd switches files).
N,A ⊗≠ Go to next window lower on screen (wrapping around).
N,A ⊗#⊗≠ Go to #th window lower on screen (wrapping around).
N,A ⊗-⊗≠ Go to next window higher on screen (wrapping around).
N,A BOTSET Position bottom edge of current window
N,A CONTINUE Re-open last previously closed window
N EXIT Exit to monitor (or close # windows if more present)
N,A,E QUIT Exit (or close # windows) w/o writing out file
N,A RAISEWINDOW Raise the current window # lines on the screen
N,A TOPSET Position top edge of current window
N,A TRADEWINDOW Close current window and re-open previously closed one

The basic idea of multiple windows is this: You can have up to about 8
different windows open at any time, with one file open in each window.
Thus you can have up to 8 files all open at once. A big benefit of this
is that you can switch between such files very rapidly, since all the
files are kept in core (that is, for each window, the current page of that
window's file is in core) and switching windows does NOT cause a file to
be written out nor any disk reads to be done. Each window can be
displayed anywhere on your screen. Different windows can be positioned in
exactly the same screen area, or they can overlap somewhat, or they can be
non-intersecting, and of course they can be moved around at will. A given
window always uses whole lines on the screen; windows cannot be separated
horizontally, only vertically (that is, they can't be side by side, but
they can be one above the other).

A special warning: Don't forget that every window has a file open in it.
You can accidentally leave files open this way (and not written out --
changing windows does NOT write out the current one), and possibly block
others from using those files without your realizing it. Also, if you
manage to get the same file open in two different windows, then you won't
be able to write out either of those windows and any attempt to do so will
give you the usual File Busy error that dumps you out of E, at which point
REENTERing is about your only choice. For this reason, E warns you
whenever you successfully get a file open in two or more windows, and it
will not let you use the ⊗H, ⊗XHOME or ⊗? commands to go to a file already
open in another window (you CAN use ⊗ε or ⊗λ to open a file multiply).

At any given time, there is a "current" window. That's the window whose
file will be affected by any editing commands, and it's also the window
in which the attach buffer (if any) will be displayed. However, there are
various simple commands to move to another window (or to create a new
window), thus making it the current one. When you move from one window to
another, any attach buffer goes along with you. There is only one
attach buffer (not one per window), and it is always displayed in the
current window (just above the current line within that window).

Although overlapping windows may obscure parts of each other, the current
window is always completely visible. Non-current windows may be visible
in part or in whole, provided they extend to parts of the screen not used
by the current window. Selecting a window (i.e., making it the current
one) can be thought of as placing that window on the screen on top of the
pile of other recently visited windows, where they sit on the screen,
thus possibly obscuring such previous windows.

Although windows can be positioned arbitrarily on the screen, there are
two common ways for a group of windows to share screen space. The first of
these is for the windows to overlap completely, so that each uses the
same set of lines on the screen. In this case, only one of the
windows will ever be visible at a time, but each window is of maximum size
(for the given screen area). The other common situation is for the
windows to butt up against each other, one right above the other, with no
overlap and no wasted lines in between. This arrangement lets you see all
of the text in each window, at the expense of making each one smaller than
the maximum for the given total screen area. Windows with this
relationship do not, of course, need to be of the same size. Furthermore,
these two basic ways of positioning windows can be easily combined, say
with one window using the top half of the screen and several other windows
each using the entire bottom half, or with one window using the whole
screen and two or more other windows each using half of the screen.

In line with the above two basic screen sharing techniques, there are two
ways that the position for a new window can be set up: (1) the new window
can be given the exact screen area that the current window has (this is
the default), thus totally obliterating (for the time being) the old
window, or (2) the new window can take away some screen lines from the
current window so that the two of them can both be entirely visible at the
same time. In case (2), the default is to split the current window in
half, giving half to the new window and half to the old. You can also
specify the exact number of lines to be used for the new window in (2),
but every window must possess at least 3 lines (of text space). Once you
have set up a new window's position using (1) or (2), you can adjust it at
will to anywhere on the screen (for example, with ⊗XBOTSET and ⊗XTOPSET,
described later).

CREATING A NEW WINDOW: THE ⊗π COMMAND

To create a new window, you use the ⊗π command immediately preceding a
file-switching command, for example:
⊗π⊗λ<filename><cr> ;Makes new window same size as old.
or
⊗0⊗π⊗ε<filename><cr> ;Makes new & old windows half old size of old.
The given file will be opened in the new window. With no numeric
argument, ⊗π makes the new window use the same lines as the old. With any
argument at all, ⊗π will take lines away from the current window and give
them to the new window. The argument specifies how many lines the new
window gets. If the arg is zero, ⊗0⊗π makes the new window use half of
the old one. With an unsigned non-zero arg, ⊗#⊗π gives the new window #
lines (with the 3-line minimum per window). And with a signed arg, ⊗+⊗#⊗π
or ⊗-⊗#⊗π add or subtract # lines from half the old window size to
determine the new window size (reducing the old window's size). For
example, ⊗1⊗π⊗λ... will create a minimum size new window, and ⊗∞⊗π⊗λ...
will reduce the old window to minimum size. When the old window is being
split to make room for a new one (i.e., an argument was used with ⊗π), the
new window will be placed in the top part of the old window if the arrow
was in the bottom half of the old window, and vice versa ("bottom half"
here means with respect to the actual lines displayed, in case of a short
page that doesn't fill up the window). Thus, E tries to leave the
remaining part of the old window's text unmoved from its previous position
on the screen, with the arrow line still visible.

The ⊗π command works with all the file-switching commands, namely, ⊗ε, ⊗λ,
⊗?, ⊗H, ⊗XHOME, ⊗XPOINTER, and ⊗#⊗∃, and the arguments on these commands
are interpreted just like they would be if the ⊗π were not included (see
these individual commands' writeups). For instance, ⊗9⊗π⊗2⊗0⊗? opens a
9-line window at page 20 of E.ALS. If you abort any of these
file-switching commands (one way or another), the new window is also
aborted; but the exciting thing is that this aborting is very fast, since
the original file doesn't have to be read back in -- its window still has
the file open.

To abort a ⊗π command, type <altmode>. This works quickly even if you
have already said ⊗π⊗ε when you type the <altmode>!

THE WINDOW STACK AND THE ⊗G COMMAND

E maintains a stack of windows visited, and the ⊗G command is used to Go
to another window from the stack. The arguments to ⊗G are interpreted
just like the arguments to the other stack commands ⊗H, ⊗N, ⊗O. For
example, αG goes to the previous window, αβG to the 2nd previous one (by
default), and ⊗0αG lists the window stack, naming the file open in each
window. See the description of the stack commands on p. 34. The ⊗G
command is the recommended way of switching between windows (once the
windows have been created with ⊗π).

THE ⊗≠ COMMAND

In addition to the ⊗G command for selecting a window from the stack,
there is the ⊗≠ command for moving to the next window lower down on the
screen (as opposed to on the stack). This command checks all windows,
including those currently not visible on the screen, and wraps around from
the bottom to the top of the screen, when looking for the next lower
window. To determine which of two windows is lower, ⊗≠ uses their top
edges; if those are the same, then the bottom edges are used; if those too
are the same, then age of window is used to break the tie so that a series
of ⊗≠ commands will cycle geographically through all the windows.

CLOSING AND RE-OPENING WINDOWS

If you type αE, then the current window is written out and closed. If it
is the only window, then E exits, else it returns to the previous window
on the stack. Once a window has been closed, you can't get back to it
except by re-opening it. This can be done with the command ⊗XCONTINUE
(like the monitor command CONTINUE that returns to E after you have
exited). Normally E only remembers one closed window, but you can set the
number it will remember with ⊗-⊗#⊗XCONTINUE. ⊗0⊗XCONTINUE tells what
closed windows there are (and the maximum number if other than 1). At any
given time, you can re-open only the last window closed (in other words,
it's a stack of closed windows). (By the way, unlike the monitor command
CONTINUE, ⊗XCONTINUE cannot be abbreviated to anything shorter than
⊗XCONTI because of another similar command name.)

If you want to close all your windows at once and exit to the monitor,
give the command αβE (⊗XEXIT does exactly the same thing). This will
write out your files, one at a time, and finally exit. (From inside a
macro, αE and αβE cannot be used to close a window or exit -- you must
use ⊗#⊗XEXIT or ⊗XEXIT to carry out those functions from a macro, since ⊗E
also sometimes means put down the attach buffer). Exiting may require you
to reaffirm READWRITE or READONLY mode one or more times -- once for each
file with the W flag set in /R mode. The name of each such file, however,
is typed along the the message about reaffirming the mode.

The ⊗XQUIT command can be used to exit to the monitor without writing
out any files, no matter how many windows are open.

After αβE (or ⊗XEXIT) or ⊗XQUIT command, you can return to E by
immediately giving the monitor command CONTINUE, at which point all your
previous windows will still exist.

If either the ⊗#⊗XEXIT or ⊗#⊗XQUIT command is given with a numeric
argument, then the given number of windows are closed (writing them out
iff ⊗XEXIT was used). If that closes all windows, then E will exit to the
monitor. Whenever a group of windows are all closed simultaneously like
this, E remembers all of these closed windows so that you can re-open
them, for instance in case you didn't really mean to do it. However,
subsequently closing another window may cause E to forget about previously
closed windows (depending on the current number of such windows E will
remember, set by the ⊗-⊗#⊗XCONTINUE command, as described above).

A less common command exists for re-opening a closed window, especially
when you already have the maximum number of windows open. This is the
⊗XTRADEWINDOW command, which trades the current window (closes it) for the
most recently killed window (re-opens it). If you tried to do that with
separate commands, you would either exceed the maximum number of open
windows or else end up closing and re-opening the same window. This
command probably isn't very useful, but it's here just in case (at least
until I decide it can't possibly be of any use).

A closed window doesn't have any file open, although the file information
is remembered in core; thus re-opening a window is pretty fast, although E
does have to do a LOOKUP (but normally without re-reading the file).

Usually when a closed window is re-opened, it is restored to its previous
position on the screen. However, if the page printer has been moved up
since then, the re-opened window may be moved up automatically in order
to avoid overlapping the page printer area.

WINDOW HEADERS AND TRAILERS

In displaying multiple windows, E conserves screen lines by normally
displaying only one trailer line for the entire screen. Each window,
however, gets its own header line, and these are generally used to delimit
the various windows. The trailer appears at the bottom of the screen but
contains info from the current window, no matter where that window is.
However, if a window holds a short page, then the trailer for that window
may appear within the window. You can actually force each window to have
its trailer line displayed just below it by making that line not be used
by any windows (⊗+⊗XBOTSET will do it for any window but the bottommost
one, provided there are no overlapping windows).

A window may not be displayed at all, despite having screen lines that are
not covered up by other windows, if the window contains a short page all
of whose lines ARE obscured by another (more-recently-visited) window.

The current window's header line displays "h" if there are any hidden
windows open or "hw" if any hidden window has the W flag set (its page
needs to be written out). (A hidden window is one that is completely
obscured by one or more other windows.) Thus "hw" means one or more
hidden windows need their pages written out, whereas just "h" means there
are hidden windows but none needs to be written out. This way, you can
always see on the screen whether any windows haven't yet been written out
(any partially visible window will always have a header line displayed on
which any W flag will be clearly visible).

ALLOCATION OF SCREEN LINES TO WINDOWS

Whenever you visit (or "select") a given window, all of that window's
normally used screen lines are automatically claimed by that window.
Any line not used by that window, but which was previously claimed by some
other window, remains claimed by the previous window and continues to show
some piece of that other window. Since it is possible to have a small
window positioned in the middle of a larger one (although this is not
particularly a recommended technique), such a situation can result in the
displaying of two or more header lines from the bigger window, one for
each contiguous visible segment of that bigger window. The header lines
are needed to delimit the texts of the different windows. Similarly,
although normally only one trailer line is present at the bottom of the
screen, other trailer lines may be displayed when necessary to delimit
window text. Sometimes such a special delimiting trailer will contain
just dots (....) or stars (****) with nothing else, but the significance
of the dots versus stars has the usual meaning -- dots if there is more
text on the page and stars if not. The current window is always
guaranteed to have its full normal trailer visible, either at the bottom
of the window or at the bottom of the screen.

When you close a window (as with αE), the screen lines from that window
will automatically be given to any adjacent, currently-visible window
(possibly making such a window larger than it used to be). When you move
a window up or down on the screen, screen lines released will be claimed
by any adjacent visible window that includes those lines, but in this case
the window is never made larger (although more of it may become visible).

Although αE (if only closing a window) normally gives the current window's
screen lines to some other window, ⊗XCONTINUE to re-open a closed window
does not reduce the number of lines used by any other windows, since at
that point E has forgotten whether or not the αE gave away any lines. So
⊗XCONTINUE may result in more overlapped lines than you had before the αE.
However, you can fix that, if you want, with the ⊗XTOPSET and ⊗XBOTSET
commands described below.

MOVING WINDOWS AROUND ON THE SCREEN: ⊗XTOPSET, ⊗XBOTSET, ⊗XRAISEWINDOW, ⊗XHEIGHT

You can move a window around on the screen with any of the various commands
described below.

The commands ⊗XTOPSET and ⊗XBOTSET move the top and bottom edges,
respectively, of the current window, without affecting the opposite edge.
Thus these commands generally change the size of the current window. The
argument to either of these commands is the number of lines above the top,
or below the bottom, of the window. However, with no argument at all,
these commands normalize the position of the top or bottom of the window,
basically pushing it back out to the original starting position for the
one-window edge. (Of course, you may have moved the edge out beyond that
point, so these normalizing commands might have to pull the edge back in,
to that point instead of pushing it out to there.)

If you want to move an edge by a few lines, you can use a relative
argument to TOPSET or BOTSET. E.g., ⊗-⊗3⊗XBOTSET will move the bottom edge
down 3 lines and ⊗+⊗2⊗XTOPSET will move the top down 2 lines. The signed
argument is added to the current distance from the edge of the screen. As
usual, you're not allowed to move an edge so much that the window becomes
less than 3 lines high.

Another way to move a window is with the command ⊗XRAISEWINDOW, which
raises both the top and bottom edges of the window by the amount of the
argument, limited by the edge of the screen and the minimum window size.
A negative argument, of course, will move the window down instead of up.
Note that this command may actually shrink the window size if you bump
against the edge of the screen. The default argument here is 1.

The page printer is not allowed to overlap with any windows, so you are
not allowed to move the bottom edge of a window down below the top of the
page printer. However, attempts to move the bottom of a window will
automatically move the top of the page printer down if necessary and up if
possible. Thus, with only one window, ⊗1⊗0⊗XBOTSET will make a 10 line
page printer, but the same command given with two windows that exactly
overlap will not affect the page printer size or position at all. In
order to make a big page printer area in the latter case, you must move
the bottoms of both windows up, for example by giving the ⊗1⊗0⊗XBOTSET
command from each window.

The ⊗XHEIGHT command can be used to change the size of the current window,
leaving its top edge unchanged. This command does NOT change the page
printer size, although it may change its position (if it can do so without
moving it over any window's bottom edge).

NOTE: The maximum attach buffer display size is automatically adjusted to
fit the size of the current window, always leaving at least two lines of
the window for normal text. The minimum value of the maximum attach
buffer display is 1 line (it can't be invisible); hence adding in the 2
normal text lines that are required to be available, you get the 3-line
minimum window size. The user can still set the normal maximum attach
buffer display size (whose default is 8 lines, set with the ⊗#⊗XATTSET
command), but the current value of this maximum display size is
automatically limited by the window size.

MISCELLANEOUS NOTES ON WINDOWS

Since E keeps one file in core for every window open, using multiple
windows tends to use more core than one window would. Normally this
shouldn't be a problem, but if you try to maintain several windows, each
with a large page (and/or large file) in core, then E may run out of core
(it'll tell you one way or another). Of course, this can also happen with
only a single window and a huge page. If you have many windows open, it
doesn't hurt to glance at your core size in the wholine. When it tries to
go beyond 256P, you're in trouble.

With the use of multiple windows, the file stack is updated any time
you change files, either explicitly within a window or implicitly
by changing windows. Thus the file stack always represents the stack
of files most recently visited in one window or another. If you keep
each file in a separate window, you can ignore the file stack completely
and reference only the window stack instead.

If you always use ⊗π⊗ε or ⊗π⊗λ instead of ⊗ε and ⊗λ, you can then always
use ⊗G instead of ⊗H and get the same effect of switching files that you
used to, except that the file switching will be much faster than before.
In this case, each window will use the entire screen.

Even if you exit from E with multiple windows set up, returning to E via
ET<cr> with no arguments will not restore multiple windows. It will
simply open the last file you were in before exiting. Files previously
open in other windows may, however, appear in the file stack upon your
return to E, and you can open them in other windows with commands like
⊗π⊗ε/2H<cr>. Of course, E currently remembers only the last three files
upon being restarted with ET.

Any command that tries to write out the page will fail (the command will
be aborted) if you have the current file open in two different windows.
The same is true for the ⊗XOPEN command. You must close one such window
before you can write out the file or use ⊗XOPEN.

The ⊗XZFILES command flushes from E's list of remembered files all files
except the current ones in the various open or closed windows. When done,
⊗XZFILES types out the list of remaining files (except in terse mode).

When E's list of files is full and room is needed for another file, E will
flush the file deepest on the file stack that is not the current file in
any open or closed window. If there are no such files that E can flush,
it will flush a closed window and its file. This is always possible since
E will not let you have more open windows than there are slots in E's list
of filenames (currently 7 or 8).

Non-displays can have multiple windows too. Of course, on a non-display
you only get to see one line of the current window at a time, but multiple
windows still allow you to keep several files open at once, thus making
for fast file switching. Whenever you switch windows on a non-display,
the new window's filename is typed out, along with the page and line
numbers and text of the current line.

Header flags and their meanings

The following one- or two-letter flags may appear on E's header line
on a display. These flags generally report the state of the edit. Some
apply globally to E's state, and others apply only to one window. The
global flags are always displayed on the current window's header (in the
case of multiple windows). Flags relevant to a single wiidow will appear
on that window's header.

The first two flags always appear after the filename in the header.

/-A autoburp mode is disabled
/R file is open in Readonly mode

The next two flags apply to a single window.

W incore version of the page has changed without being updated on disk
U the directory on the disk needs to be Updated

The remaining flags apply to the overall state of the edit.

I line Insert mode is in effect
A some text is in the Attach buffer
M a Macro definition is in progress
E Eval mode is in effect -- all type-in goes to a subjob
R a multiline extended command (⊗X) is being typed
V display updating has been disabled

h one or more open windows are Hidden from view
hw one or more open windows are Hidden and need to be written out (W flag on)
t subjob output mode is Type-out
a subjob output mode is Attach
p subjob output mode is insert at Page-end
f subjob output mode is insert in File at current line
What to do if E can't open your file to write it out

Of course, with all of E available, there are lots of other things you
could do to save your text, such as mailing it to yourself (from E) or
copying it to another file (say, using multiple windows).

File renaming or deleting: ⊗XRENAME ⊗XFILEDELETE

N,E RENAME Rename the current file to the new name given
N,E FILEDELETE Mark the current file to be deleted when closed

It is possible within E to rename or delete the file you are editing.

The command ⊗XRENAME <newname><cr> renames the current file being edited
to the new name given. If a file already exists with the new name, E will
ask you if you want to replace it with the current file (renamed) (that
is, if you want E to delete the old file of that name so that the current
file can be renamed). The current file's old filename is removed from the
file list. Any filename parts omitted from <newname> in this command will
default to their current values. For example, ⊗XRENAME .TXT will simply
change the extension of the current file to .TXT; and ⊗XRENAME [ppn] will
rename the file to the new ppn given, without changing the basic filename.
⊗XRENAME is not legal in ReadOnly mode.

The command ⊗XFileDelete marks the current file for deleting. The file
will be deleted as soon as you exit from it -- that is, when you cause E
to close that file completely (e.g., with ⊗H, ⊗E, ⊗XEXIT, ⊗ε, ⊗λ, etc.).
Note that simply changing to another window (say, with αG) after giving
the ⊗XFileDelete command does not cause E to close the file and therefore
will not cause E to delete it at that time (although E will still remember
that the file is to be deleted later). Any altering of the incore text,
switching to another page, or changing to ⊗XReadOnly mode will
automatically remove the deletion mark, preventing the file's deletion
(except by a later ⊗XFileDelete cmd). Thus, the ⊗XFileDelete command
should generally be given just before you leave the file. When the file
is actually deleted, E will type out a message to that effect (both at the
bottom of the screen and on the page printer that you see when you exit
from E) and will move that filename to the bottom of the file stack. The
command ⊗0⊗XFileDelete will tell you if the current file has been marked
for deleting, and with a negative argument ⊗-⊗XFileDelete will remove the
deletion mark, to avoid deleting the file. Finally, the ⊗XFileDelete
command cannot be abbreviated to less that six letters (⊗XFileDe) and is
not legal in ReadOnly mode (except in the forms with zero and negative
args: ⊗0⊗XFileDelete and ⊗-⊗XFileDelete).

Sending message to users and/or terminals from E: ⊗XMAIL ⊗XSEND ⊗XREMIND

N,A,S MAIL Mail a message to someone
N,A,S REMIND Enter a REMIND-system reminder
N,A,S SEND Send a message to someone logged in

E can be used to send messages to users and their terminals and to
enter reminders for later delivery. These things are done with the
commands:

⊗#⊗XMAIL <destinations and switches>
⊗#⊗XSEND <destinations and switches>
⊗#⊗XREMIND <destinations and switches>

Execute a system MAIL, SEND or REMIND command using lines
from the incore text or attach buffer. If a numeric arg
is given with any of these commands, only that many lines
of text are included in the message, else the whole attach
buffer (if any) or all incore text is used. Leading blank
lines are excluded from the text given to MAIL (in order
to make the ⊗! command useful for specifying the range of
text). If a zero arg is used, a one-line message can be
sent entirely from the ⊗X-command line (no text from page
or attach buffer sent). For example, ⊗0⊗XSEND ME Hey, it
really works!<cr> will send ME the message "Hey, it really
works!" You can also use the command line to include a
subject or an initial text line ahead of the message text
being output from the page (or attach buffer). That is,
α!⊗XMAIL/SUBJECT PRG Sending mail from E<cr> will mail the
current paragraph to PRG with the subject "Sending mail
from E".

These commands are executed by starting up another job
running the MAIL program. When that job finishes, it will
type out a message on your terminal reporting the success
or failure of the command. Detailed information on
failure is not given.

When there are no job slots for E to start up a MAIL job,
mail sent from E is queued (by writing it into a special
file on RMD,SYS which will get processed later
automatically). You are told when this is happening, and
you will eventually be notified of the success or failure
of the mail delivery.

Also, whenever the MAIL program detects an error in mail
coming from E, it will mail the whole message and command
back to the sender with an appropriate message prefixed to
it.

See Appendix 4 in the Monitor Command Manual for full
details on the form of switches and destinations for these
commands.

∂16-Feb-83 0216 ME ⊗XMAIL documentation
The basic idea of ⊗XMAIL, ⊗XSEND and ⊗XREMIND in E is that you can have
the text for the command taken from the command line(s) and/or the page or
attach buffer (see below about multiple-line command text). "Text"
includes all the destinations, switches, subject and message text, not
just the latter. Any command line text is inserted ahead of any page or
attach buffer text. MAIL will interpret the "text" from E almost exactly
the way it would if you typed it from a terminal -- starting with the
command (MAIL, SEND or REMIND), then global switches, destinations with
optional switches, then subject, then message text -- except that since
MAIL can't prompt for a subject (or anything else), it won't assume a
subject unless you use the /SUBJECT (/SU) switch. Destinations, as usual,
are separated by commas and can be followed by switches. When the
destinations end (no comma after last one), if there is a /SUBJECT switch,
then the subject comes from the next piece of text to the end of its line
(this can be on the same line as the destinations, or on the following
line). Everything else is taken as message text. This means that you can
point at the next blank line below and say ⊗4⊗XSEND<cr> to do what it
says:

ME/su this text is the subject
This line is the first line of the message, being sent to ME.
Second and last line of message.

Of course, you could have pointed to the line after the blank line and
used ⊗3 instead of ⊗4. MAIL requires at least one destination, so it will
find it even if it follows a blank line. Also, leading blank lines from
the page or attach buffer are not passed to MAIL, thus making ⊗! very
handy for specifying the range of text to be sent. You can send the same
message as above with α!⊗XSEND<cr> while pointing anywhere in the next
"paragraph".

ME/su
this text is the subject
This line is the first line of the message, being sent to ME.
Second and last line of message.

Or you can do the same with α!⊗XSEND ME/su<cr> while pointing anywhere in
the following "paragraph".

this text is the subject
This line is the first line of the message, being sent to ME.
Second and last line of message.

Or you can do the same with α!⊗XSEND ME/su this text is the subject<cr>
while pointing anywhere in the next "paragraph".

This line is the first line of the message, being sent to ME.
Second and last line of message.

Or, you can type the whole thing in the extended command itself, using a
"multiple-line" extended command. This is done by ending the extended
command line with a linefeed <LF> instead of a carriage return <CR>. Then
type any number of additional lines, terminating them with the end-of-file
character: αβ<LF> on displays, ↑Z on non-displays. The following example
will send the same message as above, this time all typed by the user in a
multiple-line SEND command. Note the <LF> ending the command line.

⊗0⊗XSEND ME/su this text is the subject<LF>
This line is the first line of the message, being sent to ME.<CR>
Second and last line of message.αβ<LF>

This is particularly useful for prefacing some file text with a message
that you don't want to edit into the file, although you are sending the
text from the file. For instance, the command:

⊗XMAIL ME/su this text is the subject<LF>
This line is the first line of the message, being sent to ME.αβ<LF>

will insert the given subject and first message line ahead of the text
from the entire page as it is handed to MAIL.

While you are entering addition lines of a multiple-line command (command
line ended with <lf>), (1) an "R" is displayed in the header line at the
top of the screen, and (2) typing an <altmode> will abort the entire
command. E will insert a <cr><lf> at the αβ<lf> (or ↑Z) if one does not
already precede it.

In text handed to MAIL, any typed-in <formfeed> not preceded or followed
by a <cr><lf> will be turned into a <cr><lf>, and other <formfeed>'s will
be ignored. All text taken from the extended command line(s) (one or more
lines) is placed ahead of any text being sent from the page or attach
buffer.

Here's an example of using a typed-in <formfeed> in a command. Notice how
it gets a subject and two lines of message all in the one line of the
extended command.

⊗0⊗XMAIL/SU ME The subject<formfeed>First line..<formfeed>Another line..<cr>

Now here's a more complicated example, using multiple destinations on
separate lines. The command typed is simply ⊗XMAIL<cr> and everything
else comes from the current page, which looks like this:

/SUB
frost%Shasta,
frost%Diablo,
ME%Score/CC, ME%Sierra
this is the subject
Now here begins the text of the message, from here to the end of the
page (since no numeric argument to ⊗XMAIL was given). The
destinations continue until one ("ME%Sierra" here) isn't followed by a
comma. The next text is the subject (which could have been on the
same line as the last destination, although it isn't here), and then
comes the message proper.

To recap, the basic idea for the ⊗XMAIL, ⊗XSEND and ⊗XREMIND commands is
simply that the text you specify should contain the following, in this
order: (1) any optional global switches, (2) the destinations and their
optional switches, (3) an optional subject (if /SUBJECT present), and
finally (4) the message proper. Pieces of this text can come from (a) the
extended-command line, (b) continuation lines of the extended command,
and (c) the incore text or the attach buffer.