TUESDAY APRIL 23,1974 NM+2D.8H.36M.6S. LISP 810 - GLS -
BRIEF SYNOPSIS:
[1] NEW FUNCTION: GETCHARN
[2] ALARMCLOCK AND TTY INTERRUPTS ARE RUN WITH (NOINTERRUPT T)
[3] NEW ARRAY SCHEME
[4] NEW FUNCTIONS: SUBRCALL, LSUBRCALL, ARRAYCALL
[5] UUO'S CHANGED: LER2,LER4 GONE; LER3 MOVED; ACALL,AJCALL NEW
[6] HH$X SLIGHTLY IMPROVED
----------------------------------------------------------------
[1] NEW FUNCTION: GETCHARN IS LIKE GETCHAR, BUT RETURNS A
NUMBER INSTEAD OF A SINGLE CHARACTER OBJECT. IT IS
TO GETCHAR AS EXPLODEN IS TO EXPLODEC, AND IS SIMILAR IN ACTION
TO (LAMBDA (X) (CAR (EXPLODEN X))). EXAMPLES:
(GETCHARN 'FOOBAR 1) => 106 ;OCTAL
(GETCHARN 'FOOBAR 4) => 102
(GETCHARN 'FOOBAR -1) => 0
(GETCHARN 'FOOBAR 77) => 0
[2] WHEN AN ALARMCLOCK OR TTY INTERRUPT HAPPENS, THE NOINTERRUPT
FLAG IS SAVED, (NOINTERRUPT T) IS PERFORMED, THE USER'S SERVICE
FUNCTION IS EXECUTED, AND THE NOINTERRUPT FLAG IS RESTORED AFTER
EXECUTION. [THE FLAG MIGHT CONCEIVABLY BE ON IF (IOC <X>) WERE
USED TO INITIATE THE INTERRUPT - NOINTERRUPT ONLY LOCKS OUT
REAL-TIME EVENTS.] THUS, AN ALARMCLOCK HANDLER, FOR EXAMPLE,
WONT BE ABORTED BY A RANDOM ^G BEFORE IT HAS HAD A CHANCE TO
RESTART THE CLOCK.
[3] THE NEW ARRAY SCHEME IS WORKING WELL NOW FROM THE INTERPRETER
SIDE; THE NCOMPLR WILL KNOW ABOUT IT WHEN THE NEXT VERSION
IS AVAILABLE, AND COMPLR WILL FOLLOW SUIT SHORTLY THEREAFTER.
THE LISP NEW-ARRAY SCHEME COMPRISES MANY CHANGES TO THE
ARRAY PACKAGE, MOST OF WHICH ARE EXTENSIONS; THERE
ARE FEW INCOMPATIBILITIES. THE MOST IMPORTANT EXTENSION IS
THE ADDITION OF TWO NEW TYPES OF ARRAYS: FIXNUM AND FLONUM.
THESE TYPES OF ARRAYS STORE THEIR ELEMENTS AS 36-BIT WORDS
RATHER THAN AS 18-BIT POINTERS, THUS SAVING SPACE AND TIME.
SHORTLY, BOTH COMPLR AND NCOMPLR WILL PRODUCE CODE FOR ARRAYS
THAT WILL OPEN-ACCESS BOTH STANDARD AND FULLWORD ARRAYS ALMOST
AS FAST AS FORTRAN-COMPILED CODE DOES.
ONE SOMEWHAT DRASTIC CHANGE: NSTORE WILL GO AWAY, SINCE
FIXNUM ARRAYS CAN BE USED WHERE AN ARRAY OF NUMBERS IS DESIRED.
FUNCTIONS SUCH AS LOADARRAYS AND DISGORGE WILL BE MODIFIED TO
USE FIXNUM ARRAYS RATHER THAN S-EXPRESSION-WITHOUT-GC-PROTECTION
ARRAYS. IT IS POSSIBLE THAT SOMETIME IN THE FUTURE THERE MAY BE
OTHER VERSIONS OF THE FIXNUM-ARRAY IDEA, IN WHICH THE USER
SPECIFIES THE NUMBER OF BITS FOR EACH ENTRY; THUS AN ARRAY
OF 1-BIT BYTES COULD EFFECT A SAVINGS OF A FACTOR OF 36. BUT
THIS IS ONLY A POSSIBILITY FOR THE FUTURE. OTHER CHANGES AND
EXTENSIONS ARE DESCRIBED BELOW ON A FUNCTION-BY-FUNCTION BASIS:
(*ARRAY <ARRAY> <TYPE> <DIM1> ... <DIMN>) ;LSUBR (2 . 7)
CREATES AN N-DIMENSIONAL ARRAY. <TYPE> SPECIFIES THE TYPE
OF THE ARRAY TO BE CREATED:
T S-EXPRESSION (AS BEFORE)
NIL S-EXPRESSION (BUT NO GC PROTECTION)
FIXNUM CONTAINS FIXNUMS AS 36-BIT WORDS
FLONUM CONTAINS FLONUMS AS 36-BIT WORDS
OBARRAY OBARRAY
READTABLE READTABLE
IF <ARRAY> IS NIL, THEN AN ARRAY OF THE SPECIFIED TYPE,
DIMENSIONALITY, AND SIZE IS CREATED, AND A FRESH ARRAY
POINTER IS CONSED UP AND RETURNED; THE LATTER IS AN
OBJECT WHICH POINTS TO THE BODY OF THE ARRAY.
TYPEP OF SUCH AN OBJECT RETURNS "ARRAY". SUCH OBJECTS
ARE ALSO THE RESULT OF SAYING (GET 'FOO 'ARRAY), AND
ARE THE VALUE OF ATOMIC SYMBOLS LIKE OBARRAY AND READTABLE.
ARRAY POINTERS MAY BE GIVEN TO APPLY AND FUNCALL; THUS
(READTABLE 10) IS THE 10'TH ENTRY OF THE INITIAL READTABLE,
THAT IS, OF THE ARRAY UNDER READTABLE'S ARRAY PROPERTY; BUT
(FUNCALL READTABLE 10) IS THE 10'TH ENTRY OF THE CURRENT
READTABLE, THAT IS, THE ARRAY POINTER WHICH IS THE VALUE
OF THE VARIABLE "READTABLE". IN GENERAL, ARRAY POINTERS
MAY BE USED IN ALMOST ANY PLACE (ALMOST!) THAT AN ATOMIC
SYMBOL WITH AN ARRAY PROPERTY MAY BE USED. THERE IS A PLACE
WHERE ARRAY POINTERS MUST BE USED IN PREFERENCE TO ATOMIC
SYMBOLS WITH ARRAY PROPERTIES: SEE THE NEW "ARRAYCALL"
FUNCTION BELOW. IN GENERAL, THE USER CANNOT MANIPULATE
ARRAYS DIRECTLY, BUT ONLY THROUGH ARRAY POINTERS; THIS
IS BECAUSE ARRAYS MAY BE RELOCATED WITHOUT WARNING BY
THE GARBAGE COLLECTOR. FURTHERMORE, NO TWO NON-EQ ARRAY
POINTERS CAN EVER POINT TO THE SAME ARRAY.
IF <ARRAY> IS NON-NIL, THEN IT MUST BE EITHER AN ARRAY
POINTER OR AN ATOMIC SYMBOL. IF IT IS A SYMBOL, AND THE
SYMBOL HAS NO ARRAY PROPERTY, IT IS GIVEN ONE (A FRESH
ARRAY POINTER IS CONSED UP FOR THIS PURPOSE). IF <ARRAY>
IS AN ARRAY POINTER, OR A SYMBOL WITH AN ARRAY PROPERTY,
THEN ANY ARRAY CURRENTLY POINTED TO BY THAT POINTER IS
KILLED. IN ANY CASE THE ARRAY POINTER IS THEN MADE TO
POINT TO THE NEWLY CREATED ARRAY.
AN ARRAY MAY BE UP TO FIVE-DIMENSIONAL (FORMERLY ONLY FOUR
DIMENSIONS WERE ALLOWED). IF <DIMX> IS SPECIFIED AS JX,
THEN THE X'TH SUBSCRIPT VARIES FROM 0 TO JX-1, AS BEFORE.
AN ARRAY IS EFFECTIVELY A FUNCTION; THUS IF FOO HAS AN
ARRAY PROPERTY, THEN (FOO 1 3) RETURNS ELEMENT [1,3] OF THE
ARRAY FOO (WHICH BETTER BE TWO-DIMENSIONAL!)
WHEN A NEW ARRAY IS CREATED, ITS ENTRIES ARE INITIALIZED TO
NIL FOR ARRAYS OF TYPE "T" OR "NIL", TO 0 FOR FIXNUM ARRAYS,
OR TO 0.0 FOR FLONUM ARRAYS. TO INITIALIZE AN ARRAY TO OTHER
VALUES, SEE THE FUNCTIONS *REARRAY, BLTARRAY, AND FILLARRAY
BELOW.
IF <TYPE> IS OBARRAY OR READTABLE, THEN THE EXTRA ARGUMENTS
HAVE A SLIGHTLY DIFFERENT SIGNIFICANCE. ONLY TWO OR THREE
ARGUMENTS IN ALL MAY BE GIVEN; THE THIRD, IF PRESENT, TELLS
HOW TO INITIALIZE THE OBARRAY OR READTABLE.
FOR AN OBARRAY, A THIRD ARGUMENT OF NIL MEANS THAT THE NEW
OBARRAY SHOULD BE LEFT COMPLETELY EMPTY. A THIRD ARGUMENT
OF T MEANS THAT THE NEW ARGUMENT SHOULD BE INITIALIZED FROM
THE CURRENT OBARRAY (THAT IS, FROM WHATEVER ARRAY POINTER IS
THE CURRENT VALUE OF THE VARIABLE "OBARRAY"). ANY OTHER
THIRD ARGUMENT MUST BE AN ARRAY OF TYPE OBARRAY FROM WHICH
TO INITIALIZE THE NEW OBARRAY. OMITTING THE THIRD ARGUMENT
IS THE SAME AS SAYING T. NOTE THAT WHEN ONE OBARRAY IS
INITIALIZED FROM ANOTHER, THE BUCKETS ARE COPIED, BUT
THE ATOMIC SYMBOLS ARE NOT COPIED.
FOR A READTABLE, A THIRD ARGUMENT OF NIL MEANS THAT THE NEW
READTABLE SHOULD BE INITIALIZED FROM THE CURRENT READTABLE.
A THIRD ARGUMENT OF T MEANS TO INITIALIZE FROM THE SYSTEM'S
INITIAL READTABLE. ANY OTHER THIRD ARGUMENT MUST BE A
READTABLE TO INITIALIZE FROM. (IT MAKES NO SENSE TO HAVE AN
"EMPTY" READTABLE AS IT DOES FOR AN OBARRAY). OMITTING THE
THIRD ARGUMENT IS THE SAME AS SAYING NIL.
EXAMPLES:
(*ARRAY 'FOO 'FIXNUM 3 4 5) ;FOO GETS AN ARRAY
; PROPERTY FOR A
; 3X4X5 ARRAY OF FIXNUMS
(*ARRAY NIL T 4 4) ;RETURNS ARRAY POINTER
; FOR A 4X4 ARRAY OF
; ARBITRARY S-EXPRESSIONS
(*ARRAY 'QUUX 'READTABLE) ;QUUX IS GIVEN AN ARRAY
; PROPERTY FOR A
; READTABLE, INITIALIZED
; FROM CURRENT ONE
(ARRAY <<ARRAY> <TYPE> <DIM1> ... <DIMN>) ;FSUBR
ARRAY IS THE SAME AS *ARRAY, EXCEPT THAT THE FIRST TWO
ARGUMENTS ARE NOT EVALUATED. THUS THE EXAMPLES ABOVE COULD
HAVE BEEN WRITTEN:
(ARRAY FOO FIXNUM 3 4 5)
(ARRAY NIL T 4 4)
(ARRAY QUUX READTABLE)
(STORE <ARRAY CALL> <VALUE>) ;FSUBR
THIS WORKS AS BEFORE: IT STORES THE GIVEN VALUE IN THE
SPECIFIED ARRAY ELEMENT. IF <ARRAY CALL> IS A CALL TO
A FIXNUM OR FLONUM ARRAY, THEN <VALUE> SHOULD BE A FIXNUM
OR FLONUM, RESPECTIVELY. RECALL THAT STORE EVALUATES ITS
SECOND ARGUMENT BEFORE THE FIRST ARGUMENT; THUS
(SETQ J 3)
(STORE (FOOARRAY (SETQ J 5)) J)
WILL STORE 3, NOT 5, IN ELEMENT 5 OF FOOARRAY. ONE SHOULD AVOID
DEPENDING ON THIS FACT, HOWEVER, IN THE INTERESTS OF CLARITY.
SEE ALSO THE DESCRIPTION OF THE NEW "ARRAYCALL" FUNCTION BELOW.
(ARRAYDIMS <ARRAY>) ;SUBR 1
THIS FUNCTION WORKS AS BEFORE, BUT CAN RETURN A BROADER
RANGE OF VALUES. IT RETURNS A LIST, SUCH THAT THE CAR
OF THE LIST IS THE TYPE OF THE ARRAY (I.E., T, NIL,
FIXNUM, FLONUM, OBARRAY, OR READTABLE), AND THE CDR IS
A LIST OF ARRAY DIMENSIONS. THUS:
(ARRAY QUUX FIXNUM 3 4 5)
(ARRAYDIMS 'QUUX) => (FIXNUM 3 4 5)
(ARRAYDIMS (GET 'QUUX 'ARRAY)) => (FIXNUM 3 4 5)
(ARRAY ZORCH OBARRAY)
(ARRAYDIMS 'ZORCH) => (OBARRAY 777)
WHERE 777 HAPPENS TO BE THE SIZE OF AN OBARRAY ON THIS
GIVEN LISP SYSTEM (THIS VARIES FROM ONE LISP TO ANOTHER).
NOTE THAT ARRAYDIMS RETURNS SLIGHTLY DIFFERENT VALUES FOR
READTABLES AND OBARRAYS THAN IT USED TO.
(*REARRAY <ARRAY> <TYPE> <DIM1> ... <DIMN>) ;LSUBR (1 . 7)
THIS FUNCTION WORKS PRETTY MUCH AS BEFORE.
IF IT IS GIVEN ONLY ONE ARGUMENT (*REARRAY FOO), THEN FOO
MAY BE AN ARRAY POINTER OR AN ATOMIC SYMBOL. IF IT IS AN
ATOMIC SYMBOL WITH NO ARRAY PROPERTY, IT MERELY RETURNS.
OTHERWISE IT KILLS THE ARRAY POINTED TO BY THE ARRAY POINTER
(THE ONE GIVEN, OR THE ONE OBTAINED FROM THE SYMBOL'S
PROPERTY LIST). THE ARRAY POINTER IS NOW "DEAD", AND CANNOT
BE USED AS A FUNCTION UNLESS AND UNTIL IT IS GIVEN A NEW
ARRAY TO POINT TO.
IF MORE THAN ONE ARGUMENT IS GIVEN TO *REARRAY, THEN THEY
SHOULD BE ARGUMENTS SIMILAR TO THOSE FOR *ARRAY, EXCEPT THAT
THE FIRST ARGUMENT MUST ALREADY BE A LIVE ARRAY, EITHER AS
AN ARRAY POINTER OR AS A SYMBOL WITH A LIVE ARRAY PROPERTY.
*REARRAY EFFECTIVELY CREATES A NEW ARRAY OF THE SPECIFIED
DIMENSIONS AND BLTARRAY'S DATA FROM THE GIVEN ARRAY INTO THE
NEW, THEN ALTERS THE ARRAY POINTER TO POINT TO THE NEW ARRAY.
*REARRAY WILL NOT PERMIT YOU TO ALTER THE TYPE OF THE ARRAY
AT PRESENT - YOU MUST SPECIFY THE CORRECT TYPE. IT IS RATHER
MEANINGLESS TO USE *REARRAY OF MORE THAN ONE ARGUMENT ON A
READTABLE OR OBARRAY.
(BLTARRAY <FROMARRAY> <TOARRAY>) ;SUBR 2
BLTARRAY, AS BEFORE, COPIES THE DATA IN <FROMARRAY> INTO
<TOARRAY>. IF <FROMARRAY> IS SHORTER, THEN EXTRA DATA IN
<TOARRAY> IS UNHARMED, MORE OR LESS. IF <TOARRAY> IS
SHORTER, THEN AS MUCH DATA AS WILL FIT IS COPIED.
BLTARRAY INSISTS ON GETTING TWO ARRAYS OF THE SAME TYPE;
IT WILL NOT COPY A FIXNUM ARRAY INTO A FLONUM ARRAY, AN
S-EXPRESSION ARRAY, OR A READTABLE.
IF ONE OBARRAY IS COPIED INTO ANOTHER, THE BUCKETS ARE
COPIED AS WELL, AS IF FOR *ARRAY.
(LISTARRAY <ARRAY>) ;SUBR 1
LISTARRAY NOW WORKS ON ARRAYS OF ALL TYPES AND ALL
DIMENSIONS. IT RETURNS A LIST OF ALL THE DATA IN THE
GIVEN ARRAY. IF A MULTI-DIMENSIONAL ARRAY IS GIVEN,
THE DATA IS TAKEN IN ROW-MAJOR ORDER; FOR EXAMPLE:
(ARRAY FOO FIXNUM 2 2)
(LISTARRAY 'FOO)
RETURNS FOO[0,0] FOO[0,1] FOO[1,0] FOO[1,1] AS A LIST
IN THAT ORDER.
(FILLARRAY <ARRAY> <LIST>) ;SUBR 2
FILLARRAY IS AN INVERSE TO LISTARRAY, EXCEPT THAT IT
IS NOT PERMITTED TO USE FILLARRAY ON READTABLES OR
OBARRAYS. IT DISTRIBUTES THE GIVEN LIST OF ITEMS
INTO THE GIVEN ARRAY IN ROW-MAJOR ORDER. IF A FIXNUM
OR FLONUM ARRAY IS SUPPLIED, THEN THE ELEMENTS OF THE
LIST MUST ALL BE FIXNUMS OR FLONUMS, RESPECTIVELY.
IF THERE ARE TOO MANY ITEMS IN THE LIST, THE EXTRA ONES
ARE IGNORED; IF THERE ARE NOT ENOUGH, THEN THE LAST ONE
IS USED TO FILL OUT THE ARRAY. THUS
(FILLARRAY 'FOO '(43 11 27)) ;RANDOM NUMBERS
FILLS FOO, AS DEFINED ABOVE, SUCH THAT
FOO[0,0] = 43
FOO[0,1] = 11
FOO[1,0] = 27
FOO[1,1] = 27
(MAKOBLIST <ARG>) ;SUBR 1
THIS FUNCTION WORKS AS BEFORE. NOTE THE FOLLOWING
EQUIVALENCES IN THE NEW ARRAY SCHEME:
(MAKOBLIST NIL) <=> (LISTARRAY OBARRAY)
(MAKOBLIST X) <=> (*ARRAY X 'OBARRAY)
FOR X NOT NIL.
(MAKREADTABLE <ARG>) ;SUBR 1
THIS FUNCTION WORKS AS BEFORE. NOTE THE FOLLOWING
EQUIVALENCES IN THE NEW ARRAY SCHEME:
(MAKREADTABLE NIL) <=> (*ARRAY (GENSYM) 'READTABLE)
(MAKREADTABLE T) <=> (*ARRAY (GENSYM) 'READTABLE T)
(MAKREADTABLE X) <=> (*ARRAY X 'READTABLE)
FOR X NOT NIL OR T.
(ARRAYCALL <TYPE> <APTR> <ARG1> ... <ARGN>) ;LSUBR (2 . 6)
[SEE ALSO ITEM [4] BELOW.]
ARRAYCALL IS SIMILAR TO FUNCALL, BUT INSISTS THAT ITS SECOND
ARGUMENT BE AN ARRAY POINTER (AN ATOMIC SYMBOL WITH AN ARRAY
PROPERTY IS NOT ACCEPTABLE IN THIS CONTEXT!) ITS FIRST ARGUMENT
SHOULD MATCH THE TYPE INFORMATION OF THE ARRAY - EITHER FIXNUM,
FLONUM, NIL, OR T.
ITS PRIME VIRTUE IS THAT IT PERMITS THE COMPILER TO OPEN-CODE
ACCESS TO VARIABLE ARRAYS. ONE MAY ALSO WRITE
(STORE (ARRAYCALL TYPE VAR X1 ... XN) VAL)
AND HAVE IT COMPILE EFFICIENTLY. EXAMPLE OF USE:
(DEFUN TRANSPOSE (A)
(PROG (ARY TYP)
(COND ((EQ (SETQ TYP (TYPEP A)) 'ARRAY)
(SETQ ARY A))
((AND (EQ TYP 'SYMBOL)
(SETQ ARY (GET A 'ARRAY))))
(T (RETURN
(TRANSPOSE
(ERROR 'NON-ARRAY/ -/ TRANSPOSE
A 'WRNG-TYPE-ARG)))))
(OR (AND (= (LENGTH (SETQ TYP
(ARRAYDIMS ARY)))
3)
(= (CADR TYP) (CADDR TYP)))
(RETURN
(TRANSPOSE
(ERROR 'NOT/ 2-DIM/ SQUARE/ -/ TRANSPOSE
A 'WRNG-TYPE-ARG))))
(DO ((N) (I 1 (1+ I)))
((= I (CADR TYP)))
(DO ((J 1 (1+ J)))
((= J I))
(SETQ N (ARRAYCALL (CAR TYP) ARY I J))
(STORE (ARRAYCALL (CAR TYP) ARY I J)
(ARRAYCALL (CAR TYP) ARY J I))
(STORE (ARRAYCALL (CAR TYP) ARY J I) N)))
(RETURN A)))
ANOTHER VARIATION WOULD BE TO LIMIT TRANSPOSE TO FIXNUM ARRAYS.
THE EACH OF THE FOUR USAGES OF ARRAYCALL WOULD BE LIKE
(ARRAYCALL 'FIXNUM ARY . . .), AND THE NCOMPLR WOULD BE ABLE
TO MAKE OPEN-CODED REFERENCES TO THE ARRAY.
PRIN1, PRINC, EXPLODEC, ETC.
THE PRINT FUNCTIONS AND OTHER RELATED FUNCTIONS PRINT ARRAY
POINTERS IN THE FOLLOWING MANNER: IF THE ARRAY POINTER IS
DEAD (POINTS TO NO LIVE ARRAY), IT PRINTS AS "#DEAD-ARRAY".
OTHERWISE IT PRINTS AS "#", THE TYPE OF ARRAY, "-", THE
DIMENSIONS OF THE ARRAY SEPARATED BY ":" IN THE CURRENT
RADIX, "-", AND THE ADDRESS OF THE ARRAY POINTER IN OCTAL.
THUS PRINTING AN ARRAY POINTER LETS YOU SEE THE SAME
INFORMATION RETURNED BY ARRAYDIMS. EXAMPLES:
USER: (ARRAY NIL OBARRAY)
LISP: #OBARRAY-777-103426
U: (ARRAY NIL FIXNUM 4 5 6)
L: #FIXNUM-4:5:6-103424
U: (ARRAY FOO T 3 5 2 4 3)
L: FOO
U: (GET 'FOO 'ARRAY)
L: #T-3:5:2:4:3-102362
[4] THREE NEW FUNCTIONS: SUBRCALL, LSUBRCALL, ARRAYCALL.
(ARRAYCALL IS ALSO THORUGHLY DESCRIBED IN ITEM [3].)
THESE ARE ANALOGOUS TO FUNCALL, IN THAT THEY TAKE
A "FUNCTION" SPECIFICATION AS THE FIRST ARGUMENT AND
AND ARGUMENTS FOR THAT FUNCTION AS THE REST OF THE
ARGUMENTS. THE DIFFERENCE IS THAT THE SECOND ARGUMENT
TO <FOO>CALL (FOR <FOO> AMONG [SUBR, LSUBR, ARRAY])
SHOULD BE THE KIND OF ITEM YOU WOULD OBTAIN BY SAYING
(GET 'QUUX '<FOO>) FOR SOME ATOMIC SYMBOL QUUX.
THUS:
(SUBRCALL NIL (GET 'CAR 'SUBR) '(A . B)) => A
YOU USE THESE AT YOUR OWN RISK, OF COURSE; THE INTERPRETER
CAN'T CHECK EVERYTHING. SOON THE COMPILER WILL OPEN-CODE
THESE GUYS SUPER-EFFICIENTLY.
HERE IS AN INTERESTING HACK:
(SETQ SUBRDISPATCH (ARRAY NIL T 40)) ;40=RANDOM SIZE
(DO ((I 0 (1+ I))
(X '(CAR CDR CADR REVERSE EXPLODE ...) (CDR X)))
((NULL X))
(STORE (ARRAYCALL T SUBRDISPATCH I)
(GET (CAR X) 'SUBR)))
(SUBRCALL NIL (ARRAYCALL T SUBRDISPATCH 3) '(A B C)) => (C B A)
(SUBRCALL NIL (ARRAYCALL T SUBRDISPATCH 1) '(A B C)) => B
AND SO FORTH AND SO ON. THAT IS, YOU CAN HAVE AN ARRAY
OF DISPATCH ADDRESSES. AGAIN, BE CAREFUL!
[5] FOR MACHINE LANGUAGE HACKERS ONLY:
PDP-10 LISP'S UUO'S HAVE BEEN REARRANGED. LER2 AND LER4
HAVE BEEN FLUSHED. LER3'S OPCODE HAS BEEN ALTERED.
TWO NEW UUO'S: ACALL AND AJCALL. THE EFFECTIVE ADDRESS
OF ACALL MUST AN ARRAY POINTER, WHICH SHOULD HAVE ITS
COMPILED-CODE-NEEDS-ME BIT TURNED ON. ACALL SERVES
AS AN NCALL TO AN ARRAY (ONE CAN'T INCREMENT THE
EFFECTIVE ADDRESS OF AN NCALL TO AN ARRAY BECAUSE IT
IS INDIRECT). THE UUO HANDLER THUS SMASHES NCALL'S TO
ARRAYS TO BE ACALL'S INSTEAD OF PUSHJ'S, AND SIMILARLY
NJCALL'S TO BE AJCALL'S. IN MOST PRACTICAL CASES THIS
WILL NOT BE NECESSARY, SINCE THE COMPILER HOPEFULLY
CAN OPEN-CODE MOST ARRAY ACCESSES ANYWAY.
THE GETMIDASOP FUNCTION HAS BEEN UPDATED TO REFLECT
THESE ALTERED OP-CODES.
[6] HH$X TRIES NOT TO SIGNAL A ^H INTERRUPT IF IT THINKS THAT THE
INTERRUPT WILL BE STACKED IN THE INTERRUPT QUEUE RATHER THAN
RUN IMMEDIATELY. IT WILL SIMPLY RETURN TO DDT IN THIS CASE.