12/3/73 MONDAY DEC 03,1973 LISP 686 - GLS, JONL -
NOT-SO-BRIEF SYNOPSIS:
[0] TRY BLISP! (THIS IS, AT LONG LAST, THE FAMOUS "BIBOP LISP".)
INFO ON BIBOP LISP IS AT THE *END* OF THIS LISP RECENT,
AND ALSO ON .INFO.;BIBOP (MEMO). THE LATTER IS TJ6'D,
SUITABLE FOR OUTPUTTING TO THE XGP OR LPT. IF YOU
ARE DEEPLY CONCERNED WITH THE INNER WORKINGS OF LISP,
E.G. YOU MAKE UP AND DUMP CONNIVERS OR MACSYMAS, SEE
GLS OR JONL IN ROOM 834 FOR AN ILLUSTRATED BIBOP MEMO
AND/OR A LONG-WINDED EXPLANATION.
[1] NUMBERP, FIXP, FLOATP, BIGP RETURN T OR NIL, NOT ARG
[2] CURSORPOS EXTENDED
[3] NEW FUNCTIONS:
[3A] COPYSYMBOL
[3B] SYSP
[3C] ALLOC
[4] NOINTERRUPT NOW RETURNS OLD STATE
[5] NEW SWITCH FOR ARITHMETIC UNDERFLOW: ZUNDERFLOW
[6] GRIND0 AND SPRINTER NOW AUTOLOAD
[7] DISINI TAKES SECOND ARG TO USE GT40
[8] GCMIN HAS DISAPPEARED; NEW GC-LOSSAGE AND GC-DAEMON ARGS
[9] COMPLR HAS TWO READTABLES
----------------------------------------------------------------
[1] FOR VARIOUS REASONS HAVING TO DO WITH EFFICIENCY OF CODE
PRODUCED BY THE NUMBER COMPILER (NCOMPLR), NUMBERP, FIXP,
FLOATP, AND BIGP NOW ALWAYS RETURN T OR NIL, AND NEVER THEIR
ARGUMENTS AS THEY USED TO.
[2] CURSORPOS HAS BEEN EXTENDED IN TWO WAYS:
[2A] IN THE TWO-ARGUMENT FORM, AN ARGUMENT OF NIL MEANS
DON'T CHANGE THAT COORDINATE.
[2B] CURSORPOS MAY BE CALLED WITH ONE ARGUMENT, WHICH
SHOULD BE EITHER A SINGLE-CHARACTER OBJECT (AN
ATOMIC SYMBOL, THE FIRST CHARACTER OF WHICH IS USED)
OR A FIXNUM BETWEEN 0 AND 177 SPECIFYING THE ASCII
VALUE OF A CHARACTER. A LIST OF VALID CHARACTERS
AND THEIR ACTIONS (HACKERS WILL NOTE THAT THESE
ARE CONTROL-P TTY CODES):
CHARACTER FUNCTION
C CLEAR SCREEN AND HOME UP
F MOVE CURSOR FORWARD NON-DESTRUCTIVELY
B MOVE CURSOR BACKWARD
D MOVE CURSOR DOWN (LINE FEED)
U MOVE CURSOR UP (LINE STARVE)
] KILL FROM CURSOR TO END OF LINE
E KILL FROM CURSOR TO END OF SCREEN
T HOME UP, DO NOT CLEAR SCREEN
M,N CONNECTED TO **MORE** FEATURE,
NOT VERY WELL DEFINED. USE AT
YOUR OWN RISK.
NOTE THAT R AND S ARE NOT PERMITTED, SINCE LISP
USES THOSE CODES FOR ITS ONW PURPOSES. IF
YOU FEED AN INVALID CHARACTER TO CURSORPOS, IT
WILL GIVE A CORRECTABLE WRNG-TYPE-ARG ERROR.
[3] THREE NEW FUNCTIONS: COPYSYMBOL, SYSP, AND ALLOC.
[3A] COPYSYMBOL IS A SUBR OF TWO ARGUMENTS. THE FIRST MUST
BE AN ATOMIC SYMBOL, AND THE SECOND IS A FLAG. IT
RETURNS A COPY (NON-INTERNED!) OF THE ATOMIC SYMBOL.
THIS COPY WILL HAVE THE SAME PRINT NAME AS THE OLD ONE.
IF THE FLAG IS NIL, THE NEW SYMBOL WILL HAVE NO OTHER
PROPERTIES OR VALUE. IF THE FLAG IS NON-NIL, IT WILL
HAVE THE SAME PROPERTIES AS THE OLD ONE. NOTE THAT
ALTHOUGH VALUES OF PROPERTIES WILL BE EQ, SECTIONS
OF PROPERTY LIST WILL NOT; THUS PUTTING A PROPERTY
ONTO THE OLD ATOM AFTERWARD WILL NOT AFFECT THE NEW
ONE, AND VICE VERSA. IF THE OLD ATOM HAD A VALUE,
THE NEW ONE WILL HAVE ITS OWN VALUE CELL, BUT THE
SAME VALUE IN THAT VALUE CELL. ARGS PROPERTIES,
SUBR PROPERTIES, ETC. WILL BE TRANSFERRED IN AN
APPROPRIATE MANNER.
THIS IS THE RECOMMENDED WAY TO CREATE NEW ATOMIC SYMBOLS
(MAKNAM AND GENSYM ARE ALSO RECOMMENDED). THE OLD
TECHNIQUE (THAT'S A POLITE TERM FOR A CROCK) OF
SAYING (CONS (CAR NIL) (CDR <ATOM>)) DOES NOT WORK
ON MULTICS AND WILL NOT WORK ON THE NEW PDP-10 BIBOP
LISP, AND IS THEREFORE HIGHLY DISCOURAGED.
[3B] SYSP IS A SUBR OF ONE ARGUMENT. IF ITS ARGUMENT IS A
SUBR PROPERTY WHICH IS THAT OF SOME SYSTEM SUBR (AS
OPPOSED TO A USER SUBR), OR AN ATOMIC SYMBOL WITH
SUCH A PROPERTY, THEN SYSP RETURNS T, OTHERWISE NIL.
THIS IS USED PRIMARILY BY COMPLR.
EXAMPLES: (SYSP 'CAR) => T
(SYSP 'FOO) => NIL
(SYSP 47) => NIL
[3C] ALLOC IS A SUBR OF ONE ARGUMENT, WHICH CAN BE USED
TO SET THE GCMIN PARAMETERS FOR VARIOUS SPACES. (NOTE
THAT THE VARIABLE GCMIN HAS DISAPPEARED - SEE [8] BELOW.)
IT TAKES A PAIRED LIST; THE FIRST ITEM OF EACH PAIR
SHOULD BE THE NAME OF A SPACE (LIST, FIXNUM, OR FLONUM),
AND THE SECOND SHOULD BE OF THE FORM (NIL NIL <FIXNUM>).
THE FIXNUM IS USED TO SET THE GCMIN. THIS STRANGE FORMAT
IS FOR COMPATIBLITY WITH BIBOP; SEE BELOW.
EXAMPLE: TO SET THE GCMIN FOR LIST TO 333, AND FOR FLONUM
TO 22, LEAVING THE FIXNUM GCMIN ALONE, SAY:
(ALLOC '(LIST (NIL NIL 333) FLONUM (NIL NIL 22)))
TO EXAMINE THE GCMINS, SAY (ALLOC T) AND YOU WILL
GET BACK A LIST SUITABLE FOR USE AS AN ARGUMENT TO ALLOC,
CONTAINING THE CURRENT STATES OF THE GCMINS.
[4] THE NOINTERRUPT FUNCTION DESCRIBED IN THE LAST LISP RECENT
HAS BEEN ALTERED SO THAT IT ALWAYS RETURNS THE PREVIOUS
STATE OF THE SWITCH, RATHER THAN ITS ARGUMENT. THUS ONE
MAY "PUSH" AND "POP" THE STATE OF THIS SWITCH.
[5] MOST OF THE FLONUM ARITHMETIC FUNCTIONS GIVE AN ERROR
"ARITHMETIC UNDERFLOW" IF UNDERFLOW OCCURS DURING SOME
COMPUTATION. SETTING THE VARIABLE ZUNDERFLOW TO NON-NIL
CAUSES 0 TO BE RETURNED INSTEAD WHEN UNDERFLOW OCCURS.
IN PARTICULAR
((LAMBDA (ZUNDERFLOW)
(LIST (TIMES 1.0E-20 1.0E-20)
(*$ 1.0E-20 1.0E-20)
(EXPT 1.0E-20 2)))
T)
WILL RETURN (0.0 0.0 0.0). NOTE THAT UNDERFLOW DETECTION
WILL NOT OCCUR IN NUMERICAL CODE OPEN-CODED BY NCOMPLR;
ONLY CLOSED (OR INTERPRETED) CALLS TO LISP SYSTEM SUBRS
WILL DETECT THIS.
[6] SPRINTER AND GRIND0 NOW AUTOLOAD.
SPRINTER IS MERELY A "PRETTY-PRINT" FUNCTION FOR RANDOM FORMS;
IT IS ESSENTIALLY WHAT GRINDEF CALLS WHEN IT IS "PRETTY-PRINTING"
A FUNCTION DEFINITION.
[7] DISINI MAY NOW TAKE A SECOND ARGUMENT, WHICH SPECIFIES
THAT A GT40 IS TO BE USED INSTEAD OF THE 340. THIS
ARGUMENT SHOULD BE AN ATOMIC SYMBOL WHOSE PRINT NAME IS
THE GT40'S TTY NUMBER. EXAMPLE: (DISINI 0 'T34)
CURRENTLY, T34 IS THE ONLY GT40 AVAILABLE.
[8] THE VARIABLE GCMIN NO LONGER EXISTS. TO ALTER GCMIN PARAMETERS,
USE THE FUNCTION ALLOC, DESCRIBED ABOVE.
THE FORMAT OF THE ARGUMENT TO THE GC-LOSSAGE FUNCTION HAS
BEEN ALTERED FOR COMPATIBILITY WITH BIBOP. IT USED TO BE
THE NAME OF THE LOSING SPACE (LIST, FIXNUM, OR FLONUM).
NOW IT IS A LIST OF THE SPACE NAME AND THE ATOM "MIN";
THUS IF LIST SPACE OVERFLOWED, THE GC-LOSSAGE FUNCTION
WOULD GET THE ARGUMENT (LIST MIN).
THE FORMAT OF THE GC-DAEMON'S ARGUMENT HAS ALSO BEEN ALTERED:
WHERE THE ARGUMENT USED TO BE OF THE FORM
(<BEFORE> . <AFTER>),
IT IS NOW OF THE FORM
(<SPACE NAME> <BEFORE> . <AFTER>).
THUS A TYPICAL GC-DAEMON ARGUMENT MIGHT BE
((LIST 200 . 473) (FIXNUM 0 . 375) (FLONUM 457 . 472)).
[9] THE COMPILER NOW HAS TWO READTABLES. THE FIRST IS THE
STANDARD INITIAL READTABLE, THE OTHER IS THE VALUE OF
THE VARIABLE CREADTABLE. THE VARIABLE READTABLE IS LAMBDA-BOUND
TO THE VALUE OF CREADTABLE WHEN COMPILATION BEGINS. THIS
READTABLE WILL THUS BE IN EFFECT DURING EXECUTION OF DECLARES,
ETC. SO THAT FUNNY MACRO CHARACTERS DEFINED IN THE FILE WILL GO
INTO THE SECOND READTABLE. THUS THESE CHARACTERS WILL NOT BE
SEEN IF YOU DO A ^G QUIT. IF YOUR FILE NEEDS CERTAIN MACRO
CHARACTER DEFINITIONS IN ORDER TO BE READABLE, THERE ARE TWO WAYS
TO GET THESE DEFINITIONS INTO CREADTABLE:
1) BY DECLARE, E.G.
(DECLARE (SETSYNTAX '/: 'SPLICING '(LAMBDA NIL NIL)))
OR EVEN
(DECLARE (EVAL (READ)))
(SETSYNTAX '/: 'SPLICING '(LAMBDA NIL NIL))
2) BY EXPLICITLY BINDING READTABLE TO CREADTABLE, E.G.
((LAMBDA (READTABLE) (FASLOAD MAC CHARS)) CREADTABLE)
[0] HERE FOLLOWS SOME INFORMATION ON BIBOP LISP:
The (in)famous "Bibop" (pronounced "bee-bop") LISP scheme is
now available. Bibop means "BIg Bag Of Pages", a reference
to the method of memory management used to take advantage of
the memory paging features of ITS. The average LISP user
should not be greatly affected in converting to this new
LISP (which very eventually will become the standard LISP,
say in two or three months).
Much effort has been expended to keep Bibop and non-Bibop
LISPs compatible. In particular, if LISP code written for
non-Bibop LISP also works "as is" in Bibop LISP, then so
will the corresponding LAP and FASL files; that is, the
compiler output is completely compatible (and will be kept
so). Unless you must alter source code for Bibop LISP,
there is no need to recompile.
$$$$$ [1] $$$$$ Atomic Symbols Are Different $$$$$
Atomic symbols in Bibop LISP are very different from those
in non-Bibop LISP. The PNAME, ARGS, and VALUE "properties"
are not stored on the property list, but in a secret hidden
place. The ARGS property can be examined and altered with
the function ARGS as in non-Bibop LISP, the VALUE property
with EVAL, SET, SETQ, and BOUNDP, and the PNAME property
with EXPLODE, GETCHAR, etc.
The car of an atomic symbol is not -1 (#777777) in Bibop
LISP. The cdr of an atomic symbol is still the property
list, however; using RPLACD on an atom, though hackish,
also works as before. EXPR and SUBR properties are kept on
the property list as in non-Bibop LISP.
Note well: (CONS (CAR NIL) <property-list>) is most
definitely not a good way to construct a new atomic symbol
(in Bibop, the result won't be an atom at all, but a dotted
pair or whatever). If it is necessary to create a new
atomic symbol in this manner, use the function COPYSYMBOL,
which works as described in LISP ARCHIV in both Bibop and
non-Bibop LISPs.
$$$$$ [2] $$$$$ The Allocator Is Different $$$$$
When a Bibop LISP starts up, it says:
BIBOP LISP <version number>
ALLOC?
All the usual responses have their usual effects; ^Q, ^W,
space, Y, N, etc. work as in non-Bibop LISP. Some questions
asked are different, however, and they are presented in a
different order. Questions and their default values look
something like:
CORE = 66
REGPDL = 10000
SPECPDL = 4000
FXPDL = 10000
FLPDL = 2000
LIST = 40000
FIXNUM = 5000
FLONUM = 2000
BIGNUM = 400
SYMBOL = 2000
SAR = 400
The only parameters which are of real importance are the
various pdl allocations, which is why they come first; the
others can be changed later (see below). The four pdl
parameters are upper limits to the sizes (in PDP-10 words)
of the four push-down stacks in LISP. Don't be afraid to
give large values for these allocations (or for others,
either) since you are not really given as much core as you
ask for, but only one page of core per pdl; as the pdls
grow, more pages of core are added. The other six
parameters control the maximum size for each of six "spaces"
used to contain various objects. They are:
LIST lists and dotted pairs
FIXNUM fixnums (like FXS in non-Bibop LISP)
FLONUM flonums (like FLS in non-Bibop LISP)
BIGNUM bignums (actually, just the bignum headers,
which hold the sign and point to the rest)
SYMBOL atomic symbols (this is why you can't use
CONS to create symbols; they are not in
LIST space!)
SAR special array cells (seen primarily on
property lists as values of ARRAY
properties; the allocation for these need
not be large)
Again, you are not really given as much core as you ask for,
so don't be afraid to ask for lots; you only get a little
core, and more is added when you need it.
As in non-Bibop LISP, if you type ^Q or other magic
characters at the ALLOC? question, your .LISP. (INIT) file
will be read. The first form should be a comment, as usual.
The names of the spaces should be the same as the names used
by ALLOC, given above. Note that supplying nonexistent
space names in the comment doesn't hurt, so you can use the
same comment in non-Bibop LISPs as well as Bibop LISPs;
e.g. the comment
(COMMENT FXS 4000 FIXNUM 5000 FLS 2000
SYMBOL 4000 FLONUM 2000 BIGNUM 1400)
will for non-Bibop set the size for FXS=4000, FLS=2000 and
for Bibop will set FIXNUM=5000, FLONUM=2000, SYMBOL=4000,
BIGNUM=1400.
$$$$$ [3] $$$$$ The ALLOC Function $$$$$
The primary feature of Bibop is that it allows you to expand
memory dynamically. It does this automatically to a certain
extent; however, the user may explicitly alter the sizes of
memory spaces with the function ALLOC. This is a subr whose
single argument should look like the comment form given in a
.LISP. (INIT) file. Example:
(ALLOC '(LIST 40000 FIXNUM 6000 SYMBOL 5000))
will dynamically re-allocate LIST space to be a maximum of
40000 words, etc. At present Bibop can only expand memory,
not shrink it, so if you specify a size for a space smaller
than its current actual size, your request is ignored for
that space. ALLOC returns T.
(The ALLOC function is actually considerably more
complicated, but the above description should suffice for
the purposes of most users. An extended description of
ALLOC may be found in section II.[3].)
$$$$$ [4] $$$$$ A Few New Messages $$$$$
If you should run out of memory for any reason, you will see
a message similar to that in non-Bibop LISP, e.g.:
(FIXNUM MAX) STORAGE CAPACITY EXCEEDED
;BKPT GC-LOSSAGE
Now all is not lost at this point in a Bibop LISP; you may
call the function ALLOC to make FIXNUM space bigger, then
say (RETURN '(T)) to continue the computation. If you say
$P the computation is aborted. If it says (FIXNUM MIN)
instead of (FIXNUM MAX), then you have lost badly; just
type $P. This should happen only rarely, however.
If you see a message that looks something like
;ADDING A NEW FIXNUM SEGMENT - FIXNUM SPACE NOW 2000 WORDS
it merely means that the garbage collector has decided to
add more memory. You will only see this if you have typed
^D to see the garbage collector statistics (as in
non-Bibop).
Yet another message you may see (which also does not exist
in non-Bibop LISP) is:
;BKPT PDL-OVERFLOW
This means that you have used excessive amounts of pdl, and
therefore are probably stuck in infinite recursion or
something. If you want to keep going, just say $P and
Bibop will try to extend the pdl if it can. To abort the
computation, use ^G.MONDAY OCT 15,1973 FM+4D.3H.22M.30S. LISP 623 - GLS -
BRIEF SYNOPSIS:
[1] NEW FUNCTION GCD FOR "GREATEST COMMON DIVISOR"
[2] NEW DO FORMAT PERMITS PROGS WITH INITIAL SETTINGS FOR VARIABLES
[3] PRINLEVEL, PRINLENGTH, AND (STATUS ABBREVIATE)
[4] NOINTERRUPT - USER FEATURE TO LOCK OUT REAL-TIME INTERRUPTS
[5] (STATUS DOW) FOR DAY-OF-WEEK INFORMATION
[6] NEW COMPLR SWITCH: V
[7] SOME CHAGES:
A) (STATUS XCTPG) AND (XCTBLT) SUPERSEDED BY
(STATUS UUOLINKS) AND (SSTATUS UUOLINKS)
B) REMOB IS NOW A SUBR
C) SECOND ARG TO RECLAIM IS DIFFERENT
----------------------------------------------------------------
[1] THERE EXIST TWO FUNCTIONS TO TAKE THE GCD OF TWO NUMBERS.
(GCD X Y) TAKES THE GCD OF X AND Y, WHICH MAY BE FIXNUMS
OR BIGNUMS. (\\ X Y) IS SIMILAR, BUT X AND Y MAY ONLY BE
FIXNUMS. THUS \\ IS TO GCD AS * IS TO TIMES, ETC. THIS
SYMBOL IS EASILY REMEMBERED IF YOU REMEMBER THAT \ MEANS
REMAINDER, AND GCD IS JUST A MOBY REMAINDER, SORT OF.
[2] THERE IS A THIRD FORMAT FOR DO NOW:
(DO <VAR-SPECS> NIL
BODY...)
THIS IS EXACTLY LIKE A NEW-STYLE DO (MULTIPLE INDICES)
EXCEPT THAT THE PREDICATE/RETURN VALUE CLAUSE IS NIL.
(NOT (NIL), BUT NIL!!!) THE MEANING OF THIS IS THAT
THE VARIABLES SHOULD BE INITIALIZED AND THE BODY
PERFORMED EXACTLY ONCE. NOTE THAT STEPPERS FOR THE VARIABLES
ARE ILLEGAL IN THIS MODE, SINCE STEPPERS CAN NEVER BE
EXECUTED. EXAMPLE:
(DO ((A 0) (B 1)) NIL
(PRINT 'A=)
(PRIN1 A)
(PRINT 'B=)
(PRIN1 B))
PRINTS THE FOLLOWING:
A=0
B=1
AND THEN RETURNS NIL. IN THIS WAY ONE GETS THE EFFECT OF
THE FAMOUS "PROG WITH INITIALIZED VARIABLES" FEATURE.
[3] THE MANY AND VARIOUS OUTPUT FUNCTIONS (PRINT, PRIN1,
FLATSIZE, ETC.) ARE NOW CONTROLLED BY TWO GLOBAL VARIABLES
AND A STATUS CALL. PRINLEVEL AND PRINLENGTH SHOULD ALWAYS
BE EITHER NON-NEGATIVE FIXNUMS OR NIL. PRINLEVEL IS
THE MAXIMUM NUMBER OF UNBALANCED OPEN PARENTHESES WHICH
PRIN1, ETC. MAY OUTPUT; IF THE LIST STRUCTURE IS TOO
"DEEP" TO BE ABLE TO DO THIS, THEN SUB-LISTS BELOW THE
PRINLEVEL ARE ABBREVIATED BY #. E.G. SUPPOSE ONE TRIES
TO PRINT THE LIST
(FOO (BAR (LAMBDA (X Y) (QUUX BAZ))) (TEST))
WITH PRINLEVEL=1. THEN IT WOULD ACTUALLY PRINT AS:
(FOO # #)
WITH PRINLEVEL=2, IT WOULD COME OUT AS:
(FOO (BAR #) (TEST))
AND WITH PRINLEVEL=3 IT WOULD PRINT AS:
(FOO (BAR (LAMBDA # #)) (TEST))
PRINLEVEL=NIL MEANS PRINLEVEL=INFINITY.
PRINLENGTH IS TO THE CDR DIRECTION WHAT PRINLEVEL IS
TO THE CAR DIRECTION. IF ANY LIST IS LONGER THAN
SPECIFIED BY PRINLENGTH, THEN ANY EXTRA ITEMS ARE
OMITTED AND ABBREVIATED AS ... EXAMPLE: IF YOU
TRY TO PRINT THE LIST
(FOO (BAR (BAZ) (HERE (IS) A TEST)) WHAT ARE YOU)
WITH PRINLENGTH=1 (AND PRINLEVEL=NIL) IT WOULD PRINT AS:
(FOO ...)
WITH PRINLENGTH=2, AS:
(FOO (BAR (BAZ) ...) ...)
AND WITH PRINLENGTH=3 AS:
(FOO (BAR (BAZ) (HERE (IS) A ...)) WHAT ...)
OF COURSE, ONE CAN USE PRINLEVEL AND PRINLENGTH BOTH AT THE
SAME TIME. IF THE ABOVE LISTS WERE PRINTED WITH PRINLEVEL=2
AND PRINLENGTH=2, THEY WOULD PRINT AS:
(FOO (BAR #) ...)
(FOO (BAR # ...) ...)
WITH PRINLEVEL=3 AND PRINLENGTH=2, THEY WOULD PRINT AS:
(FFOO (BAR (LAMBDA # ...)) ...)
(FOO (BAR (BAZ) ...) ...)
AND WITH PRINLEVEL=3 AND PRINLENGTH=3, THEY WOULD PRINT AS:
(FOO (BAR (LAMBDA # #)) (TEST))
(FOO (BAR (BAZ) (HERE # A ...)) WHAT ...)
THE DEFAULT CONDITION FOR ALL THIS HACKERY IS THAT IT
APPLIES ONLY TO TTY OUTPUT AND NO OTHER. THUS IF ONE
IS OUTPUTTING TO BOTH DSK AND TTY, THE TTY OUTPUT WILL
BE ABBREVIATED AS SPECIFIED BY PRINLEVEL AND PRINLENGTH,
BUT OUTPUT TO THE FILE WILL NOT BE, NOR WILL THE
RESULT OF EXPLODE AND FLATSIZE BE AFFECTED.
THIS CAN BE ALTERED BY (SSTATUS ABBREVIATE <N>).
IF THE 1 BIT OF N (A FIXNUM) IS ON, IT MEANS THAT OUTPUT
TO FILES SHOULD BE ABBREVIATED; IF THE 2 BIT IS ON, IT
MEANS THAT FLATSIZE AND EXPLODE SHOULD USE ABBREVIATIONS.
THUS 0 => ONLY TTY, 1 => TTY AND FILES, 2 => TTY AND
FLATSIZE, AND 3 => TTY, FILES, AND FLATSIZE.
AS A HACK, (SSTATUS ABBREVIATE T) MEANS EVERYTHING GETS
ABBREVIATED, AND (SSTATUS ABBREVIATE NIL) MEANS ONLY
TTY GETS ABBREVIATED; THIS WILL CONTINUE TO BE TRUE EVEN
IF MORE BITS OF (STATUS ABBREVIATE) ARE ASSIGNED MEANINGS.
NOTE THAT, LIKE (STATUS TERPRI), (STATUS _), AND
(STATUS TTYREAD), (STATUS ABBREVIATE) RESIDES IN THE
READTABLE; THUS ONE CAN ALTER IT (AND IN PARTICULAR
LAMBDA-BIND IT) BY CHANGING READTABLES.
[4] USERS CAN CONTROL SOMEWHAT THE HAPPENING OF RANDOM "REAL
TIME" INTERRUPTS WITH THE FUNCTION NOINTERRUPT OF ONE
ARGUMENT. (NOINTERRUPT T) PUTS LISP IN A MODE WHEREBY
ALL TTY AND ALARMCLOCK INTERRUPTS WILL BE DEFERRED
(EVEN ^G AND ^X INTERRUPTS!!!) AND SAVED IN A FIFO
QUEUE. (NOINTERRUPT NIL) RELEASES THIS MODE AND PROCESSES
ANY INTERRUPTS WHICH WERE STACKED UP DURING THIS TIME,
IF ANY. NOTE THAT IF WHILE IN (NOINTERRUPT T) MODE,
YOU TYPE (SAY) ^H ^] ^G ^A ^\ THEN THE ^G WILL
FLUSH THE ^H AND ^] INTERRUPTS FROM THE QUEUE; BUT
WHEN (NOINTERRUPT NIL) IS DONE, THE ^G QUIT WILL BE
PERFORMED, FOLLOWED BY THE ^A AND ^\ INTERRUPTS.
IN GENERAL, WHEN NOINTERRUPT MODE IS REALEASED,
PENDING INTERRUPTS ARE PROCESSED IN THE ORDER
(^G, ^X QUIT), (CLOCK INTERRUPTS), (OTHER TTY INTERRUPTS).
NOTE THAT CALLS TO THE FUNCTION IOC ALWAYS PERFORM THEIR
ACTIONS, EVEN IN NOINTERRUPT MODE; THUS (IOC G) WILL DO
A ^G-QUIT IN SPITE OF THE STATE OF THE NOINTERRUPT MODE.
[5] (STATUS DOW) RETURNS ONE OF THE EIGHT SYMBOL ATOMS
SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY,
SATURDAY, OR NIL (THE LATTER IF ITS DOESN'T KNOW THE DAY).
USE YOUR IMAGINATIONS! A PRIZE FOR THE BEST HACK USING THIS
[6] COMPLR HAS A NEW SWITCH: V (CORRESPONDS TO THE VARIABLE
NFUNVARS). IF TRUE (NORMALLY NIL), IT MEANS THAT THERE
ARE NO FUNCTIONAL VARIABLE USAGES IN YOUR FILE [I.E.
CONSTRUCTS WHERE YOU SAY (FOO A B), AND FOO IS NOT DIRECTLY
THE NAME OF THE FUNCTION, BUT RATHER FOO'S VALUE HOLDS THE
NAME OF THE FUNCTION TO BE APPLIED TO A AND B.]
IN SITUATIONS WHERE FOO IS A FREE SPECIAL VARIABLE, OR ANY
BOUND VARIABLE OF THE FUNCTION CONTAINING THE FORM (FOO A B),
COMPLR ASSUMES THAT IT IS A FUNCTIONAL VARIABLE RATHER THAN
SOME YET-TO-BE-COMPILED USER FUNCTION. ONE CAN ALWAYS USE
DECLARATIONS NEAR THE BEGINNING OF ONE'S FILES, SUCH AS
(*EXPR FOO) OR (*LEXPR FOO) OR (*FEXPR FOO), BUT WHEN USING
THE ALL-VARIABLES-AUTOMATICALLY-MADE-SPECIAL OPTION
[THE S SWITCH] IT WOULD MEAN AN UNNECESSARILY LARGE NUMBER
OF SUCH DECLARATIONS. THE NEW V SWITCH IF FOR THE MOST COMMON
CASE, IN WHICH THE USER DOES NOT USE FUNCTIONAL VARIABLES.
EVEN WHEN THIS SWITCH IS SET, YOU CAN STILL EVALUATE VARIABLES
TO GET FUNCTIONS BY USING THE FUNCTION FUNCALL, DESCRIBED IN
THE PREVIOUS LISP RECENT.
[7] IN AN ATTEMPT AT MNEMONICITY (MUMBLE!), (STATUS XCTPG)
IS NOW CALLED (STATUS UUOLINKS), AND THE FUNCTION XCTBLT
IS NOW INVOKED AS (SSTATUS UUOLINKS).
YES, INDEED, FOLKS, REMOB, AS, EARLIER, WE THREATENED,
IS, NOW, NOT AN FSUBR, BUT, TAKING ONE ARGUMENT, A SUBR.
THE SECOND ARGUMENT TO THE RECLAIM FUNCTION NOW HAS
A SOMEWHAT DIFFERENT MEANING: IF NIL, IT RECLAIMS ONLY
THE TOP LEVEL OF A LIST (DOES NOTHING IS FIRST ARG IS
ATOMIC); IF NON-NIL, IT RECLAIMS ALL LIST, FIXNUM,
AND FLONUM CELLS WITHIN THE S-EXPRESSION, INCLUDING
BIGNUMS, BUT NOT ATOMIC SYMBOLS.