FRIDAY MARCH 01,1974 FQ+18H.38M.31S. LISP 767 - GLS - [1] NEGATIVE RUNTIMES [2] ERRFRAME CHANGE [3] FUNCALL PUSHES APPLY FRAMES [4] NEW FUNCTION: NRECONC [5] PRINT, PRIN1, PRINC CHECK I/O FLAGS - AFFECTS ABBREVIATION [6] (STATUS UREAD) IS NOW CONSISTENT ABOUT LINKS [7] SOME CHANGES TO ARRAY STUFF (PREPARING FOR NEW ARRAYS) [7A] TYPEP MAY RETURN ARRAY [7B] BIBOP SAR SPACE NOW CALLED ARRAY SPACE [7C] IN BOTH LISPS, ALLOC SAYS "ARRAY=" [8] REVIEW OF P.$X AND FRIENDS ---------------------------------------------------------------- [1] IT HAS BEEN OBSERVED THAT OCCASIONALLY RUNTIMES WILL BE MEASURED AS BEING NEGATIVE. THIS IS APPARENTLY AN ITS BUG HAVING SOMETHING TO DO WITH REQUESTING CORE MANAGEMENT, SO IT HAPPENS MORE IN BIBOP LISP THAN IN NON-BIBOP. I'VE TAKEN SOME COMPENSATIVE ACTIONS, BUT BE FOREWARNED AND BEWARE. [2] CHANGE TO ERRFRAMES: FOR COMPATIBILITY WITH EVALFRAMES, ERRFRAMES ARE NOW OF THE FORM (ERR ) I.E. THE ATOM "ERR" IS NOW CONSED ON THE FRONT, JUST AS "EVAL" OR "APPLY" IS CONSED ONTO AN EVALFRAME. [3] SPEAKING OF EVALFRAMES: FUNCALL CREATES SUCH A FRAME OF THE APPLY VARIETY THESE DAYS. [4] (NRECONC X Y) <=> (NCONC (NREVERSE X) Y) BUT IS FASTER, BECAUSE IT DOESN'T HAVE TO SCAN BACK DOWN THE LIST JUST NREVERSED TO DO THE NCONC. [5] PRINT, PRIN1, AND PRINC CHECK ALL THEOUTPUT FLAGS (^W, ^R, ^B, ^N) BEFORE COMMENCING PRINTOUT. IF THE FLAGS ALL INDICATE NO OUTPUT, THEY RETURN IMMEDIATELY, THUS SAVING MUCH TIME. FURTHERMORE, IF OUTPUT IS GOING TO THE TTY AND NOWHERE ELSE, AND YOU ARE USING PRINLEVEL AND PRINLENGTH TO GET ABBREVIATED FORMS OUTPUT, THEN ONLY THE ABBREVIATED FORMS ARE GENERATED. THIS MEANS THAT TYPING ^R IN THE MIDDLE OF SUCH A PRINTOUT MAY CAUSE A FILE TO RECEIVE (THE TAIL END OF) AN ABBREVIATED FORM, EVEN IF (STATUS ABBREVIATE) REQUESTS OTHERWISE. ON THE OTHER HAND, THIS HACK PREVENTS CERTAIN SCREWS INVOLVING CIRCULAR LISTS. [6] IF DSK:LOSER;FOO BAR IS A LINK TO DSK:CLOD;ZORCH QUUX AND YOU DO (UREAD FOO BAR DSK LOSER), THEN (STATUS UREAD) WILL RETURN (ZORCH QUUX DSK CLOD) AND NOT (ZORCH QUUX DSK LOSER) AS IT USED TO. [7] SOME NEW STUFF HAS BEEN INSTALLED IN THIS LISP IN ANTICIPATION OF THE NEW FAST ARRAY SCHEME. A NEW KIND OF SPACE HAS BEEN IMPLEMENTED IN NON-BIBOP LISP, ANALOGOUS TO BIBOP LISP'S FORMER "SAR" SPACE, WHICH HOLDS OBJECTS CALLED ARRAY POINTERS. [7A] SUCH OBJECTS ARE OF TYPE "ARRAY". TYPEP WILL RETURN "ARRAY" FOR SUCH AN OBJECT. [7B] BIBOP'S SAR SPACE IS NOW CALLED ARRAY SPACE, FOR INDEED THEY ARE THE SAME OBJECTS. THUS YOU MUST NOW SAY (ALLOC '(ARRAY 300)) INSTEAD OF (ALLOC '(SAR 300)), ETC. [7C] THE INITIAL ALLOC WILL ASK YOU "ARRAY=". ARRAY POINTERS ARE TWO WORDS, SO IF YOU SAY 100., YOU HAVE ALLOCATED ROOM FOR 50. ARRAY POINTERS. OTHERWISE ALL THE ARRAY STUFF SHOULD WORK THE SAME AS BEFORE; BUT WATCH FOR THE NEW ARRAY SCHEME! [8] FOR PEOPLE WHO USE DDT TO DEBUG LISP CODE (I.E. SUPER-HACKERS), HERE IS A REVIEW OF P.$X AND FRIENDS: P.$X AND RELATED GOODIES ARE NAMED INSTRUCTIONS WHICH YOU CAN EXECUTE FROM DDT WITH THE $X COMMAND WHICH DO ALL KINDS OF NICE THINGS FOR YOU. THEY AVOID CLOBBERING ANYTHING WITHIN THE LISP, E.G. THEY SAVE AND RESTORE ANY ACCUMULATORS AND/OR TEMPORARIES THEY USE, AND ARE CIRCUMSPECT ABOUT I/O SWITCHES. REFERENCES TO "THE LEFT HALF OF ." OR "THE RIGHT HALF OF ." MEANS THAT THE LEFT OR RIGHT HALF OF DDT'S CURRENTLY OPEN LOCATION IS UNDER CONSIDERATION. $=ALTMODE. P.$X ASSUMES THE RIGHT HALF OF . TO BE AN S-EXPRESION, AND PRINTS IT. PL.$X PRINTS THE LEFT HALF OF . AS AN S-EXPRESSION. PP Z$X WHERE Z IS SOME QUANTITY, PRINTS THAT QUANTITY AS IF IT WERE A POINTER, AS AN S-EXPRESSION. (PP IS A UUO, AND Z IS ITS EFFECTIVE ADDRESS. SINCE PP IS A UUO, A FEW TEMPORARIES USED BY THE UUO HANDLER GET CLOBBERED; THUS BEWARE OF USING IT IF YOU MAY HAVE BROKEN OUT OF THE UUO HANDLER TO DDT.) VC.$X ASSUMES THAT THE RIGHT HALF OF . POINTS TO A VALUE CELL, AND RUNS OVER THE OBARRAY TRYING TO FIND AN ATOM WITH THAT VALUE CELL. PRINTS THE ATOM IF IT FINDS ONE, OTHERWISE PRINTS ?. VCL.$X ASSUMES LEFT HALF OF . POINTS TO A VALUE CELL, AND BEHAVES LIKE VC.$X. NOTE THAT THIS IS PARTICULARLY GOOD FOR EXAMINING SPECIAL PDL ENTRIES, WHICH HAVE VALUE CELL POINTERS IN THE LEFT HALF, AND OLD VALUES ON THE RIGHT HALF. SB.$X ASSUMES THAT THE RIGHT HALF OF . POINTS SOMEWHERE INTO THE MIDDLE OF A SUBR, AND RUNS OVER THE OBARRAY TRYING TO FIND THE NAME OF THE SUBR. IF THE NAME CAN BE FOUND, IT IS PRINTED. THIS IS ESPECIALLY GOOD FOR REGULAR PDL ENTRIES CREATED BY PUSHJ, BECAUSE THEY CONTAIN A SUBR RETURN ADDRESS IN THE RIGHT HALF. HH$X CREATE A FAKE ^H BREAKPOINT IN LISP. THIS SAVES THE ENVIRONMENT THE WAY ANY USER INTERRUPT DOES AND LETS YOU INVESTIGATE A LITTLE. THIS IS GOOD WHEN YOU CAN'T AFFORD TO PROCEED THE LISP EVEN LONG ENOUGH TO TYPE ^H AT IT. WHEN YOU TYPE $P AT LISP, YOU WILL SEE A *. YOU ARE IN DDT! (YES, $P GETS YOU BACK TO DDT, NOT BACK FROM IT, HERE!) NOTE THAT IF YOU WENT BACK TO DDT WHILE LISP HAD USER INTERRUPTS LOCKED OUT (E.G. IN THE MIDDLE OF A GARBAGE COLLECTION), THEN THE ^H BREAK CAN'T BE RUN; YOU WILL RETURN TO DDT IMMEDIATELY. DP$X DEPURIFIES THE PAGE CONTAINING .. THIS WAS INVENTED BEFORE DDT DID IT FOR YOU. RP$X REPURIFIES THE PAGE CONTAINING .. THIS IS SOMEWHAT MORE USEFUL, E.G. TO REPURIFY A PAGE AFTER PATCHING IT. PURIFY$G THIS PURIFIES THE SYSTEM PAGES OF LISP WHICH MAY BE PURE. FOR BIBOP LISP, IT ALSO PURIFIES THOSE PAGES OF USER CODE WHICH HAVE BEEN MARKED AS PURIFIABLE. IT TENDS TO DESTROY ACCUMULATORS; YOU CAN'T PROCEED AFTER DOING IT. (IT IS GENERALLY PERFORMED PRIOR TO DUMPING OUT A LISP, E.G. JUST AFTER A CALL TO THE FUNCTION MACDMP.) THE REST OF THESE ARE AVAILABLE ONLY IN BIBOP LISP. T.$X IS LIKE P.$X, BUT INSTEAD OF PRINTING THE RIGHT HALF OF . AS AN S-EXPRESSION, IT GETS TYPEP INFORMATION FOR IT FROM THE BIBOP TYPE TABLE, AND PRINTS THE TYPE INFORMATION. TL.$X LIKE T.$X, BUT LOOKS AT THE LEFT HALF OF .. TP Z$X LIKE PP Z$X, ONLY DOES T. INSTEAD OF P.. TBLPUR$X PRINTS OUT BIBOP'S PURTBL DATA BASE, ONE DIGIT FOR EVERY PAGE IN THE 256K ADDRESS SPACE. THE DIGITS ARE 0 = NONEXISTENT MEMORY, 1 = IMPURE MEMORY, 2 = PURE MEMORY, 3 = MEMORY IN AN UNCERTAIN STATE, E.G. PDL AREAS AND THE END OF BINARY PROGRAM SPACE. AT THE END SUMMARIES ARE PRINTED. THIS IS NOT THE ACTUAL STATE OF MEMORY, BUT ONLY WHAT BIBOP WOULD LIKE IT TO BE, E.G. A PAGE MARKED 2 MAY NOT REALLY BE PURE. PURIFY$X IN BIBOP EFFECTIVELY FORCES THE ACTUAL STATE OF THE WORLD TO CONFORM TO THE PURTBL. PAGPUR$X PRINTS OUT A TABLE LIKE TBLPUR, BUT DISPLAYS THE ACTUAL STATE OF EACH PAGE, NONEXISTENT, IMPURE, OR PURE. WEDNESDAY FEB 13,1974 FM+7D.3H.28M.38S. LISP 746 - GLS - AS OF VERSION 746, LISP SYSTEMS OF THE SAME VERSION WILL SHARE PAGES AMONG THEMSELVES; I.E. A LISP, MACSYMA, AND CONNIVER CAN ALL SHARE PAGES COMMON TO THE LISP SYSTEM. BIBOP LISP HAS BEEN GREATLY RESTRUCTURED; I WILL RE-EDIT THE BIBOP DOCUMENT AS SOON AS I CAN (SAY WITHIN THE NEXT WEEK). -- GLS BRIEF SYNOPSIS: [1] LOSSES DUE TO FAILURE TO GET CORE NOW LEAVE YOU IN DDT [2] NEW FUNCTION: IMPLODE [3] FASLOAD, UREAD, UFILE OF ONE ARG [4] USE :PDUMP FOR BIBOP LISP SYSTEMS, NEVER $Y [5] ALTMODE LETS INIT FILE LOOK AT JCL [6] (STATUS STATUS ...), (STATUS SSTATUS ...), (STATUS FEATURE ...) [7] NEW *PURE HACK USING VALUE OF THE SYMBOL "PUTPROP" [8] *PURE CAUSES ALL SYMBOL BLOCKS CREATED TO BE PURE [9] ARGS OF NIL DOES NOTHING, RETURNS NIL [10] (PRINC '/^P) DOES NOT OUTPUT CTRL/P, BUT UPARROW-P ---------------------------------------------------------------- [1] THE LOAD ON THE PDP-10'S HAS INCREASED GREATLY OF LATE. BECAUSE OF THIS, LISP MORE OFTEN FAILS TO GET MORE CORE WHEN IT NEEDS TO. FORMERLY THIS USED TO PRODUCE VARIOUS KINDS OF UNCORRECTABLE LISP ERRORS, SUCH AS "NO CORE - FASLOAD". (THIS WAS REASONABLE BECAUSE IT HAPPENED SO SELDOM.) NOW, UNDER SUCH HEAVY LOADS, IT IS NOT REASONABLE TO LOSE PERMANENTLY JUST BECAUSE THE SYSTEM IS LOADED. THEREFORE WHEN LISP FAILS TO GET CORE, IT SHOULD NOW PRINT THE MESSAGE :$ CAN'T GET CORE! YOU ARE IN DDT - TYPE $P TO TRY AGAIN $ OR WORDS TO THAT EFFECT. WHEN THIS HAPPENS, YOU ARE INDEED IN DDT; YOU MAY FLUSH THE LISP AND LOG OUT, THEREBY BECOMING A HERO FOR LIGHTENING THE SYSTEM LOAD, OR YOU CAN PROCEED THE LISP, WHICH WILL TRY AGAIN TO GET THE NECESSARY CORE. [2] NEW FUNCTION: IMPLODE, A SUBR OF ONE ARGUMENT, IS EQUIVALENT TO INTERN OF MAKNAM, I.E. (IMPLODE X) <==> (INTERN (MAKNAM X)). THE DIFFERENCE IS THAT IMPLODE IS MUCH MORE EFFICIENT (AVOIDS MUCH UNNECESSARY CONSING). [3] UREAD, UFILE, AND FASLOAD NOW ACCEPT A SINGLE ARGUMENT; UREAD AND UFILE ASSUME THAT THE MISSING SECOND FILE NAME IS ">", WHILE FASLOAD ASSUMES THAT THE SECOND FILE NAME IS "FASL". IN THE INTERESTS OF SAFETY, UKILL STILL REQUIRES BOTH NAMES. [4] BECAUSE OF LOSSAGE ON ITS' PART, COMBINED WITH THE MEMORY MANAGEMENT STRATEGIES OF BIBOP LISP, ONE SHOULD NEVER, NEVER, NEVER USE $Y TO DUMP OUT A BIBOP LISP ONCE SOMETHING HAS BEEN LOADED INTO IT, SUCH AS A CONNIVER OR ACTOR SYSTEM. ALWAYS BUT ALWAYS, USE :PDUMP INSTEAD, EVEN IF YOU HAVEN'T PURIFIED THE BIBOP LISP. [5] IF THE JOB COMMAND LINE TO A FRESH LISP CONTAINS AN ALTMODE, THEN THE PART BEFORE THE ALTMODE IS USED AS THE INIT FILE NAME, AND THE PART AFTER IS IGNORED. FURTHERMORE THE JCL IS NOT FLUSHED; THUS THE INIT FILE CAN USE (STATUS JCL) TO LOOK AT THE PART AFTER THE ALTMODE. IF THERE IS NOTHING BEFORE THE ALTMODE, THEN LISP JUST SAYS "ALLOC?"; BUT THE JCL HAS NOT BEEN FLUSHED AND CAN BE EXAMINED AS BEFORE. THUS IF YOU SAY TO DDT :LISP FOO;BAR QUUX$HACK THEN THE INIT FILE NAMED "FOO;BAR QUUX" IS USED, AND (STATUS JCL) WOULD RETURN THE LIST (F O O /; B A R / Q U U X $ H A C K) [6] THREE NEW STATUS FEATURES: [A] (STATUS STATUS FOO) RETURNS T IFF "FOO" IS A VALID STATUS OPTION. THUS (STATUS STATUS UNAME) WOULD RETURN T, WHILE (STATUS STATUS ZORCH) WOULD RETURN NIL. IF "FOO" IS NOT PRESENT (I.E., YOU SAY (STATUS STATUS)), THEN A LIST OF VALID STATUS OPTIONS IS RETURNED (THE NAMES WILL BE TRUNCATED TO 5 CHARACTERS, HOWEVER, AND TO SOME OTHER NUMBER OF CHARACTERS ON OTHER IMPLEMENTATION). [B] (STATUS SSTATUS FOO) IS SIMILAR TO THE ABOVE, BUT RETURNS T IFF "FOO" IS A VALID SSTATUS OPTION. NOTE THAT ALL VALID SSTATUS OPTIONS ARE VALID STATUS OPTIONS, BUT NOT ALL VALID STATUS OPTIONS ARE VALID SSTATUS OPTIONS. (STATUS SSTATUS) RETURNS A LIST OF (TRUNCATED) NAMES OF VALID SSTATUS OPTIONS. [C] (STATUS FEATURE FOO) IS ESSENTIALLY THE SAME AS (NOT (NULL (MEMQ 'FOO (STATUS FEATURES)))) AND IS FOR CONVENIENCE' SAKE. [7] *PURE, WHICH IS THE MAGIC VARIABLE CONTROLLING VARIOUS PURIFICATION HACKS IN BIBOP LISP, HAS AN EFFECT ON THE PUTPROP FUNCTION. THE VALUE OF THE VARIABLE PUTPROP SHOULD BE A LIST OF PROPERTY NAMES (IT IS INITIALLY (SUBR FSUBR LSUBR); PUTTING "ARRAY" ON THIS LIST IS A MAJOR DISASTER, SO DON'T DO IT!). IF *PURE IS NON-NIL, THEN IF PUTPROP IS PUTTING ON A PROPERTY WHICH DIDN'T EXIST BEFORE, THEN INSTEAD OF PUTTING THE PROPERTY AT THE FRONT OF THE PROPERTY LIST, IT PUTS IT IN THE MIDDLE SOMEWHERE, AND PURIFIES BOTH THE PROPERTY VALUE AND THE TWO WORDS OF PROPERTY LIST IT CREATES. RECALL THAT *PURE IS FOR USE ONLY WHEN LOADING UP LARGE SYSTEMS TO BE DUMPED, LIKE MACSYMA. IF YOU AREN'T SURE OF ALL THIS, EITHER IGNORE IT OR ASK GLS OR JONL. [8] ANOTHER *PURE HACK IS THAT IF ANY ATOMIC SYMBOLS ARE CREATED, AS MUCH AS POSSIBLE OF THE ATOMIC SYMBOL IS MADE PURE. THIS CAUSES SOME FUNNINESSES TO HAPPEN, SUCH THAT SOMETIMES IT MUST BE DEPURIFIED (I.E. COPIED). ANY QUESTIONS? SEE GLS. [9] IF THE FIRST ARGUMENT TO ARGS IS NIL, IT DOES NOTHING AT ALL EXCEPT RETURN NIL. (RECALL THAT NIL IS NOT A VALID FUNCTION ANYWAY). [10] TO PREVENT THOSE NASTY I/O SCREWS, TYO AND RELATED FUNCTIONS LIKE PRINT WILL NOT OUTPUT CTRL/P'S - RATHER IT OUTPUTS THEM AS AN UPARROW AND A P (THIS AFFECTS ONLY THE TTY - CTRL/P'S CAN STILL BE SENT TO FILES). TO DO CURSOR CONTROL, FOR ANY CHARACTER X, DO (CURSORPOS 'X) INSTEAD OF (PRINC '/^PX). EXAMPLE: TO CLEAR THE SCREEN, USE (CURSORPOS 'C). WEDNESDAY DEC 26,1973 NM+2D.6H.21M.49S. LISP 707 - GLS - BRIEF SYNOPSIS: [1] "APPLY FRAMES" ARE PUSHED BY APPLY AND UUO HANDLER [2] NEW VARIABLE IN BLISP: *PURE CONTROLS PURE FREE STORAGE [3] RPLACA/RPLACD NOW DO SOME ARGUMENT CHECKING [4] IN BLISP, GC-OVERFLOW IS WHAT USED TO BE GC-LOSSAGE (MAX) [5] (STATUS NEWLINE) RETURNS ASCII VALUE OF NEWLINE CHARACTER [6] LISP NOW KNOWS ABOUT (INIT) DIRECTORY; STANDARD INIT FILES [7] GETCOR SUBROUTINE TO ALLOCATE CORE FOR HAND-CODED LAP USERS ---------------------------------------------------------------- [1] THERE ARE NOW TWO VARIETIES OF EVALFRAMES: ONE IS THE USUAL EVAL FRAME, AND THE OTHER IS CALLED AN "APPLY FRAME". THE FORMER IS PUSHED BY ENTRIES TO EVAL, THE LATTER BY ENTRIES TO APPLY. ALSO, THE UUO HANDLER WILL NOW PUSH ONE OR THE OTHER KIND OF FRAME IF IT CAN (USUALLY AN APPLY FRAME); THUS COMPILED CODE CALLS CAN BE BETTER DEBUGGED WITH BAKTRACE AND EVALFRAME ALSO (PROVIDING *RSET AND NOUUO ARE BOTH ON, OF COURSE). THE DIFFERENCE BETWEEN AN EVAL FRAME AND AN APPLY FRAME IS THAT AN EVAL FRAME CONTAINS A FORM, WHILE AN APPLY FRAME CONTAINS A FUNCTION AND A LIST OF (PRESUMABLY ALREADY EVALUATED) ARGUMENTS. THE EVALFRAME FUNCTION HAS BEEN ALTERED ACCORDINGLY; IT NOW RETURNS A 4-LIST INSTEAD OF A 3-LIST. THE CAR OF THIS LIST IS ONE OF THE SYMBOLS "EVAL" OR "APPLY"; THE CADR IS THE FRAME POINTER (THE CAR OF THE OLD 3-LIST); THE CADDR IS A FORM FOR AN EVAL FRAME (AS BEFORE), BUT FOR AN APPLY FRAME IS A 2-LIST OF THE FUNCTION AND THE LIST OF ARGUMENTS; AND THE CADDDR IS THE A-LIST POINTER (THE CADDR OF THE OLD 3-LIST). EXAMPLE: IF AN EVAL FRAME WERE CREATED FOR (FOO 'A 'B) THEN EVALFRAME WOULD RETURN (EVAL (FOO (QUOTE A) (QUOTE B)) (FOO (A B)) ) NOTE THAT IN EITHER CASE CAADDR OF THE 4-LIST GIVES YOU THE FUNCTION THAT WAS INVOKED. OF COURSE, ALL THIS STUFF HAPPENS ONLY IN *RSET MODE, AND FOR THE UUO STUFF TO WORK NOUUO SHOULD BE NON-NIL ALSO. [2] IN BLISP, THE CONTROL OF AUTOMATIC USE OF PUR FREE STORAGE HAS BEEN TRANSFERRED FROM THE VARIABLE "PURE" TO THE VARIABLE "*PURE". "PURE", AS BEFORE, STILL CONTROLS THE PURE CODE GENERATION AND XCT PAGES HACKERY SUPPORTED BY FASLOAD. *PURE SHOULD BE NON-NIL ONLY WHEN LOADING UP A SYSTEM TO BE SUBSEQUENTLY :PDUMP'ED; IT CAUSES CERTAIN KINDS OF THINGS TO BE PLACED IN PURE FREE STORAGE SO THAT THEY WILL BE SHARED IN THE NEW SYSTEM. AMONG THE THINGS THAT WILL BE AUTOMATICALLY PURIFIED: CONSTANT LIST STRUCTURE USED BY COMPILED CODE PNAMES OF ALL INTERNED ATOMIC SYMBOLS VARIOUS OTHER THINGS MAY OR MAY NOT BE PURIFIED; I AM STILL EXPERIMENTING WITH THIS HACK. HOWEVER, ITS ACTIONS WILL ALWAYS BE CONSISTENT WITH THE IDEA OF LOADING UP AND :PDUMP'ING A LARGE SYSTEM (E.G. MACSYMA). AGAIN, THE CORRECT USE IS: (SETQ *PURE T) ;MAYBE ALSO SETQ PURE --- LOAD UP SYSTEM --- (SETQ *PURE NIL) ;HOWEVER, NEEDN'T CHANGE PURE (MACDMP ':PDUMP/ / ) [3] RPLACA, WHEN CALLED INTERPRETIVELY, OBJECTS TO CLOBBERING ANYTHING BUT AN IMPURE LIST CELL. RPLACD OBJECTS TO CLOBBERING ANYTHING BUT AN IMPURE LIST CELL OR AN ATOMIC SYMBOL. (RECALL THAT THESE ARE OPEN-CODED BY COMPLR.) [4] THE GC-LOSSAGE INTERRUPT NOW RECEIVES NOT A LIST, BUT ONLY THE NAME OF A SPACE (AS NON-BIBOP USED TO, AND NOW DOES AGAIN). THIS CORRESPONDS TO WHAT FORMERLY WAS INDICATED BY ( MIN). THE MAX CASE IS NOW FIELDED BY A NEW USER INTERRUPT (NUMBER 13.) CALLED GC-OVERFLOW. THIS IS NOT AN ERROR BREAK INTERRUPT, THOUGH THE DEFAULT HANDLER DOES DO A ;BKPT GC-OVERFLOW. INSTEAD, IT IS MORE AKIN TO THE GC-DAEMON, THE DIFFERENCE BEING THAT GC-DAEMON RUNS AFTER EVERY GC, WHILE GC-OVERFLOW RUNS ONLY WHEN A GCMAX PARAMETER HAS BEEN EXCEEDED. .INFO.;BIBOP (MEMO) REFLECTS THESE CHANGES, IN EFFECT AS OF BIBOP LISP 696. NOTE THE GREAT SIMILARITY OF GC-OVERFLOW TO PDL-OVERFLOW; IN PARTICULAR, SINCE GC-OVERFLOW IS NOT AN ERROR BREAK, SAYING $P DOES NOT ERROR OUT TO TOP LEVEL, BUT RATHER CONTINUES THE COMPUTATION. YOU MUST USE ^G OR SOMETHING TO QUIT. NOTE THAT IF YOU SAY (SETQ GC-OVERFLOW NIL) YOU WILL NEVER SEE ANYTHING WHEN A GCMAX IS EXCEEDED, AND GC WON'T COMPLAIN; HOWEVER, MEMORY WILL BE EXPANDED IN AN INCREDIBLY INEFFICIENT MANNER. THE FILE ML:GLS;BIBOP GCOVER CONTAINS A SAMPLE GC-OVERFLOW HANDLER (A REWORKED COPY OF THE OLD GC-LOSSAGE EXAMPLE). NOTE THAT ALL THIS SHOULD CORRECT THE PROBLEM OF GC-LOSSAGE INSIDE AN ERRSET. [5] (STATUS NEWLINE) RETURNS 13. IN PDP-10 LISP, BUT 10. ON MULTICS; THAT IS, IT RETURNS THE ASCII VALUE OF THE NEWLINE CHARACTER FOR WHATEVER SYSTEM YOU'RE ON. THIS SHOULD RELIEVE SOME INCOMPATIBILITIES. [6] LISP WILL NOW USE THE (INIT) DIRECTORY TO FIND LISP INIT FILES. THERE ARE TWO CASES: [A] IF YOU GAVE THE LISP JCL, BUT LEFT THE SECOND FILE NAME TO BE (INIT), AND THE SPECIFIED FILE DOESN'T EXIST, THEN LISP PERMUTES FOO;BAR (INIT) TO BE (INIT);FOO BAR AND LOOKS FOR THAT FILE. IF THIS FAILS, LISP GETS UNHAPPY AND REVERTS TO THE TTY. EXAMPLE: :LISP FOO; WOULD FIRST LOOK FOR FOO;.LISP. (INIT), AND THEN FOR (INIT);FOO .LISP. NOTE THAT IF YOU GIVE TWO FILES NAMES FOR JCL, LISP WILL NOT LOOK AT THE (INIT) DIRECTORY, SINCE THE SECOND FILE NAME WILL NOT BE (INIT). THUS :LISP FOO BAR WOULD NOT LOOK AT THE (INIT) DIRECTORY IF FOO BAR DIDN'T EXIST, BUT :LISP FOO;BAR WOULD (IT WOULD LOOK FOR (INIT);FOO BAR, PROVIDED THAT FOO;BAR (INIT) DIDN'T EXIST). [B] IF YOU GAVE LISP NO JCL, BUT TYPE ^Q OR ^W AT THE ALLOC? QUESTION, THEN LISP LOOKS FIRST FOR ;.LISP. (INIT), AND IF THAT FAILS, FOR (INIT); .LISP. FOR CONVENIENCE THERE ARE TWO FILES ON (INIT) CALLED "DOCTOR .LISP." AND "INDEX .LISP.". THUS TO GET A DOCTOR YOU NEED ONLY SAY TO DDT :LISP DOCTOR; AND TO GET AN INDEX (WITH CORE=60) :LISP INDEX; NOTE: THE SEMICOLONS ARE IMPORTANT! [7] THERE IS A LITTLE ROUTINE INTERNAL TO LISP FOR THE BENEFIT OF HAND-CODED LAP LOSERS TO GOBBLE UP BLOCKS OF CORE. IT IS INVOKED AS FOLLOWS (NATURALLY, YOU SHOULD HAVE LISP SYMBOLS LOADED INTO DDT WHEN YOU LOAD UP THE LAP): (MOVEI TT ) ;NUMBER OF 1K PAGES DESIRED (PUSHJ P GETCOR) ;RESERVES A BLOCK OF CORE (JUMPE TT LOSE) ;RETURNS 0 IN TT IF LOST ... ;ELSE TT HAS LOW ADDRESS OF BLOCK ACCUMULATOR TT SHOULD HAVE THE AMOUNT OF CORE DESIRED, MEASURED IN 1K PAGES. IF GETCOR WINS IT WILL RETURN THE LOW ADDRESS OF A CONTIGUOUS BLOCK OF THE SPECIFIED SIZE IN TT; OTHERWISE IT WILL RETURN 0 IN TT. GETCOR RESERVES THE RIGHT TO SMASH ANY ACCUMULATORS IT WANTS TO, SO BE CAREFUL! NOTE WELL: GETCOR MERELY RESERVES ADDRESS SPACE; IT DOES NOT ACTUALLY CAUSE THE CORE TO APPEAR. THUS IT IS UP TO THE CALLER TO DO *CBLK'S TO GET THE CORE, OR MAP IT INTO PDP-6 OR PDP-11 MEMORY, OR WHATEVER. GETCOR MERELY CAUSES LISP TO PROMISE NOT TO USE THAT SECTION OF THE ADDRESS SPACE FOR ANY OTHER PURPOSE. SUCCESSIVE CALLS TO GETCOR WILL RETURN DISJOINT AND NOT NECESSARILY CONTIGUOUS BLOCKS OF CORE. THERE IS NO PROVISION FOR RETURNING A BLOCK OF CORE WHEN YOU'RE DONE WITH IT. THIS ROUTINE EXISTS IN BOTH NON-BIBOP AND BIBOP LISPS; THOSE PEOPLE WHO HAVE JUST BEEN GRABBING PAGES OF HIGH CORE IN NON-BIBOP LISP SHOULD CHANGE THEIR CODE TO USE GETCOR SO THAT IT WILL RUN IN BIBOP LISP. EXAMPLE: (MOVEI TT 10) (PUSHJ P GETCOR) ;GET CORE (JUMPE TT LOSE) ;LOSEY LOSEY (MOVEI D 10) ;SO MAP 8. PAGES (MOVE R (% 0 0 001777 600030)) ;MAGIC NUMBER (MOVEI F 0 TT) ;F GETS LOW ADDRESS OF BLOCK (LSH F -12) ;NO, MAKE THAT THE PAGE # LOOP (*CALL 0 11MAP) ;MAP A PAGE (*VALUE) (ADDI F 1) ;INCREMENT STUFF (ADD R (% 0 0 0 4)) (SOJG D LOOP) ... 11MAP (SETZ) ;MAGIC CALL TO MAP A PAGE (SIXBIT T11MP) (F) (SETZ 0 R) THIS EXAMPLE MAPS THE MEMORY OF THE PDP-11 DISPLAY INTO AN 8K BLOCK OF MEMORY IN LISP SO THAT OTHER ROUTINES CAN MUNG THE DISPLAY, PRESUMABLY. THE ADDRESS OF THE LOW END OF THE 8K BLOCK IS STILL IN ACCUMULATOR TT. 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 )) 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 ). 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 ( . ), IT IS NOW OF THE FORM ( . ). 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) ) 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 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 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 ). 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. 9/15/73 GLS, AND JONL BRIEF SYNOPSIS: 1) NEW FUNCTIONS PROGN AND FUNCALL 2) THE FUNCTION BREAK EXPLAINED 3) NUMBERS ARE ACCEPTABLE AS PROG TAGS 4) MORE EXTENSIONS FOR USERS OF LOWER-CASE CHARS. 5) SOME REMINDERS OF IMPORTANT THINGS ALREADY KNOWN 6) A FEW MORE ARCANE DETAILS ABOUT THE EVALUATOR. 1) LISP NOW HAS TWO MORE FUNCTIONS: [1] PROGN, AN LSUBR OF 0 OR MORE ARGS, WHICH (ODDLY ENOUGH) RETURNS ITS LAST ARGUMENT (NIL IF NO ARGS). [2] FUNCALL, AN LSUBR OF 1 OR MORE ARGS. (FUNCALL F X1 X2 ... XN) CALLS THE FUNCTION F WITH ARGUMENTS X1, X2, ... XN. THIS IS USEFUL IN SITUATIONS WHERE ONE WANTS TO EVALUATE SOME EXPRESSION TO OBTAIN THE FUNCTION. THUS (FUNCALL (CAR X) A B C) IS SIMILAR TO ((CAR X) A B C) BUT LOOKS NICER. ITS PRIMARY USE IS IN THE CASE WHERE SOME VARIABLE HAS A FUNCTION AS ITS VALUE, BUT MAYBE ALSO HAS A FUNCTION PROPERTY. EXAMPLE: ((LAMBDA (CAR) (CAR X)) 'FOO) RETURNS THE RESULT OF APPLYING THE FUNCTION CAR TO THE VALUE OF X; HOWEVER ((LAMBDA (CAR) (FUNCALL CAR X)) 'FOO) RETURNS THE RESULT OF APPLYING THE FUNCTION FOO TO X. ********* INVALIDATED 1 NOV 1973. (SSTATUS BREAKLOOP) HAS BEEN FLUSHED ****** 2) (SSTATUS BREAKLOOP
) IS SIMILAR TO (SSTATUS TOPLEVEL ) TOP LEVEL. (ISN'T THAT AMAZING!) (STATUS BREAKLOOP), ODDLY ENOUGH, RETURNS THE FORM CURRENTLY BEING USED FOR BREAKLOOPS. NIL INDICATES THAT THE STANDARD BREAK LOOP IS TO BE USED. A NEAR APPROXIMATION TO THE ACTION OF BREAK, AND ITS INTERACTION WITH THE FORM SPECIFIED BY (STATUS BREAKLOOP) IS (DEFUN BREAK FEXPR (X) (AND (EVAL (CADR X)) ((LAMBDA (OBARRAY READTABLE ^Q ^W) (PRINC '/;BKPT/ ) (PRINC (CAR X)) (TERPRI) (PROG (V) A (AND (NULL (SETQ V (ERRSET (DO NIL (NIL) (EVAL BLF))))) (GO A)) (TERPRI) (RETURN (COND ((EQ V INTERNAL-UNBOUND) (AND (CDDR X) (EVAL (CADDR X)))) (V))))) (GET 'OBARRAY 'ARRAY) (GET 'READTABLE 'ARRAY) NIL NIL))) BLF IS THE BREAK LEVEL FORM, AND IS WHAT IS SET BY (SSTATUS BREAKLOOP BLF). THE DEFAULT VALUE IS SOMETHING LIKE ((LAMBDA (Z) (COND ((EQ Z 'P) (ERR INTERNAL-UNBOUND)) ((EQ (CAR Z) 'RETURN) (ERR (EVAL (CADR Z)))) (T (PRINT (EVAL Z)) (TERPRI)))) (READ)) ***** END OF INVALIDATED SECTION ***** ***** CESSATION OF INVALIDATION ***** ***** COMPLETION OF DELETION ***** 3) FIXNUMS AND FLONUMS MAY NOW BE USED AS PROG TAGS; THUS (PROG (YX) (FOO X) -2 (BAR X) 4.72 (OR X (GO -2)) (OR YX (GO 4.7)) (RETURN '(GO S ARE HAZARDOUS TO YOUR PROGRAMS))) WILL WORK PERFECTLY WELL. HOWEVER, BIGNUMS DO NOT WORK AS PROG TAGS. 4) MORE TRIUMPHS FOR LOWER CASE: [ONE] VALRET NOW KNOWS ABOUT :KILL WRITTEN IN LOWER CASE AS WELL AS UPPER CASE. IN EITHER CASE, WHEN ALL A VALRET STRING SAYS IS :KILL, THEN A .BREAK 16,120000 IS DONE INSTEAD OF A VALRET. [TWO] THE READER NOW ALLOWS LOWER-CASE LETTERS AS SUPRA-DECIMAL DIGITS AS WELL AS UPPER CASE WHEN (SSTATUS + T) IS DONE. 5) REMEMBER THIS! A WARNING TO USERS OF PUTPROP, REMPROP, ARGS, ETC: IN CERTAIN RESTRICTED CASES, THESE FUNCTIONS WILL COPY THE TOP LEVEL OF THE MENTIONED ATOM'S PROPERTY LIST. THIS HAPPENS IN THE CASE WHERE ALL OR PART OF THE PROPERTY LIST LIES IN A PURE (READ-ONLY) AREA OF MEMORY; IN PARTICULAR, THIS FACT IS TRUE OF ATOMIC SYMBOLS ASSEMBLED INTO THE SYSTEM, LIKE CAR AND LAMBDA. IF YOU FASLOAD IN A FILE WHICH REDEFINES MANY FUNCTIONS (LIKE LOADING IN A FILE TWICE OR SOMETHING!) AND YOU GET TIRED OF ALL THE WARNING MESSAGES, TRY SAYING (SETQ FASLOAD NIL), WHICH WILL TURN OFF THE MESSAGES. THIS CAN BE DONE IN THE MIDDLE OF A FASLOAD FROM A ^H BREAK. (SETQ FASLOAD T) TURNS THEN BACK ON AGAIN. 6) SOME REMNANTS: (STATUS RCT ...) AND (SSTATUS RCT ...) HAVE DISAPPEARED. IN *RSET MODE, THE FUNCTION STORE TRIES TO BE CLEVER ABOUT CHECKING ITS FIRST ARGUMENT TO MAKE SURE IT IS INDEED AN ARRAY CALL: ITS FIRST ARGUMENT SHOULD BE OF THE FORM (A X1 X2 ... XN) WHERE A HAS AN ARRAY PROPERTY OR HAS AS ITS VALUE AN ATOM WITH AN ARRAY PROPERTY. IF THESE CONDITIONS ARE NOT MET, STORE MAY BARF AT YOU. (THEN AGAIN, MAYBE NOT). STORE IS ALSO CLEVER ABOUT FORMS LIKE (STORE (FUNCALL A X1 ... XN) Y) AND (STORE (B X1 X2 . . . XN)) WHERE B HAS A MACRO PROPERTY. TO AVOID TRAPS OF AMBIGUITY, ESPECIALLY DURING COMPILATION, USE THE FUNCALL CONSTRUCT FOR "VARIABLE" ARRAYS. CALLS FROM COMPILED CODE, AND ANY OTHER USAGE OF THE CALL UUO, WILL PREFER ORDINARY FUNCTIONAL PROPERTIES TO ANY MACRO PROPERTY WHEN TRYING TO FIND THE FUNCTION DEFINITION FOR AN ATOM. IF A CALLED ATOM HAS ONLY A MACRO PROPERTY, THEN AN UNDF-FNCTN ERROR INTERRUPT WILL HAPPEN. THE AUTOLOAD MECHANISM DESCRIBED EARLIER IS ACTUALLY MORE COMPLICATED THAN PREVIOUSLY ADVERTISED. THIS IS HOW IT REALLY WORKS: IF EVAL, APPLY, OR THE UUO HANDLER IS HANDED AS A FUNCTION SOME ATOMIC SYMBOL WHOSE PROPERTY LIST HAS AN AUTOLOAD PROPERTY (AND NO OTHER FUNCTIONAL PROPERTY IS AHEAD OF IT ON THE PROPERTY LIST), THEN USER INTERRUPT NUMBER 18. (THAT'S EIGHTEEN DECIMAL) IS INVOKED; AS ITS SINGLE ARGUMENT THE INTERRUPT FUNCTION IS HANDED A DOTTED PAIR WHOSE CAR IS THE ATOMIC SYMBOL AND WHOSE CDR IS THE AUTOLOAD PROPERTY (JUST TO MAKE THINGS EASY). INITIALLY, THE HANDLER FOR INTERRUPT 18. IS SOMETHING LIKE (DEFUN +INTERNAL-AUTOLOAD (X) (APPLY (FUNCTION FASLOAD) (CDR X))) AS AND WHEN THE INTERRUPT HANDLER DECIDES TO RETURN, IT DARN WELL BETTER HAVE STUCK SOME OTHER KIND OF FUNCTION PROPERTY ON THE PROPERTY LIST OF THE ATOMIC SYMBOL! (IT IS NOT NECESSARY TO REMPROP THE AUTOLOAD PROPERTY, SO LONG AS THE OTHER ONE COMES FIRST ON THE PROPERTY LIST.) IS THE INTERRUPT HANDLER FAILS TO DO THIS, AN UNDF-FNCTN INTERRUPT WILL HAPPEN, WITH A MESSAGE LIKE "FUNCTION UNDEFINED AFTER AUTOLOAD". MAKUNBOUND HAS BEEN CHANGED SLIGHTLY FOR COMPATIBILITY: IT NOW RETURNS ITS ARGUMENT, RATHER THAN RETURNING THE INTERNAL UNBOUND MARKER. THE ; READ-MACRO FUNCTION IS NOW MORE CLEVER ABOUT THE SITUATION WHERE IT HITS THE END OF A FILE BEFORE FINDING A CARRIAGE RETURN. 7/31/73 - GLS, JONL - LISP 523 BRIEF SYNOPSIS: 1) NEW AUTOLOAD FEATURE FOR NON-CORE-RESIDENT FUNCTIONS 2) EXTENSIONS TO SORT AND SORTCAR TO ALLOW SORTING OF LISTS WITHOUT INTERMEDIATE USE OF ARRAYS. 3) FILLARRAY SUPERSEDES INITARRAY 4) LISTIFY OPTIONS EXTENDED TO GET LAST N ARGS TO AN LEXPR AS 5) (ARG NIL) USED TO OBTAIN THE NUMBER OF ARGS PASSED TO AN LEXPR. WELL AS THE FIRST N. 6) THE ATOM "PNAME" WILL NO LONGER USED. BEGINNING WITH LISP 523, "SYMBOL" WILL BE THE RESULT OF TYPEP FOR THAT CLASS OF OBJECTS. 7) THE FILE .INFO.;LISP FCNS HAS AN ALPHABETIZED TABLE OF INITIAL LISP FUNCTIONS AND GLOBAL VARIABLES. 8) COMPLR HAS QUOTING CHAR FOR FILE NAME SPECS, AND ACCEPTS MULTIPLE INPUT FILES. THE AUTOLOAD FEATURE HAS BEEN GENERALIZED FOR USE BY LOSERS: AN "AUTOLOAD" PROPERTY ON AN ATOM IS TREATED BY THE INTERPRETER VERY MUCH LIKE A FUNCTIONAL PROPERTY. IF "AUTOLOAD" IS THE FIRST FUNCTIONAL PROPERTY ON AN ATOMS PROPERTY LIST, THEN THE INTERPRETER WILL FIRST FASLOAD IN THE FILE SPECIFIED UNDER THAT PROPERTY. THUS, IF YOU HAVE SAID (DEFPROP FOO (BAR FASL DSK QUUX) AUTOLOAD) OR THE EQUIVALENT, AND THEN TRY TO USE FOO AS A FUNCTION [AND THE AUTOLOAD PROPERTY IS FOUND BEFORE ANY OTHER KIND OF FUNCTIONAL PROPERTY]; THEN EVAL (OR WHOEVER) WILL FASLOAD IN DSK:QUUX;BAR FASL, AND TRY AGAIN TO GET A MORE STANDARD FUNCTION PROPERTY FOR FOO (WHICH HAD DARNED WELL BETTER BE REDEFINED BY THE FILE AS SOMETHING ELSE OTHER THAN "AUTOLOAD"). THE SORT FUNCTIONS HAVE BEEN EXTENDED AS FOLLOWS: IF THE FIRST ARGUMENT TO SORT OR SORTCAR IS NOT A LIST, THEN IT HAD BETTER BE AN ARRAY, AND THE CURRENT ARRAY SORT IS USED. IF IT IS A LIST, THEN A SUPER-WINNING MERGE SORT (CODED IN LISP BY MJF, THEN HAND-TRANSLATED TO MIDAS) IS USED. THE ITEMS OF THE LIST ARE ORDERED BY DOING MANY RPLACD'S ON THE LIST; THUS IF YOU DON'T WANT YOUR LIST DESTROYED, COPY IT FIRST BY SAYING (SORT (APPEND FOO NIL) 'PRED) INSTEAD OF (SORT FOO 'PRED) OR WHATEVER. IF YOU DON'T CARE, THEN YOU PROBABLY WANT TO USE IT LIKE DELQ IS USUALLY USED: SAY (SETQ FOO (SORT FOO 'PRED)). THE EXISTENCE OF THIS NEW MERGE SORT OF COURSE OBSOLETES THE EXAMPLE GIVEN PREVIOUSLY FOR SORTING A LIST. THE MERGE SORT IS GENERALLY FASTER THAN THE ARRAY SORT, AT THE EXPENSE OF THE DATA OCCUPYING TWICE AS MUCH CORE (OF COURSE, THE DATA WILL RESIDE IN DIFFERENT AREAS OF CORE ALSO: BPS FOR ARRAY SORT, LIST SPACE FOR MERGE.) THE FUNCTION INITARRAY PREVIOUSLY ADVERTISED HAS DISAPPEARED: FILLARRAY HAS BEEN GENERALIZED TO SERVE THE SAME PURPOSE. IF THE LIST GIVEN TO FILLARRAY IS TOO SHORT, THEN FILLARRAY USES THE LAST ITEM TO FILL OUT THE REST OF THE ARRAY. THUS (FILLARRAY 'BAR '(FOO)) <=> (INITARRAY 'BAR 'FOO). NO GUARANTEES ABOUT ANYTHING IF YOU HAND FILLARRAY AN ATOM INSTEAD OF A NON-NIL LIST! THE FUNCTION LISTIFY HAS BEEN GENERALIZED SO THAT IF YOU HAND IT A NEGATIVE ARG THEN THE LAST N ARGS ARE LISTIFIED UP INSTEAD OF THE FIRST N. THUS: ((LAMBDA N (LIST (LISTIFY -3) (LISTIFY 3)) 'A 'B 'C 'D 'E) EVALUATES TO ((C D E) (A B C)). (THIS IS SIMILAR TO THE CONVENTION WITH HAIPART, IF THAT'S ANY HELP...) FINALLY, IF YOU SAY (ARG NIL) INSIDE AN LSUBR/LEXPR, YOU GET BACK THE NUMBER OF ARGS SUPPLIED TO THAT LSUBR/LEXPR. SPEAKING OF TYPEP, IN NLISP (TYPEP 'FOO) RETURNS THE ATOM "SYMBOL", NOT THE ATOM "PNAME". THIS IS BECAUSE, EVENTUALLY (INDEED, ALREADY, ON MULTICS), ATOMS WILL NOT HAVE PNAME PROPERTIES ON THEIR PROPERTY LISTS, BUT WILL STORE THE PACKED-ASCII CHARACTERS OF THE PRINT-NAME IN A MORE EFFICIENT FASHION. ALSO, IN SOME PAROCHIAL PARTS OF THE LISP WORLD, THERE ARE BELIEVERS WHO BELIEVE THAT EVERY OBJECT "HAS" A PRINT-NAME AND HENCE "PNAME" DOES NOT UNIQUELY IDENTIFY THAT CLASS OF OBJECTS THAT WE HAVE ALL COME TO KNOW AND LOVE SO WELL. IN THE FUTURE, WE WILL TRY TO REFER TO MEMBERS OF THIS CLASS OF OBJECTS AS "SYMBOLS". THE FILE .INFO.;LISP FCNS HAS BEEN CLEANED UP A BIT; IT CONTAINS A TABLE OF ALL CURRENT INITIAL LISP FUNCTIONS, AND TOP-LEVEL GLOBAL VARIABLES. TAKE A LOOK. WRONG-NUMBER-OF-ARGS CHECKING IN NLISP IS SOMEWHAT IMPROVED. (TRY, FOR INSTANCE, (QUOTE A B) AND SEE WHAT YOU GET.) A REMINDER: (FIXP X) IS NON-NIL (EQUAL TO THE ARG) IFF X IS A BIGNUM OR A FIXNUM. FOR A FIXNUM-ONLY TEST, USE (EQ (TYPEP X) 'FIXNUM). SOME LOSERS WANT TO COMPILE FILES WITH ODDBALL NAMES [SUCH AS, NAMES CONTAING , ;, :, _ AND OTHERS]. THESE NAMES MAY BE TYPED AT COMPLR BY QUOTING THE OFFENDING CHARACTERS WITH "/". THE MAKLAP PARSER WILL NOW ACCEPT MULTIPLE INPUT FILE SPECIFICATIONS, SEPARATED BY COMMAS, AND COMPILE ALL AS IF THEY WERE CONCATENATED, LEFT TO RIGHT, IN ONE BIG INPUT FILE; SIMILARLY, FASLAP WILL ASSEMBLE MULTIPLE INPUT FILES INTO ONE FASL FILE. EXAMPLE COMMAND: _TGQ:MOBY LAP_TMQ:DECLAR 2/_1,TLQ:OLD SRC/ / @ COMPLR WILL ALSO PUT A SEMI-COLON COMMENT NEAR THE HEAD OF THE LAP FILE TELLING THE DATE AND TIME OF COMILATION. THESE FEATURES ARE IN EFFECT AS OF COMPLR 338. TUESDAY JULY 10,1973 FQ+3D.0H.44M.22S. - GLS - TRY NLISP! THERE ARE SEVEN NEW FUNCTIONS IN THE LATEST NLISP. THE FIRST IS A NEW STATUS CALL: (STATUS FEATURES) RETURNS A LIST OF FEATURES IMPLEMENTED IN THE LISP. THIS FEATURES LIST IS A LIST OF ATOMIC SYMBOLS WHICH CAN CONVENIENTLY BE MEMQ'ED, PRINTED, OR WHATEVER. CURRENTLY THESE ATOMS MAY APPEAR ON THE FEATURES LIST: BIBOP ;HAIRY PAGING SCHEME (BEING IMPLEMENTED) LAP SORT ;FUZZY SORT FUNCTIONS (SEE BELOW) EDIT FASLOAD ^F ;MOBYIO PACKAGE BIGNUM ML ;THIS LISP IS ON MATHLAB AI ;THIS LISP IS ON AI ITS ;THIS LISP IS ON SOME ITS SYSTEM DEC10 ;THIS LISP IS ON A DECSYSTEM-10 MONITOR (CAR (LAST (STATUS FEATURES))) IS GENERALLY CONSIDERED TO BE AN IMPLEMENTATION NAME; THUS IT WILL BE "ITS" OR "DEC10" (OR MAYBE EVENTUALLY "MULTICS", ON THAT SYSTEM). THIS IS USEFUL FOR PRINTING HEADINGS OR WHATEVER. THE MAIN IDEA BEHIND THIS STATUS CALL IS THAT AN APPLICATION PACKAGE CAN LOAD UP INTO ANY MACLISP IMPLEMENTATION AND DECIDE WHAT TO DO ON THE BASIS OF THE FEATURES IT FINDS AVAILABLE. EXAMPLE: (COND ((MEMQ 'BIGNUM (STATUS FEATURES)) (PROG2 NIL (EVAL (READ)) (READ))) (T (READ) (EVAL (READ)))) (DEFUN FACTORIAL (N) ;BIGNUM VERSION (COND ((ZEROP N) 1) ((TIMES N (FACTORIAL (SUB1 N)))))) (DEFUN FACTORIAL (N) ;FIXNUM-ONLY VERSION (COND ((> N 13.) (BARF 'FACTORIAL/ TOO/ BIG)) ((ZEROP N) 1) ((* N (FACTORIAL (1- N)))))) THREE OF THE NEW FUNCTIONS ARE FOR ARRAY MANIPULATION; THEY ARE INTENDED TO MAKE ARRAYS SOMEWHAT LESS PAINFUL TO USE. THEY ARE: ********** OBSOLETE 7/30/73 ********** * INITARRAY SUBR 2 ARGS * (INITARRAY 'FOO 'GLITCH) INITIALIZES ALL ENTRIES OF THE ARRAY FOO * TO CONTAIN GLITCH. (THIS IS A STORE-TYPE INITIALIZATION, NOT NSTORE; * BUT THE KLUDGY 18-BIT NUMBER ARRAYS WILL DISAPPEAR EVENTUALLY ANYWAY.) * THUS TO ZERO OUT AN ARRAY, SAY (INITARRAY 'FOO NIL). * THERE! NOW ISN'T THAT NICER THAN SAYING (BLTARRAY 'ZEROARRAY 'FOO)? * INITARRAY RETURNS ITS SECOND ARGUMENT. ********** OBSOLETE TO HERE ********** FILLARRAY SUBR 2 ARGS (FILLARRAY ) FILLS THE ARRAY WITH CONSECUTIVE ITEMS FROM THE LIST; THUS (FILLARRAY 'ZTESCH '(A B C)) IS LIKE (PROG NIL (STORE (ZTESCH 0) 'A) (STORE (ZTESCH 1) 'B) (STORE (ZTESCH 2) 'C) (RETURN 'ZTESCH)) IF THE ARRAY IS TOO SHORT TO CONTAIN ALL OF THE ITEMS IN THE LIST, THE EXTRA ITEMS ARE IGNORED. IF THE LIST IS TOO SHORT TO COMPLETELY FILL THE ARRAY, THE EXTRA ARRAY SLOTS ARE FILLED WITH THE LAST ITEM FROM THE LIST. FILLARRAY RETURNS ITS FIRST ARGUMENT AS VALUE. LISTARRAY SUBR 1 ARG (LISTARRAY 'SNARK) CONSES UP ALL ITEMS IN THE S-EXPRESSION ARRAY SNARK, IN ORDER, AND RETURNS THEM AS A LIST. THUS: (ARRAY QUUX T 10) (FILLARRAY 'QUUX '(A B C D E)) (LISTARRAY 'QUUX) RETURNS (A B C D E E E E). THE OTHER THREE FUNCTIONS COMPRISE THE NEW SORTING PACKAGE. FOR ARRAYS, THEY USE THE QUICKSORT METHOD DESCRIBED IN KNUTH (VOL 3, P. 114 FF.) THIS METHOD GIVES THE SORT FUNCTIONS THE FOLLOWING PROPERTIES: [1] THE SORT IS GUARANTEED TO TERMINATE, NO MATTER WHAT PREDICATE IS USED FOR SORTING (SEE BELOW.) THAT IS, GIVING SORT THE WRONG FUNCTION WON'T CAUSE IT TO HANG OR LOOP. [2] THE SORT IS **NOT** STABLE. EQUAL KEYS WILL NOT STAY IN THEIR ORIGINAL ORDER; IN FACT, EQUAL KEYS WILL BE ORDERED RANDOMLY (SINCE THE ALGORITHM USES A RANDOM NUMBER GENERATOR TO FEND OFF CERTAIN WORST CASES.) [3] THE SORT IS, ON THE AVERAGE, ON THE ORDER OF N LOG N IN SPEED. PRELIMINARY TIMING TESTS SHOW THAT 2500. ATOMIC SYMBOLS WERE SORTED ALPHABETICALLY IN 10. SECONDS OR RUNTIME, AND 10000. ATOMS IN 40. SECONDS OF RUNTIME. FOR LISTS, THE METHOD USED IS THE MERGE SORT [KNUTH, VOL. 3, PP. X] THE ARGUMENT LIST IS REARRANGED WITH RPLACD, AND A SORTED LIST IS RETURNED; THUS TO SORT A LIST CURRENTLY THE VALUE OF THE VARIABLE L, AND MAKE THE SORTED LIST THE NEW VALUE OF L, DO (SETQ L (SORT L 'PRED)) THE FUNCTIONS ARE INDIVIDUALLY DESCRIBED BELOW: SORT SUBR 2 ARGS THE FIRST ARGUMENT TO SORT IS AN S-EXPRESSION ARRAY OR A LIST, THE SECOND A PREDICATE OF TWO ARGUMENTS. THE DOMAIN OF THE PREDICATE SHOULD INCLUDE ALL THE ITEMS IN THE LIST OR ARRAY TO BE SORTED. THE PREDICATE SHOULD BE A LISP FUNCTION OF TWO ARGUMENTS WHICH DEFINES A WELL-ORDERING OVER ITS DOMAIN, AND HAS THE SENSE THAT THE FIRST ARGUMENT "PRECEEDS" THE SECOND WHEN THE PREDICATE IS TRUE, AND THE SECOND "PRECEEDS" THE FIRST WHEN FALSE. NOTE THAT SINCE SORTING REQUIRES MANY COMPARISONS, AND THUS MANY CALLS TO THE PREDICATE, SORTING WILL BE MUCH FASTER IF THE PREDICATE IS A COMPILED FUNCTION RATHER THAN INTERPRETED. SORT, LIKE THE MAP SERIES OF FUNCTIONS, WILL TRY TO ESTABLISH A DIRECT MACHINE-INSTRUCTION SUBROUTINE LINK TO THE FUNCTIONAL ARGUMENT WHENEVER THAT IS POSSIBLE. EXAMPLE: (DEFUN MOSTCAR (X) (COND ((ATOM X) X) ((MOSTCAR (CAR X))))) (SORT FOOARRAY (FUNCTION (LAMBDA (X Y) (ALPHALESSP (MOSTCAR X) (MOSTCAR Y))))) IF FOOARRAY CONTAINED THESE ITEMS BEFORE THE SORT: (TOKENS (THE LION SLEEPS TONIGHT)) (CARPENTERS (CLOSE TO YOU)) ((ROLLING STONES) (BROWN SUGAR)) ((BEACH BOYS) (I GET AROUND)) (BEATLES (I WANT TO HOLD YOUR HAND)) THEN AFTER THE SORT FOOARRAY WOULD CONTAIN: ((BEACH BOYS) (I GET AROUND)) (BEATLES (I WANT TO HOLD YOUR HAND)) (CARPENTERS (CLOSE TO YOU)) ((ROLLING STONES) (BROWN SUGAR)) (TOKENS (THE LION SLEEPS TONIGHT)) SORTCAR SUBR 2 ARGS SORTCAR IS EXACTLY LIKE SORT, BUT THE ITEMS TO BE SORTED SHOULD ALL BE NON-ATOMIC. SORTCAR TAKES THE CAR OF EACH ITEM BEFORE HANDING TWO ITEMS TO THE PREDICATE. THUS SORTCAR IS TO SORT AS MAPCAR IS TO MAPLIST. 7/8/73 - JONL - TRY NLISP! POSSIBLE DIFFICULTIES: 1) EQ WILL NOT BE GUARANTEED TO WORK ON SMALL FIXNUMS. ONE SHOULD USE = OR EQUAL AS APPROPRIATE. 2) ZEROP MUST BE COMPILED DIFFERENTLY FOR NLISP THAN FOR LISP. THUS IF YOUR CODE HAS ANY ZEROP'S IN IT, YOU WILL HAVE TO RECOMPILE EITHER WITH SYS:TS XCOMPLR, WHICH IS A NORMAL COMPLR SET UP TO COMPILE ZEROP FOR NLISP, OR WITH SYS:TS NCOMPLR, WHICH IS THE SUPER-DUPER-WINNING COMPILER THAT HAS BEAT OUT FORTRAN ON REASONABLE NUMERICAL PROGRAMS. ERIC ROSEN, WHO IS IN T.S. 834 FOR THE REMAINDER OF THE SUMMER, WILL BE ABLE TO HELP YOU WITH THE DECLARATIONS TO NECESSARY TO GIVE YOU AS MUCH OPEN-CODED REAL, LIVE ARITHMETIC AS IS POSSIBLE IN A LISP PROGRAM. 3) THUS MANY PROGRAMS WILL BE LISP-NLISP COMPATIBLE, OR CAN BE MADE SO BY THE REPLACEMENT OF (ZEROP X) WITH (= X 0), AND THE CAREFUL REMOVAL OF ANY USE OF EQ ON NUMBERS. AS OF THIS DATE, COM:LAP FASL, COM:GRIND FASL, AND COM:INDEX FASL ARE SO COMPATIBLE. HOPEFULLY, THERE WILL BE A COMPATIBLE CNVR FORTHCOMING. THE COMPATIBLE INDEXER, HOWEVER, WILL PROPERLY INDEX CNVR CODE WHEN CNPARSE IS SET TO NON-NIL. 4) JONL WILL BE ON VACATION FROM TUESDAY, JULY 10, UNTIL SUNDAY, JULY 22. HOPEFULLY, GUY STEELE [GLS] WILL BE ABLE TO HELP ALL YOU LISP LOSERS OUT THERE OVERCOME THE UNEXPECTED "FEATURES". AT ANY RATE, DONT HESITATE TO LEAVE MAIL. THE SYSTEM INDEXER, OBTAINABLE BY FASLOADING IN COM:INDEX FASL, NOW HANDLES CNVR FILES APPROPRIATELY. BY SETTING THE VARIABLE CNPARSE TO NON-NIL, YOU MAY INFORM THE INDEXER THAT A CNVR FILE IS COMING, AND THAT IT SHOULD OBEY THE CNVR READ MACROS. THE VALUE OF THE VARIABLE EDIT IS NOW (AS OF LISP 486) A LIST OF FLAGS THAT THE IN-CORE EDITOR WILL USE WHEN SEARCHING FOR A FUNCTION DEFINITION. THUS TO EDIT CNVR FUNCTIONS, ONE MAY WANT TO DO (SETQ EDIT (CONS 'CEXPR EDIT)) THE VALUE OF THE VARIABLE  IS THE BACK-UP CHAIN FOR THE EDITOR, THE CAR OF WHICH WILL BE POINTING TO THE PLACE IN YOUR FUNCTION WHERE THE CURRENT EDIT CURSOR IS. THUS, ONE MAY USE THE EDITOR TO POSITION THE EDIT-CURSOR, AND THEN RUN OTHER PROGRAMS THAT "TAKE IT FROM THERE" THE NEW FUNCTION LISTIFY, A SUBR OF ONE ARGUMENT, MAY BE OF USE TO THOSE WHO USE LEXPRS. IT IS ESSENTIALLY A FAST, HAND-CODED VERSION OF THE FOLLOWING EXPR: (DEFUN LISTIFY (N) (COND ((ZEROP N) NIL) ((DO ((I 1 (1+ I)) (L NIL)) ((> I N) (REVERSE L)) (SETQ L (CONS (ARG I) L)))))) IN SHORT, IT MAY BE USED TO QUICKLY UNSTACK THE ARGUMENTS TO AN LEXPR, AND CONS THEM UP INTO A LIST. ********** HAS BEEN EXTENDED - SEE NOTE OF 7/30/73 ********** (STATUS LINEL . . .) AND (STATUS CHRCT . . .) HAVE BEEN FLUSHED, SINCE THIS IS NOT THE WAY THEY WILL BE USED IN THE NEW MULTIPLEL I/O CHANNEL SCHEME. THIS HIGHLY DESIRABLE FEATURE, WHICH IS PARTIALLY IMPLEMENTED, MIGHT BE FINISHED IF AND WHEN STAVROS EVER COMES BACK FROM GREECE. THEN AGAIN, IT MIGHT NOT. BOTH MIDAS AND MACLISP ARE NOW AVAILABLE FOR USE ON A DEC SYSTEM-10 TIME-SHARING MONITOR [AND CONSEQUENTLY, FOR USE UNDER A TENEX MONITOR] FOR MORE INFORMATION, LEAVE MAIL FOR JONL. 5/22/73 - JONL - A NEW LSUBR, ERROR, OF 0, 1, 2, OR 3 ARGS IS NOW AVAILABLE TO ALLOW THE USER TO ENTER THE LISP ERROR SYSTEM. THE FIRST ARG, IF PRESENT, IS TAKEN TO BE A MESSAGE, AND IS PRINC'D JUST LIKE THE MESSAGES THAT ARE PRINTED OUT WHEN AN ERROR IS DETECTED BY THE LISP SYSTEM. THE SECOND ARG, IF PRESENT, IS CONSIDERED TO BE AN OFFENDING PIECE OF DATUM WHICH IS PRINTED JUST BEFORE THE MESSAGE. THE THIRD ARG, IF PRESENT, IS TAKEN TO BE AN LISP ERROR INTERRUPT NUMBER, OR THE ATOM WHOSE VALUE HOLDS THAT INTERRUPT FUNCTION; AND THE CORRESPONDING CORRECTABLE-ERROR INTERRUPT FUNCTION IS CALLED. IN THIS LAST CASE, THE SECOND ARG TO ERROR IS PASSED ALONG AS THE ARGUMENT TO THE INTERRUPT FUNCTION [THE USUAL PROTOCOL FOR CORRECTING AN ERROR APPLIES, SEE PRIOR DISCUSSION IN THIS FILE], AND THE CORRECTED RETURN-VALUE IS THE VALUE OF ERROR. IF THERE IS NO THIRD ARGUMENT, THEN AN ORDINARY BOMB-OUT UNCORRECTABLE LISP ERROR IS PERFORMED. FOR EXAMPLE, SUPPOSE ONE WANTS TO CAUSE A WRNG-TYPE-ARG ERROR WHEN AN ATOM ATOM PASSED TO "GOODP" IS EITHER UNBOUND (IN THE LISP SENSE) OR ELSE HAS THE VALUE "MUNBOUND": (DEFUN GOODP (X) (COND ((OR (NOT (EQ (TYPEP X) 'PNAME)) (NOT (BOUNDP X)) (EQ (EVAL X) 'MUNBOUND)) (ERROR 'ATOM-WITH-RANDOM-VALUE X 7)) (T X))) BRIEF REVIEW ERROR INTERRUPT FUNCTION NUMBERS, AND GLOBAL VARIABLE WHOSE VALUE HOLDS THE INTERRUPT FUNCTION: ERROR CHANNEL # USER INTERRUPT # GLOBAL VARIABLE 0 5 UNDF-FUNCTION 1 6 UNBND-VRBL 2 7 WRNG-TYPE-ARG 3 8. UNSEEN-GO-TAG 4 9. WRNG-NO-ARGS 5 10. GC-LOSSAGE 6 11. FAIL-ACT NOTE THAT (ERROR) EVAL'S THE SAME AS (ERR), AND IN THE EXAMPLE ABOVE, ONE COULD ALSO HAVE WRITTEN (ERROR 'ATOM-WITH-RANDOM-VALUE X 'WNRG-TYPE-ARG) CURSORPOS HAS BEEN MADE AN LSUBR - WITH NO ARGUMENTS IT RETURNS THE POSITION OF THE DISPLAY CURSOR AS A DOTTED PAIR (LINENO . COLUMNO), WHERE LINE NUMBER 0 IS THE TOP LINE OF THE SCREEN, AND COLUMN NUMBER 0 IS THE LEFTMOST [FOR NON-DISPLAY CONSOLES, CURSORPOS ALWAYS RETURNS NIL]. WITH TWO ARGUMENTS, (CURSORPOS X Y) MOVES THE DISPLAY CURSOR TO THE XTH LINE, YTH COLUMN, AND THEN RETURNS T [AGAIN, RETURNS NIL FOR NON-DISPLAY CONSOLES]. A NEW SUBR OF THREE ARGUMENTS, SETSYNTAX, IS IMPLEMENTED TO FACILITATE CERTAIN READTABLE SYNTAX HACKING. THE ARGUMENTS ARE 1) EITHER A FIXNUM LESS THAN 128., OR A SINGLE CHARACTER, WHICH SPECIFIES THE ENTRY OF THE READTABLE TO BE HACKED; 2) ONE OF 2A) NIL, MEANING NO ACTION ON THE CHAR'S SYNTAX, 2B) A FIXNUM, WHICH IS THE NEW SYNTAX CATEGORY FOR THE FIRST ARG, 2C) A SINGLE-CHARACTER ATOM, MEANING NEW SYNTAX FOR FIRST ARG TO BE SAME AS THE INITIAL, SYSTEM-SET SYNTAX FOR THIS CHAR, 2D) THE ATOM "MACRO", MEANING ELEMENTAL READ-MACRO SYNTAX, AND IMPLYING THAT THE THIRD ARG IS THE MACRO FUNCTION, 2E) THE ATOM "SPLICING", MEANING SPLICING READ-MACRO; 3) ONE OF 3A) NIL, MEANING NO ACTION ON CHTRAN OF FIRST ARG, OR ELSE, IF SECOND ARG IS OPTION 2D OR 2E, THEN MEANING IS TO TURN OFF THE READ-MACRO, RESTORING THE SYNTAX AND CHTRAN TO THE INITIAL SYSTEM VALUE FOR THAT CHAR, 3B) A FIXNUM, MEANING THE ASCII INPUT TRANSLATION FOR THE FIRST ARG, 3C) A SINGLE CHARACTER ATOM, MEANING TRANSLATE TO ASCII VALUE OF THAT CHARACTER, 3D) A FUNCTION, WHICH IS THE MACRO FUNCTION REQUIRED BY OPTIONS 2D AND 2E. SETSYNTAX ALWAYS RETURNS T. TWO NEW STATUS CALLS: (STATUS UDIR) RETURNS AN ATOM WHOSE PNAME IS THE SAME AS THE INITIAL WORKING DIRECTORY OF THE USER LOGGED IN. ON THE PDP10 SYSTEM, THIS WILL ALWAYS BE THE SAME AS (STATUS UNAME), BUT ON THE MULTICS SYSTEM, THESE TWO ARE DIFFERENT. (STATUS HACTRN) RETURNS NON-NIL IF AND ONLY IF THE LISP IS AN INFERIOR JOB TO A HACTRN. THIS WILL ALLOW A LISP IN A DISOWNED TREE TO CONTINUE INTERACTION WITH A HACTRN ABOVE IT, TYPICALLY FOR THE PURPOSE OF ADDING TO, OR INSPECTING ITS JOB SYMBOL TABLE. ALSO, ONE MIGHT TEST THIS BEFORE VALRET'ING A STRING. NEEDLESS TO SAY, THIS CALL IS IMPLEMENTED ONLY IN THE ITS PDP10 VERSION. 5/9/73 - JONL - ERRORS GENERATED BY THE DISPLAY SLAVE ARE NOW CORRECTABLE, FAIL-ACT TYPE. REMINDER: IF THE FAIL-ACT INTERRUPT HANDLER RETURNS A NON-NULL LIST, THEN THE CAR OF THAT LIST IS EVAL'D AND THE RESULTANT RETURNED AS THE VALUE OF THE FORM WHICH LOST; THE SYSTEM-SUPPLIED FAIL-ACT HANDLER IS A BREAK LOOP, AND IF ONE DESIRES TO PROCEED (ACCEPTING AN OUTPUT VALUE OF T) HE CAN TYPE (RETURN '(T)) TYPING P IS THE SAME AS RETURNING NIL, WHICH CAUSES THE ERROR HANDLER TO GO THE ROUTE OF ALL UNCORRECTED ERRORS. THERE IS A MANUAL FOR THE MULTICS VERSION OF MACLISP IN THE PREPARATION. IT MAY PROVE TO BE OF MUCH USE EVEN TO THE PDP10 MACLISP USER. LISP WILL NOW ACCEPT A COMMAND LINE FROM DDT, IN THE FASHION OF THE HACTRN COMMAND LINE. THE SIGNIFICANCE OF THIS LINE FOR LISP IS THAT IT IS USED TO SPECIFY A FILE FOR INITIAL LOADING, JUST AS THE .LISP. (INIT) FILE IS USED. THUS, THE FIRST S-EXPRESSION ON THE FILE MUST BE A COMMENT, WHOSE ALTERNATING PAIRS GIVE ALLOCATION REQUESTS; THE REMAINDER OF THE FILE MAY BE ANY S-EXPRESSIONS. FOR EXAMPLE, IF ONE HAS A FILE "INDEX LOADER" ON HIS DIRECTORY WHICH CONTAINS (COMMENT CORE 70 FXS 5000 FLPDL 1) (FASLOAD INDEX FASL COM) THEN WHEN HE TYPES AT DDT :LISP INDEX LOADER HE WILL FIND HIMSELF WITH A 70-BLOCK LISP (WITH A LITTLE EXTRA FIXNUM SPACE, AND A MINIMAL FLONUM PDL) WHICH HAS BEEN EMBELLISHED WITH THE LISP INDEXER. THE COMMAND LINE IS ALLOWED TO BE ANY ITS FILE SPECIFICATION, WITH DEFAULTING ON THE DEVICE TO BE DSK, AND DEFAULTING ON THE SNAME TO BE THAT SET BY HACTRN. REMINDER: THE FIRST ITEM OF AN ALTERNATING PAIR IN THE COMMENT FOR ALLOC IS SPELLED EXACTLY THE WAY ALLOC SPELLS IT WHEN IT TYPES THE QUESTIONS AT YOU; IF YOU WANT TO TRY IT, JUST TYPE "Y" TO THE QUESTION "ALLOC?" AND NOTE THE KINDS OF SPACES THAT ARE ASKED ABOUT. 4/15/73 -JONL- RUBOUT WHEN TYPED FROM THE JOB CONSOLE AT A DATAPOINT SHOULD DO SOMETHING A LITTLE MORE INTERESTING THESE DAYS. HOWEVER, IT IS NOT POSSIBLE TO DO THINGS CORRECTLY WHEN TYPE-IN ECHO IS INTERMINGLED WITH PROGRAM TYPE-OUT, SO IF YOU GET CONFUSED, TRY ^K AND ^L. THE LSUBRS "-", "-$", "/", AND "/$" NOW OPERATE IN ACCORD WITH THE COMMON USAGE WHEN GIVEN ONE ARGUMENT: NAMELY, THE OPERATION IS PERFORMED WITH THE OPERATOR IDENTITY AND THE SINGLE ARG. THIS NEW DEFINITION HAS NO EFFECT FOR THE COMMUTATIVE OPERATORS, BUT ALLOWS ONE TO WRITE (- N) INSTEAD OF (MINUS N) AND TO WRITE (//$ X) INSTEAD OF (QUOTIENT 1.0 X). ALTHOUGH THIS VARIES SLIGHTLY FROM THE SIMPLER DEFINITION FORMAT, IT SEEMS TO BE PREFERRED BY MOST PROGRAMMERS. A NEW SUBR OF NO ARGUMENTS - CURSORPOS - WILL RETURN A DOTTED PAIR FOR THE COLUMN POSITION AND ROW POSITION OF THE CURSOR AT A DISPLAY TERMINAL. RETURNS NIL FOR OTHER TERMINALS. TWO NEW BIT-DIDDLING FUNCTIONS - HAULONG, A SUBR OF ONE ARGUMENT, AND HAIPART, A SUBR OF TWO ARGUMENTS. (HAULONG X) EXPECTS X TO BE EITHER A FIXNUM OR BIGNUM, AND, IN INFORMAL LANGUAGE, RETURNS THE NUMBER OF BITS IN X. MORE PRECISELY, IT IS +1 INFORMALLY, (HAIPART X N) RETURNS A NUMBER WHICH IS COMPOSED OF THE HIGH N BITS OF X. TO DESCRIBE HAIPART MORE PRECISELY, LET (Z X N) = (EXPT 2 (- (HAULONG X) N)) FOR N < (HAULONG X), = 1 OTHERWISE. THEN (HAIPART X N) = (QUOTIENT (ABS X) (Z X N)) FOR N > 0, = (REMAINDER (ABS X) (EXPT 2 (ABS N))) OTHERWISE. THUS, A NEGATIVE SECOND ARG RETRIEVES THE "LOWPART" OF X. A NEW STATUS CALL - (SSTATUS TTYREAD T) CAUSES THE TELETYPE INPUT BUFFERING THAT GOES ON FOR READ TO TERMINATE ONLY WHEN A "TTY-FORCE-FEED" CHARACTER HAS BEEN TYPED. A TTY-FORCE-FEED CHAR IS CREATED BY OR'ING 1040 (OCTAL) INTO THE CHARACTER'S SYNTAX CATEGORY. WHEN (STATUS TTYREAD) = NIL, THEN TYPING RUBOUT MORE TIMES THAN THERE ARE CHARS IN THE TTY INPUT BUFFER WILL CAUSE AN END-OF-FILE CONDITION. THIS IS SO THAT USER-SUPPORTED READ ROUTINES CAN DO THEIR OWN SUBTLE THING WITH RUBOUT. ALLOC - JUST A SHORT REVIEW OF THE ANSWERS YOU CAN TYPE AT THE INITIAL QUESTION "ALLOC?": Y, y[LOWER CASE Y], OR ^S[CONTROL-S] CAUSES ENTRY INTO THE ALLOCATION REQUEST PHASE, WHEREBY THE USER REPLIES BY TYPING NUMERICAL VALUES TO THE VARIOUS ALLOCATOR QUESTIONS; AND N, n[LOWER CASE N], OR SPACE CAUSES THE STANDARD DEFAULT ALLOTMENT FOR ALL AREAS TO BE TAKEN. THE STANDARD DEFAULTS ARE PRINTED OUT DURING THE ALLOCATION REQUEST PHASE, AND THE USER MAY TYPE SPACE OR CARRIAGE-RETURN TO ACCEPT THE DEFAULT, OR ELSE A STRING OF DIGITS FOLLOWED BY SPACE OR CARRIAGE-RETURN [MEANING AN OCTAL NUMBER], OR ELSE A STRING OF DIGITS FOLLOWED BY A DECIMAL-POINT [MEANING A DECIMAL NUMBER]. TYPING RUBOUT DURING THE ALLOCATION REQUEST PHASE CANCELS THE NOT-YET-COMPLETED ANSWER TO THE MOST RECENT QUESTION, AND THE ANSWER MAY BE RETYPED. TYPING ALT-MODE CAUSES THE REMAINING QUESTIONS TO TAKE THE STANDARD ALLOTMENT, AND TYPING ^G[CONTROL-G] CAUSES THE ALLOC PHASE TO RESTART ALL OVER AGAIN WITH THE QUESTION "ALLOC?". ^S, IN ADDITION, CAUSES THE USERS .LISP. (INIIT) FILE TO BE SELECTED RIGHT AFTER ALLOC'ING. TYPING ^Q OR ^W AT THE "ALLOC?" QUESTION IMMEDIATELY SELECTS THE .LISP. (INIT) FILE, AND TAKES ALLOCATION REQUESTS FROM IT BEFORE READING IT IN. FOR THIS PURPOSE, THE FIRST EXPRESSION ON THE FILE MUST BE A LIST OF THE FORM (COMMENT S1 V1 S2 V2 . . . SN VN). EACH S[I] IS ONE OF CORE, FXS, FLS, REGPDL, SPECPDL, FXPDL, FLPDL OR BPS; AND THE ASSOCIATED V[I] IS THE NUMERICAL VALUE INTENDED FOR THAT SPACE. ANY SPACE NOT SPECIFIED BY THE COMMENT LIST IS ALLOTED THE STANDARD DEFAULT. COMPLR SWITCHES - FOLLOWING IS A BRIEF TABLE OF THE SWITCHES THAT ONE MAY SET WHEN REQUESTING COMPILATION OF A FILE VIA MAKLAP. EACH SWITCH SETS THE VALUE OF A GLOBAL VARIABLE TO T, AND THE CORRESPONDING SWITCH PRECEEDED BY A MINUS SIGN SETS THE VARIABLE TO NIL. ALL SWITCH VARIABLES ARE INITIALLY NIL. SWITCHES MAY BE SET EITHER BY DECLARATIONS IN THE USERS SOURCE FILE, OR BY ENCLOSING THE SWITCH LETTERS IN PARENTHESES IN THE MAKLAP COMMAND LINE, E.G. "FOO LAP_FOO >(ZN-T)" SWITCH VARIABLE BRIEF MEANING A ASSEMBLE ONLY DO THE ASSEMBLY PHASE ON THE FILE D DISOWNED DISOWN THE COMPLR AFTER STARTING F FASL PRODUCE A FASL FILE BY COMPILING THE INPUT INTO LAP, AND THEN ASEMBLING THE LAP [OR INTERMEDIATE] FILE. K NOLAP KILL THE INTERMEDIATE LAP FILE M MACROS OUTPUT MACRO DEFINITIONS INTO THE LAP FILE N NOARGS DONT OUTPUT ARGS INFORMATION FOR COMPILED ROUTINES S SPECIAL AUTO-DECLARE ALL VARIABLES TO BE SPECIAL T TTYNOTES PUT A NOTE ON JOB CONSOLE AT END OF COMPILING EACH FUNCTION, AND/OR AT END OF ASSEMBLING EACH FUNCTION. U UNFASLCOMMENTS PRODUCE A FILE OF COMMENTS ABOUT THE FASL ASSEMBLY [2ND FNAME IS UNFASL]. X MAPEX EXPAND ALL MAP CALLS INTO DOS. TAKES A LITTLE MORE CODE, BUT CODE THEN RUNS A LITTLE FASTER. Z SYMBOLS CAUSE SUBROUTINE SYMBOL DEFINITIONS TO BE ADDED TO JOB SYMBOL TABLE AT LOAD TIME. JONL 3/22/73 1) THE CONTROL CHARACTERS ^P AND ^U NO LONGER ARE RELEVANT TO THE INTERPRETIVE PLOTTER: ^P IS NOT USED, AND ^U IS NOW USED FOR THE PAGEPAUSER DESCRIBED BELOW. THE PLOTTER MAY BE CLOSED AND RELEASED BY EXECUTING (PLOT 0), AND ANY OTHER PLOTTER REQUEST WILL SIEZE AND OPEN UP THE PLOTTER OF IT IS NOT ALREADY OPEN. 2) (SSTATUS PAGEPAUSE T) WILL TURN ON AN INTERESTING MODE FOR LISP USERS LOGGED IN FROM DISPLAY CONSOLES. NIL INSTEAD OF T REVERTS TO THE STANDARD MODE. (STATUS PAGEPAUSE) INTERROGATES THE FLAG. (STATUS SYSTEM X) ASSUMES THAT X IS AN ATOM, AND RETURNS A LIST OF PROPERTIES [EXCEPT PNAME] THAT ARE ON THE ATOM AT LISP LOAD TIME. THUS, SINCE "ALARMCLOCK" IS A SYSTEM SUBR, AND ALSO A TOP-LEVEL GLOBAL VARIABLE: (STATUS SYSTEM 'ALARMCLOCK) = (VALUE SUBR) 3) THREE NEW FUNCTIONS. IN THE FOLLOWING, LET X AND Y BE PNAME-TYPE ATOMS, AND N BE A FIXNUM: (ALPHALESSP X Y) RETURNS T IF X PRECEEDS Y IN THE ASCII LEXICAL ORDERING. NIL OTHERWISE. (GETCHAR X N) RETURNS THE NTH CHARACTER OF THE PNAME OF X. (SAMEPNAMEP X Y) RETURNS T IF X AND Y HAVE THE SAME PNAME [IF (SAMEPNAMEP X Y) = T, AND (EQ X Y) = NIL, THEN X AND Y CAN'T BOTH BE ON A GIVEN OBARRAY]. 4) HASH-CODING. TO FACILITATE HASHCODING SCHEMES FOR S-EXPRESSIONS, THE FUNCTION SXHASH HAS BEEN WRITTEN: (SXHASH FOO) WILL PRODUCE A 35.-BIT SIGNED INTEGER FOR ANY S-EXPRESSION FOO, AND ANY TWO EQUAL EXPRESSIONS WILL SXHASH TO THE SAME NUMBER. IT WOULD BE A VERY GOOD IDEA FOR USERS WHO WANT TO WRITE THEIR OWN HASHING FUNCTIONS TO DEFINE THEM IN TERMS OF THE RESULTS FROM SXHASH, AND DEFINITELY NOT IN TERMS OF THE "POINTER" FOR THE S-EXPRESSION. FOR EXAMPLE, TO HAVE A TABLE OF S-EXPRESSIONS ONE COULD WRITE: (DEFUN KNOWNP (X) (PROG (I BKT) (SETQ I (PLUS 76 (REMAINDER (SXHASH X) 77))) ;THE REMAINDER SHOULD BE REASONABLY RANDOMIZED BETWEEN ;-76 AND 76, THUS TABLE SIZE MUST BE > 175 (SETQ BKT (TABLE I)) ;BKT IS THUS A LIST OF ALL THOSE EXPRESSIONS THAT HASH ;INTO THE SAME NUMBER AS DOES X (RETURN (MEMQ X BKT)))) TO WRITE AN "INTERN" FOR SEXPRESSIONS, ONE COULD THUS DO (DEFUN SINTERN (X) (PROG (BKT I TEM) (SETQ BKT (TABLE (SETQ I (+ 2N-2 (\ (SXHASH X) 2N-1))))) ;2N-1 AND 2N-1 STAND FOR A POWER OF 2 MINUS ONE AND ;MINUS TWO RESPECTIVELY. THIS IS A GOOD CHOICE TO ;RANDOMIZE THE RESULT OF THE REMAINDER OPERATION (RETURN (COND ((SETQ TEM (MEMBER X BKT)) (CAR TEM)) (T (STORE (TABLE I) (CONS X BKT)) X))))) SEVERAL INCARNATIONS OF LISP FOLLOW THE "RELOCATING" GARBAGE- COLLECTOR STRATEGY, AND IN THESE LISPS THE ADDRESS, OR "POINTER" FOR A GIVEN S-EXPRESSION WILL CHANGE AFTER A GC. THUS TRYING TO REWRITE KNOWNP AS (DEFUN KNOWNP (X) (PROG (I II) (SETQ II (SETQ I (\ (MAKNUM X) 2N-1))) A (COND ((EQ (TABLE I) X) (RETURN T)) ((< (SETQ I (1+ I)) 2N-1) (GO A))) (SETQ I -1) B (COND ((NOT (< (SETQ I (1+ I)) II)) (RETURN NIL)) ((EQ (TABLE I) X) (RETURN T)) (T (GO B))))) WILL SURELY LEAD TO MUCH GRIEF. 5) IT HAS COME TO MY ATTENTION THAT MANY PERSONS ARE USING THE ERRLIST AS A MEANS FOR REDEFINING THE TOP LEVEL FUNCTION. ONE MUST BE CAREFUL TO PLACE ERRSETS AROUND ANY COMPUTATIONS ON THE ERRLIST THAT MIGHT CONCEIVABLY LEAD TO BOMB-OUT ERRORS, FOR OTHERWISE, THE LISP MAY GET INTO AN INFINITE LOOP OF ERRORS. TO ENCOURAGE THE USE OF THE MACLISP TOPLEVEL FEATURE, THE TOPLEVEL FUNCTION HAS BEEN SLIGHTLY REVISED AS FOLLOWS: (PROG () B (ERRSET (PROG () (SETQ ^R NIL) ;IN ADDITION, MANY OTHER INTERNAL ;VARIABLES ARE RESET TO TOP LEVEL ;SETTINGS, INCLUDING PDL POINTERS, ;FLAGS ETC. (MAPC 'EVAL ERRLIST) (SETQ * '*) A (SETQ * (COND ((STATUS TOPLEVEL) (EVAL (STATUS TOPLEVEL))) (T (PRINT *) ;CYCLING THRU THE LOOP (TERPRI) ;IS ESSENTIALLY PRINT (EVAL (READ))))) ;OF EVAL OF READ (GO A))) (GO B)) ;IF ERROR OCCURS, RESTART AT B INSTEAD OF A 7) SETTING THE VALUE OF THE VARIABLE "SPECIAL" TO NON-NIL IN THE COMPLR WILL CAUSE EVERY VARIABLE TO BE AUTOMATICALLY DECLARED SPECIAL. THIS WILL TAKE THE HEAT OFF THE POOR LOSER WHO TRIES TO COMPILE SOMEONE ELSE'S PROGRAM WITHOUT ACTUALLY UNDERSTANDING THE OTHER'S PROGRAM. HOWEVER, IT SHOULD BE NOTED THAT SOME REPRESENTATIVE, SAMPLE LISP PROGRAMS HAVE BEEN OBSERVED TO REQUIRE 40% MORE RUNNING TIME IF COMPILED FOR ALL VARIABLES BEING SPECIAL THAN IF COMPILED WITH JUDICIOUS USE OF SPECIALIZATION. 8) (TYIPEEK T) HAS BEEN SLIGHTLY EXTENDED SO THAT ANY SPLICING MACRO CHARACTERS OCCURING AT TOP-LEVEL READ WILL BE EXECUTED, AND THEN TYIPEEK SCANNING CONTINUED. THIS IS TO ALLOW MACROS LIKE SEMI-COLON TO DISPOSE OF THEIR COMMENT CHARACTERS, AND IS FAIL-SAFE FOR READ, SINCE READ WOULD ONLY DO THE SAME THING [IE, EXECUTE THE SPLICING MACRO FUNCTION, AND TOSS OUT THE RESULT.] GLS 2/17/73 THE NEW FASLOAD "XCT HACK" SEEMS TO BE WORKING WELL NOW. (THIS IS THE HACK WHEREBY CODE TO BE PURIFIED HAS ITS CALLS AND JCALLS REPLACED BY XCTS WHICH POINT TO THE CALLS, WHICH ARE ALL COLLECTED INTO A FEW "IMPURABLE" PAGES.) IT WORKS AS FOLLOWS: WHEN FASLOAD IS INVOKED, IT INSPECTS THE VARIABLE "PURE". IF IT IS NIL OR UNBOUND A SIMPLE LOAD IS PERFORMED. IF IT IS A NON-NIL NON-FIXNUM, A NORMAL PURE LOAD IS DONE (ATTEMPTS TO REPLACE CALLS WITH PUSHJ'S, ETC). IF IT IS A FIXNUM (AND IT MUST BE BETWEEN 1 AND 8) THEN ONE OF TWO THINGS HAPPEN: [1] IF THIS IS THE FIRST TIME FASLOAD HAS NOTICED PURE BEING A FIXNUM, IT DOES A PAGEBPORG AND THEN GRABS TWO CHUNKS OF BINARY PROGRAM SPACE, EACH PAGES IN LENGTH. THE FIRST IS CALLED "XCT AREA 1" AND THE SECOND (SURPRISE!) "XCT AREA 2". THESE TWO AREAS ARE HENCEFORTH, ON THIS AND AND SUBSEQUENT FASLOADS, USED FOR THE XCT HACKERY. [2] IF THESE XCT AREAS HAVE ALREADY BEEN SET UP, THEN FASLOAD USES THEM FOR XCT HACKERY. AS CALLS ARE READ IN, FASLOAD SEARCHES AREA 2 FOR A MATCHING CALL (USING A HASH SCHEME). IF NONE IS FOUND, THE CALL IS ADDED TO BOTH AREAS (UNLESS THEY ARE FULL) AND INSTEAD OF LOADING A CALL INTO BINARY PROGRAM SPACE AN XCT POINTING TO THE CALL IN AREA 1 IS USED. IF A MATCHING CALL IS FOUND, AN XCT POINTING TO IT IS USED; THUS MANY XCTS MAY SHARE THE SAME CALL. IF FOR ANY REASON FASLOAD CAN'T CREATE AN XCT FOR THE CALL (AREA 2 HAS BEEN PURIFIED (SEE BELOW), AREAS ARE FULL) THEN A NORMAL PURIFICATION ON THE CALL IS DONE (AS IF PURE=T FOR THAT CALL). NOW IT IS INTENDED THAT EVENTUALLY AREA 2 WILL BE PURIFIED, AND AREA 1 LEFT IMPURE. THIS MEANS THAT IF NOUUO=NIL THE CALLS IN AREA 1 WILL EVENTUALLY BE SMASHED TO PUSHJ'S AND JRST'S, SO THAT THE XCT'S WILL EXECUTE THE PUSHJ'S ETC. (IF NOUUO=T, THEN THE EXPECTED THINGS HAPPEN, OF COURSE.) AREA 2 IS USED IN CASE IT IS DESIRED TO RESTORE AREA 1. (SEE XCTBLT BELOW.) THE FUNCTION "PURIFY" HAS BEEN ALTERED SO THAT IF AREA 2 IS EVER PURIFIED (ACTUALLY, IF THE FIRST PAGE OF THAT AREA IS PURIFIED), THEN A SWITCH IS PERMANENTLY SET SO THAT FASLOAD CAN STILL CREATE XCTS POINTING TO CALLS ALREADY IN AREA (ACTUALLY TO PLACES IN AREA 1 CORRESPONDING TO CALLS IN AREA 2; THIS WAY IF SOME CALLS HAVE BEEN CLOBBERED IN AREA 1 FASLOAD CAN STILL FIND THEM), BUT CANNOT PUT NEW CALLS IN THE AREAS (SINCE DOING THIS WOULD BE A MEMORY VIOLATION). ANY ATTEMPT TO PUT A NEW CALL IN THE XCT AREAS IS CONVERTED TO A NORMAL PURIFICATION. IN CASE IT IS DESIRED TO "UNSMASH" THE CALLS IN AREA 1 (E.G. TRACING PURPOSES) THE FUNCTION "XCTBLT" OF NO ARGUMENTS IS PROVIDED. IF NO XCT AREAS EXIST IT RETURNS NIL; OTHERWISE IT BLT'S AREA 2 INTO AREA 1 AND RETURNS T. (THE NAME OF THIS FUNCTION IS VARIOUSLY PRONOUNCED "EXECUTE-BLIT", "KSICT-BLIT", AND (BY STAVROS) "SICK-BLIT". THE FIRST AND THIRD ARE TO BE CONSIDERED OFFICIAL; USE THE ONE WHICH SHOWS HOW MUCH YOU LIKE THE FEATURE.) ********* XCTBLT SUPERSEDED BY (SSTATUS UUOLINKS) - 10/15/73 ***** FINALLY, INVOKING (STATUS XCTPG) WILL RETURN SOME INFO ABOUT THE XCT AREAS: IF NONE HAVE BEEN SET UP, IT RETURNS NIL. IF THEY HAVE BEEN SET UP, IT RETURNS A 2-LIST; THE FIRST ITEM IS T/NIL IF AREA 2 HAS/HAS NOT BEEN PURIFIED; THE SECOND IS A COUNT OF HOW MUCH ROOM IS LEFT IN XCT AREA 2 FOR MORE CALLS OR WHATEVER. ******** (STATUS XCTPG) REPLACED BY (STATUS UUOLINKS) - 10/15/73 ***** AN EXAMPLE: (** MEANS TYPED BY LOSER, == BY LISP, ; MEANS COMMENTS) ** (NOUUO NIL) ;NOUUO IS NIL - CAN SMASH CALLS == NIL ** BPORG == 64000 ;BPORG IS 64000 ** (STATUS XCTPG) == NIL ;NO XCT AREAS YET ** (XCTBLT) == NIL ;THEREFORE CAN'T BLT THEM ** (SETQ PURE 2) ;MAKE PURE A FIXNUM TO == 2 ; RESERVE 2 2-PAGE AREAS ** (FASLOAD COUNT FASL DSK GLS) == 74056 ;56-WORD FILE, PLUS 4 PAGES ** (STATUS XCTPG) ;COUNT HAS 10 DIFFERENT CALLS, == (NIL 3770) ; THUS 3770 WORDS ARE FREE ** (PAGEBPORG) == 76000 ** (PURIFY 70000 75777 'BPORG) ;PURIFY COUNT AND XCT == 70000 ; AREA 2 ** (STATUS XCTPG) == (T 3770) ;XCT AREA 2 IS NOW PURE, THUS T ** (COUNT '(A B C)) ;TRY COUNT == ((A . 1) (B . 1) (C . 1) (NIL . 1)) ;OBVIOUSLY IT WORKS ** (TRACE COUNTX) ;TRACE COUNTX (USED BY COUNT) == TRACE 22 LOADING: == DONE == (COUNTX) ** (COUNT '(A B C)) ;BUT CALL TO COUNTX HAS BEEN == ((A . 1) (B . 1) (C . 1) (NIL . 1)) ; SMASHED ** (XCTBLT) ;BLT BACK CALLS == T ;WIN ** (COUNT '(A B C)) ;NOW WE CAN WIN WITH TRACE == [TRACE GARBAGE, ETC.] JONL 2/2/73 FINALLY, THE NEW FASL FORMAT IS IN EFFECT, WITH LISP 229CW. IT IS AN EXTENDED FORMAT THAT REMOVES THE DIFFICULTIES SOME USERS HAVE HAD WITH RANDOM EVALUATIONS IN THE FASL FILE REFERENCEING THE FUNCTIONS DEFINED IN THE FILE. ALSO, IT ALLOWS VIRTUAL SYMBOL DEFINITIONS AT LOAD TIME SO THAT THERE WILL BE NO MORE ANNOYING PHASE DIFFERENCES IN ASSEMBLING AND LOADING HAND CODED LAP THE NEW FUNCTION ODDP EXISTS. IT REQUIRES A FIXNUM OR BIGNUM AS INPUT, AND ITS ACTION SHOULD BE SELF EXPLANATORY. MANY LOSERS HAVE FORGOTTEN THE WONDERFUL LSUBR BOOLE: ITS FIRST ARG IS A FIXNUM BETWEEN 0 AND 17 WHICH SELECTS ONE OF THE 16. BOOLEAN FUNCTIONS OF TWO BINARY VARIABLES. THIS FUNCTION IS THEN APPLIED SUCCESSIVELY TO THE 36.-BIT VALUES OF THE REMAINING ARGS. THE SELECTED FUNCTION MAY BEST BE DESCRIBED BY A GENERALIZED EXAMPLE. SUPPOSE THE CALL IS (BOOLE N X Y) AND THE BINARY REPRESENTATION OF N IS ABCD [A,B,C,D ARE ALL BINARY DIGITS] THEN THE TABLE FOR THE FUNCTION CORRESPONDING TO N IS: ! Y ! 0 1 ---------- X 0 ! A C 1 ! B D FROM THIS IT IS EASY TO SEE THAT THE "AND" FUNCTION IS DESIGNATED BY 1, "XOR" BY 6, "OR" BY 7, AND THE COMPLEMENT OF ANY FUNCTION N BY 17-N; THUS "NAND" IS 17-1=16, "EQUIV" IS 17-6=11, AND "NOR" IS 17-7=10 [ALL NUMBERS IN OCTAL]. BY "APPLIED SUCCESSIVELY" IS MEANT THAT (BOOLE N X Y Z) IS THE SAME AS (BOOLE N (BOOLE N X Y) Z). A FIXNUM CORRESPONDING TO THE 36.-BIT RESULT IS RETURNED. TYIPEEK IS NOW LSUBR. IF GIVEN AN NUMERICAL ARGUMENT, IT IS INTERPRETED AS FOLLOWS: A) IF < 200 (OCTAL), THEN SCAN CHARS UNTIL ONE IS INPUT THAT MATCHES THE VALUE OF ARG. THE NEXT TYI OR READ WILL THUS ENCOUNTER THAT CHAR. B) IF > 777, THEN IS CONSIDRED TO BE A SYNTAX CATEGORY LSH'D NINE PLACES, AND SCANNING IS TO STOP WHEN A CHAR IS ENCOUNTERED THAT BELONGS TO THAT CATEGORY. C) IF ARG IS NOT NUMERIC, THEN T MEANS ASSUME A NUMERICAL ARGUMENT THAT WILL CAUSE SCANNING TO THE NEXT CHAR WHICH WILL START OUT A READ. SPLICING MACRO CHARS WILL NOT START OUT A TOP-LEVEL READ, AND ARE EXECUTED MERELY TO GIVE THEM A CHANCE TO HAVE ANY APPROPRIATE SIDE-EFFECTS. SINCE SPACES, CONTROL-CHARACTERS, ETC. WON'T START OUT A READ, THESE ARE SKIPPED OVER UNTIL SOME CHARACTER SUCH AS PARENTHESIS, LETTER, DIGIT, DECIMAL-POINT, ETC. IS FOUND. EXAMPLES: (TYIPEEK 15) SCANS UNTIL CARRIAGE-RETURN IS MET (TYIPEEK 4000_9.) SCANS UNTIL MACRO CHAR IS MET (TYIPEEK) AS BEFORE, SIMPLY TAKES NEXT CHAR NEW USER INTERRUPT CONTROL CHARS AVAILABLE: ^\ ^] ^^ (ASCII VALUES 34 35 AND 36) CORRESPOND TO USER INTERRUPTS 14. 15. AND 16. THERE ARE NO GLOBAL VARIABLES CORRESPONING, SO ONE MUST USE SSTATUS TO SET AND CHANGE THESE INTERRUPTS. COMPLR HAS YET TWO MORE SWITCHES TO PUT IN COMMAND LINES; D IS FOR DISOWNED AND I IS FOR INITIALIZE. SPECIFYING D WILL CAUSE COMPLR TO AUTOMATICALLY DISOWN ITSELF AND COMMIT SUICIDE WHEN COMPILATION IS DONE. THIS SWITCH SHOULD BE USED RATHER THAN ANY OTHER METHOD OF DISOWNING SINCE THIS WAY COMPLR WILL KNOW IT IS DISOWNED AND CAN AVOID CERTAIN TYPES OF HACKERY INVOLVING DDT. WHEN COMPLR IS FIRST LOADED THE DEFAULT VALUES OF ALL SWITCHES IS NIL, EXCEPT TTYNOTES (T) AND UNFASLCOMMENTS (U), WHICH ARE INITIALIZED TO T. MORE CONTROLS FROM THE STATUS FUNCTIONS. (SSTATUS TERPRI T) WILL SUPPRESS THE GENERATION OF CARRIAGE RETURNS BY THE TYO FUNCTION [WHICH ARE NORMALLY PRODUCED WHENEVER THERE IS A RUN OF LINEL OR MORE CHARACTERS WITH OUT A CARRIAGE RETURN]. WHEN BASE = 10., (SSTATUS _ T) WILL PERMIT THE USE OF THE PRINT FORMAT XXX_YY WHEN BASE = 8. [THIS FORMAT IS AN ESPECIAL WIN FOR LAP OUTPUT IN BASE EIGHT, BUT IS PROBABLY NOT ACCEPTABLE TO THE NUMBER THEORY HACKER]. IN EACH CASE, THE SUPPRESSION-SWITCH MAY BE INTERROGATED WITH STATUS. INITIAL VALUES ARE NIL FOR TERPRI, AND T FOR _. ALARMCLOCK TWO TYPES OF ALARMCLOCKS ARE AVAILABLE NOW - REAL ELAPSED TIME, AND CPU RUNTIME USED BY JOB IN QUESTION. FIRST ARG SPECIFIES WHICH TIMER TO USE, AND SECOND ARG SPECIFIES INTERVAL TO WAIT, EXCEPT THAT A NEGATIVE SECOND ARG MEAN SHUT OFF THAT TIMER. FIRST ARG = "RUNTIME" => WAIT FOR ELAPSED RUNTIME IN UNITS OF MICROSECONDS; FIRST ARG = "TIME" => WAIT FOR ELAPSED REALTIME IN UNITS OF SECONDS. SECOND ARG MAY BE EITHER FIXED OR FLOATING POINT. VALUE RETURNED IS T IF A TIMER WAS JUST SET, AND NIL IF IT WAS TURNED OFF. THE ARGUMENT TO SLEEP IS NOW IN SECONDS, [MAY BE EITHER FIXED OR FLOATING]; THE RETURN VALUE OF TIME IS A FLOATING POINT NUMBER MEASURED IN SECONDS. TO OBTAIN THE VALUE OF THE ITS SYSTEM COUNTER [IN UNITS OF 1/30.TH OF A SECOND] DO (FIX (*$ (TIME) 30.0), WHICH WILL BE ACCURATE TO THE NEAREST FOUR WEEKS. 11/14/72 - JONL - THE FASLAP-FASLOAD SCHEME SEEMS TO BE WORKING QUITE WELL NOW, AND IS DOCUMENTED BELOW ALONG WITH NEW INSTRUCTIONS FOR USING COMPLR. SEE SECTION 9 BELOW. 0) CERTAIN OPTIONS WITH THE FUNCTIONS STATUS ARE SELDOM USED, BECAUSE THEY EXIST AS INDEPENDENT FUNCTIONS. HENCE THESE OPTIONS HAVE BEEN FLUSHED FROM THE STATUS-SSTATUS SERIES: CRUNIT GCTWA NORET NOUUO *RSET *NOPOINT TIME RUNTIME LISTEN GCMIN 1) SOME NEW FUNCTIONS, THAT MIGHT PROVE USEFUL - A) FASLOAD, A FSUBR, EXPECTS AN ARGUMENT LIKE UREAD, AND RATHER SNAPPILY LOADS IN THE FILE, PROVIDED THAT IT IS AN FASL FILE [THE OUTPUT OF THE FASLAP ASSEMBLER, NOW A STANDARD PART OF COMPLR] B) BOUNDP PRESUMES A PNAME-TYPE ATOM AS ARGUMENT AND RETURNS A POINTER TO ATOM'S VALUE CELL, IF IT HAS A VALUE CELL, AND IF ITS VALUE CONTAINED THEREIN IS NOT THE SPECIAL SYSTEM "UNBOUND" MARKER. OTHERWISE, NIL IS RETURNED. C) MAKUNBOUND INSURES THAT AN ATOM HAS A VALUE CELL, AND THEN SETS THE ATOMS VALUE TO THE INTERNAL UNBOUND MARKER. D) FRETURN ALLOWS YOU TO RETURN FROM AN ARBITRARY EVALFRAME [OBTAINED, OF COURSE, BY THE FUNCTION EVALFRAME]. THUS, WHEN AN ERROR OCCURS, AND THE USER TRACES BACK UP THE PDL EVENTUALLY FINDING SOME EVALUATION THAT HAS A BUG IN IT, HE CAN CALL FRETURN WITH FIRST ARGUMENT THE PDL POINTER FOR THAT FRAME [SEE PRIOR NOTES ON THE USAGE OF FRAMES IN THE LISP ENVIRONMENT] AND WITH SECOND ARG THE DESIRED RETURN VALUE FOR THAT EVALUATION. E) THE NUMERICAL SUBROUTINES FORMERLY FOUND ON JONL;NUMSBR > ARE NOW PART OF THE STANDARD LISP. THE PURE PART OF THE SYSTEM CODE NOW HAS ONE WHOLE PAGE DEVOTED TO NUMERICAL ROUTINES [E.G., PLUS, EXPT, *, ETC]. THE NEW ADDITIONS ARE SQRT, ISQRT, SIN, COS, ATAN, LOG, AND EXP, WHICH ARE ALL FLOATING-POINT FUNCTIONS EXCEPT FOR ISQRT [INTENDED TO BE "INTEGER" SQUARE ROOT, BUT FOR THE TIME BEING, SIMPLY FLOATS ITS ARGUMENT, CALLS SQRT, AND FIXES THE RESULT]. SIN AND COS ASSUME THE ARGUMENT IS IN RADIANS, AND WILL GENERATE AN ERROR IF THE ARGUMENT IS TOO LARGE TO MAINTAIN AT LEAST 7 DECIMAL DIGITS OF ACCURACY IS THE ANSWER. ATAN REQUIRES TWO ARGS, THE FIRST A DELTA-Y AND THE SECOND A DELTA-X, AND RETURNS THE ANGLE BETWEEN 0 AND 2*PI WITH TANGENT (DELTA-Y/DELTA-X). LOG IS NATURAL LOGARITHM, AND EXP IS NATURAL ANTI-LOGARITHM [EXPONENTIATION BASE E]. F) A FEW FUNCTIONS NOW RESIDENT IS THE STANDARD LISP PRIMARILY FOR THE BENEFIT OF LAP, MIGHT CONCEIVABLY BE OF SOME USE TO SOMEONE. GETMIDASOP EXPECTS A PNAME-TYPE ATOM AND RETURNS EITHER NIL IF ITS ARG ISN'T A PDP10 INSTRUCTION, OR THE NUMERICAL VALUE OF THE INSTRUCTION AS A FIXNUM. IN ADDITION TO THE STANDARD PDP10 INSTRUCTION SET, THE CALL UUOS FROM LISP AND THE STRT, ERINT, AND LERR UUOS ARE DEFINED. ALSO DEFINED ARE MANY, BUT NOT ALL, OF THE ITS TIME-SHARING SYSTEM CALLS. GETDDTSYM ALSO EXPECTS A PNAME-TYPE ARGUMENT AND INTERROGATES THE JOB SYMBOL TABLE, IF THE JOB'S SUPERIOR IS A DDT WITH A SYMBOL TABLE LOADED IN; NIL IS RETURNED IN THE CONTRARY CASE, AS WELL AS IN THE CASE THAT THE SYMBOL ISN'T IN THE TABLE. PUTDDTSYM MAKES AN ENTRY INTO THE SYMBOL TABLE - SYMBOL IS FIRST ARGUMENT, VALUE IS SECOND; RETURNS T IF REQUEST SUCCEDED, AND NIL IF FAILED. 2) IN VIEW OF THE WINNITUDE OF FASLOAD ON FASL FILES, THERE APPEARS TO BE NO REASON TO CONTINUE USING E LAP OR C LAP; RATHER THE USER SHOULD SIMPLY DO (FASLOAD F LAP COM) WHICH WILL LOAD IN THE FASL VERSION OF THE LAP ASSEMBLER IN TWO JIFFYS. IF IN FACT THE USER'S LAP FILE IS SOMETHING THAT GETS ASSEMBLED IN ALMOST EVERY TIME HE LOADS UP A LISP, THEN HE SHOULD CONSIDER ASEMBLING THE FILE WITH FASLAP [SEE ITEM 8 BELOW] AND SIMPLY FASLOADING IN THE FASL VERSION OF THE FILE, RATHER THAN LAPPING IN THE LAP VERSION. 3) USER INTERRUPT NUMBER ZERO IS NOW AVAILABLE TO THE USER AS AN ORDINARY INTERRUPT FACILITY WHICH IS RUN WHENEVER CONTROL-@ IS STRUCK [OR (IOC @) EVAL'D]. THIS AUGMENTS THE FACILITY FOR INTERRUPTING ON CONTROL-H AND CONTROL-A, CURRENTLY USER INTERRUPTS NUMBERS 1 AND 2. AS NOTED PREVIOUSLY, (STATUS INTERR 1) SIMPLY ACCESSES THE VALUE CELL OF THE ATOM ^H, WHICH INITIALLY COMES SET THE THE INTERNAL-^H-BREAK FUNCTION. THERE IS, HOWEVER, NO ATOM FOR THE OTHER TWO INTERRUPTS. 4) THE SINGLE-CHARACTER-OBJECT HASH TABLE HAS BEEN MERGED INTO A PART OF THE OBARRAY, SO THAT IT WINS COMPLETELY FOR MULTIPLE OBARRAY HACKS. IF THIS DOESN'T MAKE SENSE TO YOU, DONT WORRY ABOUT IT. ALL YOU NEED TO KNOW IS THAT READCH IS NO MORE COSTLY OR TIME-CONSUMING THAN TYI. 5) DO AND IOG HAVE SLIGHTLY MORE GENERAL FORMATS NOW. (IOG C E1 E2 . . . EN) WORKS AS BEFORE, BUT ALL OF E1 TO EN ARE EVALUATED, WITH THE VALUE OF EN BEING RETURNED. (DO ((Z INITIALVALUE STEPPERFUN) . . .) (ENDTEST E1 E2 . . .EN)) WORKS LIKE THE USUAL EXTENDED DO FORMAT, EXCEPT THAT THE ENDTEST- RETURNVALUE PAIR NOW LOOKS LIKE THE GENERALIZED COND CLAUSE. *************** YET ANOTHER EXTENSION ON 10/15/73 ********* 6) PRINT OUTPUT FOR FIXNUMS HAS BEEN SLIGHTLY HACKED TO GIVE OUT STRINGS SUCH AS 244_33, OR -3_41 WHERE APPLICABLE. OF COURSE, THESE NUMBERS READ IN PROPERLY, AND SHOULD PROVE TO BE LESS OF A STRAIN ON THE EYES THAN SUCH STRINGS AS 344000000000 [OR IN BASE 10., 228._27. RATHER THAN 30601641984.] 7) GRABBING A DISPLAY SLAVE, WITH DISINI, NOW CAUSES A MESSAGE TO BE PRINTED ON THE JOB CONSOLE REGARDING WHICH COMPUTER S ACTUALLY RUNNING THE SLAVE. ORDINARILY, THE PDP6 IS PREFERRED, BUT IF IT IS UNAVAILABLE, OR IF IT IS NOT RUNNING, THE USER IS INFORMED. 8) THERE IS NO LONGER ANY DIFFICULTY WITH COMPILING AN EXPR OF MORE THAN 5 ARGUMENTS. COMPLR CURRENTLY WILL CONVERT SUCH AN EXPR INTO AN LSUBR WITH NO LOSS OF EFFICIENCY. SIMILARLY, THERE IS NO LIMITATION ON THE NUMBER OF VARIABLES IN A LAMBDA APPLICATION. 9) WHEN COMPLR IS LOADED, MAKLAP HAS BEEN ENTERED. TYPING CONTROL-G WILL GET ONE BACK TO LISP TOP LEVEL. A COMMAND TO MAKLAP IS OF THE FORM _ OR OF THE FORM IN THIS CASE THE TARGET FILE WILL BE DEFAULTED TO BE JUST LIKE THE SOURCE FILE, EXCEPT THAT THE SECOND FILE NAME WILL BE "LAP" FOR COMPLR OUTPUT, AND "FASL" FOR FASLAP OUTPUT [IF THERE IS ANY] THERE IS ALSO A NEW WAY TO SET CERTAIN COMPILE-TIME SWITCHES: IN THE COMMAND LINE TO MAKLAP, ONE CAN ENCLOSE CERTAIN SWITCH DESIGNATORS IN PARENTHESES AS FOLLOWS FOO LAP1_JONL;FOO BAR(N -M S) EACH LETTER WITHIN PARENTHESES SETS A SWITCH FROM ITS NORMAL NIL STATE TO NON-NIL; USING A "-" BEFORE THE LETTER SETS IT BACK TO NIL. FOLLOWING IS A LIST OF THE CURRENT SWITCHES AND THEIR MEANINGS: N NOARGS DONT OUTPUT THE ARGS INFORMATION X MAPEX EXPAND ALL MAPS INTO CORRESPONDING DOS M MACROS PRINT INTO THE OUTPUT FILE ANY MACRO DEFINITIONS S SYMBOLS OUTPUT SYMBOLS REQUESTS TO LAP [SO THAT THE LAP SYMBOLS ARE ENTERED IN THE DDT SYMBOL TABLE] F FASL AFTER COMPILATION, ASSEMBLE THE LAP FILE INTO A FASL FILE [AND INCIDENTALLY PRODUCING AN UNFASL FILE] K NOLAP KILL THE IMTERMEDIATE LAP FILE AFTER PRODUCTION OF THE FASL FILE A ASSEMBLE DO THE ASSEMBLE PHASE ONLY - MEANS THAT INPUT FILE IS A LAP SOURCE,, AND OUTPUT IS A FASL FILE. U UNFASLCOMMENTS PRINT FASLAP COMMENTS, WARNING MESSAGES, AND SOURCE FILE COMMENTS LIKE (COMMENT FOO BAR) AND (QUOTE (FOO BAR)) ON THE UNFASL FILE. T TTYNOTES HAVE COMPLER PRINT ON THE JOB CONSOLE AN ANNOTATION AFTER SUCCESSFUL COMPILATION OF EACH FUNCTION. LIKEWISE FOR FASLAP ASSEMBLIES. SPACES,TABS, CARRIAGE RETURNS, AND LINE FEEDS BETWEEN THE SWITCH DESIGNATORS ARE IGNORED; THE REQUEST MAY APPEAR ANYWHERE IN THE COMMAND LINE. AT TIMES, COMPLR AND FASLAP WILL WISH TO INFORM THE USER OF ERRONEOUS, OR POSSIBLY ERRONEOUS CODE IN HIS FILE [OR, HORRORS, A BUG IN COMPLR OR IN FASLAP]. THESE WARNINGS, OR ERROR MESSAGES ARE PRINTED OUT UNDER AN IOG MODIFIED BY THE REQUESTS FROM A TOP-LEVEL LIST "MESSIOC". NORMALLY MESSIOC IS NIL, SO THAT WARNING MESSAGES GO ONLY TO THE JOB CONSOLE, BUT IF THE USER DOES (MESSIOC FOO), IT WILL HAVE THE EFFECT OF CAUSING AN (IOC FOO) JUST BEFORE THE PRINTING OF THE MESSAGE. MESSIOC CAN BE CALLED EITHER FROM A ^H BREAK IN THE COMPLR, OR FROM COMPLR TOP LEVEL BEFORE ENTERING MAKLAP, OR IN A DECLARATION ON THE FILE TO BE COMPILED. LAP SOURCE CODE MAY STILL BE ASSEMBLED AND LOADED IN BY LAP, BUT IT THE ASSEMBLY IS DONE ONTO DISK [INTO A FASL FILE], THEN THE FASLOAD WILL BE MUCH QUICKER THAN A FULL ASSEMBLY AND LOAD. FOR ONE SHOT ASSEMBLY-AND-LOAD TASKS, IT IS STILL MUCH FASTER, HOWEVER, SIMPLY FASLOAD IN COM:F LAP AND ASSEMBLE THE FILE IN CORE [OR LOAD IN COM:E LAP IF FOR SOME REASON AN EXPR VERSION OF LAP IS DESIRED] - ONE GAINS IF HE INTENDS TO ASSEMBLE ONCE AND LOAD-IN MANY TIMES. ONE MAIN ADVANTAGE OF FASLOADING OVER SIMPLY UREADING THE ORIGINAL FILE AND LOADING IS THAT THE READER IS BYPASSED. THE READ PHASE OF LOADING IN AN AUXILLIARY FILE IS QUITE SLOW, AND THE FASL FILE HAS LIST STRUCTURE STORED IN IT IN A PRE-PARSED FORM THAT ALLOWS QUICK RECONSTRUCTION. SOME USERS MAY HAVE TO GIVE THIS A LITTLE THOUGHT, HOWEVER, FOR IT MEANS THAT RANDOM EVALUATIONS INITIATED DURING FASLOADING CANNOT EXPECT TO CALL THE FUNCTION READ AND GOBBLE UP THE NEXT FEW CHARACTERS FROM THE "INPUT FILE"; ALSO, THERE WILL BE NO READ-MACRO CHARACTER HAPPENINGS DURING THE FASLOADING PHASE. 8/9/72 JONL 1) SOME NEW STATUS CALLS A) (STATUS LISPVERSION) IS NOW NECESSARY, INSTEAD OF THE PREVIOUS DOCUMENTATION THAT SUGGESTED THAT THE VALUE OF THE ATOM LISPVERSION WOULD BE A PNAME-TYPE ATOM COMPRISED OF THE CHARACTERS OF THE SECOND FILE NAME OF THE VERSION OF LISP USED TO CREATE THE RUNNING LISP. C) (STATUS UNAME) LETS YOU KNOW WHAT NAME YOU LOGGED IN UNDER [MORE OR LESS] C) (STATUS JCL) OBTAINS AS A LIST OF SINGLE-OBJECT CHARACTERS THE JOB COMMAND LINE FROM DDT, IF THERE IS ONE, AND NIL OTHERWISE. USEFUL FOR CREATING SYSTEMS THAT COULD TAKE AN ARGUMENT FROM DDT. E.G. COMPLR NOW USES THIS FEATURE SO THAT THE CHARACTERS OF THE JCL ARE FED TO MAKLAP JUST AS YOU WOULD TYPE THEM AFTER CALLING (MAKLAP). THUS :COMPLR MOBY MESS IS ACCEPTABLE, AND WOULD COMPILE THE FILE MOBY MESS INTO MOBY LAP ON THE DSK DIRECTORY OF THE CURRENT SNAME D) (STATUS CHRCT NIL), (STATUS LINEL NIL), (SSTATUS CHRCT NIL N), AND (SSTATUS LINEL NIL N) ARE IMPLEMENTED FOR COMPATIBILITY WITH NLISP TO, TEST AND SET THE VALUES OF THE LINEL AND CHARACTER COUNTER FOR THE TTY CHANNEL. E) (SSTATUS GCTIME NEWVALUE) IS NOT REALLY NEW, BUT WILL NOW RETURN THE VALUE OF THE GCTIME COUNTER AS IT FOUND IT BEFORE THE SETTING OF A NEW VALUE. WORKS LIKE (PROG2 NIL (STATUS GCTIME) (SSTATUS GCTIME NEWVALUE)) 2) SOME NEW FUNCTIONS AND FEATURES FOR HACKING PDL FRAMES: A) EVALFRAME IS THE SAME FUNCTION AS PDLFRAME, BUT I WOULD LIKE TO SEE THE NAME "PDLFRAME" PHASED OUT, SINCE THE FRAME RETURNED BY THIS FUNCTION IS FOR AN MARKED ENTRY TO EVAL. IF (*RSET T) HAS BEEN DONE, THE UPON ENTRY TO EVAL A SMALL STACK OF ITEMS IS PUSHED ON THE REGULAR PDL; THE FIRST ELEMENT OF THE RETURND VALUE IS A PDL POINTER TO THE BEGININING OF THIS STACK, AND HENCE JUST ONE PDL SLOT BEYOND THE PDL POSITIONUPON THE ENTRYTO EVAL. [SEE NOTE OF 5/3/72, SECTION 7] B) ERRFRAME RETURNS A 3-LIST SIMILAR TO EVALFRAME, WHERE THE FIRST IS ELEMENT IS A PDL POINTER TO THE BEGINNNG OF THE STACK OF GOODIES PUSHED ONTO THE PDL WHEN THE ERROR OCCURS; AND THE SECOND ELEMENT IS AN ATOM COMPRISED OF THE CHARACTERS OF THE MAIN PART OF THE ASSOCIATED ERROR MESSAGE. C) BOTH OF THE ABOVE FUNCTIONS NOW ACCEPT AN ARGUMENT WHICH SHOULD BE A PDL POINTER [I.E., A NEGATIVE FIXNUM IN THE APPROPRIATE RANGE], OR NIL MEANING THE PRESENT PDL POSITION, AND THE INTENT IS TO START SEARCHING FOR THE FIRST ASSOCIATED STACK OF GOODIES [AN ERROR MARK FOR ERRFRAME, AND EVAL MARK FOR EVALFRAME] PRIOR TO THAT PDL POINT. HOWEVER, SOMETIMES WHEN SEARCHING THE STACK, ONE GOES BACK TOO FAR, AND WOULD LIKE TO SEARCH FORWARDS; THUS IF A LARGE POSITIVE FIXNUM IS GIVEN AS ARGUMENT, THEN IT IS ASSUMEND TO BE THE NEGATION OF SOME PDL POINTER, WHICH IT THEN USES TO START SEARCHING FORWARDS. SIMILARLY, IF ZERIO IS GIVEN AS ARGUMENT, A FORWARDS SEARCH IS INITIATED AT THE PDL BEGINNING [BOTTOM]. D) BOTH BAKTRACE AND BAKLIST NOW ALLOW AN OPTIONAL ARGUMENT WHICH IS INTERPRETED AS ABOVE FOR THE ARGUMENT TO EVALRFRAME AND ERRFRAME. HOWEVER, THERE IS NO SEARCH PHASE INVOLVED, AND THE PRINTING, (OR BAKLISTING) ALWAYS PROCEEDS BACK UP THE PDL. 3) NVID AND NVFIX NOW RETURN 16384.0 AND 16384. [OCTAL 40000] ON THE CONDITIONS OF DIM CUT OFF AND COUNTER UNDERFLOW. 4) ARGS IS NOW AN LSUBR. GIVEN TWO ARGUMENTS, THE FIRST IS AN ATOM ONTO WHICH AN ARGS PROPERTY IS TO BE PUT, AND THE SECOND IS THE ARGS PROPERTY [WHICH WILL BE PLACED JUST BEFORE THE PNAME PROPERTY]. A PREVIOUS NOTE DESCRIBES THE STRUCTURE OF THE ARGS PROPERTY. TO SAFEGUARD YOUR PROGRAMS AGAINST THE VAGARIES OF FUTURE CHANGES IN THE IMPLEMENTATION OF THIS FEATURE, OR THE VAGARIES OF RUNNING UNDER MACLISP ON ANOTHER COMPUTER, ONE SHOULD NOT USE (GET FOO 'ARGS), BUT RATHER (ARGS FOO); THIS LATER FORM ALLOWS FOR STORING THE ARGS PROPERTY IS SOME MORE EFFICIENT FASHION THAN ON THE ATOM'S PROPERTY LIST. 5) AS IT NOW OPERATES, LAP IS AN IN CORE ASSEMBLER AND RELOCATOR. THERE WILL SOON BE AN OPTIONAL VERSION THAT WILL ASSEMBLE A LAP SOURCE FILE INTO A LAP RELOCATABLE FORMAT, WHICH A LINKING-LOADER VERSION OF LAP WILL BE ABLE TO LOAD IN. WE EXPECT A CONSEQUENT SAVINGS IN TIME WHEN THE LAP LINKING LOADER IS USED ON THE RELOC FILE, AS OPPOSED TO USING THE LAP PROGRAM ON THE SOURCE FILE. 08/01/72 - GLS - THE LISP TRACE PACKAGE CONSISTS OF THREE MAIN FUNCTIONS, TRACE, UNTRACE, AND REMTRACE, ALL OF WHICH ARE FEXPRS. A CALL TO TRACE HAS THE FOLLOWING FORM: (TRACE ) A "TRACE SPEC" IN TURN IS EITHER AN ATOM (THE NAME OF THE FUNCTION TO BE TRACED) OR A LIST OF THIS FORM: ( ) WHERE THE OPTIONS ARE AS FOLLOWS: BREAK CAUSES A BREAK AFTER PRINTING THE ENTRY TRACE (IF ANY) BUT BEFORE APPLYING THE TRACED FUNCTION TO ITS ARGUMENTS, IF AND ONLY IF EVALUATES TO NON-NIL. COND CAUSES TRACE INFORMATION TO BE PRINTED FOR FUNCTION ENTRY AND/OR EXIT IF AND ONLY IF EVALUATES TO NON-NIL. ENTRYCOND CAUSES TRACE INFORMATION TO BE PRINTED FOR FUNCTION ENTRY IF AND ONLY IF EVALUATES TO NON-NIL. IF BOTH COND AND ENTRYCOND ARE USED, THE SPECIFIED FOR COND IS EVALUATED FIRST; AND BOTH 'S MUST EVALUATE TO NON-NIL FOR ENTRY TRACE INFORMATION TO BE PRINTED. IS THE FOR COND EVALUATES TO NIL, THEN THE FOR ENTRYCOND WILL NOT BE EVALUATED. EXITCOND CAUSES TRACE INFORMATION TO BE PRINTED FOR FUNCTION EXIT IF AND ONLY IF EVALUATES TO NON-NIL. IF BOTH COND AND EXITCOND ARE USED, BOTH MUST EVALUATE TO NON-NIL FOR EXIT TRACE INFORMATION TO BE PRINTED. NOTE THAT THE FOR COND IS NOT RE-EVALUATED ON EXIT; RATHER, ITS VALUE ON ENTRY IS SAVED. IF THIS VALUE IS NIL, THEN THE FOR EXITCOND WILL NOT BE EVALUATED. WHEREIN CAUSES THE FUNCTION TO BE TRACED ONLY WHEN CALLED FROM THE SPECIFIED FUNCTION. ONE CAN GIVE SEVERAL TRACE SPECS TO TRACE, ALL SPECIFYING THE SAME FUNCTION BUT WITH DIFFERENT WHEREIN OPTIONS, SO THAT THE FUNCTION IS TRACED IN DIFFERENT WAYS WHEN CALLED FROM DIFFERENT FUNCTIONS. NOTE THAT IF THE FUNCTION SPECIFIED BY THE WHEREIN OPTION IS ALREADY BEING TRACED ITSELF, THE WHEREIN OPTION PROBABLY WILL NOT WORK AS DESIRED, PROBABLY. (THEN AGAIN, IT MIGHT.) NOTE THAT MUST BE AN INTERPRETED FUNCTION, SINCE THE WHEREIN TRACE INVOLVES ALTERING THE CALLING FUNCTION AS WELL AS THE CALLED. ARGPDL SPECIFIES AN ATOM WHOSE VALUE TRACE INITIALLY SETS TO NIL. WHEN THE FUNCTION IS TRACED, A LIST OF THE CURRENT RECURSION LEVEL FOR THE FUNCTION, THE FUNCTION'S NAME, AND A LIST OF THE ARGUMENTS IS CONSED ONTO THE WHEN THE FUNCTION IS ENTERED, AND CDR'ED BACK OFF WHEN THE FUNCTION IS EXITED. (ACTUALLY, THIS CONSING/CDRING IS DONE BY MEANS OF LAMBDA-BINDING, SO THAT IF AN ERROR OR OTHER INTERRUPT OCCURS THE WILL BE RESET BY UNBINDING.) THE CAN BE INSPECTED FROM A BREAKPOINT, FOR EXAMPLE, AND USED TO DETERMINE THE VERY RECENT HISTORY OF THE FUNCTION. THIS OPTION CAN BE USED WITH OR WITHOUT PRINTED TRACE OUTPUT. EACH FUNCTION CAN BE GIVEN ITS OWN PDL, OR ONE PDL MAY SERVE SEVERAL FUNCTIONS. ENTRY SPECIFIES A LIST OF ARBITRARY S-EXPRESSIONS WHOSE VALUES ARE TO BE PRINTED ALONG WITH THE USUAL ENTRY TRACE. THE LIST OF RESULTANT VALUES, WHEN PRINTED, IS PRECEDED BY A \\ TO SEPARATE THEM FROM THE OTHER INFORMATION. EXIT SIMILAR TO ENTRY, BUT SPECIFIES EXPRESSIONS WHOSE VALUES ARE PRINTED WITH THE EXIT TRACE. AGAIN, THE LIST OF VALUES PRINTED IS PRECEDED BY \\. ARG SPECIFY THAT THE FUNCTION'S ARGUMENTS, VALUE RESULTANT VALUE, BOTH, OR NEITHER ARE TO BOTH BE TRACED. IF NOT SPECIFIED, THE DEFAULT NIL IS BOTH. ANY "OPTIONS" FOLLOWING ONE OF THESE FOUR ARE ASSUMED TO BE ARBITRARY S-EXPRESSIONS WHOSE VALUES ARE TO BE PRINTED ON BOTH ENTRY AND EXIT TO THE FUNCTION. HOWEVER, IF ARG IS SPECIFIED, THE VALUES ARE PRINTED ONLY ON ENTRY, AND IF VALUE, ONLY ON EXIT. NOTE THAT SINCE ARG, VALUE, BOTH, NIL, SWALLOW ALL FOLLOWING EXPRESSIONS FOR THIS PURPOSE, WHICHEVER ONE IS USED SHOULD BE THE LAST OPTION SPECIFIED. ANY SUCH VALUES PRINTED WILL BE PRECEDED BY A // AND WILL FOLLOW ANY VALUES SPECIFIED BY ENTRY OR EXIT OPTIONS. IF THE VARIABLE ARGLIST IS USED IN ANY OF THE EXPRESSIONS GIVEN FOR THE COND, BREAK, ENTRY, EXIT, OR AFTER-THE-ARG- VALUE-BOTH-OR-NIL OPTIONS, WHEN THOSE EXPRESSIONS ARE EVALUATED THE VALUE OF ARGLIST WILL EFFECTIVELY BE A LIST OF THE ARGUMENTS GIVEN TO THE TRACED FUNCTION. THUS (TRACE (FOO BREAK (NULL (CAR ARGLIST)))) WOULD CAUSE A BREAK IN FOO IFF THE FIRST ARGUMENT TO FOO IS NIL. SIMILARLY, THE VARIABLE FNVALUE WILL EFFECTIVELY BE THE RESULTING VALUE OF THE TRACED FUNCTION; SINCE THE VALUE OF THE FUNCTION IS OF COURSE AVAILABLE ONLY ON EXIT FROM THE FUNCTION, THIS SHOULD ONLY BE USED WITH THE EXIT AND EXITCOND OPTIONS. ALSO, THE VARIABLE RECURLEV, ON BOTH ENTRY AND EXIT, WILL EFFECTIVELY HAVE AS ITS VALUE A NUMBER INDICATING THE CURRENT RECURSION LEVEL (AS WOULD BE PRINTED BY TRACE). THIS ALLOWS CONDITIONAL BREAKS AND TRACES BASED ON THE DEPTH OF RECURSION. THE RECURSION LEVEL IS INCREMENTED BY MEANS OF LAMBDA-BINDING; THUS IF AN ERROR OR OTHER INTERRUPT OCCURS, THE RECURSION LEVEL WILL BE RESET BY UNBINDING. (NOTE THAT THE WORD "EFFECTIVELY" IS USED IN DESCRIBING THE VALUES OF THE ABOVE "VARIABLES" SINCE THESE VARIABLES ARE NOT ACTUALLY USED; TRACE ACTUALLY PERFORMS A SUBLIS ON THE EXPRESSIONS FOR THE OPTIONS MENTIONED ABOVE, SUBSTITUTING CERTAIN NON-INTERNED ATOMS FOR ANY AND ALL APPEARANCES OF THE SPECIAL "VARIABLES" MENTIONED ABOVE. THEREFORE, DO NOT TRY TO USE THESE VARIABLES FOR ANYTHING BUT OBTAINING THEIR VALUES WHEN USING THEM IN EXPRESSIONS FOR THE ABOVE OPTIONS.) IN ADDITION TO USING THE VARIABLE ARGLIST, EXPRESSIONS FOR TRACE OPTIONS MAY REFER TO THE ACTUAL NAMES OF THE FUNCTION'S ARGUMENTS IF THE FUNCTION IS INTERPRETED RATHER THAN COMPILED. FURTHERMORE, SUCH ARGUMENT VARIABLES MAY BE EXAMINED FROM BREAKPOINTS. THERE EXISTS A VERSION OF THE TRACE PACKAGE CALLED STRACE. IT LOOKS EXACTLY LIKE THE NORMAL TRACE PACKAGE, EXCEPT THAT ONE EXTRA OPTION IS AVAILABLE: GRIND SPECIFIES THAT ANY TRACE OUTPUT IS TO BE DONE, NOT WITH THE USUAL CALL TO PRINT, BUT THROUGH THE SPRINT FUNCTION FROM THE GRIND PACKAGE; THUS, TRACE OUTPUT FOR THAT WILL BE "PRETTY-PRINTED". THIS FEATURE IS NOT INCLUDED IN THE REGULAR TRACE PACKAGE BECAUSE IT REALLY EATS UP FREE STORAGE. EXAMPLES OF CALLS TO TRACE: [1] TO TRACE FUNCTION FOO, PRINTING BOTH ARGUMENTS ON ENTRY AND RESULT ON EXIT: (TRACE FOO) OR (TRACE (FOO)) OR (TRACE (FOO BOTH)). [2] TO TRACE FUNCTION FOO ONLY WHEN CALLED FROM FUNCTION BAR, AND THEN ONLY IF (CDR X) IS NIL: (TRACE (FOO WHEREIN BAR COND (NULL (CDR X)))) OR (TRACE (FOO COND (NULL (CDR X)) WHEREIN BAR)). AS THIS EXAMPLE SHOWS, THE ORDER OF THE OPTIONS MAKES NO DIFFERENCE, EXCEPT FOR ARG, VALUE, BOTH, OR NIL, WHICH MUST BE LAST. [3] TO TRACE FUNCTION QUUX, PRINTING THE RESULTANT VALUE ON EXITING BUT NO ARGUMENTS ON ENTRY, PRINTING THE VALUE OF (CAR X) ON ENTRY, OF FOO1, FOO2, AND (FOO3 BAR) ON EXIT, AND OF ZXCVBNM AND (QWERTY SHRDLU) ON BOTH ENTRY AND EXIT: (TRACE (QUUX ENTRY ((CAR X)) EXIT (FOO1 FOO2 (FOO3 BAR)) VALUE ZXCVBNM (QWERTY SHRDLU))). [4] TO TRACE FUNCTION FOO ONLY WHEN CALLED BY FUNCTIONS BAR AND BAZ, PRINTING ARGS ON ENTRY AND RESULT ON EXIT, PRINTING THE VALUE OF (QUUX BARF BARPH) ON EXIT FROM FOO WHEN CALLED BY BAZ ONLY, AND CONDITIONALLY BREAKING WHEN CALLED BY BAR IF A EQUALS B: (TRACE (FOO WHEREIN BAR BREAK (EQUAL A B)) (FOO WHEREIN BAZ EXIT ((QUUX BARF BARPH)))). [5] TO TRACE FUNCTIONS PHOO AND FU, NEVER PRINTING ANYTHING FOR EITHER, BUT SAVING ALL ARGUMENTS FOR BOTH ON A COMMON PDL CALLED FOOPDL, AND BREAKING INSIDE PHOO IF X IS NIL: (TRACE (PHOO ARGPDL FOOPDL BREAK (NULL X) COND NIL NIL) (FU ARGPDL FOOPDL COND NIL NIL)). THE "COND NIL" PREVENTS ANYTHING AT ALL FROM BEING PRINTED. THE SECOND NIL IN EACH SPECIFIES THAT NO ARGS OR VALUE ARE TO BE PRINTED; ALTHOUGH THE COND NIL WOULD PREVENT THE PRINTOUT ANYWAY, SPECIFYING THIS TOO PREVENTS TRACE FROM EVEN SETTING UP THE MECHANISMS TO DO THIS (WHICH IT WOULD, AGAINST THE POSSIBILITY THAT SOMEDAY NIL MIGHT NOT EVALUATE TO NIL.) [6] TO TRACE FUNCTION FOOBAR, PRINTING ARGS ON ENTRY AND RESULT ON EXIT, PLUS THE VALUE OF MOBY-EXPR ON EXIT, AND PRETTY-PRINTING THE OUTPUT: (TRACE (FOOBAR GRIND EXIT (MOBY-EXPR))). [7] TO TRACE FUNCTION GHOTI, ONE OF WHOSE ARGUMENTS IS FISH, PRINTING ALL ARGUMENTS ONLY IF FISH IS NON-NIL, AND PRINTING ON EXIT ONLY IF THE RESULT IS NOT A NUMBER: (TRACE (GHOTI ENTRYCOND FISH EXITCOND (NOT (NUMBERP FNVALUE)))). [8] TO TRACE FUNCTION SSEHC, PRINTING TRACE OUTPUT ONLY IF DRAOB IS NON-ATOMIC, AND EVEN THEN ON ENTRY ONLY IF POHSIB IS A NEGATIVE NUMBER, BREAKING WHEN THE RECURSION LEVEL IS EITHER 3 OR GREATER THAN 7: (TRACE (SSEHC COND DRAOB ENTRYCOND (AND (NUMBERP POHSIB) (MINUSP POHSIB)) BREAK (AND NEEUQ (OR (EQUAL RECURLEV 3) (LESSP 7 RECURLEV))))). TRACE RETURNS AS ITS VALUE A LIST OF NAMES OF ALL FUNCTIONS SET TO TRACE; FOR ANY FUNCTIONS TRACED WITH THE WHEREIN OPTION, SAY (TRACE (FOO WHEREIN BAR)), INSTEAD OF RETURNING JUST THE NAME IT RETURNS A 3-LIST (FOO WHEREIN BAR). IF TRACE FINDS A IT DOESN'T LIKE, INSTEAD OF THE FUNCTION'S NAME IT RETURNS A LIST WHOSE CAR IS ? AND WHOSE CDR INDICATES WHAT TRACE DIDN'T LIKE. (THIS SHOULD BE SLIGHTLY MORE HELPFUL THAN THE OOLD TRACE, WHICH SIMPLY RETURNED NIL.) A LIST OF POSSIBLE ERROR INDICATIONS: (? WHEREIN FOO) TRACE COULDN'T FIND AN EXPR, FEXPR, OR MACRO PROPERTY FOR THE FUNCTION SPECIFIED BY THE WHEREIN OPTION; OR THE FUNCTION SPECIFIED WAS NOT ATOMIC. (? ARGPDL FOO) THE ITEM FOLLOWING THE ARGPDL OPTION WAS NOT A NON-NIL PNAME-TYPE ATOM. (? FOO NOT FUNCTION) INDICATES THAT THE FUNCTION SPECIFIED TO BE TRACED WAS NON-ATOMIC, OR HAD NO FUNCTIONAL PROPERTY. (VALID FUNCTIONAL PROPERTIES ARE EXPR, FEXPR, SUBR, FSUBR, LSUBR, AND MACRO.) (? FOO) FOO IS NOT A VALID OPTION. THUS A CALL TO TRACE SUCH AS (TRACE (FOO WHEREIN (NIL)) (BAR ARGPDL NIL)) WOULD RETURN, WITHOUT SETTING UP ANY TRACES, ((? WHEREIN (NIL)) (? ARGPDL NIL)). IF YOU ATTEMPT TO SPECIFY TO TRACE A FUNCTION ALREADY BEING TRACED, TRACE CALLS UNTRACE BEFORE SETTING UP THE NEW TRACE. IF AN ERROR OCCURS, CAUSING (? ) TO BE RETURNED, THE FUNCTION FOR WHICH THE ERROR OCCURRED MAY OR MAY NOT HAVE BEEN UNTRACED. BEWARE! IT IS POSSIBLE TO CALL TRACE WITH NO ARGUMENTS. (TRACE) RETURNS AS ITS VALUE A LIST OF ALL FUNCTIONS CURRENTLY BEING TRACED. UNTRACE IS USED TO UNDO THE EFFECTS OF TRACE AND RESTORE FUNCTIONS TO THEIR NORMAL (?) UNTRACED STATE. THE ARGUMENT TO UNTRACE FOR A GIVEN FUNCTION SHOULD BE ESSENTIALLY WHAT TRACE RETURNED FOR IT; I.E. IF TRACE RETURNED FOO, USE (UNTRACE FOO); IF TRACE RETURNED (FOO WHEREIN BAR) USE (UNTRACE (FOO WHEREIN BAR)). UNTRACE WILL TAKE MULTIPLE UNTRACE SPECIFICATIONS, E.G. (UNTRACE FOO QUUX (BAR WHEREIN BAZ) FUPHOO). CALLING UNTRACE WITH NO ARGUMENTS WILL UNTRACE ALL FUNCTIONS CURRENTLY BEING TRACED. REMTRACE, ODDLY ENOUGH, EXPUNGES THE ENTIRE TRACE PACKAGE. IT TAKES NO ARGUMENTS. 6/29/72 JONL 1) A POINT TO NOTE WELL: CERTAIN LOSING SITUATIONS WILL FIRST BE TRAPPED OUT BY SOME OF THE NEW ERROR INTERRUPT FUNCTIONS, AND SOME USERS HAVE NOT RECOGNIZED THE BREAK-POINT IDENTIFICATIONS AS MEANINGFUL. AMONG THE MOST COMMON CAUSES OF AMAZEMENT ARE: BKPT GC-LOSSAGE MESSAGE FROM THE GC-LOSSAGE FUNCTION, MEANING THAT YOU HAVE EXAUSTED SOME STORAGE SPACE. BKPT FAIL-ACT ANY OF A NUMBER OF SYSTEMIC PROBLEMS HAS ARISEN. SEE POINT 5 BELOW. AFTER ANY SUCH BREAK-POINT, IT IS USUALLY GOOD STRATEGY TO TYPE ARGS TO SEE WHAT THE TROUBLE-MAKER IS. 2) CATCH AND THROW ARE BOTH FSUBRS AND HAVE OPTIONAL SECOND ARGS WHICH ARE CONSIDERED TAGS. (THROW FOO T1) WILL THROW BACK TO THE MOST RECENT SETTING OF (CATCH (BAR) T1). (THROW FOO) WILL BE CAUGHT BY THE MOST RECENT CATCH, REGARDLESS OF ANY TAG SETTING, AND (CATCH (BAR)) WILL CATCH ANY THROW. HOWEVER, (CATCH (BAR) T2) WILL NEVER CAPTURE A (THROW FOO T1) - IF THERE IS NO CATCH TO MATCH A GIVEN THROW (EITHER ONE WITH THE SAME TAG NAME, OR ELSE A TAG-LESS CATCH), THEN AN UNSEEN-GO-TAG CORRECTABLE ERROR IS DONE. 3) A REMINDER THAT THE SECOND ARG, IF SUPPLIED, TO THROW, TO CATCH, TO ERRSET, AND TO ERR IS NOT EVAL'D, BUT USED DIRECTLY AS A TAG OR INDICATOR. [A NON-NILL SECOND ARG TO ERR SAYS EVALUATE THE FIRST ARG ONLY AFTER UNDOING THE ERRSET THAT IS ABOUT TO CATCH THE ERR. THE ORDINARY CASE IS TO EVALUATE THE FIRST ARG IMMEDIATELY, THEN UNDO THE ERRSET - THUS ERRORS DURING THE EVALUATION OF THE FIRST ARG WILL BE CAUGHT BY THE ERRSET THAT WAS ABOUT TO RECEIVE THE OUTPUT OF ERR. (ERR FOO) IS EQUIVALENT TO (ERR FOO NIL)]. 4) UPON STARTING UP A LISP, THE ATOM TTY IS SET TO A NUMBER DESCRIBING THE TYPE OF TERMINAL THE JOB IS ATTACHED TO: 0 PRINTING, LIKE TELETYPE, MEMOREX, DATEL, ETC. 1 NEW STYLE DATAPOINT 2 OLD STYLE DATAPOINT 3 IMLAC THIS LIST MAY BE EXPANDED IN THE FUTURE. 5) NVSET AND NVFIX INTERACT VERY SMOOTHLY WITH THE FAKE TV PACKAGE OF JERRY LERMAN. A FORTH COMING DOCUMENT BY JERRY WILL DESCRIBE ITS USAGE COMPLETELY, INCLUDING SSTATUS CALLS IN LISP TO SWITCH FROM FAKE TO REAL TV. 6) A FEW MORE ERROR CONDITIONS HAVE BEEN ADDED TO THE CORRECTABLE CATEGORY, UNDER THE FAIL-ACT BRAND. [THE FAIL-ACT FUNCTION IS HANDED A LIST THAT IS GENERALLY VERY DESCRIPTIVE OF SOME REQUESTED ACTION THAT CANNOT BE DONE]. A COMPLETE LIST FOLLOWS: A) AN ARRAY ACCESS ERROR HAS BEEN DETECTED, INDEX IS TOO LARGE OR TOO SMALL B) A REQUEST IS MADE OF NVFIX FOR A POINT OUTSIDE THE SCREEN AREA [OR IN ADDITION, FOR THE FAKETV, A POINT NOT STORED]. C) *REARRAY IS DONE ON SOMETHING THAT ISN'T CURRENTLY AN ARRAY D) (UREAD FN1 FN2), (UKILL FN1 FN2), OR (SSTATUS FTV FN1 FN2) IS DONE ON A NON-EXISTENT FILE. E) REMPROP IS TRYING TO REMOVE A VALUE CELL FROM AN IMPORTANT SYSTEM ATOM. F) GO OR RETURN IS CALLED, BUT THERE IS NO PROG IN USE. G) ARG OR SETARG IS CALLED, BUT THERE IS NO LEXPR IN USE. IN EACH CASE ABOVE, THE FAIL-ACT INTERRUPT FUNCTION MAY RETURN A LIST CONTAINING ONE FORM TO BE EVAL'D IN PLACE OF THE LOSING ACTION; THE INITIAL SETTING OF FAIL-ACT IS MERELY A BREAK LOOP, SO THAT ONE CAN RETURN FROM IT BY TYPING (RETURN RETVAL). THE FAIL-ACT ERRORS LISTED BELOW HAPPEN ONLY TO INFORM THE USER THAT SOME REQUESTED ACTION DIDN'T ACTUALLY HAPPEN, OR TO TELL HIM THAT SOME SYSTEM PARAMETER HAD TO BE RESTORED TO AN INITIAL VALUE. AGAIN, IF THE INTERRUPT FUNCTION RETURNS NIL, AN ORDINARY LISP ERROR WILL BE INITIATED, BUT IF SOME NON-NULL LIST IS RETURNED, THEN THE SYSTEM WILL TRY TO RECUPERATE AS BEST AS IS POSSIBLE. H) BAD GCMIN LIST - WAS RESTORED TO INITIAL VALUE I) BAD IBASE - WAS RESTORED TO EIGHT. J) ATTEMPT TO SETQ NIL - VALUE OF NIL REMAINS UNCHANGED K) ATTEMPT TO WRITE ON A UWRITE OUTPUT CHANNEL, BUT NO UWRITE HAS BEEN DONE. ^R HAS BEEN SHUT OFF, AND WILL BE TURNED ON AGAIN UPON EXIT IF THE INTERRUPT FUNCTION DOES A UWRITE. L) ATTEMPT TO READ FROM A UREAD FILE, BUT NONE HAS BEEN SELECTED [ARGS IS BOUND TO (UREAD)]. ^Q IS RESET TO NIL, AND WILL BE TURNED ON AGAIN UPON EXIT IF THE INTERRUPT FUNCTION DOES A UREAD. THERE MAY BE, IN THE FUTURE, ADDITIONS TO THIS LIST. 7) CERTAIN SUB-PACKAGES OF THE LISP SYSTEM ARE NOW GROUPED TOGETHER ON A SINGLE PAGE [EVEN THOUGH THIS MEANS WASTING A FEW CELLS THAT ARE UNUSED] SO THAT THE USER WHO DOESN'T USE THAT SUB-PACKAGE WONT NEED ANY PART OF IT IN CORE. THESE ARE ARE ALL PURE PAGES, AND SOME OF THE IDENTIFIABLE SUB-PACKAGES ARE: ERROR PROCESSING UNIQUE I/O DEVICE CODE [LIKE VIDISSECTOR, 340 SLAVE, ETC.] EVAL-APPLY AND CERTAIN OPEN-CODED FUNCTIONS [COMPILED CODE WONT BE USING THIS PAGE MUCH] INFINITE-PRECISION ARITHMETIC ROUTINES READ, AND ASSOCIATED FUNCTIONS [LIKE TYI, READLIST] GARBAGE COLLECTOR, AND LISP INITIALIZATION STATUS ,SSTATUS AND EDIT ARRAY-DEPENDENT FUNCTIONS [LIKE ARRAY, MAKREADTABLE, ETC.] GETSP, SUBLIS, AND FUNARG STUFF CERTAIN CONSTANT INITIAL LIST STRUCTURE [3 PAGES] BINARY PROGRAM SPACE [NOT INITIALLY PURE] IN ADDITION, THERE IS A PAGE OF WELL-KNOWN AND OFTEN-USED SUBRS; AND A PAGE CONTAINING THE PRINT-RELATED OUTPUT FUNCTIONS ALONG WITH SOME LESSER-KNOWN SUBRS; AND A PAGE CONTAINING THE TOP-LEVEL CODE, THE INTERRUPT HANDLER AND UUO HANDLER CODE, AND SOME COMMON SYSTEM SUBROUTINES. 06/09/72 JONL 1) THERE ARE SOME NEW FUNCTIONS DESCRIBED IN ITEMS 3-7 BELOW, AND A FEW MINOR INCOMPATIBILITIES DESCRIBED IN 8-14. ITEM 2 IS REPRODUCED FROM THE LAST NOTE TO EMPHASIZE THE CONTINUING DIFFICULTY WITH THE COMPILATION OF ERRSET'S: BECAUSE OF THE NATURE OF ITEM 2 BELOW, SOME FILES COMPILED PRIOR TO TODAY MAY NOT WORK IN THE CURRENT LISP [LISP 229AS]. READ THIS NOTE CAREFULLY. 2) THERE IS A NEW PAIR OF BREAK-AWAY FUNCTIONS: CATCH, A FSUBR WHICH MERELY EVALS THE FIRST ITEM IN ITS ARGLIST, AND THROW, A SUBR OF ONE ARGUMENT WHICH BREAKS AWAY BACK TO THE MOST RECENT CATCH, CAUSING CATCH TO RETURN AS ITS VALUE THE ARGUMENT TO THROW. IF NO THROWS TAKE PLACE, THE CATCH MERELY RETURNS THE EVALUATION WHICH IT COMMENCED. THIS MECHANISM IS INDEPENDENT OF ERRSET, AND SHOULD ALLEVIATE PROBLEMS FOR THOSE WHO HAVE BEEN USING ERRSET AND ERR TO DO THE JOB THAT CATCH AND THROW NOW DO. HOWEVER, MORE STUFF MUST BE SAVED UP WHEN A CATCH OR ERRSET IS EVAL'D AND THUS CODE COMPILED BY COMPILERS PRIOR TO NUMBER 246 WILL NOT HAVE COMPILED ERRSET EVALUATIONS CORRECTLY. 3) THE FAKE TV [PSEUDO-VIDISSECTOR] WILL USE AS MANY BLOCKS OF CORE TO HOLD THE SIMULATED DATA AS THE USER REQUESTS; DEFAULT IS 4. THE REQUEST IS MADE AS (SSTATUS FTVSIZE N) FOR SUITABLE N, AND (STATUS FTVSIZE) WILL READ OUT THIS PARAMETER. DEPENDING ON ONE'S SCAN PATTERN, HE MAY CAUSE FREQUENT, TIME-CONSUMING DISK REFERENCES; THE HOPE IS TO MINIMIZE THIS BY ALLOWING MANY BLOCKS OF DATA TO BE IN CORE AT ONCE. 4) ALL USER INTERRUPT SERVICE FUNCTIONS HAVE BEEN ASSIGNED TO THE VALUE OF A SUTIABLE-SOUNDING ATOM. ONE CAN STILL ACCESS THEM USING THE STATUS CALLS, BUT THE USE OF LISP VARIABLES ALLOWS MNEMONIC REFERENCE AS WELL AS LAMBDA-BINDING POSSIBILITIES. NAME INTERRUPT # DESCRIPTION ^H 1 CONTROL-H TYPED ON CONSOLE ALARMCLOCK 3 ALARMCLOCK EXPIRED ERRSET 4 ERROR BEING CAUGHT BY ERRSET UNDF-FNCTN 5 UNDEFINED FUNCTION OBJECT ENCOUNTERED UNBND-VRBL 6 UNBOUND VARIABLE WRNG-TYPE-ARG 7 WRONG OR UNSUITABLE ARG FOR FUNCTION UNSEEN-GO-TAG 8. GO TO A TAG NOT WITHIN PROG WRNG-NO-ARGS 9. WRONG NUMBER OF ARGS TO FUNCTION GC-LOSSAGE 10. NOT ENOUGHT SPACE RECLAIMED FAIL-ACT 11. SOME REQUESTED ACTION FAILED *RSET-TRAP 19. AN ERROR CAUSING RETURN TO TOPLEVEL GC-DAEMON 20. A MONITOR ON THE GARBAGE COLLECTOR INTERUPTS 5 THROUGH 11. COME PRESET IN THE LISP TO A SYSTEM SUBR WHICH MERELY BINDS THE ATOM ARGS AS NOTED PREVIOUSLY, AND ENTERS A BREAK LOOP [WITH IDENTIFICATION THE SAME AS THE NAME OF THE INTERRUPT] ONE CAN THUS INSPECT THE CAUSE OF HIS LOSSAGE, TAKE CORRECTIVE ACTION, AND RETURN A LIST CONTAINING SOME NEW FORM [OR PERHAPS THE SAME OLD ONE, IF IT HAS BEEN CORRECTED] TO TRY INSTEAD. FAIL-ACT IS A NEW CORRECTABLE ERROR USER INTERRUPT, WHICH IS INVOKED ONLY A FEW PLACES CURRENTLY. USUALLY THE SERVICE FUNCTION WILL BE HANDED SOME DESCRIPTIVE LIST AS ARGUMENT. TO PRECEED FROM A FAIL-ACT ERROR, ONE RETURNS A LIST OF SOME FORM TO BE EVAL'ED IN PLACE OF THE ONE THAT FAILED IN ACTION. THE GC-DAEMON FUNCTION, AS NOTED PREVIOUSLY, IS HANDED A LIST SHOWING THE BEFORE-AND-AFTER AMOUNTS THAT ARE FREE IN THE VARIOUS STORAGE SPACES. IN THIS WAY, ONE CAN ASCERTAIN WHICH SPACES NEED MORE ALLOCATION. E.G., TRY (SETQ GC-DAEMON '(LAMBDA (GCL) (PRINT GCL))) ALSO, THE GCMIN FEATURE, THAT ALLOWS THE USER TO SPECIFY THE LOWER LIMIT OF FREE STORAGE FOR EACH SPACE, IS NOW THE VALUE OF THE ATOM GCMIN. THUS ONE WOULD SAY (SETQ GCMIN '(1000 200 10)) TO SAY TO THE GARBAGE COLLECTOR THAT IT SHOULD CONSIDER IT AN ERROR IF THE AMOUNT OF SPACE FREE FOR STORING LIST STRUCTURE FALLS BELOW 1000, OR FOR FIXNUMS FALLS BELOW 200, OR FLONUMS BELOW 10. 5) THE READER'S SYNTAX TABLE IS NOW AN ARRAY, WHOSE SPECIAL ARRAY CELL IS POINTED TO BY THE VALUE OF THE ATOM READTABLE. THUS ONE CAN QUICKLY SWITCH BACK AND FORTH BETWEEN SEVERAL SYNTAX OPTIONS BY MEANS OF LAMBDA BINDNG AND SETQ. AS WITH THE OBARRAY FEATURE, THERE IS A NEW FUNCTION TO CREATE A COPY OF THE CURRENT READ SYNTAX TABLE AS AN ORDINARY LISP ARRAY. E.G., (MAKREADTABLE 'LISP1/.5) ;(MAKREADTABLE NIL) WOULD ;GENSYM UP AN ARRAY ((LAMBDA (READTABLE) ;WE WANT THE LISP1/.5 (SSTATUS MACRO /; NIL) ;TABLE TO HAVE NONE OF THE (SSTATUS MACRO /' NIL));MACLISP SYNTAX OPTIONS (GET 'LISP1/.5 'ARRAY)) 6) ERRPRINT, A NEW SUBR OF ONE ARGUMENT, WAS IMPLEMENTED TO AID IN DEBUGGING. WHEN AN ERROR OCCURS, THE LISP SYSTEM PUSHES SOME ERROR INFORMATION ON THE PDL AND RUNS THE CORRESPONDING INTERRUPT FUNCTION IF THERE IS ONE, AND MAY ALSO RUN THE *RSET-TRAP FUNCTION JUST BEFORE RESTORING BACK TO TOP LEVEL. THESE SERVICE FUNCTIONS ARE OFTEN BREAK LOOPS, AND ONE MISSES THE ERROR MESSAGES THAT ARE ULTIMATELY PRINTED OUT. THE ARGUMENT TO ERRPRINT IS EITHER NIL OR A PDL POINTER, JUST LIKE THE ARGUMENT TO FRAME [SEE PREVIOUS LISP NOTE]. (ERRPRINT NIL) PRINTS OUT THE MOST RECENTLY STACKED-UP ERROR MESSAGE, AND (ERRPRINT FOO) BEGINS SEARCHING THE PUSH-DOWN STACK FOR AN ERROR MESSAGE PRIOR TO THE POINT NOTED BY THE PDL POINTER FOO. AS SOME USERS HAVE ALREADY NOTICED, IF AN ERROR IS CAUGHT BY AN ERRSET, AND THE USER INTERUPT NUMBER 4 IS NOT ENABLED, THERE IS NO ACTION BY THE CORRESPONDING ERROR SERVICE FUNCTION, THE IDEA BEING THE CATCH BY THE ERRSET WAS SUFFICIENT ACTION. SINCE THE SYSTEM-SUPPLIED SERVICE FUNCTIONS ARE PRIMARILY A CALL TO THE FSUBR BREAK, AND SINCE THE EVALUATIONS BEGUN AT THE TELETYPE ARE CUSHIONED BY A SURROUNDING ERRSET, THEN THE ERROR SYSTEM DOES NOT AT FIRST GLANCE APPEAR TO BE RECURSIVE. IT IS, HOWEVER, AS THE USER MAY VERIFY BY WRITING HIS OWN INTERRUPT SERVICE FUNCTIONS, OR BY SETQ'ING ERRSET TO AN APPROPRIATE FUNCTION. 7A) A NEW FUNCTION BLTARRAY, A SUBR TO TWO ARGUMENTS, ASSUMES THAT BOTH ARE ARRAYS, AND ZAPS AS MUCH AS POSSIBLE OF THE FIRST INTO THE SECOND USING THE BLT INSTRUCTION OF THE PDP10. BLTARRAY DOES NOT *REARRAY EITHER ARRAY; THAT IS TO SAY THAT NEITHER ARRAY IS MOVED AROUND, NOR IS EITHER ARRAY EXTENDED IN SIZE. 7B) A NEW FUNCTION ARRAYDIMS, A SUBR OF ONE ARGUMENT, ASSUMES THAT ITS ARGUMENT IS AN ARRAY, AND RETURNS A LIST OF THE TYPE AND SIZES OF EACH DIMENSION OF THE ARRAY. THUS IF AN ARRAY BAZ WERE CREATED BY (ARRAY BAZ T 2 30), (ARRAYDIMS 'BAZ) WOULD RETURN (T 2 30). 8) ** DELETED ** 9) THERE ARE TWO NEW FUNCTIONS LOADARRAYS AND DUMPARRAYS; THE PLANNED USAGE IS FOR QUICKLY SWAPPING DATA ARRAYS IN AND OUT OF AUXILLIARY STORAGE. [A DATA ARRAY, AS OPPOSED TO AN S-EXPRESSION ARRAY, IS ONE THAT WAS MADE WITH THE GC BIT OFF - AS IN (ARRAY FOO NIL 40). DISGORGE RETURNS SUCH AN ARRAY, AND MUCH USAGE OF LOADARRAYS AND DUMPARRAYS CENTERS AREOUND THE DISPLAY SLAVE. DUMPARRAYS TAKES TWO ARGUMENTS, THE FIRST OF WHICH IS A LIST OF THE NAMES OF THE ARRAYS TO BE DUMPED ONTO AN OUTPUT FILE, AND THE SECOND OF WHICH IS A FILE SPECIFICATION [WITH DEFAULTING LIKE UREAD]. LOADARRAYS HAS ONE ARGUMENT, A FILE SPECIFICATION FOR SOME FILE CREATED BY DUMPARRAYS, WHICH IT PROCEEDS TO SNARF DOWN, LOADING AS MANY ARRAYS [WITH GENSYM'ED NAMES] AS ARE INDICATED IN THE INPUT FILE, AND RETURNING A LIST OF 3-LISTS FOR EACH NEWLY LOADED-IN ARRAY: A) GENSYM NAME OF NEWLY-CREATED ARRAY B) ORIGINAL PNAME OF ARRAY WHEN DUMPARRAYED C) SIZE OF ARRAY [IN TERMS OF NUMBER OF ENTRIES] EXAMPLE USAGE: (ARRAY FOO NIL 40) ;FOO CREATED HERE - (NSTORE (A 37) 105105) ;ASSUME BAR ALREADY EXISTS (DUMPARRAY '(FOO BAR) '(FOOD DATA DSK VIS)) (SETQ COPIES (LOADARRAYS '())) ;NOTE DEFAULTING AS IN UREAD ;CAUSES SAME FILE TO BE OPENED (MAPC '(LAMBDA (X) (DISGOBBLE (CAR X))) COPIES) ;LOOK AT COPIES FROM DSK 10.) THE ARGUMENT GIVEN TO THE INTERRUPT FUNCTIONS FOR UNDF-FNCTN, UNBND-VRBL, WRNG-TYPE-ARG, AND UNSEEN-GO-TAG IS NOW A LIST OF THE LOSING ITEM, RATHER THAN SIMPLY THE LOSING ITEM. THUS IF FOO WERE THE UNBOUND VARIABLE, ARGS WOULD BE BOUND TO (FOO) 11.) ARRAY ACCESS ERRORS NOW CAUSE A CORRECTABLE ERROR OF TYPE "FAIL-ACT", [USER INTERUPT NUMBER 7], WHICH MAY BE PROCEEDED WITH ANY FORM TO BE EVALUATED IN PLACE OF THE FAULTY REFERENCE. THE INTERRUPT FUNCTION, INTITIALLY SET TO A BREAK LOOP WITH ARGUMENT "ARGS", IS HANDED A 2-LIST WHOSE FIRST ELEMENT IS THE ATOM "ARRAYINDEX" AND THE SECOND IS A LIST OF THE ARRAY NAME AND THE VALUES OF THE INDICES THAT CAUSED THE ERROR, E.G. (ARRAYINDEX (BAR 3 5)). THE USER COULD RESTART THE EVALUATION BY RETURNING SAY ((BAR 2 4)), [OR FOR EXAMPLE, ((RANDOMNESS PHOOEY)) IF SOME OTHER VALUE IS DESIRED]. IF THE ARRAY IS NOT ON THE OBLIST, [SUCH WOULD BE THE CASE WITH A NON-INTERN'ED GENSYM'ED ARRAY] THE ARGUMENT TO THE INTERRUPT WILL BE (ARRAYINDEX (? 3 5)), THE ? INDICATING THAT A PNAME FOR THE ARRAY COULD NOT BE READILY OBTAINED. 12.) ** DELETED ** 13.) THE COMPLR WILL NOW OUTPUT ARGS INFORMATION [IN THE FORM OF PSEUDO-OPS TO LAP] ABOUT EXPRS WHICH IT COMPILES, AND LAP WILL TRY TO USE THIS INFORMATION TO PLACE ARGS PROPERTIES OF THE FUNCTIONS ASSEMBLED. THERE IS A COMPILER SWITCH TO CONTROL THE OUTPUTTING OF THIS INFORMATION - NORMALLY THE SWITCH IS ON - BUT A DECLARATION OF (NOARGS T) WILL TURN IT OFF SO THAT THE COMPLR WILL NOT OUTPUT THIS STUFF; OF COURSE (NOARGS NIL) TURNS IT BACK ON AGAIN. 14.) THE DELAYED-READ-MACRO FEATURE HAS BEEN FLUSHED. ALSO, THE CLI INTERRUPT HAS BEEN FLUSHED. 05/03/72 JONL 1) BECAUSE OF THE NATURE OF ITEM 2 BELOW, SOME FILES COMPILED PRIOR TO TODAY MAY NOT WORK IN THE CURRENT LISP [LISP 229AF]. READ THIS NOTE CAREFULLY. 2) THERE IS A NEW PAIR OF BREAK-AWAY FUNCTIONS: CATCH, A FSUBR WHICH MERELY EVALS THE FIRST ITEM IN ITS ARGLIST, AND THROW, A SUBR OF ONE ARGUMENT WHICH BREAKS AWAY BACK TO THE MOST RECENT CATCH, CAUSING CATCH TO RETURN AS ITS VALUE THE ARGUMENT TO THROW. IF NO THROWS TAKE PLACE, THE CATCH MERELY RETURNS THE EVALUATION WHICH IT COMMENCED. THIS MECHANISM IS INDEPENDENT OF ERRSET, AND SHOULD ALLEVIATE PROBLEMS FOR THOSE WHO HAVE BEEN USING ERRSET AND ERR TO DO THE JOB THAT CATCH AND THROW NOW DO. HOWEVER, MORE STUFF MUST BE SAVED UP WHEN A CATCH OR ERRSET IS EVAL'D AND THUS CODE COMPILED BY COMPILERS PRIOR TO NUMBER 240 WILL NOT HAVE COMPILED ERRSET EVALUATIONS CORRECTLY. 3) MOST SYSTEM SUBRS AND LSUBRS HAVE AN ARGS PROPERTY SUPPLIED BY THE SYSTEM. IN *RSET MODE, THE INTERPRETOR WILL CHECK, INASMUCH AS IS POSSIBLE, TO SEE THAT ANY FUNCTION CALL IS MADE WITH THE CORRECT NUMBER OF ARGUMENTS, AND IF NOT WILL CREATE A CORRECTABLE ERROR ON USER INTERRUPT 9. [CURRENTLY THE SYSTEM SUPPLIES A BREAK LOOP FOR THIS INTERRUPT.] FOR SUBRS THE ARGS PROPERTY IS (NIL . N) WHERE N IS THE REQUIRED NUMBER OF ARGUMENTS, AND FOR LSUBRS THE PROPERTY IS (N . M) WHERE AT LEAST N ARGUMENTS ARE REQUIRED, AND AT MOST M ARE ALLOWED. 4) FOR EFFICIENCY REASONS, THE INTERPRETOR WILL LOOK FOR AN ARGS PROPERTY ONLY ON THE PORTION OF THE PROPERTY LIST FOLLOWING THE FUNCTION PROPTERTY. THUS THE FUNCTION ARGS, A SUBR OF TWO ARGUMENTS, HAS BEEN IMPLEMENTED TO FACILITATE PLACING THE ARGS PROPERTY AT THE END OF THE PROPERTY LIST: THE FIRST ARGUMENT IS THE NAME OF THE FUNCTION IN QUESTION, AND THE SECOND ARGUMENT IS A DOTTED PAIR AS DESCRIBED IN ITEM 3 ABOVE. THIS CHECKING FEATURE HAS BEEN OBSERVED TO REQUIRE AN ADDITIONAL AMOUNT OF RUNNING TIME OF BETWEEN 2% AND 10.% DEPE j ON THE PROGRAM. FOR THIS REASON, IT MAY BE DISENABLED AS DESCRIBED IN ITEM 5 BELOW. 5) *RSET HAS TAKEN OVER THE FUNCTION OF NOCHK - THAT IS, (*RSET T) WILL [AMONGST OTHER EFFECTS] CAUSE ARRAY REFERENCES TO BE CHECKED FOR INDEX WITHIN PROPER RANGE, AND (*RSET NIL) WILL [AMONGST OTHER THINGS] INHIBIT THIS TIME CONSUMING CHECKING. ALSO, *RSET = NIL WILL DISENALBE THE ARGUMENT NUMBER CHECKING, AND *RSET = T WILL ENABLE IT. 6) THERE IS A NEW FUNCTION BAKLIST, A SUBR OF NO ARGUMENTS, WHICH OBTAINS A LIST VERY SIMILAR TO THE STUFF PRINTED OUT BY BAKTRACE. AS USUAL, UNLESS *RSET = T, THE AMOUNT OF INFORMATION CONTAINED THEREIN MAY BE MINIMAL. 7) THERE IS A NEW DEBUGGING AID, A FUNCTION CALLED EVALFRAME, WHICH IS A SUBR OF ONE ARGUMENT. WHEN IN *RSET = T MODE, THE EVALUATOR WILL PUSH ONTO THE PDL THE FORM WHICH IT IS TRYING TO EVAL [ALONG WITH A SPECIAL MARKER INDICATING JUST THAT]. (EVALFRAME NIL) WILL RETRIEVE A 3-LIST (P FORM ALIST), WHERE P, A LISP NUMBER, IS THE PDL POINTER OF THE MOST RECENT MARKING BY EVAL, FORM IS THE ARGUMENT TO EVAL AT THAT POINT, AND ALIST, A LISP NUMBER ALSO, IS A SPECIAL PDL POINTER SUCH AS CAN BE USED AS A SECOND ARGUMENT TO EVAL IN PLACE OF AN A-LIST. (EVALFRAME P) WHERE P IS A PDL POINTER, WILL GET THE FRAME [AS A 3-LIST] OF THE CALL TO EVAL JUST PRIOR THE THE ONE MARKED ON THE PDL AT P. [SEE NOTE OF 8/9/72 SECTION 2 FOR POSSIBLE VARIATIONS ON THE RANGE OF P]. THE MAIN PURPOSE OF THIS FUNCTION IS TO AID IN FINDNG THE CONTEXT IN WHICH AN ERROR HAS OCCURRED; FOR EXAMPLE, SUPPOSE A CORRECTABLE ERROR OCCURS, THE CORRESPONDING BREAK INTERUPT IS ENTERED, AND BY APPROPRIATE CALLS TO FRAME THE USER HAS FOUND A PLACE REVEALING THE ERROR; SUPPOSE FURTHER THAT HE WANTS TO LOOK AT SOME VARIABLES AND SEE WHAT VALUE THEY HAD JUST BEFORE EVAL BEGAN WORK ON THE FORM. THEN THE ALIST OF THAT FRAME IS RELEVANT IN THAT HE MIGHT TRY (EVAL '(BREAK PEEKBACK T) ALIST) 8) ** DELETED ** 9) GENSYM IS NOW AN LSUBR, AND IF GIVEN AN ARGUMENT WILL RESET THE GENSYM COUNTER AS DESCRIBED BELOW: ARGUMENT IS OF TYPE PNAME - RESETS THE LETTER PREFIX ARGUMENT IS OF TYPE FIXNUM - RESETS THE 4 DIGIT NUMBER [BY PRINTING OUT THE ARGUMENT IN BASE 10. AND USING THE LAST FOUR DIGITS.] 10) (DISFRAME N) CAUSES THE DISPLAY SLAVE TO GIVE N ZAPS OF THE DISPLAY TO AN ATTACHED MOTION PICTURE CAMERA. 11) EXPT WILL NOW DO VERY WELL WHEN THE MAGNITUDE OF ITS FIRST ARGUMENT IS EITHER 0 OR 1. IN SHORT, IT VERY QUICKLY UTILIZES THE MATHMEMATICAL FACTS THAT 1^X=1, -1^X=(COND((ODDP X)-1)(1)), AND 0^X=0; FOR CONVENIENCE, IT GIVES 0^0=1. EXPT DOES NOT ALLOW EXPONENTS OTHER THAN NON-NEGATIVE INTEGERS, BUT HAS LONG CAPITALIZED FOR SPEED UPON THE FACT THAT X^0=1 4/19/72 - JONL - LISP WILL NOW CHECK THE NUMBER OR ARGUMENTS GIVEN TO A SYSTEM SUBR, AND GENERATE A [CORRECTABLE] ERROR IF THE WRONG NUMBER ARE GIVEN. THERE IS A NEW FUNCTION, "ARGS", OF TWO ARGUMENTS IMPLEMENTED TO OBTAIN THE NUMBER OF ARGS FOR A GIVEN SUBR, AND TO SET THIS PARAMETER CURRENTLY, THIS FEATURE IS IMPLEMENTED USING AN "ARGS" PROPERTY ON THESE ATOMS. THE CORRECTABLE ERRORS ARE UTILIZED BY MEANS OF THE USER INTERRUPT FEATURE - IF THE INTERUPT NUMBER CORRESPONDING TO THE ERROR HAS AN ASSOCIATED FUNCTION, AND IF THE ERROR IS NOT CAUGHT UNDER ERRSET, THEN THAT FUNCTION WILL BE APPLIED TO AN APPROPRIATE ARGUMENT, AND THE RESULT, IF NON-NIL, WILL BE TAKEN TO BE A LIST OF A CORRECTED FORM. THE BASIC GOAL OF AN ERROR RECOVERY INTERRUPT IS TO DETECT A FAULTY FORM NOT OTHERWISE CAUGHT [AS BE ERRSET], AND TO ALLOW THE USER TO SUBSTITUTE A CORRECTED FORM FOR THE FAULTY ONE; IF THE SERVICE IS ASSUMED THAT NO CORRECTION IS DESIRABLE, AND AN ORDINARY LISP ERROR IS CREATED, WITH CONSEQUENT RETURN TO TOP LEVEL. INITIALLY, THESE INTERRUPTS COME SET TO A SIMPLE INTERNAL FUNCTION, WITH ARGUMENT "ARGS", THAT SIMPLY ENTERS A BREAK LOOP. [A BREAK LOOP HAS AN EXPLICIT ERRSET AROUND IT, SO THAT ERRORS AT THIS LEVEL WILL BE RETURNED TO THE LOOP, RATHER THAN ENTER THE RECOVERY SYSTEM RECURSIVELY. HOWEVER THE USER MAY RESET THE INTERRUPT FUNCTION TO ONE THAT DOES NOT DO AN ERRSET, AND THUS EXPECT RECURSIVE HANDLING OF ERRORS.] INTERRUPT # MEANING 5 UNDEFINDED FUNCTION - USER CAN GIVE ANOTHER FUNCTION TO BE USED IN PLACE OF LOSER, OR DEFUN THE LOSER AND GIVE IT BACK TO BE TRIED AGAIN. 6 UNBOUND VARIABLE - USER CAN GIVE BACK ANY FORM TO BE EVAL'D IN PLACE OF THE VALUELESS VARIABLE. 7 WRONG TYPE OF ARGUMENT - AS FOR UNBOUND VARIABLE, CAN GIVE OUT ANY FORM TO BE EVAL'D AND TAKE THE PLACE OF THE LOSING ARGUMENT 8. UNSEEN GO TAG - CAN GIVE AN ATOM TO TRY AS THE RIGHT GO TAG. 9. WRONG NUMBER OF ARGUMENTS TO SOME FUNCTION - THE EVALUATION OF SOME FORM WILL HAVE TO BE RESTARTED: SEE EXAMPLE IMMEDIATELY BELOW. 10. GC LOSSAGE [FAILED TO COLLECT ENOUGH SPACE] - AS DESCRIBED IN PRIOR NOTES, THIS FUNCTION WILL GET AS ARGUMENT EITHER "LIST" "FIXNUM" OR "FLONUM" DEPENDING ON WHICH SPACE OVERFLOWED. IF THE RETURNED VALUE IS NON-NIL, ANOTHER GC WILL BE INITIATED AND HOPEFULLY SOME SPACE WILL HAVE APPEARED. WHILE IN A BREAK LOOP OF ONE THESE INTERRUPT FUNCTIONS, THE USER COULD OF COURSE FIND THE CONTEXT IN WHICH THE OFFENDING FORM OCCURS, AND EDIT IT TO SOME CORRECT STATE. HE IS STILL OBLIGED, HOWEVER, TO GIVE OUT AS VALUE SOME S-EXPRESSION THAT WILL DO IN PLACE OF THE LOSER JUST CAUGHT. FOR EXAMPLE, IF A USER TRIES TO EVAL (CONS X), THE FUNCTION FOR WRONG NUMBER OF ARGUMENTS [INTERRUPT FUNCTION NUMBER 9.], WILL BE HANDED A TWO-LIST INDICATING THE FUNCTION ABOUT TO BE APPLIED AND THE ARGUMENTS ACTUALLY PASSED ALONG, AND A NUMBER INDICATING THE CORRECT NUMBER OF ARGUMENTS FOR THE FUNCTION. [IF CONS WERE AN EXPR, THE SECOND ARGUMENT WOULD BE THE LAMBDA LIST.] IN THIS EXAMPLE, ARG = ((CONS (A B C)) 2), WHICH SHOWS THAT CONS WAS BEING CALLED AND THE VALUE [REPEAT! VALUE] OF THE ARGUMENT TO CONS WAS (A B C); THE USER, AFTER INSPECTING ARGS, MIGHT TYPE (RETURN '( (CONS '5 '(A B C)) )) REMEMBERING THAT BREAK, UPON READING A RETURN, WILL ITSELF RETURN THAT VALUE, WHICH IS EITHER NIL OR A LIST OF THE CORRECTED FORM; IN THIS CASE, THE EVALUATION OF (CONS . . .) WILL BE RESTARTED AND REPLACED BY (CONS '5 '(A B C)). ALSO, ONE MIGHT WANT TO HAVE *RSET = T WHILE DEBUGGING, SO THAT HE MAY GET MEANINGFUL OUTPUT FROM BACKTRACE. A SAMPLE INTERACTION FOLLOWS, WITH LISP'S OUTPUT PRECEEDED BY * (FOO 'X) ;HOPELESS USER WILL TRY ANYTHING * BKPT UNDF-FNCTN ;LISP GENERATES TIMELY MESSAGE ARGS ;USER WOULD LIKE TO KNOW WHAT FUNCTION IS * FOO ;CAUSING TROUBLE (DEFUN FOO (A B) (PLUS A B)) (RETURN '( FOO )) ;AFTER CORRECTING, HE TRIES FOO AGAIN * BKPT WRNG-#-ARGS ;STILL NOT WINNING ARGS ;OUR HERO IS STILL CURIOUS * ((FOO X) (A B)) ;SO HE WILL LOOK UP THE MEANING OF THIS IN ;.INFO.;LISP ARCHIV, PAGE HEADED 3/17/72 ;IF FOO WERE A SYSTEM SUBR OF TWO ARGUMENTS, ;THIS VALUE WOULD BE ((FOO X) 2) (RETURN '( (FOO 'X 3) )) ;HE THINKS HE SIMPLY FORGOT THE 3 * BKPT WRNG-TYPE-ARG ARGS * X (RETURN '( 2 )) ;THIS IS THE LAST KLUDGY ATTEMPT TO WIN * 5 ;AHA, A WELL-KNOWN RESULT THE WRONG TYPE ARG ERROR IS INTENDED TO CATCH A WIDE VARIETY OF CASES WHEREIN A FUNCTION HAS BEEN HANDED AN UNSUITABLE ARGUMENT ORDINARILY, FOR A WRONG TYPE ARG OR AN UNSEEN GO TAG ERROR, THE OFFENDING S-EXPRESSION IS HANDED TO THE INTERRUPT FUNCTION WHICH MAY RECOVER BY SUBSTITUTING SOME OTHER ONE FOR IT [OR BY CORRECTING, AND REQUESTING TO TRY THE SAME ONE AGAIN]. HOWEVER, FOR AN ARRAY ACCESS ERROR, WHICH OCCURS WHEN THE INDEX TO THE ARRAY IS TOO LARGE OR IS NEGATIVE, THE WRONG TYPE ARG ROUTINE GETS A LIST AS IN THE FOLLOWING EXAMPLE: (ARRAY A T 40) (STORE (A 37) 'RANDOMVALUE) (SETQ N 40) (A N) * BKPT WRNG-TYPE-ARG ARGS * (ARRAYINDEX (A 40)) (RETURN '( (A (1- N)) )) * RANDOMVALUE JONL 04/19/72 GRINDEF, AS FOUND ON COM:E GRIND WILL NO LONGER EXIT BY CALLING ERR, BUT WILL RETURN THE ATOM WITH THE NULL PNAME [(ASCII 0)]. THIS WILL HAVE THE EFFECT NOT ONLY OF SUPPRESSING THAT ANNOYING * AFTER A GRINDEF, BUT ALSO IF GRINDEF IS CALLED FROM INSIDE ANOTHER FUNCTION, THERE WILL BE NO ERR OUT. VERY SHORTLY, IRA'S GRINDER WILL BECOME THE STANDARD, BOTH AS COM:E GRIND, AND AS THE ONE IN SYS:TS INDEX. IT HAS MANY NICE FEATURES. JONL 04/12/72 NEW COMPLR, AND READCH. COMPLR 234 WILL COMPILE THE MULTIPLE-INDEX DO FORMAT RECENTLY DESCRIBED. IT ALSO WILL CONVERT A MAP INTO A DO, WHEN NECESSARY, TO PREVENT MAKING VARIBALES (IN THE LAMBDA-FORM GIVEN TO THE MAP) UNNECESSARILY SPECIAL. READCH NOW RUNS FASTLY, IN LISP 229X; IN GENERAL, IT CAN BE EXPECTED TO RUN AS FAST AS TYI. JONL 04/06/72 HINT: TO PLOT ON THE PLOTTER ALL THE ARRAYS CURRENTLY ON DISPLAY IN THE DISPLAY SLAVE: (DEFUN PLOTALL NIL (PLOTLIST (MAPCAR '(LAMBDA (N) (GET (DISGORGE N) 'ARRAY)) (DISLIST)))) 4/5/72 - JONL- THERE ARE THREE NEW FEATURES WITH US NOW: 1) TYIPEEK, A SUBR OF NO ARGUMENTS, WILL INSPECT THE NEXT CHARACTER IN THE INPUT STREAM AND RETURN ITS ASCII VALUE LIKE TYI, EXCEPT THAT IT WILL NOT GOBBLE UP THE CHARACTER. THE NEXT READCH OR READ WILL FIND IT STILL IN THE READ STREAM. FOR THE TTY, THIS MEANS THAT SOME BUFFERING IS DONE BY THE SYSTEM. FOR OTHER INPUT DEVICES, SUCH AS HAVE END-OF-FILE CONDITIONS, WHEN THE EOF IS REACHED, TYIPEEK RETURNS 3 [CORRESPONDING TO CONTROL-C] INSTEAD OF SWITCHING TO THE NEXT DEFAULT DEVICE. 2) USER INTERRUPT NUMBER 20. IS A GARBAGE-COLLECTOR DAEMON, OF SORTS. JUST AFTER EACH COLLECTION, THIS INTERRUPT FUNCTION IS CALLED WITH A LIST OF THREE PAIRS OF NUMBERS ((LIST0 . LIST1) (FX0 . FX1) (FL0 . FL1)) LIST0 IS THE NUMBER OF CELLS FREE IN LIST STORAGE SPACE WHEN THE GC WAS INITIATED, AND LIST1 IS THE NUMBER FREE AFTER THE GC FINISHED; SIMILARLY FOR FIXNUM SPACE AND FLONUM SPACE. IN THE ROSY FUTURE, A USER WILL BE ABLE TO ADD BLOCKS OF STORAGE TO ANY SUCH SPACE [INCLUDING PDLS], AND HE WILL PROBABLY HAVE A HEURISTIC GC-DAEMON FUNCTION TO DECIDE WHEN TO DO SO. 3) IF YOU DEBUG FROM DDT, YOU WILL BE INTERESTED TO KNOW THAT HHX SIMULATES A CONTROL-H INTERRUPT IN LISP. P.X STILL PRINTS OUT THE RIGHT-HALF OF THE CURRENTLY OPEN CELL AS LIST STRUCTURE; PL.X WILL PRINT OUT THE LEFT-HALF. THERE ARE A FEW CORRECTIONS TO THE DESCRIPTION OF THE DISPLAY SLAVE, AND IT MIGHT BE WISE TO TAKE ANOTHER COPY IF YOU ARE INTERESTED. IT IS AT THE BOTTOM OF THE PAGE IN THIS FILE HEADED 3/17/72 THE SERVICE FUNCTION FOR INTERRUPT NUMBER 10. [CALLED WHEN SOME STORAGE AREA IS ABOUT TO RUN OUT OF SPACE] WILL BE GIVEN AS ARGUMENT ONE OF THE THREE ATOMS LIST, FIXNUM, OR FLONUM DEPENDING ON WHICH SPACE IS ABOUT TO LOSE. THE NEW ARITHMETIC FUNCTIONS ANNOUNCED LAST SUMMER FOR NLISP HAVE BEEN IN LISP FOR SOME TIME ALSO. TO RECAPITULATE, THEY ARE: + - * / 1+ 1- ;WHICH REQUIRE FIXNUM ARGUMENTS +$ -$ *$ /$ 1+$ 1-$ ;WHICH REQUIRE FLONUMS < > = ;REQUIRES ARGS OF SAME TYPE IN GENERAL THESE ARE LSUBRS THAT WORK EXACTLY LIKE PLUS, DIFFERENCE, TIMES, QUOTIENT, ADD1, SUB1, LESSP, GREATERP, AND EQUAL [<, >, AND = ARE SUBRS OF TWO ARGUMENTS]; HOWEVER, THE ARGUMENTS MUST OBEY THE NOTED RESTRICTIONS. THIS IS SO THAT THE COMPLR MAY SOMEDAY OPEN CODE THESE ARITHMETIC FUNCTIONS, BUT SOME OF THE USER COMMUNITY HAVE FOUND THEIR STYLE AND SPELLING PREFERABLE TO THE EARLIER. FOR THE SUPER-HACKER, THERE IS A SERIES OF FUNCTIONS TO DO ARITHMETIC ON THE ACTUAL DATUM PASSED AS ARGUMENT RATHER THAN THE LISP INTERPRETATION OF THAT DATUM [E.G., THE NUMBER 69.0E23 IS REPRESENTED AS AN 18.-BIT ADDRESS IN THE FLONUM STORAGE AREA, CONTENTS OF WHICH ADDRESS IS THE PDP10 36.-BIT FLOATING-POINT REPRESENTATION OF 69.0E23]. THEY ARE: +# -# *# /# 1+# 1-# <# ># OF COURSE, "EQ" IS THE EQUAL TEST FOR POINTERS. NOTE ALSO THAT /, /$, AND /# MUST BE TYPED IN AS //, //$, AND //#. THE VARIABLE OBLIST FEATURE IS WORKING WELL, AND IS PARTICULARLY USEFUL WHEN ONE WANTS TO READ IN A RATHER SELF-CONTAINED FILE OF FUNCTIONS BUT DOESN'T WANT FUNCTION DEFINITIONS ON THAT FILE TO CONFLICT WITH ALREADY EXISTING USER-DEFINED FUNCTIONS. FOR EXAMPLE, (COMMENT RUNNER BLOCK) ;SINCE THE TOP LEVEL READER WILL READ ;THIS, THESE ATOMS WILL BE INTERNED ;ON THE CURRENT [I.E. THE STANDARD] ;OBARRAY. (MAKOBLIST 'RUNOB) ;HERE WE MAKE UP AN OBARRAY FOR USE WHILE ;LOADING IN THE FILE. AT THIS POINT, IT IS ;JUST A COPY OF THE STANDARD, INCLUDING ;"RUNNER" AND "BLOCK", WHICH WILL BE THE ;SAME IN BOTH OBARRAYS. ************* REMOB IS NOW A SUBR - 10/15/73 ******************* ((LAMBDA (OBARRAY) ;SO HERE WE BIND OBARRAY TO THE ARRAY ;PROPERTY OF RUNOB (REMOB NVFIX NVSET) ;REMOBS TWO ATOMS [COMMON TO BOTH ;OBARRAYS] FROM THE RUNOB OBARRAY, ;BUT NOT FROM THE STANDARD ONE. (LOADINFILE RUNNER > DSK FOO) ;SUPPOSE WE HAVE A FILE LOADING FUNCTION 'LOADED) (GET 'RUNOB 'ARRAY)) ;SO NEW WE ARE BACK IN THE GOOD OLD STANDARD OBARRAY, BUT ;CAN SWITCH TO THE OTHER ONE TO LOOK AROUND IF NECESSARY. ;FURTHERMORE, WE CAN CALL THE FUNCTION RUNNER FROM EITHER, ;BUT THE LOCAL FUNCTION "DRAGGER", DEFINED ON THE FILE ;RUNNER >, CAN BE ACCESSED BY THE READER ONLY WHEN THE ;RUNOB OBARRAY IS IN USE. IN THE NEXT NOTE ON LISP, I HOPE TO HAVE A REVIEW, IN SOME COHERENT FORM, OF ALL THE STATUS OPTIONS, ALL THE USER INTERRUPTS AVAILABLE, ALL THE READER'S SYNTAX CATEGORIES, AND SOME USEFUL EXAMPLES WHICH PLAY UPON THESE GOODIES. QUITE POSSIBLY, WE NEED A LIBRARY OF USEFUL READ-CHARACTER MACROS AND CORRECTABLE-ERROR INTERRUPT SERVICE FUNCTIONS. 3/17/72 - JONL - THE MAJOR NEW FEATURE OF LISP 229W IS THE USAGE OF THE DISPLAY SLAVE THAT IRA, JERRY LERMAN AND I HAVE BEEN WORKING ON. SINCE THE DESCRIPTION OF ITS USAGE IT QUITE LENGTHY, IT IS RESERVED FOR LAST IN THIS NOTE. FLOATING POINT OUTPUT IS NOW MUCH MORE READABLE - LISP HAS IMPROVED CONVERSION ROUTINES THAT ACTUALLY ROUND TO 8. SIGNIFICANT DECIMAL DIGITS, RATHER THAN TRUNCATING AS MOST OTHER PDP10 SYSTEMS PROGRAMS DO [THAT IS WHY .1 PRINTS OUT AT YOU AS 0.09999999]. ALSO, CALCULATION OF POWER-OF-TEN MULTIPLIERS IS DONE IN DOUBLE-PRECISION FLOATING-POINT TO INSURE THAT THE READ-IN PHASE GETS THE BEST 27.-BIT APPROXIMATION TO THE MANTISSA OF THE NUMBER, AND THAT THE PRINT-OUT PHASE DOES NOT LOSE ANY BITS IN THE NORMALIZATION PHASE: NORMALIZES TO INTERVAL [1.0 10.0) ALL FLOATING POINT NUMBERS EXCEPT THOSE IN THE RANGE (.099999999 99999999.5], AND WHEN NORMALIZED PRINTS THE EXPONENT PRECEEDED BY "E". AN EXPANDED FORM THE MULTIPLE-INDEX DO HAS BEEN ADDED TO THE SYSTEM (DO INDEXLIST (ENDTEST RETURNVALUE) DOBODY) THE ITEMS OF AN INDEXLIST MAY BE OF FORMS: (X XINIT XSTEPPER) WHERE X IS INITIALIZED TO XINIT AND MODIFIED AFTER EACH PASS THROUGH DOBODY BY (SETQ X XSTEPPER) (X XINIT) X IS INITIALIZED TO XINIT, AND MAY BE USED LIKE A PROG VAR (X) LIKE (X NIL) AN ALTERNATE FORM FOR (ENDTEST RETURNVALUE) IS (ENDTEST), WHICH IS TAKEN TO BE (ENDTEST NIL). CAREFUL ABOUT PARENTHESES - AN ENDTEST OF (NULL X) IN THIS ABBREVIATED FORMAT WOULD LOOK LIKE, FOR EXAMPLE, (DO ((X LONGLIST (CDR X)) (N 5 (SUB1 N)) (FLAG)) ((NULL L)) (COND ((EQ (CAR L) 'FOO) (SETQ FLAG T)) (((EQ (CAR L) 'BAR) (SETQ FLAG N)))) (INFORM (CAR L) FLAG) (INFORM 'GAG FLAG)) THE ORIGINAL DO FORMAT - (DO X XINIT XSTEPPER ENDTEST DOBODY) - IS STILL APPLICABLE, AND FOR THE NEXT FEW WEEKS, THE COMPLR WILL NOT HANDLE THE NEW MULTIPLE FORMAT. *********** THIRD DO FORMAT INSTALLED 10/15/73 ********* BACKTRACE NOW WORKS MUCH BETTER, AND OMITS ALL THAT GARBAGE, OFTEN SEEN WHEN AN ERROR OCCURS, ABOUT THE *RSET EXPR. THE FORMAT IS ALSO A LITTLE DIFFERENT IN THAT AN ENTRY TO FUNCTION FOO WILL BE PRINTED OUT AS FOO_ AND IF BAR IS CALLING FUNCTION FOO, THE PRINT-OUT WILL BE FOO_BAR. IN GENERAL, PROGS AND CONDS ARE NO LONGER LISTED TWICE FOR EACH ENTRY. REMINDER! BACKTRACE IS NOT AUTOMATICALLY INVOKED UPON AN ERROR, SO THE BEST WAY TO USE IT IS TO HAVE THE *RSET SWITCH SET TO T, AND WHEN AN ERROR OCCURS, DO (BAKTRACE). IF YOUR ERROR IS BEING CAUGHT AN STOPPED BY AN ERRSET, TRY SETTING USER INTERRUPT NUMBER 4, WHICH WILL BE EXECUTED JUST AS AN ERROR IS BEING CAUGHT BY AN ERRSET. TYPICAL USAGE WOULD BE (SSTATUS INTERR 4 '(LAMBDA (FOO) (BREAK ERSTBREAK T))) SPEAKING OF USER INTERRUPTS, NUMBER 9. WILL SERVICE A WRONG NUMBER OF ARGUMENTS CAUGHT BY THE INTERPRETER.(CONTRARY TO A PREVIOUS NOTE, THE FUNCTION CALLED WHEN AN ERROR CAUSES RESTORATION TO TOP LEVEL, I.E., THE *RSET FUNCTION, IS STORED IN INTERRUPT NUMBER 19.) AS ARGUMENT IT WILL BE HANDED A TWO-LIST INDICATING THE FUNCTION ABOUT TO BE APPLIED AND THE ARGUMENTS ACTUALLY PASSED ALONG, AND THE LAMBDA LIST OF THE FUNCTION. FOR EXAMPLE ((FOO V1 V2 ) (X Y Z)) SHOWS THAT FOO WAS BEING CALLED AND THE VALUES [REPEAT! VALUES] OF THE ARGUMENTS TO FOO WERE V1 AND V2; ALSO, THE LAMBDA LIST OF FOO IS (X Y Z) [CURRENTLY, THE INTERPRETER DOES NOT CATCH CALLS TO SUBRS WHERE THE NUMBER OF ARGUMENTS IS WRONG]. SINCE A TYPICAL SERVICE FUNCTION MIGHT BE (LAMBDA (ARGLOSS) (BREAK WNA T)), THE USER, AFTER INSPECTING ARGLOSS, MIGHT TYPE (RETURN '((FOO 'V1 'V2 35.))) REMEMBERING THAT BREAK, UPON READING A RETURN, WILL ITSELF RETURN THAT VALUE. AS BEFORE, IF THE SERVICE FUNCTION RETURNS A NON-NIL VALUE, IT IS PRESUMED TO BE A LIST OF THE CORRECTED FORM; IN THIS CASE, THE EVALUATION OF (FOO . . .) WILL BE RESTARTED AND REPLACED BY (FOO 'V1 'V2 35.) THE FAMOUS PSEUDO VIDISSECTOR IS WORKING WELL, AND IS INITIALIZED BY (SSTATUS FTV FN1 FN2 DEV USR), IN ORDER TO USE THAT FILE OF CANNED VIDI SCENES. NVFIX AND NVID WILL THEN OBTAIN THEIR VALUES FROM THERE RATHER THAN FROM THE REAL VIDISSECTOR. GIVING NVFIX A NEGATIVE FIRST ARGUMENT WILL ALLOW ACCESS OF CERTAIN HEADER INFORMATION STORED WITH THE PICTURE ARRAY, THE SECOND ARGUMENT SPECIFYING WHICH: (NVFIX -1 0) => (XLL . YLL) (NVFIX -1 1) => (XUR . YUR) (NVFIX -1 2) => (DCO . CONF) ASK JERRY LERMAN FOR MORE INFORMATION IF YOU ARE INTERESTED. TYPEP IS A NEW SUBR THAT RETURNS ONE OF LIST FIXNUM FLONUM BIGNUM PNAME RANDOM DEPENDING UPON WHAT THE TYPE OF THE ARGUMENT IS; NIL IS OF TYPE PNAME AS WELL AS TYPE LIST, SO IT IS ARBITRARILY GIVEN TYPE PNAME HERE; ANY DOTTED PAIR, AND NOT JUST PROPER LISTS, IS GIVEN VALUE LIST. MAKNUM IS NOW AN LSUBR, WITH (MAKNUM FOO) BEING EQUIVALENT TO (MAKNUM FOO 'FIXNUM) (SSTATUS DIVOV T) WILL ENABLE A DIVIDE OVERFLO IN THE FUNCTION QUOTIENT TO RETURN THE NUMERATOR WITH ITS MAGNITUDE INCREASED BY ONE (RATHER THAN CREATING AN ARITHMETIC OVERFLOW ERROR). MORE REMINDERS OF THINGS ALREADY KNOWN: (1) IF AN ITEM IN A LIST TO MAKNAM OR READLIST IS A NUMBER INSTEAD OF A PNAME-TYPE ATOM, IT IS TREATED AS THE SINGLE CHARACTER ATOM WHOSE ASCII CHARACTER VALUE IS THAT NUMBER. THUS (READLIST '(101 102)) RETURNS AB . (2) INFINITE PRECISION FIXNUM ARITHMETIC WORKS WELL IN BNLISP - SOME HAVE SUGGESTED MAKING THIS THE STANDARD LISP. IF ANYONE OBJECTS TO THE EXTRA BLOCK OF PURE CODE THAT THIS WOULD REQUIRE, OR TO THE LOSS OF ERROR MESSAGES ON ARITHMETIC OVERFLOWS, OR TO THE EPSILON TIME LOSS REQUIRED FOR ADDITIONAL INTERPRETATION, PLEASE LEAVE ME A NOTE [DO :MAIL JONL I OBJECT ETC.] PERHAPS IT IS REDUNDANT TO SAY, BUT CODE COMPILED BY THE UPCOMING FAST-NUMBER COMPILER WILL NOT MAKE USE OF THE INFINITE PRECISION SUBROUTINES. INSTEAD WE AIM ONLY FOR ONE-HALF FORTRAN SPEED ON FORTRAN-LIKE PROBLEMS ENCODED IN MACLISP. PLANS FOR THE FUTURE: SUPER-FAST ARRAY ACCESSING, LIKE FORTRAN ALMOST, AND THE EXTENSION OF THE FAST-NUMBER COMPLR TO HANDLE THEM. A COMPATIBLE VERSION OF MACLISP [EXCEPT FOR UNUSUAL I/O DEVICES] LIVES ON THE BBN TENEX SYSTEM; SOME GROUP AT UNIV. OF MICH. HAS IMPLEMENTED A MACLISP ON A 360. WORK IS AFOOT TO OBTAIN A COMPATIBLE MACLISP ON MULTICS [THEY SAY, TOO, THAT WORK IS AFOOT TO MAKE MULTICS COMPATIBLE WITH REAL TIME]. THE VERSION RUNNING ON THE MATHLAB SYSTEM MAY BE THE FIRST TO HAVE A DYNAMICALLY EXPANDABLE FREE STORAGE, BUT THIS IS MANY MONTHS IN THE FUTURE. IN ORDER TO USE THE SLAVE, IT IS NECESSARY TO HAVE AVAILABLE THE PDP6. SOON WE WILL HAVE A VERSION THAT WILL ALSO RUN ON THE 10 UNDER ITS, AT PERHAPS SOME DEGRADATION IN PERFORMANCE (BOTH OF THE SLAVE AND ITS). THE PDP6 SHOULD BE IN THE RUNNING STATE, AND IF SIMPLY HITTING THE START SWITCH DOESN'T KEEP THE RUN LIGHT ON, DEPOSIT ZEROS INTO LOCATIONS 40 AND 41 AND START UP AT 40 THE REMAINDER OF THIS DESCRIPTION OF LISP FUNCTIONS FOR THE NEW PDP6 DISPLAY SLAVE USES THE FOLLOWING CONVENTIONS: X, Y ARE ASSUMED TO BE INTEGER ARGUMENTS TO LINE DRAWING, POINT INSERTING, AND OTHER SUCH FUNCTIONS N IS A FIXED-POINT NUMERICAL ARGUMENT DESCRIBED UNDER PARTICULAR FUNCTIONS ITEM IS ASSUMED TO BE THE NUMERICAL INDEX OF SOME DISPLAY SLAVE ITEM. IT IS A QUANTITY SUCH AS IS RETURNED BY DISCREATE. BRITE EACH ITEM HAS A BRIGHTNESS LEVEL ASSOCIATED WITH IT, RANGEING BETWEEN 1 AND 8. DEFAULT VALUE = 8. SCALE EACH ITEM HAS A SCALE, OR MAGNIFICATION, FACTOR ASSOCIATED WITH IT, RANGEING BETWEEN 1 AND 4. DEFAULT, AND NORMAL, IS 1; 2 DOUBLES THE LENGTH OF DRAWN LINES AND TEXT, 3 QUADRUPLES AND 4 MULTIPLYS BY 8. TEXT LOOKS MUCH NICER IF IT IS DRAWN WITH A LITTLE MAGNIFICATION; GENERALLY 2 IS APPROPRIATE. FLAG IS AN INDICATOR TELLING WHETHER A GIVEN ACTION IS TO BE DONE [ON NON-NIL] OR UNDONE BSL IS EITHER NIL, IN WHICH CASE THERE IS NO CHANGE, OR IS A LIST LIKE (BRITE SCALE) INDICATING A SETTING OF LEVELS FOR A GIVEN ACTION 121. A WELL-KNOWN INTEGER, EASILY RECOGNIZED TO BE THE SQUARE OF THE FIFTH PRIME, BUT NOT SO EASILY SEEN AS SUCH WHEN EXPRESSED IN OCTAL AS 171 - THUS WE USE OCTAL NOTATION EXCEPT WHEN THE STRING OF DIGITS IS FOLLOWED BY A . EACH ITEM HAS ASSOCIATED WITH IT VARIABLES DETERMINING THE BRIGHTNESS, SCALE, AND VISIBILITY OF POINT AND LINE INSERTION REQUESTS; LIKE THE LOGO TURTLE, WE THINK OF THE ITEM AS HAVING A PEN WHICH CAN BE "DOWN" SO THAT A LINE IS VISIBLE WHEN THE TURTLE IS REQUESTED TO GO FROM ONE PLACE TO ANOTHER, OR "UP" SO THAT NO MARK IS SEEN. FOR THE COMMANDS TO AFFECT BRIGHTNESS, SCALE, OR THE PENUP STATUS, 0 GENERALLY MEANS NO CHANGE. COMMANDS WHICH TAKE AN OPTIONAL BSL ARGUMENT - NAMELY DISAPOINT, DISCUSS, AND DISALINE - WILL TREAT IT AS A TEMPORARY SETTING FOR THESE VALUES, AND UPON EXIT WILL RESTORE THESE VARIABLES TO THEIR VALUES PRIOR TO THE CALL. SIMILARLY, THE OPTIONAL PENUP ARGUMENT TO DISALINE IS TREATED AS TEMPORARY. ARGUMENTS THAT ARE INTENDED TO SPECIFY LOCATIONS ON THE 340 SCREEN FOR THE FUNCTIONS DISALINE, DISAPOINT, AND DISCUSS, ARE INTERPRETED IN ONE OF FOUR WAYS DEPENDING ON THE SETTING OF THE SLAVE VARIABLE "ASTATE": 0 RELATIVE MODE - THE POINT SPECIFIED IS IN RELATION TO THE HOME OF THE ITEM ON WHICH THE COMMAND IS ACTING. 1 ABSOLUTE MODE - X AND Y ARE DIRECTLY INTERPRETED IN THE CO-ORDINATES OF THE 340 SCREEN, MOD 1024., WITH THE LOWER-LEFT CORNER BEING [0,0] 2 INCREMENTAL MODE - THE POINT SPECIFIED IS IN RELATION TO THE CURRENT POSITION OF THE PEN OF THE ITEM ON WHICH THE COMMAND IS ACTING. 3 POLAR MODE - LIKE INCREMENTAL, BUT THE ARGUMENTS, WHICH MUST BE FLOATING POINT, ARE CONSIDERED AS THE RADIUS AND ANGLE FOR A POLAR COORDINATE SYSTEM CENTERED ABOUT THE CURRENT PENPOSITION (WITH ZERO DEGREES BEING HORIZONTAL TO THE RIGHT). TO EMPHASIZE THE ASTATE MAPPING OF THESE ARGUMENTS, WE WILL WRITE ASTATE[X,Y] TO MEAN THE POINT SPECIFIED BY X AND Y. N.B.: FUNCTIONS LIKE DISCREATE, DISLOCATE, AND DISMOTION, WHICH PLACE FOR AN ITEM'S HOME IN SOME SPECIFIED LOCATION, ALWAYS INTERPRET THE SPECIFICATION IN ABSOLUTE MODE. TYPICAL CALLS FUNCTION TYPE EXPLANATION (DISCREATE X Y) LSUBR CREATE A DISPLAY ITEM WITH HOME AT (DISCREATE) [X,Y] ON THE 340 SCREEN. DEFAULT OPTION IS TO PLACE HOME AT [0,0] IF X AND Y NOT GIVEN. RETURNS ITEM NUMBER OF NEWLY CREATED ITEM. (DISINI) LSUBR SEIZE AND INITIALIZE SLAVE. IF USER ALREADY HAS SLAVE, THEN REINITIALIZE, AND SET ASTATE TO GIVEN ARGUMENT. ALWAYS RETURNS PREVIOUS VALUE OF ASTATE, BUT NO ARG GIVEN, OR ARG NOT AMONG 0,1,2,3 MAKES NO CHANGE IN ASTATE. INITIAL ASTATE = 0. (DISPLAY ITEM FLAG) SUBR ITEM ON OR OFF DISPLAY - I.E. MAKE VISIBLE ON SCREEN OR NOT. DISCREATE, DISCOPY, AND DISGOBBLE PLACE THEIR ITEMS ON DISPLAY, EVEN WHEN NULL. WHEN OFF DISPLAY, THE ITEM IS STILL REMEMBERED BY THE SLAVE UNTIL FLUSHED (DISFLUSH) LSUBR NO ARG GIVEN MEANS FLUSH WHOLE SLAVE (DISFLUSH ITEM1 . . . ITEMN) OTHERWISE SIMPLY KILL ITEMS. (DISLOCATE ITEM X Y) SUBR MOVE ITEM'S HOME TO LOCATION [X,Y] (DISBLINK ITEM FLAG) SUBR SELF EXPLANATORY (DISCOPY ITEM) SUBR MAKE A COPY OF ITEM, AS A NEW ITEM WITH HOME AT SAME LOCATION. RETURN NEW ITEM NUMBER. (DISMARK ITEM N) SUBR IF N=0, REMOVE MARKER FROM ITEM. IF N<0, INSERT STANDARD MARKER IF N> , USE ITEM WITH #N AS MARKER (DISCRIBE ITEM) SUBR GET LIST OF (XHOME,YHOME,XPENPOS, YPENPOS,BRITE,SCALE,PENUP,MARKER) FROM ITEM (DISCHANGE ITEM BRITE SCALE) SUBR BRITE AND SCALE ARE INCREMENTS TO BE ADDED TO THE PARTS OF ITEM (DISLINK ITEM1 ITEM2 FLAG) SUBR LINK OR UNLINK ITEM1 TO ITEM2 ITEM2 IS THE "INFERIOR" OF ITEM1, AND WILL BE DISLOCATED, DCHANGED, DISBLINKED, AND DISPLAYED AS A SUBPART OF ITEM1 WHENEVER THESE OPERATIONS ARE PERFORMED ON ITEM1. (DISLIST) LSUBR RETURN LIST OF ALL ITEMS ON DISPLAY (DISLIST ITEM) RETURN LIST OF ALL INFERIORS OF ITEM (DISET ITEM N BSL) SUBR SETS THE DEFAULT VALUES FOR PENUP, BIRGHTNESS, AND SCALE PARAMETERS FOR THE ITEM. IF N IS -1, PUT PEN DOWN; IF +1, LIFT UP PEN; IF 0, LEAVE PEN ALONE. SET BRITE AND SCALE FROM BSL [FOR MEANING OF BSL, SEE CONVENTIONS DISCUSSED ABOVE] WHEN CREATED, THE ITEM'S DEFAULTS ARE: PEN IS DOWN, BRIGHTNESS IS 8., AND SCALE IS 1. (DISALINE ITEM X Y) (DISALINE ITEM X Y N) (DISALINE ITEM X Y BSL) (DISALINE ITEM X Y BSL N) LSUBR SET PENUP AND BSL AS INDICATED BY N AND BSL (SEE DISET ABOVE), THEN GO FROM CURRENT PEN POSITION TO ASTATE[X,Y], LEAVING A VISIBLE LINE ONLY IF THE PEN IS DOWN, AND THEN RESTORE THE PENUP AND BSL PARAMETERS (DISAPOINT ITEM X Y) (DISAPOINT ITEM X Y BSL) LSUBR DISPLAY A POINT AT ASTATE[X,Y]. DOES AFFECT ITEM'S PENUP OR BSL PARAMETERS (DISCUSS ITEM X Y TEXT) (DISCUSS ITEM X Y TEXT BSL) LSUBR THE CHARACTERS OF THE VALUE OF TEXT ARE INSERTED, AS IF PRINC'ED, INTO THE INTO ITEM BEGINNING AT POINT ASTATE[X,Y]. NO CHANGE IN ITEM'S PENUP AND BSL PARAMETERS. (DISMOTION ITEM X Y SPD) SUBR CAUSES ITEM TO BE SLOWLY DISLOCATED SO THAT IT'S HOME IS AT [X,Y]. IF EITHER X OR Y IS NEGATIVE THEN PLACES ITEM UNDER CONTROL OF SPACE WAR CONSOLE 1. THE BUTTON RETURNS CONTROL TO THE TTY. SPD IS AN INVERSE MEASURE OF THE SPEED AT WHICH THE ITEM WILL MOVE. SPD = 0 IS MAXIMUM. NOTE WELL: ALTHOUGH THE SPACE-WAR CONSOLE CONTROL WILL WORK FOR ANY DISPLAY ITEM, THE AUTOMATIC SLOW MOTION WILL CURRENTLY WORK ONLY FOR ITEMS CONSISTING SOLELY OF LINES DRAWN BY DISALINE. (DISGORGE ITEM) SUBR CREATES A (GENSYM'D) LISP ARRAY AND FILLS IT WITH THE 340 CODE FROM ITEM. (DISGOBBLE ARRAYNAM) SUBR TAKES THE ENTRIES OF THE LISP ARRAY ARRAYNAM AND CREATES A DISPLAY SLAVE ITEM WITH THOSE ENTRIES. EXAMPLES A SUBROUTINE TO DRAW A LIGHT BOX WITH A MEDIUM POINT INSIDE IT AT THE CENTER OF THE SCREEN, RETURNING A DESCRIPTION OF THE SLAVE ITEM: ((LAMBDA (OASTATE B) (DISALINE B -100 -100 1) ;GO TO LOWER-LEFT CORNER (DISET B 0 (LIST 3 BOXSCL)) ;GLOBAL VARIABLE FOR SCALE, ;NO CHANGE TO PENUP STATUS (DISALINE B 0 200) (DISALINE B 200 0) ;SEE HOW EASY IT IS IN (DISALINE B 0 -200) ;INCREMENTAL MODE! (DISALINE B -200 0) (DISINI 0) ;BUT EASIER TO PUT IN POINT (DISAPOINT B 0 0 '(6 0)) ;IN RELATIVE MODE. NOTE THAT ;SCALE IS NOT USED HERE (DISINI OASTATE) ;RESTORE ASTATE (DISCRIBE B)) (DISINI 2) (DISCREATE 1000 1000)) ;CREATES B, HOME AT CENTER TO ADD SOME TEXT ON THE TOP OF THE BOX, ASSUMING ASTATE=0 AND THAT B'S VALUE IS THE NUMBER OF THE ABOVE ITEM: (DISCUSS B -200 207 '(HERE IS THE BOX - SEE THE BOX) '(6 2)) TO MOVE THE BOX B RIGHT 100 UNITS: (SETQ FOO (DISCRIBE B)) (SETQ FOO (LIST (CAR FOO) (CADR FOO))) (DISLOCATE B (+ 100 (CAR FOO)) (CADR FOO)) TO PUT A CROSS WHERE THE PEN IS NOW, AND SOME TEXT WHERE IT USED TO BE BEFORE THE MOVE: (DISMARK B -1) (DISCUSS B (CADDR FOO) (CADDDR FOO) '(TURTLE SLEPT HERE)) TO BRIGHTEN UP THE BOX AND POINT [BUT THE TEXT "(TURTLE SLEPT HERE)" WAS ALREADY IN BRIGHTEST MODE, SO IT REMAINS UNCHANGED]: (DISCHANGE B 2 0) TO FLUSH THE BOX: (DISFLUSH B) TO FLUSH ALL ITEMS ON THE LIST L: (APPLY 'DISFLUSH L) TO GIVE UP THE SLAVE: (DISFLUSH) 11/4/71 - JONL - **** THERE ARE SOME NEW FUNCTIONS IN BOTH LISP AND NLISP. EXPLODEN IS LIKE EXPLODEC, EXCEPT THAT THE LIST OF ITEMS PRODUCED CONTAINS THE ASCII VALUES [AS FIXED-POINT NUMBERS] OF THE EXPLODED PARTS, INSTEAD OF SINGLE CHARACTER OBJECTS. PLUSP OPERATES SIMILARLY TO MINUSP. IF A RETURN IS EXECUTED AT THE TOP LEVEL OF A BREAK, [SEE PRIOR NOTES ON BREAK LOOPS] THEN THE BREAK WILL EXIT RETURNING THE GIVEN VALUE RATHER THAN THE DEFAULT VALUE AS DESCRIBED IN PRIOR NOTES. WHILE TYPING IN FROM A JOB CONSOLE OF THE DISPLAY TYPE, YOU MAY HAVE NOTICED THAT TYPING CONTROL-L CLEARS THE SCREEN AND RETYPES THE CURRENT TTY INPUT BUFFER. YOU MAY NOW USE CONTROL-K TO MERELY DO A CARRIAGE-RETURN-LINE-FEED FOLLOWED BY A RETYPING OF THE TTY INPUT BUFFER. **** CONTRARY TO WHAT YOU MAY HAVE HEARD, THE LISP FUNCTION SET IS BACK WITH US AS AN ORDINARY OLD SUBR OF TWO ARGUMENTS. SETQ HAS ALWAYS BEEN AN FSUBR, AND HAS BEEN RECENTLY ACCEPTING MULTIPLE REQUESTS LIKE (SETQ A 1 B 2 C 3). CODE COMPILED FOR FUNCTIONS USING SET WILL NOT BE AFFECTED BY THIS CHANGE. **** IRA, JERRY LERMAN, AND I ARE DEVELOPING A SIMPLE, NEAT DISPLAY LANGUAGE FOR USE IN LISP. WE ENVISION USING THE PDP6 AS AN OFF-LINE DISPLAY PROCESSOR SO THAT ONE MAY OBTAIN HIGH-QUALITY IMAGES WITHOUT SLOWING DOWN THE TIME-SHARING SYSTEM. A PDP-10 ON-LINE VERSION OF THE PROCESSOR WILL BE USED WHEN THE 6 IS NOT AVAILABLE [FOR COMPATIBILITY], BUT OF COURSE THIS WILL CAUSE SOME DEGRADATION OF THE ITS PERFORMANCE. PERSONS WITH EITHER EXPERIENCE DESCRIBING VISUAL SCENES, DISPLAYS, GRAPHS, ETC., OR WITH STRONG IDEAS ON HOW TO DO SO EASILY, SHOULD SPEAK WITH US SOON. **** THE GOODIES ABOUT THE GARBAGE COLLECTOR MENTIONED IN THE LAST UPDATE NOTE [REGARDING INTERRUPT NUMBER 10. FOR CATCHING STORAGE SPACE CAPACITY EXCEEDED ERRORS] APPLIES TO LISP AS WELL AS NLISP. **** SOME BUGS IN THE BIGNUMBER INPUT ROUTINES HAVE BEEN REPAIRED, AS WELL AS SOME ANNOYING BUGS IN THE FLOATING-POINT PRINTOUT ROUTINE OF NLISP. 9/5/71 - RMS - ***** THIS FACILITY, AND THESE FUNCTIONS, EXIST ONLY IN THE VERSION OF MACLISP CURRENTLY CALLED "NLISP" AND ARE NOT STANDARD YET [AS OF DECEMBER 1972] CHANGES TO NLISP I-O: CONTENTS: FILES, AND HOW TO OPEN THEM SELECTION FOR INPUT ENABLING FOR OUTPUT NEW LPT OUTPUT FORMAT EOF HANDLING NEW STATUS CALLS OTHER NEW FUNCTIONS OLD I-O FUNCTIONS INCOMPATIBILITIES FILES, AND HOW TO OPEN THEM: A FILE IN LISP IS REFERRENCED THROUGH A FILE-ARRAY. A FILE-ARRAY IS AN ATOM WITH A FILE PROPERTY OF A SPECIAL TYPE; IT CONTAINS TWO FILENAMES, A DEVICE NAME, AND A SYSTEM NAME; AN EOF FUNCTION RELEVANT ONLY TO INPUT; AND A CHRCT AND A LINEL RELEVANT ONLY TO OUTPUT. IT ALSO CONTAINS OTHER INTERNAL DATA. TO OPEN A FILE, USE THE LSUBRS OPENI AND OPENO, FOR INPUT AND OUTPUT, RESPECTIVELY. THEY WILL BE REFERRED TO COLLECTIVELY AS 'OPEN. OPEN CAN TAKE AN ATOMIC ARG, A LIST ARG, NEITHER, OR BOTH. IF THERE IS NO ATOMIC ARG, OPEN WILL GENSYM ONE. IF THE ATOM IS NOT A FILE-ARRAY, OPEN WILL MAKE IT ONE, AND PUT IN THE DEFAULT NAMES, LINEL, AND EOFFN. IF THERE WAS A LIST ARG, THE NAMES IN IT WILL BE MERGED IN TO THOSE IN THE FILE-ARRAY. THE RESULTING SET OF NAMES SPECIFIES THE FILE, WHICH IS THEN OPENED. THE VALUE OF OPEN IS THE FILE-ARRAY. EXAMPLES: (OPENI UREAD) RE-OPENS THE UREAD FILE, TO START AT THE BEGINNING AGAIN. (SEE "OLD I-O FUNCTIONS") (SETQ Z (OPENI '(NEW CLAP COM))) OPENS COM:NEW CLAP IN A FILE-ARRAY WHICH OPEN CREATES, AND PUTS IT IN Z. (OPENI 'Z '(NEW CLAP COM)) MAKES Z A FILE-ARRAY, AND OPENS COM:NEW CLAP IN IT. IT IS ADVISABLE TO HAVE OPEN GENSYM ALL FILE-ARRAYS, SO THAT THEY WILL BE UNINTERNED, AND THEREFORE SUBJECT TO GC; AND WILL AUTOMATICALLY BE CLOSED ANG GO AWAY WHEN NO LONGER NEEDED. THIS REQUIRES THAT EACH ONE BE PUT WHERE IT CAN BE FOUND WHEN IT IS RETURNED BY OPEN (E.G. BY SETING A VARIABLE TO IT, SELECTING OR ENABLING IT). SELECTION FOR INPUT: SINCE THERE CAN BE SEVERAL FILES OPEN FOR INPUT AT ONCE, AS WELL AS THE TTY, THERE EXISTS A SPECIAL MECHANISM FOR TELLING LISP WHICH INPUT SOURCE TO READ FROM. LISP REMEMBERS: A CURRENTLY SELECTED INPUT SOURCE; AND A STACK, ACTUALLY IN THE FORM OF A LIST, OF PREVIOUSLY SELECTED INPUT SOURCES WHICH HAVE BEEN PUSHED DOWN. AN INPUT SOURCE IS EITHER A FILE-ARRAY OPEN FOR INPUT, OR NIL FOR THE TTY. INPUT SOURCES ARE SELECTED BY THE SUBRS INSEL AND INPUSH. (INSEL X) SELECTS THE INPUT SOURCE X. (INPUSH X), WHERE X IS AN INPUT SOURCE,PUSHES THE CURRENTLY SELECTED INPUT SOURCE ONTO THE SELECTION STACK-LIST, AND THEN SELECTS X. (INPUSH 0) DOES NOTHING BUT RETURN THE CURRENTLY SELECTED SOURCE. (INPUSH -1) POPS THE FIRST INPUT SOURCE OFF THE SPECIAL STACK, AND SELECTS IT.(INPUSH -2) DOES THAT TWICE, ETC. (INPUSH 1) IS LIKE (INPUSH (INPUSH 0)) (INPUSH 2) DOES THAT TWICE, ETC. INSEL AND INPUSH ALWAYS RETURN THE INPUT SOURCE SELECTED WHEN THEY EXIT. ANY INPUSH OR INSEL THAT SELECTS THE TTY, EXCEPT (INPUSH 0), TURNS OFF THE ^Q SWITCH. IF THE ^Q SWITCH IS SET, ALL ORDINARY LISP INPUT FUNCTIONS TAKE THEIR INPUT FROM THE CURRENTLY SELECTED INPUT SOURCE. OTHERWISE, THEY READ FROM THE TTY, WHATEVER IS SELECTED. ENABLING FOR OUTPUT: IF A FILE IS TO BE WRITTEN ON, IT MUST FIRST BE ENABLED. LISP KEEPS RECORDS OF WHICH OUTPUT CHANNELS ARE ENABLED. ANY SET OF OUTPUT CHANNELS MAY BE ENABLED AT ONCE. (AN OUTPUT CHANNEL IS EITHER A FILE-ARRAY OPEN FOR OUTPUT, OR NIL FOR THE TTY) OUTPUT CHANNELS ARE ENABLED AND DISABLED WITH THE SUBR ENABLE. (ENABLE X T) ENABLES OUTPUT CHANNEL X (ENABLE X NIL) DISABLES IT ENABLE RETURNS NON-NIL IFF THE OUTPUT CHANNEL IS ENABLED. (ENABLEP X) RETURNS THE SAME THING. ALL ORDINARY LISP OUTPUT WILL GO TO ALL ENABLED FILE-ARRAYS IFF THE ^R SWITCH IS NON-NIL. OUTPUT WILL GO TO THE TTY IFF IT IS ENABLED. (NOTE: THE ENABLE SWITCH FOR THE TTY IS JUST (NULL ^W)) WHEN A FILE HAS BEEN COMPLETELY WRITTEN, IT MUST BE CLOSED TO WRITE OUT THE LAST BUFFERFULL. IT IS ADVISABLE TO CLOSE INPUT FILES ALSO, WHEN THEY ARE NO LONGER NEEDED. (CLOSE X) CLOSES THE FILE-ARRAY X, AND RETURNS IT. IN CASE IT WAS OPEN FOR INPUT: X IS DELETED FROM THE SELECTION STACK, AND IF IT IS SELECTED, (INPUSH -1) IS DONE TO DESELECT IT. IF X IS EQ TO UREAD, (SETQ UREAD NIL) IS DONE. SIMILAR FOR 'UWRITE, IN CASE WAS OPEN FOR OUTPUT. CLOSING A FILE-ARRAY NOT OPEN HAS NO EFFECT. CLOSING NIL IS AN ERROR. NEW LINE PRINTER OUTPUT FORMAT: TYPING CNTRL-B CAUSES OUTPUT TO THE LINE PRINTER AS FOLLOWS: (IF THE LPT IS NOT AVAILABLE, OUTPUT WILL BE TO TPL INSTEAD, AND " SPOOLING LPT " WILL BE PRINTED ON THE TTY IF IT (THE TTY) IS ENABLED) ALL S-EXPRESSIONS READ FROM THE TTY WILL BE PRINTED ON THE LPT, PRECEDED BY " * ". ORDINARY OUTPUT LINES WILL BE PRECEDED BY A TAB. THUS, THE FOLLOWING ON THE TTY: (PLUS 5 (REEADDAEAD))4 9 COULD CAUSE THE FOLLOWING ON THE LPT: * (PLUS 5 (READ)) * 4 9 THE LPT HAS NO FILE-ARRAY WHEN OPEN IN THIS MODE. THE USUAL I-O FUNCTIONS WON'T WORK ON IT. IT CAN BE DISABLED AND CLOSED ONLY BY TYPING ^E (OR EVALLING (IOC E), OF COURSE). THE SAME CHRCT AND LINEL ARE USED FOR THE TTY AND LPT. ORDINARY OUTPUT CAN BE DONE TO THE LPT BY OPENING IT NORMALLY. EOF HANDLING: NORMALLY, EOF CAUSES THE SELECTED FILE TO BE CLOSED, (AND THUS POPPED BY (INPUSH -1) WHICH CLOSE DOES). IF WITHIN (READ), (READCH), ETC., READING WILL CONTINUE WITH THE INPUT SOURCE WHICH IS THEN SELECTED. IF WITHIN (READ X), (READCH X), ETC., READING WILL STOP AND X WILL BE RETURNED. OTHER ACTIONS CAN BE OBTAINED BY GIVING A FILE-ARRAY A NON-NIL EOF FUNCTION. IF THAT IS DONE, THEN IF EOF OCCURS ON THAT FILE, THE EOF FUNCTION WILL BE CALLED WITH ONE ARG, WHICH WILL BE NIL IF THE READ, READCH ETC. IN PROGRESS HAD NO ARG, (LIST ARG) IF IT HAD ONE (WITHIN (READ X) IT WOULD BE (LIST X)). IF THE EOF FUNCTION RETURNS NIL, THE SELECTED INPUT SOURCE IS CLOSED, AND READING CONTINUES FROM THE SOURCE POPPED TO. IF IT RETURNS T, READING WILL CONTINUE IMMEDIATELY. (FROM THE SOURCE THE EOF FUNCTION LEFT SELECTED) OTHERWISE, THE SELECTED SOURCE WILL BE CLOSED, AND READ, READCH, ETC. WILL RETURN THE CAR OF WHAT THE EOF FUNCTION RETURNED. NEW STATUS AND SSTATUS CALLS: (STATUS ENABL) RETURNS A LIST OF ALL ENABLED OUTPUT CHANNELS. (SSTATUS ENABL X) CAUSES ONLY THOSE OUTPUT CHANNELS IN THE LIST X TO BE ENABLED. RETURNS X. THE FOLLOWING CALLS REFER TO THE DEFAULTS IF X IS NIL: (STATUS FILE X) WHERE X IS A FILE-ARRAY, RETURNS A LIST OF THE NAMES STORED IN X AS: (FN1 FN2 DEV SNAME). (SSTATUS FILE X Y) PUTS THE NAMES IN Y INTO THE FILE-ARRAY X. IF A NAME IN Y IS $$ (ALTMODE-ALTMODE), THE NAME IN X WON'T BE CHANGED. (STATUS RFILE X) WHERE X IS A FILE ARRAY WHICH IS NOT OPEN, IS EQUIVALENT TO (STATUS FILE X). BUT, IF X IS OPEN, THE NAMES OF THE FILE ACTUALLY OPEN ARE RETURNED. (SSTATUS RFILE X Y) LIKE (SSTATUS FILE X Y), BUT RETURNS (STATUS RFILE X). (STATUS EOFFN X) RETURNS X'S EOF FUNCTION (SSTATUS EOFFN X Y) SETS X'S EOF FUNCTION TO Y, RETURNS Y. (STATUS LINEL X) RETURNS X'S LINEL. THE TTY ALWAYS USES THE DEFAULT LINEL. (SSTATUS LINEL X Y) SETS X'S LINEL TO Y, RETURNS Y. IF A LINEL IS 0, NO EXTRA CRLF'S WILL BE OUTPUT. (STATUS CHRCT X) RETURNS X'S CHRCT. THERE IS NO DEFAULT CHRCT; (STATUS CHRCT NIL) RETURNS THE TTY'S CHRCT. (SSTATUS CHRCT X Y) SETS X'S CHRCT. (SSTATUS CHRCT NIL Y) SETS THE TTY'S CHRCT. (STATUS CHNUM X) RETURNS NON-NIL IFF X IS OPEN. (STATUS CHNUM NIL) IS NIL . OTHER NEW FUNCTIONS: RENAME -- SUBR. (RENAME X Y), WHERE X IS A FILE-ARRAY, RENAMES THE FILE OPEN IN X, OR THE FILE WHOSE NAMES ARE IN X, AS THE NAMES IN Y. THE NEW NAMES ARE PUT IN X, WHICH IS RETURNED. NAMES IN Y WHICH ARE $$ ARE LEFT UNCHANGED. IF X ISN'T OPEN, DEVICE AND SNAME CAN COME FROM Y. IF X IS OPEN, ANY DEVICE OR SNAME IN Y IS IGNORED. IF X IS A LIST OF NAMES, THEY ARE PUT OVER THE DEFAULT NAMES TO GET THE NAMES OF THE FILE TO BE RENAMED AS THE NAMES IN Y. IN THIS CASE, Y IS RETURNED. READFILE -- LSUBR. (READFILE X) RETURNS (READ), DONE WITH X TEMPORARILY SELECTED. (READFILE Y X) IS SIMILAR, BUT RETURNS (READ Y). MAKFIL -- SUBR. (MAKFIL X) MAKES THE ATOM X INTO A FILE-ARRAY, AND RETURNS IT. THE DEFAULTS ARE PUT INTO IT. TYI -- IS NOW AN LSUBR. CAN TAKE 0 OR 1 ARG, LIKE READCH. OLD I-O FUNCTIONS KEPT FOR COMPATIBILITY: (WITH EQUIVALENT DEFINITIONS) UREAD -- FSUBR. OPENS AND SELECTS FILE SPECIFIED IN GENSYMMED FILE-ARRAY, WHICH BECOMES VALUE OF ATOM 'UREAD. UPDATES DEFAULT NAMES. (LAMBDA (X) (SSTATUS FILE NIL X) (SETQ UREAD (INSEL (OPENI X))) (STATUS CRUNIT)) UWRITE -- FSUBR. OPENS AND ENABLES FILE .LISP. OUTPUT ON SPECIFIED UNIT. USES GENSYMMED FILE-ARRAY, WHICH BECOMES VALUE OF 'UWRITE. UPDATES DEFAULT UNIT (DEVICE AN SNAME). (LAMBDA (X) (SSTATUS CRUNIT X) (SETQ UWRITE (OPENO '(/.LISP/. OUTPUT))) (ENABLE UWRITE T) (STATUS CRUNIT)) UFILE -- FSUBR. CLOSES UWRITE FILE WITH SPECIFIED NAMES. UPDATES DEFAULT FILENAMES. RETURNS UNIT WRITTEN ON. (LAMBDA (X) (RENAME UWRITE X) (SSTATUS FILE NIL (STATUS FILE UWRITE)) (CDDR (STATUS FILE (CLOSE UWRITE)))) UKILL -- FSUBR. DELETES SPECIFIED FILE. UPDATES DEFAULT NAMES. (LAMBDA (X) (SSTATUS FILE NIL X) (RENAME (STATUS FILE NIL) '/ ) (STATUS CRUNIT)) CRUNIT -- FSUBR. SETS DEFAULT UNIT. RETURNS NEW DEFAULT. (LAMBDA (X) (SSTATUS FILE NIL (COONS $$ (CONS $$ X))) (STATUS CRUNIT)) OLD STATUS CALLS: STATUS CRUNIT -- RETURNS DEFAULT UNIT. (LAMBDA NIL (CDDR (STATUS FILE NIL))) SSTATUS CRUNIT -- EQUIVALENT TO CRUNIT. STATUS UREAD -- INDICATES WHETHER UREADING, GIVES NAME OF FILE BEING UREAD. (LAMBDA NIL (COND (UREAD (STATUS FILE UREAD)))) STATUS UWRITE -- INDICATES WHETHER UWRITING, GIVES UNIT BEING UWRITTEN ON. (LAMBDA NIL (COND (UWRITE (CDDR (STATUS FILE UWRITE))))) SSTATUS UREAD -- EQUIVALENT TO UREAD. SSTATUS UWRITE -- EQUIVALENT TO UWRITE. INCOMPATIBILITIES: THE ATOMS CHRCT AND LINEL NO LONGER HAVE SPECIAL MEANINGS IN LISP. THERE IS NOTHING WHICH HAS EXACTLY THEIR MEANING. THE DIS DEVICE -- NO LONGER HAS SPECIAL FACILITIES IN LISP. IT CAN BE WRITTEN ON WITH OPENO, OF COURSE. CNTRL-N AND CNTRL-O NO LONGER DO ANYTHING. (NOR (IOC N)) THE ATOM ^N HAS NO SPECIAL MEANING. UKILL -- NO LONGER FLAPS TAPES. * -- IS NO LONGER PRINTED OUT AFTER ERRORS. VIDI, VIDLIN, VIDLOG -- HAVE BEEN FLUSHED. 8/30/71 - JONL - OH, HAPPY DAY! LISP WILL NO LONGER GO AWAY WHEN THE GARBAGE COLLECTOR UNDERFLOWETH. INTERRUPT NUMBER TEN WILL CATCH AS CATCH CAN A LESS-THAN-MINIMAL AMOUNT OF STORETH. (SSTATUS GCMIN '(MINFS MINFXS MINFLS)) RESETS THE DEFAULT RATE WICH COMES TO YOU IN A LISP NEW AT 100, 20, AND EIGHT. A STATUS CALL CORRESPONDING TO GCMIN ALSO EXISTS, WHICH RETURNS A LIST SHOWING THE DEFAULT RATES FOR, IN ORDER, THE FREE STORAGE AREA, THE FIXNUM AREA, AND THE FLONUM AREA. IN ADDITION TO THE INTERRUPTION CAUSED BY FAILURE TO COLLECT ENOUGH SPACE, THE USERS INTERRUPT SERVICE FUNCTION (AS WELL AS A *RSET ERROR CATCHING FUNCTION) CAN COUNT ON HAVING AT LEAST THE MINIMAL AMOUNT OF FREE SPACE IN EACH STORE [BUT THIS DOES NOT APPLY RECURSIVELY TO UNDERFLOWS CAUSED BY THE SERVICE FUNCTION.] IN THE CASE OF THE SERVICE FUNCTION FOR INTERRUPT NUMBER TEN, IT WILL BE GIVEN AS ARGUMENT THE ATOM LIST, FIXNUM, OR FLONUM ACCORDING TO WHICH SPACE UNDERFLOWED. 8/30/71 - ECR - THERE IS A NEW NLISP (LISP VERSIONS 234 AND HIGHER) WHICH SHOULD BECOME THE SYSTEM LISP IN ABOUT A MONTH. ITS MAIN NEW FEATURE IS UNIFORM REPRESENTATION OFNUMBERS - THE INUM KLUDGE IS GONE. THE PURPOSE OF THIS CHANGE IS TO ALLOW THE COMPILER TO CONTAIN A FAST-ARITHMETIC FEATURE. THERE IS A NEW COMPILER, LISCOM VERSIONS 129 AND HIGHER, WHICH CAN OPEN-CODE ARITHMETIC EXPRESSIONS. SEE LISCOM NOTE. USERS SHOULD TAKE NOTE OF THE FOLLOWING , IN PREPARATION FOR THE DAY THAT NLISP BECOMES LISP: 1-IN NLISP , TWO NUMBERS MAY NOT BE EQ EVEN IF THEY ARE EQUAL. NEVER USE EQ FOR NUMBERS. USE EQUAL OR =. (SEE BELOW FOR AN EXPLANATION OF =.) 2-NLISP HAS A MULTIPLE I/O FEATURE. SEE NOTE BY RMS 3-THE ONLY COMPILER PRESENTLY AVAILABLE FOR USE WITH NLISP IS NLISCOM. OTHER VERSIONS OF THE COMPILER, NAMELY OLISCOM ,LISCOM , AND COMPLR WILL NOT PRODUCE CODE WHICH WILL RUN IN NLISP. IT IS EXPECTED THAT NLISP-COMPATIBLE VERSION OF COMPLR WILL BE AVAILABLE SHORTLY, BUT SINCE IT WON'T HAVE THE FAST-ARITHMETIC FEATURE, IT WILL STILL BE A LOSER. 4-THERE ARE SOME NEW ARITHMETIC OPERATIORS IN NLISP. +,-,*,/,1+,1-,\, ARE LIKE PLUS,DIFFERENCE, TIMES, QUOTIENT, ADD1,SUB1,REMAINDER, EXCEPT THAT THEY TAKE ONLY FIXNUM OPERANDS. SIMILARLY, +$,-$,*$,/$,1+$,1-$, TAKE ONLY FLONUM OPERANDS. (INCIDENTALLY, THESE ARE REAL DOLLAR SIGNS). THOUGH THESE WILL RUN A BIT FASTER THAN THEIR MORE FAMILIAR COUNTERPARTS, THEIR MAIN ADVANTAGE IS THAT THEY WILL ALWAYS BE OPEN-CODED BY THE COMPILER. THERE ARE ALSO THREE NEW SUBR'S, =,<,>. THEY ARE LIKE EQUAL, LESSP, AND GREATERP, EXCEPT THAT THEIR OPERANDS MUST BE NUMBERS OF THE SAME TYPE (BOTH FIXNUMS OR BOTH FLONUMS). AGAIN, THESE FUNCTIONS WILL ALWAYS BE OPEN-COMPILED. HOWEVER, = IS A WINNER EVEN WHEN RUNNING INTERPREIVELY, SINCE IT CAN BE EXPECTED TO RUN MUCH FASTER THAN EQUAL. 5-(ZEROP 0.0) NOW RETURNS T. 6-A POINTER ARITHMETIC SCHEME WILL SOON BE AVAILABLE IN NLISP FOR THOSE LOSERS WHO FOOLISHLY INSIST ON CONSING TOGETHER LOTS OF NUMBERS. 7- WITH NLISP, ALWAYS USE COM:NEW LAP OR COM:NEW CLAP FOR THE PROPER VERSIONS OF E LAP AND C LAP. 8/11/71 - JONL - FOR SOME TIME THERE HAS BEEN A WINNING, BUT AS YET UNADVERTISED, FEATURE IN THE TRACE PACKAGE. ONE MAY SPECIFY A TRACE OF THE FUNCTION FOO ONLY FOR THOSE CALLS TO FOO WHICH ARE DIRECTLY CALLED FROM THE FUNCTION BAR BY SAYING: (TRACE (FOO WHEREIN BAR . . .)) THE . . . TAKES THE PLACE OF THE REMAINDER OF THE TRACING SPECIFICATION, E.G. (TRACE (FOO WHEREIN BAR COND (NULL X) BOTH)) SUCH A TRACE IS REMOVED BY SAYING (UNTRACE (FOO WHEREIN BAR)) OR BY THE GENERAL UNTRACING OF SAYING (UNTRACE). SETQ NOW TAKES MULTIPLE PAIRS OF ARGUMENTS, AS IN (SETQ A 1 B 25 C A) THE ORDER OF EVALUATION IS SEQUENTIAL AS IF SEVERAL SETQ STATEMENTS HAD BEEN WRITTEN, SO THAT IN THE ABOVE EXAMPLE C WOULD ALSO BE GIVEN THE VALUE 1. INTERRUPT NUMBER 9 IN THE USER'S INTERUPT TABLE IS THE FUNCTION CALLED WHEN AN ERROR CAUSES RESTORE TO TOP LEVEL [AND *RSET = T] CURRENTLY IT IS (LAMBDA (*RSET) (IOG NIL (BREAK *RSET T))) THUS THE USER CAN CHANGE THIS FUNCTION AT WILL, AS WELL AS THE ^H BREAK INTERRUPT FUNCTION [INTERRUPT NUMBER 1]. THREE MORE STATUS GOODIES ARE AVAILABLE: (STATUS GCTIM) RETURNS THE TOTAL AMOUNT OF TIME (IN MICROSECONDS) SPEND IN GARBAGE COLLECTION. (SSTATUS GCTIM V) WILL RESET THIS COUNTER TO THE VALUE OF V. (STATUS TTY) IS THE SAME AS THE VALUE OF THE TOP LEVEL VARIABLE TTY - NAMELY NIL IF THE CURRENTLY ATTACHED CONSOLE IS A PRINTING TELETYPE, AND NON-NIL IF A DISPLAY-TYPE TERMINAL. (SSTATUS TTY N1 N2) HOWEVER, SETS THE TELETYPE WAKE-UP AND CONTROL CHARACTERISTICS FOR CHARACTERS TYPED ON THE JOB CONSOLE. SEE JONL OR A SYSTEM HACKER FOR MORE INFORMATION AS TO WHAT THIS MEANS. THERE IS A SIMULATED VIDISSECTOR AVAILABLE, WHOSE FEATURES HAVE YET TO BE SOLIDIFIED, BUT WHICH WILL BE SELECTED BY SOME SORT OF SSTATUS CALL SUCH AS (SSTATUS FTV T). JUST A REMINDER OF A FEW LITTLE UNDERSTOOD POINTS OF THE CURRENT LISP: (BREAK IDENTIFIER PREDICATE) AND (BREAK IDENTIFIER PREDICATE RETURNVALUE) BOTH WILL "BREAK" IF PREDICATE EVALUATES TO NON-NIL [OFTEN ONE SIMPLY MAKES PREDICATE = T]. A "BREAK" CAUSES IDENTIFIER TO BE PRINTED OUT, TELETYPE INPUT AND OUTPUT TO BE SELECTED, AND AN ERRSET-PROTECTED READ-EVAL-PRINT LOOP TO BE ENTERED. THE NORMAL EXIT IS OBTAINED BY TYPING THE ATOM P [NEEDS THREE STROKES OF THE KEYBOARD -

]. TYPING ^G WILL RESTORE TO THE TOP LEVEL OF LISP, BUT BECAUSE OF THE ERRSET PROTECTION, A ^X WILL SIMPLY RESTART THE BREAKLOOP OVER AGAIN. THE VALUE OF A BREAK IS EITHER THE VALUE OF RETURNVALUE AS IN THE SECOND EXAMPLE ABOVE, OR ELSE NIL. IF ONE TYPES ^G ANYTIME DURING THE ALLOCATION PHASE, THEN IT WILL BE RESTARTED; IF HE TYPES  , THEN IT WILL BE FORCED TO FINISH WITH THE REMAINING OPTIONS TAKEN FROM THE DEFAULT CASES. NUMBERS TYPED DURING THE ALLOCATION PHASE ARE TAKEN BASE EIGHT UNLESS SUFFIXED BY A DECIMAL POINT, IN WHICH CASE THEY ARE BASE TEN. IF ONE RESPONDS BY TYPING ^Q OR ^W AT THE REQUEST "ALLOC?", THEN HIS USER DISK FILE DIRECTORY IS SEARCHED FOR A FILE NAMED .LISP. (INIT) IF ONE EXISTS, IT IS OPENED AND THE ALLOCATION REQUESTS ARE TAKEN FROM THE FIRST S-EXPRESSION ON THE FILE, WHICH MUST BE OF THE FOLLOWIN FORMAT: (COMMENT CORE 34 FXS 1000 FLS 100 REGPDL 1400 SPECPDL 1000 FXPDL 400 FLPDL 10 BPS 600) NOT ALL OF THE QUANTITIES NEED BE TYPED, THE MISSING ONES BEING FILLED IN WITH THE DEFAULT VALUES. AFTER ALLOCATION, THIS FILE STILL REMAINS OPEN FOR READING AND BECOMES THE SOURCE OF INPUT FOR THE TOP LEVEL READ-EVAL-PRINT LOOP. THERE IS FINALLY A SUPER WINNING LISP COMPILER AVAILABLE AS SYS:TS COMPLR [OBTAINABLE BY TYPING COMPLR OR :COMPLR AT DDT] ITS VERSION NUMBER IS 200, AND WITH A FEW MINOR EXCEPTIONS IS USED JUST LIKE THE PREVIOUS COMPLR [WHICH WAS UNFORTUNATELY LOST IN A DISK CRASH MANY MOONS AGO.] LAP CODE COMPILED BY THE PREVIOUS COMPLR'S WILL PROBABLY NOT WORK CORRECTLY IN LISP 226, AND THE OUTPUT OF THE CURRENT TS COMPLR WILL NOT WORK CORRECTLY IN OLDER LISPS. THE EXCEPTIONS TO BE NOTED FOR USING COMPLR 200 ARE: 1) IF THE FUNCTION MAKLAP IS GIVEN ARGUMENTS, IT OPERATES JUST LIKE THE FUNCTION COMFILE OF LISCOM [SEE LISCOM NOTE]. OTHERWISE (MAKLAP) ENTERS A MODE AS DESCRIBED IN THE LISP ARCHIV DOCUMENTATION, TAKING A COMMAND STRING FROM THE TTY JUST AS MIDAS DOES. 2) THE FOLLOWING FUNCTIONS ARE AVAILABLE TO MAKE DECLARATIONS TO THE COMPILER: SPECIAL UNSPECIAL *EXPR *LEXPR *FEXPR GENPREFIX MACROS SYMBOLS A TYPICAL DECLARATION MIGHT LOOK LIKE (DECLARE (GENPREFIX PLNR) (SYMBOLS T) (MACROS T) (SPECIAL LDLST) (UNSPECIAL X) (PRINT '(QUOTE (STUFF TO GO INTO LAP FILE))) (READ) (COMMENT SWIPES THE NEXT S-EXPRESSION SO THE COMPILER CANT GET IT)) REMINDER: WHEN A FILE IS BEING COMPILED, NOTHING ON THE FILE IS EVAL'D EXCEPT THE ITEMS IN A DECLARE LIST. FUNCTION DEFINITIONS ARE COMPILED INTO LAP CODE, AND ALL OTHER S-EXPRESSIONS ARE MERELY READ IN AND PRINTED OUT ON THE OUTPUT FILE. SYS:TS INDEX IS NOW A COMPILED VERSION OF THE PHAMOUS WINSTON INDEXER [HOPEFULLY REPLETE WITH A COMPILED GRINDEFER TOO] ALSO OBTAINABLE BY TYPING AT DDT INDEX OR :INDEX 6/2/71 - JONL - THERE IS A NEW NLISP WHICH SHOULD BECOME THE SYSTEM LISP WITHIN A FEW SHORT WEEKS. NOTE WELL: ITEMS 1-4 BELOW DESCRIBE CHANGES THAT ARE AT VARIANCE WITH THE DOCUMENTATION OF THE PREVIOUS NLISP NOTE. 1) *** DELETED *** 2) SIGNP IS NOW A FSUBR. THE FIRST ITEM IN THE ARGLIST IS AN INDICATOR FOR COMPARISON TO ZERO, E.G., (SIGNP LE N) IS NON-NIL IF AND ONLY IF THE VALUE OF N IS A NUMBER LESS THAN OR EQUAL TO ZERO [SIGNP DOES NOT REQUIRE N TO BE OF NUMBER TYPE]. THE INDICATORS FOLLOW THE PDP-10 ARITHMETIC COMPARISON INSTURCTIONS, AND SHOULD BE SELF EXPLANATORY: - L E LE A GE N G 3) INTERRUPTING CONDITIONS WHICH THE USER MAY TRAP AND SERVICE WITH EXPR CODE HAVE BEEN EXPANDED, AND MODIFIED SLIGHTLY. IN ADDITION TO THOSE MENTIONED IN THE LAST NOTE, ON CAN NOW TRAP OUT ON UNDEFINED FUNCTION ERROR, UNBOUND VARIABLE ERROR, WRONG TYPE OF ARGUMENT ERROR, AND MISSING PROG TAG ERROR. IF THE USER'S SERVICE FUNCTION FOR THESE FOUR TRAPS RETURNS A NON-NIL VALUE, IT IS ASSUMED TO BE A LIST OF THE CORRECTED ITEM. THUS ONE MIGHT HAVE A FUNCTION OF THIS NATURE RETURN '(0) WHENEVER NIL SHOWS UP AS AN ARGUMENT TO PLUS [ETC]. ORDINARILY, ONE WOULD HAVE SUCH FUNCTIONS REQUEST SOME CONSOLE INTERACTION WITH THE USER, PERHAPS WITH THE FUNCTION BREAK, BUT ONE ANTICIPATED USE OF THE UNDEFINED FUNCTION TRAP IS TO SEARCH A FILE FOR A DEFINITION FOR THE FUNCTION AND LOAD IT IN IF FOUND. NOTE WELL: THE WAY IN WHICH INTERRUPT FUNCTIONS ARE SPECIFIED HAS CHANGED. DISREGARD THE DESCRIPTION IN THE PREVIOUS NOTE. TO SET A FUNCTION F [WHICH MUST BE A FUNCTION OF ONE ARGUMENT] TO SERVICE INTERRUPT NUMBER N, DO (SSTATUS INTERRUPT N 'F) . THE INTERRUPT CONDITIONS WHICH THE USER MAY TRAP ARE: NUMBER MEANING 1 -H TYPED ON JOB CONSOLE - CURRENTLY PRESET TO A SIMPLE BREAK BY THE SYSTEM. 2 -A TYPED ON JOB CONSOLE. NOT ALSO THAT THE VALUE OF THE ATOM ^A IS CHANGED BY THE TYPING OF -A REGARDLESS OF THE USER'S TRAP. 3 ALARMCLOCK EXPIRATION. 4 AN ERROR HAS OCCURRED WITHIN THE SCOPE ON AN ERRSET, AND THE ERRSET IS ABOUT TO RETURN A NIL. OTHERWISE, AN ERROR OCCURING UNDER AN ERRSET COMPUTATION WILL NOT ACTIVATE THE USER'S TRAP, BUT SIMPLY CAUSE THE ERRSET TO RETURN NIL. 5 UNDEFINED FUNCTION. 6 UNBOUND VARIABLE. 7 ARGUMENT NOT OF CORRECT TYPE. 8 ATTEMPTED GO TO A NON-EXISTANT PROG TAG. THE SERVICE FUNCTIONS FOR INTERRUPTS 1-4 CURRENTLY HAVE NIL GIVEN TO THEM AS ARGUMENT; BUT FOR INTERRUPTS 5-8 THE OFFENDING OBJECT IS PASSED ALONG AS ARGUMENT. SUGGESTIONS FOR FURTHER REFINEMENTS OF THIS SCHEME ARE INVITED FROM THE USING COMMUNITY. 4) THE FUNCTION BAKGAG IS NO LONGER WITH US, AND THERE IS NO MORE AUTOMATIC PRINT OUT OF A BACKTRACE WHEN AN ERROR OCCURS. HOWEVER, THE FUNCTIOPCKTRACE WILL STILL PRINT OUT A BACKTRACING, AND THE FUNCTIION OF *RSET HAS BEEN EXPANDED TO INCLUDE THAT OF THE PREVIOUS BAKGAG: WHENEVER A PROGRAM IS RUNNING IN *RSET MODE [SEE PREVIOUS NLISP NOTE], ADDITIONAL CRUFT IS STORED ON THE SYSTEM PDL SO THAT A (BAKTRACE) WILL BE WONDERFULLY CLEAR. 5) THERE IS A NEW FUNCTION: (EXPT X N) COMPUTES X TO THE NTH POWER, WHERE N IS A FIXED-POINT NUMBER AND X IS ANY NUMBER. IT RUNS FASTLY. 6) SOME IMPORTANT REMINDERS!! THE FOLLOWING ITEMS HAVE BEEN DOCUMENTED ELSEWHERE, BUT BECAUSE OF THE PREVALENCE OF MISUNDERSTANDING ABOUT THEM, THEY ARE REPRODUCED HERE. A) (MAKOBLIST NIL) RETURNS A LIST OF LISTS, LIKE THE OLD STYLE OBLIST. AN OBLIST IS NOT NORMALLY KEPT AROUND IN THE SYSTEM, BUT RATHER AN OBARRAY. (MAKOBLIST 'NEWOB) WILL COPY THE CURRENT OBARRAY AND ATTACH IT AS THE ARRAY PROPERTY OF THE ATOM NEWOB. ONE CAN LAMBDA-BIND AND SETQ THE ATOM OBARRAY IN ORDER TO CHANGE OBARRAYS. B) MAKNAM HAS NONE OF THE IDIOSYNCRATIC SYNTAX FEATURES OF THE FUNCTION READ. IT ALWAYS COMPRESSES A LIST OF CHARACTERS INTO A NEW ATOM WHICH IS NOT INTERNED ON THE OBARRAY. C) EXPLODE AND EXPLODEC ALWAYS BUT ALWAYS PRODUCE SINGLE CHARACERT PNAME-TYPE ATOMS. THUS (EXPLODEC 1.2) WOULD PRINT OUT AS (/1 /. /2) D) IF ONE USES > WITH UREAD, AS IN (UREAD FOO >), THEN (STATUS UREAD) WILL RETURN A LIST OF THE ACTUAL FILE NAMES AND DEVICE WHICH WOULD PRINT OUT AS, SAY, (FOO /12 DSK JONL) BUT A SUBSEQUENT CALL TO UFILE WITH NO ARGUMENTS (UFILE) WOULD CAUSE AN OPEN OUTPUT FILE TO BE FILED AWAY AS FOO 13 E) A MINOR GLITCH CONDITION HAS BEEN CORRECTED FOR SPLICING-TYPE READ MACROS; IF ONE IS ENCOUNTERED AT THE TOP-LEVEL READ [RATHER THAN WHILE READING THE ELEMENTS OF A LIST] THEN ITS VALUE IS IGNORED AND READ TRIES AGAIN. HENCE SUSSMAN'S SEMI-COLON MACRO WILL WORK AS DESIRED. 5/15/71 -JONL- LEAVE MAIL FOR JONL REGARDING BUGS. BE SURE TO USE NEW LAP WITH NLISP! THE CASUAL USER MAY RE-ADJUST TO NLISP [LISPS WITH VERSION NUMBER > 189] BY NOTING THE FOLLOWING QUICKIES: 1) THERE IS NO LONGER AN OBLIST, BUT RATHER AN INITIAL ARRAY CALLED OBARRAY. (MAKOBLIST NIL) PRODUCES AN OBLIST, AND (MAKOBLIST 'NEW) MAKES AN ARRAY OUT OF NEW AND COPIES THE CURRENT OBLIST INTO IT. 2) THE SUBR IOG HAS BEEN CONVERTED INTO AN FSUBR WHICH WORKES SIMILAR TO THE FOLLOWING: (DEFUN IOG FEXPR (L) ((LAMBDA (^W ^Q ^R ^B ^N) (COND ((CAR L) (APPLY 'IOC L))) (EVAL (CADR L))) NIL NIL NIL NIL NIL)) 3) IN CASE YOU HADN'T NOTICED, DO, LIKE PROG, RETURNS NIL AS ITS DEFAULT VALUE. PAGE 19 OF AI MEMO 190 [AN INTERIM LISP USERS GUIDE] SHOWS THAT THE DEFAULT RETURN VALUE IS THE VALUE OF THE INDEX UPON COMPLETION OF THE DO LOOP. ALSO, (STATUS MACRO C), IF NON-NIL, IS A 3-LIST CONTAINING IN ORDER THE ASSOCIATED FUNCTION, S OR NIL FOR SPLICING OR NOT, D OR NIL FOR DELAYED ACTION OR NOT [SEE AI MEMO 190, PAGE C2]. #### THE FOLLOWING HAS BEEN SUPERSEDED BY ENTRY OF 3/22/73 4) THE ATOM * HAS AS TOP LEVEL VALUE THE VALUE OF THE LAST THING COMPUTED IN THE TOP LEVEL LOOOOP. INITIALLY, BEFORE EVER ENTERING THE TOP LEVEL IT HAS VALUE '*, THUS WHEN RESTARTING BY G ONE WILL SEE A RANDOM * PRINTED OUT. THE PRESET PORTION OF THE TOP-LEVEL ROUTINE IS DEFINABLE AS FOLLOWS: (ERRSET (PROG NIL (SETQ ^Q NIL ^R NIL ^W NIL ^N NIL ^B NIL) (MAPC 'EVAL ERRLIST) A (PRINT *) (SETQ * (EVAL "TLF")) (GO A)) T) "TLF" IS THE PORTION THAT THE USER MAY CHANGE VIA SSTATUS, AND IS ORDINARILY DEFINABLE AS: (SSTATUS TOPLEVEL '(EVAL (READ))) BY WAY OF EXAMPLE, ONE COULD DEFINE EVALQUOTE THUSLY: (SSTATUS TOPLEVEL '(APPLY (READ) (READ)) ###THE PRECEEDING HAS BEEN SUPERSEDED BY ENTRY OF 3/22/73 5) CERTAIN REAL-TIME INTERRUPTS MAY BE SERVICED BY THE LISP USER WITH EXPR CODE. MORE WILL BE SAID ABOUT THIS BELOW, BUT FOR THE MOMENT, THE FOLLOWING GOODIE IS AVAILABLE AS A PRE-SET INTERRUPT SERVICE: WHEN ^H IS TYPED ON THE JOB COOONSOLE, THE STATE OF THE WORLD IS SAVED, (BREAK ^H T) IS EVAL'D, AND UPON EXIT FROM THE BREAK THE STATE OF THE WORLD IS RESTORED. THIS IS USEFUL IN FIGURING OUT WHY A LONG COMPUTATION IS TAKING SO LOOOOONG, SINCE ONE MAY INSPECT VALUES OF PROGRAM VARIABLES, CALL FOR A BAKTRACE, ETC. 6) *RSET NOW HAS A NEW FUNCTION IN LIFE! IF NON-NIL, THEN WHEN AN ERROR OCCURS, THE FORM (BREAK *RSET T) IS EVAL'D. CURRENTLY, PROCEEDING FROM THE BREAK CAUSES THE POP BACK TO TOP LEVEL AS BEFORE, BUT IN THE NEAR FUTURE, MANY ERRORS WILL REQUEST CORRECTIONS AND PROCEED ACCORDINGLY. SIMILARLY, MANY CONDITIONS NOW DEEMED TO BE ERRORS WILL MERELY BE NOTES TO THE USER. 7) RE*ARRAY HAS BEEN FLUSHED - INSTEAD USE *REARRAY. *REARRAY IS THE SUBR VERSION OF WHAT USED TO BE RE*ARRAY. *ARRAY IN THE LSUBR VERSION OR ARRAY. BAKTRACE HAS NO ARGUMENTS, AND CAUSES A BACKTRACEING TO BE PRINTED OUT. USEFUL WHEN IN A BREAK LOOP. TO SEE ANYTHING USEFUL, HOWEVER, ONE SHOULD REMEMBER TO SET THE BAKGAG SWITCH TO NON-NIL BEFOREHAND. [THE SYSTEM SAVES EXTRA STUFF WHEN IN BAKGAG MODE] NREVERSE IS A NO-CONSING VERSION OF REVERSE - IT RPLACD'S EACH CELL IN THE LIST IN ORDER TO TURN IT AROUND. ROT IS LIKE LSH, (ROT N M) DOES M CYCLES OF A 36-BIT LEFT-MOVING ROTATION ON THE NUMBER N. ASCII CREATES A SINGLE-CHARACTER ATOM WHOSE PNAME IS THE CHAR WITH ASCII VALUE OF THE ARGUMENT. FOR EXAMPLE, (ASCII 70.) IS THE ATOM F. RECLAIM GARBAGE-COLLECTS ITS FIRST ARGUMENT [EXCEPT FOR THE PNAME-TYPE ATOMS IN IT]. IF ITS SECOND ARGUMENT IS NIL, IT RE-COLLECTS ONLY LIST CELLS [AND NOT FIXNUM OR FLONUM CELLS]. ********* SECOND ARG TO RECLAIM DIFFERENT - 10/15/73 ******** (STATUS GCTIM) RETURNS THE TIME SPENT IN GARBAGE COLLECTION IN MICROSECONDS AS A FIXED POINT NUMBER. (STATUS MACRO . . .) NOW RETURN A LIST OF ONE OR TWO THINGS - THE FIRST IS THE ASSOCIATED FUNCTION OF THE MACRO CHARACTER, AND OPTIONALLY THERE WILL BE THE ATOMIC SYMBOL SPLICING TO DENOTE A SPLICING MACRO. (PURIFY LO HI T) PURIFYS THE PAGES FROM THAT ONE CONTAINING THE ADDRESS LO UP TO [INCLUDING] THAT ONE CONTAINING HI. SOMEDAY, A NIL 3RD ARG WILL SULLY THE PAGES [IE, DE-PURIFY THEM]. 8) THE BINFORD EDITOR HAS BEEN IN LISP FOR SOME TIME, BUT WAS UNDOCUMENTED [EXCEPT BY WORD OF MOUTH.] FOR THOSE WHO HAVE ALREADY USED IT, NOTE THAT IT HAS BEEN CHANGED EVER SO SLIGHTLY IN LISP 190] EVAL'ING (EDIT) ENTERS EDIT MODE, WHEREIN COMMANDS ARE GIVEN SIMILAR TO TECO COMMANDS, ACTION IS TAKEN ON SOME EXPRESSION CURRENTLY IN THE WORKING SPACE, AND A WINDOW AROUND THE POINTER IS PRINTED OUT AFTER EVERY COMMAND EXECUTION. (EDIT T) ENTERS EDIT MODE BUT DOES NOT TYPE OUT THE WINDOW AFTER EVERY COMMAND. [THE P COMMAND WILL CAUSE PRINTING OF THE WINDOW - USEFUL WHEN AT A TELETYPE]. COMMANDS ARE: Q EXIT FROM THE EDITOR BACK TO LISP. YATOM CAUSES THE FUNCTION PROPERTY OF ATOM TO BE BROUGHT IN FOR EDITING. YPATOMPROP YANK IN THE PROP PROPERTY OF THE ATOM ATOM. YPATOM YANKS THE WHOLE PROPERTY LIST OF ATOM. J CAUSES THE POINTER [WHICH IS PRINTED OUT AS ] TO JUMP TO THE TOP OF THE WORKING EXPRESSION. SE1 . . . EN SEARCHES FOR AN OCCURENCE OF THE SEQUENCE OF S-EXPRESSIONS E1 . . . EN AND MOVES THE POINTER JUST TO THE RIGHT IF SUCCESSFUL. NOTE THAT THE LISP READER IS USED FOR READ-IN BY THE EDITOR, SO THAT THE ATOM MUST BE FOLLOWED BY SOME ATOM TERMINATING CHARACTER [SUCH AS ]. IE1 . . . EN INSERTS AT THE CURRENT POINTER POSITION THE SEQUENCE E1 . . . EN K KILLS THE S-EXPRESSION JUST TO THE RIGHT OF THE POINTER, AND SAVES IT AS THE VALUE OF THE ATOM . IVEXP INSERTS THE VALUE OF THE S-EXPRESSION EXP. ESPECIALLY USEFUL WHEN INSERTING STUFF DELETED FROM SOME PRIOR POINT. EVEXP MERELY EVALUATES EXP. HENCEFORWARD, WILL NOT BE EXPLICITLY WRITTEN OUT, BUT WILL BE UNDERSTOOD TO BE THE COMMAND TERMINATION CHARACTER. THE NEXT GROUP OF COMMANDS ADMIT AN OPTIONAL NUMERIC ARGUMENT [BASE 10.], PRECEEDING THE COMMAND, TO BE INTERPRETED AS A REPLICATION NUMBER: F MOVE FORWARD [RIGHTWARDS] PAST ONE TOKEN. A TOKEN IS EITHER A PARENTHESIS OR AN ATOM. C SAME AS F -B SAME AS F B MOVE BACK [LEFTWARDS] OVER ONE TOKEN. -C SAME AS B -F SAME AS B R MOVE RIGHTWARDS PAST THE NEXT S-EXPRESSION. L MOVE LEFT OVER ONE S-EXPRESSION. D MOVE "DOWN" INTO THE FIRST NON-ATOMIC S-EXPRESSION TO THE RIGHT OF THE POINTER. U MOVE "UP" OUT OF THE S-EXPRESSION CONTAINING THE POINTER. K KILL ALSO ADMITS A REPLICATION NUMBER. PW ARG IS NOT REALLY A REPLICATION NUMBER, BUT RATHER THE "WINDOW WIDTH" IN NUMBER OF TOKENS. THE FOLLOWING LITTLE USED COMMANDS MAY POSSIBLY BE OF SOME INTEREST: ( INSERT A VIRTUAL OPEN PARENTHESIS. ) INSERT A VIRTUAL CLOSE PARENTHESIS. D( VIRTUALLY DELETE AN OPEN PARENS D) VIRTUALLY DELETE A CLOSE PARENS () RESTRUCTURE THE WORKING S-EXPRESSION ACCORDING TO THE VIRTUAL PARENTHESES AND DELETIONS. 9) THE PICPAC STUFF HAS BEEN DROPPED [PICARRAY, READPIC, WRITEPIC]. ANYONE INTERESTED IN ITS REVIVAL SHOULD CONTACT JONL. 10) THAT OLD BUG IN PRINT HAS BEEN CHANGED; IE, IF "/" IS THE LAST CHARACTER OUTPUTTD BEFORE AN INTERNALLYY GENERATED CARRIAGE RETURN, THEN THE NEXT CHARACTER TO BE PRINTED IS SQUEEZED IN BEFORE THE CR. THUS IT IS POSSIBLE TO HAVE LINEL+1 CHARACTERS APPEAR ON SOME LINE. 11) ANYONE HAND-CODING IN LAP WMUST TAKE NOTE THAT THE FOLLOWING SYSTEM ROUITINES WHICH USED TO BE CALLED BY A PUSHJ P, ARE NOW CALLED BY A JSP T, NUMVAL FIX1A FWCONS FPCONS FLOAT IS NOW CALLED IFLOAT, AND SIMILARLY THERE IS A LABEL IFIX. FIX1A, IFLOAT, IFIX, FWCONS, AND FPCONS ALL TAKE THEIR ARGUMENT IN ACUMULATOR TT INSTEAD OF A AS BEFORE; NUMVAL, IFLOAT, AND IFIX PRODUCE THEIR RESULT IN ACCUMULATOR TT. THERE ARE LABELS FIX1 AND FIX2 IN THE FOLLOWING SEQUENCE: FIX2: JSP T,IFIX FIX1: JSP T,FIX1A POPJ P, SIMILARLY, THERE ARE LABELS FLOAT2 AND FLOAT1. 12) MORE ON USER PROGRAMMABLE INTERRUPTS: BY DOING A (SSTATUS INTERRUPT N '(PRINT 'NOW/ IS/ THE/ TIME)) IN THE NTH ENTRY OF THE USER INTERUPT TABLE, THE FORM (PRINT . . .) IS TO BE EVAL'ED. GENERALLY, IF NO SUCH DECLARATION HAS BEEN MADE, THEN THE INTERRUPT IS IGNORED. CURRENTLY THERE ARE ONLY FOUR ENTRYS IN THE USER INTERRUPT TABLE: 1 ^H TYPED ON JOB CONSOOOLE 2 ^A TYPED 3 ALARMCLOCK TIMER EXPIRED 4 AN ERROR OCCURED IN AN ERRSET COMPUTATION, AND ERRSET IS ABOUT TO RETURN NIL BECAUSE OF IT. (ALARMCLOCK N) SETS THE ALARMCLOCK TIMER TO GO OFF [PROVIDE AN INTERRUPT] IN N MICROSECONDS [+- 5%]; (ALARMCLOCK NIL) TURNS OFF THE FOOL THING IN CASE IT HAD BEEN PREVIOUSLY SET. 9/24/69 - JONL THE LONG-AWAITED "FAST" NUMBER SCHEME IS IMPLEMENTED AND WILL MAKE ITS DEBUT IN THE NEXT NEW LISP, PROBABLY TO BE NUMBER 120. THE MAJOR NON-COMPATIBLE CHANGE IS IN THE REPRESENTATION OF NUMBERS; NO LONGER ARE THEY ATOMIC STRUCTURES IN FREESTORAGE WHOSE CDDR IS A POINTER INTO FULL WORD SPACE, BUT RATHER THEY ARE POINTERS DIRECTLY INTO FULL WORD SPACE. "INUM"S STILL ARE USED FOR REPRESENTING INTEGERS LESS THAN ABOUT 5000., BUT THIS KLUDGE MAY GO AWAY IN FAVOR OF UNIFORMITY. "ATOM" IS STILL TRUE FOR NUMBERS, AND FULL WORD SPACE IS FURTHER SUBDIVIDED INTO A FIXNUM AREA AND A FLONUM AREA. HOWEVER, ONE SHOULD NOT COUNT ON THIS DIVISION OF MEMORY REMAINING FOR VERY LONG, SINCE I HAVE A PLAN TO INCORPORATE ALL THREE AREAS INTO ONE HOMOGENEOUS SPACE WITH FULL WORDS DISTINGUISHED BY SOME EXTRA BITS. SINCE LAP USES SOME EXPR CODE WHICH IS DEPENDENT ON THE REPRESENTATION OF NUMBERS, IT WILL BE NECESSARY TO USE THE NEW LAP TO BE SUPPLIED AT THE SAME TIME AS THE APPEARANCE OF LISP 120, PROBABLY THIS WILL HAVE LAP NUMBER 17; IF THERE ARE ANY OTHER PROGRAMS AROUND WHICH REALLY DEPEND ON THE INTERNAL STRUCTURE OF BIG FIXNUMS OR FLONUMS, THEY WILL HAVE TO BE MODIFIED. BE PREPARED! ANOTHER INCOMPATIBLE CHANGE IS IN THE CALL TO PLOTLIST; THE FIRST ARGUMENT IS NOT JUST AN ARRAYNAME, BUT A LIST OF SPECIAL ARRAY CELLS, IDENTICAL TO THE FORM OF THE DISLIST. THE SECOND (OPTIONAL) ARGUMENT REMAINS UNAFFECTED. THUS ONE COULD SAY "(PLOTLIST DISLIST)". THE FUNCTION IPL HAS GONE AWAY, AND IN FACT IS NO LONGER NEEDED. THE SUBR "PLOT" EXPECTS ITS ARGUMENT TO FOLLOW THE NEW SPECINER CONVENTION AS POSTED ABOVE THE PLOTTER MACHINE AND RECORDED IN DSK:MS;IPL DESC THE SUBR "PLOTTEXT" HAS BEEN ADDED TO PLOT THE CHARACTERS OF THE ARGUMENT AS THEY WOULD BE "PRINC"ED OUT. TWO NEW OPTIONS ARE AVAILABLE UNDER THE FUNCTION "STATUS" - (STATUS TIME) RETURNS A LIST OF THREE NUMBERS TO BE INTERPRETED AS HOURS, MINUTES, AND SECONDS OF THE DAY'S TIME; (STATUS DATE) RETURNS A 3-LIST OF THE YEAR, MONTH, AND DAY AS NUMBERS. IN EACH CASE, IF ITS CANNOT DETERMINE THE REQUIRED INFORMATION, NIL IS RETURNED. THE LSUBR "MACDMP" WILL ACCEPT A LITERAL ATOM AS AN ARGUMENT, AND GIVE THE STRING OF CHARACTERS OF ITS PNAME TO DDT TO BE EXECUTED AS A COMMAND STING. IT WILL ALSO CAUSE A LOGOUT IF THE JOB IN WHICH IT IS CALLED IS DISOWNED. EXAMPLE: (MACDMP (QUOTE ///.)) THREE FUNCTIONS HAVE BEEN ADDED TO THE LAP GROUP IN ORDER TO FACILITATE COMMUNICATION WITH DDT: "GETDDTSYM" RETURNS THE DDT SYMBOL TABLE VALUE OF ITS ARGUMENT, "PUTDDTSYM" MAKES AN ENTRY INTO THE DDT SYMBOL TABEL, AND "GETMIDASOP" DECODES A SYMBOL AS AN OPERATION IF IT IS ONE. "PUTDDTSYM" RETURNS T, AND THE OTHERS RETURN NIL IF THEY FAIL. EXAMPLES: (GETDDTSYM (QUOTE LISPGO)) (PUTDDTSYM (QUOTE FOOBAR) 105) (GETMIDASOP (QUOTE HRRZ)) THE S-EXPRESSION EDITING SYSTEM OF TOM BINFORD IS NOW A REGULAR PART OF THE SYSTEM. A MEMO SHOULD BE COMING OUT SOON ON ITS USE; IT IS VERY MUCH LIKE USING TECO WHILE IN LISP. A LOT OF MINOR GLITCHES HAVE BEEN REPAIRED, BAKTRACE IS A LOT MORE MEANINGFUL, AND FEWER KINDS OF ERRORS ARE IN THE "UNRECOVERABLE" CATEGORY WHICH CANNOT BE ERRSET. ALSO, LISP HAS BEEN PUT INTO PURE PROCEDURE FORM SO THAT WHEN THE NEW PAGING SCHEME IS IMPLEMENTED IN THE HARDWARE, THERE WILL NEED TO BE ONLY ONE LISP SYSTEM RESIDENT IN CORE, WITH EACH USER HAVING HIS PRIVATE MEMORY FOR STORAGE CELLS AND FREESTORAGE. 7/6/69 22:16 JONL LISP 105 HAS THE LONG AWAITED NEW READER, WHOSE MOST NOTABLE FEATURE IS CHARACTER-BY-CHARACTER RUBOUT FROM THE JOB CONSOLE. RUBOUTS AND NON-SLASHIFIED CONTROL CHARACTERS ARE IGNORED ON INPUT FROM TAPE OR DISK; SLASHIFIED CONTROL CHARACTERS TYPED ON THE TTY HAVE NO CONTROL EFFECT [MAYBE!!!]. A LIMITED PROGRAMMABLE SYNTAX FEATURE IS AVAILABLE FOR READ, TO BE DESCRIBED IN A FORTHCOMING COMPREHENSIVE DOCUMENT ON LISP IN GENERAL, AND PDP-6/10 LISP IN PARTICULAR. ALL SYNTAX PROPERTIES ARE UNDISTURBED IN THE STANDARD LISP, EXCEPT THE CHARACTER WHICH HAS THE FOLLOWING FUNCTION: 'SEXP IN THE INPUT STRING, IS EQUIVALENT TO THE APPEARANCE OF (QUOTE SEXP) FOR ALL S-EXPRESSIONS SEXP. SUCH FUNCTION IS AN INSTANCE OF A MUCH MORE GENERAL SYNTAX ABILITY, FOR THE PRESENT CALLED "MACRO CHARACTERS". NOTE ALSO THAT THE OF-LATE-INFAMOUS SYNTAX PROPERTIES OF THE CHARACTERS + AND - ARE RESCINDED UNLESS THE USER RE-INSTATES THEM BY MEANS OF THE FUNCTION "SSTATUS" (SEE BELOW). THE USER MAY ALSO RESCIND THE MACRO PROPERTY OF DESCRIBED ABOVE, OR DEFINE SIMILAR PROPERTIES FOR OTHER CHARACTERS. THE FUNCTION "*REARRAY" EXISTS FOR THE PURPOSE OF RE-DEFINING THE SPACE OCCUPIED BY AN ARRAY (OR EVEN ITS ACCESSING FUNCTION). THE ARGUMENTS ARE GIVEN TO "*REARRAY" EXACTLY AS TO "ARRAY", EXCEPT THAT *REARRAY IS AN LSUBR AND THE FIRST ARGUMENT IS EVALUATED. ALSO, THE FRIST ARG MUST HAVE ALREADY BEEN DECLARED AN ARRAY. IF ONLY THE ARRAY NAME IS GIVEN AS ARGUMENT, THEN IT IS DIS-ARRAYED. THE ALLOCATOR NOW PRINTS OUT THE DEFAULT ALLOCATIONS WHEN ONE ASKS TO ALLOCATE. FULL WORD SPACE IS ASSIGNED AN AMOUNT EQUAL TO ABOUT 1/64TH OF THE AMOUNT OF FREE STORAGE AVAILABLE; THEN ADDED TO THIS IS THE NUMBER ASSOCIATED WITH ALLOC TAG "FWS". "PDL" IS THE TAG FOR THE REGULAR PDL; "SPDL" IS FOR THE SPECIAL PDL. EXCEPT IN THE MINI-LISP (NOT YET AVAILABLE) AND IN NON-TS LISP, THE ALLOCATOR DOES NOT ASK FOR "BPS" (BINARY PROGRAM SPACE) SINCE THIS AREA IS SHARED WITH ARRAYS AND IS DYNAMICALLY HANDLED (SEE PREVIOUS DOCUMENTATION ON LISP INFO REGARDING NEW IMPLEMENTATION OF ARRAYS AND OF THE FUNCTION "RETSP"). ANY ATOM BREAK CHARACTER WILL SUFFICE TO TERMINATE NUMBERS TYPED AT THE ALLOCATOR, AND IF THE BREAKER IS , THEN THE NUMBER IS CONVERTED TO BASE TEN (RATHER THAN EIGHT). TYPING WILL CAUSE THE ALLOCATOR TO RESTART. A FEATURE HAS BEEN IMPLEMENTED TO UTILIZE A KIND OF .LISP. (INIT) FILE IN THE USERS DSK FILE DIRECTORY BUT THE WHOLE STORY WILL HAVE TO WAIT UNTIL THE NEXT BIG CHANGE IN LISP; USERS WHO MIGHT LIKE TO USE SOME SUCH FEATURE, PLEASE SEE JONL. FUNCTIONS CALLED "STATUS" AND "SSTATUS" ARE IMPLEMENTED TO AID IN QUERYING THE STATUS OF CERTAIN SYSTEM VARIABLES AND CONDITIONS, AND IS CHANGING OR SETTING THOSE CONDITIONS. A COMPLETE DESCRIPTION OF FACILITIES WILL APPEAR IN THE FORTHCOMING COMPREHENSIVE LISP GUIDE - MANY FEATURES ARE NOT AVAILABLE IN ANY OTHER FASHION IN PREVIOUS LISPS, BUT SOME ARE INTENDED MERELY TO STOP THE PROLIFERATION OF ATOMS USED AS SYSTEM VARIABLES. 5/6/69 22:16 JONL PDL OVERFLOWS AND FREE-STORAGE EXHAUSTION ARE NOW ERRSETABLE AND BAKGAGABLE. SUBLIS WORKS WELL, AS PER PAGE 12. OF THE LISP 1.5 PROGRAMMERS MANUAL. IF THE FIRST ARGUMENT HAS MULTIPLE ENTRIES FOR THE SAME ATOM, THE ENTRY CLOSEST TO THE HEAD OF THE LIST WILL BE USED IN THE SUBSTITUTION. E.G., (SUBLIS (QUOTE ((A.B)(C.(D E))(A.F))) (QUOTE (X A Y C Z))) EVALS TO (X B Y (D E) Z). 4/25/69 JONL 1500PM LISP 104 HAS TWO NEW FEATURES, DESCRIBED BELOW, IN ADDITION TO CORRECTIONS FOR LONG LOST BUGS IN THE UUO HANDLER. APPLY HAS BEEN GENERALIZED TO WORK FOR FSUBRS AND FEXPRS - (APPLY F L) WILL DO THE SAME THING AS (EVAL (CONS F L)) IF F IS AN F-TYPE FUNCTION, AND WILL OPERATE AS NORMAL IF F IS NOT F-TY PE. SUBLIS AS DESCRIBED ON P.12 OF THE LISP 1.5 MANUAL HAS BEEN IMPLEMENTED. IT COPYS ONLY AS MUCH OF THE SUBSTITUTED-INTO S-EXPRESSION AS IS NECESSARY TO PERFORM THE SUBSTITUTIONS. IT ALSO UTILIZES A FEW TRICKS TO KEEP RUNNING TIME VERY LOW. IF WHAT ONE IS SUBSTITUTING FOR IS AN ATOM, THEN SUBLIS IS PROBABLY A BETTER FUNCTION TO USE THAN SUBST. HOWEVER, (SUBST NIL NIL L) IS STILL THE ONLY FAST WAY TO COMPLETELY COPY THE S-EXPRESSION L. 3/1/69 JONL THE CURRENT VERSION OF LISP, "LISP 102", HAS THE FOLLOWING AS-YET UNDOCUMENTED FEATURES: 1)"DEFUN" IS AN FSUBR USED TO DEFINE FUNCTIONS. EXAMPLES ARE (DEFUN ONECONS (X) (CONS 1 X)) WHICH IS EQUIVALENT TO (DEFPROP ONECONS (LAMBDA (X) (CONS 1 X) EXPR) AND (DEFUN SMASH FEXPR (L) (RPLACD L NIL)) IS EQUIVALENT TO (DEFPROP SMASH (LAMBDA (L) (RPLACD L NIL)) FEXPR) THE NOVEL FEATURE OF "DEFUN" IS THAT ONE NEED NOT BE SO CONCERNED WITH BALANCING PARENTHESES AT THE VERY END OF THE FUNCTION DEFINITION, SINCE THE TYPE FLAG MAY BE OMITTED IF IT IS "EXPR", AND APPEARS NEAR THE FRONT OF THE "DEFUN" LIST IF IT IS SOME OTHER. ALSO, THE "LAMBDA" NEED NOT BE DIRECTLY INSERTED. 2)A FAST "DO" SIMILAR TO THE FORTRAN DO FEATURE NOW EXISTS. THE SYNTAX IS (DO ATOM INITIALVALUE STEPFUN ENDTEST STATEMENT1 . . . STATEMENTN) WHERE "ATOM" IS THE INDEX VARIABLE OF THE LOOP, WHICH IS INITIALLY SET TO THE EVALUATION OF "INITIALVALUE", AND IS RESET EACH PASS THROUGH THE LOOP TO THE EVALUATION OF "STEPFUN". "STATEMENT1" TO "STATEMENTN" COMPRISE A REGULAR PROG BODY (EXCEPTING THE LIST OF PROG VARIABLES) WHICH IS EXECUTED REPEATEDLY UNTIL "ENDTEST" EVALUATES TO NON-NIL. FOR EXAMPLE, (DO I 0 (ADD1 I) (EQ I 400) (COND ((NULL (A I)) (GO B))) (PRINT (A I)) B (SETQ TOTAL (PLUS TOTAL (A I)))) ************* THERE ARE TWO OTHER DO FORMATS NOW ALSO ****** 3) A PSEUDO-RANDOM NUMBER GENERATOR CALLED "RANDOM" EXISTS AS A FUNCTION OF NO ARGUMENTS. ITS RANDOMICITY WILL VARY AS TIME GOES BY, AND AS VARIOUS RANDOM ALGORITHMS ARE TRIED OUT. CURRENTLY IT IS SOME RANDOM SHIFT REGISTER SEQUENCE. 4)"CRUNIT" MAY BE USED TO OBTAIN A LIST WHOSE FIRST MEMBER IS THE NAME OF THE MOST RECENTLY SELECTED USER-I/O-DEVICE, AND WHOSE SECOND MEMBER IS THE CURRENT USER SYSTEM NAME. IF THERE ARE ARGUMENTS, THE CURRENT DEVICE IS UPDATED IN EXACTLY THE SAME MANNER AS WITH "UREAD", BUT THE FILE IS NOT OPENED. ONE SHOULD REVIEW PREVIOUS DOCUMENTATION ABOUT OMITTING ARGUMENTS OF UREAD,UWRITE AND UFILE. 5) "GO" AND "RETURN" HAVE BEEN FIXED TO OPERATE IN ACCORD WITH ONE'S INTUITION ABOUT SUCH FUNCTIONS: THEY HAPPEN WHEN EVALUATED BY THE INTERPRETER, AS OPPOSED TO THE PREVIOUS RANDOM IMPLEMENTATION. HENCE THERE SHOULD BE NO DIFFERENCE BETWEEN INTERPRETED CODE AND COMPILED CODE ON THIS MATTER. 6) "LAMBDA" HAS BEEN GENERALIZED SUCH THAT "(LAMBDA (L) E1 E2 . . . EN)" EVALUATES LIKE "(LAMBDA (L) (PROG NIL E1 E2 . . . (RETURN EN))" 7) "ERRSET", WHEN GIVEN A SECOND ARGUMENT, NOW WORKS AS SPECIFIED IN THE LISP 1.5 PROGRAMMERS MANUAL, I.E. ERROR COMMENTS ARE GIVEN ONLY IF THE SECOND ARG EVALUATES TO NON-NIL. WITHOUT THE SECOND ARG, ERROR COMMENTS ARE ALWAYS PRINTED.