diff --git a/Makefile b/Makefile index 59b2f438..e00146a8 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,6 @@ EMULATOR ?= simh -SRC = system syseng sysen1 sysen2 sysnet kshack dragon channa midas _teco_ emacs rms klh syshst sra mrc ksc cstacy gren bawden emacs1 _mail_ l lisp liblsp libdoc +SRC = system syseng sysen1 sysen2 sysnet kshack dragon channa midas _teco_ emacs rms klh syshst sra mrc ksc cstacy gren bawden emacs1 _mail_ l lisp liblsp libdoc comlap DOC = info _info_ sysdoc kshack _teco_ emacs emacs1 MINSYS = _ sys sys2 sys3 device emacs _teco_ sysbin inquir diff --git a/README.md b/README.md index a422f09d..9b66641e 100644 --- a/README.md +++ b/README.md @@ -100,6 +100,7 @@ from scratch. - DQ Device, for doing hostname resolutions. Used by COMSAT. - DSKUSE, disk usage information. - LISP, lisp interpreter and runtime library (autoloads only) + - COMPLR, lisp compiler 6. A brand new host table is built from the host table source and installed into SYSBIN; HOSTS3 > using H3MAKE. diff --git a/build/build.tcl b/build/build.tcl index 2bdc2442..731b9637 100644 --- a/build/build.tcl +++ b/build/build.tcl @@ -493,16 +493,37 @@ respond "*" ":load .temp.;*lisp bin\r" respond "*" "\033g" respond "*" "purify\033g" respond "*" ":pdump sys;purqio >\r" +respond "*" ":kill\r" respond "*" ":link sys;ts lisp,sys:purqio >\r" respond "*" ":link sys;ts q,sys;purqio >\r" respond "*" ":link sys;atsign lisp,sys;purqio >\r" +respond "*" ":link sys;ts l,sys;ts lisp\r" respond "*" ":link .info.;lisp step,.info.;step info\r" respond "*" ":link libdoc;struct doc,alan;struct doc\r" respond "*" ":link .info.;lisp struct,libdoc;struct doc\r" respond "*" ":link l;-read- -this-,lisp;-read- -this-\r" +# lisp compiler +respond "*" ":link comlap;complr fasl,comlap;cl.fas >\r" +respond "*" ":link comlap;phas1 fasl,comlap;ph.fas >\r" +respond "*" ":link comlap;comaux fasl,comlap;cx.fas >\r" +respond "*" ":link comlap;faslap fasl,comlap;fl.fas >\r" +respond "*" ":link comlap;maklap fasl,comlap;mk.fas >\r" +respond "*" ":link comlap;initia fasl,comlap;in.fas >\r" +respond "*" ":link comlap;srctrn fasl,comlap;st.fas >\r" +respond "*" ":print lspdmp;..new. (udir)\r" +type ":vk\r" +respond "*" "lisp\013" +respond "Alloc?" "n\r" +respond "*" "(load \"comlap;ccload\")" +respond ";BKPT CCLOAD:DUMPVERNO" "(setq ccload:dumpverno 2154)" +respond "2154" "(return)" +respond "*" ":kill\r" +respond "*" ":link sys;ts complr,lspdmp;cl.dmp >\r" +respond "*" ":link info;complr 1,info;lispc >\r" + # ndskdmp tape respond "*" ":link kshack;good ram,.;ram ram\r" diff --git a/src/comlap/ccload.193 b/src/comlap/ccload.193 new file mode 100755 index 00000000..b28a048e --- /dev/null +++ b/src/comlap/ccload.193 @@ -0,0 +1,585 @@ +;;; CCLOAD -*-LISP-*- +;;; ************************************************************** +;;; ***** Maclisp ****** CCLOAD - Loader for COMPLR ************** +;;; ************************************************************** +;;; ** (c) Copyright 1981 Massachusetts Institute of Technology ** +;;; ****** this is a read-only file! (all writes reserved) ******* +;;; ************************************************************** + +(comment CORE 80. BPS 16000.) + +;This will compose a MACLISP compiler from the following files: +; LISP; BACKQ FASL (BACKQ.FAS on TOPS-10/20 systems) +; LISP; DEFMAC FASL (DEFMAC.FAS on TOPS-10/20 systems) +; LISP; DEFMAX FASL (DEFMAX.FAS on TOPS-10/20 systems) +; LISP; MACAID FASL (MACAID.FAS on TOPS-10/20 systems) +; LISP; MLMAC FASL (MLMAC.FAS on TOPS-10/20 systems) +; LISP; ERRCK FASL (ERRCK.FAS on TOPS-10/20 systems) +; LISP; GETMID FASL (GETMID.FAS on TOPS-10/20 systems) +; LISP; SHARPM FASL (SHARPM.FAS on TOPS-10/20 systems) +; LISP; SETF FASL (SETF.FAS on TOPS-10/20 systems) +; LISP; LET FASL (LET.FAS on TOPS-10/20 systems, except +; for Stanford system where not used) +; COMLAP;COMPLR FASL (COMPLR.FAS on TOPS-10/20 systems) +; PHAS1 FASL (PHAS1.FAS on TOPS-10/20 systems) +; COMAUX FASL (COMAUX.FAS on TOPS-10/20 systems) +; INITIA FASL (INITIA.FAS on TOPS-10/20 systems) +; MAKLAP FASL (MAKLAP.FAS on TOPS-10/20 systems) +; FASLAP FASL (FASLAP.FAS on TOPS-10/20 systems) +;Additionally, a gc-daemon and many other help files are loaded in the +; SAIL version. +;Ordinarily, this file will be used as an "INIT" file, but it can be +; directly loaded into a running lisp, using any of LOAD, or UREAD. + +;Ordinarily the result will be :PDUMPI'd (by SUSPEND) as +; LSPDMP;CL.DMP [there is a link on SYS for TS COMPLR +; to LSPDMP;CL.DMP >] +; however, if (STATUS FEATURE EXPERIMENTAL) is non-null, then they +; will go out as LSPDMP;XC.DMP . Thus there is a link +; for XCOMPLR to LSPDMP;XC.DMP > + + +;;; Following code must come before everything else, so that only the +;;; important symbols get on the copy of the initial OBARRAY. +;;; PURCOPYs the buckets of the initial OBARRAY copy. +;;; And even then, STRING doesn't want to be on it! + + +(DEFUN CC:subload MACRO (x) + (subst (cadr x) 'X '(OR (GET 'x 'VERSION) (FASLOAD (LISP) x)))) + +;;;; pure ATOM list for OBARRAY + + +(PROG (N READTABLE *RSET) + (SETQ N (- (ARRAY-DIMENSION-N 1 OBARRAY) 129.) + READTABLE (ARRAY () READTABLE 'T)) + (COMMENT ;Put on both obarrays + IGNORE COMPLRVERNO BITS PAIR CHARACTER TYPE-OF + VECTORP STRINGP BITSP TYPECASEQ PTR-TYPEP *:TRUTH + ; MAKE-VECTOR VREF VSET VECTOR-LENGTH + ; BITS BIT RPLACBIT NIBBLE SET-NIBBLE + ; MAKE-STRING CHAR RPLACHAR CHAR-N RPLACHAR-N + ; EXTEND SI:EXTENDP VECTOR STRING +INTERNAL-STRING-MARKER + ; VERSION PAIRP + +INTERNAL-TEMP-MARKER :LOCAL-VAR CL:CL SOURCE-TRANS ACS + *EXPR *FEXPR *LEXPR **LEXPR @DEFINE ARRAY* RUNTIME-LIMIT + CHOMP CHOMPHOOK CMSGFILES COBARRAY COMPILE COMPLR SPECIALP + STRUCT-LET EVONCE EVAL-ONCE EVAL-ORDERED EVAL-ORDERED* + GRIND-MACROEXPANDED GENVALS GENSYMS |DEFUN&-CHECK-ARGS| + |DEFUN&-ERROR| CERROR FERROR CERROR-PRINTER ERROR-OUTPUT + COUTPUT CREADTABLE EOC-EVAL EOF-COMPILE-QUEUE &BODY + GENPREFIX ALLOC-MARK-RATIO GOFOO MACRO-EXPAND MACROLIST + MAKLAP MSDEV MSDIR NCOMPLR NO-EXTRA-OBARRAY NOTYPE + NUMFUN NUMVAR ONMLS OWN-SYMBOL RECOMPL SETVST DISOWN + SKIP-WARNING TTYNOTES-FUNCTION SI:EVALUATE-NUMBER? + SOBARRAY SPECIAL SPLITFILE SPLITFILE-HOOK SQUID + SREADTABLE SWITCHTABLE TOPLEVEL UNDFUNS UNSPECIAL + PRATTSTACK USERATOMS-HOOKS USER-STRING-MARK-IN-FASL + QUERY-IO Y-OR-N-P YES-OR-NO-P SI:LOST-MESSAGE-HANDLER + SETF +INTERNAL-SETF-X SETF-SIMPLEP-SCAN STRUCT-SETF + SETF-STRUCT SETF-X CONS-A-SETF SETF-CLASS + + USER-SLOT SETF-USER-SLOT GENSYMS SETF-GENSYMS + GENVALS SETF-GENVALS INVERT SETF-INVERT + ACCESS SETF-ACCESS RET-OK SETF-RET-OK + SIDE-EFFECTS SETF-SIDE-EFFECTS I-COMPUTE SETF-I-COMPUTE + COMPUTE SETF-COMPUTE + + LEXPR-SEND LEXPR-SEND-AS SEND-AS :SEND + EXTSFA DEFSFA SFA-UNCLAIMED-MESSAGE SI:DEFSFA-ACCESSOR + SI:DEFSFA-CREATOR SI:INIT-SFA DEFSFA-NAME DEFSFA-INITP + DEFSFA-SIZE DEFSFA-HANDLER DEFSFA-INITS DEFSFA-IDX + WHICH-OPERATIONS SI:WHICH-OPERATIONS-INTERNAL :INIT + SFA-UNCLAIMED-MESSAGE + CHECK-ARG ERROR-RESTART + CLASS-CLASS OBJECT-CLASS SEQUENCE-CLASS + VECTOR-CLASS STRUCT-CLASS STRUCT=INFO-CLASS + ) + (ALLOC '(FIXNUM (2048. 10240. .25) FLONUM (256. 4096. .10) + BIGNUM (256. 4096. .10) SYMBOL (1536. 8192. .25) + ARRAY (64. 1024. 64.) )) + (AND (STATUS FEATURE ITS) (ALLOC '(LIST (14336. 40960. .35)))) + (SETQ *RSET () NOUUO () NORET 'T USERATOMS-HOOKS () ) + (SETQ CCLOAD:PUTPROP PUTPROP + CCLOAD:INITIAL-PROPS () ) + (cond + ((status feature SHARABLE) (setq PUTPROP PURE-PUTPROP)) + ('T + (setq PUTPROP + (purcopy + (append '(STRUCT=INFO SELECTOR CONSTRUCTOR AUTOLOAD + VERSION CARCDR |side-effectsp/|| SETF-X + GRINDFN GRINDPREDICT GRINDMACRO GRINDFLATSIZE) + putprop)) + PURE-PUTPROP PUTPROP))) + (setq PUTPROP (purcopy (append '(CARCDR FUNTYP-INFO ARGS) PUTPROP))) + ;; THESE ARE "BOOTSTRAP" VERSIONS - WILL BE REDEFINED BY MAKLAP FILE + ((lambda (pure *pure) + (DEFUN CCLOAD:BOOTMACS (Y Z) + ;; CCLOAD:INITIAL-PROPS is a list of items like + ;; ( ... ), where each + ;; 'prop' is to be preserved over INITIALIZE-ation. + ((LAMBDA (W) + (COND (W (OR (MEMQ Z (CDR W)) + (RPLACD W (CONS Z (CDR W))))) + ('T (SETQ CCLOAD:INITIAL-PROPS + (CONS (LIST Y Z) + CCLOAD:INITIAL-PROPS))))) + (ASSQ Y CCLOAD:INITIAL-PROPS)) + () ) + (DEFUN SPECIAL MACRO (L) + (MAPC '(LAMBDA (X) + (PUTPROP X (LIST 'SPECIAL X) 'SPECIAL) + (CCLOAD:BOOTMACS X 'SPECIAL)) + (CDR L)) + ''SPECIAL) + (DEFUN *LEXPR MACRO (L) + (MAPC '(LAMBDA (X) + (PUTPROP X 'T '*LEXPR) + (CCLOAD:BOOTMACS X '*LEXPR)) + (CDR L)) + ''*LEXPR) + (DEFUN *EXPR MACRO (L) + (MAPC '(LAMBDA (X) + (PUTPROP X 'T '*EXPR) + (CCLOAD:BOOTMACS X '*EXPR)) + (CDR L)) + ''*EXPR) + ) + () () ) + (SETQ CCLOAD:BOOTMACS '(SPECIAL *EXPR *LEXPR)) + (and (status feature ITS) + (SETQ CCLOAD:DUMPFILE () CCLOAD:DUMPVERNO '/0)) + (SETQ CCLOAD:PURE PURE + *PURE (STATUS FEATURE PAGING) + PURE (COND ((STATUS FEATURE PAGING) + 1) + ((status nofeature SAIL) -1) + ('T (COND ((STATUS FEATURE NCOMPLR) + (SETQ CCLOAD:PURESEG T) -1) + ((STATUS FEATURE BCOMPLR) + (SETQ CCLOAD:PURESEG ()) 1) + ('T (TERPRI) (PRINT 'PURE) (PRINT '| |) + (PRINT '=) (PRINT '| |) (PRINT '?) + (TERPRI) (BREAK NCOMPLR))) ))) + (and (status FEATURE SAIL) (SETQ CCLOAD:PURESEG (EQUAL PURE -1))) + (SSTATUS FEATURE COMPLR) + ((LAMBDA (PUTPROP) + (CC:subload DEFMAX) + (CC:subload MACAID) + (CC:subload EXTSTR) + (CC:subload EXTHUK) + (CC:subload DEFVSY) + (CC:subload MLMAC) + (CC:subload ERRCK) + (CC:subload MLSUB) + (OR (FBOUNDP (CAR (STATUS MACRO /#))) + (CC:subload SHARPM)) + (OR (FBOUNDP (CAR (STATUS MACRO /`))) + (CC:subload BACKQ))) + (CONS 'MACRO (APPEND CCLOAD:BOOTMACS PUTPROP))) + (progn ;;Patch-up declarations + (or (memq 'EXTSTR-USERATOMS-HOOK USERATOMS-HOOKS) + (push 'EXTSTR-USERATOMS-HOOK USERATOMS-HOOKS)) + (mapc '(lambda (x) + (or (get x '*LEXPR) + (eq (car (get x 'FUNTYP-INFO)) 'LSUBR) + (eval (list '*LEXPR x)))) + '(GENTEMP SETSYNTAX-SHARP-MACRO SI:LOST-MESSAGE-HANDLER + CERROR SEND SEND-AS LEXPR-SEND LEXPR-SEND-AS)) + (mapc '(lambda (x) + (or (get x 'SPECIAL) (eval (list 'SPECIAL x)))) + '(GENTEMP SI:CLASS-MARKER SI:SKELETAL-CLASSES + ;; CLASS-CLASS OBJECT-CLASS SEQUENCE-CLASS + ;; VECTOR-CLASS STRUCT-CLASS STRUCT=INFO-CLASS + SI:CHECK-MULTIPLICITIES BACKQUOTE-EXPAND-WHEN + /#-MACRO-DATALIST ERROR-OUTPUT CERROR-PRINTER + SI:STRUCT=INFO-VERSION )) + + ) + (REMOB 'CC:subload) + (SETQ SAIL-MORE-SYSFUNS () ) + (and (status FEATURE SAIL) + (FASLOAD (DSK (MAC LSP)) MATCH FAS)) + (AND (STATUS FEATURE EXPERIMENTAL) + (NOT (STATUS FEATURE XC)) + (SSTATUS FEATURE XC)) + ;These guys wont be be preloaded. + (MAPC '(LAMBDA (X) (CCLOAD:BOOTMACS X 'MACRO)) + '(DEFMACRO DEFMACRO-DISPLACE DEFUN/& MACRO LET LET* DESETQ + SETF DEFSETF EVAL-ORDERED SI:PICK-A-MASK)) + (MAPATOMS '(LAMBDA (X) (AND (GET X 'MACRO) + (CCLOAD:BOOTMACS X 'MACRO)))) + (SSTATUS FEATURE NOLDMSG) + (SETQ IREADTABLE READTABLE) + (SETQ IOBARRAY (ARRAY () OBARRAY '() )) ;Make pure copy of + (DO I 0 (1+ I) (= I N) ; original obarray + (STORE (ARRAYCALL T IOBARRAY I) (PURCOPY (OBARRAY I)))) + (COND ((STATUS FEATURE SHARABLE) + (MAPC 'DEPURIFY-SYMBOL DEPURIFY-SYMBOL) + (MAPC '(LAMBDA (X) + (MAPC 'DEPURIFY-SYMBOL (APPEND (CAR X) (CDR X)))) + *SHARING-FILE-LIST*) + (MAPC 'DEPURIFY-SYMBOL (CONS (STATUS UDIR) + '(AI ML MC DSK LSPDMP LISP))))) + (RETURN '*)) + +(or (alphalessp (get 'SHARPM 'VERSION) "82") + (prog (x y) + (or (setq y IREADTABLE + x (assoc READTABLE /#-MACRO-DATALIST)) + (setq y READTABLE + x (assoc IREADTABLE /#-MACRO-DATALIST)) + (+internal-lossage 'SHARPM 'CCLOAD () )) + (push (cons y (cdr x)) /#-MACRO-DATALIST))) + + +;; There is some unfathomable bug in trying to load up a BCOMPLR +;; at SAIL, so experimentally we found that this will fix it. +#+SAIL (PROGN (GC) (FASLOAD (LISP) SETF)) + +;;;; PROGN for LOAD of files + +(PROGN + (SETQ PUTPROP (PURCOPY + (APPEND '(STATUS SSTATUS INST INSTN IMMED ARITHP + NUMBERP NOTNUMP CONTAGIOUS COMMU BOTH CONV + ACS MINUS FLOATI P1BOOL1ABLE ) + PUTPROP))) + (LET ((PUTPROP (CONS 'AUTOLOAD PUTPROP))) + (MAPC '(LAMBDA (L) + (MAPC '(LAMBDA (X) (OR (GETL X '(SUBR LSUBR MACRO AUTOLOAD)) + (PUTPROP X `((LISP) ,X FASL) 'AUTOLOAD))) + (CDR L))) + '(((CERROR) CERROR FERROR SI:LOST-MESSAGE-HANDLER + SI:ERROR-OUTPUT-HANDLER +INTERNAL-LOSSAGE) + ((DEFSETF) DEFSETF)))) + (PROG (GL LVRL TIME RUNTIME ALARMCLOCK SLOTX REGACS + NUMACS MODELIST FASLOAD UNSFLST FXPDL REGPDL NLNVTHTBP + #+ITS CCLOAD:CLOCK-SLOWDOWN #+ITS CCLOAD:CLOCK-INTERVAL + #+ITS CCLOAD:CLOCK-EPSILON #+ITS CCLOAD:TIME-TEMP + #+ITS CCLOAD:OTIME-TEMP + CCLOAD:FLUSH-TTY CCLOAD:DEV-DIR + ) + (SETQ RUNTIME (RUNTIME) TIME (TIME)) + (COMMENT + ;SLOTX holds either NUMACS or REGACS, to hac the ALARMCLOCK + ; (NUMACS) turns ALARMCLOCK feature on + ; (REGACS) turns it off + ;RUNTIME is the RUNTIME before beginning + ;TIME is the realTIME before beginning + ;CCLOAD:CLOCK-INTERVAL is the interval between alarm rings, + ;CCLOAD:CLOCK-EPSILON is the epsilonics - two tics within a + ; realtime of less than CCLOAD:CLOCK-EPSILON cause the + ; second to be ignored. + ;CCLOAD:CLOCK-SLOWDOWN is the time at which the interval should + ; be slowed, [i.e., doubled] we want alarms less often as + ; time goes by + ;CCLOAD:TIME-TEMP is a temporary time holder + ;CCLOAD:FLUSH-TTY causes a veto on message printers + ) + (SETQ ^Q () ) + + +;;; Falls thru to below +; +;;; Falls thru from above + + #+ITS (PROGN + (SETQ CCLOAD:CLOCK-EPSILON 3.0) + (SETQ NUMACS '(LAMBDA () ;TURNS ALARM OFF + (ALARMCLOCK 'TIME -1) + (PRINC "/ +Clock-OFF " TYO) + (SETQ ALARMCLOCK () ^W 'T CCLOAD:FLUSH-TTY 'T + SLOTX REGACS)) + REGACS '(LAMBDA () ;TURNS ALARM ON + (SETQ ALARMCLOCK MODELIST ^W () SLOTX NUMACS + CCLOAD:FLUSH-TTY () CCLOAD:CLOCK-SLOWDOWN 40.0 + CCLOAD:CLOCK-INTERVAL 10.) + (PRINC "/ +Clock-ON " TYO) + (ALARMCLOCK 'TIME 1.)) + MODELIST '(LAMBDA (VGO) + (COND (CCLOAD:FLUSH-TTY (ALARMCLOCK 'TIME -1)) + ('T (SETQ CCLOAD:TIME-TEMP (TIME)) + (COND ((AND (NOT CCLOAD:FLUSH-TTY) + (> (-$ CCLOAD:TIME-TEMP + CCLOAD:OTIME-TEMP) + CCLOAD:CLOCK-EPSILON)) + (TERPRI TYO) + (PRINC "Using " TYO) + (SETQ CCLOAD:TIME-TEMP + (*QUO (- (RUNTIME) RUNTIME) + 1.0E5) ) + (PRINC (*QUO (FIX CCLOAD:TIME-TEMP) + 10.0) + TYO) + (PRINC " secs so far, out of " TYO) + (PRINC (*QUO (FIX (*$ (-$ (TIME) TIME) 10.0)) + 10.0) + TYO) + (PRINC '| | TYO) + (SETQ CCLOAD:TIME-TEMP (TIME)))) + (COND ((> (-$ (SETQ CCLOAD:OTIME-TEMP CCLOAD:TIME-TEMP) TIME) + CCLOAD:CLOCK-SLOWDOWN) + (SETQ CCLOAD:CLOCK-SLOWDOWN + (*$ 2.0 CCLOAD:CLOCK-SLOWDOWN) + CCLOAD:CLOCK-INTERVAL + (* 2 CCLOAD:CLOCK-INTERVAL)))) + (ALARMCLOCK 'TIME CCLOAD:CLOCK-INTERVAL))) )) + (SSTATUS TTYIN 30. '(LAMBDA (VGO VGOL) (FUNCALL SLOTX))) + (FUNCALL REGACS)) ;Sets up SLOTX, and starts ALARMCLOCK + +;;; Falls thru to below +; +;;; Falls thru from above + + + B #+ITS (SETQ CCLOAD:OTIME-TEMP (TIME)) + (AND (NOT CCLOAD:FLUSH-TTY) + (PRINC "/ + (In LISP version " TYO) + (PRINC (STATUS LISPV) TYO) + (PRINC '|)|) TYO) + #+ITS (OR (NOT (STATUS HACTR)) + (VALRET (COND ((STATUS FEATURE XC) + "/ :JCL/ +XCOMPLJ:VP ") + ("/ :JCL/ +COMPLRJ:VP ")))) + (SETQ CCLOAD:DEV-DIR + #+ITS '(DSK COMLAP) + #+SAIL '(DSK (MAC LSP)) + #-(or ITS SAIL) + (COND #+DEC20 ((PROBEF '((PS MACLISP) COMPLR FASL)) + '(PS MACLISP)) + ((LIST 'DSK (STATUS UDIR))))) + C (SETQ NLNVTHTBP (CONS CCLOAD:DEV-DIR '(* FASL))) + #-ITS (AND (NOT (PROBEF (CONS CCLOAD:DEV-DIR '(COMPLR FASL)))) + (PROG2 (PRINC "/ +;Please set up "CCLOAD:DEV-DIR" to a list of the device and directory / +;names to use for the loading the COMPLR and FASLAP FASL files/ +" TYO) + (BREAK ULUZ) + (GO C))) + (COND ((NULL (GETSP (COND ((SIGNP L PURE) 12000.) + ('T #+SAIL 50000. + #-SAIL 43000.)))) + (TERPRI) + (PRINC ";Can't get enough Binary Program Space - You have lost badly!!") + (TERPRI) + (BREAK ULUZ) + (GO C))) + +;;; Falls thru to below +; +(comment LOAD ALL AUTOLOAD FILES) +;;; Falls thru from above + + (SETQ + LVRL + '(LAMBDA (REGPDL) + (COND ((GET (CAR REGPDL) (CADR REGPDL))) + ((OR (AND (SETQ GL (GET (CAR REGPDL) 'AUTOLOAD)) (PROBEF GL)) + (PROBEF (SETQ GL (LIST '(LISP) (CADDR REGPDL) 'FASL))) + (AND (SETQ GL (MERGEF NLNVTHTBP (CADDR REGPDL))) + (PROBEF GL))) + (COND ((NOT CCLOAD:FLUSH-TTY) + (TERPRI TYO) + (PRINC ";Autoloading " TYO) + (PRINC (CADR GL) TYO) + (PRINC '| | TYO) + (PRINC (CADDR GL) TYO) + (PRINC " for " TYO) + (PRIN1 (CAR REGPDL) TYO))) + (LOAD GL)) + ('T (PROG (^Q ^R ^W) + (TERPRI) + (PRINC '/;) + (PRINC (CAR REGPDL)) + (PRINC " has not been defined. Please load ") + (PRINC (CADDR REGPDL)) + (PRINC " file, and resume by P ") + (BREAK WAIT-FOR-LOADING)) )))) + + #+SAIL (PROGN (HELP) + (FUNCALL LVRL '(GC-OVERFLOW-DAEMON SUBR DEMON)) + (SETQ GC-OVERFLOW 'GC-OVERFLOW-DAEMON) + (DEFUN SAVE-COMPILER (GL) + (CDUMP (MAKNAM (APPEND (EXPLODEN "SAVE ") + (EXPLODEN GL)))))) + #-SAIL (FUNCALL LVRL '(GC-DAEMON SUBR GCDEMN)) + + (MAPC LVRL '( (LET MACRO LET) + (|Certify-no-var-dependency/|| SUBR CNVD) + (DEFMACRO MACRO DEFMACRO) + (GETMIDASOP SUBR GETMIDASOP) + (+INTERNAL-SETF-X SUBR SETF))) + + (MAPATOMS '(LAMBDA (X) (AND (GET X 'MACRO) + (CCLOAD:BOOTMACS X 'MACRO)))) + +;;; Falls thru to below +; +(comment LOADING MAIN COMPLR FILES) +;;; Falls thru from above + + (SETQ LVRL '(LAMBDA (REGPDL) + (SETQ GL (CONS CCLOAD:DEV-DIR + (COND ((ATOM REGPDL) (CONS REGPDL '(FASL))) + (REGPDL)))) + (COND ((PROBEF GL) + (COND ((NOT CCLOAD:FLUSH-TTY) + (TERPRI TYO) + (PRINC " Fazloading ") + (PRINC REGPDL TYO) + (PRINC " FASL " TYO))) + (LOAD GL) + (COND ((AND (NOT CCLOAD:FLUSH-TTY) + (SETQ GL (COND ((EQ REGPDL 'FASLAP) + 'FASLVERNO) + ((IMPLODE + (NCONC + (EXPLODEC REGPDL) + '(V E R N O)))))) + (BOUNDP GL) + (SETQ GL (SYMEVAL GL))) + (TERPRI TYO) + (PRINC " (") + (PRINC REGPDL TYO) + (PRINC " version number " TYO) + (PRINC GL TYO) + (PRINC '") " TYO) ))) + ('T (PROG (^Q ^R ^W) + (TERPRI) + (PRINC '/;) + (PRINC REGPDL) + (PRINC " FASL has not been found. Please load it, and resume by P ") + (BREAK ULUZ-BUNKIE)))))) + + (MAPC LVRL '(COMPLR PHAS1 COMAUX FASLAP MAKLAP INITIA SRCTRN)) + + #+SAIL (PROGN + (PROG (PURE) + (FUNCALL LVRL (COND ((AND (EQ GL 'DIRECT) (STATUS FEATURE DDT)) + '(DIRECT DFA)) + ('DIRECT)))) + (MAPC LVRL '(EREAD MACROD NCOREQ LOADED)) + (SETQ SAIL-MORE-SYSFUNS + (APPEND '(EREAD EOPEN ELOAD UGREAT1 REQUIRE EDIT CODE + MATCH-MACRO MACRODEF MACROBIND TRANS TRANSDEF MAIL %MATCH + %CONTINUE %CONTINUE-MATCH %CHAR1 %MATCH-LOOKUP + %%EXPAND%% %%EXPAND1%% %%%STRING%%% ) + SAIL-MORE-SYSFUNS)) + (MAPC '(LAMBDA (X) + (COND ((GET (CAR X) 'AUTOLOAD) + (AND (CDDR X) (ARGS (CAR X) (CDDR X))) + (AND (CDR X) (PUTPROP (CAR X) (CDR X) 'FUNTYP-INFO))))) + '((EREAD FSUBR) (EOPEN LSUBR 0 . 4) (ELOAD SUBR () . 1) + (UGREAT1 SUBR () . 1) (REQUIRE FSUBR) (EDIT FSUBR) + (CODE FSUBR) (MAIL FSUBR))) ) + +;;; Falls thru to below +; +;;; Falls thru from above + +;;;; INITIALIZEing + + (COND ((NOT CCLOAD:FLUSH-TTY) + (TERPRI TYO) + (PRINC "Initializing " TYO))) + (AND |carcdrp/|| + (MAPC '(LAMBDA (X) (|carcdrp/|| X)) ;Make CARCDR props + '(CAR CDR CDDR CDDDR CDDDDR ; exist for a few + CDAR CADR CADDR CADDDR))) + (MAPC #'(LAMBDA (X) (REMPROP X 'MACRO)) CCLOAD:BOOTMACS) + (REMPROP 'CCLOAD:BOOTMACS 'EXPR) + (INITIALIZE) + #+ITS (ALARMCLOCK 'TIME -1) + (COND ((NOT CCLOAD:FLUSH-TTY) + (TERPRI TYO) + (PRINC "Total Time = " TYO) + (PRINC (*QUO (FIX (*QUO (- (RUNTIME) RUNTIME) 1.0E5)) + 10.0) + TYO) + (PRINC " secs out of " TYO) + (PRINC (*QUO (FIX (*$ (-$ (TIME) TIME) 10.0)) 10.0) TYO) + (TERPRI))) + (SETQ ALARMCLOCK () ^Q () ^W () )) + +;;; Note remainder of code below is outside this PROG +;;; +;;; Note that this code is still within the moby PROGN above + + (AND (FILEP UREAD) (CLOSE UREAD)) + (INPUSH -1) ;Closes INIT file, if any, or else LOAD file + (AND (STATUS SSTATUS FLUSH) (SSTATUS FLUSH 'T)) + (SETQ PUTPROP CCLOAD:PUTPROP) + (MAPC 'REMOB + (MAPCAR 'MAKUNBOUND + '( #+ITS CCLOAD:CLOCK-SLOWDOWN #+ITS CCLOAD:CLOCK-INTERVAL + #+ITS CCLOAD:CLOCK-EPSILON #+ITS CCLOAD:TIME-TEMP + #+ITS CCLOAD:OTIME-TEMP + CCLOAD:DEV-DIR CCLOAD:FLUSH-TTY CCLOAD:PUTPROP CCLOAD:BOOTMACS ))) + (GCTWA) + (NORET () ) + (cond ((not (status FEATURE PAGING)) ) + (pure (PAGEBPORG) (PURIFY 0 0 'BPORG))) + (SETQ PURE CCLOAD:PURE *PURE () ) + #+(or DEC20 ITS) + (PROGN (SETQ CCLOAD:DUMPFILE + #+ITS (COND ((OR (NOT (FIXP CCLOAD:PURE)) (STATUS FEATURE XC)) + (PRINC "Dumping eXperimentalCOMPLr on LSPDMP;XC.DMP " TYO) + "DSK:LSPDMP;XC.DMP ") + ('T + (PRINC "Dumping LSPDMP;CL.DMP " TYO) + "DSK:LSPDMP;CL.DMP ")) + #+DEC20 (COND ((EQ (status opsys) 'TOPS-20) + (PRINC "Ready to SAVE as COMPLR.EXE." TYO) + "PS:COMPLR.EXE") + ('T + (PRINC "Ready to SAVE as COMPLR.SAV;" TYO) + "DSK:COMPLR.SAV"))) + (LET ((BASE 10.) (IBASE 10.) (*NOPOINT 'T) + X Y ) + (SETQ CCLOAD:DUMPVERNO + #+ITS (PROG2 (SETQ X (NTH 2 (PROBEF '|DSK:LSPDMP;XC.DMP >|)) + Y (NTH 2 (PROBEF '|DSK:LSPDMP;CL.DMP >|))) + (COND ((OR (NULL X) (ALPHALESSP X Y)) Y) + (T X))) + #-ITS (NTH 3 (PROBEF CCLOAD:DUMPFILE))) + (OR CCLOAD:DUMPVERNO (BREAK CCLOAD:DUMPVERNO)) + (SETQ CCLOAD:DUMPVERNO (EXPLODEN CCLOAD:DUMPVERNO)) + (SETQ CCLOAD:DUMPVERNO + (IMPLODE (EXPLODEN (1+ (READLIST CCLOAD:DUMPVERNO)))))) + (PUTPROP 'COMPLR CCLOAD:DUMPVERNO 'VERSION) + (PRINC CCLOAD:DUMPVERNO TYO) + (TERPRI) + #+ITS (CDUMP 0 (NAMESTRING (MERGEF CCLOAD:DUMPFILE + (LIST '* CCLOAD:DUMPVERNO)))) + #+DEC20 (CDUMP (maknam (nconc (exploden "$") + (exploden " COMPLR (version ") + (exploden CCLOAD:DUMPVERNO) + (exploden " )"))) +) + + ) + #-(or DEC20 ITS) + (PROGN (MAKUNBOUND 'CCLOAD:PURE) + (PRINC COMPLRVERNO TYO) + (TERPRI)) + #+DEC10 (PRINC "Ready to SSAVE as COMPLR.SAV (or .SHR,.LOW)/ +Version number = " TYO) + #+SAIL (COND (CCLOAD:PURESEG + (MAKUNBOUND 'CCLOAD:PURESEG) + (CDUMP '|save sys:ncompl| + '(ncompl shr sys (1 3)))) + ('T (MAKUNBOUND 'CCLOAD:PURESEG) + (CDUMP '|Save sys:bcompl|))) + #+DEC10 (PROGN (MAKUNBOUND 'CCLOAD:PURESEG) + (CDUMP)) + ) + + diff --git a/src/comlap/cl_fas.936 b/src/comlap/cl_fas.936 new file mode 100755 index 00000000..86457e10 Binary files /dev/null and b/src/comlap/cl_fas.936 differ diff --git a/src/comlap/complr.tags b/src/comlap/complr.tags new file mode 100755 index 00000000..196aaeb4 --- /dev/null +++ b/src/comlap/complr.tags @@ -0,0 +1,494 @@ +DSK: COMLAP; COMPLR > +01362,LISP +(DEFUN COMPLRVERNO ¹96 +(DEFUN CHOMP ±347 +(DEFUN CHMP1 ²132 +(DEFUN CL ²760 +(DEFUN COMPILE ³327 +(DEFUN COMP ±1663 +(DEFUN COMPE ±1726 +(DEFUN COMP1 ±1797 +(DEFUN COMPW ±1865 +(DEFUN COMPR ±1954 +(DEFUN COMP0 ±2237 +(DEFUN COMPFORM ±3708 +(DEFUN COMABSMINUS ²8924 +(DEFUN COMAD1SB1 ²9669 +(DEFUN COMARITH ²9989 +(DEFUN COMARRAY ³3235 +(DEFUN COM-AREF ³3501 +(DEFUN ACLQ-FIND ´1032 +(DEFUN AREF-ADD ´1422 +(DEFUN COMARG ´1551 +(DEFUN COMBOOLE ´2622 +(DEFUN COMCOND ´4714 +(DEFUN SNILPTST µ4490 +(DEFUN CCHAK-BOOL1ABLE µ4605 +(DEFUN COMEQ µ5333 +(DEFUN NUMODIFY µ8904 +(DEFUN COMEX-DP µ9084 +(DEFUN COMERSET ¶0011 +(DEFUN COMFIXFLT ¶2367 +(DEFUN COMHAULONG ¶3869 +(DEFUN COMGO ¶4981 +(DEFUN COMGORET ¶5156 +(DEFUN COMGRTLSP ¶7977 +(DEFUN COMLAMAP ·1782 +(DEFUN COMLOCMODE ·9257 +(DEFUN COMLC ¸0181 +(DEFUN COML1 ¸2118 +(DEFUN COMMAKNUM ¸2769 +(DEFUN COMMUNKAM ¸3479 +(DEFUN COMNULL ¸3869 +(DEFUN COMPLIST ¸4449 +(DEFUN COMPROG ¸5207 +(DEFUN COMPROGN ¸7940 +(DEFUN CMPRGLDNIL ¸8096 +(DEFUN COMRETURN ¸8269 +(DEFUN COMREMAINDER ¸8815 +(DEFUN COMSHIFTS ¹0271 +(DEFUN COMRPLAC ¹1080 +(DEFUN COMSET ¹2704 +(DEFUN COMSETQ ¹3082 +(DEFUN ASIDE-FROM-FOO ¹9025 +(DEFUN FREEZE-VAR ¹9588 +(DEFUN COMTP ±00877 +(DEFUN COMSIGNP ±04112 +(DEFUN COMZP ±04909 +(DEFUN COM-X-C-R ±05908 + +DSK: COMLAP; PHAS1 > +02049,LISP +(DEFUN P1 ±015 +(DEFUN PWTNTPTFN ²3592 +(DEFUN P1ACK ²5095 +(DEFUN P1ARG-WRNTYP ²5709 +(DEFUN P1ANDOR ²5889 +(DEFUN P1ARITH ²6295 +(DEFUN P1AEVAL ³6453 +(DEFUN P1BINDARG ³8724 +(DEFUN P1BOOL1ABLE ´0377 +(DEFUN P1BASICBOOL1ABLE ´1005 +(DEFUN P1CARCDR ´1130 +(DEFUN P1CARCDR-CHASE ´1889 +(DEFUN P1CCEXPLODE ´2071 +(DEFUN P1ITERLIST ´2231 +(DEFUN P1COND ´2466 +(DEFUN P1AOC ´3513 +(defun p1nonumck ´3872 +(DEFUN P1CDC ´4002 +(DEFUN P1CJ ´5731 +(DEFUN P1CJ-NUMVALP ´7350 +(defvar *:TRUTH ´7901 +(DEFUN P1CASEQ ´7953 +(DEFUN P1CASEQ-CLAUSE ´9393 +(DEFUN P1DO ´9591 +(DEFUN P1DO-RETURN µ1445 +(DEFUN P1DO-STEPPER µ1543 +(DEFUN P1EQQTE µ1753 +(DEFUN P1E µ1848 +(DEFUN P1E1 µ1896 +(DEFUN P1HUNOZ µ2607 +(DEFUN P1F µ3012 +(DEFUN P1FAKE µ3177 +(DEFUN P1FV µ3629 +(DEFUN P1FUNGET µ3723 +(DEFUN P1GFY µ4038 +(DEFUN P1PFX µ4247 +(DEFUN P1LAM µ4362 +(DEFUN P1GLM µ6419 +(DEFUN P1GLM1 µ7030 +(DEFUN P1KNOWN µ7267 +(DEFUN P1L µ7475 +(DEFUN P1LST µ7711 +(DEFUN P1LST-LSTGET µ8975 +(DEFUN P1LMBIFY µ9461 +(DEFUN P1MODESET ¶2184 +(DEFUN P1MACROGET ¶2868 +(DEFUN P1MAP ¶3567 +(DEFUN LOCAL-VAR ¶7190 +(DEFUN P1PROG ¶7309 +(DEFUN P1GO ¶9567 +(DEFUN P1RETURN ¶9917 +(DEFUN P1TAG ·0954 +(DEFUN P1TAGDEFP ·1202 +(DEFUN P1PROG2 ·1376 +(DEFUN P1PROGN ·1862 +(DEFUN P1SETQ ·2096 +(DEFUN P1SPECIAL ·4049 +(DEFUN P1SPECIALIZEDVS ·4819 +(DEFUN P1SQE ·5444 +(DEFUN P1SQG ·5694 +(DEFUN P1SQV ·5819 +(DEFUN P1SYNCHRONIZE-CNTS ·6066 +(DEFUN P1SIGNP ·6273 +(DEFUN P1STATUS ·6915 +(DEFUN P1STVAL ·8277 +(DEFUN P1STQLIFY ·8647 +(DEFUN P1TYPE-ADD ·9066 +(DEFUN P1TRESS ·9788 +(DEFUN P1VAP ¸0572 +(DEFUN P1VN ¸0713 +(DEFUN NLNVASG ¸0870 +(DEFUN NLNVFINDCR ¸1403 +(DEFUN NLNVCR ¸1654 +(DEFUN NLNVEX ¸1803 +(DEFUN NLNV1 ¸2102 +(DEFUN NUMTYP ¸2543 +(DEFUN NUMTYPEP ¸2667 +(DEFUN NUMFUNP ¸5270 +(DEFUN NUMERVARP ¸6787 +(DEFUN NOTNUMP ¸6917 +(DEFUN SAMETYPES ¸7992 +(DEFUN P2UNSAFEP ¸8343 +(DEFUN UUVP ¸9066 +(DEFUN CKARGS ¸9953 +(DEFUN CKCFV ¹0254 +(DEFUN WRNTYP ¹0558 + +DSK: COMLAP; COMAUX > +04139,LISP +(DEFUN 1FREE ¹51 +(DEFUN 1INSP ¹93 +(DEFUN 6BSTR ±351 +(DEFUN ACSMRGL ±841 +(DEFUN ACMRG ±921 +(DEFUN ADD ²554 +(DEFUN ADR ²613 +(DEFUN ASQSLT ²714 +(DEFUN MEMASSQR ²831 +(DEFUN BADTAGP ²926 +(DEFUN BOOLOUT ³153 +(DEFUN BOOL1 ³639 +(DEFUN BOOL1LCK ¶056 +(DEFUN BOOL2 ¶278 +(DEFUN BOOL2LOOP ¶589 +(DEFUN BOOL3 ¶669 +(DEFUN CARCDR ·583 +(DEFUN CCOUT ±2727 +(DEFUN CC0 ±2946 +(DEFUN CCSWITCH ±3371 +(DEFUN CARCDR-FREEZE ±4123 +(DEFUN CLEAR ±4842 +(DEFUN CLEARACS ±7096 +(DEFUN CLEARACS0 ±7705 +(DEFUN CLEARACS1 ±7778 +(DEFUN CLEARVARS ±7908 +(DEFUN CLEARNUMACS ±7982 +(DEFUN CLEARACSMODE ±8043 +(DEFUN CLEANUPSPL ±8233 +(DEFUN CLCHK ±8931 +(DEFUN CLLOC ±9014 +(DEFUN CLMEMBER ±9106 +(DEFUN CLOBBER-SLOT ±9515 +(DEFUN CONVNUMLOC ±9738 +(DEFUN CONT ²0244 +(DEFUN CONTENTS ²0291 +(DEFUN CPUSH ²0352 +(DEFUN CPUSH-DDLPDLP ²0408 +(DEFUN CPUSH1 ²0826 +(DEFUN CPUSH2 ²1682 +(DEFUN CPUSHFOO ²1796 +(DEFUN CSLD ²3277 +(DEFUN CPVRL ²5223 +(DEFUN CNPUSH ²5430 +(DEFUN CNPUSH1 ²6228 +(DEFUN DIDUP ²6682 +(DEFUN DIDU1 ²6902 +(DEFUN DVP ²7126 +(DEFUN DVP1 ²7168 +(DEFUN DVP2 ²7468 +(DEFUN DVP3 ²8459 +(DEFUN DVP4 ²8929 +(DEFUN EASYGO ²9890 +(DEFUN FIND ³0262 +(DEFUN FLUSH-SPL-NILS ³0654 +(DEFUN FRACF ³0997 +(DEFUN FRAC ³1122 +(DEFUN FRACB ³1656 +(DEFUN FRAC1 ³2297 +(DEFUN FRAC5 ³2488 +(DEFUN FREEREGAC ³2694 +(DEFUN FREEIFYNUMAC ³2892 +(DEFUN FREENUMAC ³3102 +(DEFUN FREENUMAC1 ³3219 +(DEFUN FREENUMAC0 ³3785 +(DEFUN FUNMODE ³4015 +(DEFUN FUNTYP-DECODE ³4164 +(DEFUN GCDR ³4520 +(DEFUN GCONTENTS ³4940 +(DEFUN GENTAG ³5041 +(DEFUN GETMODE ³5208 +(DEFUN GETMODE0 ³5362 +(DEFUN ILOC0 ³6218 +(DEFUN ILOC1 ³6597 +(DEFUN ILOC2 ³7680 +(DEFUN ILOCMODE ³7922 +(DEFUN ITEML ´0706 +(DEFUN L/.LE/. ´1444 +(DEFUN L2F ´1668 +(DEFUN LSUB ´1793 +(DEFUN LADD ´1976 +(DEFUN LAND ´2063 +(DEFUN LJOIN ´2240 +(DEFUN LEVEL ´2511 +(DEFUN LEVELTAG ´2641 +(DEFUN LOADACS ´2756 +(DEFUN LOADAC ´3337 +(DEFUN LOADINNUMAC ´7179 +(DEFUN LOADINREGAC ´9405 +(DEFUN LOADINSOMENUMAC µ0088 +(DEFUN MAKEPDLNUM µ0152 +(DEFUN MAKESAFE µ0909 +(DEFUN MAKESURE µ1963 +(DEFUN LLTV/.UNSAFE µ2716 +(DEFUN NX2LAST µ2998 +(DEFUN OJRST µ3187 +(DEFUN OPUSH µ3243 +(DEFUN OSPB µ3796 +(DEFUN OPOP µ3989 +(DEFUN OUTFUNCALL µ4506 +(DEFUN OUTG µ5095 +(DEFUN ICOUTPUT µ5338 +(DEFUN OUTPUT µ6868 +(DEFUN OUT1 µ7503 +(DEFUN OUT3 µ8851 +(DEFUN OUT2 µ8968 +(DEFUN OUT3FIELDS ¶0373 +(DEFUN OUT4FIELDS ¶0423 +(DEFUN OUT5FIELDS ¶0477 +(DEFUN OUTJ ¶0535 +(DEFUN OUTJ0 ¶0694 +(DEFUN OUTTAG ¶3119 +(DEFUN OUTTAG0 ¶3396 +(DEFUN PROGHACSET ¶4551 +(DEFUN QNILP ¶5165 +(DEFUN Q0P+0P ¶5244 +(DEFUN Q1P+1P-1P ¶5458 +(DEFUN QNP ¶5724 +(DEFUN REGADP ¶5806 +(DEFUN REMOVEB ¶5952 +(DEFUN REMOVE ¶6010 +(DEFUN REMOVS ¶6204 +(DEFUN PNAMECONC ¶6579 +(DEFUN PCGAV ¶6919 +(DEFUN REMPROPL ¶7225 +(DEFUN LREMPROP ¶7292 +(DEFUN MSOUT ¶7485 +(DEFUN MSOUT-BRK ¶8989 +(DEFUN RESTORE ¶9388 +(DEFUN RST ·3503 +(DEFUN RSTD ·3686 +(DEFUN RETURNTAG ·4196 +(DEFUN SETMODE ·4345 +(DEFUN SHRINKPDL ·4412 +(DEFUN STRETCHPDL ·4592 +(DEFUN SLOTLISTCOPY ·4836 +(DEFUN SLOTLISTSET ·4998 +(DEFUN STRTIBLE ·5337 +(DEFUN UNSAFEP ·5733 +(DEFUN VARBP ·6231 +(DEFUN VARMODE ·6502 +(DEFUN ASSEMBLE ·6765 +(DEFUN CLOSED ·6818 +(DEFUN DISOWNED ·6871 +(DEFUN EXPR-HASH ·6927 +(DEFUN FASL ·6978 +(DEFUN FIXSW ·7027 +(DEFUN FLOSW ·7076 +(DEFUN GAG-ERRBREAKS ·7133 +(DEFUN HUNK2-TO-CONS ·7196 +(DEFUN EXPAND-OUT-MACROS ·7263 +(DEFUN MACROS ·7322 +(DEFUN MAPEX ·7372 +(DEFUN MUZZLED ·7424 +(DEFUN NOLAP ·7475 +(DEFUN ARRAYOPEN ·7529 +(DEFUN SPECIALS ·7584 +(DEFUN SYMBOLS ·7638 +(DEFUN UNFASLCOMMENTS ·7699 +(DEFUN *EXPR ·7807 +(DEFUN *FEXPR ·7853 +(DEFUN *LEXPR ·7900 +(DEFUN **LEXPR ·7948 +(DEFUN /@DEFINE ·8019 +(DEFUN EOC-EVAL ·8052 +(DEFUN FIXNUM ·8118 +(DEFUN FLONUM ·8164 +(DEFUN GENPREFIX ·8213 +(DEFUN IGNORE ·8275 +(DEFUN NOTYPE ·8322 +(DEFUN OWN-SYMBOL ·8376 +(DEFUN RECOMPL ·8828 +(DEFUN SPECIAL ·8889 +(DEFUN UNSPECIAL ·8940 +(DEFUN *DECLARE ·9118 +(DEFUN NUMPROP ¸0148 +(DEFUN NMPSUBST ¸0827 +(DEFUN ARRAY* ¸1417 +(DEFUN AR*1 ¸1464 + +DSK: COMLAP; CDMACS > +01546,LISP +(DEFUN COMPDECLARE ¹44 +(DEFUN FASLDECLARE ³653 +(DEFMACRO OUTFS ´816 +(DEFMACRO NCDR µ005 +(DEFMACRO EQUIV µ045 +(DEFMACRO /2^N-P µ103 +(DEFMACRO INVERSE-ASCII µ162 +(DEFMACRO |Oh, FOO!|µ211 +(DEFMACRO ITSP µ247 +(DEFMACRO SAILP µ285 +(DEFMACRO DEC10P µ325 +(DEFMACRO DEC20P µ366 +(DEFMACRO BARF µ409 +(DEFMACRO DBARF µ489 +(DEFMACRO WARN µ568 +(DEFMACRO PDERR µ648 +(DEFMACRO KNOW-ALL-TYPES µ723 +(DEFMACRO INITIALSLOTS µ845 +(DEFMACRO ERL-SET ¶055 +(DEFMACRO SETUP-CATCH-PDL-COUNTS ¶189 +(DEFMACRO CLEARALLACS ¶273 +(DEFMACRO NO-DELAYED-SPLDS ¶321 +(DEFMACRO MAX-NPUSH ¶378 +(DEFMACRO MAX-0PUSH ¶409 +(DEFMACRO MAX-0*0PUSH ¶440 +(DEFMACRO NACS ¶471 +(DEFMACRO NUMVALAC ¶499 +(DEFMACRO NUMNACS ¶526 +(DEFMACRO NACS+1 ¶552 +(DEFMACRO FXP0 ¶590 +(DEFMACRO FLP0 ¶645 +(DEFMACRO NPDL-ADDRS ¶724 +(DEFMACRO REGADP-N ¶757 +(DEFMACRO REGACP ¶814 +(DEFMACRO REGACP-N ¶879 +(DEFMACRO REGPDLP-N ¶932 +(DEFMACRO REGPDLP ¶979 +(DEFMACRO PDLLOCP ·042 +(DEFMACRO PDLLOCP-N ·083 +(DEFMACRO ACLOCP ·122 +(DEFMACRO ACLOCP-N ·161 +(DEFMACRO NUMACP ·196 +(DEFMACRO NUMACP-N ·267 +(DEFMACRO NUMPDLP ·318 +(DEFMACRO NUMPDLP-N ·389 +(DEFMACRO FLPDLP-N ·437 +(DEFMACRO PDLAC ·485 +(DEFMACRO PDLGET ·583 +(DEFMACRO ACSGET ·686 +(DEFMACRO ACSSLOT ·745 +(DEFMACRO ACSMODESLOT ·881 +(DEFMACRO NACSGET ¸016 +(DEFMACRO NULLIFY-NUMAC ¸116 +(DEFMACRO ILOCREG ¸201 +(DEFMACRO ILOCNUM ¸269 +(DEFMACRO ILOCF ¸332 +(DEFMACRO ILOCN ¸396 +(DEFMACRO FREACB ¸461 +(DEFMACRO FREAC ¸502 + +DSK: COMLAP; FASLAP > +00821,LISP +(DEFUN FASLVERNO ±052 +(DEFUN FASLIFY ±158 +(DEFUN FASLPASS1 ³353 +(DEFUN RECLITCOUNT µ327 +(DEFUN FASLPASS2 ¶667 +(DEFUN ARGSINFO ¹818 +(DEFUN FASLEVAL ¹979 +(DEFUN FASLPLUS ±3804 +(DEFUN FASLDIFF ±4655 +(DEFUN FASLMINUS ±5482 +(DEFUN FASLNEGLIS ±5647 +(DEFUN LAPCONST ±6210 +(DEFUN LAPC1 ±6770 +(DEFUN ATOMINDEX ±7210 +(defun COLLECTATOMS ±8193 +(defun useratoms-intern ²0839 +(defun useratoms-lookup ²0967 +(DEFUN HASSOCN ²1025 +(DEFUN FASLDEFSYM ²1734 +(DEFUN BLOBLENGTH ²2438 +(DEFUN SUBMATCH ²2953 +(DEFUN MUNGEABLE ²3198 +(DEFUN MOBYSYMPOP ²3525 +(defun LISTOUT ²4114 +(DEFUN BUFFERBIN ²6016 +(DEFUN POPNCK@ ²7800 +(DEFUN MKEVAL ²7987 +(DEFUN MAKEWORD ²8189 +(DEFUN GLHAK ³1468 +(DEFUN BINOUT ³2142 +(DEFUN *DDTSYM ³2186 +(DEFUN FASLOUT ³2284 + +DSK: COMLAP; MAKLAP > +00930,LISP +(DEFUN COUTPUT ¹49 +(DEFUN MACRO-EXPAND ±105 +(DEFUN MAP-MCX-TRACE ±361 +(DEFUN MCX-TRACE ±549 +(DEFUN CMP1 ´391 +(DEFUN COMPREAD ±5007 +(DEFUN CMP1-MACRO-ENLIVEN ±6111 +(DEFUN TERFASL ±6743 +(DEFUN COEFN ±6835 +(DEFUN CHMP2 ±7321 +(DEFUN CMP-LAPFUN ±7729 +(DEFUN INDENT-TO-INSTACK ±8152 +(DEFUN PRINT-LINEND ±8346 +(DEFUN LAP-FILE-MSG ±8458 +(DEFUN MAKLAP ²0024 +(DEFUN FASL-LAP-P ²9020 +(DEFUN DISOWN ²9340 +(DEFUN GIVUPTTY ²9418 +(DEFUN STOP-RUNAWAYS ³0003 +(DEFUN SPLITFILE ³0700 +(DEFUN LAPCL ³1796 +(DEFUN LAPOP ³2045 +(DEFUN RDSYL ³2274 +(DEFUN MAKLAP-MERGEF ³3065 +(DEFUN ZAP2NIL ³3537 +(DEFUN ZTYI ³4825 +(DEFUN FASL-A-FILE ³5437 +(DEFUN FASL-START ³6674 +(DEFUN FASL-CLOSEOUT ³7724 +(DEFUN RENAMEVERNOP ³9575 +(defsimplemac NULDEVP ´0228 +(DEFUN FASL-DELETEF ´0312 +(DEFUN FASL-RENAMEF ´0402 +(DEFUN UNFASL-MSG ´0607 +(DEFUN NOTE-IN-UNFASL ´0903 + +DSK: COMLAP; INITIA > +00344,LISP +(DEFUN INITIALIZE ±309 +(DEFUN DEBUG-BREAK ¹090 +(DEFUN MACR-AMP-FUN ¹234 +(DEFUN INT-^^-FUN ¹492 +(DEFUN INT-^^-TOPLE ¹662 +(DEFUN DB ±0045 +(DEFUN DB-TOPLE ±0188 +(DEFUN S-C ±0737 +(DEFUN CDUMP ±0868 +(DEFUN COMPLR-TOPLE ±1197 +(DEFUN COMPLR-TOPLE-AFTER-SUSPEND ±1617 +(DEFUN FASLINIT ±5136 + +DSK: COMLAP; CCLOAD > +00063,LISP +(DEFUN CC:subload ²406 + +DSK: COMLAP; SRCTRN > +00251,LISP +(defun LISTP-FERROR-expander ±082 +(defun ML-<>-expander ±415 +(defun ML-trans-expander ³192 +(defmacro SI:PICK-A-MASK ³993 +(defun FOO-BYTE-EXPANDER ´135 +(defun ZERO-BYTEP ·487 +(defun LDB-expander ·709 + diff --git a/src/comlap/cx_fas.25 b/src/comlap/cx_fas.25 new file mode 100755 index 00000000..cd7ca81e Binary files /dev/null and b/src/comlap/cx_fas.25 differ diff --git a/src/comlap/fl_fas.392 b/src/comlap/fl_fas.392 new file mode 100755 index 00000000..dcb8c473 Binary files /dev/null and b/src/comlap/fl_fas.392 differ diff --git a/src/comlap/in_fas.120 b/src/comlap/in_fas.120 new file mode 100755 index 00000000..2e8678b9 Binary files /dev/null and b/src/comlap/in_fas.120 differ diff --git a/src/comlap/mk_fas.80 b/src/comlap/mk_fas.80 new file mode 100755 index 00000000..edfbe186 Binary files /dev/null and b/src/comlap/mk_fas.80 differ diff --git a/src/comlap/ph_fas.86 b/src/comlap/ph_fas.86 new file mode 100755 index 00000000..65e3ae96 Binary files /dev/null and b/src/comlap/ph_fas.86 differ diff --git a/src/comlap/st_fas.20 b/src/comlap/st_fas.20 new file mode 100755 index 00000000..69e17d9f Binary files /dev/null and b/src/comlap/st_fas.20 differ diff --git a/src/lisp/exthuk.fasl b/src/lisp/exthuk.fasl new file mode 100755 index 00000000..ad89e268 Binary files /dev/null and b/src/lisp/exthuk.fasl differ diff --git a/src/lisp/gcdemn.fasl b/src/lisp/gcdemn.fasl new file mode 100755 index 00000000..d13408c6 Binary files /dev/null and b/src/lisp/gcdemn.fasl differ