(LET ((*REOPEN-OPEN-FILE* NIL)) (WITH-OPEN-FILE (COPY S :DIRECTION :OUTPUT) (STREAMP COPY)))
EQL-OK: T
(PROGN (SETF (FDEFINITION 'CLHS-ROOT) SAVED-CLHS-ROOT (FDEFINITION 'IMPNOTES-ROOT) SAVED-IMPNOTES-ROOT) (LIST (STRINGP (CLHS-ROOT)) (STRINGP (IMPNOTES-ROOT))))
EQUAL-OK: (T T)
(SYMBOLS-CLEANUP '(S S1 S2 S3 S4 S5 S6 S7 S8 S9 S10 B1 B2 C1 C2 C3 C4 INPTW SY SAVED-CLHS-ROOT SAVED-IMPNOTES-ROOT TW EC STR1 STRGSTREAM OS OS1 IS ES S50 S49 *MY-INDENT-LEVEL*))
EQL-OK: NIL
(SETQ *PRINT-LENGTH* NIL)
EQL-OK: NIL
RUN-TEST: finished "streams" (0 errors out of 388 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"streamslong.tst" @1>
(READ-FROM-STRING "123")
EQL-OK: 123
(PRIN1-TO-STRING 123)
EQUAL-OK: "123"
(SETQ *A* (MAKE-ARRAY 10 :ELEMENT-TYPE 'STRING-CHAR :FILL-POINTER 0))
EQUAL-OK: ""
(FORMAT *A* "XXX")
EQL-OK: NIL
*A*
EQUAL-OK: "XXX"
(DEFUN BIN-STREAM-TEST (&KEY (SIZE (INTEGER-LENGTH MOST-POSITIVE-FIXNUM)) (TYPE 'UNSIGNED-BYTE) (FILE-NAME "streamslong-tst-foo") (NUM-BYTES 10) (BYTES (IF (EQ TYPE 'SIGNED-BYTE) (LOOP :REPEAT NUM-BYTES :COLLECT (- (RANDOM (ASH 1 SIZE)) (ASH 1 (1- SIZE)))) (LOOP :REPEAT NUM-BYTES :COLLECT (RANDOM (ASH 1 SIZE)))))) (WITH-OPEN-FILE (FOO FILE-NAME :DIRECTION :OUTPUT :ELEMENT-TYPE (LIST TYPE SIZE)) (DOLIST (BYTE BYTES) (WRITE-BYTE BYTE FOO))) (UNWIND-PROTECT (WITH-OPEN-FILE (FOO FILE-NAME :DIRECTION :INPUT :ELEMENT-TYPE (LIST TYPE SIZE)) (LIST (STREAM-ELEMENT-TYPE FOO) (FILE-LENGTH FOO) BYTES (LOOP :FOR BYTE :IN BYTES :FOR NB = (READ-BYTE FOO) :COLLECT NB :UNLESS (= NB BYTE) :DO (FLET ((BY-OUT (SZ BY) (FORMAT NIL "~v,'0,' ,4:b" (+ SZ (FLOOR SZ 4)) BY))) (ERROR "~& * [(~s ~s)] ~a != ~a~%" TYPE SIZE (BY-OUT SIZE BYTE) (BY-OUT SIZE NB)))))) (DELETE-FILE FILE-NAME)))
EQL-OK: BIN-STREAM-TEST
foo
foo
(LOOP FOR SIZE FROM 2 TO 40 DO (BIN-STREAM-TEST :SIZE SIZE))
EQL-OK: NIL
(LOOP FOR SIZE FROM 2 TO 40 DO (BIN-STREAM-TEST :SIZE SIZE :TYPE 'SIGNED-BYTE))
EQL-OK: NIL
(LET ((NOTICED 'NIL) FILE-WRITTEN) (FLET ((NOTICE (X) (PUSH X NOTICED) X)) (UNWIND-PROTECT (PROGN (WITH-OPEN-FILE (S "streamslong-tst-footest.bin" :ELEMENT-TYPE '(UNSIGNED-BYTE 8) :DIRECTION :OUTPUT :IF-EXISTS :ERROR) (NOTICE (FILE-POSITION S)) (WRITE-BYTE 5 S) (WRITE-BYTE 6 S) (LET ((P (FILE-POSITION S))) (NOTICE P) (NOTICE (WHEN P (FILE-POSITION S (1- P))))) (WRITE-BYTE 7 S) (NOTICE (FILE-POSITION S)) (SETQ FILE-WRITTEN (TRUENAME S))) (WITH-OPEN-FILE (S FILE-WRITTEN :ELEMENT-TYPE '(UNSIGNED-BYTE 8) :DIRECTION :INPUT) (NOTICE (FILE-POSITION S)) (LET ((LENGTH (FILE-LENGTH S))) (NOTICE LENGTH) (WHEN LENGTH (DOTIMES (I LENGTH) (NOTICE (READ-BYTE S)))))) (NREVERSE NOTICED)) (DELETE-FILE FILE-WRITTEN))))
EQUAL-OK: (0 2 1 2 0 2 5 7)
(LET ((S (MAKE-STRING-INPUT-STREAM (MAKE-ARRAY 10 :ELEMENT-TYPE (ARRAY-ELEMENT-TYPE "") :DISPLACED-TO "abcdefghijklmnopqrst" :DISPLACED-INDEX-OFFSET 5)))) (PROG1 (LIST (READ-CHAR S) (READ-CHAR S) (FILE-POSITION S) (FILE-POSITION S 4) (READ-CHAR S) (FILE-POSITION S :START) (READ-CHAR S) (FILE-POSITION S :END) (FILE-POSITION S)) (CLOSE S)))
EQUAL-OK: (#\f #\g 2 4 #\j 0 #\f 10 10)
(LET ((S (MAKE-STRING-OUTPUT-STREAM))) (PROG1 (LIST (WRITE-CHAR #\a S) (WRITE-CHAR #\b S) (FILE-POSITION S) (GET-OUTPUT-STREAM-STRING S) (WRITE-STRING "foo" S) (FILE-POSITION S 1) (WRITE-CHAR #\z S) (GET-OUTPUT-STREAM-STRING S) (FILE-POSITION S :START) (WRITE-CHAR #\u S) (FILE-POSITION S :END) (WRITE-CHAR #\w S) (GET-OUTPUT-STREAM-STRING S)) (CLOSE S)))
EQUAL-OK: (#\a #\b 2 "ab" "foo" 1 #\z "fz" 0 #\u 1 #\w "uw")
(LET ((V (MAKE-ARRAY 3 :ADJUSTABLE T :FILL-POINTER 0 :ELEMENT-TYPE 'CHARACTER))) (WITH-OUTPUT-TO-STRING (S V) (LIST (WRITE-STRING "foo" S) (CONS (FILE-POSITION S) (COPY-SEQ V)) (FILE-POSITION S 2) (WRITE-STRING "bar" S) (CONS (FILE-POSITION S) (COPY-SEQ V)) (FILE-POSITION S :START) (WRITE-STRING "zot" S) (CONS (FILE-POSITION S) (COPY-SEQ V)) (FILE-POSITION S :END) (WRITE-STRING "plonk" S) (CONS (FILE-POSITION S) (COPY-SEQ V)) V)))
EQUAL-OK: ("foo" (3 . "foo") 2 "bar" (5 . "fobar") 0 "zot" (3 . "zot") 3 "plonk" (8 . "zotplonk") "zotplonk")
(LET ((F "streamslong-tst-foo") (S "12345") L) (WITH-OPEN-FILE (O F :DIRECTION :OUTPUT) (WRITE-STRING S O)) (WITH-OPEN-FILE (I F :BUFFERED T) (LISTEN I) (PUSH (READ-CHAR I) L)) (WITH-OPEN-FILE (I F :BUFFERED NIL) (LISTEN I) (PUSH (READ-CHAR I) L)) (DELETE-FILE F) L)
EQUAL-OK: (#\1 #\1)
(LET ((FILE "streamslong-tst-foo") S1 S2) (WITH-OPEN-FILE (OUT FILE :DIRECTION :OUTPUT) (WRITE OUT :STREAM OUT) (TERPRI OUT) (SETQ S1 (WRITE-TO-STRING OUT)) (FORCE-OUTPUT OUT) (APPEASE-CERRORS (WITH-OPEN-FILE (IN FILE :DIRECTION :INPUT) (SETQ S2 (READ-LINE IN))))) (DELETE-FILE FILE) (STRING= S1 S2))
WARNING: OPEN:
         #<OUTPUT BUFFERED FILE-STREAM CHARACTER #P"streamslong-tst-foo">
         already points to file
         "/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/tests/streamslong-tst-foo"
         , opening the file again for :INPUT may produce unexpected results
         Open the file anyway
EQL-OK: T
(PROGN (DEFCLASS GRAY-OUT (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM) ((ACCUMULATOR :TYPE STRING))) (DEFMETHOD INITIALIZE-INSTANCE :AFTER ((S GRAY-OUT) &REST ARGS) (SETF (SLOT-VALUE S 'ACCUMULATOR) (MAKE-ARRAY 0 :ELEMENT-TYPE 'CHARACTER :ADJUSTABLE T :FILL-POINTER 0))) (DEFMETHOD STREAM-WRITE-CHAR ((S GRAY-OUT) CH) (VECTOR-PUSH-EXTEND CH (SLOT-VALUE S 'ACCUMULATOR))) (DEFMACRO WITH-G-O ((V) &BODY FORMS) `(LET ((,V (MAKE-INSTANCE 'GRAY-OUT))) ,@FORMS (CLOSE ,V) (COERCE (SLOT-VALUE ,V 'ACCUMULATOR) 'SIMPLE-STRING))) (LIST (WITH-G-O (V) (WRITE-CHAR #\a V)) (WITH-G-O (V) (WRITE-CHAR-SEQUENCE "abc" V)) (HANDLER-CASE (WITH-G-O (V) (WRITE-SEQUENCE #(#\a #\b #\c) V)) (METHOD-CALL-ERROR (E) (GENERIC-FUNCTION-NAME (METHOD-CALL-ERROR-GENERIC-FUNCTION E)))) (WITH-G-O (V) (STREAM-WRITE-CHAR-SEQUENCE V "abc")) (HANDLER-CASE (WITH-G-O (V) (STREAM-WRITE-SEQUENCE V #(#\a #\b #\c))) (METHOD-CALL-ERROR (E) (GENERIC-FUNCTION-NAME (METHOD-CALL-ERROR-GENERIC-FUNCTION E)))) (WITH-G-O (V) (STREAM-WRITE-SEQUENCE "abc" V)) (SETF (FIND-CLASS 'GRAY-OUT) NIL) (FMAKUNBOUND 'WITH-G-O)))
EQUAL-OK: ("a" "abc" STREAM-WRITE-CHAR-SEQUENCE "abc" STREAM-WRITE-SEQUENCE "abc" NIL WITH-G-O)
(LET ((FNAME "streamslong-tst-foo") (VEC (MAKE-ARRAY 5 :ELEMENT-TYPE '(UNSIGNED-BYTE 8)))) (FLET ((FOO (L) (UNWIND-PROTECT (LIST (WITH-OPEN-FILE (F FNAME :EXTERNAL-FORMAT :DOS :DIRECTION :IO) (DOLIST (S L) (WRITE-LINE S F)) (FILE-POSITION F 0) (READ-LINE F) (SETF (STREAM-ELEMENT-TYPE F) '(UNSIGNED-BYTE 8)) (READ-BYTE F NIL)) (MAPCAR (LAMBDA (B) (WITH-OPEN-FILE (F FNAME :DIRECTION :INPUT :BUFFERED B) (READ-LINE F) (SETF (STREAM-ELEMENT-TYPE F) '(UNSIGNED-BYTE 8)) (LIST B (READ-BYTE F NIL)))) '(T NIL)) (MAPCAR (LAMBDA (B) (WITH-OPEN-FILE (F FNAME :DIRECTION :INPUT :BUFFERED B) (READ-LINE F) (SETF (STREAM-ELEMENT-TYPE F) '(UNSIGNED-BYTE 8)) (LIST B (SUBSEQ VEC 0 (READ-SEQUENCE VEC F))))) '(T NIL))) (DELETE-FILE FNAME)))) (LIST (FOO '("1")) (FOO '("1" "2")))))
EQUALP-OK: ((NIL ((T NIL) (NIL NIL)) ((T #()) (NIL #()))) (50 ((T 50) (NIL 50)) ((T #(50 13 10)) (NIL #(50 13 10)))))
(LET ((FNAME "streamslong-tst-foo")) (FLET ((LINE-TERM (S) (ENCODING-LINE-TERMINATOR (STREAM-EXTERNAL-FORMAT S)))) (UNWIND-PROTECT (LIST (WITH-OPEN-FILE (F FNAME :DIRECTION :OUTPUT :EXTERNAL-FORMAT :DOS) (LET ((B (MAKE-BROADCAST-STREAM F))) (LIST (LIST (LINE-TERM B) (LINE-TERM F)) (PROGN (SETF (STREAM-EXTERNAL-FORMAT B :OUTPUT) :UNIX) (LIST (LINE-TERM B) (LINE-TERM F))) (LIST (STREAM-ELEMENT-TYPE B) (STREAM-ELEMENT-TYPE F)) (SETF (STREAM-ELEMENT-TYPE B) '(UNSIGNED-BYTE 8)) (LIST (STREAM-ELEMENT-TYPE B) (STREAM-ELEMENT-TYPE F))))) (WITH-OPEN-FILE (F FNAME :DIRECTION :INPUT :EXTERNAL-FORMAT :DOS) (LET ((C (MAKE-CONCATENATED-STREAM F))) (LIST (LIST (LINE-TERM C) (LINE-TERM F)) (PROGN (SETF (STREAM-EXTERNAL-FORMAT C :INPUT) :UNIX) (LIST (LINE-TERM C) (LINE-TERM F))) (LIST (STREAM-ELEMENT-TYPE C) (STREAM-ELEMENT-TYPE F)) (SETF (STREAM-ELEMENT-TYPE C) '(UNSIGNED-BYTE 8)) (LIST (STREAM-ELEMENT-TYPE C) (STREAM-ELEMENT-TYPE F)))))) (DELETE-FILE FNAME))))
EQUAL-OK: (((:DOS :DOS) (:UNIX :UNIX) (CHARACTER CHARACTER) (UNSIGNED-BYTE 8) ((UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8))) ((:DOS :DOS) (:UNIX :UNIX) (CHARACTER CHARACTER) (UNSIGNED-BYTE 8) ((UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8))))
(LET ((FNAME "test-eof") (*REOPEN-OPEN-FILE* NIL)) (OPEN FNAME :DIRECTION :PROBE :IF-EXISTS :OVERWRITE :IF-DOES-NOT-EXIST :CREATE) (FLET ((F (BUF NEW) (WITH-OPEN-FILE (IN FNAME :DIRECTION :INPUT) (LIST (READ-LINE IN NIL :EOF) (PROGN (WITH-OPEN-FILE (OUT FNAME :DIRECTION :OUTPUT :IF-EXISTS :APPEND) (WRITE-LINE NEW OUT)) (CLEAR-INPUT IN) (READ-LINE IN NIL :EOF)))))) (UNWIND-PROTECT (LIST (F T "foo") (F NIL "bar")) (DELETE-FILE FNAME))))
EQUAL-OK: ((:EOF "foo") ("foo" "bar"))
(LET* ((LIST NIL) (OUT (MAKE-BUFFERED-OUTPUT-STREAM (LAMBDA (C) (PUSH C LIST))))) (LIST (WRITE-CHAR #\a OUT) (CLOSE OUT) LIST))
EQUAL-OK: (#\a T ("a"))
(LET* ((LIST NIL) (OUT (MAKE-BUFFERED-OUTPUT-STREAM (LAMBDA (C) (PUSH C LIST) (ERROR (STRING C)))))) (LIST (WRITE-CHAR #\a OUT) (BLOCK B (HANDLER-BIND ((ERROR (HANDLER-RETURN B LIST))) (CLOSE OUT)))))
[SIMPLE-ERROR]: a
EQUAL-OK: (#\a ("a"))
(LET* ((LIST NIL) (OUT (MAKE-BUFFERED-OUTPUT-STREAM (LAMBDA (C) (PUSH C LIST) (ERROR (STRING C)))))) (LIST (WRITE-CHAR #\a OUT) (CLOSE OUT :ABORT T) LIST (PRINC-TO-STRING OUT)))
EQUAL-OK: (#\a T ("a") "#<CLOSED OUTPUT BUFFERED-OUTPUT-STREAM NIL>")
(LET ((FILE-IN "test-extfmt-in") (FILE-OUT "test-extfmt-out")) (OPEN FILE-IN :DIRECTION :PROBE :IF-DOES-NOT-EXIST :CREATE) (UNWIND-PROTECT (WITH-OPEN-FILE (OUT FILE-OUT :DIRECTION :OUTPUT :EXTERNAL-FORMAT :DOS) (WITH-OPEN-FILE (IN FILE-IN :DIRECTION :INPUT :EXTERNAL-FORMAT :DOS) (WITH-OPEN-STREAM (IO (MAKE-TWO-WAY-STREAM IN OUT)) (LIST (ENCODING-LINE-TERMINATOR (STREAM-EXTERNAL-FORMAT IO)) (ENCODING-LINE-TERMINATOR (SETF (STREAM-EXTERNAL-FORMAT IO) :UNIX)) (ENCODING-LINE-TERMINATOR (STREAM-EXTERNAL-FORMAT IO)) (ENCODING-LINE-TERMINATOR (STREAM-EXTERNAL-FORMAT IN)) (ENCODING-LINE-TERMINATOR (STREAM-EXTERNAL-FORMAT OUT)))))) (DELETE-FILE FILE-IN) (DELETE-FILE FILE-OUT)))
EQUAL-OK: (:DOS :UNIX :UNIX :UNIX :UNIX)
(LET ((FILE "test-extfmt")) (WITH-OPEN-FILE (OUT FILE :DIRECTION :OUTPUT :EXTERNAL-FORMAT :DOS :IF-EXISTS :SUPERSEDE) (TERPRI OUT) (SETF (STREAM-EXTERNAL-FORMAT OUT) :UNIX) (TERPRI OUT)) (UNWIND-PROTECT (WITH-OPEN-FILE (IN FILE :DIRECTION :INPUT :ELEMENT-TYPE '(UNSIGNED-BYTE 8)) (LET ((V (MAKE-ARRAY (FILE-LENGTH IN)))) (READ-SEQUENCE V IN) (MAP 'VECTOR #'CODE-CHAR V))) (DELETE-FILE FILE)))
EQUALP-OK: #(#\Return #\Newline #\Newline)
(LET ((FILE "test-pipe")) (UNWIND-PROTECT (DOLIST (B '(NIL T)) (WITH-OPEN-STREAM (OUT (MAKE-PIPE-OUTPUT-STREAM (FORMAT NIL "/bin/cat > ~A" FILE) :EXTERNAL-FORMAT CHARSET:UTF-8 :BUFFERED B)) (LOOP FOR I BELOW 1000 DO (PRINT I OUT))) (SLEEP 1) (WITH-OPEN-FILE (IN FILE :DIRECTION :INPUT :EXTERNAL-FORMAT CHARSET:UTF-8) (LOOP FOR I BELOW 1000 DO (ASSERT (= I (READ IN)))))) (DELETE-FILE FILE)))
EQL-OK: NIL
(SYMBOLS-CLEANUP '(*A* BIN-STREAM-TEST))
EQL-OK: NIL
RUN-TEST: finished "streamslong" (0 errors out of 25 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"strings.tst" @1>
(CHAR "abcdef-dg1ndh" 0)
EQL-OK: #\a
(CHAR "abcdef-dg1ndh" 1)
EQL-OK: #\b
(CHAR "abcdef-dg1ndh" 6)
EQL-OK: #\-
(CHAR "abcdef-dg1ndh" 20)
[SIMPLE-TYPE-ERROR]: CHAR: index 20 should be less than the length of the string

EQL-OK: ERROR
(CHAR "abcdef-dg1ndh")
[SIMPLE-SOURCE-PROGRAM-ERROR]: EVAL: too few arguments given to CHAR: #1=(CHAR "abcdef-dg1ndh")

EQL-OK: ERROR
(CHAR "abcdef-dg1ndh" -3)
[SIMPLE-TYPE-ERROR]: CHAR: index should not be negative: -3

EQL-OK: ERROR
(CHAR)
[SIMPLE-SOURCE-PROGRAM-ERROR]: EVAL: too few arguments given to CHAR: #1=(CHAR)

EQL-OK: ERROR
(CHAR 2)
[SIMPLE-SOURCE-PROGRAM-ERROR]: EVAL: too few arguments given to CHAR: #1=(CHAR 2)

EQL-OK: ERROR
(CHAR "abcde" 2 4)
[SIMPLE-SOURCE-PROGRAM-ERROR]: EVAL: too many arguments given to CHAR: #1=(CHAR "abcde" 2 4)

EQL-OK: ERROR
(CHAR 'A 0)
[SIMPLE-TYPE-ERROR]: CHAR: argument A is not a string

EQL-OK: ERROR
(CHAR 'ANNA 0)
[SIMPLE-TYPE-ERROR]: CHAR: argument ANNA is not a string

EQL-OK: ERROR
(SCHAR 'A 0)
[SIMPLE-TYPE-ERROR]: SCHAR: argument A is not a SIMPLE-STRING

EQL-OK: ERROR
(SCHAR 'ANNA 0)
[SIMPLE-TYPE-ERROR]: SCHAR: argument ANNA is not a SIMPLE-STRING

EQL-OK: ERROR
(SCHAR "abcdef-dg1ndh" 0)
EQL-OK: #\a
(SCHAR "abcdef-dg1ndh" 1)
EQL-OK: #\b
(SCHAR "abcdef-dg1ndh" 6)
EQL-OK: #\-
(SCHAR "abcdef-dg1ndh" 20)
[SIMPLE-TYPE-ERROR]: SCHAR: index 20 should be less than the length of the string

EQL-OK: ERROR
(SCHAR "abcdef-dg1ndh")
[SIMPLE-SOURCE-PROGRAM-ERROR]: EVAL: too few arguments given to SCHAR: #1=(SCHAR "abcdef-dg1ndh")

EQL-OK: ERROR
(SCHAR "abcdef-dg1ndh" -3)
[SIMPLE-TYPE-ERROR]: SCHAR: index should not be negative: -3

EQL-OK: ERROR
(SCHAR2)
[SIMPLE-UNDEFINED-FUNCTION]: EVAL: undefined function SCHAR2

EQL-OK: ERROR
(SCHAR2 2)
[SIMPLE-UNDEFINED-FUNCTION]: EVAL: undefined function SCHAR2

EQL-OK: ERROR
(SCHAR "abcde" 2 4)
[SIMPLE-SOURCE-PROGRAM-ERROR]: EVAL: too many arguments given to SCHAR: #1=(SCHAR "abcde" 2 4)

EQL-OK: ERROR
(STRING= "foo" "foo")
EQL-OK: T
(STRING= "foo" "Foo")
EQL-OK: NIL
(STRING= "foo" "FOO")
EQL-OK: NIL
(STRING= "foo" "bar")
EQL-OK: NIL
(STRING= "together" "frog" :START1 1 :END1 3 :START2 2)
EQL-OK: T
(STRING= "abcdef" "defghi" :START1 3 :END2 3)
EQL-OK: T
(STRING= "abcdefghi" "uvdefmgnj" :START1 3 :END1 6 :START2 2 :END2 5)
EQL-OK: T
(STRING= "abcdefg" "abcdefg" :END2 4)
EQL-OK: NIL
(STRING= "abcdef" "abcdef" :START1 1 :END1 4 :START2 4 :END2 1)
[SIMPLE-ERROR]: STRING=: :START2-index 4 must not be greater than :END2-index 1

EQL-OK: ERROR
(STRING-EQUAL "foo" "foo")
EQL-OK: T
(STRING-EQUAL "foo" "Foo")
EQL-OK: T
(STRING-EQUAL "foo" "FOO")
EQL-OK: T
(STRING-EQUAL "foo" "bar")
EQL-OK: NIL
(STRING-EQUAL "absDEfg-HijM1#r" "udEFG-hIfvd" :START1 3 :END1 10 :START2 1 :END2 8)
EQL-OK: T
(STRING-EQUAL "ABCdefg" "abcDEFG")
EQL-OK: T
(STRING-EQUAL "ABCdefg" "abcDEFG" :START1 3)
EQL-OK: NIL
(STRING-EQUAL "AbCdEf" "aBcDeF" :START1 5 :END1 3)
[SIMPLE-ERROR]: STRING-EQUAL: :START1-index 5 must not be greater than :END1-index 3

EQL-OK: ERROR
(STRING< "" "abcdefgh")
EQL-OK: 0
(STRING< "a" "abcdefgh")
EQL-OK: 1
(STRING< "abc" "abcdefgh")
EQL-OK: 3
(STRING< "cabc" "abcdefgh")
EQL-OK: NIL
(STRING< "abcdefgh" "abcdefgh")
EQL-OK: NIL
(STRING< "xyzabc" "abcdefgh")
EQL-OK: NIL
(STRING< "abc" "xyzabcdefgh")
EQL-OK: 0
(STRING< "abcdefgh" "abcdefgh" :END1 4)
EQL-OK: 4
(STRING< "xyzabc" "abcdefgh" :START1 3)
EQL-OK: 6
(STRING< "abc" "xyzabcdefgh" :START2 3)
EQL-OK: 3
(STRING< "abc" "xyzabcdefgh" :START2 3 :END2 8)
EQL-OK: 3
(STRING< "abc" "xyzabcdefgh" :START2 3 :END2 5)
EQL-OK: NIL
(STRING< "abcdefgh" "")
EQL-OK: NIL
(STRING< "abcdefgh" "a")
EQL-OK: NIL
(STRING< "abcdefgh" "abc")
EQL-OK: NIL
(STRING< "abcdefgh" "cabc")
EQL-OK: 0
(STRING< "abcdefgh" "xyzabc")
EQL-OK: 0
(STRING< "xyzabcdefgh" "abc")
EQL-OK: NIL
(STRING< "abcdefgh" "abcdefgh" :END2 4)
EQL-OK: NIL
(STRING< "xyzabc" "abcdefgh" :START2 3)
EQL-OK: NIL
(STRING< "abc" "xyzabcdefgh" :START2 3)
EQL-OK: 3
(STRING< "abc" "xyzabcdefgh" :START2 3 :END2 8)
EQL-OK: 3
(STRING< "abc" "xyzabcdefgh" :START2 3 :END2 5)
EQL-OK: NIL
(STRING< "abcdef" "bcdefgh")
EQL-OK: 0
(STRING< "abcdef" "abcdefgh" :START2 2)
EQL-OK: 0
(STRING< "abcdef" "bngdabcdef" :START2 9 :END2 5)
[SIMPLE-ERROR]: STRING<: :START2-index 9 must not be greater than :END2-index 5

EQL-OK: ERROR
(STRING> "" "abcdefgh")
EQL-OK: NIL
(STRING> "a" "abcdefgh")
EQL-OK: NIL
(STRING> "abc" "abcdefgh")
EQL-OK: NIL
(STRING> "cabc" "abcdefgh")
EQL-OK: 0
(STRING> "abcdefgh" "abcdefgh")
EQL-OK: NIL
(STRING> "xyzabc" "abcdefgh")
EQL-OK: 0
(STRING> "abc" "xyzabcdefgh")
EQL-OK: NIL
(STRING> "abcdefgh" "abcdefgh" :END1 4)
EQL-OK: NIL
(STRING> "xyzabc" "abcdefgh" :START1 3)
EQL-OK: NIL
(STRING> "abc" "xyzabcdefgh" :START2 3)
EQL-OK: NIL
(STRING> "abc" "xyzabcdefgh" :START2 3 :END2 8)
EQL-OK: NIL
(STRING> "abc" "xyzabcdefgh" :START2 3 :END2 5)
EQL-OK: 2
(STRING> "abcdefgh" "")
EQL-OK: 0
(STRING> "abcdefgh" "a")
EQL-OK: 1
(STRING> "abcdefgh" "abc")
EQL-OK: 3
(STRING> "abcdefgh" "cabc")
EQL-OK: NIL
(STRING> "abcdefgh" "xyzabc")
EQL-OK: NIL
(STRING> "xyzabcdefgh" "abc")
EQL-OK: 0
(STRING> "abcdefgh" "abcdefgh" :END2 4)
EQL-OK: 4
(STRING> "xyzabc" "abcdefgh" :START2 3)
EQL-OK: 0
(STRING> "abc" "xyzabcdefgh" :START2 3)
EQL-OK: NIL
(STRING> "abc" "xyzabcdefgh" :START2 3 :END2 8)
EQL-OK: NIL
(STRING> "abc" "xyzabcdefgh" :START2 3 :END2 5)
EQL-OK: 2
(STRING> "abcde" "bc")
EQL-OK: NIL
(STRING> "bcdef" "abcde")
EQL-OK: 0
(STRING> "bcdef" "abcdef")
EQL-OK: 0
(STRING> "abcdefghij" "abcdefgh" :START1 1)
EQL-OK: 1
(STRING> "ghijkl" "xyzabcd" :START2 6 :END2 4)
[SIMPLE-ERROR]: STRING>: :START2-index 6 must not be greater than :END2-index 4

EQL-OK: ERROR
(STRING< "" "abcdefgh")
EQL-OK: 0
(STRING<= "a" "abcdefgh")
EQL-OK: 1
(STRING<= "abc" "abcdefgh")
EQL-OK: 3
(STRING<= "aaabce" "aaabcdefgh")
EQL-OK: NIL
(STRING<= "cabc" "abcdefgh")
EQL-OK: NIL
(STRING<= "abcdefgh" "abcdefgh")
EQL-OK: 8
(STRING<= "xyzabc" "abcdefgh")
EQL-OK: NIL
(STRING<= "abc" "xyzabcdefgh")
EQL-OK: 0
(STRING<= "abcdefgh" "abcdefgh" :END1 4)
EQL-OK: 4
(STRING<= "xyzabc" "abcdefgh" :START1 3)
EQL-OK: 6
(STRING<= "abc" "xyzabcdefgh" :START2 3)
EQL-OK: 3
(STRING<= "abc" "xyzabcdefgh" :START2 3 :END2 8)
EQL-OK: 3
(STRING<= "abc" "xyzabcdefgh" :START2 3 :END2 5)
EQL-OK: NIL
(STRING<= "abcdefgh" "")
EQL-OK: NIL
(STRING<= "abcdefgh" "a")
EQL-OK: NIL
(STRING<= "abcdefgh" "abc")
EQL-OK: NIL
(STRING<= "abcdefgh" "cabc")
EQL-OK: 0
(STRING<= "abcdefgh" "xyzabc")
EQL-OK: 0
(STRING<= "xyzabcdefgh" "abc")
EQL-OK: NIL
(STRING<= "abcdefgh" "abcdefgh" :END2 4)
EQL-OK: NIL
(STRING<= "xyzabc" "abcdefgh" :START2 3)
EQL-OK: NIL
(STRING<= "abc" "xyzabcdefgh" :START2 3)
EQL-OK: 3
(STRING<= "abc" "xyzabcdefgh" :START2 3 :END2 8)
EQL-OK: 3
(STRING<= "abc" "xyzabcdefgh" :START2 3 :END2 5)
EQL-OK: NIL
(STRING<= "abcdef" "bcdefgh")
EQL-OK: 0
(STRING<= "abcdef" "abcdefgh" :START2 2)
EQL-OK: 0
(STRING<= "abcdef" "bngdabcdef" :START2 9 :END2 5)
[SIMPLE-ERROR]: STRING<=: :START2-index 9 must not be greater than :END2-index 5

EQL-OK: ERROR
(STRING>= "" "abcdefgh")
EQL-OK: NIL
(STRING>= "a" "abcdefgh")
EQL-OK: NIL
(STRING>= "abc" "abcdefgh")
EQL-OK: NIL
(STRING>= "cabc" "abcdefgh")
EQL-OK: 0
(STRING>= "abcdefgh" "abcdefgh")
EQL-OK: 8
(STRING>= "xyzabc" "abcdefgh")
EQL-OK: 0
(STRING>= "abc" "xyzabcdefgh")
EQL-OK: NIL
(STRING>= "abcdefgh" "abcdefgh" :END1 4)
EQL-OK: NIL
(STRING>= "xyzabc" "abcdefgh" :START1 3)
EQL-OK: NIL
(STRING>= "abc" "xyzabcdefgh" :START2 3)
EQL-OK: NIL
(STRING>= "abc" "xyzabcdefgh" :START2 3 :END2 8)
EQL-OK: NIL
(STRING>= "abc" "xyzabcdefgh" :START2 3 :END2 5)
EQL-OK: 2
(STRING>= "abcdefgh" "")
EQL-OK: 0
(STRING>= "abcdefgh" "a")
EQL-OK: 1
(STRING>= "abcdefgh" "abc")
EQL-OK: 3
(STRING>= "abcdefgh" "cabc")
EQL-OK: NIL
(STRING>= "abcdefgh" "xyzabc")
EQL-OK: NIL
(STRING>= "xyzabcdefgh" "abc")
EQL-OK: 0
(STRING>= "abcdefgh" "abcdefgh" :END2 4)
EQL-OK: 4
(STRING>= "xyzabc" "abcdefgh" :START2 3)
EQL-OK: 0
(STRING>= "xyzabc" "abcdefgh" :START1 3)
EQL-OK: NIL
(STRING>= "abc" "xyzabcdefgh" :START2 3)
EQL-OK: NIL
(STRING>= "abc" "xyzabcdefgh" :START2 3 :END2 8)
EQL-OK: NIL
(STRING>= "abc" "xyzabcdefgh" :START2 3 :END2 5)
EQL-OK: 2
(STRING>= "bcdef" "abcdef")
EQL-OK: 0
(STRING>= "abcdefghij" "abcdefgh" :START1 1)
EQL-OK: 1
(STRING>= "ghijkl" "xyzabcd" :START2 6 :END2 4)
[SIMPLE-ERROR]: STRING>=: :START2-index 6 must not be greater than :END2-index 4

EQL-OK: ERROR
(STRING/= "" "abcdefgh")
EQL-OK: 0
(STRING/= "a" "abcdefgh")
EQL-OK: 1
(STRING/= "abc" "abcdefgh")
EQL-OK: 3
(STRING/= "cabc" "abcdefgh")
EQL-OK: 0
(STRING/= "abcdefgh" "abcdefgh")
EQL-OK: NIL
(STRING/= "xyzabc" "abcdefgh")
EQL-OK: 0
(STRING/= "abc" "xyzabcdefgh")
EQL-OK: 0
(STRING/= "abcdefgh" "abcdefgh" :END1 4)
EQL-OK: 4
(STRING/= "xyzabc" "abcdefgh" :START1 3)
EQL-OK: 6
(STRING/= "abc" "xyzabcdefgh" :START2 3)
EQL-OK: 3
(STRING/= "abc" "xyzabcdefgh" :START2 3 :END2 8)
EQL-OK: 3
(STRING/= "abc" "xyzabcdefgh" :START2 3 :END2 5)
EQL-OK: 2
(STRING/= "abcdefgh" "")
EQL-OK: 0
(STRING/= "abcdefgh" "a")
EQL-OK: 1
(STRING/= "abcdefgh" "abc")
EQL-OK: 3
(STRING/= "abcdefgh" "cabc")
EQL-OK: 0
(STRING/= "abcdefgh" "xyzabc")
EQL-OK: 0
(STRING/= "xyzabcdefgh" "abc")
EQL-OK: 0
(STRING/= "abcdefgh" "abcdefgh" :END2 4)
EQL-OK: 4
(STRING/= "xyzabc" "abcdefgh" :START2 3)
EQL-OK: 0
(STRING/= "abc" "xyzabcdefgh" :START2 3)
EQL-OK: 3
(STRING/= "abc" "xyzabcdefgh" :START2 3 :END2 8)
EQL-OK: 3
(STRING/= "abc" "xyzabcdefgh" :START2 3 :END2 5)
EQL-OK: 2
(STRING/= "abcdefghi" "uvdefmgnj" :START1 3 :END1 6 :START2 2 :END2 5)
EQL-OK: NIL
(STRING/= "abcdefg" "abcdefg" :END2 4)
EQL-OK: 4
(STRING/= "abcdef" "abcdef" :START1 1 :END1 4 :START2 4 :END2 1)
[SIMPLE-ERROR]: STRING/=: :START2-index 4 must not be greater than :END2-index 1

EQL-OK: ERROR
(STRING-LESSP "" "abcDEFgh")
EQL-OK: 0
(STRING-LESSP "a" "Abcdefgh")
EQL-OK: 1
(STRING-LESSP "abc" "aBcDEfgh")
EQL-OK: 3
(STRING-LESSP "cABc" "aBCDefgh")
EQL-OK: NIL
(STRING-LESSP "abCDeFgh" "abCDEfgh")
EQL-OK: NIL
(STRING-LESSP "xyzAbc" "ABcCDfgh")
EQL-OK: NIL
(STRING-LESSP "aBC" "xYZAbcdEfgh")
EQL-OK: 0
(STRING-LESSP "abcDEfgh" "abcDEfgh" :END1 4)
EQL-OK: 4
(STRING-LESSP "XYZabc" "ABcdefgh" :START1 3)
EQL-OK: 6
(STRING-LESSP "aBc" "xyZABcdefgh" :START2 3)
EQL-OK: 3
(STRING-LESSP "abc" "xyzabCDEcdefgh" :START2 3 :END2 8)
EQL-OK: 3
(STRING-LESSP "abc" "xyzABcdefgh" :START2 3 :END2 5)
EQL-OK: NIL
(STRING-LESSP "abcdefgh" "")
EQL-OK: NIL
(STRING-LESSP "Abcdefgh" "a")
EQL-OK: NIL
(STRING-LESSP "ABCdefgh" "abc")
EQL-OK: NIL
(STRING-LESSP "ABCdefgh" "cabc")
EQL-OK: 0
(STRING-LESSP "abcdefgh" "xyzABC")
EQL-OK: 0
(STRING-LESSP "xyzABCdefgh" "abc")
EQL-OK: NIL
(STRING-LESSP "abcdEFgh" "abcdeFGh" :END2 4)
EQL-OK: NIL
(STRING-LESSP "xyzaBC" "abCDefgh" :START2 3)
EQL-OK: NIL
(STRING-LESSP "ABC" "xyzabcdefgh" :START2 3)
EQL-OK: 3
(STRING-LESSP "ABC" "xyzabcdefgh" :START2 3 :END2 8)
EQL-OK: 3
(STRING-LESSP "ABC" "xyzabcdefgh" :START2 3 :END2 5)
EQL-OK: NIL
(STRING-LESSP "aBCDef" "bcdefgh")
EQL-OK: 0
(STRING-LESSP "aBCDef" "abcdefgh" :START2 2)
EQL-OK: 0
(STRING-LESSP "aBCDef" "bngdabcdef" :START2 9 :END2 5)
[SIMPLE-ERROR]: STRING-LESSP: :START2-index 9 must not be greater than :END2-index 5

EQL-OK: ERROR
(STRING-GREATERP "" "abcdefgh")
EQL-OK: NIL
(STRING-GREATERP "A" "abcdefgh")
EQL-OK: NIL
(STRING-GREATERP "ABc" "abcdefgh")
EQL-OK: NIL
(STRING-GREATERP "CAbc" "abcdefgh")
EQL-OK: 0
(STRING-GREATERP "abcdefgh" "abcDEFgh")
EQL-OK: NIL
(STRING-GREATERP "xyzabc" "abCDEfgh")
EQL-OK: 0
(STRING-GREATERP "ABC" "xyzabcdefgh")
EQL-OK: NIL
(STRING-GREATERP "ABCdefgh" "abcdefgh" :END1 4)
EQL-OK: NIL
(STRING-GREATERP "xyzaBc" "ABCdefgh" :START1 3)
EQL-OK: NIL
(STRING-GREATERP "abc" "xyzABcdefgh" :START2 3)
EQL-OK: NIL
(STRING-GREATERP "abc" "xyzABcdefgh" :START2 3 :END2 8)
EQL-OK: NIL
(STRING-GREATERP "abc" "xyZAbcdefgh" :START2 3 :END2 5)
EQL-OK: 2
(STRING-GREATERP "abcdefgh" "")
EQL-OK: 0
(STRING-GREATERP "Abcdefgh" "a")
EQL-OK: 1
(STRING-GREATERP "ABCdefgh" "abc")
EQL-OK: 3
(STRING-GREATERP "ABCdefgh" "cabc")
EQL-OK: NIL
(STRING-GREATERP "ABCdefgh" "xyzabc")
EQL-OK: NIL
(STRING-GREATERP "xyzabcdefgh" "Abc")
EQL-OK: 0
(STRING-GREATERP "abcdefgh" "aBCDefgh" :END2 4)
EQL-OK: 4
(STRING-GREATERP "xyzabc" "abcdEFgh" :START2 3)
EQL-OK: 0
(STRING-GREATERP "ABC" "xyzabcdefgh" :START2 3)
EQL-OK: NIL
(STRING-GREATERP "ABC" "xyzabcdefgh" :START2 3 :END2 8)
EQL-OK: NIL
(STRING-GREATERP "ABC" "xyzabcdefgh" :START2 3 :END2 5)
EQL-OK: 2
(STRING-GREATERP "bCDEf" "abcde")
EQL-OK: 0
(STRING-GREATERP "bcDEF" "abcdef")
EQL-OK: 0
(STRING-GREATERP "abCDEfghij" "abcdefgh" :START1 1)
EQL-OK: 1
(STRING-GREATERP "ghijKl" "xyzabcd" :START2 6 :END2 4)
[SIMPLE-ERROR]: STRING-GREATERP: :START2-index 6 must not be greater than :END2-index 4

EQL-OK: ERROR
(STRING-NOT-GREATERP "" "abcdefgh")
EQL-OK: 0
(STRING-NOT-GREATERP "A" "abcdefgh")
EQL-OK: 1
(STRING-NOT-GREATERP "aBC" "abcdefgh")
EQL-OK: 3
(STRING-NOT-GREATERP "CABc" "abcdefgh")
EQL-OK: NIL
(STRING-NOT-GREATERP "abcDEFgh" "abcdefgh")
EQL-OK: 8
(STRING-NOT-GREATERP "xyzabc" "ABcdefgh")
EQL-OK: NIL
(STRING-NOT-GREATERP "abc" "xyzABcdefgh")
EQL-OK: 0
(STRING-NOT-GREATERP "ABCDEFgh" "abcdefgh" :END1 4)
EQL-OK: 4
(STRING-NOT-GREATERP "xyzabc" "aBCDefgh" :START1 3)
EQL-OK: 6
(STRING-NOT-GREATERP "ABC" "xyzabcdefgh" :START2 3)
EQL-OK: 3
(STRING-NOT-GREATERP "ABC" "xyzabcdefgh" :START2 3 :END2 8)
EQL-OK: 3
(STRING-NOT-GREATERP "ABC" "xyzabcdefgh" :START2 3 :END2 5)
EQL-OK: NIL
(STRING-NOT-GREATERP "abcdefgh" "")
EQL-OK: NIL
(STRING-NOT-GREATERP "Abcdefgh" "a")
EQL-OK: NIL
(STRING-NOT-GREATERP "ABCdefgh" "abc")
EQL-OK: NIL
(STRING-NOT-GREATERP "ABCdefgh" "cabc")
EQL-OK: 0
(STRING-NOT-GREATERP "ABCdefgh" "xyzabc")
EQL-OK: 0
(STRING-NOT-GREATERP "xyzABCdefgh" "abc")
EQL-OK: NIL
(STRING-NOT-GREATERP "abcdeFgh" "abcdefgh" :END2 4)
EQL-OK: NIL
(STRING-NOT-GREATERP "xyzABC" "abcdefgh" :START2 3)
EQL-OK: NIL
(STRING-NOT-GREATERP "ABC" "xyzabcdefgh" :START2 3)
EQL-OK: 3
(STRING-NOT-GREATERP "ABC" "xyzabcdefgh" :START2 3 :END2 8)
EQL-OK: 3
(STRING-NOT-GREATERP "ABC" "xyzabcdefgh" :START2 3 :END2 5)
EQL-OK: NIL
(STRING-NOT-GREATERP "abcDEF" "bcdefgh")
EQL-OK: 0
(STRING-NOT-GREATERP "abcDEF" "abcdefgh" :START2 2)
EQL-OK: 0
(STRING-NOT-GREATERP "abcdef" "bngDAbcdef" :START2 9 :END2 5)
[SIMPLE-ERROR]: STRING-NOT-GREATERP: :START2-index 9 must not be greater than :END2-index 5

EQL-OK: ERROR
(STRING-NOT-LESSP "" "abcdefgh")
EQL-OK: NIL
(STRING-NOT-LESSP "a" "Abcdefgh")
EQL-OK: NIL
(STRING-NOT-LESSP "ABC" "abcdefgh")
EQL-OK: NIL
(STRING-NOT-LESSP "CABc" "abcdefgh")
EQL-OK: 0
(STRING-NOT-LESSP "ABCdefgh" "abcdefgh")
EQL-OK: 8
(STRING-NOT-LESSP "xyzABC" "abcdefgh")
EQL-OK: 0
(STRING-NOT-LESSP "ABC" "xyzabcdefgh")
EQL-OK: NIL
(STRING-NOT-LESSP "ABCdefgh" "abcdefgh" :END1 4)
EQL-OK: NIL
(STRING-NOT-LESSP "xyzABC" "abcdefgh" :START1 3)
EQL-OK: NIL
(STRING-NOT-LESSP "ABC" "xyzabcdefgh" :START2 3)
EQL-OK: NIL
(STRING-NOT-LESSP "ABC" "xyzabcdefgh" :START2 3 :END2 8)
EQL-OK: NIL
(STRING-NOT-LESSP "ABC" "xyzabcdefgh" :START2 3 :END2 5)
EQL-OK: 2
(STRING-NOT-LESSP "abcdefgh" "")
EQL-OK: 0
(STRING-NOT-LESSP "Abcdefgh" "a")
EQL-OK: 1
(STRING-NOT-LESSP "ABCdefgh" "abc")
EQL-OK: 3
(STRING-NOT-LESSP "abCDEfgh" "cabc")
EQL-OK: NIL
(STRING-NOT-LESSP "aBCdefgh" "xyzabc")
EQL-OK: NIL
(STRING-NOT-LESSP "xyzABcdefgh" "abc")
EQL-OK: 0
(STRING-NOT-LESSP "abCDEfgh" "abcdefgh" :END2 4)
EQL-OK: 4
(STRING-NOT-LESSP "xyzABc" "abcdefgh" :START2 3)
EQL-OK: 0
(STRING-NOT-LESSP "ABC" "xyzabcdefgh" :START2 3)
EQL-OK: NIL
(STRING-NOT-LESSP "ABC" "xyzabcdefgh" :START2 3 :END2 8)
EQL-OK: NIL
(STRING-NOT-LESSP "ABC" "xyzabcdefgh" :START2 3 :END2 5)
EQL-OK: 2
(STRING-NOT-LESSP "bCDef" "abcdef")
EQL-OK: 0
(STRING-NOT-LESSP "ABCdefghij" "abcdefgh" :START1 1)
EQL-OK: 1
(STRING-NOT-LESSP "ghIjkl" "xyzabcd" :START2 6 :END2 4)
[SIMPLE-ERROR]: STRING-NOT-LESSP: :START2-index 6 must not be greater than :END2-index 4

EQL-OK: ERROR
(STRING-NOT-EQUAL "" "abcdefgh")
EQL-OK: 0
(STRING-NOT-EQUAL "A" "abcdefgh")
EQL-OK: 1
(STRING-NOT-EQUAL "ABc" "abcdefgh")
EQL-OK: 3
(STRING-NOT-EQUAL "cABc" "abcdefgh")
EQL-OK: 0
(STRING-NOT-EQUAL "ABCdefgh" "abcdefgh")
EQL-OK: NIL
(STRING-NOT-EQUAL "xyzABc" "abcdefgh")
EQL-OK: 0
(STRING-NOT-EQUAL "ABC" "xyzabcdefgh")
EQL-OK: 0
(STRING-NOT-EQUAL "ABCdefgh" "abcdefgh" :END1 4)
EQL-OK: 4
(STRING-NOT-EQUAL "xyzaBC" "abcdefgh" :START1 3)
EQL-OK: 6
(STRING-NOT-EQUAL "ABC" "xyzabcdefgh" :START2 3)
EQL-OK: 3
(STRING-NOT-EQUAL "ABC" "xyzabcdefgh" :START2 3 :END2 8)
EQL-OK: 3
(STRING-NOT-EQUAL "ABC" "xyzabcdefgh" :START2 3 :END2 5)
EQL-OK: 2
(STRING-NOT-EQUAL "abcdefgh" "")
EQL-OK: 0
(STRING-NOT-EQUAL "Abcdefgh" "a")
EQL-OK: 1
(STRING-NOT-EQUAL "aBCdefgh" "abc")
EQL-OK: 3
(STRING-NOT-EQUAL "abcdefgh" "cABc")
EQL-OK: 0
(STRING-NOT-EQUAL "abcdefgh" "xyzAbc")
EQL-OK: 0
(STRING-NOT-EQUAL "xyzabcdefgh" "ABC")
EQL-OK: 0
(STRING-NOT-EQUAL "abcdefgh" "abcDEFgh" :END2 4)
EQL-OK: 4
(STRING-NOT-EQUAL "xyzabc" "aBCDefgh" :START2 3)
EQL-OK: 0
(STRING-NOT-EQUAL "abc" "xyzABCdefgh" :START2 3)
EQL-OK: 3
(STRING-NOT-EQUAL "abc" "xyzABCdefgh" :START2 3 :END2 8)
EQL-OK: 3
(STRING-NOT-EQUAL "abc" "xyzABCdefgh" :START2 3 :END2 5)
EQL-OK: 2
(STRING/= "abcdefghi" "uvdEFmgnj" :START1 3 :END1 6 :START2 2 :END2 5)
EQL-OK: 4
(STRING/= "abcdefg" "abcDEfg" :END2 4)
EQL-OK: 3
(STRING/= "abcdef" "abCDef" :START1 1 :END1 4 :START2 4 :END2 1)
[SIMPLE-ERROR]: STRING/=: :START2-index 4 must not be greater than :END2-index 1

EQL-OK: ERROR
(STRING-TRIM '(#\Space #\Tab #\Newline) " garbanzo beans
   ")
EQUAL-OK: "garbanzo beans"
(STRING-TRIM " (*)" " ( *three(siily) words* ) ")
EQUAL-OK: "three(siily) words"
(STRING-TRIM 'A "ababa")
[SIMPLE-TYPE-ERROR]: FIND: A is not a SEQUENCE

EQL-OK: ERROR
(STRING-TRIM '(A) "ababa")
EQUAL-OK: "ababa"
(STRING-TRIM "a" "ababa")
EQUAL-OK: "bab"
(STRING-TRIM "c e" "    ceabceabce    c")
EQUAL-OK: "abceab"
(STRING-TRIM '(#\a) "abcd")
EQUAL-OK: "bcd"
(STRING-TRIM '(#\a) "xyzabcd")
EQUAL-OK: "xyzabcd"
(STRING-TRIM '(#\a) "abcda")
EQUAL-OK: "bcd"
(STRING-LEFT-TRIM '(#\Space #\Tab #\Newline) " garbanzo beans
   ")
EQUAL-OK: "garbanzo beans
   "
(STRING-LEFT-TRIM " (*)" " ( *three(siily) words* ) ")
EQUAL-OK: "three(siily) words* ) "
(STRING-LEFT-TRIM 'A "ababa")
[SIMPLE-TYPE-ERROR]: FIND: A is not a SEQUENCE

EQL-OK: ERROR
(STRING-LEFT-TRIM '(A) "ababa")
EQUAL-OK: "ababa"
(STRING-LEFT-TRIM "a" "ababa")
EQUAL-OK: "baba"
(STRING-LEFT-TRIM "c e" "    ceabceabce    c")
EQUAL-OK: "abceabce    c"
(STRING-LEFT-TRIM '(#\a) "abcd")
EQUAL-OK: "bcd"
(STRING-LEFT-TRIM '(#\a) "xyzabcd")
EQUAL-OK: "xyzabcd"
(STRING-LEFT-TRIM '(#\a) "abcda")
EQUAL-OK: "bcda"
(STRING-RIGHT-TRIM '(#\Space #\Tab #\Newline) " garbanzo beans
   ")
EQUAL-OK: " garbanzo beans"
(STRING-RIGHT-TRIM " (*)" " ( *three(siily) words* ) ")
EQUAL-OK: " ( *three(siily) words"
(STRING-RIGHT-TRIM 'A "ababa")
[SIMPLE-TYPE-ERROR]: FIND: A is not a SEQUENCE

EQL-OK: ERROR
(STRING-RIGHT-TRIM '(A) "ababa")
EQUAL-OK: "ababa"
(STRING-RIGHT-TRIM "a" "ababa")
EQUAL-OK: "abab"
(STRING-RIGHT-TRIM "c e" "    ceabceabce    c")
EQUAL-OK: "    ceabceab"
(STRING-RIGHT-TRIM '(#\a) "abcd")
EQUAL-OK: "abcd"
(STRING-RIGHT-TRIM '(#\a) "xyzabcd")
EQUAL-OK: "xyzabcd"
(STRING-RIGHT-TRIM '(#\a) "abcda")
EQUAL-OK: "abcd"
(STRING-UPCASE "abCD efGh-ij")
EQUAL-OK: "ABCD EFGH-IJ"
(STRING-UPCASE "abCD efGh-ij" :START 5)
EQUAL-OK: "abCD EFGH-IJ"
(STRING-UPCASE "abCD efGh-ij" :END 5)
EQUAL-OK: "ABCD efGh-ij"
(STRING-UPCASE "abCD efGh-ij" :START 1 :END 6)
EQUAL-OK: "aBCD EfGh-ij"
(STRING-UPCASE "abCD efGh-ij" :START 6 :END 1)
[SIMPLE-ERROR]: STRING-UPCASE: :START-index 6 must not be greater than :END-index 1

EQL-OK: ERROR
(STRING-UPCASE "abCD efGh-ij" :START 3 :END 3)
EQUAL-OK: "abCD efGh-ij"
(STRING-DOWNCASE "abCD efGh-ij")
EQUAL-OK: "abcd efgh-ij"
(STRING-DOWNCASE "abCD efGh-ij" :START 3)
EQUAL-OK: "abCd efgh-ij"
(STRING-DOWNCASE "abCD efGh-ij" :END 3)
EQUAL-OK: "abcD efGh-ij"
(STRING-DOWNCASE "abCD efGh-ij" :START 3 :END 3)
EQUAL-OK: "abCD efGh-ij"
(STRING-DOWNCASE "abCD efGh-ij" :START 1 :END 6)
EQUAL-OK: "abcd efGh-ij"
(STRING-DOWNCASE "abCD efGh-ij" :START 6 :END 1)
[SIMPLE-ERROR]: STRING-DOWNCASE: :START-index 6 must not be greater than :END-index 1

EQL-OK: ERROR
(STRING-CAPITALIZE "abcd def g hi")
EQUAL-OK: "Abcd Def G Hi"
(STRING-CAPITALIZE "abCd dEf G hi")
EQUAL-OK: "Abcd Def G Hi"
(STRING-CAPITALIZE "Abcd Def G Hi")
EQUAL-OK: "Abcd Def G Hi"
(STRING-CAPITALIZE "abcd def g hi" :START 6)
EQUAL-OK: "abcd dEf G Hi"
(STRING-CAPITALIZE "abcd def g hi" :END 6)
EQUAL-OK: "Abcd Def g hi"
(STRING-CAPITALIZE "abcd def g hi" :START 2 :END 10)
EQUAL-OK: "abCd Def G hi"
(STRING-CAPITALIZE "abcd def g hi" :START 10 :END 2)
[SIMPLE-ERROR]: STRING-CAPITALIZE: :START-index 10 must not be greater than :END-index 2

EQL-OK: ERROR
(STRING-CAPITALIZE "don't")
EQUAL-OK: "Don'T"
(STRING-CAPITALIZE "DON'T")
EQUAL-OK: "Don'T"
(STRING-CAPITALIZE "34a 5BC")
EQUAL-OK: "34a 5bc"
(STRING 65)
[SIMPLE-TYPE-ERROR]: STRING: argument 65 should be a string, a symbol or a character

EQL-OK: ERROR
(STRING 'A)
EQUAL-OK: "A"
(STRING #\a)
EQUAL-OK: "a"
(STRING "abc")
EQUAL-OK: "abc"
(NSTRING-UPCASE "abCD efGh-ij")
EQUAL-OK: "ABCD EFGH-IJ"
(NSTRING-UPCASE "abCD efGh-ij" :START 5)
EQUAL-OK: "abCD EFGH-IJ"
(NSTRING-UPCASE "abCD efGh-ij" :END 5)
EQUAL-OK: "ABCD efGh-ij"
(NSTRING-UPCASE "abCD efGh-ij" :START6 :END 1)
[SIMPLE-PROGRAM-ERROR]: NSTRING-UPCASE: keyword arguments in (:START6 :END 1) should occur pairwise

EQL-OK: ERROR
(NSTRING-UPCASE "abCD efGh-ij" :START 3 :END 3)
EQUAL-OK: "abCD efGh-ij"
(NSTRING-DOWNCASE "abCD efGh-ij")
EQUAL-OK: "abcd efgh-ij"
(NSTRING-DOWNCASE "abCD efGh-ij" :START 3)
EQUAL-OK: "abCd efgh-ij"
(NSTRING-UPCASE "abCD efGh-ij" :START 1 :END 6)
EQUAL-OK: "aBCD EfGh-ij"
(NSTRING-DOWNCASE "abCD efGh-ij" :END 3)
EQUAL-OK: "abcD efGh-ij"
(NSTRING-DOWNCASE "abCd efGh-ij" :START 3 :END 3)
EQUAL-OK: "abCd efGh-ij"
(NSTRING-DOWNCASE "abCd efGh-ij" :START 1 :END 6)
EQUAL-OK: "abcd efGh-ij"
(NSTRING-DOWNCASE "abCD efGh-ij" :START 6 :END 1)
[SIMPLE-ERROR]: NSTRING-DOWNCASE: :START-index 6 must not be greater than :END-index 1

EQL-OK: ERROR
(NSTRING-DOWNCASE "abCD efGh-ij" :START NIL :END NIL)
[SIMPLE-TYPE-ERROR]: NSTRING-DOWNCASE: :START-index should be an integer, not NIL

EQL-OK: ERROR
(NSTRING-UPCASE "abDC efGh-oj")
EQUAL-OK: "ABDC EFGH-OJ"
(NSTRING-UPCASE "abCD efGh-ij" :START 1 :END 6)
EQUAL-OK: "aBCD EfGh-ij"
(NSTRING-UPCASE "abCD efGh-fg" :START 1 :END 6)
EQUAL-OK: "aBCD EfGh-fg"
(NSTRING-UPCASE "abCD efGh-ef" :START 3 :END 3)
EQUAL-OK: "abCD efGh-ef"
(NSTRING-UPCASE "abCD efGh-ef" :START 3 :END 3)
EQUAL-OK: "abCD efGh-ef"
(NSTRING-UPCASE "abCD efGh-ef" :START 3 :END 3)
EQUAL-OK: "abCD efGh-ef"
(NSTRING-UPCASE "abCD efGh-ef" :START 3 :END 1)
[SIMPLE-ERROR]: NSTRING-UPCASE: :START-index 3 must not be greater than :END-index 1

EQL-OK: ERROR
(NSTRING-UPCASE "abCD efGh-ef" :START NIL :END NIL)
[SIMPLE-TYPE-ERROR]: NSTRING-UPCASE: :START-index should be an integer, not NIL

EQL-OK: ERROR
(NSTRING-DOWNCASE "saBG efGh-ef")
EQUAL-OK: "sabg efgh-ef"
(NSTRING-DOWNCASE "dfGV efGh-ef" :START 1 :END 6)
EQUAL-OK: "dfgv efGh-ef"
(NSTRING-DOWNCASE "fgCD efGf-ef" :START 1 :END 3)
EQUAL-OK: "fgcD efGf-ef"
(NSTRING-DOWNCASE "dfCF edFg-fg" :START NIL :END NIL)
[SIMPLE-TYPE-ERROR]: NSTRING-DOWNCASE: :START-index should be an integer, not NIL

EQL-OK: ERROR
(NSTRING-DOWNCASE "fgHG edgf-fg" :START 5 :END 1)
[SIMPLE-ERROR]: NSTRING-DOWNCASE: :START-index 5 must not be greater than :END-index 1

EQL-OK: ERROR
(NSTRING-DOWNCASE "scDF edFG-ef" :START 1)
EQUAL-OK: "scdf edfg-ef"
(NSTRING-DOWNCASE "fgHG edFG-ef" :END 4)
EQUAL-OK: "fghg edFG-ef"
(NSTRING-CAPITALIZE "fg hgf fgh")
EQUAL-OK: "Fg Hgf Fgh"
(LET ((X "ABCDEF")) (NSTRING-DOWNCASE X) X)
EQUAL-OK: "abcdef"
(LET* ((S "abcdefgh") (D (MAKE-ARRAY 5 :DISPLACED-TO S :DISPLACED-INDEX-OFFSET 3 :ELEMENT-TYPE (ARRAY-ELEMENT-TYPE S)))) (STRING-UPCASE D :START 2 :END 4))
EQUAL-OK: "deFGh"
(LET* ((S "abcdefgh") (D (MAKE-ARRAY 5 :DISPLACED-TO S :DISPLACED-INDEX-OFFSET 3 :ELEMENT-TYPE (ARRAY-ELEMENT-TYPE S)))) (AND (EQ (NSTRING-UPCASE D :START 2 :END 4) D) D))
EQUAL-OK: "deFGh"
(NSTRING-UPCASE (MAKE-ARRAY 0 :ELEMENT-TYPE NIL))
EQUAL-OK: ""
(LET* ((S (FORMAT NIL "A~CB" (CODE-CHAR 0))) (D (MAKE-ARRAY 2 :DISPLACED-TO S :DISPLACED-INDEX-OFFSET 1 :ELEMENT-TYPE 'CHARACTER))) (LIST (STRING-WIDTH S :START 0 :END 1) (STRING-WIDTH S :START 1 :END 2) (STRING-WIDTH S :START 2 :END 3) (STRING-WIDTH S :START 0 :END 2) (STRING-WIDTH S :START 0 :END 3) (STRING-WIDTH S :START 1 :END 3) (STRING-WIDTH D :START 0 :END 1) (STRING-WIDTH D :START 1 :END 2) (STRING-WIDTH D :START 0 :END 2) (STRING-WIDTH D)))
EQUAL-OK: (1 0 1 1 2 1 0 1 1 1)
(SETQ X (MAKE-ARRAY 10 :FILL-POINTER 5 :ELEMENT-TYPE 'CHARACTER :INITIAL-CONTENTS "abcdefghij"))
EQUAL-OK: "abcde"
(CHAR X 7)
EQL-OK: #\h
(ELT X 7)
[SIMPLE-TYPE-ERROR]: ELT: index 7 for "abcde" is out of range

EQL-OK: ERROR
(SETF (CHAR X 7) #\H)
EQL-OK: #\H
(CHAR X 7)
EQL-OK: #\H
(REVERSE X)
EQUAL-OK: "edcba"
(NREVERSE X)
EQUAL-OK: "edcba"
X
EQUAL-OK: "edcba"
(LET* ((X (MAKE-ARRAY 10 :FILL-POINTER 4 :ELEMENT-TYPE 'CHARACTER :INITIAL-ELEMENT #\Space :ADJUSTABLE T)) (Y (MAKE-ARRAY 10 :FILL-POINTER 4 :ELEMENT-TYPE 'CHARACTER :DISPLACED-TO X))) (ADJUST-ARRAY X '(5)) (CHAR Y 5))
[SIMPLE-ERROR]: An array has been shortened by adjusting it while another array was displaced to it.

EQL-OK: ERROR
(LENGTH (ADJUST-ARRAY (MAKE-ARRAY 0 :ELEMENT-TYPE 'CHARACTER :ADJUSTABLE T) 1))
EQL-OK: 1
(LET ((S (MAKE-ARRAY 10 :ELEMENT-TYPE 'CHARACTER :INITIAL-ELEMENT #\a))) (LIST (MULTIPLE-VALUE-LIST (SYSTEM::STRING-INFO S)) (PROGN (SETF (AREF S 3) (CODE-CHAR 12345)) (MULTIPLE-VALUE-LIST (SYSTEM::STRING-INFO S))) (PROGN (GC) (MULTIPLE-VALUE-LIST (SYSTEM::STRING-INFO S))) (PROGN (SETF (AREF S 3) (CODE-CHAR 123456)) (MULTIPLE-VALUE-LIST (SYSTEM::STRING-INFO S))) (PROGN (GC) (MULTIPLE-VALUE-LIST (SYSTEM::STRING-INFO S)))))
EQUAL-OK: ((8 NIL NIL) (16 NIL T) (16 NIL NIL) (32 NIL T) (32 NIL NIL))
(LENGTH (MAKE-ARRAY '3 :ELEMENT-TYPE 'CHARACTER :INITIAL-CONTENTS '(#\U65E5 #\U672C #\U8A9E)))
EQL-OK: 3
(LET ((X (MAKE-ARRAY '(3 3) :ELEMENT-TYPE 'CHARACTER :INITIAL-CONTENTS '((#\U65E5 #\U672C #\U8A9E) (#\T #\LATIN_SMALL_LETTER_U_WITH_DIAERESIS #\r) (#\k #\LATIN_SMALL_LETTER_C_WITH_CEDILLA #\e))))) (GC) (ARRAY-DIMENSIONS X))
EQUAL-OK: (3 3)
(SYMBOLP (MAKE-SYMBOL (MAKE-ARRAY 0 :ELEMENT-TYPE NIL)))
EQL-OK: T
(STRING= "" (MAKE-ARRAY 0 :ELEMENT-TYPE NIL))
EQL-OK: T
(STRING-INVERTCASE "AbCdEfGh" :START 1 :END 5)
EQUAL-OK: "ABcDefGh"
(TRIM-IF #'SYSTEM::WHITESPACEP "  asdf 	 ")
EQUAL-OK: "asdf"
(PROGN (SYMBOL-CLEANUP 'X))
EQL-OK: T
RUN-TEST: finished "strings" (0 errors out of 409 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"symbol10.tst" @1>
(DEFUN TESTVAR (VAR) (LIST (BOUNDP VAR) (IF (BOUNDP VAR) (SYMBOL-VALUE VAR) NIL) (CONSTANTP VAR) (AND (SPECIAL-VARIABLE-P VAR) (NOT (CONSTANTP VAR))) (AND (FBOUNDP VAR) T) (AND (FBOUNDP VAR) (MACRO-FUNCTION VAR) T) (AND (FBOUNDP VAR) (SPECIAL-OPERATOR-P VAR) T) (AND (OR (GET VAR 'I1) (GET VAR 'I2) (GET VAR 'I3)) T) (GET VAR 'I1) (GET VAR 'I2) (GET VAR 'I3)))
EQL-OK: TESTVAR
(SYMBOL-CLEANUP 'V1)
EQL-OK: T
(TESTVAR 'V1)
EQUAL-OK: (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)
(SETQ V1 'VAL)
EQL-OK: VAL
(TESTVAR 'V1)
EQUAL-OK: (T VAL NIL NIL NIL NIL NIL NIL NIL NIL NIL)
(MAKUNBOUND 'V1)
EQL-OK: V1
(TESTVAR 'V1)
EQUAL-OK: (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)
(SETQ V1 'VAL2)
EQL-OK: VAL2
(TESTVAR 'V1)
EQUAL-OK: (T VAL2 NIL NIL NIL NIL NIL NIL NIL NIL NIL)
(DEFMACRO V1 (X) (LIST 'QUOTE X))
EQL-OK: V1
(TESTVAR 'V1)
EQUAL-OK: (T VAL2 NIL NIL T T NIL NIL NIL NIL NIL)
(FMAKUNBOUND 'V1)
EQL-OK: V1
(TESTVAR 'V1)
EQUAL-OK: (T VAL2 NIL NIL NIL NIL NIL NIL NIL NIL NIL)
(DEFMACRO V1 (X) (LIST 'QUOTE (LIST X X)))
EQL-OK: V1
(V1 33)
EQUAL-OK: (33 33)
(TESTVAR 'V1)
EQUAL-OK: (T VAL2 NIL NIL T T NIL NIL NIL NIL NIL)
(MAKUNBOUND 'V1)
EQL-OK: V1
(TESTVAR 'V1)
EQUAL-OK: (NIL NIL NIL NIL T T NIL NIL NIL NIL NIL)
(SETQ V1 'VAL3)
EQL-OK: VAL3
(TESTVAR 'V1)
EQUAL-OK: (T VAL3 NIL NIL T T NIL NIL NIL NIL NIL)
(SETF (GET 'V1 'I1) 11)
EQL-OK: 11
(SETF (GET 'V1 'I2) 22)
EQL-OK: 22
(SETF (GET 'V1 'I3) 33)
EQL-OK: 33
(TESTVAR 'V1)
EQUAL-OK: (T VAL3 NIL NIL T T NIL T 11 22 33)
(NOT (NULL (REMPROP 'V1 'I2)))
EQL-OK: T
(NOT (NULL (REMPROP 'V1 'I1)))
EQL-OK: T
(NOT (NULL (REMPROP 'V1 'I3)))
EQL-OK: T
(FMAKUNBOUND 'V1)
EQL-OK: V1
(MAKUNBOUND 'V1)
EQL-OK: V1
(TESTVAR 'V1)
EQUAL-OK: (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)
(SETF (GET 'V1 'I1) 99)
EQL-OK: 99
(DEFMACRO V1 (X) (LIST 'QUOTE (LIST X X X)))
EQL-OK: V1
(V1 A)
EQUAL-OK: (A A A)
(SETQ V1 'VAL4)
EQL-OK: VAL4
(TESTVAR 'V1)
EQUAL-OK: (T VAL4 NIL NIL T T NIL T 99 NIL NIL)
(SYMBOL-CLEANUP 'V1)
EQL-OK: T
(TESTVAR 'V1)
EQUAL-OK: (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)
(SYMBOL-CLEANUP 'V2)
EQL-OK: T
(DEFVAR V2 'V2A)
EQL-OK: V2
(TESTVAR 'V2)
EQUAL-OK: (T V2A NIL T NIL NIL NIL NIL NIL NIL NIL)
(SETF (GET 'V2 'I3) 33)
EQL-OK: 33
(SETF (GET 'V2 'I2) 22)
EQL-OK: 22
(SETF (GET 'V2 'I1) 11)
EQL-OK: 11
(TESTVAR 'V2)
EQUAL-OK: (T V2A NIL T NIL NIL NIL T 11 22 33)
(MAKUNBOUND 'V2)
EQL-OK: V2
(NOT (NULL (REMPROP 'V2 'I1)))
EQL-OK: T
(NOT (NULL (REMPROP 'V2 'I2)))
EQL-OK: T
(NOT (NULL (REMPROP 'V2 'I3)))
EQL-OK: T
(TESTVAR 'V2)
EQUAL-OK: (NIL NIL NIL T NIL NIL NIL NIL NIL NIL NIL)
(DEFVAR V2 'V2B)
EQL-OK: V2
(SETF (GET 'V2 'I1) 111)
EQL-OK: 111
(SETF (GET 'V2 'I2) 222)
EQL-OK: 222
(SETF (GET 'V2 'I3) 333)
EQL-OK: 333
(TESTVAR 'V2)
EQUAL-OK: (T V2B NIL T NIL NIL NIL T 111 222 333)
(DEFUN V2 (X) (LIST X X))
EQL-OK: V2
(V2 44)
EQUAL-OK: (44 44)
(TESTVAR 'V2)
EQUAL-OK: (T V2B NIL T T NIL NIL T 111 222 333)
(SYMBOL-CLEANUP 'V2)
EQL-OK: T
(TESTVAR 'V2)
EQUAL-OK: (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)
(SYMBOL-CLEANUP 'V3)
EQL-OK: T
(DEFUN V3 (X Y) (LIST X Y))
EQL-OK: V3
(TESTVAR 'V3)
EQUAL-OK: (NIL NIL NIL NIL T NIL NIL NIL NIL NIL NIL)
(DEFCONSTANT V3 99)
EQL-OK: V3
V3
EQL-OK: 99
(V3 'A 'B)
EQUAL-OK: (A B)
(TESTVAR 'V3)
EQUAL-OK: (T 99 T NIL T NIL NIL NIL NIL NIL NIL)
(MAKUNBOUND 'V3)
[SIMPLE-SOURCE-PROGRAM-ERROR]: MAKUNBOUND: V3 is a constant, may not be used as a variable

EQL-OK: ERROR
(FMAKUNBOUND 'V3)
EQL-OK: V3
(DEFCONSTANT V3 999)
WARNING: (DEFCONSTANT V3 999) redefines the constant V3. Its old value was 99.
EQL-OK: V3
(DEFUN V3 (X) (LIST X X))
EQL-OK: V3
(V3 'C)
EQUAL-OK: (C C)
V3
EQL-OK: 999
(TESTVAR 'V3)
EQUAL-OK: (T 999 T NIL T NIL NIL NIL NIL NIL NIL)
(DEFPARAMETER VAR33)
[SIMPLE-SOURCE-PROGRAM-ERROR]: The macro DEFPARAMETER may not be called with 1 arguments: #1=(DEFPARAMETER VAR33)
EQL-OK: ERROR
(DEFPARAMETER VAR3 99)
EQL-OK: VAR3
VAR3
EQL-OK: 99
(TESTVAR 'VAR3)
EQUAL-OK: (T 99 NIL T NIL NIL NIL NIL NIL NIL NIL)
(MAKUNBOUND 'VAR3)
EQL-OK: VAR3
(TESTVAR 'VAR3)
EQUAL-OK: (NIL NIL NIL T NIL NIL NIL NIL NIL NIL NIL)
(SETF (GET 'V3 'I2) 222)
EQL-OK: 222
(SETF (GET 'V3 'I1) 111)
EQL-OK: 111
(TESTVAR 'V3)
EQUAL-OK: (T 999 T NIL T NIL NIL T 111 222 NIL)
(SYMBOL-CLEANUP 'V3)
EQL-OK: T
(TESTVAR 'V3)
EQUAL-OK: (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)
(SYMBOL-CLEANUP 'V4)
EQL-OK: T
(DEFUN V4 (X) X)
EQL-OK: V4
(V4 55)
EQL-OK: 55
(TESTVAR 'V4)
EQUAL-OK: (NIL NIL NIL NIL T NIL NIL NIL NIL NIL NIL)
(FMAKUNBOUND 'V4)
EQL-OK: V4
(TESTVAR 'V4)
EQUAL-OK: (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)
(DEFUN V4 (X) (LIST X))
EQL-OK: V4
(V4 88)
EQUAL-OK: (88)
(TESTVAR 'V4)
EQUAL-OK: (NIL NIL NIL NIL T NIL NIL NIL NIL NIL NIL)
(SETF (GET 'V4 'I1) 11)
EQL-OK: 11
(SETF (GET 'V4 'I2) 22)
EQL-OK: 22
(TESTVAR 'V4)
EQUAL-OK: (NIL NIL NIL NIL T NIL NIL T 11 22 NIL)
(FMAKUNBOUND 'V4)
EQL-OK: V4
(NOT (NULL (REMPROP 'V4 'I1)))
EQL-OK: T
(NOT (NULL (REMPROP 'V4 'I2)))
EQL-OK: T
(TESTVAR 'V4)
EQUAL-OK: (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)
(DEFUN V4 (X) (LIST X X X))
EQL-OK: V4
(V4 44)
EQUAL-OK: (44 44 44)
(SETF (GET 'V4 'I2) 222)
EQL-OK: 222
(SETF (GET 'V4 'I3) 333)
EQL-OK: 333
(TESTVAR 'V4)
EQUAL-OK: (NIL NIL NIL NIL T NIL NIL T NIL 222 333)
(DEFVAR V4 'V4-VALUE)
EQL-OK: V4
(TESTVAR 'V4)
EQUAL-OK: (T V4-VALUE NIL T T NIL NIL T NIL 222 333)
(SYMBOL-CLEANUP 'V4)
EQL-OK: T
(TESTVAR 'V4)
EQUAL-OK: (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)
(SYMBOL-CLEANUP 'V5)
EQL-OK: T
(SETF (GET 'V5 'I1) 1)
EQL-OK: 1
(SETF (GET 'V5 'I2) 2)
EQL-OK: 2
(TESTVAR 'V5)
EQUAL-OK: (NIL NIL NIL NIL NIL NIL NIL T 1 2 NIL)
(NOT (NULL (REMPROP 'V5 'I1)))
EQL-OK: T
(NOT (NULL (REMPROP 'V5 'I2)))
EQL-OK: T
(TESTVAR 'V5)
EQUAL-OK: (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)
(SETF (GET 'V5 'I1) 11)
EQL-OK: 11
(SETF (GET 'V5 'I2) 22)
EQL-OK: 22
(TESTVAR 'V5)
EQUAL-OK: (NIL NIL NIL NIL NIL NIL NIL T 11 22 NIL)
(DEFCONSTANT V5 '123)
EQL-OK: V5
(TESTVAR 'V5)
EQUAL-OK: (T 123 T NIL NIL NIL NIL T 11 22 NIL)
(MAKUNBOUND 'V5)
[SIMPLE-SOURCE-PROGRAM-ERROR]: MAKUNBOUND: V5 is a constant, may not be used as a variable

EQL-OK: ERROR
(NOT (NULL (REMPROP 'V5 'I2)))
EQL-OK: T
(NOT (NULL (REMPROP 'V5 'I1)))
EQL-OK: T
(DEFCONSTANT V5 321)
WARNING: (DEFCONSTANT V5 321) redefines the constant V5. Its old value was 123
         .
EQL-OK: V5
(SETF (GET 'V5 'I3) 333)
EQL-OK: 333
(SETF (GET 'V5 'I2) 222)
EQL-OK: 222
(TESTVAR 'V5)
EQUAL-OK: (T 321 T NIL NIL NIL NIL T NIL 222 333)
(DEFUN V5 (X) X)
EQL-OK: V5
(V5 666)
EQL-OK: 666
(TESTVAR 'V5)
EQUAL-OK: (T 321 T NIL T NIL NIL T NIL 222 333)
(SYMBOL-CLEANUP 'V5)
EQL-OK: T
(TESTVAR 'V5)
EQUAL-OK: (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)
(SYMBOL-CLEANUP 'V6)
EQL-OK: T
(SETF (GET 'V6 'I1) 1)
EQL-OK: 1
(SETF (GET 'V6 'I3) 3)
EQL-OK: 3
(TESTVAR 'V6)
EQUAL-OK: (NIL NIL NIL NIL NIL NIL NIL T 1 NIL 3)
(DEFMACRO V6 (X) (LIST 'QUOTE X))
EQL-OK: V6
(V6 A)
EQL-OK: A
(TESTVAR 'V6)
EQUAL-OK: (NIL NIL NIL NIL T T NIL T 1 NIL 3)
(DEFCONSTANT V6 234)
EQL-OK: V6
(TESTVAR 'V6)
EQUAL-OK: (T 234 T NIL T T NIL T 1 NIL 3)
(SYMBOL-CLEANUP 'V6)
EQL-OK: T
(TESTVAR 'V6)
EQUAL-OK: (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)
(PROGN (MAPC #'UNINTERN '(V1 V2 V3 V4 V5 V6)) T)
EQL-OK: T
(EVAL (READ-FROM-STRING ":abazonk-does-not-exist-yet-0"))
EQL-OK: :ABAZONK-DOES-NOT-EXIST-YET-0
:ABAZONK-DOES-NOT-EXIST-YET-0A
EQL-OK: :ABAZONK-DOES-NOT-EXIST-YET-0A
(EVAL (READ-FROM-STRING "keyword::abazonk-does-not-exist-yet-1"))
EQL-OK: :ABAZONK-DOES-NOT-EXIST-YET-1
:ABAZONK-DOES-NOT-EXIST-YET-1A
EQL-OK: :ABAZONK-DOES-NOT-EXIST-YET-1A
(HANDLER-CASE (READ-FROM-STRING "keyword:abazonk-does-not-exist-yet-2") (PACKAGE-ERROR NIL T) (:NO-ERROR NIL NIL))
EQL-OK: T
(LET ((L (APROPOS-LIST "ABAZONK-DOES-NOT-EXIST-YET"))) (MAPC #'UNINTERN L) (LENGTH L))
EQL-OK: 4
(SYMBOLS-CLEANUP '(TESTVAR V1 V2 V3 V4 V5 V6 VAR3 VAR33))
EQL-OK: NIL
RUN-TEST: finished "symbol10" (0 errors out of 152 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"symbols.tst" @1>
(SYMBOL-NAME 'XYZ)
EQUAL-OK: "XYZ"
(PROGN (SETQ *GENSYM-COUNTER* 32) (GENSYM) T)
EQL-OK: T
(PRIN1-TO-STRING (GENSYM "FOO-"))
EQUAL-OK: "#:FOO-33"
(PRIN1-TO-STRING (GENSYM "garbage-"))
EQUAL-OK: "#:|garbage-34|"
(LET* ((CL-SYMBOLS-REQUIRED '(&ALLOW-OTHER-KEYS *PRINT-MISER-WIDTH* &AUX *PRINT-PPRINT-DISPATCH* &BODY *PRINT-PRETTY* &ENVIRONMENT *PRINT-RADIX* &KEY *PRINT-READABLY* &OPTIONAL *PRINT-RIGHT-MARGIN* &REST *QUERY-IO* &WHOLE *RANDOM-STATE* * *READ-BASE* ** *READ-DEFAULT-FLOAT-FORMAT* *** *READ-EVAL* *BREAK-ON-SIGNALS* *READ-SUPPRESS* *COMPILE-FILE-PATHNAME* *READTABLE* *COMPILE-FILE-TRUENAME* *STANDARD-INPUT* *COMPILE-PRINT* *STANDARD-OUTPUT* *COMPILE-VERBOSE* *TERMINAL-IO* *DEBUG-IO* *TRACE-OUTPUT* *DEBUGGER-HOOK* + *DEFAULT-PATHNAME-DEFAULTS* ++ *ERROR-OUTPUT* +++ *FEATURES* - *GENSYM-COUNTER* / *LOAD-PATHNAME* // *LOAD-PRINT* /// *LOAD-TRUENAME* /= *LOAD-VERBOSE* 1+ *MACROEXPAND-HOOK* 1- *MODULES* < *PACKAGE* <= *PRINT-ARRAY* = *PRINT-BASE* > *PRINT-CASE* >= *PRINT-CIRCLE* ABORT *PRINT-ESCAPE* ABS *PRINT-GENSYM* ACONS *PRINT-LENGTH* ACOS *PRINT-LEVEL* ACOSH *PRINT-LINES* ADD-METHOD ADJOIN ATOM BOUNDP ADJUST-ARRAY BASE-CHAR BREAK ADJUSTABLE-ARRAY-P BASE-STRING BROADCAST-STREAM ALLOCATE-INSTANCE BIGNUM BROADCAST-STREAM-STREAMS ALPHA-CHAR-P BIT BUILT-IN-CLASS ALPHANUMERICP BIT-AND BUTLAST AND BIT-ANDC1 BYTE APPEND BIT-ANDC2 BYTE-POSITION APPLY BIT-EQV BYTE-SIZE APROPOS BIT-IOR CAAAAR APROPOS-LIST BIT-NAND CAAADR AREF BIT-NOR CAAAR ARITHMETIC-ERROR BIT-NOT CAADAR ARITHMETIC-ERROR-OPERANDS BIT-ORC1 CAADDR ARITHMETIC-ERROR-OPERATION BIT-ORC2 CAADR ARRAY BIT-VECTOR CAAR ARRAY-DIMENSION BIT-VECTOR-P CADAAR ARRAY-DIMENSION-LIMIT BIT-XOR CADADR ARRAY-DIMENSIONS BLOCK CADAR ARRAY-DISPLACEMENT BOOLE CADDAR ARRAY-ELEMENT-TYPE BOOLE-1 CADDDR ARRAY-HAS-FILL-POINTER-P BOOLE-2 CADDR ARRAY-IN-BOUNDS-P BOOLE-AND CADR ARRAY-RANK BOOLE-ANDC1 CALL-ARGUMENTS-LIMIT ARRAY-RANK-LIMIT BOOLE-ANDC2 CALL-METHOD ARRAY-ROW-MAJOR-INDEX BOOLE-C1 CALL-NEXT-METHOD ARRAY-TOTAL-SIZE BOOLE-C2 CAR ARRAY-TOTAL-SIZE-LIMIT BOOLE-CLR CASE ARRAYP BOOLE-EQV CATCH ASH BOOLE-IOR CCASE ASIN BOOLE-NAND CDAAAR ASINH BOOLE-NOR CDAADR ASSERT BOOLE-ORC1 CDAAR ASSOC BOOLE-ORC2 CDADAR ASSOC-IF BOOLE-SET CDADDR ASSOC-IF-NOT BOOLE-XOR CDADR ATAN BOOLEAN CDAR ATANH BOTH-CASE-P CDDAAR CDDADR CLEAR-INPUT COPY-TREE CDDAR CLEAR-OUTPUT COS CDDDAR CLOSE COSH CDDDDR CLRHASH COUNT CDDDR CODE-CHAR COUNT-IF CDDR COERCE COUNT-IF-NOT CDR COMPILATION-SPEED CTYPECASE CEILING COMPILE DEBUG CELL-ERROR COMPILE-FILE DECF CELL-ERROR-NAME COMPILE-FILE-PATHNAME DECLAIM CERROR COMPILED-FUNCTION DECLARATION CHANGE-CLASS COMPILED-FUNCTION-P DECLARE CHAR COMPILER-MACRO DECODE-FLOAT CHAR-CODE COMPILER-MACRO-FUNCTION DECODE-UNIVERSAL-TIME CHAR-CODE-LIMIT COMPLEMENT DEFCLASS CHAR-DOWNCASE COMPLEX DEFCONSTANT CHAR-EQUAL COMPLEXP DEFGENERIC CHAR-GREATERP COMPUTE-APPLICABLE-METHODS DEFINE-COMPILER-MACRO CHAR-INT COMPUTE-RESTARTS DEFINE-CONDITION CHAR-LESSP CONCATENATE DEFINE-METHOD-COMBINATION CHAR-NAME CONCATENATED-STREAM DEFINE-MODIFY-MACRO CHAR-NOT-EQUAL CONCATENATED-STREAM-STREAMS DEFINE-SETF-EXPANDER CHAR-NOT-GREATERP COND DEFINE-SYMBOL-MACRO CHAR-NOT-LESSP CONDITION DEFMACRO CHAR-UPCASE CONJUGATE DEFMETHOD CHAR/= CONS DEFPACKAGE CHAR< CONSP DEFPARAMETER CHAR<= CONSTANTLY DEFSETF CHAR= CONSTANTP DEFSTRUCT CHAR> CONTINUE DEFTYPE CHAR>= CONTROL-ERROR DEFUN CHARACTER COPY-ALIST DEFVAR CHARACTERP COPY-LIST DELETE CHECK-TYPE COPY-PPRINT-DISPATCH DELETE-DUPLICATES CIS COPY-READTABLE DELETE-FILE CLASS COPY-SEQ DELETE-IF CLASS-NAME COPY-STRUCTURE DELETE-IF-NOT CLASS-OF COPY-SYMBOL DELETE-PACKAGE DENOMINATOR EQ DEPOSIT-FIELD EQL DESCRIBE EQUAL DESCRIBE-OBJECT EQUALP DESTRUCTURING-BIND ERROR DIGIT-CHAR ETYPECASE DIGIT-CHAR-P EVAL DIRECTORY EVAL-WHEN DIRECTORY-NAMESTRING EVENP DISASSEMBLE EVERY DIVISION-BY-ZERO EXP DO EXPORT DO* EXPT DO-ALL-SYMBOLS EXTENDED-CHAR DO-EXTERNAL-SYMBOLS FBOUNDP DO-SYMBOLS FCEILING DOCUMENTATION FDEFINITION DOLIST FFLOOR DOTIMES FIFTH DOUBLE-FLOAT FILE-AUTHOR DOUBLE-FLOAT-EPSILON FILE-ERROR DOUBLE-FLOAT-NEGATIVE-EPSILON FILE-ERROR-PATHNAME DPB FILE-LENGTH DRIBBLE FILE-NAMESTRING DYNAMIC-EXTENT FILE-POSITION ECASE FILE-STREAM ECHO-STREAM FILE-STRING-LENGTH ECHO-STREAM-INPUT-STREAM FILE-WRITE-DATE ECHO-STREAM-OUTPUT-STREAM FILL ED FILL-POINTER EIGHTH FIND ELT FIND-ALL-SYMBOLS ENCODE-UNIVERSAL-TIME FIND-CLASS END-OF-FILE FIND-IF ENDP FIND-IF-NOT ENOUGH-NAMESTRING FIND-METHOD ENSURE-DIRECTORIES-EXIST ENSURE-GENERIC-FUNCTION FIND-PACKAGE FIND-RESTART FIND-SYMBOL GET-INTERNAL-RUN-TIME FINISH-OUTPUT GET-MACRO-CHARACTER FIRST GET-OUTPUT-STREAM-STRING FIXNUM GET-PROPERTIES FLET GET-SETF-EXPANSION FLOAT GET-UNIVERSAL-TIME FLOAT-DIGITS GETF FLOAT-PRECISION GETHASH FLOAT-RADIX GO FLOAT-SIGN GRAPHIC-CHAR-P FLOATING-POINT-INEXACT HANDLER-BIND FLOATING-POINT-INVALID-OPERATION HANDLER-CASE FLOATING-POINT-OVERFLOW HASH-TABLE FLOATING-POINT-UNDERFLOW HASH-TABLE-COUNT FLOATP HASH-TABLE-P FLOOR HASH-TABLE-REHASH-SIZE FMAKUNBOUND HASH-TABLE-REHASH-THRESHOLD FORCE-OUTPUT HASH-TABLE-SIZE FORMAT HASH-TABLE-TEST FORMATTER HOST-NAMESTRING FOURTH IDENTITY FRESH-LINE IF FROUND IGNORABLE FTRUNCATE IGNORE FTYPE IGNORE-ERRORS FUNCALL IMAGPART FUNCTION IMPORT FUNCTION-KEYWORDS IN-PACKAGE FUNCTION-LAMBDA-EXPRESSION INCF FUNCTIONP INITIALIZE-INSTANCE GCD INLINE GENERIC-FUNCTION INPUT-STREAM-P GENSYM INSPECT GENTEMP INTEGER GET INTEGER-DECODE-FLOAT GET-DECODED-TIME INTEGER-LENGTH GET-DISPATCH-MACRO-CHARACTER INTEGERP GET-INTERNAL-REAL-TIME INTERACTIVE-STREAM-P INTERN LISP-IMPLEMENTATION-TYPE INTERNAL-TIME-UNITS-PER-SECOND LISP-IMPLEMENTATION-VERSION INTERSECTION LIST INVALID-METHOD-ERROR LIST* INVOKE-DEBUGGER LIST-ALL-PACKAGES INVOKE-RESTART LIST-LENGTH INVOKE-RESTART-INTERACTIVELY LISTEN ISQRT LISTP KEYWORD LOAD KEYWORDP LOAD-LOGICAL-PATHNAME-TRANSLATIONS LABELS LOAD-TIME-VALUE LAMBDA LOCALLY LAMBDA-LIST-KEYWORDS LOG LAMBDA-PARAMETERS-LIMIT LOGAND LAST LOGANDC1 LCM LOGANDC2 LDB LOGBITP LDB-TEST LOGCOUNT LDIFF LOGEQV LEAST-NEGATIVE-DOUBLE-FLOAT LOGICAL-PATHNAME LEAST-NEGATIVE-LONG-FLOAT LOGICAL-PATHNAME-TRANSLATIONS LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT LOGIOR LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT LOGNAND LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT LOGNOR LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT LOGNOT LEAST-NEGATIVE-SHORT-FLOAT LOGORC1 LEAST-NEGATIVE-SINGLE-FLOAT LOGORC2 LEAST-POSITIVE-DOUBLE-FLOAT LOGTEST LEAST-POSITIVE-LONG-FLOAT LOGXOR LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT LONG-FLOAT LEAST-POSITIVE-NORMALIZED-LONG-FLOAT LONG-FLOAT-EPSILON LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT LONG-FLOAT-NEGATIVE-EPSILON LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT LONG-SITE-NAME LEAST-POSITIVE-SHORT-FLOAT LOOP LEAST-POSITIVE-SINGLE-FLOAT LOOP-FINISH LENGTH LOWER-CASE-P LET MACHINE-INSTANCE LET* MACHINE-TYPE MACHINE-VERSION MASK-FIELD MACRO-FUNCTION MAX MACROEXPAND MEMBER MACROEXPAND-1 MEMBER-IF MACROLET MEMBER-IF-NOT MAKE-ARRAY MERGE MAKE-BROADCAST-STREAM MERGE-PATHNAMES MAKE-CONCATENATED-STREAM METHOD MAKE-CONDITION METHOD-COMBINATION MAKE-DISPATCH-MACRO-CHARACTER METHOD-COMBINATION-ERROR MAKE-ECHO-STREAM METHOD-QUALIFIERS MAKE-HASH-TABLE MIN MAKE-INSTANCE MINUSP MAKE-INSTANCES-OBSOLETE MISMATCH MAKE-LIST MOD MAKE-LOAD-FORM MOST-NEGATIVE-DOUBLE-FLOAT MAKE-LOAD-FORM-SAVING-SLOTS MOST-NEGATIVE-FIXNUM MAKE-METHOD MOST-NEGATIVE-LONG-FLOAT MAKE-PACKAGE MOST-NEGATIVE-SHORT-FLOAT MAKE-PATHNAME MOST-NEGATIVE-SINGLE-FLOAT MAKE-RANDOM-STATE MOST-POSITIVE-DOUBLE-FLOAT MAKE-SEQUENCE MOST-POSITIVE-FIXNUM MAKE-STRING MOST-POSITIVE-LONG-FLOAT MAKE-STRING-INPUT-STREAM MOST-POSITIVE-SHORT-FLOAT MAKE-STRING-OUTPUT-STREAM MOST-POSITIVE-SINGLE-FLOAT MAKE-SYMBOL MUFFLE-WARNING MAKE-SYNONYM-STREAM MULTIPLE-VALUE-BIND MAKE-TWO-WAY-STREAM MULTIPLE-VALUE-CALL MAKUNBOUND MULTIPLE-VALUE-LIST MAP MULTIPLE-VALUE-PROG1 MAP-INTO MULTIPLE-VALUE-SETQ MAPC MULTIPLE-VALUES-LIMIT MAPCAN NAME-CHAR MAPCAR NAMESTRING MAPCON NBUTLAST MAPHASH NCONC MAPL NEXT-METHOD-P MAPLIST NIL NINTERSECTION PACKAGE-ERROR NINTH PACKAGE-ERROR-PACKAGE NO-APPLICABLE-METHOD PACKAGE-NAME NO-NEXT-METHOD PACKAGE-NICKNAMES NOT PACKAGE-SHADOWING-SYMBOLS NOTANY PACKAGE-USE-LIST NOTEVERY PACKAGE-USED-BY-LIST NOTINLINE PACKAGEP NRECONC PAIRLIS NREVERSE PARSE-ERROR NSET-DIFFERENCE PARSE-INTEGER NSET-EXCLUSIVE-OR PARSE-NAMESTRING NSTRING-CAPITALIZE PATHNAME NSTRING-DOWNCASE PATHNAME-DEVICE NSTRING-UPCASE PATHNAME-DIRECTORY NSUBLIS PATHNAME-HOST NSUBST PATHNAME-MATCH-P NSUBST-IF PATHNAME-NAME NSUBST-IF-NOT PATHNAME-TYPE NSUBSTITUTE PATHNAME-VERSION NSUBSTITUTE-IF PATHNAMEP NSUBSTITUTE-IF-NOT PEEK-CHAR NTH PHASE NTH-VALUE PI NTHCDR PLUSP NULL POP NUMBER POSITION NUMBERP POSITION-IF NUMERATOR POSITION-IF-NOT NUNION PPRINT ODDP PPRINT-DISPATCH OPEN PPRINT-EXIT-IF-LIST-EXHAUSTED OPEN-STREAM-P PPRINT-FILL OPTIMIZE PPRINT-INDENT OR PPRINT-LINEAR OTHERWISE PPRINT-LOGICAL-BLOCK OUTPUT-STREAM-P PPRINT-NEWLINE PACKAGE PPRINT-POP PPRINT-TAB READ-CHAR PPRINT-TABULAR READ-CHAR-NO-HANG PRIN1 READ-DELIMITED-LIST PRIN1-TO-STRING READ-FROM-STRING PRINC READ-LINE PRINC-TO-STRING READ-PRESERVING-WHITESPACE PRINT READ-SEQUENCE PRINT-NOT-READABLE READER-ERROR PRINT-NOT-READABLE-OBJECT READTABLE PRINT-OBJECT READTABLE-CASE PRINT-UNREADABLE-OBJECT READTABLEP PROBE-FILE REAL PROCLAIM REALP PROG REALPART PROG* REDUCE PROG1 REINITIALIZE-INSTANCE PROG2 REM PROGN REMF PROGRAM-ERROR REMHASH PROGV REMOVE PROVIDE REMOVE-DUPLICATES PSETF REMOVE-IF PSETQ REMOVE-IF-NOT PUSH REMOVE-METHOD PUSHNEW REMPROP QUOTE RENAME-FILE RANDOM RENAME-PACKAGE RANDOM-STATE REPLACE RANDOM-STATE-P REQUIRE RASSOC REST RASSOC-IF RESTART RASSOC-IF-NOT RESTART-BIND RATIO RESTART-CASE RATIONAL RESTART-NAME RATIONALIZE RETURN RATIONALP RETURN-FROM READ REVAPPEND READ-BYTE REVERSE ROOM SIMPLE-BIT-VECTOR ROTATEF SIMPLE-BIT-VECTOR-P ROUND SIMPLE-CONDITION ROW-MAJOR-AREF SIMPLE-CONDITION-FORMAT-ARGUMENTS RPLACA SIMPLE-CONDITION-FORMAT-CONTROL RPLACD SIMPLE-ERROR SAFETY SIMPLE-STRING SATISFIES SIMPLE-STRING-P SBIT SIMPLE-TYPE-ERROR SCALE-FLOAT SIMPLE-VECTOR SCHAR SIMPLE-VECTOR-P SEARCH SIMPLE-WARNING SECOND SIN SEQUENCE SINGLE-FLOAT SERIOUS-CONDITION SINGLE-FLOAT-EPSILON SET SINGLE-FLOAT-NEGATIVE-EPSILON SET-DIFFERENCE SINH SET-DISPATCH-MACRO-CHARACTER SIXTH SET-EXCLUSIVE-OR SLEEP SET-MACRO-CHARACTER SLOT-BOUNDP SET-PPRINT-DISPATCH SLOT-EXISTS-P SET-SYNTAX-FROM-CHAR SLOT-MAKUNBOUND SETF SLOT-MISSING SETQ SLOT-UNBOUND SEVENTH SLOT-VALUE SHADOW SOFTWARE-TYPE SHADOWING-IMPORT SOFTWARE-VERSION SHARED-INITIALIZE SOME SHIFTF SORT SHORT-FLOAT SPACE SHORT-FLOAT-EPSILON SPECIAL SHORT-FLOAT-NEGATIVE-EPSILON SPECIAL-OPERATOR-P SHORT-SITE-NAME SPEED SIGNAL SQRT SIGNED-BYTE STABLE-SORT SIGNUM STANDARD SIMPLE-ARRAY STANDARD-CHAR SIMPLE-BASE-STRING STANDARD-CHAR-P STANDARD-CLASS SUBLIS STANDARD-GENERIC-FUNCTION SUBSEQ STANDARD-METHOD SUBSETP STANDARD-OBJECT SUBST STEP SUBST-IF STORAGE-CONDITION SUBST-IF-NOT STORE-VALUE SUBSTITUTE STREAM SUBSTITUTE-IF STREAM-ELEMENT-TYPE SUBSTITUTE-IF-NOT STREAM-ERROR SUBTYPEP STREAM-ERROR-STREAM SVREF STREAM-EXTERNAL-FORMAT SXHASH STREAMP SYMBOL STRING SYMBOL-FUNCTION STRING-CAPITALIZE SYMBOL-MACROLET STRING-DOWNCASE SYMBOL-NAME STRING-EQUAL SYMBOL-PACKAGE STRING-GREATERP SYMBOL-PLIST STRING-LEFT-TRIM SYMBOL-VALUE STRING-LESSP SYMBOLP STRING-NOT-EQUAL SYNONYM-STREAM STRING-NOT-GREATERP SYNONYM-STREAM-SYMBOL STRING-NOT-LESSP T STRING-RIGHT-TRIM TAGBODY STRING-STREAM TAILP STRING-TRIM TAN STRING-UPCASE TANH STRING/= TENTH STRING< TERPRI STRING<= THE STRING= THIRD STRING> THROW STRING>= TIME STRINGP TRACE STRUCTURE TRANSLATE-LOGICAL-PATHNAME STRUCTURE-CLASS TRANSLATE-PATHNAME STRUCTURE-OBJECT TREE-EQUAL STYLE-WARNING TRUENAME TRUNCATE VALUES-LIST TWO-WAY-STREAM VARIABLE TWO-WAY-STREAM-INPUT-STREAM VECTOR TWO-WAY-STREAM-OUTPUT-STREAM VECTOR-POP TYPE VECTOR-PUSH TYPE-ERROR VECTOR-PUSH-EXTEND TYPE-ERROR-DATUM VECTORP TYPE-ERROR-EXPECTED-TYPE WARN TYPE-OF WARNING TYPECASE WHEN TYPEP WILD-PATHNAME-P UNBOUND-SLOT WITH-ACCESSORS UNBOUND-SLOT-INSTANCE WITH-COMPILATION-UNIT UNBOUND-VARIABLE WITH-CONDITION-RESTARTS UNDEFINED-FUNCTION WITH-HASH-TABLE-ITERATOR UNEXPORT WITH-INPUT-FROM-STRING UNINTERN WITH-OPEN-FILE UNION WITH-OPEN-STREAM UNLESS WITH-OUTPUT-TO-STRING UNREAD-CHAR WITH-PACKAGE-ITERATOR UNSIGNED-BYTE WITH-SIMPLE-RESTART UNTRACE WITH-SLOTS UNUSE-PACKAGE WITH-STANDARD-IO-SYNTAX UNWIND-PROTECT WRITE UPDATE-INSTANCE-FOR-DIFFERENT-CLASS WRITE-BYTE UPDATE-INSTANCE-FOR-REDEFINED-CLASS WRITE-CHAR UPGRADED-ARRAY-ELEMENT-TYPE WRITE-LINE UPGRADED-COMPLEX-PART-TYPE WRITE-SEQUENCE UPPER-CASE-P WRITE-STRING USE-PACKAGE WRITE-TO-STRING USE-VALUE Y-OR-N-P USER-HOMEDIR-PATHNAME YES-OR-NO-P VALUES ZEROP)) (CL-SYMBOLS-ACTUAL (LET ((LST NIL)) (DO-EXTERNAL-SYMBOLS (S (FIND-PACKAGE :COMMON-LISP) LST) (PUSH S LST)) LST)) (KNOWN-MISSING NIL) (KNOWN-EXTRA NIL) (MISSING (SET-DIFFERENCE CL-SYMBOLS-REQUIRED CL-SYMBOLS-ACTUAL)) (EXTRA (SET-DIFFERENCE CL-SYMBOLS-ACTUAL CL-SYMBOLS-REQUIRED))) (FORMAT T "~:[~;~&~d missing symbol~:p: ~s~%~]" MISSING (LENGTH MISSING) MISSING) (FORMAT T "~:[~;~d extra symbol~:p: ~s~%~]" EXTRA (LENGTH EXTRA) EXTRA) (DOLIST (SY CL-SYMBOLS-ACTUAL) (LOOP :FOR IP :IN (SYMBOL-PLIST SY) :BY #'CDDR :WHEN (EQ IP (FIND-SYMBOL (SYMBOL-NAME IP) "COMMON-LISP-USER")) :DO (ERROR "~s has an ilegal property ~s" SY IP))) (LIST (SET-DIFFERENCE MISSING KNOWN-MISSING) (SET-DIFFERENCE KNOWN-MISSING MISSING) (SET-DIFFERENCE EXTRA KNOWN-EXTRA) (SET-DIFFERENCE KNOWN-EXTRA EXTRA)))
EQUAL-OK: (NIL NIL NIL NIL)
(WITH-COLLECT (C) (DOLIST (P *SYSTEM-PACKAGE-LIST*) (DO-EXTERNAL-SYMBOLS (S P) (UNLESS (OR (NOT (FBOUNDP S)) (SYSTEM::SUBR-INFO S) (SPECIAL-OPERATOR-P S) (DOCUMENTATION S 'SYSTEM::FILE) (NOT (EQ S (SYSTEM::FUNCTION-NAME (OR (MACRO-FUNCTION S) S))))) (C (LIST S (SYMBOL-PLIST S) (FDEFINITION S)))))))
EQL-OK: NIL
RUN-TEST: finished "symbols" (0 errors out of 6 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"time.tst" @1>
(ENCODE-UNIVERSAL-TIME 0 0 0 1 1 1900 0)
EQL-OK: 0
(ENCODE-UNIVERSAL-TIME 0 0 1 4 7 1976 5)
EQL-OK: 2414296800
(DEFUN CHECK-UNIVERSAL-TIME (TIME &OPTIONAL TZ) "check that DECODE-UNIVERSAL-TIME is the inverse of ENCODE-UNIVERSAL-TIME" (MULTIPLE-VALUE-BIND (SE MI HO DA MO YE WK DS-P ZONE) (DECODE-UNIVERSAL-TIME TIME TZ) (LET ((UT (ENCODE-UNIVERSAL-TIME SE MI HO DA MO YE (OR TZ (IF DS-P (1- ZONE) ZONE))))) (UNLESS (= UT TIME) (LIST TIME (LIST SE MI HO DA MO YE WK DS-P ZONE TZ) UT (- UT TIME))))))
EQL-OK: CHECK-UNIVERSAL-TIME
(STRINGP (DOCUMENTATION 'CHECK-UNIVERSAL-TIME 'FUNCTION))
EQL-OK: T
(COMPILE 'CHECK-UNIVERSAL-TIME)
EQL-OK: CHECK-UNIVERSAL-TIME
(STRINGP (DOCUMENTATION #'CHECK-UNIVERSAL-TIME T))
EQL-OK: T
(CHECK-UNIVERSAL-TIME 2879996399)
EQL-OK: NIL
(CHECK-UNIVERSAL-TIME 2879996400)
EQL-OK: NIL
(CHECK-UNIVERSAL-TIME 3)
EQL-OK: NIL
(CHECK-UNIVERSAL-TIME 3 7)
EQL-OK: NIL
(DEFUN TIME-LOOP (START END STEP &OPTIONAL TZ) "return the periods of badness" (TIME (LOOP :WITH STATE = NIL :WITH RET = NIL :FOR TM :FROM START :BELOW END :BY STEP :FOR CHECK = (CHECK-UNIVERSAL-TIME TM TZ) :DO (CASE STATE ((:GOOD) (WHEN CHECK (SETQ STATE :BAD) (SHOW CHECK) (PUSH CHECK RET))) ((:BAD) (UNLESS CHECK (PUSH (SHOW (LIST TM (MULTIPLE-VALUE-LIST (DECODE-UNIVERSAL-TIME TM TZ)))) (CAR RET)) (SETQ STATE :GOOD))) (T (SETQ STATE (IF CHECK :BAD :GOOD)) (SHOW (LIST STATE TM CHECK)))) :FINALLY (RETURN (NREVERSE RET)))))
EQL-OK: TIME-LOOP
(STRINGP (DOCUMENTATION #'TIME-LOOP T))
EQL-OK: T
(COMPILE 'TIME-LOOP)
EQL-OK: TIME-LOOP
(STRINGP (DOCUMENTATION 'TIME-LOOP 'FUNCTION))
EQL-OK: T
(TIME-LOOP 100000 5000000000 5000)
(:GOOD 100000 NIL)
Real time: 6.771611 sec.
Run time: 6.764205 sec.
Space: 146550232 Bytes
GC: 186, GC time: 1.742875 sec.
EQL-OK: NIL
(TIME-LOOP 4300066700 4300181201 10)
(:GOOD 4300066700 NIL)
Real time: 0.078551 sec.
Run time: 0.078321 sec.
Space: 1981800 Bytes
GC: 2, GC time: 0.018709 sec.
EQL-OK: NIL
(TIME-LOOP 100000 5000000000 5000 0)
(:GOOD 100000 NIL)
Real time: 6.011308 sec.
Run time: 6.004573 sec.
Space: 146550232 Bytes
GC: 186, GC time: 1.638234 sec.
EQL-OK: NIL
(TIME-LOOP 4300066700 4300081201 10 0)
(:GOOD 4300066700 NIL)
Real time: 0.00679 sec.
Run time: 0.00664 sec.
Space: 251128 Bytes
EQL-OK: NIL
(LET ((TOTAL 10000)) (LOOP :WITH BAD = 0 :REPEAT TOTAL :FOR TIME = (RANDOM 10000000000) :FOR CHECK = (CHECK-UNIVERSAL-TIME TIME) :WHEN CHECK :COLLECT (PROGN (INCF BAD) CHECK) :FINALLY (FORMAT T "~&~:D out of ~:D bad: ~5F%~%" BAD TOTAL (/ BAD TOTAL 0.01d0))))
WARNING: LOOP: FOR clauses should occur before the loop's main body
WARNING: LOOP: FOR clauses should occur before the loop's main body
0 out of 10,000 bad:   0.0%
EQL-OK: NIL
(LET ((TOTAL 10000)) (LOOP :WITH BAD = 0 :REPEAT TOTAL :FOR TIME = (RANDOM 10000000000) :FOR CHECK = (CHECK-UNIVERSAL-TIME TIME 0) :WHEN CHECK :COLLECT (PROGN (INCF BAD) CHECK) :FINALLY (FORMAT T "~&~:D out of ~:D bad: ~5F%~%" BAD TOTAL (/ BAD TOTAL 0.01d0))))
WARNING: LOOP: FOR clauses should occur before the loop's main body
WARNING: LOOP: FOR clauses should occur before the loop's main body
0 out of 10,000 bad:   0.0%
EQL-OK: NIL
(- (ENCODE-UNIVERSAL-TIME 12 34 21 23 12 2208) (ENCODE-UNIVERSAL-TIME 12 34 20 23 12 2208))
EQL-OK: 3600
(PROGN (SYMBOL-CLEANUP 'CHECK-UNIVERSAL-TIME) (SYMBOL-CLEANUP 'TIME-LOOP))
EQL-OK: T
RUN-TEST: finished "time" (0 errors out of 22 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"tread.tst" @1>
27
EQL-OK: 27
27
EQL-OK: 27
27
EQL-OK: 27
27
EQL-OK: 27
27
EQL-OK: 27
27
EQL-OK: 27
27
EQL-OK: 27
'(A B)
EQUAL-OK: (A B)
'(A B)
EQUAL-OK: (A B)
'(A B)
EQUAL-OK: (A B)
'(A B)
EQUAL-OK: (A B)
'(A B)
EQUAL-OK: (A B)
'|foobar|
EQL-OK: |foobar|
'|foobar|
EQL-OK: |foobar|
'|fooBARbaz|
EQL-OK: |fooBARbaz|
'|fooBARbaz|
EQL-OK: |fooBARbaz|
(PROGN (UNLESS (FIND-PACKAGE '|foo|) (MAKE-PACKAGE '|foo|)) T)
EQL-OK: T
'|foo:bar|
EQL-OK: |foo:bar|
(READ-FROM-STRING "|foo|:|bar|")
[SIMPLE-PACKAGE-ERROR]: READ from #<INPUT STRING-INPUT-STREAM>: #1=#<PACKAGE |foo|> has no external symbol with name "bar"

EQL-OK: ERROR
(DELETE-PACKAGE '#:|foo|)
EQL-OK: T
'|1B5000|
EQL-OK: |1B5000|
'|777777Q|
EQL-OK: |777777Q|
'|1.7J|
EQL-OK: |1.7J|
'|-3/4+6.7J|
EQL-OK: |-3/4+6.7J|
'|12/25/83|
EQL-OK: |12/25/83|
'|27^19|
EQL-OK: |27^19|
'|3^4/5|
EQL-OK: |3^4/5|
'|6//7|
EQL-OK: |6//7|
'|3.1.2.6|
EQL-OK: |3.1.2.6|
'|^-43^|
EQL-OK: |^-43^|
'|3.141_592_653_589_793_238_4|
EQL-OK: |3.141_592_653_589_793_238_4|
'|-3.7+2.6I-6.17J+19.6K|
EQL-OK: |-3.7+2.6I-6.17J+19.6K|
'/
EQL-OK: /
'/5
EQL-OK: /5
'+
EQL-OK: +
'1+
EQL-OK: 1+
'1-
EQL-OK: 1-
'FOO+
EQL-OK: FOO+
'AB.CD
EQL-OK: AB.CD
'_
EQL-OK: _
'^
EQL-OK: ^
'^/-
EQL-OK: ^/-
'BAD-FACE
EQL-OK: BAD-FACE
'25-SEC-83
EQL-OK: 25-SEC-83
'A/B
EQL-OK: A/B
'FAD_CAFE
EQL-OK: FAD_CAFE
'F^
EQL-OK: F^
(SETQ *PRINT-BASE* 16)
EQL-OK: 10
'|BAD-FACE|
EQL-OK: |BAD-FACE|
'|25-SEC-83|
EQL-OK: |25-SEC-83|
'|A/B|
EQL-OK: |A/B|
'|FAD_CAFE|
EQL-OK: |FAD_CAFE|
'|F^|
EQL-OK: |F^|
(SETQ *PRINT-BASE* A)
EQL-OK: 10
'|123|
EQL-OK: |123|
'|123E12|
EQL-OK: |123E12|
'|123S12|
EQL-OK: |123S12|
'|123L12|
EQL-OK: |123L12|
'|123D12|
EQL-OK: |123D12|
'|123F12|
EQL-OK: |123F12|
'|123/12|
EQL-OK: |123/12|
'(A . B)
EQUAL-OK: (A . B)
'(A.B)
EQUAL-OK: (A.B)
'(A. B)
EQUAL-OK: (A. B)
'(A |.| B C)
EQUAL-OK: (A |.| B C)
'(A |.| B C)
EQUAL-OK: (A |.| B C)
'(A |...| B C)
EQUAL-OK: (A |...| B C)
'(A |...| B C)
EQUAL-OK: (A |...| B C)
'(A B . C)
EQUAL-OK: (A B . C)
'.AB
EQL-OK: .AB
(READ-FROM-STRING "(. b)")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: token "." not allowed here

EQL-OK: ERROR
(READ-FROM-STRING "(a .. b)")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: a token consisting only of dots cannot be meaningfully read in

EQL-OK: ERROR
(READ-FROM-STRING "(a . . 'b   )")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: token "." not allowed here

EQL-OK: ERROR
(READ-FROM-STRING "(a b c ...)")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: a token consisting only of dots cannot be meaningfully read in

EQL-OK: ERROR
#\Newline
EQL-OK: #\Newline
#\Newline
EQL-OK: #\Newline
#\Space
EQL-OK: #\Space
#\Rubout
EQL-OK: #\Rubout
#\Page
EQL-OK: #\Page
#\Tab
EQL-OK: #\Tab
#\Backspace
EQL-OK: #\Backspace
#\Return
EQL-OK: #\Return
(SETQ *READ-BASE* 2)
EQL-OK: 2
(SETQ *PRINT-RADIX* T)
EQL-OK: T
(PRIN1-TO-STRING #10r4/3)
EQUAL-OK: "#10r4/3"
(SETQ *PRINT-BASE* 2.)
EQL-OK: #b10
(PRIN1-TO-STRING #b100/11)
EQUAL-OK: "#b100/11"
(SETQ *PRINT-BASE* #b1010)
EQL-OK: 10.
'|123|
EQL-OK: |123|
123.
EQL-OK: 123.
312.
EQL-OK: 312.
(SETQ *READ-BASE* 10.)
EQL-OK: 10.
(SETQ *PRINT-RADIX* NIL)
EQL-OK: NIL
0.1
EQL-OK: 0.1
0.1
EQL-OK: 0.1
-0.1
EQL-OK: -0.1
1.0
EQL-OK: 1.0
1.0
EQL-OK: 1.0
-1.0
EQL-OK: -1.0
10.0
EQL-OK: 10.0
10.0
EQL-OK: 10.0
-10.0
EQL-OK: -10.0
10.0
EQL-OK: 10.0
10.0
EQL-OK: 10.0
-10.0
EQL-OK: -10.0
(SETQ *READ-BASE* 16)
EQL-OK: 16
'|1A1.|
EQL-OK: |1A1.|
'|1R1.|
EQL-OK: |1R1.|
(SETQ *READ-BASE* 10)
EQL-OK: 10
(SETQ *PRINT-LEVEL* 10)
EQL-OK: 10
(SETQ *PRINT-CIRCLE* T)
EQL-OK: T
(PRIN1-TO-STRING '(#1=(A B #1#)))
EQUALP-OK: "(#1=(a b #1#))"
(PRIN1-TO-STRING '(#1=(#1#)))
EQUAL-OK: "(#1=(#1#))"
(PRIN1-TO-STRING '(#1=(A B #1#) (C D #1#)))
EQUALP-OK: "(#1=(a b #1#) (c d #1#))"
(SETQ *PRINT-LEVEL* NIL)
EQL-OK: NIL
(SETQ *PRINT-LENGTH* 11)
EQL-OK: 11
(PRIN1-TO-STRING '(1 2 3 4 (5 5) 6 7 8 9 10 11 ...))
EQUAL-OK: "(1 2 3 4 (5 5) 6 7 8 9 10 11 ...)"
(PRIN1-TO-STRING '#1=(A B . #1#))
EQUAL-OK: "#1=(A B . #1#)"
(SETQ *PRINT-LENGTH* NIL)
EQL-OK: NIL
':ABC
EQL-OK: :ABC
(PROGN (UNLESS (FIND-PACKAGE 'ABC) (MAKE-PACKAGE 'ABC)) T)
EQL-OK: T
(READ-FROM-STRING "abc:de")
[SIMPLE-PACKAGE-ERROR]: READ from #<INPUT STRING-INPUT-STREAM>: #1=#<PACKAGE ABC> has no external symbol with name "DE"

EQL-OK: ERROR
'ABC::DE
EQL-OK: ABC::DE
(READ-FROM-STRING "::111")
EQL-OK: :|111|
(READ-FROM-STRING ":abc:")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: too many colons in token ":abc:"

EQL-OK: ERROR
(READ-FROM-STRING ":abc:00")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: too many colons in token ":abc:00"

EQL-OK: ERROR
(READ-FROM-STRING "ab:cd:2")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: too many colons in token "ab:cd:2"

EQL-OK: ERROR
(READ-FROM-STRING "ab:")
[SIMPLE-PACKAGE-ERROR]: READ from #<INPUT STRING-INPUT-STREAM>: there is no package with name #1="AB"

EQL-OK: ERROR
(READ-FROM-STRING "ab:cd:")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: too many colons in token "ab:cd:"

EQL-OK: ERROR
(READ-FROM-STRING "abc::")
EQL-OK: ABC::||
(DELETE-PACKAGE '#:ABC)
EQL-OK: T
#0A7
EQUALP-OK: #0A7
#(1 2 3 4 5 6 7 8)
EQUALP-OK: #(1 2 3 4 5 6 7 8)
#2A((1 2 3) (3 2 1))
EQUALP-OK: #2A((1 2 3) (3 2 1))
#3A(((1 2 3) (4 5 6)) ((1 2 3) (4 5 6)))
EQUALP-OK: #3A(((1 2 3) (4 5 6)) ((1 2 3) (4 5 6)))
(READ-FROM-STRING "#a7")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: bad syntax for array: #A7

EQL-OK: ERROR
#2A((1 2) (3 4) (5 6))
EQUALP-OK: #2A((1 2) (3 4) (5 6))
#3A(((1 2) (3 4) (5 6)) ((7 8) (9 10) (11 12)))
EQUALP-OK: #3A(((1 2) (3 4) (5 6)) ((7 8) (9 10) (11 12)))
(MULTIPLE-VALUE-LIST (READ-FROM-STRING "1(123)"))
EQUAL-OK: (1 1)
(READ-FROM-STRING "#0*111")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: BIT-VECTOR is longer than the explicitly given length 0

EQL-OK: ERROR
(READ-FROM-STRING "#0(1 1 1 )")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: VECTOR is longer than the explicitly given length 0

EQL-OK: ERROR
(READ-FROM-STRING "#0r111")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: The base 0 given between # and R should lie between 2 and 36

EQL-OK: ERROR
(READ-FROM-STRING "#1r111")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: The base 1 given between # and R should lie between 2 and 36

EQL-OK: ERROR
7
EQL-OK: 7
1333
EQL-OK: 1333
(READ-FROM-STRING "#37r111")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: The base 37 given between # and R should lie between 2 and 36

EQL-OK: ERROR
(READ-FROM-STRING "#011010")
[SIMPLE-END-OF-FILE]: READ: input stream #1=#<INPUT STRING-INPUT-STREAM> ends within read macro beginning with #\#

EQL-OK: ERROR
-1
EQL-OK: -1
-1
EQL-OK: -1
-1
EQL-OK: -1
0
EQL-OK: 0
0
EQL-OK: 0
0
EQL-OK: 0
0
EQL-OK: 0
'|-12./12|
EQL-OK: |-12./12|
'|-0./12|
EQL-OK: |-0./12|
(LIST 1 2 #\a)
EQUAL-OK: (1 2 #\a)
(READ-FROM-STRING "")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: illegal character #\Escape

EQL-OK: ERROR
(READ-FROM-STRING "abc")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: illegal character #\Escape

EQL-OK: ERROR
(READ-FROM-STRING "a|bc")
[SIMPLE-END-OF-FILE]: READ: input stream #1=#<INPUT STRING-INPUT-STREAM> ends within a token after multiple escape character

EQL-OK: ERROR
(READ-FROM-STRING "#2(a b c)")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: VECTOR is longer than the explicitly given length 2

EQL-OK: ERROR
(READ-FROM-STRING "::")
EQL-OK: :||
(READ-FROM-STRING "#2*1010")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: BIT-VECTOR is longer than the explicitly given length 2

EQL-OK: ERROR
(READ-FROM-STRING "#1#")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: undefined label #1#

EQL-OK: ERROR
(READ-FROM-STRING "... ")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: a token consisting only of dots cannot be meaningfully read in

EQL-OK: ERROR
(PROGN (SETQ *READ-BASE* 40) (READ-FROM-STRING "123"))
[SIMPLE-TYPE-ERROR]: The value of *READ-BASE* should be an integer between 2 and 36, not 40.
It has been reset to 10.

EQL-OK: ERROR
*READ-BASE*
EQL-OK: 10
(SETQ *READ-BASE* 10)
EQL-OK: 10
*READ-BASE*
EQL-OK: 10
(PROGN (SETQ *PRINT-BASE* NIL) (PRIN1-TO-STRING *PRINT-BASE*))
[SIMPLE-TYPE-ERROR]: The value of *PRINT-BASE* should be an integer between 2 and 36, not NIL.
It has been reset to 10.

EQL-OK: ERROR
(PROGN (SETQ *PRINT-BASE* 10) T)
EQL-OK: T
*PRINT-BASE*
EQL-OK: 10
(READ-FROM-STRING "#2a((1 2 3)(1 2)")
[SIMPLE-END-OF-FILE]: READ: input stream #1=#<INPUT STRING-INPUT-STREAM> ends within an object

EQL-OK: ERROR
(READ-FROM-STRING "#2a((1 2 3)(1 2))")
[SIMPLE-ERROR]: MAKE-ARRAY: (1 2) is of incorrect length

EQL-OK: ERROR
(READ-FROM-STRING "#2a(1 2 3}")
[SIMPLE-END-OF-FILE]: READ: input stream #1=#<INPUT STRING-INPUT-STREAM> ends within an object

EQL-OK: ERROR
(SETQ *PRINT-LEVEL* T)
EQL-OK: T
*PRINT-LEVEL*
EQL-OK: T
(SETQ *PRINT-LEVEL* NIL)
EQL-OK: NIL
*PRINT-LEVEL*
EQL-OK: NIL
(SETQ *PRINT-LENGTH* T)
EQL-OK: T
*PRINT-LENGTH*
EQL-OK: T
(SETQ *PRINT-LENGTH* NIL)
EQL-OK: NIL
*PRINT-LENGTH*
EQL-OK: NIL
(MAKE-SYNONYM-STREAM 123)
[SIMPLE-TYPE-ERROR]: MAKE-SYNONYM-STREAM: argument should be a symbol, not 123

EQL-OK: ERROR
(PRIN1-TO-STRING (MAKE-SYNONYM-STREAM '*READ-BASE*))
EQUAL-OK: "#<IO SYNONYM-STREAM *READ-BASE*>"
(READ-FROM-STRING "#(1 2 3 .               )")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: token "." not allowed here

EQL-OK: ERROR
(READ-FROM-STRING "(a .)")
[SIMPLE-READER-ERROR]: READ-DELIMITED-LIST from #1=#<INPUT STRING-INPUT-STREAM>: illegal end of dotted list

EQL-OK: ERROR
(READ-FROM-STRING "(. a)")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: token "." not allowed here

EQL-OK: ERROR
(MAKE-ECHO-STREAM PI *STANDARD-OUTPUT*)
[SIMPLE-TYPE-ERROR]: MAKE-ECHO-STREAM: argument #1=3.1415926535897932385L0 is not a stream

EQL-OK: ERROR
(MAKE-TWO-WAY-STREAM PI *STANDARD-OUTPUT*)
[SIMPLE-TYPE-ERROR]: MAKE-TWO-WAY-STREAM: argument #1=3.1415926535897932385L0 is not a stream

EQL-OK: ERROR
(MAKE-ECHO-STREAM *STANDARD-INPUT* PI)
[SIMPLE-TYPE-ERROR]: MAKE-ECHO-STREAM: argument #1=3.1415926535897932385L0 is not a stream

EQL-OK: ERROR
(MAKE-TWO-WAY-STREAM *STANDARD-INPUT* PI)
[SIMPLE-TYPE-ERROR]: MAKE-TWO-WAY-STREAM: argument #1=3.1415926535897932385L0 is not a stream

EQL-OK: ERROR
(PROGN (SETQ *READTABLE* T) (READ-FROM-STRING "123"))
[SIMPLE-TYPE-ERROR]: The value of *READTABLE* was not a readtable. It has been reset.

EQL-OK: ERROR
(PROGN (SETQ *READTABLE* (COPY-READTABLE NIL)) T)
EQL-OK: T
(READ-FROM-STRING "#37R")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: The base 37 given between # and R should lie between 2 and 36

EQL-OK: ERROR
(READ-FROM-STRING "#10rabc")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: token "ABC" after #r is not a rational number in base 10

EQL-OK: ERROR
(READ-FROM-STRING "#10ra/b")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: token "A/B" after #r is not a rational number in base 10

EQL-OK: ERROR
(READ-FROM-STRING "#nocontrol-")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: After #\# is #\n an undefined dispatch macro character

EQL-OK: ERROR
(READ-FROM-STRING "#control-")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: bad syntax for complex number: #CONTROL-

EQL-OK: ERROR
(SETQ *PRINT-RADIX* T)
EQL-OK: T
(WRITE-TO-STRING 11111.)
EQUAL-OK: "11111."
(SETQ *PRINT-BASE* 2.)
EQL-OK: #b10
(WRITE-TO-STRING #b10101101100111)
EQUAL-OK: "#b10101101100111"
(SETQ *PRINT-BASE* #b1000)
EQL-OK: #o10
(WRITE-TO-STRING #o25547)
EQUAL-OK: "#o25547"
(SETQ *PRINT-BASE* #o20)
EQL-OK: #x10
(WRITE-TO-STRING #x2B67)
EQUAL-OK: "#x2B67"
(SETQ *PRINT-BASE* #x16)
EQL-OK: #22r10
(WRITE-TO-STRING #22r10L1)
EQUAL-OK: "#22r10L1"
(SETQ *PRINT-BASE* #22rA)
EQL-OK: 10.
(SETQ *PRINT-RADIX* NIL)
EQL-OK: NIL
(WRITE-TO-STRING 11111)
EQUAL-OK: "11111"
(SETQ *PRINT-BASE* 2)
EQL-OK: 10
(WRITE-TO-STRING 10101101100111)
EQUAL-OK: "10101101100111"
(SETQ *PRINT-BASE* 1000)
EQL-OK: 10
(WRITE-TO-STRING 25547)
EQUAL-OK: "25547"
(SETQ *PRINT-BASE* 20)
EQL-OK: 10
(WRITE-TO-STRING 2B67)
EQUAL-OK: "2B67"
(SETQ *PRINT-BASE* 16)
EQL-OK: 10
(WRITE-TO-STRING 10L1)
EQUAL-OK: "10L1"
(SETQ *PRINT-BASE* A)
EQL-OK: 10
0.00999998
EQL-OK: 0.00999998
0.009999998
EQL-OK: 0.009999998
0.01
EQL-OK: 0.01
1.23
EQL-OK: 1.23
(PRIN1-TO-STRING 1.23E20)
EQUAL-OK: "1.23E20"
(PRIN1-TO-STRING 1.23E20)
EQUAL-OK: "1.23E20"
(PRIN1-TO-STRING 1.23s20)
EQUAL-OK: "1.23s20"
1.23d20
EQL-OK: 1.23d20
1.23L20
EQUALP-OK: 1.23d20
(PRIN1-TO-STRING 1.2345679E8)
EQUAL-OK: "1.2345679E8"
(PRIN1-TO-STRING 1.2345678E7)
EQUAL-OK: "1.2345678E7"
(PRIN1-TO-STRING 1234567.1)
EQUAL-OK: "1234567.1"
(PRIN1-TO-STRING 123456.125)
EQUAL-OK: "123456.125"
(PRIN1-TO-STRING 12345.123)
EQUAL-OK: "12345.123"
(PRIN1-TO-STRING 1234.1234)
EQUAL-OK: "1234.1234"
123.123
EQL-OK: 123.123
12.12
EQL-OK: 12.12
1.1
EQL-OK: 1.1
(SETQ *READ-DEFAULT-FLOAT-FORMAT* 'SHORT-FLOAT)
EQL-OK: SHORT-FLOAT
1.23
EQL-OK: 1.23
(PRIN1-TO-STRING 1.23E20)
EQUAL-OK: "1.23E20"
(PRIN1-TO-STRING 1.23f20)
EQUAL-OK: "1.23f20"
(PRIN1-TO-STRING 1.23E20)
EQUAL-OK: "1.23E20"
1.23d20
EQL-OK: 1.23d20
1.23L20
EQUALP-OK: 1.23d20
(PRIN1-TO-STRING 1.23457E8)
EQUAL-OK: "1.23457E8"
(PRIN1-TO-STRING 1.23457E7)
EQUAL-OK: "1.23457E7"
(PRIN1-TO-STRING 1234560.0)
EQUAL-OK: "1234560.0"
(PRIN1-TO-STRING 123456.0)
EQUAL-OK: "123456.0"
(PRIN1-TO-STRING 12345.1)
EQUAL-OK: "12345.1"
(PRIN1-TO-STRING 1234.13)
EQUAL-OK: "1234.13"
(PRIN1-TO-STRING 123.123)
EQUAL-OK: "123.123"
12.12
EQL-OK: 12.12
1.1
EQL-OK: 1.1
(SETQ *READ-DEFAULT-FLOAT-FORMAT* 'DOUBLE-FLOAT)
EQL-OK: DOUBLE-FLOAT
1.23
EQL-OK: 1.23
1.23E20
EQL-OK: 1.23E20
(PRIN1-TO-STRING 1.23f20)
EQUAL-OK: "1.23f20"
(PRIN1-TO-STRING 1.23s20)
EQUAL-OK: "1.23s20"
1.23E20
EQL-OK: 1.23E20
1.23L20
EQUALP-OK: 1.23E20
(PRIN1-TO-STRING 1.2345678912345679E8)
EQUAL-OK: "1.2345678912345679E8"
1.234567812345678E7
EQL-OK: 1.234567812345678E7
1234567.1234567
EQL-OK: 1234567.1234567
123456.123456
EQL-OK: 123456.123456
12345.12345
EQL-OK: 12345.12345
1234.1234
EQL-OK: 1234.1234
123.123
EQL-OK: 123.123
12.12
EQL-OK: 12.12
1.1
EQL-OK: 1.1
(SETQ *READ-DEFAULT-FLOAT-FORMAT* 'LONG-FLOAT)
EQL-OK: LONG-FLOAT
1.23
EQL-OK: 1.23
1.23E20
EQL-OK: 1.23E20
(PRIN1-TO-STRING 1.23f20)
EQUAL-OK: "1.23f20"
(PRIN1-TO-STRING 1.23s20)
EQUAL-OK: "1.23s20"
1.23d20
EQL-OK: 1.23d20
1.23E20
EQL-OK: 1.23E20
(PRIN1-TO-STRING 1.23456789123456789E8)
EQUAL-OK: "1.23456789123456789E8"
1.234567812345678E7
EQL-OK: 1.234567812345678E7
1234567.1234567
EQL-OK: 1234567.1234567
123456.123456
EQL-OK: 123456.123456
12345.12345
EQL-OK: 12345.12345
1234.1234
EQL-OK: 1234.1234
123.123
EQL-OK: 123.123
12.12
EQL-OK: 12.12
1.1
EQL-OK: 1.1
(SETQ *READ-DEFAULT-FLOAT-FORMAT* 'SINGLE-FLOAT)
EQL-OK: SINGLE-FLOAT
(WRITE-TO-STRING 'ABCDE)
EQUAL-OK: "ABCDE"
(WRITE-TO-STRING 'ABCDE-EFGHIJ)
EQUAL-OK: "ABCDE-EFGHIJ"
(WRITE-TO-STRING 'ABCDE1EFGHIJ)
EQUAL-OK: "ABCDE1EFGHIJ"
(WRITE-TO-STRING 'ABCDE-1EFGH)
EQUAL-OK: "ABCDE-1EFGH"
(SETQ *PRINT-CASE* :DOWNCASE)
EQL-OK: :downcase
(write-to-string 'abcde)
EQUAL-OK: "abcde"
(write-to-string 'abcde-efghij)
EQUAL-OK: "abcde-efghij"
(write-to-string 'abcde1efghij)
EQUAL-OK: "abcde1efghij"
(write-to-string 'abcde-1efgh)
EQUAL-OK: "abcde-1efgh"
(setq *print-case* :capitalize)
EQL-OK: :Capitalize
(Write-To-String 'Abcde)
EQUAL-OK: "Abcde"
(Write-To-String 'Abcde-Efghij)
EQUAL-OK: "Abcde-Efghij"
(Write-To-String 'Abcde1efghij)
EQUAL-OK: "Abcde1efghij"
(Write-To-String 'Abcde-1efgh)
EQUAL-OK: "Abcde-1efgh"
(Setq *Print-Case* :Upcase)
EQL-OK: :UPCASE
(LET ((*GENSYM-COUNTER* 1234)) (SYMBOL-NAME (GENSYM "TEST")))
EQUAL-OK: "TEST1234"
(LET ((*PRINT-GENSYM* T) (G (GENSYM 7))) (LIST (PRINC-TO-STRING G) (PRIN1-TO-STRING G)))
EQUAL-OK: ("G7" "#:G7")
(LET ((*PRINT-GENSYM* NIL) (G (GENSYM 20))) (LIST (PRINC-TO-STRING G) (PRIN1-TO-STRING G)))
EQUAL-OK: ("G20" "G20")
(WRITE-TO-STRING NIL)
EQUAL-OK: "NIL"
(WRITE-TO-STRING '(A B NIL C))
EQUAL-OK: "(A B NIL C)"
(WRITE-TO-STRING '(A B (NIL) C))
EQUAL-OK: "(A B (NIL) C)"
(WRITE-TO-STRING '(A B (NIL C) D))
EQUAL-OK: "(A B (NIL C) D)"
(WRITE-TO-STRING '#(A B NIL C (A B NIL C) (NIL)))
EQUAL-OK: "#(A B NIL C (A B NIL C) (NIL))"
(SETQ *PRINT-PRETTY* T)
EQL-OK: T
(WRITE-TO-STRING NIL)
EQUAL-OK: "NIL"
(WRITE-TO-STRING '(A B NIL C))
EQUAL-OK: "(A B NIL C)"
(WRITE-TO-STRING '(A B (NIL) C))
EQUAL-OK: "(A B (NIL) C)"
(WRITE-TO-STRING '(A B (NIL C) D))
EQUAL-OK: "(A B (NIL C) D)"
(WRITE-TO-STRING '#(A B NIL C (A B NIL C) (NIL)))
EQUAL-OK: "#(A B NIL C (A B NIL C) (NIL))"
(SETQ *PRINT-PRETTY* NIL)
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#o33"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#x1b"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#b11011"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#.(* 3 3 3)"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "(a . b)"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "(a.b)"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "(a. b)"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "(a . b c)"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "(a |.| b c)"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "(a ... b c)"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "(a |...| b c)"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "(a b . c)"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING ".ab"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "(. b)"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "(a .. b)"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "(a . . 'b   )"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "(a b c ...)"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (MULTIPLE-VALUE-LIST (READ-FROM-STRING "#\\control-meta-a")))
EQUAL-OK: (NIL 16)
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#\\control-meta-\\a"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#\\linefeed"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#\\newline"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#\\space"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#\\rubout"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#\\page"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#\\tab"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#\\backspace"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#\\return"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#\\control-space"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#\\c-m-return"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#\\control-meta-tab"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#\\h-s-m-c-rubout"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#\\control-%"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#\\control-\""))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#\\meta->"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "xx:xx"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "xx::xx"))
EQL-OK: NIL
(SETQ *PRINT-LEVEL* 10)
EQL-OK: 10
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "(#1=(a b #1#))"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "(#1=(#1#))"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "(#1=(a b #1#) (c d #1#))"))
EQL-OK: NIL
(SETQ *PRINT-LEVEL* NIL)
EQL-OK: NIL
(SETQ *PRINT-LENGTH* 11)
EQL-OK: 11
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#1=(a b . #1#)"))
EQL-OK: NIL
(SETQ *PRINT-LENGTH* NIL)
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#0a7"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#1a(1 2 3 4 5 6 7 8)"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#2a((1 2 3)(3 2 1))"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#3a(((1 2 3 ) (4 5 6))
                                                          ((1 2 3 ) (4 5 6)))"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#a7"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#2a((1 2)(3 4)(5 6))"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#3a(((1 2)(3 4)(5 6))
                                                          ((7 8)(9 10)(11 12)))"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#0*111"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#0(1 1 1 )"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#0r111"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#1r111"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#2r111"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#36r111"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#37r111"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#2(a b c)"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#2*1010"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#1#"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#(1 2 3 .               )"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "(a .)"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "(. a)"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#37R"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#10rabc"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#10ra/b"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#\\nocontrol-"))
EQL-OK: NIL
(LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#\\control-"))
EQL-OK: NIL
(READ-FROM-STRING "#\\break")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: there is no character with name "bREAK"

EQL-OK: ERROR
(READ-FROM-STRING "#\\home-up")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: there is no character with name "hOME-UP"

EQL-OK: ERROR
(READ-FROM-STRING "#\\escape")
EQL-OK: #\Escape
NIL
EQL-OK: NIL
NIL
EQL-OK: NIL
(READ-FROM-STRING "#c(pi 0)")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: bad syntax for complex number: #C(PI 0)

EQL-OK: ERROR
(READ-FROM-STRING "#c(0 pi)")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: bad syntax for complex number: #C(0 PI)

EQL-OK: ERROR
(SETQ *READTABLE* (COPY-READTABLE NIL) *PRINT-BASE* 10 *PRINT-CASE* :UPCASE *PRINT-CIRCLE* NIL *PRINT-ESCAPE* T *PRINT-GENSYM* T *PRINT-LENGTH* NIL *PRINT-LEVEL* NIL *PRINT-LINES* NIL *PRINT-RADIX* NIL *READ-BASE* 10)
EQL-OK: 10
RUN-TEST: finished "tread" (0 errors out of 395 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"type.tst" @1>
(TYPEP 'A 'SYMBOL)
EQL-OK: T
(TYPEP 'NIL 'SYMBOL)
EQL-OK: T
(TYPEP '(NIL) 'SYMBOL)
EQL-OK: NIL
(TYPEP 3 'INTEGER)
EQL-OK: T
(TYPEP 3 '(INTEGER 0 4))
EQL-OK: T
(TYPEP 3 '(INTEGER 0 3))
EQL-OK: T
(TYPEP 3 '(INTEGER 0 2))
EQL-OK: NIL
(TYPEP 3 '(FLOAT 0.0 2.0))
EQL-OK: NIL
(TYPEP 3 '(FLOAT 0.0 2.0))
EQL-OK: NIL
(TYPEP 3 '(FLOAT 0.0 4.0))
EQL-OK: NIL
(TYPEP 3.2 '(FLOAT 0.0 4.0))
EQL-OK: T
(TYPEP 3.2 '(FLOAT 0.0 3.2))
EQL-OK: T
(TYPEP 3.2 '(FLOAT 0.0 (3.2)))
EQL-OK: NIL
(TYPEP 3.2 '(SHORT-FLOAT 0.0s0 3.2s0))
EQL-OK: NIL
(TYPEP 3.2 '(SINGLE-FLOAT 0.0 3.2))
EQL-OK: T
(TYPEP 3.2 '(DOUBLE-FLOAT 0.0d0 3.2d0))
EQL-OK: NIL
(TYPEP 3.2 '(DOUBLE-FLOAT 0.0d0 3.2d0))
EQL-OK: NIL
(TYPEP 3.2 '(DOUBLE-FLOAT 0.0d0 3.2d0))
EQL-OK: NIL
(TYPEP 3.2s0 '(DOUBLE-FLOAT 0.0d0 3.2d0))
EQL-OK: NIL
(TYPEP 3.2 '(DOUBLE-FLOAT 0.0d0 3.2d0))
EQL-OK: NIL
(TYPEP 3.2 '(FLOAT 0.0 3.2))
EQL-OK: T
(TYPEP 3.2s0 '(FLOAT 0.0s0 3.2s0))
EQL-OK: T
(TYPEP 2.0s0 '(SHORT-FLOAT 0.0s0 3.0s0))
EQL-OK: T
(TYPEP 2.0s0 '(SINGLE-FLOAT 0.0 3.0))
EQL-OK: NIL
(TYPEP 2.0 '(SINGLE-FLOAT 0.0 3.0))
EQL-OK: T
(TYPEP 2.0d0 '(DOUBLE-FLOAT 0.0d0 3.0d0))
EQL-OK: T
(TYPEP 3.0d0 '(DOUBLE-FLOAT 0.0d0 3.0d0))
EQL-OK: T
(TYPEP 3.0d0 '(DOUBLE-FLOAT 0.0d0 (3.0d0)))
EQL-OK: NIL
(TYPEP 4 '(MOD 4))
EQL-OK: NIL
(TYPEP 4 '(MOD 5))
EQL-OK: T
(TYPEP 4 '(RATIONAL 2 5))
EQL-OK: T
(TYPEP 4 '(RATIONAL 2 7/2))
EQL-OK: NIL
(TYPEP 4 '(RATIONAL 2 9/2))
EQL-OK: T
(TYPEP 4 '(RATIONAL 2 4))
EQL-OK: T
(TYPEP 4/3 '(RATIONAL 2 4))
EQL-OK: NIL
(TYPEP 2 '(RATIONAL 2 4))
EQL-OK: T
(TYPEP "abcd" 'STRING)
EQL-OK: T
(TYPEP "abcd" '(STRING 4))
EQL-OK: T
(TYPEP "abcd" '(STRING 43))
EQL-OK: NIL
(TYPEP '#(2 3) '(COMPLEX INTEGER))
EQL-OK: NIL
(TYPEP '#(2 3) 'COMPLEX)
EQL-OK: NIL
(TYPEP #C(2 3) 'COMPLEX)
EQL-OK: T
(TYPEP #C(2 3) '(COMPLEX INTEGER))
EQL-OK: T
(TYPEP #C(2.2 3) '(COMPLEX FLOAT))
EQL-OK: NIL
(TYPEP #C(2 3) '(COMPLEX SYMBOL))
[SIMPLE-ERROR]: UPGRADED-COMPLEX-PART-TYPE: type SYMBOL is not a subtype of REAL
EQL-OK: ERROR
(TYPEP '#(A B C D) 'VECTOR)
EQL-OK: T
(TYPEP '#(A B C D) '(VECTOR * 4))
EQL-OK: T
(TYPEP #C(0 1) '(COMPLEX (EQL 0)))
EQL-OK: NIL
(TYPEP 'A '(SYMBOL CONS))
[SIMPLE-ERROR]: TYPEP: invalid type specification (SYMBOL CONS)
EQL-OK: ERROR
(TYPEP 'A '(OR CONS SYMBOL))
EQL-OK: T
(TYPEP 'A '(OR CONS NUMBER))
EQL-OK: NIL
(TYPEP 'A '(OR ATOM NUMBER))
EQL-OK: T
(TYPEP 'A '(AND ATOM NUMBER))
EQL-OK: NIL
(TYPEP '2 '(AND ATOM NUMBER))
EQL-OK: T
(NOT (NOT (TYPEP '2 '(MEMBER 1 2 3))))
EQL-OK: T
(NOT (NOT (TYPEP '2 '(MEMBER 1 3))))
EQL-OK: NIL
(TYPEP '2 '(NOT (MEMBER 1 3)))
EQL-OK: T
(TYPEP '2 '(NOT (MEMBER 1 2 3)))
EQL-OK: NIL
(TYPEP 2 '(AND NUMBER (NOT SYMBOL)))
EQL-OK: T
(TYPEP 2 '(AND STRING (NOT SYMBOL)))
EQL-OK: NIL
(TYPEP 2 '(OR STRING (NOT SYMBOL)))
EQL-OK: T
(TYPEP 'CONS 'FUNCTION)
EQL-OK: NIL
(TYPEP 'CONS '(SATISFIES FUNCTIONP))
EQL-OK: NIL
(TYPEP 'CONS '(SATISFIES NOT))
EQL-OK: NIL
(TYPEP 'NIL '(SATISFIES NOT))
EQL-OK: T
(TYPEP 'NIL NIL)
EQL-OK: NIL
(TYPEP 'T NIL)
EQL-OK: NIL
(SUBTYPEP 'CONS T)
EQL-OK: T
(SUBTYPEP NIL 'CONS)
EQL-OK: T
(SUBTYPEP 'CONS 'LIST)
EQL-OK: T
(SUBTYPEP 'CONS '(OR ATOM CONS))
EQL-OK: T
(SUBTYPEP 'CONS '(AND ATOM CONS))
EQL-OK: NIL
(SUBTYPEP 'CONS '(NOT ATOM))
EQL-OK: T
(SUBTYPEP 'LIST '(NOT ATOM))
EQL-OK: NIL
(SUBTYPEP '(INTEGER 1 5) '(INTEGER 0 7))
EQL-OK: T
(SUBTYPEP '(INTEGER 1 5) '(INTEGER 0 (5)))
EQL-OK: NIL
(SUBTYPEP '(INTEGER 1 5) '(INTEGER 0 5))
EQL-OK: T
(SUBTYPEP '(INTEGER 1 5) '(MOD 5))
EQL-OK: NIL
(SUBTYPEP '(INTEGER 1 (5)) '(MOD 5))
EQL-OK: T
(SUBTYPEP '(OR (INTEGER 1 (5) FLOAT)) '(OR FLOAT (MOD 5)))
[SIMPLE-ERROR]: SUBTYPEP: invalid type specification (INTEGER 1 (5) FLOAT)
EQL-OK: ERROR
(SUBTYPEP '(OR (INTEGER 1 (5)) FLOAT) '(OR FLOAT (MOD 5)))
EQL-OK: T
(SUBTYPEP '(AND NUMBER (FLOAT 1.0 (5.0))) '(OR FLOAT (MOD 5)))
EQL-OK: T
(SUBTYPEP '(AND NUMBER (NOT (FLOAT 1.0 (5.0)))) '(OR FLOAT (MOD 5)))
EQL-OK: NIL
(SUBTYPEP '(AND FLOAT (NOT (FLOAT 1.0 (5.0)))) '(OR FLOAT (MOD 5)))
EQL-OK: T
(SUBTYPEP '(AND FLOAT (NOT (FLOAT 1.0 (5.0)))) '(OR (FLOAT * 1.0) (FLOAT * 5.0)))
EQL-OK: NIL
(SUBTYPEP '(SATISFIES CONSP) 'LIST)
EQL-OK: NIL
(SUBTYPEP 'SIMPLE-STRING 'ARRAY)
EQL-OK: T
(DEFTYPE MOD1 (N) `(AND NUMBER (FLOAT 0.0 (,N))))
EQL-OK: MOD1
(TYPEP 4.1 '(MOD1 5.0))
EQL-OK: T
(TYPEP 4.1 '(MOD1 4.1))
EQL-OK: NIL
(SUBTYPEP '(FLOAT 2.3 6.7) '(MOD1 6.8))
EQL-OK: T
(SUBTYPEP '(FLOAT 2.3 6.7) '(MOD1 6.7))
EQL-OK: NIL
(DEFUN BELIEBIGER-TEST (A) (MEMBER A '(U I V X)))
EQL-OK: BELIEBIGER-TEST
(NOT (NULL (TYPEP 'U '(SATISFIES BELIEBIGER-TEST))))
EQL-OK: T
(TYPEP 'A '(SATISFIES BELIEBIGER-TEST))
EQL-OK: NIL
(SUBTYPEP '(MEMBER U I) '(SATISFIES BELIEBIGER-TEST))
EQL-OK: T
(SUBTYPEP '(OR (MEMBER U I)) '(SATISFIES BELIEBIGER-TEST))
EQL-OK: T
(SUBTYPEP '(OR (MEMBER U I A)) '(SATISFIES BELIEBIGER-TEST))
EQL-OK: NIL
(SUBTYPEP '(SATISFIES BELIEBIGER-TEST) '(MEMBER U I V X Y))
EQL-OK: NIL
(DEFTYPE BELIEBIGER-TYP NIL '(SATISFIES BELIEBIGER-TEST))
EQL-OK: BELIEBIGER-TYP
(NOT (NULL (TYPEP 'U 'BELIEBIGER-TYP)))
EQL-OK: T
(TYPEP 'A 'BELIEBIGER-TYP)
EQL-OK: NIL
(TYPEP #\A 'FFI:FOREIGN-ADDRESS)
EQL-OK: NIL
(SUBTYPEP '(MEMBER U I) 'BELIEBIGER-TYP)
EQL-OK: T
(SUBTYPEP 'BELIEBIGER-TYP '(MEMBER U I V X Y))
EQL-OK: NIL
(SUBTYPEP NIL 'FIXNUM)
EQL-OK: T
(SUBTYPEP 'SHORT-FLOAT 'FLOAT)
EQL-OK: T
(SUBTYPEP 'SINGLE-FLOAT 'FLOAT)
EQL-OK: T
(SUBTYPEP 'DOUBLE-FLOAT 'FLOAT)
EQL-OK: T
(SUBTYPEP 'LONG-FLOAT 'FLOAT)
EQL-OK: T
(SUBTYPEP 'NULL 'SYMBOL)
EQL-OK: T
(SUBTYPEP 'NULL 'LIST)
EQL-OK: T
(SUBTYPEP 'CONS 'LIST)
EQL-OK: T
(SUBTYPEP 'STANDARD-CHAR 'STRING-CHAR)
EQL-OK: T
(SUBTYPEP 'STRING-CHAR 'CHARACTER)
EQL-OK: T
(SUBTYPEP 'STRING 'VECTOR)
EQL-OK: T
(SUBTYPEP 'BIT-VECTOR 'VECTOR)
EQL-OK: T
(SUBTYPEP 'VECTOR 'ARRAY)
EQL-OK: T
(SUBTYPEP 'SIMPLE-ARRAY 'ARRAY)
EQL-OK: T
(SUBTYPEP 'SIMPLE-VECTOR 'SIMPLE-ARRAY)
EQL-OK: T
(SUBTYPEP 'SIMPLE-VECTOR 'VECTOR)
EQL-OK: T
(SUBTYPEP 'SIMPLE-STRING 'SIMPLE-ARRAY)
EQL-OK: T
(SUBTYPEP 'SIMPLE-BIT-VECTOR 'SIMPLE-ARRAY)
EQL-OK: T
(SUBTYPEP 'SIMPLE-STRING 'STRING)
EQL-OK: T
(SUBTYPEP 'SIMPLE-STRING 'VECTOR)
EQL-OK: T
(SUBTYPEP 'SIMPLE-STRING 'SIMPLE-VECTOR)
EQL-OK: NIL
(SUBTYPEP 'SIMPLE-BIT-VECTOR 'BIT-VECTOR)
EQL-OK: T
(SUBTYPEP 'BIT-VECTOR 'VECTOR)
EQL-OK: T
(SUBTYPEP 'SIMPLE-BIT-VECTOR 'SIMPLE-VECTOR)
EQL-OK: NIL
(SUBTYPEP 'UNSIGNED-BYTE 'INTEGER)
EQL-OK: T
(SUBTYPEP 'SIGNED-BYTE 'INTEGER)
EQL-OK: T
(SUBTYPEP 'INTEGER '*)
[SIMPLE-ERROR]: SUBTYPEP: invalid type specification *
EQL-OK: ERROR
(TYPE-OF (COERCE '(1 2 3 4) '(SIMPLE-ARRAY (UNSIGNED-BYTE 8))))
EQUAL-OK: (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (4))
(TYPE-OF (COERCE '(1 2 3 4) '(SIMPLE-ARRAY *)))
EQUAL-OK: (SIMPLE-VECTOR 4)
(TYPE-OF (COERCE '(1 2 3 4) '(SIMPLE-ARRAY * (4))))
EQUAL-OK: (SIMPLE-VECTOR 4)
(MULTIPLE-VALUE-LIST (SUBTYPEP 'ATOM 'CONS))
EQUAL-OK: (NIL T)
(MULTIPLE-VALUE-LIST (SUBTYPEP 'ATOM 'LIST))
EQUAL-OK: (NIL T)
(MULTIPLE-VALUE-LIST (SUBTYPEP 'CONS 'ATOM))
EQUAL-OK: (NIL T)
(MULTIPLE-VALUE-LIST (SUBTYPEP 'LIST 'ATOM))
EQUAL-OK: (NIL T)
(MULTIPLE-VALUE-LIST (SUBTYPEP 'STREAM 'ATOM))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP 'STRING 'ATOM))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP 'VECTOR 'ATOM))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP NIL NIL))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP 'EXTENDED-CHAR 'CHARACTER))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP 'ATOM '(OR CONS (SATISFIES UNKNOWN))))
EQUAL-OK: (NIL NIL)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(VECTOR NIL) 'STRING))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP 'FFI:FOREIGN-FUNCTION 'FUNCTION))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(AND (NOT BOOLEAN) STANDARD-CHAR) 'STANDARD-CHAR))
EQUAL-OK: (T T)
(LET ((X 1)) (CTYPECASE X (T 'A)))
EQL-OK: A
(LET ((X 1)) (ETYPECASE X (T 'A)))
EQL-OK: A
(MULTIPLE-VALUE-LIST (SUBTYPEP '(AND CONS (NOT (EQL 0))) 'CONS))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(INTEGER 1 2) '(REAL 1 2)))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(INTEGER 1 2) '(REAL (1) 2)))
EQUAL-OK: (NIL T)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(MOD 10) '(OR (MOD 10) (MOD 10))))
EQUAL-OK: (T T)
(DEFUN TYPEOF-TYPEP-SUBTYPE (X Y) (LIST (TYPE-OF X) (TYPEP X Y) (SUBTYPEP (TYPE-OF X) Y)))
EQL-OK: TYPEOF-TYPEP-SUBTYPE
(TYPEOF-TYPEP-SUBTYPE #\Space 'STANDARD-CHAR)
EQUAL-OK: (STANDARD-CHAR T T)
(TYPEOF-TYPEP-SUBTYPE #\Return 'STANDARD-CHAR)
EQUAL-OK: (BASE-CHAR NIL NIL)
(TYPEOF-TYPEP-SUBTYPE (SYMBOL-FUNCTION 'LET) 'COMPILED-FUNCTION)
EQUAL-OK: (SPECIAL-OPERATOR NIL NIL)
(TYPEOF-TYPEP-SUBTYPE (SYMBOL-FUNCTION 'LET) 'FUNCTION)
EQUAL-OK: (SPECIAL-OPERATOR NIL NIL)
(TYPEOF-TYPEP-SUBTYPE #'CAR 'COMPILED-FUNCTION)
EQUAL-OK: (COMPILED-FUNCTION T T)
(TYPEOF-TYPEP-SUBTYPE #'CAR 'FUNCTION)
EQUAL-OK: (COMPILED-FUNCTION T T)
(TYPEOF-TYPEP-SUBTYPE #'CAR 'GENERIC-FUNCTION)
EQUAL-OK: (COMPILED-FUNCTION NIL NIL)
(TYPEOF-TYPEP-SUBTYPE #'COMPILE 'COMPILED-FUNCTION)
EQUAL-OK: (COMPILED-FUNCTION T T)
(TYPEOF-TYPEP-SUBTYPE #'COMPILE 'FUNCTION)
EQUAL-OK: (COMPILED-FUNCTION T T)
(TYPEOF-TYPEP-SUBTYPE #'COMPILE 'GENERIC-FUNCTION)
EQUAL-OK: (COMPILED-FUNCTION NIL NIL)
(TYPEOF-TYPEP-SUBTYPE #'PRINT-OBJECT 'COMPILED-FUNCTION)
EQUAL-OK: (STANDARD-GENERIC-FUNCTION NIL NIL)
(TYPEOF-TYPEP-SUBTYPE #'PRINT-OBJECT 'FUNCTION)
EQUAL-OK: (STANDARD-GENERIC-FUNCTION T T)
(TYPEOF-TYPEP-SUBTYPE #'PRINT-OBJECT 'GENERIC-FUNCTION)
EQUAL-OK: (STANDARD-GENERIC-FUNCTION T T)
(TYPEOF-TYPEP-SUBTYPE #'PRINT-OBJECT 'STANDARD-GENERIC-FUNCTION)
EQUAL-OK: (STANDARD-GENERIC-FUNCTION T T)
(TYPEOF-TYPEP-SUBTYPE (MAKE-ARRAY 0 :ELEMENT-TYPE NIL) 'STRING)
EQUAL-OK: ((SIMPLE-ARRAY NIL (0)) T T)
(TYPEOF-TYPEP-SUBTYPE (MAKE-ARRAY 0 :ELEMENT-TYPE NIL) '(VECTOR NIL))
EQUAL-OK: ((SIMPLE-ARRAY NIL (0)) T T)
(SUBTYPEP '(MEMBER 0 1 2) '(MOD 3))
EQL-OK: T
(SUBTYPEP '(MOD 3) '(MEMBER 0 1 2))
EQL-OK: T
(SUBTYPEP '(MEMBER 0 1 2 4 8) '(MOD 3))
EQL-OK: NIL
(SUBTYPEP '(MOD 3) '(MEMBER 0 1 2 4 8))
EQL-OK: T
(SUBTYPEP '(OR (INTEGER 0 999) (INTEGER 1001 2000)) '(AND (INTEGER 0 2000) (NOT (EQL 1000))))
EQL-OK: T
(SUBTYPEP '(AND (INTEGER 0 2000) (NOT (EQL 1000))) '(OR (INTEGER 0 999) (INTEGER 1001 2000)))
EQL-OK: T
(SUBTYPEP '(OR (INTEGER 0 1000) (INTEGER 1001 3000)) '(OR (INTEGER 0 2000) (INTEGER 2001 3000)))
EQL-OK: T
(SUBTYPEP 'COMPLEX '(COMPLEX * *))
EQL-OK: T
(SUBTYPEP '(COMPLEX * *) 'COMPLEX)
EQL-OK: T
(SUBTYPEP 'COMPLEX '(COMPLEX REAL REAL))
EQL-OK: T
(SUBTYPEP '(COMPLEX REAL REAL) 'COMPLEX)
EQL-OK: T
(SUBTYPEP '(COMPLEX * *) '(COMPLEX REAL REAL))
EQL-OK: T
(SUBTYPEP '(COMPLEX REAL REAL) '(COMPLEX * *))
EQL-OK: T
(SUBTYPEP '(COMPLEX NIL NIL) 'NIL)
EQL-OK: T
(MULTIPLE-VALUE-LIST (SUBTYPEP '(NOT INTEGER) '(OR NUMBER (SATISFIES ANYTHING))))
EQUAL-OK: (NIL NIL)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(AND SYMBOL NUMBER) 'NIL))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(ARRAY T (2 5)) '(OR (ARRAY T (2 3 4)) (ARRAY T (2 4)))))
EQUAL-OK: (NIL T)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(ARRAY T (2 5)) '(NOT (OR (ARRAY T (2 3 4)) (ARRAY T (2 5))))))
EQUAL-OK: (NIL T)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(ARRAY T (2 5)) '(NOT (OR (ARRAY T (2 3 4)) (ARRAY T (2 4))))))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(AND (RATIONAL 2/3 1) RATIO) '(AND (RATIONAL 4/5 1) RATIO)))
EQUAL-OK: (NIL T)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(RATIONAL 4/5 1) '(OR (MEMBER 1) (RATIONAL 2/3 (1)))))
EQUAL-OK: (T T)
(LET ((L '(ARRAY BASE-CHAR BASE-STRING BIT-VECTOR BOOLEAN CHARACTER COMPLEX CONS FLOAT FUNCTION GENERIC-FUNCTION HASH-TABLE INTEGER LIST NULL NUMBER PACKAGE PATHNAME LOGICAL-PATHNAME RANDOM-STATE RATIONAL READTABLE REAL SEQUENCE STANDARD-GENERIC-FUNCTION STREAM STRING SYMBOL VECTOR)) (FAILURES 'NIL)) (DOLIST (A L) (DOLIST (B L) (UNLESS (OR (SUBTYPEP A B) (SUBTYPEP B A)) (LET ((CONTAINS-NULL (AND (MEMBER A '(BOOLEAN LIST NULL SEQUENCE SYMBOL)) (MEMBER B '(BOOLEAN LIST NULL SEQUENCE SYMBOL)))) (CONTAINS-VECTOR (AND (MEMBER A '(ARRAY VECTOR SEQUENCE)) (MEMBER B '(ARRAY VECTOR SEQUENCE))))) (UNLESS (IF CONTAINS-NULL (AND (EQUAL (MULTIPLE-VALUE-LIST (SUBTYPEP `(AND ,A ,B) 'NIL)) '(NIL T)) (EQUAL (MULTIPLE-VALUE-LIST (SUBTYPEP `(AND ,A ,B) 'NULL)) '(T T))) (IF CONTAINS-VECTOR (AND (EQUAL (MULTIPLE-VALUE-LIST (SUBTYPEP `(AND ,A ,B) 'NIL)) '(NIL T)) (EQUAL (MULTIPLE-VALUE-LIST (SUBTYPEP `(AND ,A ,B) 'VECTOR)) '(T T))) (EQUAL (MULTIPLE-VALUE-LIST (SUBTYPEP `(AND ,A ,B) 'NIL)) '(T T)))) (PUSH (LIST A B) FAILURES)))))) FAILURES)
EQUAL-OK: ((STREAM STANDARD-GENERIC-FUNCTION) (STREAM GENERIC-FUNCTION) (STREAM FUNCTION) (STANDARD-GENERIC-FUNCTION STREAM) (GENERIC-FUNCTION STREAM) #'STREAM)
(UNINTERN 'BAR)
EQL-OK: T
(UNINTERN 'FOO)
EQL-OK: T
(PROGN (SETQ *DISJOINT-TYPES-LIST* '(CONS SYMBOL ARRAY NUMBER CHARACTER HASH-TABLE FUNCTION READTABLE PACKAGE PATHNAME STREAM RANDOM-STATE CONDITION RESTART)) (DEFCLASS BAR NIL NIL) (DEFSTRUCT FOO))
EQL-OK: FOO
(LOOP FOR TYPE IN *DISJOINT-TYPES-LIST* UNLESS (AND (EQUAL (MULTIPLE-VALUE-LIST (SUBTYPEP TYPE 'BAR)) '(NIL T)) (EQUAL (MULTIPLE-VALUE-LIST (SUBTYPEP 'BAR TYPE)) '(NIL T))) COLLECT TYPE)
EQL-OK: NIL
(LOOP FOR TYPE IN *DISJOINT-TYPES-LIST* UNLESS (AND (EQUAL (MULTIPLE-VALUE-LIST (SUBTYPEP TYPE 'FOO)) '(NIL T)) (EQUAL (MULTIPLE-VALUE-LIST (SUBTYPEP 'FOO TYPE)) '(NIL T))) COLLECT TYPE)
EQL-OK: NIL
(MULTIPLE-VALUE-LIST (SUBTYPEP '(FUNCTION (T T) CONS) 'FUNCTION))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP 'FUNCTION '(FUNCTION (T T) CONS)))
EQUAL-OK: (NIL NIL)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(FUNCTION (INTEGER INTEGER) CONS) '(FUNCTION (T T) CONS)))
EQUAL-OK: (NIL NIL)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(FUNCTION (T T) CONS) '(FUNCTION (INTEGER INTEGER) CONS)))
EQUAL-OK: (NIL NIL)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(EQL #<SYSTEM-FUNCTION CONS>) '(FUNCTION (INTEGER INTEGER) CONS)))
EQUAL-OK: (NIL NIL)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(AND (EQL #<SYSTEM-FUNCTION CONS>) INTEGER) 'CHARACTER))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(AND (EQL #<SYSTEM-FUNCTION CONS>) (FUNCTION (T T) CONS)) 'CHARACTER))
EQUAL-OK: (NIL NIL)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(AND (EQL #<SYSTEM-FUNCTION CONS>) FUNCTION) 'CHARACTER))
EQUAL-OK: (NIL T)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(AND (EQL #<SYSTEM-FUNCTION CONS>) INTEGER) '(FUNCTION (INTEGER INTEGER) CONS)))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(AND (EQL #<SYSTEM-FUNCTION CONS>) (FUNCTION (T T) CONS)) '(FUNCTION (INTEGER INTEGER) CONS)))
EQUAL-OK: (NIL NIL)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(AND (EQL #<SYSTEM-FUNCTION CONS>) FUNCTION) '(FUNCTION (INTEGER INTEGER) CONS)))
EQUAL-OK: (NIL NIL)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(AND (EQL #<SYSTEM-FUNCTION CONS>) INTEGER) 'FUNCTION))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(AND (EQL #<SYSTEM-FUNCTION CONS>) (FUNCTION (T T) CONS)) 'FUNCTION))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(AND (EQL #<SYSTEM-FUNCTION CONS>) FUNCTION) 'FUNCTION))
EQUAL-OK: (T T)
(LOOP :WITH CLASS = (FIND-CLASS 'VECTOR) :FOR X :IN '((1 0) #(1 0) #*10) :FOR Y = (COERCE X CLASS) :ALWAYS (AND (EQUALP Y #(1 0)) (VECTORP Y)))
EQL-OK: T
(COERCE 1.0 'COMPLEX)
EQL-OK: #C(1.0 0.0)
(WITHOUT-PACKAGE-LOCK ("CL") (DEFTYPE OTHERWISE NIL NIL))
EQL-OK: OTHERWISE
(TYPECASE 'FOO (OTHERWISE :WRONG) (T :RIGHT))
EQL-OK: :RIGHT
(TYPECASE 'FOO (OTHERWISE :WRONG) (SYMBOL :RIGHT) (T :WRONG2))
EQL-OK: :RIGHT
(THE FIXNUM (+ 5 7))
EQL-OK: 12
(MULTIPLE-VALUE-LIST (THE (VALUES) (TRUNCATE 3.2 2)))
EQUAL-OK: (1 1.2)
(MULTIPLE-VALUE-LIST (THE INTEGER (TRUNCATE 3.2 2)))
EQUAL-OK: (1 1.2)
(MULTIPLE-VALUE-LIST (THE (VALUES INTEGER) (TRUNCATE 3.2 2)))
EQUAL-OK: (1 1.2)
(MULTIPLE-VALUE-LIST (THE (VALUES INTEGER FLOAT) (TRUNCATE 3.2 2)))
EQUAL-OK: (1 1.2)
(MULTIPLE-VALUE-LIST (THE (VALUES INTEGER FLOAT SYMBOL) (TRUNCATE 3.2 2)))
EQUAL-OK: (1 1.2)
(MULTIPLE-VALUE-LIST (THE (VALUES INTEGER FLOAT SYMBOL T NULL LIST) (TRUNCATE 3.2 2)))
EQUAL-OK: (1 1.2)
(LET ((I 100)) (DECLARE (FIXNUM I)) (THE FIXNUM (1+ I)))
EQL-OK: 101
(LET* ((X (LIST 'A 'B 'C)) (Y 5)) (SETF (THE FIXNUM (CAR X)) Y) X)
EQUAL-OK: (5 B C)
(THE (VALUES) 'A)
EQL-OK: A
(MULTIPLE-VALUE-LIST (THE (VALUES &REST SYMBOL) (VALUES 'A 'B)))
EQUAL-OK: (A B)
(HANDLER-CASE (THE FIXNUM 'A) (TYPE-ERROR (C) (CONS (TYPE-ERROR-EXPECTED-TYPE C) (TYPE-ERROR-DATUM C))))
EQUAL-OK: (FIXNUM A)
(TYPE-OF (MAKE-ARRAY '(10 3) :ELEMENT-TYPE NIL))
EQUAL-OK: (SIMPLE-ARRAY NIL (10 3))
(TYPE-OF (MAKE-ARRAY 10 :ELEMENT-TYPE NIL))
EQUAL-OK: (SIMPLE-ARRAY NIL (10))
(SUBTYPEP (TYPE-OF 123) 'UNSIGNED-BYTE)
EQL-OK: T
(SUBTYPEP (TYPE-OF 12345678901234567890) 'UNSIGNED-BYTE)
EQL-OK: T
(DEFSTRUCT (FOO (:TYPE LIST)) A B)
EQL-OK: FOO
(MAKE-FOO :A 123)
EQUAL-OK: (123 NIL)
(MULTIPLE-VALUE-LIST (SUBTYPEP 'FOO 'LIST))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP 'LIST 'FOO))
EQUAL-OK: (NIL T)
(DEFSTRUCT (FOO (:TYPE LIST) :NAMED) A NIL B)
EQL-OK: FOO
(LET* ((Y (MAKE-FOO :A 123)) (Z (COPY-FOO Y))) (SETF (FOO-NIL Z) 321) (LIST Y Z))
EQUAL-OK: ((FOO 123 NIL NIL) (FOO 123 321 NIL))
(PROGN (MAPC #'UNINTERN '(FOO70 FOO71 FOO72 FOO73 FOO74)) T)
EQL-OK: T
(DEFSTRUCT (FOO70 (:TYPE (VECTOR (UNSIGNED-BYTE 8)))) X Y)
EQL-OK: FOO70
(TYPE-OF (MAKE-FOO70 :X 12 :Y 5))
EQUAL-OK: (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (2))
(TYPE-OF (MAKE-FOO70 :X -1 :Y 1))
[SIMPLE-TYPE-ERROR]: SYSTEM::STORE: -1 does not fit into #(0 50), bad type

EQL-OK: ERROR
(TYPEP (MAKE-FOO70 :X 12 :Y 5) 'FOO70)
EQL-OK: T
(DEFSTRUCT (FOO71 (:TYPE LIST) (:INITIAL-OFFSET 5)))
EQL-OK: FOO71
(DEFSTRUCT (FOO72 (:TYPE LIST) (:INITIAL-OFFSET 2) (:INCLUDE FOO71)))
EQL-OK: FOO72
(LIST (LENGTH (MAKE-FOO71)) (LENGTH (MAKE-FOO72)))
EQUAL-OK: (5 7)
(TYPEP (MAKE-LIST 6) 'FOO71)
EQL-OK: T
(TYPEP (MAKE-LIST 6) 'FOO72)
EQL-OK: NIL
(MULTIPLE-VALUE-LIST (SUBTYPEP '(CONS T (CONS T (CONS T (CONS T (CONS T (CONS T NULL)))))) 'FOO71))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(CONS T (CONS T (CONS T (CONS T (CONS T (CONS T NULL)))))) 'FOO72))
EQUAL-OK: (NIL T)
(DEFSTRUCT (FOO73 (:TYPE LIST) (:INITIAL-OFFSET 5) :NAMED))
EQL-OK: FOO73
(DEFSTRUCT (FOO74 (:TYPE LIST) (:INITIAL-OFFSET 2) :NAMED (:INCLUDE FOO73)))
EQL-OK: FOO74
(LIST (LENGTH (MAKE-FOO73)) (LENGTH (MAKE-FOO74)))
EQUAL-OK: (6 9)
(TYPEP (LIST NIL NIL NIL NIL NIL 'FOO73 NIL) 'FOO73)
EQL-OK: T
(FOO73-P (LIST NIL NIL NIL NIL NIL 'FOO73 NIL))
EQL-OK: T
(TYPEP (LIST NIL NIL NIL NIL NIL 'FOO73 NIL NIL 'FOO74) 'FOO73)
EQL-OK: T
(FOO74-P (LIST NIL NIL NIL NIL NIL 'FOO73 NIL NIL 'FOO74))
EQL-OK: T
(TYPEP (LIST* NIL NIL NIL NIL NIL 'FOO73 NIL 'TAIL) 'FOO74)
EQL-OK: NIL
(FOO74-P (LIST* NIL NIL NIL NIL NIL 'FOO73 NIL 'TAIL))
EQL-OK: NIL
(MULTIPLE-VALUE-LIST (SUBTYPEP '(CONS T (CONS T (CONS T (CONS T (CONS T (CONS (EQL FOO73) NULL)))))) 'FOO73))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(CONS T (CONS T (CONS T (CONS T (CONS T (CONS (EQL FOO73) NULL)))))) 'FOO74))
EQUAL-OK: (NIL T)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(AND SIMPLE-ERROR TYPE-ERROR) 'ERROR))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP '(OR SIMPLE-ERROR TYPE-ERROR) 'CONDITION))
EQUAL-OK: (T T)
(PROGN (DEFSTRUCT (FOO129A (:TYPE LIST)) SLOT1 (SLOT2 T) (SLOT3 (FLOOR PI)) (SLOT4 44)) (DEFSTRUCT (FOO129B (:TYPE LIST) (:INCLUDE FOO129A (SLOT4 -44))) SLOT5 (SLOT6 T) (SLOT7 (FLOOR (* PI PI))) (SLOT8 88)) (LET ((A (MAKE-FOO129B))) (LIST (FOO129B-SLOT1 A) (FOO129B-SLOT2 A) (FOO129B-SLOT3 A) (FOO129B-SLOT4 A) (FOO129B-SLOT5 A) (FOO129B-SLOT6 A) (FOO129B-SLOT7 A) (FOO129B-SLOT8 A))))
EQUAL-OK: (NIL T 3 -44 NIL T 9 88)
(LET ((*BREAK-ON-SIGNALS* T) A) (DEFSTRUCT (FOO139 (:PREDICATE IS-FOO139)) P) (SETQ A (MAKE-FOO139 :P 10)) (LIST (IS-FOO139 A) (FOO139-P A)))
EQUAL-OK: (T 10)
(LET ((*BREAK-ON-SIGNALS* T) A) (DEFSTRUCT (FOO140 (:PREDICATE IS-FOO140) (:TYPE VECTOR) :NAMED) P) (SETQ A (MAKE-FOO140 :P 10)) (LIST (IS-FOO140 A) (FOO140-P A)))
EQUAL-OK: (T 10)
(DEFMACRO CHECK-TYPE-ERROR (&BODY FORMS) `(BLOCK NIL (HANDLER-BIND ((TYPE-ERROR (LAMBDA (C) (RETURN (TYPEP (TYPE-ERROR-DATUM C) (TYPE-ERROR-EXPECTED-TYPE C)))))) ,@FORMS)))
EQL-OK: CHECK-TYPE-ERROR
(CHECK-TYPE-ERROR (GETF '(A . B) 'C))
EQL-OK: NIL
(CHECK-TYPE-ERROR (GET-PROPERTIES '(A 1 B 2 C . D) '(X Y)))
EQL-OK: NIL
(CHECK-TYPE-ERROR (FBOUNDP #'CAR))
EQL-OK: NIL
(TYPEP '#1=(A 1 B 2 #1#) 'SYSTEM::PLIST)
EQL-OK: NIL
(CHECK-TYPE-ERROR (UNION NIL "A"))
EQL-OK: NIL
(MULTIPLE-VALUE-LIST (SUBTYPEP CHARSET:UCS-4 CHARSET:UTF-8))
EQUAL-OK: (T T)
(MULTIPLE-VALUE-LIST (SUBTYPEP CHARSET:UTF-8 CHARSET:UCS-4))
EQUAL-OK: (T T)
(TYPE-OF (BYTE 1 2))
EQL-OK: BYTE
(TYPEP (BYTE 1 2) 'BYTE)
EQL-OK: T
(ETYPECASE (BYTE 1 2) (INTEGER 'INTEGER) (BYTE T) (LIST 'LIST))
EQL-OK: T
(MAPCAN (LAMBDA (TYPE) (AND (TYPEP 0 TYPE) (LIST TYPE))) '(ARRAY ATOM BASE-CHAR BASE-STRING BIGNUM BIT BIT-VECTOR BROADCAST-STREAM BUILT-IN-CLASS CELL-ERROR CHARACTER CLASS COMPILED-FUNCTION COMPLEX CONCATENATED-STREAM CONDITION CONS CONTROL-ERROR DIVISION-BY-ZERO DOUBLE-FLOAT ECHO-STREAM END-OF-FILE ERROR EXTENDED-CHAR FILE-ERROR FILE-STREAM FIXNUM FLOAT FLOATING-POINT-INEXACT FLOATING-POINT-INVALID-OPERATION FLOATING-POINT-OVERFLOW FLOATING-POINT-UNDERFLOW FUNCTION GENERIC-FUNCTION HASH-TABLE INTEGER KEYWORD LIST LOGICAL-PATHNAME LONG-FLOAT METHOD METHOD-COMBINATION NIL NULL NUMBER PACKAGE PACKAGE-ERROR PARSE-ERROR PATHNAME PRINT-NOT-READABLE PROGRAM-ERROR RANDOM-STATE RATIO RATIONAL READER-ERROR READTABLE REAL RESTART SEQUENCE SERIOUS-CONDITION SHORT-FLOAT SIGNED-BYTE SIMPLE-ARRAY SIMPLE-BASE-STRING SIMPLE-BIT-VECTOR SIMPLE-CONDITION SIMPLE-ERROR SIMPLE-STRING SIMPLE-TYPE-ERROR SIMPLE-VECTOR SIMPLE-WARNING SINGLE-FLOAT STANDARD-CHAR STANDARD-CLASS STANDARD-GENERIC-FUNCTION STANDARD-METHOD STANDARD-OBJECT STORAGE-CONDITION STREAM STREAM-ERROR STRING STRING-STREAM STRUCTURE-CLASS STRUCTURE-OBJECT STYLE-WARNING SYMBOL SYNONYM-STREAM T TWO-WAY-STREAM TYPE-ERROR UNBOUND-SLOT UNBOUND-VARIABLE UNDEFINED-FUNCTION UNSIGNED-BYTE VECTOR WARNING))
EQUAL-OK: (ATOM BIT FIXNUM INTEGER NUMBER RATIONAL REAL SIGNED-BYTE T UNSIGNED-BYTE)
(LET ((SYM (GENSYM))) (PROCLAIM `(DECLARATION ,SYM)) (EVAL `(DEFTYPE ,SYM NIL T)))
[SIMPLE-ERROR]: DEFTYPE: #:G2376 names a DECLARATION, cannot name a type
EQL-OK: ERROR
(LET ((SYM (GENSYM))) (PROCLAIM `(DECLARATION ,SYM)) (EVAL `(DEFSTRUCT ,SYM A B C)))
[SIMPLE-ERROR]: DEFSTRUCT: #:G2377 names a DECLARATION, cannot name a type
EQL-OK: ERROR
(LET ((SYM (GENSYM))) (PROCLAIM `(DECLARATION ,SYM)) (EVAL `(DEFCLASS ,SYM NIL (A B C))))
[SIMPLE-ERROR]: DEFCLASS: #:G2378 names a DECLARATION, cannot name a type
EQL-OK: ERROR
(LET ((SYM (GENSYM))) (PROCLAIM `(DECLARATION ,SYM)) (EVAL `(DEFINE-CONDITION ,SYM (CONDITION) (A B C))))
[SIMPLE-ERROR]: DEFINE-CONDITION: #:G2379 names a DECLARATION, cannot name a type
EQL-OK: ERROR
(LET ((SYM (GENSYM))) (EVAL `(DEFTYPE ,SYM NIL T)) (PROCLAIM `(DECLARATION ,SYM)))
[SIMPLE-ERROR]: PROCLAIM: #:G2380 defines a type, cannot be declared a DECLARATION
EQL-OK: ERROR
(LET ((SYM (GENSYM))) (EVAL `(DEFSTRUCT ,SYM A B C)) (PROCLAIM `(DECLARATION ,SYM)))
[SIMPLE-ERROR]: PROCLAIM: #1=#:G2381 defines a type, cannot be declared a DECLARATION
EQL-OK: ERROR
(LET ((SYM (GENSYM))) (EVAL `(DEFCLASS ,SYM NIL (A B C))) (PROCLAIM `(DECLARATION ,SYM)))
[SIMPLE-ERROR]: PROCLAIM: #1=#:G2383 defines a type, cannot be declared a DECLARATION
EQL-OK: ERROR
(LET ((SYM (GENSYM))) (EVAL `(DEFINE-CONDITION ,SYM (CONDITION) (A B C))) (PROCLAIM `(DECLARATION ,SYM)))
[SIMPLE-ERROR]: PROCLAIM: #1=#:G2386 defines a type, cannot be declared a DECLARATION
EQL-OK: ERROR
(LET ((TLDL (SYSTEM::TOP-LEVEL-DECLARATIONS))) (SETF (CDR TLDL) (DELETE-IF-NOT #'SYMBOL-PACKAGE (CDR TLDL))) (EVERY #'SYMBOL-PACKAGE TLDL))
EQL-OK: T
(SYMBOLS-CLEANUP '(MOD1 BELIEBIGER-TEST BELIEBIGER-TYP TYPEOF-TYPEP-SUBTYPE *DISJOINT-TYPES-LIST* BAR FOO FOO70 FOO71 FOO72 FOO73 FOO74 FOO129A FOO129B FOO139 FOO140 CHECK-TYPE-ERROR))
EQL-OK: NIL
RUN-TEST: finished "type" (0 errors out of 289 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"unportable.tst" @1>
(DIGIT-CHAR-P #\KHMER_DIGIT_ZERO)
EQL-OK: 0
(TYPE-OF (READ-FROM-STRING (STRING #\KHMER_DIGIT_ZERO)))
EQL-OK: SYMBOL
(PROCLAIM '(INLINE SOME-FUNCTION))
EQL-OK: NIL
(DECLAIM (INLINE SOME-FUNCTION))
EQL-OK: NIL
(LET (A) (DOTIMES (I 3) (PUSH (LAMBDA NIL I) A)) (LOOP FOR X IN A COLLECT (FUNCALL X)))
EQUAL-OK: (3 3 3)
(LET (A) (DOLIST (I '(0 1 2)) (PUSH (LAMBDA NIL I) A)) (LOOP FOR X IN A COLLECT (FUNCALL X)))
EQUAL-OK: (2 2 2)
(FBOUNDP '(SETF CAR))
EQL-OK: NIL
(LET ((L (LIST 1 2 3))) (NREVERSE L) L)
EQUAL-OK: (3 2 1)
(LET ((L (LIST 1 2 3))) (NRECONC L 'A) L)
EQUAL-OK: (3 2 1 . A)
(LET ((S (MAKE-STRING 2))) (SETF (CHAR S 0) #\a) (SETF (CHAR S 1) #\b) (NREVERSE S) S)
EQUAL-OK: "ba"
(LET ((H (MAKE-HASH-TABLE))) (PUSHNEW 1 (GETHASH 2 H '(1))) (MULTIPLE-VALUE-LIST (GETHASH 2 H)))
EQUAL-OK: ((1) T)
(READ-FROM-STRING "#3()")
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: must specify elements of VECTOR of length 3

EQL-OK: ERROR
(PROGN (PROCLAIM '(SPECIAL FIRST-SPECIAL-THEN-MACRO)) T)
EQL-OK: T
(DEFINE-SYMBOL-MACRO FIRST-SPECIAL-THEN-MACRO *PRINT-CASE*)
[SIMPLE-PROGRAM-ERROR]: SYSTEM::%PROCLAIM-SYMBOL-MACRO: the symbol FIRST-SPECIAL-THEN-MACRO names a global SPECIAL variable
EQL-OK: ERROR
(DEFINE-SYMBOL-MACRO FIRST-MACRO-THEN-SPECIAL *PRINT-CASE*)
EQL-OK: FIRST-MACRO-THEN-SPECIAL
(PROGN (PROCLAIM '(SPECIAL FIRST-MACRO-THEN-SPECIAL)) T)
[SIMPLE-PROGRAM-ERROR]: PROCLAIM: attempting to turn FIRST-MACRO-THEN-SPECIAL into a SPECIAL variable, but it is already a global SYMBOL-MACRO.
EQL-OK: ERROR
(TAGBODY (BLOCK TRY-RETURN (UNWIND-PROTECT (GO EXIT) (RETURN-FROM TRY-RETURN))) EXIT)
EQL-OK: NIL
(BLOCK TRY-RETURN (TAGBODY (BLOCK TRY-RETURN (UNWIND-PROTECT (GO EXIT) (RETURN-FROM TRY-RETURN))) EXIT) (RETURN-FROM TRY-RETURN T))
EQL-OK: T
(BLOCK NIL (PROG ((X (RETURN :OUTER-LET))) (RETURN :NEVER)) (RETURN :CLHS))
EQL-OK: :CLHS
(DOLIST (I '(1 2 . 3) I))
[SIMPLE-TYPE-ERROR]: ENDP: A proper list must not end with 3

EQL-OK: ERROR
(LOOP FOR I IN '(1 2 . 3) COUNT T)
[SIMPLE-TYPE-ERROR]: ENDP: A proper list must not end with 3

EQL-OK: ERROR
(BUTLAST '(1 2 . 3) 0)
EQUAL-OK: (1 2)
(LIST 1 NIL 2)
EQUAL-OK: (1 NIL 2)
(LET ((X (LIST 1))) (MULTIPLE-VALUE-LIST (SETF (VALUES (CAR X) (CDR X)) (VALUES 2 3 4))))
EQUAL-OK: (2 3)
(LET (A (B T) C) (SETF (VALUES (VALUES A B) C) (VALUES 1 2 3 4)) (LIST A B C))
EQUAL-OK: (1 NIL 2)
(LOOP REPEAT 3.5 COUNT T)
EQL-OK: 4
(LOOP FOR I DOWNFROM (- 3.5 1) TO 0 COUNT T)
EQL-OK: 3
(LENGTH '(1 2 . 3))
[SIMPLE-TYPE-ERROR]: LENGTH: A proper list must not end with 3

EQL-OK: ERROR
(LIST-LENGTH '(1 2 . 3))
[SIMPLE-TYPE-ERROR]: LIST-LENGTH: A proper list must not end with 3

EQL-OK: ERROR
(LET ((L (LIST 1 2 3))) (DELETE 2 L) L)
EQUAL-OK: (1 3)
(SYMBOLS-CLEANUP '(FIRST-SPECIAL-THEN-MACRO FIRST-MACRO-THEN-SPECIAL))
EQL-OK: NIL
RUN-TEST: finished "unportable" (0 errors out of 31 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weak.tst" @1>
(MAPCAR #'(LAMBDA (X) (LIST (WEAK-POINTER-P X) (WEAK-LIST-P X) (WEAK-AND-RELATION-P X) (WEAK-OR-RELATION-P X) (WEAK-MAPPING-P X) (WEAK-AND-MAPPING-P X) (WEAK-OR-MAPPING-P X) (WEAK-ALIST-P X) (STRINGP (WITH-OUTPUT-TO-STRING (*STANDARD-OUTPUT*) (DESCRIBE X))))) (LIST '(A B C) #(A B C) (MAKE-WEAK-POINTER (LIST 'X)) (MAKE-WEAK-LIST (LIST 'X 'Y 'Z)) (MAKE-WEAK-AND-RELATION (LIST (LIST 'X))) (MAKE-WEAK-OR-RELATION (LIST (LIST 'X))) (MAKE-WEAK-MAPPING '#:G15 '#:G16) (MAKE-WEAK-AND-MAPPING (LIST '#:G15 '#:G16) '#:G17) (MAKE-WEAK-OR-MAPPING (LIST '#:G15 '#:G16) '#:G17) (MAKE-WEAK-ALIST)))
EQUAL-OK: ((NIL NIL NIL NIL NIL NIL NIL NIL T) (NIL NIL NIL NIL NIL NIL NIL NIL T) (T NIL NIL NIL NIL NIL NIL NIL T) (NIL T NIL NIL NIL NIL NIL NIL T) (NIL NIL T NIL NIL NIL NIL NIL T) (NIL NIL NIL T NIL NIL NIL NIL T) (NIL NIL NIL NIL T NIL NIL NIL T) (NIL NIL NIL NIL NIL T NIL NIL T) (NIL NIL NIL NIL NIL NIL T NIL T) (NIL NIL NIL NIL NIL NIL NIL T T))
(LET ((A (LIST 'X))) (LET ((W (MAKE-WEAK-POINTER A))) (GC) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE W))))
EQUAL-OK: ((X) T)
(LET ((A (LIST 'X))) (LET ((W (MAKE-WEAK-POINTER A))) (SETQ A (LIST 'Y)) (GC) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE W))))
EQUAL-OK: (NIL NIL)
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-LIST (LIST A B C)))) (GC) (WEAK-LIST-LIST W)))
EQUAL-OK: ((X) (Y) (Z))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-LIST (LIST A B C)))) (SETQ A NIL) (GC) (WEAK-LIST-LIST W)))
EQUAL-OK: ((Y) (Z))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-LIST (LIST A B C)))) (SETQ B NIL) (GC) (WEAK-LIST-LIST W)))
EQUAL-OK: ((X) (Z))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-LIST (LIST A B C)))) (SETQ C NIL) (GC) (WEAK-LIST-LIST W)))
EQUAL-OK: ((X) (Y))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-LIST (LIST A B C)))) (SETQ A 1 B 2 C 3) (GC) (WEAK-LIST-LIST W)))
EQL-OK: NIL
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-LIST (LIST A B C)))) (SETQ A NIL) (GC) (SETF (WEAK-LIST-LIST W) (LIST C B)) (GC) (WEAK-LIST-LIST W)))
EQUAL-OK: ((Z) (Y))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-LIST (LIST A B C)))) (SETQ A NIL C NIL) (GC) (SETQ C (LIST 'ZZ)) (SETF (WEAK-LIST-LIST W) (LIST C C B C)) (GC) (WEAK-LIST-LIST W)))
EQUAL-OK: ((ZZ) (ZZ) (Y) (ZZ))
(LET ((LI 'NIL)) (LOOP :FOR I :FROM 0 :TO 1000 :FOR STRING = (FORMAT NIL "~r" I) :DO (PUSH STRING LI)) (SETQ LI (NREVERSE LI)) (LET ((W (MAKE-WEAK-LIST LI))) (LIST (PROGN (GC) (LENGTH (WEAK-LIST-LIST W))) (PROGN (SETQ LI NIL) (GC) (LENGTH (WEAK-LIST-LIST W))))))
EQUAL-OK: (1001 0)
(LET ((A (LIST 'X))) (LET ((W (MAKE-WEAK-AND-RELATION (LIST A)))) (GC) (WEAK-AND-RELATION-LIST W)))
EQUAL-OK: ((X))
(LET ((A (LIST 'X))) (LET ((W (MAKE-WEAK-AND-RELATION (LIST A)))) (SETQ A (LIST 'Y)) (GC) (WEAK-AND-RELATION-LIST W)))
EQL-OK: NIL
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-AND-RELATION (LIST A B C)))) (GC) (WEAK-AND-RELATION-LIST W)))
EQUAL-OK: ((X) (Y) (Z))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-AND-RELATION (LIST A B C)))) (SETQ A NIL) (GC) (WEAK-AND-RELATION-LIST W)))
EQL-OK: NIL
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-AND-RELATION (LIST A B C)))) (SETQ B NIL) (GC) (WEAK-AND-RELATION-LIST W)))
EQL-OK: NIL
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-AND-RELATION (LIST A B C)))) (SETQ C NIL) (GC) (WEAK-AND-RELATION-LIST W)))
EQL-OK: NIL
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-AND-RELATION (LIST A (MAKE-WEAK-AND-RELATION (LIST A B)))))) (GC) (WEAK-AND-RELATION-LIST W)))
EQL-OK: NIL
(LET ((A (LIST 'X))) (LET ((W (MAKE-WEAK-OR-RELATION (LIST A)))) (GC) (WEAK-OR-RELATION-LIST W)))
EQUAL-OK: ((X))
(LET ((A (LIST 'X))) (LET ((W (MAKE-WEAK-OR-RELATION (LIST A)))) (SETQ A (LIST 'Y)) (GC) (WEAK-OR-RELATION-LIST W)))
EQL-OK: NIL
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-OR-RELATION (LIST A B C)))) (GC) (WEAK-OR-RELATION-LIST W)))
EQUAL-OK: ((X) (Y) (Z))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-OR-RELATION (LIST A B C)))) (SETQ A NIL B NIL) (GC) (WEAK-OR-RELATION-LIST W)))
EQUAL-OK: ((X) (Y) (Z))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-OR-RELATION (LIST A B C)))) (SETQ B NIL C NIL) (GC) (WEAK-OR-RELATION-LIST W)))
EQUAL-OK: ((X) (Y) (Z))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-OR-RELATION (LIST A B C)))) (SETQ A NIL C NIL) (GC) (WEAK-OR-RELATION-LIST W)))
EQUAL-OK: ((X) (Y) (Z))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-OR-RELATION (LIST A B C)))) (SETQ A NIL B NIL C NIL) (GC) (WEAK-OR-RELATION-LIST W)))
EQL-OK: NIL
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-OR-RELATION (LIST A (MAKE-WEAK-OR-RELATION (LIST A B)))))) (GC) (MAPCAR #'TYPE-OF (WEAK-OR-RELATION-LIST W))))
EQUAL-OK: (CONS WEAK-OR-RELATION)
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-OR-RELATION (LIST A (MAKE-WEAK-OR-RELATION (LIST A B)))))) (SETQ B NIL) (GC) (WEAK-OR-RELATION-LIST (SECOND (WEAK-OR-RELATION-LIST W)))))
EQUAL-OK: ((X) (Y))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-OR-RELATION (LIST (MAKE-WEAK-OR-RELATION (LIST A B)) B)))) (SETQ A NIL) (GC) (WEAK-OR-RELATION-LIST (FIRST (WEAK-OR-RELATION-LIST W)))))
EQUAL-OK: ((X) (Y))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-MAPPING A B))) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-MAPPING-VALUE W)))))
EQUAL-OK: (((X) (Y) T) ((Y)))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-MAPPING A B))) (SETQ B NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-MAPPING-VALUE W)))))
EQUAL-OK: (((X) (Y) T) ((Y)))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-MAPPING A B))) (SETQ A NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-MAPPING A B))) (SETQ A NIL B NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-MAPPING A3 A4)) (W2 (MAKE-WEAK-MAPPING A1 A2)) (W3 (MAKE-WEAK-MAPPING A4 A5)) (W4 (MAKE-WEAK-MAPPING A2 A3))) (SETQ A2 NIL A3 NIL A4 NIL A5 NIL) (GC) (LIST (WEAK-MAPPING-VALUE W2) (WEAK-MAPPING-VALUE W4) (WEAK-MAPPING-VALUE W1) (WEAK-MAPPING-VALUE W3))))
EQUAL-OK: ((X2) (X3) (X4) (X5))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-MAPPING A3 A4)) (W2 (MAKE-WEAK-MAPPING A1 A2)) (W3 (MAKE-WEAK-MAPPING A4 A5)) (W4 (MAKE-WEAK-MAPPING A2 A3))) (SETQ A1 NIL A3 NIL A4 NIL A5 NIL) (GC) (LIST (WEAK-MAPPING-VALUE W2) (WEAK-MAPPING-VALUE W4) (WEAK-MAPPING-VALUE W1) (WEAK-MAPPING-VALUE W3))))
EQUAL-OK: (NIL (X3) (X4) (X5))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-MAPPING A3 A4)) (W2 (MAKE-WEAK-MAPPING A1 A2)) (W3 (MAKE-WEAK-MAPPING A4 A5)) (W4 (MAKE-WEAK-MAPPING A2 A3))) (SETQ A1 NIL A2 NIL A4 NIL A5 NIL) (GC) (LIST (WEAK-MAPPING-VALUE W2) (WEAK-MAPPING-VALUE W4) (WEAK-MAPPING-VALUE W1) (WEAK-MAPPING-VALUE W3))))
EQUAL-OK: (NIL NIL (X4) (X5))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-MAPPING A3 A4)) (W2 (MAKE-WEAK-MAPPING A1 A2)) (W3 (MAKE-WEAK-MAPPING A4 A5)) (W4 (MAKE-WEAK-MAPPING A2 A3))) (SETQ A1 NIL A2 NIL A3 NIL A5 NIL) (GC) (LIST (WEAK-MAPPING-VALUE W2) (WEAK-MAPPING-VALUE W4) (WEAK-MAPPING-VALUE W1) (WEAK-MAPPING-VALUE W3))))
EQUAL-OK: (NIL NIL NIL (X5))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-MAPPING A3 A4)) (W2 (MAKE-WEAK-MAPPING A1 A2)) (W3 (MAKE-WEAK-MAPPING A4 A5)) (W4 (MAKE-WEAK-MAPPING A2 A3))) (SETQ A1 NIL A2 NIL A3 NIL A4 NIL) (GC) (LIST (WEAK-MAPPING-VALUE W2) (WEAK-MAPPING-VALUE W4) (WEAK-MAPPING-VALUE W1) (WEAK-MAPPING-VALUE W3))))
EQUAL-OK: (NIL NIL NIL NIL)
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-MAPPING A B))) (SETF (WEAK-MAPPING-VALUE W) C) (LIST (MULTIPLE-VALUE-LIST (WEAK-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-MAPPING-VALUE W)))))
EQUAL-OK: (((X) (Z) T) ((Z)))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-MAPPING A B))) (SETF (WEAK-MAPPING-VALUE W) C) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-MAPPING-VALUE W)))))
EQUAL-OK: (((X) (Z) T) ((Z)))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-MAPPING A B))) (GC) (SETF (WEAK-MAPPING-VALUE W) C) (LIST (MULTIPLE-VALUE-LIST (WEAK-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-MAPPING-VALUE W)))))
EQUAL-OK: (((X) (Z) T) ((Z)))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-MAPPING A B))) (SETQ A NIL) (SETF (WEAK-MAPPING-VALUE W) C) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-MAPPING A B))) (SETQ A NIL) (GC) (SETF (WEAK-MAPPING-VALUE W) C) (LIST (MULTIPLE-VALUE-LIST (WEAK-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-AND-MAPPING (LIST A) B))) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-VALUE W)))))
EQUAL-OK: ((((X)) (Y) T) ((Y)))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-AND-MAPPING (LIST A) B))) (SETQ B NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-VALUE W)))))
EQUAL-OK: ((((X)) (Y) T) ((Y)))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-AND-MAPPING (LIST A) B))) (SETQ A NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-AND-MAPPING (LIST A) B))) (SETQ A NIL B NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z)) (D (LIST 'R))) (LET ((W (MAKE-WEAK-AND-MAPPING (LIST A B C) D))) (SETQ D NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-VALUE W)))))
EQUAL-OK: ((((X) (Y) (Z)) (R) T) ((R)))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z)) (D (LIST 'R))) (LET ((W (MAKE-WEAK-AND-MAPPING (LIST A B C) D))) (SETQ A NIL D NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z)) (D (LIST 'R))) (LET ((W (MAKE-WEAK-AND-MAPPING (LIST A B C) D))) (SETQ B NIL D NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z)) (D (LIST 'R))) (LET ((W (MAKE-WEAK-AND-MAPPING (LIST A B C) D))) (SETQ C NIL D NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (D (LIST 'R))) (LET ((W (MAKE-WEAK-AND-MAPPING (LIST A (MAKE-WEAK-AND-MAPPING (LIST A B) D)) D))) (SETQ D NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-AND-MAPPING (LIST A3) A4)) (W2 (MAKE-WEAK-AND-MAPPING (LIST A1) A2)) (W3 (MAKE-WEAK-AND-MAPPING (LIST A4) A5)) (W4 (MAKE-WEAK-AND-MAPPING (LIST A2) A3))) (SETQ A2 NIL A3 NIL A4 NIL A5 NIL) (GC) (LIST (WEAK-AND-MAPPING-VALUE W2) (WEAK-AND-MAPPING-VALUE W4) (WEAK-AND-MAPPING-VALUE W1) (WEAK-AND-MAPPING-VALUE W3))))
EQUAL-OK: ((X2) (X3) (X4) (X5))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-AND-MAPPING (LIST A3) A4)) (W2 (MAKE-WEAK-AND-MAPPING (LIST A1) A2)) (W3 (MAKE-WEAK-AND-MAPPING (LIST A4) A5)) (W4 (MAKE-WEAK-AND-MAPPING (LIST A2) A3))) (SETQ A1 NIL A3 NIL A4 NIL A5 NIL) (GC) (LIST (WEAK-AND-MAPPING-VALUE W2) (WEAK-AND-MAPPING-VALUE W4) (WEAK-AND-MAPPING-VALUE W1) (WEAK-AND-MAPPING-VALUE W3))))
EQUAL-OK: (NIL (X3) (X4) (X5))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-AND-MAPPING (LIST A3) A4)) (W2 (MAKE-WEAK-AND-MAPPING (LIST A1) A2)) (W3 (MAKE-WEAK-AND-MAPPING (LIST A4) A5)) (W4 (MAKE-WEAK-AND-MAPPING (LIST A2) A3))) (SETQ A1 NIL A2 NIL A4 NIL A5 NIL) (GC) (LIST (WEAK-AND-MAPPING-VALUE W2) (WEAK-AND-MAPPING-VALUE W4) (WEAK-AND-MAPPING-VALUE W1) (WEAK-AND-MAPPING-VALUE W3))))
EQUAL-OK: (NIL NIL (X4) (X5))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-AND-MAPPING (LIST A3) A4)) (W2 (MAKE-WEAK-AND-MAPPING (LIST A1) A2)) (W3 (MAKE-WEAK-AND-MAPPING (LIST A4) A5)) (W4 (MAKE-WEAK-AND-MAPPING (LIST A2) A3))) (SETQ A1 NIL A2 NIL A3 NIL A5 NIL) (GC) (LIST (WEAK-AND-MAPPING-VALUE W2) (WEAK-AND-MAPPING-VALUE W4) (WEAK-AND-MAPPING-VALUE W1) (WEAK-AND-MAPPING-VALUE W3))))
EQUAL-OK: (NIL NIL NIL (X5))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-AND-MAPPING (LIST A3) A4)) (W2 (MAKE-WEAK-AND-MAPPING (LIST A1) A2)) (W3 (MAKE-WEAK-AND-MAPPING (LIST A4) A5)) (W4 (MAKE-WEAK-AND-MAPPING (LIST A2) A3))) (SETQ A1 NIL A2 NIL A3 NIL A4 NIL) (GC) (LIST (WEAK-AND-MAPPING-VALUE W2) (WEAK-AND-MAPPING-VALUE W4) (WEAK-AND-MAPPING-VALUE W1) (WEAK-AND-MAPPING-VALUE W3))))
EQUAL-OK: (NIL NIL NIL NIL)
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-AND-MAPPING (LIST A) B))) (SETF (WEAK-AND-MAPPING-VALUE W) C) (LIST (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-VALUE W)))))
EQUAL-OK: ((((X)) (Z) T) ((Z)))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-AND-MAPPING (LIST A) B))) (SETF (WEAK-AND-MAPPING-VALUE W) C) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-VALUE W)))))
EQUAL-OK: ((((X)) (Z) T) ((Z)))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-AND-MAPPING (LIST A) B))) (GC) (SETF (WEAK-AND-MAPPING-VALUE W) C) (LIST (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-VALUE W)))))
EQUAL-OK: ((((X)) (Z) T) ((Z)))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-AND-MAPPING (LIST A) B))) (SETQ A NIL) (SETF (WEAK-AND-MAPPING-VALUE W) C) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-AND-MAPPING (LIST A) B))) (SETQ A NIL) (GC) (SETF (WEAK-AND-MAPPING-VALUE W) C) (LIST (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-AND-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-OR-MAPPING (LIST A) B))) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-VALUE W)))))
EQUAL-OK: ((((X)) (Y) T) ((Y)))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-OR-MAPPING (LIST A) B))) (SETQ B NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-VALUE W)))))
EQUAL-OK: ((((X)) (Y) T) ((Y)))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-OR-MAPPING (LIST A) B))) (SETQ A NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-OR-MAPPING (LIST A) B))) (SETQ A NIL B NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z)) (D (LIST 'R))) (LET ((W (MAKE-WEAK-OR-MAPPING (LIST A B C) D))) (SETQ D NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-VALUE W)))))
EQUAL-OK: ((((X) (Y) (Z)) (R) T) ((R)))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z)) (D (LIST 'R))) (LET ((W (MAKE-WEAK-OR-MAPPING (LIST A B C) D))) (SETQ A NIL B NIL D NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-VALUE W)))))
EQUAL-OK: ((((X) (Y) (Z)) (R) T) ((R)))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z)) (D (LIST 'R))) (LET ((W (MAKE-WEAK-OR-MAPPING (LIST A B C) D))) (SETQ B NIL C NIL D NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-VALUE W)))))
EQUAL-OK: ((((X) (Y) (Z)) (R) T) ((R)))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z)) (D (LIST 'R))) (LET ((W (MAKE-WEAK-OR-MAPPING (LIST A B C) D))) (SETQ A NIL C NIL D NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-VALUE W)))))
EQUAL-OK: ((((X) (Y) (Z)) (R) T) ((R)))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z)) (D (LIST 'R))) (LET ((W (MAKE-WEAK-OR-MAPPING (LIST A B C) D))) (SETQ A NIL B NIL C NIL D NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (D (LIST 'R))) (LET ((W (MAKE-WEAK-OR-MAPPING (LIST A (MAKE-WEAK-OR-MAPPING (LIST A B) D)) D))) (SETQ D NIL) (GC) (MAPCAR #'TYPE-OF (WEAK-OR-MAPPING-PAIR W))))
EQUAL-OK: (CONS WEAK-OR-MAPPING)
(LET ((A (LIST 'X)) (B (LIST 'Y)) (D (LIST 'R))) (LET ((W (MAKE-WEAK-OR-MAPPING (LIST A (MAKE-WEAK-OR-MAPPING (LIST A B) D)) D))) (SETQ B NIL D NIL) (GC) (WEAK-OR-MAPPING-PAIR (SECOND (WEAK-OR-MAPPING-PAIR W)))))
EQUAL-OK: ((X) (Y))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (D (LIST 'R))) (LET ((W (MAKE-WEAK-OR-MAPPING (LIST (MAKE-WEAK-OR-MAPPING (LIST A B) D) B) D))) (SETQ A NIL D NIL) (GC) (WEAK-OR-MAPPING-PAIR (FIRST (WEAK-OR-MAPPING-PAIR W)))))
EQUAL-OK: ((X) (Y))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-OR-MAPPING (LIST A3) A4)) (W2 (MAKE-WEAK-OR-MAPPING (LIST A1) A2)) (W3 (MAKE-WEAK-OR-MAPPING (LIST A4) A5)) (W4 (MAKE-WEAK-OR-MAPPING (LIST A2) A3))) (SETQ A2 NIL A3 NIL A4 NIL A5 NIL) (GC) (LIST (WEAK-OR-MAPPING-VALUE W2) (WEAK-OR-MAPPING-VALUE W4) (WEAK-OR-MAPPING-VALUE W1) (WEAK-OR-MAPPING-VALUE W3))))
EQUAL-OK: ((X2) (X3) (X4) (X5))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-OR-MAPPING (LIST A3) A4)) (W2 (MAKE-WEAK-OR-MAPPING (LIST A1) A2)) (W3 (MAKE-WEAK-OR-MAPPING (LIST A4) A5)) (W4 (MAKE-WEAK-OR-MAPPING (LIST A2) A3))) (SETQ A1 NIL A3 NIL A4 NIL A5 NIL) (GC) (LIST (WEAK-OR-MAPPING-VALUE W2) (WEAK-OR-MAPPING-VALUE W4) (WEAK-OR-MAPPING-VALUE W1) (WEAK-OR-MAPPING-VALUE W3))))
EQUAL-OK: (NIL (X3) (X4) (X5))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-OR-MAPPING (LIST A3) A4)) (W2 (MAKE-WEAK-OR-MAPPING (LIST A1) A2)) (W3 (MAKE-WEAK-OR-MAPPING (LIST A4) A5)) (W4 (MAKE-WEAK-OR-MAPPING (LIST A2) A3))) (SETQ A1 NIL A2 NIL A4 NIL A5 NIL) (GC) (LIST (WEAK-OR-MAPPING-VALUE W2) (WEAK-OR-MAPPING-VALUE W4) (WEAK-OR-MAPPING-VALUE W1) (WEAK-OR-MAPPING-VALUE W3))))
EQUAL-OK: (NIL NIL (X4) (X5))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-OR-MAPPING (LIST A3) A4)) (W2 (MAKE-WEAK-OR-MAPPING (LIST A1) A2)) (W3 (MAKE-WEAK-OR-MAPPING (LIST A4) A5)) (W4 (MAKE-WEAK-OR-MAPPING (LIST A2) A3))) (SETQ A1 NIL A2 NIL A3 NIL A5 NIL) (GC) (LIST (WEAK-OR-MAPPING-VALUE W2) (WEAK-OR-MAPPING-VALUE W4) (WEAK-OR-MAPPING-VALUE W1) (WEAK-OR-MAPPING-VALUE W3))))
EQUAL-OK: (NIL NIL NIL (X5))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-OR-MAPPING (LIST A3) A4)) (W2 (MAKE-WEAK-OR-MAPPING (LIST A1) A2)) (W3 (MAKE-WEAK-OR-MAPPING (LIST A4) A5)) (W4 (MAKE-WEAK-OR-MAPPING (LIST A2) A3))) (SETQ A1 NIL A2 NIL A3 NIL A4 NIL) (GC) (LIST (WEAK-OR-MAPPING-VALUE W2) (WEAK-OR-MAPPING-VALUE W4) (WEAK-OR-MAPPING-VALUE W1) (WEAK-OR-MAPPING-VALUE W3))))
EQUAL-OK: (NIL NIL NIL NIL)
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-OR-MAPPING (LIST A) B))) (SETF (WEAK-OR-MAPPING-VALUE W) C) (LIST (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-VALUE W)))))
EQUAL-OK: ((((X)) (Z) T) ((Z)))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-OR-MAPPING (LIST A) B))) (SETF (WEAK-OR-MAPPING-VALUE W) C) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-VALUE W)))))
EQUAL-OK: ((((X)) (Z) T) ((Z)))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-OR-MAPPING (LIST A) B))) (GC) (SETF (WEAK-OR-MAPPING-VALUE W) C) (LIST (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-VALUE W)))))
EQUAL-OK: ((((X)) (Z) T) ((Z)))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-OR-MAPPING (LIST A) B))) (SETQ A NIL) (SETF (WEAK-OR-MAPPING-VALUE W) C) (GC) (LIST (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-OR-MAPPING (LIST A) B))) (SETQ A NIL) (GC) (SETF (WEAK-OR-MAPPING-VALUE W) C) (LIST (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (WEAK-OR-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((KA (LIST 'KX)) (VA (LIST 'VX)) (KB (LIST 'KY)) (VB (LIST 'VY)) (KC (LIST 'KZ)) (VC (LIST 'VZ))) (LET ((W (MAKE-WEAK-ALIST :TYPE :KEY :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KC VC))))) (GC) (WEAK-ALIST-TYPE W)))
EQL-OK: :KEY
(LET ((KA (LIST 'KX)) (VA (LIST 'VX)) (KB (LIST 'KY)) (VB (LIST 'VY)) (KC (LIST 'KZ)) (VC (LIST 'VZ))) (LET ((W (MAKE-WEAK-ALIST :TYPE :VALUE :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KC VC))))) (GC) (WEAK-ALIST-TYPE W)))
EQL-OK: :VALUE
(LET ((KA (LIST 'KX)) (VA (LIST 'VX)) (KB (LIST 'KY)) (VB (LIST 'VY)) (KC (LIST 'KZ)) (VC (LIST 'VZ))) (LET ((W (MAKE-WEAK-ALIST :TYPE :KEY-AND-VALUE :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KC VC))))) (GC) (WEAK-ALIST-TYPE W)))
EQL-OK: :KEY-AND-VALUE
(LET ((KA (LIST 'KX)) (VA (LIST 'VX)) (KB (LIST 'KY)) (VB (LIST 'VY)) (KC (LIST 'KZ)) (VC (LIST 'VZ))) (LET ((W (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KC VC)) :TYPE :KEY-OR-VALUE))) (GC) (WEAK-ALIST-TYPE W)))
EQL-OK: :KEY-OR-VALUE
(LET ((KA (LIST 'KX)) (VA (LIST 'VX)) (KB (LIST 'KY)) (VB (LIST 'VY)) (KC (LIST 'KZ)) (VC (LIST 'VZ))) (LET ((W (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KC VC))))) (GC) (WEAK-ALIST-TYPE W)))
EQL-OK: :KEY
(LET ((W (MAKE-WEAK-ALIST))) (GC) (WEAK-ALIST-CONTENTS W))
EQL-OK: NIL
(LET ((KA (LIST 'KX)) (VA (LIST 'VX)) (KB (LIST 'KY)) (VB (LIST 'VY)) (KC (LIST 'KZ)) (VC (LIST 'VZ))) (LET ((W (MAKE-WEAK-ALIST :TYPE :KEY :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KC VC))))) (GC) (WEAK-ALIST-CONTENTS W)))
EQUAL-OK: (((KX) VX) ((KY) VY) ((KZ) VZ))
(LET ((KA (LIST 'KX)) (VA (LIST 'VX)) (KB (LIST 'KY)) (VB (LIST 'VY)) (KC (LIST 'KZ)) (VC (LIST 'VZ))) (LET ((W (MAKE-WEAK-ALIST :TYPE :KEY :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KC VC))))) (SETQ KA NIL) (GC) (WEAK-ALIST-CONTENTS W)))
EQUAL-OK: (((KY) VY) ((KZ) VZ))
(LET ((KA (LIST 'KX)) (VA (LIST 'VX)) (KB (LIST 'KY)) (VB (LIST 'VY)) (KC (LIST 'KZ)) (VC (LIST 'VZ))) (LET ((W (MAKE-WEAK-ALIST :TYPE :KEY :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KC VC))))) (SETQ KB NIL) (GC) (WEAK-ALIST-CONTENTS W)))
EQUAL-OK: (((KX) VX) ((KZ) VZ))
(LET ((KA (LIST 'KX)) (VA (LIST 'VX)) (KB (LIST 'KY)) (VB (LIST 'VY)) (KC (LIST 'KZ)) (VC (LIST 'VZ))) (LET ((W (MAKE-WEAK-ALIST :TYPE :KEY :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KC VC))))) (SETQ KC NIL) (GC) (WEAK-ALIST-CONTENTS W)))
EQUAL-OK: (((KX) VX) ((KY) VY))
(LET ((KA (LIST 'KX)) (VA (LIST 'VX)) (KB (LIST 'KY)) (VB (LIST 'VY)) (KC (LIST 'KZ)) (VC (LIST 'VZ))) (LET ((W (MAKE-WEAK-ALIST :TYPE :KEY :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KC VC))))) (SETQ KA 1 KB 2 KC 3) (GC) (WEAK-ALIST-CONTENTS W)))
EQL-OK: NIL
(LET ((KA (LIST 'KX)) (VA (LIST 'VX)) (KB (LIST 'KY)) (VB (LIST 'VY)) (KC (LIST 'KZ)) (VC (LIST 'VZ))) (LET ((W (MAKE-WEAK-ALIST :TYPE :KEY :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KC VC))))) (SETQ KA NIL) (GC) (SETF (WEAK-ALIST-CONTENTS W) (LIST (CONS KC VC) (CONS KB VB))) (GC) (WEAK-ALIST-CONTENTS W)))
EQUAL-OK: (((KZ) VZ) ((KY) VY))
(LET ((KA (LIST 'KX)) (VA (LIST 'VX)) (KB (LIST 'KY)) (VB (LIST 'VY)) (KC (LIST 'KZ)) (VC (LIST 'VZ))) (LET ((W (MAKE-WEAK-ALIST :TYPE :KEY :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KC VC))))) (SETQ KA NIL KC NIL) (GC) (SETQ KC (LIST 'ZZ)) (SETF (WEAK-ALIST-CONTENTS W) (LIST (CONS KC VC) (CONS KC VC) (CONS KB VB) (CONS KC VC))) (GC) (WEAK-ALIST-CONTENTS W)))
EQUAL-OK: (((ZZ) VZ) ((ZZ) VZ) ((KY) VY) ((ZZ) VZ))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A B))))) (GC) (WEAK-ALIST-CONTENTS W)))
EQUAL-OK: (((X) Y))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A B))))) (SETQ B NIL) (GC) (WEAK-ALIST-CONTENTS W)))
EQUAL-OK: (((X) Y))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A B))))) (SETQ A NIL) (GC) (WEAK-ALIST-CONTENTS W)))
EQL-OK: NIL
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A B))))) (SETQ A NIL B NIL) (GC) (WEAK-ALIST-CONTENTS W)))
EQL-OK: NIL
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A3 A4)))) (W2 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A1 A2)))) (W3 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A4 A5)))) (W4 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A2 A3))))) (SETQ A2 NIL A3 NIL A4 NIL A5 NIL) (GC) (LIST (WEAK-ALIST-CONTENTS W2) (WEAK-ALIST-CONTENTS W4) (WEAK-ALIST-CONTENTS W1) (WEAK-ALIST-CONTENTS W3))))
EQUAL-OK: ((((X1) X2)) (((X2) X3)) (((X3) X4)) (((X4) X5)))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A3 A4)))) (W2 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A1 A2)))) (W3 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A4 A5)))) (W4 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A2 A3))))) (SETQ A1 NIL A3 NIL A4 NIL A5 NIL) (GC) (LIST (WEAK-ALIST-CONTENTS W2) (WEAK-ALIST-CONTENTS W4) (WEAK-ALIST-CONTENTS W1) (WEAK-ALIST-CONTENTS W3))))
EQUAL-OK: (NIL (((X2) X3)) (((X3) X4)) (((X4) X5)))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A3 A4)))) (W2 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A1 A2)))) (W3 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A4 A5)))) (W4 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A2 A3))))) (SETQ A1 NIL A2 NIL A4 NIL A5 NIL) (GC) (LIST (WEAK-ALIST-CONTENTS W2) (WEAK-ALIST-CONTENTS W4) (WEAK-ALIST-CONTENTS W1) (WEAK-ALIST-CONTENTS W3))))
EQUAL-OK: (NIL NIL (((X3) X4)) (((X4) X5)))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A3 A4)))) (W2 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A1 A2)))) (W3 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A4 A5)))) (W4 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A2 A3))))) (SETQ A1 NIL A2 NIL A3 NIL A5 NIL) (GC) (LIST (WEAK-ALIST-CONTENTS W2) (WEAK-ALIST-CONTENTS W4) (WEAK-ALIST-CONTENTS W1) (WEAK-ALIST-CONTENTS W3))))
EQUAL-OK: (NIL NIL NIL (((X4) X5)))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A3 A4)))) (W2 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A1 A2)))) (W3 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A4 A5)))) (W4 (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A2 A3))))) (SETQ A1 NIL A2 NIL A3 NIL A4 NIL) (GC) (LIST (WEAK-ALIST-CONTENTS W2) (WEAK-ALIST-CONTENTS W4) (WEAK-ALIST-CONTENTS W1) (WEAK-ALIST-CONTENTS W3))))
EQUAL-OK: (NIL NIL NIL NIL)
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A B))))) (SETF (WEAK-ALIST-VALUE A W) C) (WEAK-ALIST-CONTENTS W)))
EQUAL-OK: (((X) Z))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A B))))) (SETF (WEAK-ALIST-VALUE A W) C) (GC) (WEAK-ALIST-CONTENTS W)))
EQUAL-OK: (((X) Z))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A B))))) (GC) (SETF (WEAK-ALIST-VALUE A W) C) (WEAK-ALIST-CONTENTS W)))
EQUAL-OK: (((X) Z))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A B))))) (SETQ A (LIST 'X2)) (SETF (WEAK-ALIST-VALUE A W) C) (GC) (WEAK-ALIST-CONTENTS W)))
EQUAL-OK: (((X2) Z))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS A B))))) (SETQ A (LIST 'X2)) (GC) (SETF (WEAK-ALIST-VALUE A W) C) (WEAK-ALIST-CONTENTS W)))
EQUAL-OK: (((X2) Z))
(LET ((KA (LIST 'KX)) (VA (LIST 'VX)) (KB (LIST 'KY)) (VB (LIST 'VY)) (KC (LIST 'KZ)) (VC (LIST 'VZ))) (LET ((W (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KA VC) (CONS KC VC))))) (LIST (WEAK-ALIST-ASSOC KA W) (WEAK-ALIST-ASSOC KB W) (WEAK-ALIST-ASSOC KC W) (WEAK-ALIST-ASSOC VA W) (WEAK-ALIST-ASSOC VB W) (WEAK-ALIST-ASSOC VC W))))
EQUAL-OK: (((KX) VX) ((KY) VY) ((KZ) VZ) NIL NIL NIL)
(LET ((KA (LIST 'KX)) (VA (LIST 'VX)) (KB (LIST 'KY)) (VB (LIST 'VY)) (KC (LIST 'KZ)) (VC (LIST 'VZ))) (LET ((W (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KA VC) (CONS KC VC))))) (LIST (WEAK-ALIST-RASSOC KA W) (WEAK-ALIST-RASSOC KB W) (WEAK-ALIST-RASSOC KC W) (WEAK-ALIST-RASSOC VA W) (WEAK-ALIST-RASSOC VB W) (WEAK-ALIST-RASSOC VC W))))
EQUAL-OK: (NIL NIL NIL ((KX) VX) ((KY) VY) ((KX) VZ))
(LET ((KA (LIST 'KX)) (VA (LIST 'VX)) (KB (LIST 'KY)) (VB (LIST 'VY)) (KC (LIST 'KZ)) (VC (LIST 'VZ))) (LET ((W (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KA VC) (CONS KC VC))))) (LIST (WEAK-ALIST-VALUE KA W) (WEAK-ALIST-VALUE KB W) (WEAK-ALIST-VALUE KC W) (WEAK-ALIST-VALUE VA W) (WEAK-ALIST-VALUE VB W) (WEAK-ALIST-VALUE VC W))))
EQUAL-OK: ((VX) (VY) (VZ) NIL NIL NIL)
(LET ((KA (LIST 'KX)) (VA (LIST 'VX)) (KB (LIST 'KY)) (VB (LIST 'VY)) (KC (LIST 'KZ)) (VC (LIST 'VZ))) (LET ((W (MAKE-WEAK-ALIST :TYPE :VALUE :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KA VC) (CONS KC VC))))) (SETQ VA NIL) (GC) (LIST (WEAK-ALIST-ASSOC KA W) (WEAK-ALIST-ASSOC KB W) (WEAK-ALIST-ASSOC KC W) (WEAK-ALIST-ASSOC VB W) (WEAK-ALIST-ASSOC VC W))))
EQUAL-OK: (((KX) VZ) ((KY) VY) ((KZ) VZ) NIL NIL)
(LET ((KA (LIST 'KX)) (VA (LIST 'VX)) (KB (LIST 'KY)) (VB (LIST 'VY)) (KC (LIST 'KZ)) (VC (LIST 'VZ))) (LET ((W (MAKE-WEAK-ALIST :TYPE :VALUE :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KA VC) (CONS KC VC))))) (SETQ VA NIL) (GC) (LIST (WEAK-ALIST-RASSOC KA W) (WEAK-ALIST-RASSOC KB W) (WEAK-ALIST-RASSOC KC W) (WEAK-ALIST-RASSOC VB W) (WEAK-ALIST-RASSOC VC W))))
EQUAL-OK: (NIL NIL NIL ((KY) VY) ((KX) VZ))
(LET ((KA (LIST 'KX)) (VA (LIST 'VX)) (KB (LIST 'KY)) (VB (LIST 'VY)) (KC (LIST 'KZ)) (VC (LIST 'VZ))) (LET ((W (MAKE-WEAK-ALIST :TYPE :VALUE :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KA VC) (CONS KC VC))))) (SETQ VA NIL) (GC) (LIST (WEAK-ALIST-VALUE KA W) (WEAK-ALIST-VALUE KB W) (WEAK-ALIST-VALUE KC W) (WEAK-ALIST-VALUE VB W) (WEAK-ALIST-VALUE VC W))))
EQUAL-OK: ((VZ) (VY) (VZ) NIL NIL)
(LET ((KA (LIST 'X)) (VA (LIST '|x|)) (KB (LIST 'Y)) (VB (LIST '|y|)) (KC (LIST 'Z)) (VC (LIST '|z|))) (LET ((W (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KA VC) (CONS KC VC))))) (LIST (WEAK-ALIST-ASSOC (CAR KA) W :TEST #'STRING-EQUAL :KEY #'CAR) (WEAK-ALIST-ASSOC (CAR KB) W :TEST #'STRING-EQUAL :KEY #'CAR) (WEAK-ALIST-ASSOC (CAR KC) W :TEST #'STRING-EQUAL :KEY #'CAR) (WEAK-ALIST-ASSOC (CAR VA) W :TEST #'STRING-EQUAL :KEY #'CAR) (WEAK-ALIST-ASSOC (CAR VB) W :TEST #'STRING-EQUAL :KEY #'CAR) (WEAK-ALIST-ASSOC (CAR VC) W :TEST #'STRING-EQUAL :KEY #'CAR))))
EQUAL-OK: (((X) |x|) ((Y) |y|) ((Z) |z|) ((X) |x|) ((Y) |y|) ((Z) |z|))
(LET ((KA (LIST 'X)) (VA (LIST '|x|)) (KB (LIST 'Y)) (VB (LIST '|y|)) (KC (LIST 'Z)) (VC (LIST '|z|))) (LET ((W (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KA VC) (CONS KC VC))))) (LIST (WEAK-ALIST-RASSOC (CAR KA) W :TEST #'STRING-EQUAL :KEY #'CAR) (WEAK-ALIST-RASSOC (CAR KB) W :TEST #'STRING-EQUAL :KEY #'CAR) (WEAK-ALIST-RASSOC (CAR KC) W :TEST #'STRING-EQUAL :KEY #'CAR) (WEAK-ALIST-RASSOC (CAR VA) W :TEST #'STRING-EQUAL :KEY #'CAR) (WEAK-ALIST-RASSOC (CAR VB) W :TEST #'STRING-EQUAL :KEY #'CAR) (WEAK-ALIST-RASSOC (CAR VC) W :TEST #'STRING-EQUAL :KEY #'CAR))))
EQUAL-OK: (((X) |x|) ((Y) |y|) ((X) |z|) ((X) |x|) ((Y) |y|) ((X) |z|))
(LET ((KA (LIST 'X)) (VA (LIST '|x|)) (KB (LIST 'Y)) (VB (LIST '|y|)) (KC (LIST 'Z)) (VC (LIST '|z|))) (LET ((W (MAKE-WEAK-ALIST :INITIAL-CONTENTS (LIST (CONS KA VA) (CONS KB VB) (CONS KA VC) (CONS KC VC))))) (LIST (WEAK-ALIST-VALUE KA W :TEST #'(LAMBDA (U V) (STRING-EQUAL (CAR U) (CAR V)))) (WEAK-ALIST-VALUE KB W :TEST #'(LAMBDA (U V) (STRING-EQUAL (CAR U) (CAR V)))) (WEAK-ALIST-VALUE KC W :TEST #'(LAMBDA (U V) (STRING-EQUAL (CAR U) (CAR V)))) (WEAK-ALIST-VALUE VA W :TEST #'(LAMBDA (U V) (STRING-EQUAL (CAR U) (CAR V)))) (WEAK-ALIST-VALUE VB W :TEST #'(LAMBDA (U V) (STRING-EQUAL (CAR U) (CAR V)))) (WEAK-ALIST-VALUE VC W :TEST #'(LAMBDA (U V) (STRING-EQUAL (CAR U) (CAR V)))))))
EQUAL-OK: ((|x|) (|y|) (|z|) (|x|) (|y|) (|z|))
(LET* ((LI 'NIL) (W (LET ((ALI 'NIL)) (LOOP :FOR I :FROM 0 :TO 1000 :FOR STRING = (FORMAT NIL "~r" I) :DO (PUSH STRING LI) (PUSH (CONS STRING I) ALI)) (SETQ LI (NREVERSE LI)) (SETQ ALI (NREVERSE ALI)) (MAKE-WEAK-ALIST :INITIAL-CONTENTS ALI)))) (LIST (PROGN (GC) (LENGTH (WEAK-ALIST-CONTENTS W))) (PROGN (SETQ LI NIL) (GC) (LENGTH (WEAK-ALIST-CONTENTS W)))))
EQUAL-OK: (1001 0)
RUN-TEST: finished "weak" (0 errors out of 120 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakhash.tst" @1>
(DEFUN WEAK-HT-FILL-INITIALLY (TAB) (SETF (GETHASH (COPY-SEQ "foo") TAB) 1) (SETF (GETHASH 1 TAB) (COPY-SEQ "bar")) (SETF (GETHASH (COPY-SEQ "zoo") TAB) (COPY-SEQ "zot")))
EQL-OK: WEAK-HT-FILL-INITIALLY
(LET ((TAB (MAKE-HASH-TABLE :TEST 'EQUAL :WEAK :KEY))) (WEAK-HT-FILL-INITIALLY TAB) (GC) (LIST (GETHASH "foo" TAB) (GETHASH 1 TAB) (GETHASH "zoo" TAB)))
EQUAL-OK: (NIL "bar" NIL)
(LET ((TAB (MAKE-HASH-TABLE :TEST 'EQ :WEAK :KEY))) (LET ((A (LIST 'X))) (LET ((B (LIST 'Y))) (SETF (GETHASH A TAB) 'XXX) (SETF (GETHASH B TAB) (CONS 'YYY B))) (GC) (LIST (HASH-TABLE-COUNT TAB) (GETHASH A TAB) (LET ((L NIL)) (MAPHASH #'(LAMBDA (K V) (PUSH K L)) TAB) L))))
EQUAL-OK: (1 XXX ((X)))
(PROGN (DEFUN MAKE-FREAK-MAPPING (A B) (LET ((TAB (MAKE-HASH-TABLE :TEST 'EQ :WEAK :KEY))) (SETF (GETHASH A TAB) B) TAB)) (DEFUN FREAK-MAPPING-PAIR (TAB) (LET (A B C) (MAPHASH #'(LAMBDA (K V) (SETQ A K B V C T)) TAB) (VALUES A B C))) (DEFUN FREAK-MAPPING-VALUE (TAB) (BLOCK NIL (MAPHASH #'(LAMBDA (K V) (RETURN-FROM NIL V)) TAB) NIL)) (DEFUN (SETF FREAK-MAPPING-VALUE) (NEW-VALUE TAB) (BLOCK NIL (MAPHASH #'(LAMBDA (K V) (SETF (GETHASH K TAB) NEW-VALUE) (RETURN-FROM NIL)) TAB)) NEW-VALUE) T)
EQL-OK: T
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-FREAK-MAPPING A B))) (GC) (LIST (MULTIPLE-VALUE-LIST (FREAK-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (FREAK-MAPPING-VALUE W)))))
EQUAL-OK: (((X) (Y) T) ((Y)))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-FREAK-MAPPING A B))) (SETQ B NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (FREAK-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (FREAK-MAPPING-VALUE W)))))
EQUAL-OK: (((X) (Y) T) ((Y)))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-FREAK-MAPPING A B))) (SETQ A NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (FREAK-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (FREAK-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A (LIST 'X)) (B (LIST 'Y))) (LET ((W (MAKE-FREAK-MAPPING A B))) (SETQ A NIL B NIL) (GC) (LIST (MULTIPLE-VALUE-LIST (FREAK-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (FREAK-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-FREAK-MAPPING A3 A4)) (W2 (MAKE-FREAK-MAPPING A1 A2)) (W3 (MAKE-FREAK-MAPPING A4 A5)) (W4 (MAKE-FREAK-MAPPING A2 A3))) (SETQ A2 NIL A3 NIL A4 NIL A5 NIL) (GC) (LIST (FREAK-MAPPING-VALUE W2) (FREAK-MAPPING-VALUE W4) (FREAK-MAPPING-VALUE W1) (FREAK-MAPPING-VALUE W3))))
EQUAL-OK: ((X2) (X3) (X4) (X5))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-FREAK-MAPPING A3 A4)) (W2 (MAKE-FREAK-MAPPING A1 A2)) (W3 (MAKE-FREAK-MAPPING A4 A5)) (W4 (MAKE-FREAK-MAPPING A2 A3))) (SETQ A1 NIL A3 NIL A4 NIL A5 NIL) (GC) (LIST (FREAK-MAPPING-VALUE W2) (FREAK-MAPPING-VALUE W4) (FREAK-MAPPING-VALUE W1) (FREAK-MAPPING-VALUE W3))))
EQUAL-OK: (NIL (X3) (X4) (X5))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-FREAK-MAPPING A3 A4)) (W2 (MAKE-FREAK-MAPPING A1 A2)) (W3 (MAKE-FREAK-MAPPING A4 A5)) (W4 (MAKE-FREAK-MAPPING A2 A3))) (SETQ A1 NIL A2 NIL A4 NIL A5 NIL) (GC) (LIST (FREAK-MAPPING-VALUE W2) (FREAK-MAPPING-VALUE W4) (FREAK-MAPPING-VALUE W1) (FREAK-MAPPING-VALUE W3))))
EQUAL-OK: (NIL NIL (X4) (X5))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-FREAK-MAPPING A3 A4)) (W2 (MAKE-FREAK-MAPPING A1 A2)) (W3 (MAKE-FREAK-MAPPING A4 A5)) (W4 (MAKE-FREAK-MAPPING A2 A3))) (SETQ A1 NIL A2 NIL A3 NIL A5 NIL) (GC) (LIST (FREAK-MAPPING-VALUE W2) (FREAK-MAPPING-VALUE W4) (FREAK-MAPPING-VALUE W1) (FREAK-MAPPING-VALUE W3))))
EQUAL-OK: (NIL NIL NIL (X5))
(LET ((A1 (LIST 'X1)) (A2 (LIST 'X2)) (A3 (LIST 'X3)) (A4 (LIST 'X4)) (A5 (LIST 'X5))) (LET ((W1 (MAKE-FREAK-MAPPING A3 A4)) (W2 (MAKE-FREAK-MAPPING A1 A2)) (W3 (MAKE-FREAK-MAPPING A4 A5)) (W4 (MAKE-FREAK-MAPPING A2 A3))) (SETQ A1 NIL A2 NIL A3 NIL A4 NIL) (GC) (LIST (FREAK-MAPPING-VALUE W2) (FREAK-MAPPING-VALUE W4) (FREAK-MAPPING-VALUE W1) (FREAK-MAPPING-VALUE W3))))
EQUAL-OK: (NIL NIL NIL NIL)
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-FREAK-MAPPING A B))) (SETF (FREAK-MAPPING-VALUE W) C) (LIST (MULTIPLE-VALUE-LIST (FREAK-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (FREAK-MAPPING-VALUE W)))))
EQUAL-OK: (((X) (Z) T) ((Z)))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-FREAK-MAPPING A B))) (SETF (FREAK-MAPPING-VALUE W) C) (GC) (LIST (MULTIPLE-VALUE-LIST (FREAK-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (FREAK-MAPPING-VALUE W)))))
EQUAL-OK: (((X) (Z) T) ((Z)))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-FREAK-MAPPING A B))) (GC) (SETF (FREAK-MAPPING-VALUE W) C) (LIST (MULTIPLE-VALUE-LIST (FREAK-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (FREAK-MAPPING-VALUE W)))))
EQUAL-OK: (((X) (Z) T) ((Z)))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-FREAK-MAPPING A B))) (SETQ A NIL) (SETF (FREAK-MAPPING-VALUE W) C) (GC) (LIST (MULTIPLE-VALUE-LIST (FREAK-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (FREAK-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(LET ((A (LIST 'X)) (B (LIST 'Y)) (C (LIST 'Z))) (LET ((W (MAKE-FREAK-MAPPING A B))) (SETQ A NIL) (GC) (SETF (FREAK-MAPPING-VALUE W) C) (LIST (MULTIPLE-VALUE-LIST (FREAK-MAPPING-PAIR W)) (MULTIPLE-VALUE-LIST (FREAK-MAPPING-VALUE W)))))
EQUAL-OK: ((NIL NIL NIL) (NIL))
(PROGN (DEFUN TEST-WEAK-MAPPING-CHAIN (N) (LET (WM0) (LET ((SYM (MAKE-ARRAY N))) (DOTIMES (I N) (SETF (AREF SYM I) (MAKE-SYMBOL (PRIN1-TO-STRING I)))) (LET ((WM (MAKE-ARRAY N))) (DOTIMES (I N) (SETF (AREF WM I) (MAKE-FREAK-MAPPING 'A 'B))) (SETQ WM0 (AREF WM 0)) (DO ((I 1 (1+ I))) ((>= I N)) (SETF (GETHASH (AREF SYM (- I 1)) (AREF WM (- I 1))) (AREF WM I)))) (TIME (GC)) (DO ((I 0 (1+ I)) (W WM0 (GETHASH (AREF SYM I) W))) ((>= I N))) (SETQ SYM NIL) (TIME (GC)) (GETHASH 'A WM0)))) (TEST-WEAK-MAPPING-CHAIN 10000))
Real time: 0.015277 sec.
Run time: 0.015263 sec.
Space: 16 Bytes
GC: 1, GC time: 0.015243 sec.
Real time: 0.010646 sec.
Run time: 0.010634 sec.
Space: 16 Bytes
GC: 1, GC time: 0.010617 sec.
EQL-OK: B
(PROGN (DEFUN TEST-WEAK-MAPPING-CHAIN-REVERSE (N) (LET (WM0) (LET ((SYM (MAKE-ARRAY N))) (DOTIMES (I N) (SETF (AREF SYM I) (MAKE-SYMBOL (PRIN1-TO-STRING I)))) (LET ((WM (MAKE-ARRAY N))) (DOTIMES (I N) (SETF (AREF WM (- N 1 I)) (MAKE-FREAK-MAPPING 'A 'B))) (SETQ WM0 (AREF WM 0)) (DO ((I 1 (1+ I))) ((>= I N)) (SETF (GETHASH (AREF SYM (- I 1)) (AREF WM (- I 1))) (AREF WM I)))) (TIME (GC)) (DO ((I 0 (1+ I)) (W WM0 (GETHASH (AREF SYM I) W))) ((>= I N))) (SETQ SYM NIL) (TIME (GC)) (GETHASH 'A WM0)))) (TEST-WEAK-MAPPING-CHAIN-REVERSE 10000))
Real time: 0.013549 sec.
Run time: 0.013536 sec.
Space: 16 Bytes
GC: 1, GC time: 0.013521 sec.
Real time: 0.009933 sec.
Run time: 0.009921 sec.
Space: 16 Bytes
GC: 1, GC time: 0.009907 sec.
EQL-OK: B
(LET ((TAB (MAKE-HASH-TABLE :TEST 'EQ :WEAK :VALUE))) (SETF (GETHASH 'FOO TAB) 1) (SETF (GETHASH 1 TAB) (COPY-SEQ "bar")) (SETF (GETHASH 'ZOO TAB) (COPY-SEQ "zot")) (GC) (LIST (GETHASH 'FOO TAB) (GETHASH 1 TAB) (GETHASH 'ZOO TAB)))
EQUAL-OK: (1 NIL NIL)
(LET ((TAB (MAKE-HASH-TABLE :TEST 'EQUAL :WEAK :VALUE))) (WEAK-HT-FILL-INITIALLY TAB) (GC) (LIST (GETHASH "foo" TAB) (GETHASH 1 TAB) (GETHASH "zoo" TAB)))
EQUAL-OK: (1 NIL NIL)
(LET ((TAB (MAKE-HASH-TABLE :TEST 'EQ :WEAK :VALUE))) (LET ((A (LIST 'X))) (LET ((B (LIST 'Y))) (SETF (GETHASH 'XXX TAB) A) (SETF (GETHASH (CONS 'YYY B) TAB) B)) (GC) (LIST (HASH-TABLE-COUNT TAB) (EQ (GETHASH 'XXX TAB) A) (LET ((L NIL)) (MAPHASH #'(LAMBDA (K V) (PUSH V L)) TAB) L))))
EQUAL-OK: (1 T ((X)))
(LET ((TAB (MAKE-HASH-TABLE :TEST 'EQUAL :WEAK :KEY-AND-VALUE))) (WEAK-HT-FILL-INITIALLY TAB) (GC) (LIST (GETHASH "foo" TAB) (GETHASH 1 TAB) (GETHASH "zoo" TAB)))
EQUAL-OK: (NIL NIL NIL)
(LET ((TAB (MAKE-HASH-TABLE :TEST 'EQUAL :WEAK :KEY-OR-VALUE))) (WEAK-HT-FILL-INITIALLY TAB) (GC) (LIST (GETHASH "foo" TAB) (GETHASH 1 TAB) (GETHASH "zoo" TAB)))
EQUAL-OK: (1 "bar" NIL)
(SYMBOLS-CLEANUP '(WEAK-HT-FILL-INITIALLY MAKE-FREAK-MAPPING FREAK-MAPPING-PAIR FREAK-MAPPING-VALUE TEST-WEAK-MAPPING-CHAIN TEST-WEAK-MAPPING-CHAIN-REVERSE))
EQL-OK: NIL
RUN-TEST: finished "weakhash" (0 errors out of 26 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakhash2.tst" @1>
(HASH-TABLE-WEAK-P (PROGN (SETQ TAB (MAKE-HASH-TABLE :WEAK :KEY :TEST 'EQUAL :INITIAL-CONTENTS '((1 . 2) ("foo" . "bar")))) TAB))
EQL-OK: :KEY
(GETHASH 1 TAB)
EQL-OK: 2
(GETHASH "foo" TAB)
EQUAL-OK: "bar"
(GETHASH "zot" TAB)
EQL-OK: NIL
(GETHASH "bar" TAB)
EQL-OK: NIL
(PROGN (GC) T)
EQL-OK: T
(GETHASH 1 TAB)
EQL-OK: 2
(GETHASH "foo" TAB)
EQL-OK: NIL
(GETHASH "zot" TAB)
EQL-OK: NIL
(GETHASH "bar" TAB)
EQL-OK: NIL
(SETF (HASH-TABLE-WEAK-P TAB) NIL)
EQL-OK: NIL
(GETHASH 1 TAB)
EQL-OK: 2
(GETHASH "foo" TAB)
EQL-OK: NIL
(SETF (GETHASH "foo" TAB) "bar")
EQUAL-OK: "bar"
(GETHASH "foo" TAB)
EQUAL-OK: "bar"
(PROGN (GC) T)
EQL-OK: T
(GETHASH "foo" TAB)
EQUAL-OK: "bar"
(SETF (HASH-TABLE-WEAK-P TAB) :KEY)
EQL-OK: :KEY
(PROGN (GC) T)
EQL-OK: T
(GETHASH "foo" TAB)
EQL-OK: NIL
(SETF (HASH-TABLE-WEAK-P TAB) :VALUE)
EQL-OK: :VALUE
(SETF (GETHASH "foo" TAB) 1)
EQL-OK: 1
(SETF (GETHASH 1 TAB) "bar")
EQUAL-OK: "bar"
(SETF (GETHASH "zoo" TAB) "zot")
EQUAL-OK: "zot"
(PROGN (GC) T)
EQL-OK: T
(GETHASH "foo" TAB)
EQL-OK: 1
(GETHASH 1 TAB)
EQL-OK: NIL
(GETHASH "zoo" TAB)
EQL-OK: NIL
(SETF (HASH-TABLE-WEAK-P TAB) :KEY-AND-VALUE)
EQL-OK: :KEY-AND-VALUE
(SETF (GETHASH "foo" TAB) 1)
EQL-OK: 1
(SETF (GETHASH 1 TAB) "bar")
EQUAL-OK: "bar"
(SETF (GETHASH "zoo" TAB) "zot")
EQUAL-OK: "zot"
(PROGN (GC) T)
EQL-OK: T
(GETHASH "foo" TAB)
EQL-OK: NIL
(GETHASH 1 TAB)
EQL-OK: NIL
(GETHASH "zoo" TAB)
EQL-OK: NIL
(SETF (HASH-TABLE-WEAK-P TAB) :KEY-OR-VALUE)
EQL-OK: :KEY-OR-VALUE
(SETF (GETHASH "foo" TAB) 1)
EQL-OK: 1
(SETF (GETHASH 1 TAB) "bar")
EQUAL-OK: "bar"
(SETF (GETHASH "zoo" TAB) "zot")
EQUAL-OK: "zot"
(PROGN (GC) T)
EQL-OK: T
(GETHASH "foo" TAB)
EQL-OK: 1
(GETHASH 1 TAB)
EQUAL-OK: "bar"
(GETHASH "zoo" TAB)
EQL-OK: NIL
(LET ((HTV (MAKE-HASH-TABLE :TEST 'EQL :WEAK :VALUE)) (HTK (MAKE-HASH-TABLE :TEST 'EQL :WEAK :KEY)) (LI NIL)) (LOOP :FOR I :FROM 0 :TO 1000 :FOR STRING = (FORMAT NIL "~r" I) :DO (PUSH STRING LI) (SETF (GETHASH I HTV) STRING (GETHASH STRING HTK) I)) (LIST (LENGTH LI) (CONS (HASH-TABLE-COUNT HTV) (HASH-TABLE-COUNT HTK)) (PROGN (GC) (CONS (HASH-TABLE-COUNT HTV) (HASH-TABLE-COUNT HTK))) (PROGN (SETQ LI NIL) (GC) (CONS (HASH-TABLE-COUNT HTV) (HASH-TABLE-COUNT HTK)))))
EQUAL-OK: (1001 (1001 . 1001) (1001 . 1001) (0 . 0))
(FLET ((HT_KVTABLE (HT) (IF (INTEGERP (SYSTEM::%RECORD-REF HT 1)) (SYSTEM::%RECORD-REF HT 2) (SYSTEM::%RECORD-REF HT 1))) (WHAL_ITABLE (KVT) (SYSTEM::%RECORD-REF KVT 1))) (LET* ((HT (MAKE-HASH-TABLE :TEST 'STABLEHASH-EQ :WEAK :KEY)) (KVT (HT_KVTABLE HT))) (ASSERT (SIMPLE-VECTOR-P (WHAL_ITABLE KVT))) (GC) (GC) (AND (EQ (HT_KVTABLE HT) KVT) (SIMPLE-VECTOR-P (WHAL_ITABLE KVT)))))
EQL-OK: T
(PROGN (SYMBOL-CLEANUP 'TAB))
EQL-OK: T
RUN-TEST: finished "weakhash2" (0 errors out of 47 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"bind.tst" @1>
(LET ((X 5)) (LET ((X (1+ X))) (DECLARE (SPECIAL X)) X))
EQL-OK: 6
(LET ((X 5)) (LET* ((X (1+ X))) (DECLARE (SPECIAL X)) X))
EQL-OK: 6
(LET ((X 5)) (MULTIPLE-VALUE-BIND (X) (1+ X) (DECLARE (SPECIAL X)) X))
EQL-OK: 6
(LET ((X 5)) ((LAMBDA (X) (DECLARE (SPECIAL X)) X) (1+ X)))
EQL-OK: 6
(BLOCK FOO (HANDLER-BIND ((UNBOUND-VARIABLE (HANDLER-RETURN FOO 'GOOD))) (LET ((X (1+ X))) (DECLARE (SPECIAL X)) X)))
[SIMPLE-UNBOUND-VARIABLE]: LET: variable X has no value

EQL-OK: GOOD
(BLOCK FOO (HANDLER-BIND ((UNBOUND-VARIABLE (HANDLER-RETURN FOO 'GOOD))) (LET* ((X (1+ X))) (DECLARE (SPECIAL X)) X)))
[SIMPLE-UNBOUND-VARIABLE]: LET*: variable X has no value

EQL-OK: GOOD
(BLOCK FOO (HANDLER-BIND ((UNBOUND-VARIABLE (HANDLER-RETURN FOO 'GOOD))) (MULTIPLE-VALUE-BIND (X) (1+ X) (DECLARE (SPECIAL X)) X)))
[SIMPLE-UNBOUND-VARIABLE]: MULTIPLE-VALUE-BIND: variable X has no value

EQL-OK: GOOD
(BLOCK FOO (HANDLER-BIND ((UNBOUND-VARIABLE (HANDLER-RETURN FOO 'GOOD))) ((LAMBDA (X) (DECLARE (SPECIAL X)) X) (1+ X))))
[SIMPLE-UNBOUND-VARIABLE]: :LAMBDA: variable X has no value

EQL-OK: GOOD
(LET ((X 5)) (LET ((Y (1+ X))) (DECLARE (SPECIAL X)) Y))
EQL-OK: 6
(LET ((X 5)) (LET* ((Y (1+ X))) (DECLARE (SPECIAL X)) Y))
EQL-OK: 6
(LET ((X 5)) (MULTIPLE-VALUE-BIND (Y) (1+ X) (DECLARE (SPECIAL X)) Y))
EQL-OK: 6
(LET ((X 5)) ((LAMBDA (Y) (DECLARE (SPECIAL X)) Y) (1+ X)))
EQL-OK: 6
(LET ((X 5)) (LET ((X (1+ X))) X))
EQL-OK: 6
(LET ((X 5)) (LET* ((X (1+ X))) X))
EQL-OK: 6
(LET ((X 5)) (MULTIPLE-VALUE-BIND (X) (1+ X) X))
EQL-OK: 6
(LET ((X 5)) ((LAMBDA (X) X) (1+ X)))
EQL-OK: 6
(LET ((X 5)) (PROGV '(X) '(20) (LET ((X (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) Z)))
EQL-OK: 6
(LET ((X 5)) (PROGV '(X) '(20) (LET* ((X (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) Z)))
EQL-OK: 7
(LET ((X 5)) (PROGV '(X) '(20) (MULTIPLE-VALUE-BIND (X Z) (VALUES (1+ X) (1+ X)) (DECLARE (SPECIAL X)) Z)))
EQL-OK: 6
(LET ((X 5)) (PROGV '(X) '(20) ((LAMBDA (&OPTIONAL (X (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) Z))))
EQL-OK: 7
(LET ((X 5)) (PROGV '(X Y) '(20 120) (LET ((X (1+ X)) (Y (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) (LIST Z (LOCALLY (DECLARE (SPECIAL Y)) Y) X Y))))
EQUAL-OK: (6 120 6 6)
(LET ((X 5)) (PROGV '(X Y) '(20 120) (LET* ((X (1+ X)) (Y (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) (LIST Z (LOCALLY (DECLARE (SPECIAL Y)) Y) X Y))))
EQUAL-OK: (7 120 6 7)
(LET ((X 5)) (PROGV '(X Y) '(20 120) (MULTIPLE-VALUE-BIND (X Y Z) (VALUES (1+ X) (1+ X) (1+ X)) (DECLARE (SPECIAL X)) (LIST Z (LOCALLY (DECLARE (SPECIAL Y)) Y) X Y))))
EQUAL-OK: (6 120 6 6)
(LET ((X 5)) (PROGV '(X Y) '(20 120) ((LAMBDA (&OPTIONAL (X (1+ X)) (Y (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) (LIST Z (LOCALLY (DECLARE (SPECIAL Y)) Y) X Y)))))
EQUAL-OK: (7 120 6 7)
(LET ((X 5)) (PROGV '(X) '(20) (LET ((Y (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) Z)))
EQL-OK: 6
(LET ((X 5)) (PROGV '(X) '(20) (LET* ((Y (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) Z)))
EQL-OK: 6
(LET ((X 5)) (PROGV '(X) '(20) (MULTIPLE-VALUE-BIND (Y Z) (VALUES (1+ X) (1+ X)) (DECLARE (SPECIAL X)) Z)))
EQL-OK: 6
(LET ((X 5)) (PROGV '(X) '(20) ((LAMBDA (&OPTIONAL (Y (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) Z))))
EQL-OK: 6
(PROGN (DEFPARAMETER *GLOBAL-VAR-FOR-BIND.TST* 123) (LET ((*GLOBAL-VAR-FOR-BIND.TST* 5)) (LIST (LET ((*GLOBAL-VAR-FOR-BIND.TST* (1+ *GLOBAL-VAR-FOR-BIND.TST*))) (DECLARE (SPECIAL *GLOBAL-VAR-FOR-BIND.TST*)) *GLOBAL-VAR-FOR-BIND.TST*) *GLOBAL-VAR-FOR-BIND.TST*)))
EQUAL-OK: (6 5)
(PROGN (DEFPARAMETER *GLOBAL-VAR-FOR-BIND.TST* 123) (LET ((*GLOBAL-VAR-FOR-BIND.TST* 5)) (LIST (LET* ((*GLOBAL-VAR-FOR-BIND.TST* (1+ *GLOBAL-VAR-FOR-BIND.TST*))) (DECLARE (SPECIAL *GLOBAL-VAR-FOR-BIND.TST*)) *GLOBAL-VAR-FOR-BIND.TST*) *GLOBAL-VAR-FOR-BIND.TST*)))
EQUAL-OK: (6 5)
(PROGN (DEFPARAMETER *GLOBAL-VAR-FOR-BIND.TST* 123) (LET ((*GLOBAL-VAR-FOR-BIND.TST* 5)) (LIST (MULTIPLE-VALUE-BIND (*GLOBAL-VAR-FOR-BIND.TST*) (1+ *GLOBAL-VAR-FOR-BIND.TST*) (DECLARE (SPECIAL *GLOBAL-VAR-FOR-BIND.TST*)) *GLOBAL-VAR-FOR-BIND.TST*) *GLOBAL-VAR-FOR-BIND.TST*)))
EQUAL-OK: (6 5)
(PROGN (DEFPARAMETER *GLOBAL-VAR-FOR-BIND.TST* 123) (LET ((*GLOBAL-VAR-FOR-BIND.TST* 5)) (LIST ((LAMBDA (*GLOBAL-VAR-FOR-BIND.TST*) (DECLARE (SPECIAL *GLOBAL-VAR-FOR-BIND.TST*)) *GLOBAL-VAR-FOR-BIND.TST*) (1+ *GLOBAL-VAR-FOR-BIND.TST*)) *GLOBAL-VAR-FOR-BIND.TST*)))
EQUAL-OK: (6 5)
(PROGN (DEFPARAMETER *GLOBAL-VAR-FOR-BIND.TST* 123) (LET ((*GLOBAL-VAR-FOR-BIND.TST* 5)) (LIST (LET ((*GLOBAL-VAR-FOR-BIND.TST* (1+ *GLOBAL-VAR-FOR-BIND.TST*))) *GLOBAL-VAR-FOR-BIND.TST*) *GLOBAL-VAR-FOR-BIND.TST*)))
EQUAL-OK: (6 5)
(PROGN (DEFPARAMETER *GLOBAL-VAR-FOR-BIND.TST* 123) (LET ((*GLOBAL-VAR-FOR-BIND.TST* 5)) (LIST (LET* ((*GLOBAL-VAR-FOR-BIND.TST* (1+ *GLOBAL-VAR-FOR-BIND.TST*))) *GLOBAL-VAR-FOR-BIND.TST*) *GLOBAL-VAR-FOR-BIND.TST*)))
EQUAL-OK: (6 5)
(PROGN (DEFPARAMETER *GLOBAL-VAR-FOR-BIND.TST* 123) (LET ((*GLOBAL-VAR-FOR-BIND.TST* 5)) (LIST (MULTIPLE-VALUE-BIND (*GLOBAL-VAR-FOR-BIND.TST*) (1+ *GLOBAL-VAR-FOR-BIND.TST*) *GLOBAL-VAR-FOR-BIND.TST*) *GLOBAL-VAR-FOR-BIND.TST*)))
EQUAL-OK: (6 5)
(PROGN (DEFPARAMETER *GLOBAL-VAR-FOR-BIND.TST* 123) (LET ((*GLOBAL-VAR-FOR-BIND.TST* 5)) (LIST ((LAMBDA (*GLOBAL-VAR-FOR-BIND.TST*) *GLOBAL-VAR-FOR-BIND.TST*) (1+ *GLOBAL-VAR-FOR-BIND.TST*)) *GLOBAL-VAR-FOR-BIND.TST*)))
EQUAL-OK: (6 5)
(EVAL-WHEN (EVAL COMPILE LOAD) (DEFMACRO CHK-TYPE (FORM TYPE) (LET ((OBJ (GENSYM))) `(LET ((,OBJ ,FORM)) (ASSERT (TYPEP ,OBJ ',TYPE)) (THE ,TYPE ,OBJ)))))
EQL-OK: CHK-TYPE
(SYMBOL-MACROLET ((X (LIST 'SYMBOL))) (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@X))) (FOO 'BAR)))
EQL-OK: BAR
(LET ((X 5)) (PROGV '(X) '(20) (SYMBOL-MACROLET ((X (LIST 'SYMBOL))) (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@X))) (FOO 'BAR)))))
EQL-OK: BAR
(LET ((X :GOOD)) (DECLARE (SPECIAL X)) (LET ((X :BAD)) (SYMBOL-MACROLET NIL (DECLARE (SPECIAL X)) X)))
EQL-OK: :GOOD
(LOCALLY (DECLARE (SPECIAL SYMBOL-TYPE)) (SETQ SYMBOL-TYPE (LIST 'SYMBOL)))
EQUAL-OK: (SYMBOL)
(LOCALLY (DECLARE (SPECIAL SYMBOL-TYPE)) (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@SYMBOL-TYPE))) (FOO 'BAR)))
EQL-OK: BAR
(DEFPARAMETER *SYMBOL-TYPE* (LIST 'SYMBOL))
EQL-OK: *SYMBOL-TYPE*
(LET ((*SYMBOL-TYPE* (LIST 'SYMBOL))) (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@*SYMBOL-TYPE*))) (FOO 'BAR)))
EQL-OK: BAR
(PROGV '(X) '((SYMBOL)) (LET ((X (LIST 'SYMBOL))) (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@X))) (FOO 'BAR))))
[SIMPLE-SOURCE-PROGRAM-ERROR]: Invalid access to the value of the lexical variable X from within a MACROLET definition
EQL-OK: ERROR
(PROGV '(X) '((SYMBOL)) (LET ((X (LIST 'SYMBOL))) (DEFUN TESTFN NIL (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@X))) (FOO 'BAR)))) (TESTFN))
[SIMPLE-SOURCE-PROGRAM-ERROR]: Invalid access to the value of the lexical variable X from within a MACROLET definition
EQL-OK: ERROR
(PROGV '(X) '((SYMBOL)) (LET ((X (LIST 'SYMBOL))) (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@X))) (DEFUN TESTFN NIL (FOO 'BAR)))) (TESTFN))
[SIMPLE-SOURCE-PROGRAM-ERROR]: Invalid access to the value of the lexical variable X from within a MACROLET definition
EQL-OK: ERROR
(MACROLET ((X NIL '(LIST 'SYMBOL))) (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@(X)))) (FOO 'BAR)))
EQL-OK: BAR
(DEFUN SYMBOL-TYPE-FN NIL (LIST 'SYMBOL))
EQL-OK: SYMBOL-TYPE-FN
(FLET ((SYMBOL-TYPE-FN NIL (LIST 'SYMBOL))) (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@(SYMBOL-TYPE-FN)))) (FOO 'BAR)))
[SIMPLE-SOURCE-PROGRAM-ERROR]: Invalid access to the local function definition of SYMBOL-TYPE-FN from within a MACROLET definition
EQL-OK: ERROR
(PROGN (FLET ((SYMBOL-TYPE-FN NIL (LIST 'SYMBOL))) (DEFUN TESTFN NIL (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@(SYMBOL-TYPE-FN)))) (FOO 'BAR)))) (TESTFN))
[SIMPLE-SOURCE-PROGRAM-ERROR]: Invalid access to the local function definition of SYMBOL-TYPE-FN from within a MACROLET definition
EQL-OK: ERROR
(PROGN (FLET ((SYMBOL-TYPE-FN NIL (LIST 'SYMBOL))) (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@(SYMBOL-TYPE-FN)))) (DEFUN TESTFN NIL (FOO 'BAR)))) (TESTFN))
[SIMPLE-SOURCE-PROGRAM-ERROR]: Invalid access to the local function definition of SYMBOL-TYPE-FN from within a MACROLET definition
EQL-OK: ERROR
(BLOCK DONE (LET ((X :GOOD)) (DECLARE (SPECIAL X)) (LET ((X :BAD)) (DO* ((I 0 (RETURN-FROM DONE X))) (NIL NIL) (DECLARE (SPECIAL X))))))
EQL-OK: :GOOD
(LET ((X :GOOD)) (DECLARE (SPECIAL X)) (LET ((X :BAD)) (MULTIPLE-VALUE-BIND (A B) (FLOOR 13 4) (DECLARE (SPECIAL X)) (LIST A B X))))
EQUAL-OK: (3 1 :GOOD)
(LET ((X 1)) (DECLARE (SPECIAL X)) (LET ((X 2)) (DEFUN BIND-TEST-FUNCTION-1 (&OPTIONAL (Y X)) (DECLARE (SPECIAL X)) (LIST Y X)) (BIND-TEST-FUNCTION-1)))
EQUAL-OK: (2 1)
(LET ((X 5)) (LET ((X (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) Z))
EQL-OK: 6
(LET ((X 5)) (LET* ((X (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) Z))
EQL-OK: 7
(LET ((X 5)) (MULTIPLE-VALUE-BIND (X Z) (VALUES (1+ X) (1+ X)) (DECLARE (SPECIAL X)) Z))
EQL-OK: 6
(LET ((X 5)) ((LAMBDA (X Z) (DECLARE (SPECIAL X)) Z) (1+ X) (1+ X)))
EQL-OK: 6
(LET ((X 5)) ((LAMBDA (&OPTIONAL X Z) (DECLARE (SPECIAL X)) Z) (1+ X) (1+ X)))
EQL-OK: 6
(LET ((-X- NIL)) (DECLARE (SPECIAL -X-)) (LET ((-F- #'(LAMBDA NIL -X-))) (DECLARE (SPECIAL -F-)) (EVAL `(MACROLET ((%M (-X-) (DECLARE (SPECIAL -F-)) (FUNCALL -F-))) (%M T)))))
EQL-OK: NIL
(LET ((-X- NIL)) (DECLARE (SPECIAL -X-)) (LET ((-F- #'(LAMBDA NIL -X-))) (DECLARE (SPECIAL -F-)) (MACROLET ((%M (-X-) '(FUNCALL -F-))) (DECLARE (SPECIAL -F-)) (%M T))))
EQL-OK: NIL
(LET ((-X- NIL)) (DECLARE (SPECIAL -X-)) (LET ((-F- #'(LAMBDA NIL -X-))) (DECLARE (SPECIAL -F-)) (EVAL `(MACROLET ((%M (-X-) (DECLARE (SPECIAL -F- -X-)) (FUNCALL -F-))) (%M T)))))
EQL-OK: T
(LET ((-X- NIL)) (DECLARE (SPECIAL -X-)) (LET ((-F- #'(LAMBDA NIL -X-))) (DECLARE (SPECIAL -F-)) (MACROLET ((%M (-X-) '(FUNCALL -F-))) (DECLARE (SPECIAL -F- -X-)) (%M T))))
EQL-OK: NIL
(LET ((-X- NIL)) (DECLARE (SPECIAL -X-)) (LET ((-F- #'(LAMBDA NIL -X-))) (DECLARE (SPECIAL -F-)) (EVAL `(MACROLET ((%M ((-X-)) (DECLARE (SPECIAL -F- -X-)) (FUNCALL -F-))) (%M (T))))))
EQL-OK: T
(LET ((-X- NIL)) (DECLARE (SPECIAL -X-)) (LET ((-F- #'(LAMBDA NIL -X-))) (DECLARE (SPECIAL -F-)) (MACROLET ((%M ((-X-)) '(FUNCALL -F-))) (DECLARE (SPECIAL -F- -X-)) (%M (T)))))
EQL-OK: NIL
(LET ((X :SPECIAL)) (DECLARE (SPECIAL X)) (LET ((X :LEXICAL)) (MACROLET ((F NIL 'X)) (DECLARE (SPECIAL X)) (LIST X (F)))))
EQUAL-OK: (:SPECIAL :SPECIAL)
(LET ((X :SPECIAL)) (DECLARE (SPECIAL X)) (LET ((X :LEXICAL)) (FLET ((F NIL X)) (DECLARE (SPECIAL X)) (LIST X (F)))))
EQUAL-OK: (:SPECIAL :LEXICAL)
(LET ((X :SPECIAL)) (DECLARE (SPECIAL X)) (LET ((X :LEXICAL)) (LABELS ((F NIL X)) (DECLARE (SPECIAL X)) (LIST X (F)))))
EQUAL-OK: (:SPECIAL :LEXICAL)
(LET ((X :SPECIAL)) (DECLARE (SPECIAL X)) (LET ((X :LEXICAL)) (LABELS NIL (DECLARE (SPECIAL X)) X)))
EQL-OK: :SPECIAL
(LET ((X :SPECIAL)) (DECLARE (SPECIAL X)) (LET ((X :LEXICAL)) (LOCALLY (DECLARE (SPECIAL X)) X)))
EQL-OK: :SPECIAL
(SYMBOLS-CLEANUP '(*GLOBAL-VAR-FOR-BIND.TST* CHK-TYPE *SYMBOL-TYPE* TESTFN SYMBOL-TYPE-FN BIND-TEST-FUNCTION-1))
EQL-OK: NIL
RUN-TEST: finished "bind" (0 errors out of 72 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"bind.tst" @1>
(LET ((X 5)) (LET ((X (1+ X))) (DECLARE (SPECIAL X)) X))
EQL-OK: 6
(LET ((X 5)) (LET* ((X (1+ X))) (DECLARE (SPECIAL X)) X))
EQL-OK: 6
(LET ((X 5)) (MULTIPLE-VALUE-BIND (X) (1+ X) (DECLARE (SPECIAL X)) X))
EQL-OK: 6
(LET ((X 5)) ((LAMBDA (X) (DECLARE (SPECIAL X)) X) (1+ X)))
EQL-OK: 6
(BLOCK FOO (HANDLER-BIND ((UNBOUND-VARIABLE (HANDLER-RETURN FOO 'GOOD))) (LET ((X (1+ X))) (DECLARE (SPECIAL X)) X)))
WARNING: X is neither declared nor bound,
         it will be treated as if it were declared SPECIAL.
[SIMPLE-UNBOUND-VARIABLE]: NIL: variable X has no value

EQL-OK: GOOD
(BLOCK FOO (HANDLER-BIND ((UNBOUND-VARIABLE (HANDLER-RETURN FOO 'GOOD))) (LET* ((X (1+ X))) (DECLARE (SPECIAL X)) X)))
WARNING: X is neither declared nor bound,
         it will be treated as if it were declared SPECIAL.
[SIMPLE-UNBOUND-VARIABLE]: NIL: variable X has no value

EQL-OK: GOOD
(BLOCK FOO (HANDLER-BIND ((UNBOUND-VARIABLE (HANDLER-RETURN FOO 'GOOD))) (MULTIPLE-VALUE-BIND (X) (1+ X) (DECLARE (SPECIAL X)) X)))
WARNING: X is neither declared nor bound,
         it will be treated as if it were declared SPECIAL.
[SIMPLE-UNBOUND-VARIABLE]: NIL: variable X has no value

EQL-OK: GOOD
(BLOCK FOO (HANDLER-BIND ((UNBOUND-VARIABLE (HANDLER-RETURN FOO 'GOOD))) ((LAMBDA (X) (DECLARE (SPECIAL X)) X) (1+ X))))
WARNING: X is neither declared nor bound,
         it will be treated as if it were declared SPECIAL.
[SIMPLE-UNBOUND-VARIABLE]: NIL: variable X has no value

EQL-OK: GOOD
(LET ((X 5)) (LET ((Y (1+ X))) (DECLARE (SPECIAL X)) Y))
EQL-OK: 6
(LET ((X 5)) (LET* ((Y (1+ X))) (DECLARE (SPECIAL X)) Y))
EQL-OK: 6
(LET ((X 5)) (MULTIPLE-VALUE-BIND (Y) (1+ X) (DECLARE (SPECIAL X)) Y))
EQL-OK: 6
(LET ((X 5)) ((LAMBDA (Y) (DECLARE (SPECIAL X)) Y) (1+ X)))
EQL-OK: 6
(LET ((X 5)) (LET ((X (1+ X))) X))
EQL-OK: 6
(LET ((X 5)) (LET* ((X (1+ X))) X))
EQL-OK: 6
(LET ((X 5)) (MULTIPLE-VALUE-BIND (X) (1+ X) X))
EQL-OK: 6
(LET ((X 5)) ((LAMBDA (X) X) (1+ X)))
EQL-OK: 6
(LET ((X 5)) (PROGV '(X) '(20) (LET ((X (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) Z)))
EQL-OK: 6
(LET ((X 5)) (PROGV '(X) '(20) (LET* ((X (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) Z)))
EQL-OK: 7
(LET ((X 5)) (PROGV '(X) '(20) (MULTIPLE-VALUE-BIND (X Z) (VALUES (1+ X) (1+ X)) (DECLARE (SPECIAL X)) Z)))
EQL-OK: 6
(LET ((X 5)) (PROGV '(X) '(20) ((LAMBDA (&OPTIONAL (X (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) Z))))
EQL-OK: 7
(LET ((X 5)) (PROGV '(X Y) '(20 120) (LET ((X (1+ X)) (Y (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) (LIST Z (LOCALLY (DECLARE (SPECIAL Y)) Y) X Y))))
EQUAL-OK: (6 120 6 6)
(LET ((X 5)) (PROGV '(X Y) '(20 120) (LET* ((X (1+ X)) (Y (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) (LIST Z (LOCALLY (DECLARE (SPECIAL Y)) Y) X Y))))
EQUAL-OK: (7 120 6 7)
(LET ((X 5)) (PROGV '(X Y) '(20 120) (MULTIPLE-VALUE-BIND (X Y Z) (VALUES (1+ X) (1+ X) (1+ X)) (DECLARE (SPECIAL X)) (LIST Z (LOCALLY (DECLARE (SPECIAL Y)) Y) X Y))))
EQUAL-OK: (6 120 6 6)
(LET ((X 5)) (PROGV '(X Y) '(20 120) ((LAMBDA (&OPTIONAL (X (1+ X)) (Y (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) (LIST Z (LOCALLY (DECLARE (SPECIAL Y)) Y) X Y)))))
EQUAL-OK: (7 120 6 7)
(LET ((X 5)) (PROGV '(X) '(20) (LET ((Y (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) Z)))
WARNING: variable Y is not used.
         Misspelled or missing IGNORE declaration?
EQL-OK: 6
(LET ((X 5)) (PROGV '(X) '(20) (LET* ((Y (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) Z)))
WARNING: variable Y is not used.
         Misspelled or missing IGNORE declaration?
EQL-OK: 6
(LET ((X 5)) (PROGV '(X) '(20) (MULTIPLE-VALUE-BIND (Y Z) (VALUES (1+ X) (1+ X)) (DECLARE (SPECIAL X)) Z)))
WARNING: variable Y is not used.
         Misspelled or missing IGNORE declaration?
EQL-OK: 6
(LET ((X 5)) (PROGV '(X) '(20) ((LAMBDA (&OPTIONAL (Y (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) Z))))
WARNING: variable Y is not used.
         Misspelled or missing IGNORE declaration?
EQL-OK: 6
(PROGN (DEFPARAMETER *GLOBAL-VAR-FOR-BIND.TST* 123) (LET ((*GLOBAL-VAR-FOR-BIND.TST* 5)) (LIST (LET ((*GLOBAL-VAR-FOR-BIND.TST* (1+ *GLOBAL-VAR-FOR-BIND.TST*))) (DECLARE (SPECIAL *GLOBAL-VAR-FOR-BIND.TST*)) *GLOBAL-VAR-FOR-BIND.TST*) *GLOBAL-VAR-FOR-BIND.TST*)))
EQUAL-OK: (6 5)
(PROGN (DEFPARAMETER *GLOBAL-VAR-FOR-BIND.TST* 123) (LET ((*GLOBAL-VAR-FOR-BIND.TST* 5)) (LIST (LET* ((*GLOBAL-VAR-FOR-BIND.TST* (1+ *GLOBAL-VAR-FOR-BIND.TST*))) (DECLARE (SPECIAL *GLOBAL-VAR-FOR-BIND.TST*)) *GLOBAL-VAR-FOR-BIND.TST*) *GLOBAL-VAR-FOR-BIND.TST*)))
EQUAL-OK: (6 5)
(PROGN (DEFPARAMETER *GLOBAL-VAR-FOR-BIND.TST* 123) (LET ((*GLOBAL-VAR-FOR-BIND.TST* 5)) (LIST (MULTIPLE-VALUE-BIND (*GLOBAL-VAR-FOR-BIND.TST*) (1+ *GLOBAL-VAR-FOR-BIND.TST*) (DECLARE (SPECIAL *GLOBAL-VAR-FOR-BIND.TST*)) *GLOBAL-VAR-FOR-BIND.TST*) *GLOBAL-VAR-FOR-BIND.TST*)))
EQUAL-OK: (6 5)
(PROGN (DEFPARAMETER *GLOBAL-VAR-FOR-BIND.TST* 123) (LET ((*GLOBAL-VAR-FOR-BIND.TST* 5)) (LIST ((LAMBDA (*GLOBAL-VAR-FOR-BIND.TST*) (DECLARE (SPECIAL *GLOBAL-VAR-FOR-BIND.TST*)) *GLOBAL-VAR-FOR-BIND.TST*) (1+ *GLOBAL-VAR-FOR-BIND.TST*)) *GLOBAL-VAR-FOR-BIND.TST*)))
EQUAL-OK: (6 5)
(PROGN (DEFPARAMETER *GLOBAL-VAR-FOR-BIND.TST* 123) (LET ((*GLOBAL-VAR-FOR-BIND.TST* 5)) (LIST (LET ((*GLOBAL-VAR-FOR-BIND.TST* (1+ *GLOBAL-VAR-FOR-BIND.TST*))) *GLOBAL-VAR-FOR-BIND.TST*) *GLOBAL-VAR-FOR-BIND.TST*)))
EQUAL-OK: (6 5)
(PROGN (DEFPARAMETER *GLOBAL-VAR-FOR-BIND.TST* 123) (LET ((*GLOBAL-VAR-FOR-BIND.TST* 5)) (LIST (LET* ((*GLOBAL-VAR-FOR-BIND.TST* (1+ *GLOBAL-VAR-FOR-BIND.TST*))) *GLOBAL-VAR-FOR-BIND.TST*) *GLOBAL-VAR-FOR-BIND.TST*)))
EQUAL-OK: (6 5)
(PROGN (DEFPARAMETER *GLOBAL-VAR-FOR-BIND.TST* 123) (LET ((*GLOBAL-VAR-FOR-BIND.TST* 5)) (LIST (MULTIPLE-VALUE-BIND (*GLOBAL-VAR-FOR-BIND.TST*) (1+ *GLOBAL-VAR-FOR-BIND.TST*) *GLOBAL-VAR-FOR-BIND.TST*) *GLOBAL-VAR-FOR-BIND.TST*)))
EQUAL-OK: (6 5)
(PROGN (DEFPARAMETER *GLOBAL-VAR-FOR-BIND.TST* 123) (LET ((*GLOBAL-VAR-FOR-BIND.TST* 5)) (LIST ((LAMBDA (*GLOBAL-VAR-FOR-BIND.TST*) *GLOBAL-VAR-FOR-BIND.TST*) (1+ *GLOBAL-VAR-FOR-BIND.TST*)) *GLOBAL-VAR-FOR-BIND.TST*)))
EQUAL-OK: (6 5)
(EVAL-WHEN (EVAL COMPILE LOAD) (DEFMACRO CHK-TYPE (FORM TYPE) (LET ((OBJ (GENSYM))) `(LET ((,OBJ ,FORM)) (ASSERT (TYPEP ,OBJ ',TYPE)) (THE ,TYPE ,OBJ)))))
EQL-OK: CHK-TYPE
(SYMBOL-MACROLET ((X (LIST 'SYMBOL))) (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@X))) (FOO 'BAR)))
EQL-OK: BAR
(LET ((X 5)) (PROGV '(X) '(20) (SYMBOL-MACROLET ((X (LIST 'SYMBOL))) (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@X))) (FOO 'BAR)))))
WARNING: variable X is not used.
         Misspelled or missing IGNORE declaration?
EQL-OK: BAR
(LET ((X :GOOD)) (DECLARE (SPECIAL X)) (LET ((X :BAD)) (SYMBOL-MACROLET NIL (DECLARE (SPECIAL X)) X)))
WARNING: variable X is not used.
         Misspelled or missing IGNORE declaration?
EQL-OK: :GOOD
(LOCALLY (DECLARE (SPECIAL SYMBOL-TYPE)) (SETQ SYMBOL-TYPE (LIST 'SYMBOL)))
EQUAL-OK: (SYMBOL)
(LOCALLY (DECLARE (SPECIAL SYMBOL-TYPE)) (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@SYMBOL-TYPE))) (FOO 'BAR)))
EQL-OK: BAR
(DEFPARAMETER *SYMBOL-TYPE* (LIST 'SYMBOL))
EQL-OK: *SYMBOL-TYPE*
(LET ((*SYMBOL-TYPE* (LIST 'SYMBOL))) (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@*SYMBOL-TYPE*))) (FOO 'BAR)))
EQL-OK: BAR
(PROGV '(X) '((SYMBOL)) (LET ((X (LIST 'SYMBOL))) (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@X))) (FOO 'BAR))))
[SIMPLE-SOURCE-PROGRAM-ERROR]: Invalid access to the value of the lexical variable X from within a MACROLET definition
EQL-OK: ERROR
(PROGV '(X) '((SYMBOL)) (LET ((X (LIST 'SYMBOL))) (DEFUN TESTFN NIL (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@X))) (FOO 'BAR)))) (TESTFN))
[SIMPLE-SOURCE-PROGRAM-ERROR]: Invalid access to the value of the lexical variable X from within a MACROLET definition
EQL-OK: ERROR
(PROGV '(X) '((SYMBOL)) (LET ((X (LIST 'SYMBOL))) (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@X))) (DEFUN TESTFN NIL (FOO 'BAR)))) (TESTFN))
[SIMPLE-SOURCE-PROGRAM-ERROR]: Invalid access to the value of the lexical variable X from within a MACROLET definition
EQL-OK: ERROR
(MACROLET ((X NIL '(LIST 'SYMBOL))) (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@(X)))) (FOO 'BAR)))
EQL-OK: BAR
(DEFUN SYMBOL-TYPE-FN NIL (LIST 'SYMBOL))
EQL-OK: SYMBOL-TYPE-FN
(FLET ((SYMBOL-TYPE-FN NIL (LIST 'SYMBOL))) (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@(SYMBOL-TYPE-FN)))) (FOO 'BAR)))
[SIMPLE-SOURCE-PROGRAM-ERROR]: Invalid access to the local function definition of SYMBOL-TYPE-FN from within a MACROLET definition
EQL-OK: ERROR
(PROGN (FLET ((SYMBOL-TYPE-FN NIL (LIST 'SYMBOL))) (DEFUN TESTFN NIL (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@(SYMBOL-TYPE-FN)))) (FOO 'BAR)))) (TESTFN))
[SIMPLE-SOURCE-PROGRAM-ERROR]: Invalid access to the local function definition of SYMBOL-TYPE-FN from within a MACROLET definition
EQL-OK: ERROR
(PROGN (FLET ((SYMBOL-TYPE-FN NIL (LIST 'SYMBOL))) (MACROLET ((FOO (FORM) `(CHK-TYPE ,FORM ,@(SYMBOL-TYPE-FN)))) (DEFUN TESTFN NIL (FOO 'BAR)))) (TESTFN))
[SIMPLE-SOURCE-PROGRAM-ERROR]: Invalid access to the local function definition of SYMBOL-TYPE-FN from within a MACROLET definition
EQL-OK: ERROR
(BLOCK DONE (LET ((X :GOOD)) (DECLARE (SPECIAL X)) (LET ((X :BAD)) (DO* ((I 0 (RETURN-FROM DONE X))) (NIL NIL) (DECLARE (SPECIAL X))))))
WARNING: variable I is assigned but not read
WARNING: variable X is not used.
         Misspelled or missing IGNORE declaration?
EQL-OK: :GOOD
(LET ((X :GOOD)) (DECLARE (SPECIAL X)) (LET ((X :BAD)) (MULTIPLE-VALUE-BIND (A B) (FLOOR 13 4) (DECLARE (SPECIAL X)) (LIST A B X))))
WARNING: variable X is not used.
         Misspelled or missing IGNORE declaration?
EQUAL-OK: (3 1 :GOOD)
(LET ((X 1)) (DECLARE (SPECIAL X)) (LET ((X 2)) (DEFUN BIND-TEST-FUNCTION-1 (&OPTIONAL (Y X)) (DECLARE (SPECIAL X)) (LIST Y X)) (BIND-TEST-FUNCTION-1)))
WARNING: Function BIND-TEST-FUNCTION-1 is not defined
EQUAL-OK: (2 1)
(LET ((X 5)) (LET ((X (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) Z))
EQL-OK: 6
(LET ((X 5)) (LET* ((X (1+ X)) (Z (1+ X))) (DECLARE (SPECIAL X)) Z))
EQL-OK: 7
(LET ((X 5)) (MULTIPLE-VALUE-BIND (X Z) (VALUES (1+ X) (1+ X)) (DECLARE (SPECIAL X)) Z))
EQL-OK: 6
(LET ((X 5)) ((LAMBDA (X Z) (DECLARE (SPECIAL X)) Z) (1+ X) (1+ X)))
EQL-OK: 6
(LET ((X 5)) ((LAMBDA (&OPTIONAL X Z) (DECLARE (SPECIAL X)) Z) (1+ X) (1+ X)))
EQL-OK: 6
(LET ((-X- NIL)) (DECLARE (SPECIAL -X-)) (LET ((-F- #'(LAMBDA NIL -X-))) (DECLARE (SPECIAL -F-)) (EVAL `(MACROLET ((%M (-X-) (DECLARE (SPECIAL -F-)) (FUNCALL -F-))) (%M T)))))
EQL-OK: NIL
(LET ((-X- NIL)) (DECLARE (SPECIAL -X-)) (LET ((-F- #'(LAMBDA NIL -X-))) (DECLARE (SPECIAL -F-)) (MACROLET ((%M (-X-) '(FUNCALL -F-))) (DECLARE (SPECIAL -F-)) (%M T))))
EQL-OK: NIL
(LET ((-X- NIL)) (DECLARE (SPECIAL -X-)) (LET ((-F- #'(LAMBDA NIL -X-))) (DECLARE (SPECIAL -F-)) (EVAL `(MACROLET ((%M (-X-) (DECLARE (SPECIAL -F- -X-)) (FUNCALL -F-))) (%M T)))))
EQL-OK: T
(LET ((-X- NIL)) (DECLARE (SPECIAL -X-)) (LET ((-F- #'(LAMBDA NIL -X-))) (DECLARE (SPECIAL -F-)) (MACROLET ((%M (-X-) '(FUNCALL -F-))) (DECLARE (SPECIAL -F- -X-)) (%M T))))
EQL-OK: NIL
(LET ((-X- NIL)) (DECLARE (SPECIAL -X-)) (LET ((-F- #'(LAMBDA NIL -X-))) (DECLARE (SPECIAL -F-)) (EVAL `(MACROLET ((%M ((-X-)) (DECLARE (SPECIAL -F- -X-)) (FUNCALL -F-))) (%M (T))))))
EQL-OK: T
(LET ((-X- NIL)) (DECLARE (SPECIAL -X-)) (LET ((-F- #'(LAMBDA NIL -X-))) (DECLARE (SPECIAL -F-)) (MACROLET ((%M ((-X-)) '(FUNCALL -F-))) (DECLARE (SPECIAL -F- -X-)) (%M (T)))))
EQL-OK: NIL
(LET ((X :SPECIAL)) (DECLARE (SPECIAL X)) (LET ((X :LEXICAL)) (MACROLET ((F NIL 'X)) (DECLARE (SPECIAL X)) (LIST X (F)))))
WARNING: variable X is not used.
         Misspelled or missing IGNORE declaration?
EQUAL-OK: (:SPECIAL :SPECIAL)
(LET ((X :SPECIAL)) (DECLARE (SPECIAL X)) (LET ((X :LEXICAL)) (FLET ((F NIL X)) (DECLARE (SPECIAL X)) (LIST X (F)))))
EQUAL-OK: (:SPECIAL :LEXICAL)
(LET ((X :SPECIAL)) (DECLARE (SPECIAL X)) (LET ((X :LEXICAL)) (LABELS ((F NIL X)) (DECLARE (SPECIAL X)) (LIST X (F)))))
EQUAL-OK: (:SPECIAL :LEXICAL)
(LET ((X :SPECIAL)) (DECLARE (SPECIAL X)) (LET ((X :LEXICAL)) (LABELS NIL (DECLARE (SPECIAL X)) X)))
WARNING: variable X is not used.
         Misspelled or missing IGNORE declaration?
EQL-OK: :SPECIAL
(LET ((X :SPECIAL)) (DECLARE (SPECIAL X)) (LET ((X :LEXICAL)) (LOCALLY (DECLARE (SPECIAL X)) X)))
WARNING: variable X is not used.
         Misspelled or missing IGNORE declaration?
EQL-OK: :SPECIAL
(SYMBOLS-CLEANUP '(*GLOBAL-VAR-FOR-BIND.TST* CHK-TYPE *SYMBOL-TYPE* TESTFN SYMBOL-TYPE-FN BIND-TEST-FUNCTION-1))
EQL-OK: NIL
RUN-TEST: finished "bind" (0 errors out of 72 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"conditions.tst" @1>
(DEFUN MY-CPL (CLASS) (CLASS-PRECEDENCE-LIST (FIND-CLASS CLASS)))
EQL-OK: MY-CPL
(DEFUN CHECK-SUPERCLASSES (CLASS EXPECTED) (LET ((EXPECTED (LIST* CLASS 'T 'STANDARD-OBJECT 'CONDITION EXPECTED)) (SUPER (MAPCAR #'CLASS-NAME (MY-CPL CLASS)))) (LIST (SET-DIFFERENCE SUPER EXPECTED) (SET-DIFFERENCE EXPECTED SUPER))))
EQL-OK: CHECK-SUPERCLASSES
(MULTIPLE-VALUE-BIND (VALUE CONDITION) (IGNORE-ERRORS (ERROR "Foo")) (LIST VALUE (TYPE-OF CONDITION)))
EQUAL-OK: (NIL SIMPLE-ERROR)
(MULTIPLE-VALUE-LIST (IGNORE-ERRORS (VALUES 23 42)))
EQUAL-OK: (23 42)
(CHECK-SUPERCLASSES 'WARNING 'NIL)
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'STYLE-WARNING '(WARNING))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'SERIOUS-CONDITION 'NIL)
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'ERROR '(SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'CELL-ERROR '(ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'PARSE-ERROR '(ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'STORAGE-CONDITION '(SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'SIMPLE-ERROR '(SIMPLE-CONDITION ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'SIMPLE-CONDITION 'NIL)
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'SIMPLE-WARNING '(SIMPLE-CONDITION WARNING))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'FILE-ERROR '(ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'CONTROL-ERROR '(ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'PROGRAM-ERROR '(ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'UNDEFINED-FUNCTION '(CELL-ERROR ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'ARITHMETIC-ERROR '(ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'DIVISION-BY-ZERO '(ARITHMETIC-ERROR ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'FLOATING-POINT-INVALID-OPERATION '(ARITHMETIC-ERROR ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'FLOATING-POINT-INEXACT '(ARITHMETIC-ERROR ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'FLOATING-POINT-OVERFLOW '(ARITHMETIC-ERROR ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'FLOATING-POINT-UNDERFLOW '(ARITHMETIC-ERROR ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'UNBOUND-SLOT '(CELL-ERROR ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'PACKAGE-ERROR '(ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'PRINT-NOT-READABLE '(ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'READER-ERROR '(PARSE-ERROR STREAM-ERROR ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'STREAM-ERROR '(ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'END-OF-FILE '(STREAM-ERROR ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'UNBOUND-VARIABLE '(CELL-ERROR ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'TYPE-ERROR '(ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(CHECK-SUPERCLASSES 'SIMPLE-TYPE-ERROR '(SIMPLE-CONDITION TYPE-ERROR ERROR SERIOUS-CONDITION))
EQUAL-OK: (NIL NIL)
(DEFINE-CONDITION TEST NIL NIL)
EQL-OK: TEST
(CHECK-SUPERCLASSES 'TEST 'NIL)
EQUAL-OK: (NIL NIL)
(DEFINE-CONDITION TEST2 (TEST) NIL)
EQL-OK: TEST2
(CHECK-SUPERCLASSES 'TEST2 '(TEST))
EQUAL-OK: (NIL NIL)
(DEFINE-CONDITION TEST3 (TEST2 SIMPLE-CONDITION) NIL)
EQL-OK: TEST3
(CHECK-SUPERCLASSES 'TEST3 '(TEST2 TEST SIMPLE-CONDITION))
EQUAL-OK: (NIL NIL)
(PROGN (MAKE-CONDITION 'TEST) T)
EQL-OK: T
(IGNORE-ERRORS (PROGN (MAKE-CONDITION 'INTEGER) T))
EQL-OK: NIL
(DEFINE-CONDITION TEST4 (TEST3) NIL (:REPORT (LAMBDA (CONDITION STREAM) (FORMAT STREAM "Yow! -- ~S" (TYPE-OF CONDITION)))))
EQL-OK: TEST4
(WITH-OUTPUT-TO-STRING (S) (PRINC (MAKE-CONDITION 'TEST4) S))
EQUAL-OK: "Yow! -- TEST4"
(DEFINE-CONDITION TEST5 (TEST4) NIL)
EQL-OK: TEST5
(WITH-OUTPUT-TO-STRING (S) (PRINC (MAKE-CONDITION 'TEST5) S))
EQUAL-OK: "Yow! -- TEST5"
(WITH-OUTPUT-TO-STRING (S) (PRINC (MAKE-CONDITION 'TEST3 :FORMAT-CONTROL "And How! -- ~S" :FORMAT-ARGUMENTS '(23)) S))
EQUAL-OK: "And How! -- 23"
(DEFINE-CONDITION TEST6 (TEST4) ((FOO :INITARG :FOO :INITFORM 23 :ACCESSOR TEST6-FOO)) (:REPORT (LAMBDA (CONDITION STREAM) (FORMAT STREAM "~S -- ~S" (TYPE-OF CONDITION) (TEST6-FOO CONDITION)))))
EQL-OK: TEST6
(TEST6-FOO (MAKE-CONDITION 'TEST6))
EQL-OK: 23
(TEST6-FOO (MAKE-CONDITION 'TEST6 :FOO 42))
EQL-OK: 42
(SETF (TEST6-FOO (MAKE-CONDITION 'TEST6 :FOO 42)) 17)
EQL-OK: 17
(WITH-OUTPUT-TO-STRING (S) (PRINC (MAKE-CONDITION 'TEST6 :FOO 42) S))
EQUAL-OK: "TEST6 -- 42"
(LET ((TYPE '(OR PROGRAM-ERROR TYPE-ERROR))) (TYPEP (MAKE-CONDITION TYPE) TYPE))
EQL-OK: T
(LET ((TYPE '(AND SIMPLE-ERROR TYPE-ERROR))) (TYPEP (MAKE-CONDITION TYPE) TYPE))
EQL-OK: T
(IGNORE-ERRORS (HANDLER-BIND NIL (ERROR "Foo")))
EQL-OK: NIL
(MULTIPLE-VALUE-LIST (BLOCK FOO (HANDLER-BIND ((ERROR (HANDLER-RETURN FOO 23))) (VALUES 42 17))))
EQUAL-OK: (42 17)
(MULTIPLE-VALUE-LIST (BLOCK FOO (HANDLER-BIND ((ERROR (HANDLER-RETURN FOO (VALUES 23 17)))) (ERROR "Foo"))))
[SIMPLE-ERROR]: Foo
EQUAL-OK: (23 17)
(IGNORE-ERRORS (BLOCK FOO (HANDLER-BIND ((TYPE-ERROR (HANDLER-RETURN FOO 23))) (ERROR "Foo"))))
EQL-OK: NIL
(BLOCK FOO (HANDLER-BIND (((OR TYPE-ERROR ERROR) (HANDLER-RETURN FOO 23))) (ERROR "Foo")))
[SIMPLE-ERROR]: Foo
EQL-OK: 23
(IGNORE-ERRORS (BLOCK FOO (LET ((FIRST-TIME T)) (HANDLER-BIND ((ERROR #'(LAMBDA (C) (PRINC-ERROR C) (IF FIRST-TIME (PROGN (SETQ FIRST-TIME NIL) (ERROR "Bar")) (RETURN-FROM FOO 23))))) (ERROR "Foo")))))
[SIMPLE-ERROR]: Foo
EQL-OK: NIL
(BLOCK FOO (LET ((FIRST-TIME T)) (HANDLER-BIND ((ERROR (HANDLER-RETURN FOO 23))) (HANDLER-BIND ((ERROR #'(LAMBDA (C) (PRINC-ERROR C) (IF FIRST-TIME (PROGN (SETQ FIRST-TIME NIL) (ERROR "Bar")) (RETURN-FROM FOO 42))))) (ERROR "Foo")))))
[SIMPLE-ERROR]: Foo
[SIMPLE-ERROR]: Bar
EQL-OK: 23
(IGNORE-ERRORS (BLOCK FOO (HANDLER-BIND ((ERROR #'(LAMBDA (C) (PRINC-ERROR C) NIL)) (ERROR (HANDLER-RETURN FOO 23))) (ERROR "Foo"))))
[SIMPLE-ERROR]: Foo
[SIMPLE-ERROR]: Foo
EQL-OK: 23
(BLOCK FOO (HANDLER-BIND ((TYPE-ERROR (HANDLER-RETURN FOO 42)) (ERROR (HANDLER-RETURN FOO 23))) (ERROR "Foo")))
[SIMPLE-ERROR]: Foo
EQL-OK: 23
(BLOCK FOO (HANDLER-BIND ((ERROR (HANDLER-RETURN FOO 23))) (BLOCK BAR (HANDLER-BIND ((ERROR (HANDLER-RETURN FOO 42))) (RETURN-FROM BAR))) (ERROR "Foo")))
[SIMPLE-ERROR]: Foo
EQL-OK: 23
(MULTIPLE-VALUE-LIST (HANDLER-CASE (ERROR "Foo") (ERROR (C) (WHEN (TYPEP C 'ERROR) (VALUES 23 42)))))
EQUAL-OK: (23 42)
(IGNORE-ERRORS (HANDLER-CASE (ERROR "Foo") (TYPE-ERROR NIL 23)))
EQL-OK: NIL
(IGNORE-ERRORS (HANDLER-CASE (ERROR "Foo")))
EQL-OK: NIL
(MULTIPLE-VALUE-LIST (HANDLER-CASE (VALUES 42 17) (ERROR NIL 23)))
EQUAL-OK: (42 17)
(MULTIPLE-VALUE-LIST (HANDLER-CASE (VALUES 23 42) (:NO-ERROR (A B) (VALUES B A))))
EQUAL-OK: (42 23)
(HANDLER-CASE (ERROR "Foo") (ERROR NIL 23) (:NO-ERROR (&REST ARGS) (DECLARE (IGNORE ARGS)) 42))
EQL-OK: 23
(HANDLER-CASE 23 (:NO-ERROR (V) (1+ V)) (ERROR NIL 42))
EQL-OK: 24
(HANDLER-CASE (ERROR "Foo") (TYPE-ERROR NIL 23) (ERROR NIL 42))
EQL-OK: 42
(IGNORE-ERRORS (PROGN (BLOCK FOO (HANDLER-CASE (RETURN-FROM FOO 23) (ERROR NIL 42))) (ERROR "Foo")))
EQL-OK: NIL
(IGNORE-ERRORS (BLOCK FOO (LET ((FIRST-TIME T)) (HANDLER-CASE (ERROR "Foo") (ERROR NIL (IF FIRST-TIME (PROGN (SETF FIRST-TIME NIL) (ERROR "Bar")) (RETURN-FROM FOO 23)))))))
EQL-OK: NIL
(MACROLET ((%M (&REST ARGS) (CONS 'ERROR ARGS))) (HANDLER-BIND ((ERROR #'(LAMBDA (C2) (INVOKE-RESTART (FIND-RESTART 'FOO C2))))) (HANDLER-BIND ((ERROR #'(LAMBDA (C) (PRINC-ERROR C) (ERROR "blah")))) (RESTART-CASE (RESTART-CASE (%M "boo!") (FOO NIL 'BAD)) (FOO NIL 'GOOD)))))
[SIMPLE-ERROR]: boo!
EQL-OK: GOOD
(SYMBOL-MACROLET ((%S (ERROR "boo!"))) (HANDLER-BIND ((ERROR #'(LAMBDA (C2) (INVOKE-RESTART (FIND-RESTART 'FOO C2))))) (HANDLER-BIND ((ERROR #'(LAMBDA (C) (PRINC-ERROR C) (ERROR "blah")))) (RESTART-CASE (RESTART-CASE %S (FOO NIL 'BAD)) (FOO NIL 'GOOD)))))
[SIMPLE-ERROR]: boo!
EQL-OK: GOOD
(MACROLET ((%M2 (&REST ARGS) (CONS 'ERROR ARGS))) (MACROLET ((%M (&REST ARGS &ENVIRONMENT ENV) (MACROEXPAND (CONS '%M2 ARGS) ENV))) (HANDLER-BIND ((ERROR #'(LAMBDA (C2) (INVOKE-RESTART (FIND-RESTART 'FOO C2))))) (HANDLER-BIND ((ERROR #'(LAMBDA (C) (PRINC-ERROR C) (ERROR "blah")))) (RESTART-CASE (RESTART-CASE (%M "boo!") (FOO NIL 'BAD)) (FOO NIL 'GOOD))))))
[SIMPLE-ERROR]: boo!
EQL-OK: GOOD
(MACROLET ((%M2 (&REST ARGS) (CONS 'ERROR ARGS))) (MACROLET ((%M (&REST ARGS &ENVIRONMENT ENV) (MACROEXPAND (CONS '%M2 ARGS) ENV))) (HANDLER-BIND ((ERROR #'(LAMBDA (C2) (INVOKE-RESTART (FIND-RESTART 'FOO C2))))) (HANDLER-BIND ((ERROR #'(LAMBDA (C) (PRINC-ERROR C) (ERROR "blah")))) (RESTART-CASE (WITH-RESTARTS ((FOO NIL 'BAD)) (%M "boo!")) (FOO NIL 'GOOD))))))
[SIMPLE-ERROR]: boo!
EQL-OK: GOOD
(MULTIPLE-VALUE-LIST (WITH-SIMPLE-RESTART (FOO "zzz") (INVOKE-RESTART 'FOO)))
EQUAL-OK: (NIL T)
(MULTIPLE-VALUE-LIST (FLET ((%F NIL (INVOKE-RESTART 'FOO))) (WITH-SIMPLE-RESTART (FOO "zzz") (%F))))
EQUAL-OK: (NIL T)
(MULTIPLE-VALUE-LIST (WITH-SIMPLE-RESTART (NIL "") (INVOKE-RESTART (FIRST (COMPUTE-RESTARTS)))))
EQUAL-OK: (NIL T)
(RESTART-CASE (INVOKE-RESTART 'FOO) (FOO NIL :TEST (LAMBDA (C) (PRINC-ERROR C) NIL) 'BAD) (FOO NIL 'GOOD))
[NULL]: NIL
EQL-OK: GOOD
(BLOCK NIL (HANDLER-BIND ((TYPE-ERROR (LAMBDA (C) (RETURN (LIST (TYPE-ERROR-EXPECTED-TYPE C) (TYPE-ERROR-DATUM C)))))) (COERCE '(1 2 3) 'INTEGER)))
EQUAL-OK: (INTEGER (1 2 3))
(BLOCK NIL (HANDLER-BIND ((TYPE-ERROR (LAMBDA (C) (RETURN (LIST (TYPE-ERROR-EXPECTED-TYPE C) (TYPE-ERROR-DATUM C)))))) (COERCE '(1 2 3) '(INTEGER 1))))
EQUAL-OK: ((INTEGER 1) (1 2 3))
(LET ((DONE NIL)) (BLOCK TEST (SYSTEM::DRIVER #'(LAMBDA NIL (WHEN DONE (RETURN-FROM TEST NIL)) (SETQ DONE T) (HANDLER-BIND ((ERROR (LAMBDA (C) (THROW 'SYSTEM::DONE-SIGNALING NIL)))) (LET ((*DEBUG-IO* (MAKE-TWO-WAY-STREAM (MAKE-STRING-INPUT-STREAM "") *TERMINAL-IO*))) (ASSERT (= 1 2))))))))

*** - (= 1 2) must evaluate to a non-NIL value.
EQL-OK: NIL
(BLOCK NIL (HANDLER-BIND ((UNBOUND-VARIABLE (HANDLER-RETURN NIL :GOOD))) (LET ((FOO (GENSYM "UNBOUND-"))) (DECLARE (COMPILE) (OPTIMIZE SAFETY (DEBUG 1))) (PROGN (SYMBOL-VALUE FOO) :BAD))))
[SIMPLE-UNBOUND-VARIABLE]: SYMBOL-VALUE: variable #1=#:UNBOUND-21475 has no value

EQL-OK: :GOOD
(BLOCK NIL (DECLAIM (OPTIMIZE SAFETY (DEBUG 1))) (UNWIND-PROTECT (HANDLER-BIND ((UNBOUND-VARIABLE (HANDLER-RETURN NIL :GOOD))) (LET ((FOO (GENSYM "UNBOUND-"))) (DECLARE (COMPILE)) (PROGN (SYMBOL-VALUE FOO) :BAD))) (DECLAIM (OPTIMIZE (SAFETY 1)))))
[SIMPLE-UNBOUND-VARIABLE]: SYMBOL-VALUE: variable #1=#:UNBOUND-21483 has no value

EQL-OK: :GOOD
(BLOCK NIL (HANDLER-BIND ((UNBOUND-VARIABLE (HANDLER-RETURN NIL :GOOD))) (LET ((FOO (GENSYM "UNBOUND-"))) (PROGN (SYMBOL-VALUE FOO) :BAD))))
[SIMPLE-UNBOUND-VARIABLE]: SYMBOL-VALUE: variable #1=#:UNBOUND-21490 has no value

EQL-OK: :GOOD
(BLOCK NIL (HANDLER-BIND ((READER-ERROR (LAMBDA (C) (PRINC-ERROR C) (RETURN (STREAMP (STREAM-ERROR-STREAM C)))))) (READ-FROM-STRING ")")))
[SIMPLE-READER-ERROR]: READ from #1=#<INPUT STRING-INPUT-STREAM>: an object cannot start with #\)

EQL-OK: T
(BLOCK NIL (HANDLER-BIND ((READER-ERROR (LAMBDA (C) (PRINC-ERROR C) (RETURN (STREAMP (STREAM-ERROR-STREAM C)))))) (READ-FROM-STRING ",1")))
[SIMPLE-READER-ERROR]: READ: comma is illegal outside of backquote
EQL-OK: T
(BLOCK NIL (HANDLER-BIND ((STYLE-WARNING (HANDLER-RETURN NIL T))) (DEFUN TEST~ (B $) (DECLARE (COMPILE)) (COND (B NIL) (T T)))))
[SIMPLE-STYLE-WARNING]: in TEST~ : variable $ is not used.
Misspelled or missing IGNORE declaration?
EQL-OK: T
(LET (BAD) (DECLARE (OPTIMIZE SAFETY)) (DOLIST (TP '(ARITHMETIC-ERROR CELL-ERROR CONDITION CONTROL-ERROR DIVISION-BY-ZERO END-OF-FILE ERROR FILE-ERROR FLOATING-POINT-INEXACT FLOATING-POINT-INVALID-OPERATION FLOATING-POINT-UNDERFLOW FLOATING-POINT-OVERFLOW PACKAGE-ERROR PARSE-ERROR PRINT-NOT-READABLE PROGRAM-ERROR READER-ERROR SERIOUS-CONDITION SIMPLE-CONDITION SIMPLE-ERROR SIMPLE-TYPE-ERROR SIMPLE-WARNING STORAGE-CONDITION STREAM-ERROR STYLE-WARNING TYPE-ERROR UNBOUND-SLOT UNBOUND-VARIABLE UNDEFINED-FUNCTION WARNING) BAD) (UNLESS (TYPEP (HANDLER-CASE (MAKE-CONDITION TP) (ERROR NIL NIL)) 'CONDITION) (PUSH TP BAD))))
EQL-OK: NIL
(WITH-OUTPUT-TO-STRING (S) (DEFINE-CONDITION MY-SIMPLE (SIMPLE-CONDITION) NIL (:REPORT (LAMBDA (C S) (FORMAT S "good: ~S overrides SIMPLE-CONDITION" (TYPE-OF C))))) (PRINC (MAKE-CONDITION 'MY-SIMPLE :FORMAT-CONTROL "bad: SIMPLE-CONDITION overrides MY-SIMPLE") S))
EQUAL-OK: "good: MY-SIMPLE overrides SIMPLE-CONDITION"
(HANDLER-CASE (COMPILE NIL (LAMBDA NIL (DEFINE-CONDITION C (CONDITION) NIL (:REPORT (LAMBDA (C) (PRINC C)))))) (WARNING (W) (PRINC-ERROR W) 'WARNING))
[SIMPLE-WARNING]: in #:|1-1| : Cannot call #'(LAMBDA (C) (PRINC C)) on 2 arguments
EQL-OK: WARNING
(HANDLER-CASE (COMPILE NIL (LAMBDA NIL (MAPCAR (LAMBDA NIL 1) '(1 2 3)))) (WARNING (W) (PRINC-ERROR W) 'WARNING))
[SIMPLE-WARNING]: Cannot call #'(LAMBDA NIL 1) on 1 argument
EQL-OK: WARNING
(LET ((CLOSURE (COMPILE NIL (LAMBDA (X Y) (IGNORE-ERRORS (= X Y)))))) (FIND-IF #'SYSTEM::CLOSUREP (SYSTEM::CLOSURE-CONSTS CLOSURE)))
EQL-OK: NIL
(FIND-IF #'SYSTEM::CLOSUREP (SYSTEM::CLOSURE-CONSTS #'CLOS::ANY-METHOD-COMBINATION-CHECK-OPTIONS))
EQL-OK: NIL
(FIND-IF #'SYSTEM::CLOSUREP (SYSTEM::CLOSURE-CONSTS (COMPILE NIL (LAMBDA (ARG) (HANDLER-BIND ((ERROR (CONSTANTLY NIL))) (CAR ARG))))))
EQL-OK: NIL
(SYMBOLS-CLEANUP '(MY-CPL CHECK-SUPERCLASSES C MY-SIMPLE TEST TEST2 TEST3 TEST4 TEST5 TEST6 TEST~))
EQL-OK: NIL
RUN-TEST: finished "conditions" (0 errors out of 98 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"restarts.tst" @1>
(DEFUN HANDLER-USE-VALUE (VALUE) (LAMBDA (C) (PRINC-ERROR C) (USE-VALUE VALUE)))
EQL-OK: HANDLER-USE-VALUE
(DEFMACRO CHECK-USE-VALUE (FUN GOOD BAD &KEY (TYPE 'TYPE-ERROR) (TEST 'EQL)) `(HANDLER-BIND ((,TYPE (HANDLER-USE-VALUE ',GOOD))) (,TEST (,FUN ',GOOD) (,FUN ',BAD))))
EQL-OK: CHECK-USE-VALUE
(CHECK-USE-VALUE CHAR-CODE #\1 12 :TEST =)
[SIMPLE-TYPE-ERROR]: CHAR-CODE: argument 12 is not a character

EQL-OK: T
(CHECK-USE-VALUE SYMBOL-NAME GOOD "bad" :TEST STRING=)
[SIMPLE-TYPE-ERROR]: SYMBOL-NAME: #1="bad" is not a symbol

EQL-OK: T
(CHECK-USE-VALUE INTERN "BAR" BAR :TEST EQ)
[SIMPLE-TYPE-ERROR]: INTERN: argument BAR is not a string

EQL-OK: T
(CHECK-USE-VALUE FBOUNDP CONS "CONS")
[SIMPLE-TYPE-ERROR]: FBOUNDP: #1="CONS" is not a function name; try using a symbol instead

EQL-OK: T
(CHECK-USE-VALUE FDEFINITION CONS "CONS")
[SIMPLE-TYPE-ERROR]: FDEFINITION: #1="CONS" is not a function name; try using a symbol instead

EQL-OK: T
(CHECK-USE-VALUE STRING "123" 123)
[SIMPLE-TYPE-ERROR]: STRING: argument 123 should be a string, a symbol or a character

EQL-OK: T
(CHECK-USE-VALUE (LAMBDA (A) (AREF A 2)) #(A B C D) 1)
[SIMPLE-TYPE-ERROR]: AREF: argument 1 is not an array

EQL-OK: T
(CHECK-USE-VALUE (LAMBDA (A) (SETF (AREF A 2) 'X)) #(A B C D) 1)
[SIMPLE-TYPE-ERROR]: SYSTEM::STORE: argument 1 is not an array

EQL-OK: T
(CHECK-USE-VALUE (LAMBDA (A) (ROW-MAJOR-AREF A 3)) #2A((A B) (C D)) 1)
[SIMPLE-TYPE-ERROR]: ROW-MAJOR-AREF: argument 1 is not an array

EQL-OK: T
(CHECK-USE-VALUE (LAMBDA (A) (SETF (ROW-MAJOR-AREF A 3) 'X)) #2A((A B) (C D)) 1)
[SIMPLE-TYPE-ERROR]: SYSTEM::ROW-MAJOR-STORE: argument 1 is not an array

EQL-OK: T
(CHECK-USE-VALUE ARRAY-ELEMENT-TYPE #*1001 1)
[SIMPLE-TYPE-ERROR]: ARRAY-ELEMENT-TYPE: argument 1 is not an array

EQL-OK: T
(CHECK-USE-VALUE ARRAY-RANK #(A B C D) 1)
[SIMPLE-TYPE-ERROR]: ARRAY-RANK: argument 1 is not an array

EQL-OK: T
(CHECK-USE-VALUE (LAMBDA (A) (ARRAY-DIMENSION A 1)) #2A((A B) (C D)) 1)
[SIMPLE-TYPE-ERROR]: ARRAY-DIMENSION: argument 1 is not an array

EQL-OK: T
(CHECK-USE-VALUE ARRAY-DIMENSIONS #2A((A B) (C D)) 1 :TEST EQUAL)
[SIMPLE-TYPE-ERROR]: ARRAY-DIMENSIONS: argument 1 is not an array

EQL-OK: T
(CHECK-USE-VALUE (LAMBDA (A) (ARRAY-IN-BOUNDS-P A 1 2)) #2A((A B) (C D)) 1)
[SIMPLE-TYPE-ERROR]: ARRAY-IN-BOUNDS-P: argument 1 is not an array

EQL-OK: T
(CHECK-USE-VALUE (LAMBDA (A) (ARRAY-ROW-MAJOR-INDEX A 2)) #(A B C D) 1)
[SIMPLE-TYPE-ERROR]: ARRAY-ROW-MAJOR-INDEX: argument 1 is not an array

EQL-OK: T
(CHECK-USE-VALUE (LAMBDA (A) (ARRAY-ROW-MAJOR-INDEX A 1 1)) #2A((A B) (C D)) 1)
[SIMPLE-TYPE-ERROR]: ARRAY-ROW-MAJOR-INDEX: argument 1 is not an array

EQL-OK: T
(CHECK-USE-VALUE ADJUSTABLE-ARRAY-P #2A((A B) (C D)) 1)
[SIMPLE-TYPE-ERROR]: ADJUSTABLE-ARRAY-P: argument 1 is not an array

EQL-OK: T
(CHECK-USE-VALUE (LAMBDA (A) (BIT A 2)) #*1011 1)
[SIMPLE-TYPE-ERROR]: BIT: argument 1 is not an array

EQL-OK: T
(CHECK-USE-VALUE (LAMBDA (A) (SBIT A 2)) #*1011 1)
[SIMPLE-TYPE-ERROR]: SBIT: argument 1 is not an array

EQL-OK: T
(CHECK-USE-VALUE ARRAY-HAS-FILL-POINTER-P #2A((A B) (C D)) 1)
[SIMPLE-TYPE-ERROR]: ARRAY-HAS-FILL-POINTER-P: argument 1 is not an array

EQL-OK: T
(LET ((BS (MAKE-BROADCAST-STREAM))) (HANDLER-BIND ((TYPE-ERROR (HANDLER-USE-VALUE BS))) (BROADCAST-STREAM-STREAMS 10)))
[SIMPLE-TYPE-ERROR]: BROADCAST-STREAM-STREAMS: argument 10 is not a stream of type BROADCAST-STREAM

EQL-OK: NIL
(HANDLER-BIND ((ERROR (HANDLER-USE-VALUE #\#))) (EQ (GET-DISPATCH-MACRO-CHARACTER #\a #\() (GET-DISPATCH-MACRO-CHARACTER #\# #\()))
[SIMPLE-ERROR]: GET-DISPATCH-MACRO-CHARACTER: #\a is not a dispatch macro character

EQL-OK: T
(WITH-OUTPUT-TO-STRING (O) (HANDLER-BIND ((TYPE-ERROR (HANDLER-USE-VALUE O))) (PRINC "no error!" 123)))
[SIMPLE-TYPE-ERROR]: PRINC: argument 123 is not a stream

EQUAL-OK: "no error!"
(HANDLER-BIND ((TYPE-ERROR (HANDLER-USE-VALUE 16))) (PARSE-INTEGER "ABC" :RADIX 'LAMBDA))
[SIMPLE-TYPE-ERROR]: PARSE-INTEGER: :RADIX argument LAMBDA is not an integer between 2 and 36

EQL-OK: 2748
(WITH-INPUT-FROM-STRING (S "bazonk") (HANDLER-BIND ((TYPE-ERROR (HANDLER-USE-VALUE S))) (LIST (READ-CHAR 123) (READ-CHAR 1) (READ-CHAR 'READ-CHAR))))
[SIMPLE-TYPE-ERROR]: READ-CHAR: argument 123 is not a stream

[SIMPLE-TYPE-ERROR]: READ-CHAR: argument 1 is not a stream

[SIMPLE-TYPE-ERROR]: READ-CHAR: argument READ-CHAR is not a stream

EQUAL-OK: (#\b #\a #\z)
(HANDLER-BIND ((TYPE-ERROR (LAMBDA (C) (PRINC-ERROR C) (USE-VALUE (CASE (TYPE-ERROR-DATUM C) (1 *READTABLE*) (2 :UPCASE) (T (ERROR "huh?"))))))) (SETF (READTABLE-CASE 1) 2))
[SIMPLE-TYPE-ERROR]: SYSTEM::SET-READTABLE-CASE: new value 2 should be :UPCASE, :DOWNCASE, :PRESERVE or :INVERT.

[SIMPLE-TYPE-ERROR]: SYSTEM::SET-READTABLE-CASE: argument 1 is not a READTABLE

EQL-OK: :UPCASE
(HANDLER-BIND ((TYPE-ERROR (LAMBDA (C) (PRINC-ERROR C) (USE-VALUE (CASE (TYPE-ERROR-DATUM C) (1 #\#) (2 *READTABLE*) (T (ERROR "huh?"))))))) (NTH-VALUE 1 (GET-MACRO-CHARACTER 1 2)))
[SIMPLE-TYPE-ERROR]: GET-MACRO-CHARACTER: argument 1 is not a character

[SIMPLE-TYPE-ERROR]: GET-MACRO-CHARACTER: argument 2 is not a READTABLE

EQL-OK: T
(HANDLER-BIND ((TYPE-ERROR (HANDLER-USE-VALUE 7))) (LIST (DIGIT-CHAR-P #\3 300) (DIGIT-CHAR-P #\8 'DIGIT-CHAR-P)))
[SIMPLE-TYPE-ERROR]: DIGIT-CHAR-P: the radix must be an integer between 2 and 36, not 300

[SIMPLE-TYPE-ERROR]: DIGIT-CHAR-P: the radix must be an integer between 2 and 36, not DIGIT-CHAR-P

EQUAL-OK: (3 NIL)
(HANDLER-BIND ((TYPE-ERROR (LAMBDA (C) (PRINC-ERROR C) (USE-VALUE (CHAR (TYPE-ERROR-DATUM C) 0))))) (LIST (CHAR= "abc" "a") (CHAR-EQUAL "ABC" "a")))
[SIMPLE-TYPE-ERROR]: CHAR=: argument #1="abc" is not a character

[SIMPLE-TYPE-ERROR]: CHAR=: argument #1="a" is not a character

[SIMPLE-TYPE-ERROR]: CHAR-EQUAL: argument #1="ABC" is not a character

[SIMPLE-TYPE-ERROR]: CHAR-EQUAL: argument #1="a" is not a character

EQUAL-OK: (T T)
(HANDLER-BIND ((TYPE-ERROR (LAMBDA (C) (PRINC-ERROR C) (USE-VALUE (STRING (TYPE-ERROR-DATUM C)))))) (STRING-CONCAT "foo-" 'BAR "-baz"))
[SIMPLE-TYPE-ERROR]: STRING-CONCAT: argument BAR is not a string

EQUAL-OK: "foo-BAR-baz"
(HANDLER-BIND ((UNDEFINED-FUNCTION (LAMBDA (C) (PRINC-ERROR C) (STORE-VALUE (LAMBDA (NEW-CAR PAIR) (SETF (CAR PAIR) NEW-CAR)))))) (LET ((A '(1 . 2))) (SETF (ZZ A) 12) A))
[SIMPLE-UNDEFINED-FUNCTION]: FUNCTION: undefined function #1=(SETF ZZ)

EQUAL-OK: (12 . 2)
(FMAKUNBOUND '(SETF ZZ))
EQUAL-OK: (SETF ZZ)
(HANDLER-BIND ((UNDEFINED-FUNCTION (LAMBDA (C) (PRINC-ERROR C) (STORE-VALUE #'CAR)))) (ZZ '(1 . 2)))
[SIMPLE-UNDEFINED-FUNCTION]: EVAL: undefined function ZZ

EQL-OK: 1
(FMAKUNBOUND 'ZZ)
EQL-OK: ZZ
(DEFUN USE-VALUE-READ (C) (PRINC-ERROR C) (USE-VALUE (READ-FROM-STRING (ETYPECASE C (SOURCE-PROGRAM-ERROR (SOURCE-PROGRAM-ERROR-FORM C)) (TYPE-ERROR (TYPE-ERROR-DATUM C)) (CELL-ERROR (CELL-ERROR-NAME C))))))
EQL-OK: USE-VALUE-READ
(LET ((TABLE (COPY-READTABLE NIL))) (AND (EQ :UPCASE (READTABLE-CASE TABLE)) (SETF (READTABLE-CASE TABLE) :INVERT) (LET ((COPY (COPY-READTABLE TABLE))) (AND (NOT (EQ TABLE COPY)) (EQ (READTABLE-CASE COPY) :INVERT)))))
EQL-OK: T
(HANDLER-BIND ((TYPE-ERROR #'USE-VALUE-READ)) (SETF (READTABLE-CASE (COPY-READTABLE NIL)) ":UPCASE"))
[SIMPLE-TYPE-ERROR]: SYSTEM::SET-READTABLE-CASE: new value #1=":UPCASE" should be :UPCASE, :DOWNCASE, :PRESERVE or :INVERT.

EQL-OK: :UPCASE
(HANDLER-BIND ((ERROR (HANDLER-USE-VALUE '+))) (EVAL '#'"+"))
[SIMPLE-SOURCE-PROGRAM-ERROR]: FUNCTION: #1="+" is not a function name; try using a symbol instead

EQL-OK: #<SYSTEM-FUNCTION +>
(HANDLER-BIND ((ERROR #'USE-VALUE-READ)) (FUNCALL "+" 1 2 3))
[SIMPLE-TYPE-ERROR]: FUNCALL: #1="+" is not a function name; try using a symbol instead

EQL-OK: 6
(HANDLER-BIND ((TYPE-ERROR #'USE-VALUE-READ)) (PROGV '("foo") '(123) FOO))
[SIMPLE-TYPE-ERROR]: PROGV: #1="foo" is not a symbol

EQL-OK: 123
(HANDLER-BIND ((PROGRAM-ERROR (HANDLER-USE-VALUE 'ZZ))) (PROGV '(:CONST-VAR) '(123) ZZ))
[SIMPLE-SOURCE-PROGRAM-ERROR]: PROGV: :CONST-VAR is a constant, may not be used as a variable

EQL-OK: 123
(LET ((FORM '(PROGV '("foo" :CONST) '(123 321) (+ FOO ZZ)))) (HANDLER-BIND ((TYPE-ERROR #'USE-VALUE-READ) (PROGRAM-ERROR (HANDLER-USE-VALUE 'ZZ))) (LIST (EVAL FORM) FORM)))
[SIMPLE-TYPE-ERROR]: PROGV: #1="foo" is not a symbol

[SIMPLE-SOURCE-PROGRAM-ERROR]: PROGV: :CONST is a constant, may not be used as a variable

EQUAL-OK: (444 (PROGV '("foo" :CONST) '(123 321) (+ FOO ZZ)))
(HANDLER-BIND ((TYPE-ERROR #'USE-VALUE-READ)) (MULTIPLE-VALUE-SETQ (BAZ "foo") (VALUES 123 321)) (LIST FOO BAZ))
[SIMPLE-TYPE-ERROR]: MULTIPLE-VALUE-SETQ: #1="foo" is not a symbol

EQUAL-OK: (321 123)
(HANDLER-BIND ((PROGRAM-ERROR (HANDLER-USE-VALUE 'ZZ))) (SETQ :CONST-VAR 125) ZZ)
[SIMPLE-SOURCE-PROGRAM-ERROR]: SETQ: :CONST-VAR is a constant, may not be used as a variable

EQL-OK: 125
(HANDLER-BIND ((PROGRAM-ERROR (HANDLER-USE-VALUE '(ZZ 48)))) (LET (("foo" 32)) ZZ))
[SIMPLE-SOURCE-PROGRAM-ERROR]: LET: illegal variable specification #1=("foo" 32)

EQL-OK: 48
(HANDLER-BIND ((PROGRAM-ERROR (HANDLER-USE-VALUE 'ZZ))) (LET ((:CONST-VAR 64)) ZZ))
[SIMPLE-SOURCE-PROGRAM-ERROR]: LET: :CONST-VAR is a constant, may not be used as a variable

EQL-OK: 64
(HANDLER-BIND ((TYPE-ERROR #'USE-VALUE-READ) (SOURCE-PROGRAM-ERROR #'USE-VALUE-READ)) (FUNCALL "CAR" '(1 . 1)))
[SIMPLE-TYPE-ERROR]: FUNCALL: #1="CAR" is not a function name; try using a symbol instead

EQL-OK: 1
(HANDLER-BIND ((TYPE-ERROR #'USE-VALUE-READ) (SOURCE-PROGRAM-ERROR #'USE-VALUE-READ)) (SETQ "FOO" 1) (SYMBOL-VALUE 'FOO))
[SIMPLE-TYPE-ERROR]: SETQ: #1="FOO" is not a symbol

EQL-OK: 1
(LET ((COUNT 5)) (FLET ((HANDLER (C) (PRINC-ERROR C) (DECF COUNT) (USE-VALUE (IF (ZEROP COUNT) 'X COUNT)))) (HANDLER-BIND ((PROGRAM-ERROR #'HANDLER) (TYPE-ERROR #'HANDLER)) (SETQ :CONST-VAR 12))) (LIST COUNT X))
[SIMPLE-SOURCE-PROGRAM-ERROR]: SETQ: :CONST-VAR is a constant, may not be used as a variable

[SIMPLE-TYPE-ERROR]: SETQ: 4 is not a symbol

[SIMPLE-TYPE-ERROR]: SETQ: 3 is not a symbol

[SIMPLE-TYPE-ERROR]: SETQ: 2 is not a symbol

[SIMPLE-TYPE-ERROR]: SETQ: 1 is not a symbol

EQUAL-OK: (0 12)
(FLET ((MHT (TEST) (MAKE-HASH-TABLE :TEST TEST))) (CHECK-USE-VALUE MHT EQL BAZONK :TEST EQUALP))
[SIMPLE-TYPE-ERROR]: MAKE-HASH-TABLE: Illegal :TEST argument BAZONK

EQL-OK: T
(FLET ((MHT (W) (MAKE-HASH-TABLE :WEAK W))) (CHECK-USE-VALUE MHT NIL BAZONK :TEST EQUALP))
[SIMPLE-TYPE-ERROR]: MAKE-HASH-TABLE: argument BAZONK should be :KEY-OR-VALUE, :KEY-AND-VALUE, :VALUE, :KEY or NIL.

EQL-OK: T
(FLET ((MHT (S) (MAKE-HASH-TABLE :SIZE S))) (CHECK-USE-VALUE MHT 10 BAZONK :TEST EQUALP))
[SIMPLE-TYPE-ERROR]: MAKE-HASH-TABLE: :SIZE argument should be a fixnum >=0, not BAZONK

EQL-OK: T
(FLET ((MHT (RS) (MAKE-HASH-TABLE :REHASH-SIZE RS))) (CHECK-USE-VALUE MHT 2.0d0 BAZONK :TEST EQUALP))
[SIMPLE-TYPE-ERROR]: MAKE-HASH-TABLE: :REHASH-SIZE argument should be an integer or a float > 1, not BAZONK

EQL-OK: T
(FLET ((MHT (TR) (MAKE-HASH-TABLE :REHASH-THRESHOLD TR))) (CHECK-USE-VALUE MHT 0.5d0 BAZONK :TEST EQUALP))
[SIMPLE-TYPE-ERROR]: MAKE-HASH-TABLE: :REHASH-THRESHOLD argument should be a real between 0 and 1, not BAZONK

EQL-OK: T
(HANDLER-BIND ((PROGRAM-ERROR (HANDLER-USE-VALUE '1+)) (TYPE-ERROR (HANDLER-USE-VALUE '1-))) (LIST (EVAL '(1 10)) (FUNCALL 1 100) (APPLY 1 '(1000))))
[SIMPLE-SOURCE-PROGRAM-ERROR]: EVAL: 1 is not a function name; try using a symbol instead

[SIMPLE-TYPE-ERROR]: FUNCALL: 1 is not a function name; try using a symbol instead

[SIMPLE-TYPE-ERROR]: APPLY: 1 is not a function name; try using a symbol instead

EQUAL-OK: (11 99 999)
(PROGN (MAKUNBOUND 'BAR) (HANDLER-BIND ((UNBOUND-VARIABLE (LAMBDA (C) (PRINC-ERROR C) (STORE-VALUE 41)))) (1+ BAR)))
[SIMPLE-UNBOUND-VARIABLE]: :LAMBDA: variable BAR has no value

EQL-OK: 42
BAR
EQL-OK: 41
(PROGN (DEFCLASS ZOT NIL (ZOT-FOO)) (SETQ BAR (MAKE-INSTANCE 'ZOT)) (HANDLER-BIND ((UNBOUND-SLOT (LAMBDA (C) (PRINC-ERROR C) (STORE-VALUE 41)))) (1+ (SLOT-VALUE BAR 'ZOT-FOO))))
[SIMPLE-UNBOUND-SLOT]: SLOT-VALUE: The slot ZOT-FOO of #1=#<ZOT #xF465193E> has no value
EQL-OK: 42
(SLOT-VALUE BAR 'ZOT-FOO)
EQL-OK: 41
(PROGN (DEFINE-CONDITION XYZZY NIL ((F1 :ACCESSOR MY-F1 :INITARG :F1-IS)) (:REPORT (LAMBDA (C S) (FORMAT S "~1Txyzzy: My f1 is ~A" (MY-F1 C))))) (PRINC-TO-STRING (MAKE-CONDITION 'XYZZY :F1-IS "a silly string")))
EQUAL-OK: " xyzzy: My f1 is a silly string"
(LET* ((P1 (MAKE-PACKAGE "PACK-1" :USE NIL)) (P2 (MAKE-PACKAGE "PACK-2" :USE NIL)) (P3 (MAKE-PACKAGE "PACK-3" :USE NIL)) (P4 (MAKE-PACKAGE "PACK-4" :USE NIL)) (P5 (MAKE-PACKAGE "PACK-5" :USE NIL)) (BAR-NAME (SYMBOL-NAME (GENSYM "BAR-"))) (FOO1 (INTERN "FOO" P1)) (FOO2 (INTERN "FOO" P2)) (BAR1 (INTERN BAR-NAME P1)) (BAR2 (INTERN BAR-NAME P2)) (BAR3 (INTERN BAR-NAME P3)) (BAR4 (INTERN BAR-NAME P4)) (S12 (INTERN "SYM-1" P2)) (S22 (INTERN "SYM-2" P2)) (S13 (INTERN "SYM-1" P3)) (S23 (INTERN "SYM-2" P3)) (S14 (INTERN "SYM-1" P4)) (S24 (INTERN "SYM-2" P4)) (S15 (INTERN "SYM-1" P5)) (S25 (INTERN "SYM-2" P5))) (EXPORT (LIST S12 S22) P2) (EXPORT (LIST S13 S23) P3) (EXPORT (LIST S14 S24) P4) (HANDLER-BIND ((PACKAGE-ERROR (LAMBDA (C) (PRINC-ERROR C) (INVOKE-RESTART :PACK-3)))) (USE-PACKAGE (LIST P2 P3 P4) P1)) (ASSERT (NULL (SET-EXCLUSIVE-OR (LIST P2 P3 P4) (PACKAGE-USE-LIST P1)))) (ASSERT (EQ (FIND-SYMBOL "SYM-1" P1) S13)) (ASSERT (EQ (FIND-SYMBOL "SYM-2" P1) S23)) (HANDLER-BIND ((PACKAGE-ERROR (LAMBDA (C) (PRINC-ERROR C) (INVOKE-RESTART 'IMPORT)))) (EXPORT S15 P1)) (ASSERT (EQ (FIND-SYMBOL "SYM-1" P1) S15)) (HANDLER-BIND ((PACKAGE-ERROR (LAMBDA (C) (PRINC-ERROR C) (INVOKE-RESTART :PACK-2)))) (EXPORT FOO2 P2)) (ASSERT (EQ (FIND-SYMBOL "FOO" P1) FOO2)) (ASSERT (NULL (SET-EXCLUSIVE-OR (LIST BAR1 BAR2 BAR3 BAR4) (FIND-ALL-SYMBOLS BAR-NAME)))) (HANDLER-BIND ((PACKAGE-ERROR (LAMBDA (C) (PRINC-ERROR C) (INVOKE-RESTART :PACK-1)))) (EXPORT BAR2 P2)) (ASSERT (EQ (FIND-SYMBOL BAR-NAME P1) BAR1)) (EXPORT BAR3 P3) (EXPORT BAR4 P4) (HANDLER-BIND ((PACKAGE-ERROR (LAMBDA (C) (PRINC-ERROR C) (INVOKE-RESTART :PACK-4)))) (UNINTERN BAR1 P1)) (ASSERT (EQ (FIND-SYMBOL BAR-NAME P1) BAR4)) (DELETE-PACKAGE P5) (HANDLER-BIND ((PACKAGE-ERROR (LAMBDA (C) (PRINC-ERROR C) (CONTINUE C)))) (DELETE-PACKAGE P2) (DELETE-PACKAGE P3) (DELETE-PACKAGE P4)) (DELETE-PACKAGE P1))
[SIMPLE-PACKAGE-ERROR]: (USE-PACKAGE (#<PACKAGE PACK-4> #<PACKAGE PACK-3> #<PACKAGE PACK-2>) #1=#<PACKAGE PACK-1>): 2 name conflicts remain
Which symbol with name "SYM-2" should be accessible in #1#?

[SIMPLE-PACKAGE-ERROR]: (USE-PACKAGE (#<PACKAGE PACK-4> #<PACKAGE PACK-3> #<PACKAGE PACK-2>) #1=#<PACKAGE PACK-1>): 1 name conflicts remain
Which symbol with name "SYM-1" should be accessible in #1#?

[SIMPLE-PACKAGE-ERROR]: EXPORT: Symbol PACK-5::SYM-1 should be imported into #1=#<PACKAGE PACK-1> before being exported.

[SIMPLE-PACKAGE-ERROR]: Importing PACK-5::SYM-1 into #1=#<PACKAGE PACK-1> produces a name conflict with PACK-3:SYM-1 and other symbols.

[SIMPLE-PACKAGE-ERROR]: Exporting PACK-2::FOO from #1=#<PACKAGE PACK-2> produces a name conflict with PACK-1::FOO from #2=#<PACKAGE PACK-1>.
You may choose which symbol should be accessible in #2#.

[SIMPLE-PACKAGE-ERROR]: Exporting PACK-2::BAR-22372 from #1=#<PACKAGE PACK-2> produces a name conflict with PACK-1::BAR-22372 from #2=#<PACKAGE PACK-1>.
You may choose which symbol should be accessible in #2#.

[SIMPLE-PACKAGE-ERROR]: Uninterning PACK-1::BAR-22372 from #1=#<PACKAGE PACK-1> uncovers a name conflict.
You may choose the symbol in favour of which to resolve the conflict.

[SIMPLE-PACKAGE-ERROR]: DELETE-PACKAGE: #1=#<PACKAGE PACK-2> is used by #<PACKAGE PACK-1>.
[SIMPLE-PACKAGE-ERROR]: DELETE-PACKAGE: #1=#<PACKAGE PACK-3> is used by #<PACKAGE PACK-1>.
[SIMPLE-PACKAGE-ERROR]: DELETE-PACKAGE: #1=#<PACKAGE PACK-4> is used by #<PACKAGE PACK-1>.
EQL-OK: T
(LET ((P1 (MAKE-PACKAGE "PACK" :USE NIL)) P2 P3 P4 (BAR-NAME (SYMBOL-NAME (GENSYM "BAR-")))) (HANDLER-BIND ((PACKAGE-ERROR (LAMBDA (C) (PRINC-ERROR C) (INVOKE-RESTART 'CONTINUE)))) (ASSERT (EQ P1 (MAKE-PACKAGE "PACK")))) (HANDLER-BIND ((PACKAGE-ERROR (LAMBDA (C) (PRINC-ERROR C) (INVOKE-RESTART 'READ "KCAP")))) (SETQ P2 (MAKE-PACKAGE "PACK"))) (ASSERT (STRING= "KCAP" (PACKAGE-NAME P2))) (HANDLER-BIND ((PACKAGE-ERROR (LAMBDA (C) (PRINC-ERROR C) (INVOKE-RESTART 'CONTINUE)))) (SETQ P3 (MAKE-PACKAGE "FOO" :NICKNAMES (LIST "CL" BAR-NAME "KCAP")))) (ASSERT (EQUAL (LIST BAR-NAME) (PACKAGE-NICKNAMES P3))) (HANDLER-BIND ((PACKAGE-ERROR (LAMBDA (C) (PRINC-ERROR C) (INVOKE-RESTART 'READ "ZOT")))) (SETQ P4 (MAKE-PACKAGE "QUUX" :NICKNAMES (LIST "CL" BAR-NAME "KCAP")))) (ASSERT (EQUAL (LIST "ZOT") (PACKAGE-NICKNAMES P4))) (DELETE-PACKAGE P1) (DELETE-PACKAGE P2) (DELETE-PACKAGE P3) (DELETE-PACKAGE P4))
[SIMPLE-PACKAGE-ERROR]: MAKE-PACKAGE: a package with name "PACK" already exists.

[SIMPLE-PACKAGE-ERROR]: MAKE-PACKAGE: a package with name "PACK" already exists.

[SIMPLE-PACKAGE-ERROR]: MAKE-PACKAGE: a package with name "KCAP" already exists.

[SIMPLE-PACKAGE-ERROR]: MAKE-PACKAGE: a package with name "CL" already exists.

[SIMPLE-PACKAGE-ERROR]: MAKE-PACKAGE: a package with name "KCAP" already exists.

[SIMPLE-PACKAGE-ERROR]: MAKE-PACKAGE: a package with name "BAR-22437" already exists.

[SIMPLE-PACKAGE-ERROR]: MAKE-PACKAGE: a package with name "CL" already exists.

EQL-OK: T
(HANDLER-BIND ((ERROR (HANDLER-USE-VALUE '(9 8 7 6)))) (LIST (BUTLAST 123 2) (BUTLAST '#1=(1 2 3 . #1#) 2) (LAST 123 2) (LAST '#1# 2)))
[SIMPLE-TYPE-ERROR]: BUTLAST: 123 is not a list

[SIMPLE-ERROR]: BUTLAST: #1=(1 2 3 . #1#) is a circular list

[SIMPLE-TYPE-ERROR]: LAST: 123 is not a list

[SIMPLE-ERROR]: LAST: #1=(1 2 3 . #1#) is a circular list

EQUAL-OK: ((9 8) (9 8) (7 6) (7 6))
(HANDLER-BIND ((ERROR (HANDLER-USE-VALUE 'CHECK-USE-VALUE))) (SETF (DOCUMENTATION '(CHECK-USE-VALUE) 'FUNCTION) "docstring for check-use-value") (DOCUMENTATION 'CHECK-USE-VALUE 'FUNCTION))
[SIMPLE-SOURCE-PROGRAM-ERROR]: (SETF DOCUMENTATION): #1=(CHECK-USE-VALUE) is not a function name; try using a symbol instead

EQUAL-OK: "docstring for check-use-value"
(HANDLER-BIND ((ERROR (HANDLER-USE-VALUE 'USE-VALUE-READ))) (SETF (DOCUMENTATION '(USE-VALUE-READ) 'FUNCTION) "docstring for use-value-read") (DOCUMENTATION 'USE-VALUE-READ 'FUNCTION))
[SIMPLE-SOURCE-PROGRAM-ERROR]: (SETF DOCUMENTATION): #1=(USE-VALUE-READ) is not a function name; try using a symbol instead

EQUAL-OK: "docstring for use-value-read"
(MACROLET ((U (V) `(HANDLER-USE-VALUE ,V))) (HANDLER-BIND ((TYPE-ERROR (U "docstring for use-value-read")) (ERROR (U 'USE-VALUE-READ))) (STRING= '(FOO) (DOCUMENTATION '(FOO) 'FUNCTION))))
[SIMPLE-SOURCE-PROGRAM-ERROR]: DOCUMENTATION: #1=(FOO) is not a function name; try using a symbol instead

[SIMPLE-TYPE-ERROR]: STRING=: argument #1=(FOO) should be a string, a symbol or a character

EQL-OK: T
(SYMBOL-MACROLET ((U (HANDLER-USE-VALUE 1))) (HANDLER-BIND ((TYPE-ERROR U)) (+ 'SYMBOL-MACROLET 'HANDLER-BIND 'TYPE-ERROR)))
[SIMPLE-TYPE-ERROR]: +: SYMBOL-MACROLET is not a number

[SIMPLE-TYPE-ERROR]: +: HANDLER-BIND is not a number

[SIMPLE-TYPE-ERROR]: +: TYPE-ERROR is not a number

EQL-OK: 3
(SYMBOLS-CLEANUP '(CHECK-USE-VALUE USE-VALUE-READ ZOT FOO BAR BAZ XYZZY))
EQL-OK: NIL
RUN-TEST: finished "restarts" (0 errors out of 71 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"excepsit.tst" @1>
(INVOKE-RESTART 'NONEXISTENT-RESTART)
OK: CONTROL-ERROR
(ACOS 'X)
OK: TYPE-ERROR
(ACOSH 'X)
OK: TYPE-ERROR
(PROGN (DEFGENERIC FOO01 (X)) (DEFMETHOD FOO01 ((X NUMBER)) T) (LET ((M (FIND-METHOD #'FOO01 NIL (LIST (FIND-CLASS 'NUMBER))))) (REMOVE-METHOD #'FOO01 M) (DEFGENERIC FOO01 (X Y)) (ADD-METHOD #'FOO01 M)))
OK: ERROR
(ADJUST-ARRAY (MAKE-ARRAY 5 :ADJUSTABLE T) 4 :FILL-POINTER 1)
OK: TYPE-ERROR
(ADJUST-ARRAY "foo" 10 :FILL-POINTER T)
OK: TYPE-ERROR
(ADJUSTABLE-ARRAY-P '(X))
OK: TYPE-ERROR
(ALPHA-CHAR-P 33)
OK: TYPE-ERROR
(ALPHANUMERICP 33)
OK: TYPE-ERROR
(ARRAY-DIMENSIONS '(X))
OK: TYPE-ERROR
(ARRAY-DISPLACEMENT '(X))
OK: TYPE-ERROR
(ARRAY-ELEMENT-TYPE '(X))
OK: TYPE-ERROR
(ARRAY-HAS-FILL-POINTER-P '(X))
OK: TYPE-ERROR
(ARRAY-RANK '(X))
OK: TYPE-ERROR
(ARRAY-TOTAL-SIZE '(X))
OK: TYPE-ERROR
(ASH 3/4 2)
OK: TYPE-ERROR
(ASH 3 4.0)
OK: TYPE-ERROR
(ASIN 'X)
OK: TYPE-ERROR
(ASINH 'X)
OK: TYPE-ERROR
(ATAN 'X)
OK: TYPE-ERROR
(ATAN #C(0 0.4) 3.4)
OK: TYPE-ERROR
(ATAN -4 #C(3 4))
OK: TYPE-ERROR
(ATANH 'X)
OK: TYPE-ERROR
(BOOLE 'X 3 4)
OK: TYPE-ERROR
(BOOLE BOOLE-AND 3/4 -7)
OK: TYPE-ERROR
(BOOLE BOOLE-SET 5 #C(-3 4))
OK: TYPE-ERROR
(BOTH-CASE-P 33)
OK: TYPE-ERROR
(BOUNDP 47)
OK: TYPE-ERROR
(BUTLAST '(A B C) -1)
OK: TYPE-ERROR
(BUTLAST '#(A B C))
OK: TYPE-ERROR
(CAR 'X)
OK: TYPE-ERROR
(CDR '#(A B C))
OK: TYPE-ERROR
(CDADAR '((X Y)))
OK: TYPE-ERROR
(PROGN (DEFGENERIC FOO04 (X)) (DEFMETHOD FOO04 ((X REAL)) 'OK) (DEFMETHOD FOO04 ((X INTEGER)) (CALL-NEXT-METHOD (SQRT X))) (FOO04 -1))
OK: ERROR
(PROGN (DEFGENERIC FOO041 (X)) (DEFMETHOD FOO041 ((X REAL)) 'OK) (DEFMETHOD FOO041 ((X INTEGER)) (CALL-NEXT-METHOD (SQRT X))) (FOO04 2))
OK: ERROR
(CCASE 'X)
OK: TYPE-ERROR
(CHAR-CODE 33)
OK: TYPE-ERROR
(CHAR-DOWNCASE 33)
OK: TYPE-ERROR
(CHAR-EQUAL)
OK: PROGRAM-ERROR
(CHAR-GREATERP)
OK: PROGRAM-ERROR
(CHAR-LESSP)
OK: PROGRAM-ERROR
(CHAR-NAME 33)
OK: TYPE-ERROR
(CHAR-NOT-EQUAL)
OK: PROGRAM-ERROR
(CHAR-NOT-GREATERP)
OK: PROGRAM-ERROR
(CHAR-NOT-LESSP)
OK: PROGRAM-ERROR
(CHAR-UPCASE 33)
OK: TYPE-ERROR
(CHAR/=)
OK: PROGRAM-ERROR
(CHAR<)
OK: PROGRAM-ERROR
(CHAR<=)
OK: PROGRAM-ERROR
(CHAR=)
OK: PROGRAM-ERROR
(CHAR>)
OK: PROGRAM-ERROR
(CHAR>=)
OK: PROGRAM-ERROR
(CHARACTER "abc")
OK: TYPE-ERROR
(CHARACTER "")
OK: TYPE-ERROR
(CLEAR-INPUT '*TERMINAL-IO*)
OK: TYPE-ERROR
(CLEAR-OUTPUT '*TERMINAL-IO*)
OK: TYPE-ERROR
(COERCE '(A B C) '(VECTOR * 4))
OK: TYPE-ERROR
(COERCE '#(A B C) '(VECTOR * 4))
OK: TYPE-ERROR
(COERCE '(A B C) '(VECTOR * 2))
OK: TYPE-ERROR
(COERCE '#(A B C) '(VECTOR * 2))
OK: TYPE-ERROR
(COERCE "foo" '(STRING 2))
OK: TYPE-ERROR
(COERCE '#(#\a #\b #\c) '(STRING 2))
OK: TYPE-ERROR
(COERCE '(0 1) '(SIMPLE-BIT-VECTOR 3))
OK: TYPE-ERROR
(COERCE NIL 'NIL)
OK: TYPE-ERROR
(COERCE '#:NONEXISTENT 'FUNCTION)
OK: ERROR
(COERCE 'AND 'FUNCTION)
OK: ERROR
(COERCE -1 '(INTEGER 0 100))
OK: TYPE-ERROR
(COMPILE-FILE "./12836123.lisp")
OK: FILE-ERROR
(CONCATENATE 'SYMBOL)
OK: ERROR
(CONCATENATE '(STRING 3) "ab" "cd")
OK: TYPE-ERROR
(COPY-PPRINT-DISPATCH 'X)
OK: TYPE-ERROR
(COPY-SEQ 'X)
OK: TYPE-ERROR
(COPY-SYMBOL #\x)
OK: TYPE-ERROR
(COS 'X)
OK: TYPE-ERROR
(COSH 'X)
OK: TYPE-ERROR
(COUNT #\x 'X)
OK: TYPE-ERROR
(LET ((X NIL)) (CTYPECASE X))
OK: TYPE-ERROR
(DECODE-FLOAT 2/3)
OK: TYPE-ERROR
(DEFCLASS FOO05 NIL (A B A))
OK: PROGRAM-ERROR
(DEFCLASS FOO06 NIL (A B) (:DEFAULT-INITARGS X A X B))
OK: PROGRAM-ERROR
(DEFCLASS FOO07 NIL ((A :ALLOCATION :CLASS :ALLOCATION :CLASS)))
OK: PROGRAM-ERROR
(DEFCLASS FOO08 NIL ((A :INITFORM 42 :INITFORM 42)))
OK: PROGRAM-ERROR
(DEFCLASS FOO09 NIL ((A :TYPE REAL :TYPE REAL)))
OK: PROGRAM-ERROR
(DEFCLASS FOO10 NIL ((A :DOCUMENTATION "bla" :DOCUMENTATION "blabla")))
OK: PROGRAM-ERROR
(DEFGENERIC IF (X))
OK: PROGRAM-ERROR
(DEFUN IF NIL)
OK: PROGRAM-ERROR
(PROGN (DEFMACRO FOO11 (X) X) (DEFGENERIC FOO11 (X)))
OK: PROGRAM-ERROR
(DEFUN ! (A B C) (+ A B C))
OK: PACKAGE-ERROR
(DEFTYPE CAR NIL T)
OK: PACKAGE-ERROR
(PROCLAIM '(DECLARATION CAR))
OK: PACKAGE-ERROR
(DEFGENERIC OTHERWISE (X))
OK: PACKAGE-ERROR
(DEFMETHOD OTHERWISE ((X INTEGER)) (1+ X))
OK: PACKAGE-ERROR
(DEFMACRO OTHERWISE (&BODY BODY) `(PROGN ,@BODY))
OK: PACKAGE-ERROR
(DEFUN FOO11 ((X Y 1) Z) (LIST X Y Z))
OK: PROGRAM-ERROR
(LAMBDA ((X Y 1) Z) (LIST X Y Z))
OK: PROGRAM-ERROR
(PROGN (DEFUN FOO12 (X) X) (DEFGENERIC FOO12 (X)))
OK: PROGRAM-ERROR
(DEFGENERIC FOO13 (X Y &REST L) (:METHOD (X Y)))
OK: ERROR
(DEFGENERIC FOO14 (X) (:DOCUMENTATION "bla") (:DOCUMENTATION "blabla"))
OK: PROGRAM-ERROR
(DEFGENERIC FOO15 (X) (:MY-OPTION T))
OK: PROGRAM-ERROR
(PROGN (DEFVAR FOO16-1) (DEFINE-SYMBOL-MACRO FOO16-1 T))
OK: PROGRAM-ERROR
(PROGN (DEFINE-SYMBOL-MACRO FOO16-2 T) (DEFVAR FOO16-2))
OK: PROGRAM-ERROR
(DEFINE-SYMBOL-MACRO :FOO16-3 T)
OK: PROGRAM-ERROR
(DEFMETHOD IF (X) NIL)
OK: ERROR
(PROGN (DEFMACRO FOO17 (X) X) (DEFMETHOD FOO17 (X) NIL))
OK: ERROR
(PROGN (DEFUN FOO18 (X) X) (DEFMETHOD FOO18 (X) NIL))
OK: ERROR
(PROGN (DEFGENERIC FOO19 (X)) (DEFMETHOD FOO19 (X Y) NIL))
OK: ERROR
(PROGN (DEFPACKAGE "FOO20") (DEFPACKAGE "FOO21" (:NICKNAMES "FOO20")))
OK: PACKAGE-ERROR
(DEFPACKAGE "FOO22" (:SIZE 20) (:SIZE 20))
OK: PROGRAM-ERROR
(DEFPACKAGE "FOO23" (:DOCUMENTATION "bla") (:DOCUMENTATION "blabla"))
OK: PROGRAM-ERROR
(DEFPACKAGE "FOO24" (:MY-OPTION T))
OK: PROGRAM-ERROR
(DEFPACKAGE "FOO25" (:SHADOW "IF") (:INTERN "IF"))
OK: PROGRAM-ERROR
(DEFPACKAGE "FOO26" (:SHADOW "IF") (:IMPORT-FROM "USER" "IF"))
OK: PROGRAM-ERROR
(DEFPACKAGE "FOO27" (:SHADOW "IF") (:SHADOWING-IMPORT-FROM "USER" "IF"))
OK: PROGRAM-ERROR
(DEFPACKAGE "FOO28" (:INTERN "IF") (:IMPORT-FROM "USER" "IF"))
OK: PROGRAM-ERROR
(DEFPACKAGE "FOO29" (:INTERN "IF") (:SHADOWING-IMPORT-FROM "USER" "IF"))
OK: PROGRAM-ERROR
(DEFPACKAGE "FOO30" (:IMPORT-FROM "USER" "IF") (:SHADOWING-IMPORT-FROM "USER" "IF"))
OK: PROGRAM-ERROR
(DEFPACKAGE "FOO31" (:EXPORT "IF") (:INTERN "IF"))
OK: PROGRAM-ERROR
(DEFSTRUCT FOO32 A FOO20::A)
OK: PROGRAM-ERROR
(PROGN (DEFSTRUCT FOO33 A) (DEFSTRUCT (FOO34 (:INCLUDE FOO33)) FOO20::A))
OK: PROGRAM-ERROR
(DELETE #\x 'X)
OK: TYPE-ERROR
(DELETE-DUPLICATES 'ABBA)
OK: TYPE-ERROR
(PROGN (WITH-OPEN-FILE (S "./excepsit-tst-foo35.tmp" :DIRECTION :OUTPUT)) (DELETE-FILE "./excepsit-tst-foo35.tmp/bar"))
OK: FILE-ERROR
(DESTRUCTURING-BIND (A) '(1 2) A)
OK: ERROR
(DESTRUCTURING-BIND ((A B C)) '((1)) `(,A ,B ,B))
OK: ERROR
(ECASE 'X)
OK: TYPE-ERROR
(ELT 'X 0)
OK: TYPE-ERROR
(ELT "abc" 4)
OK: TYPE-ERROR
(ELT '(A B C) 4)
OK: TYPE-ERROR
(ELT '#(A B C) 4)
OK: TYPE-ERROR
(ELT (MAKE-ARRAY 3 :FILL-POINTER 3 :ADJUSTABLE T) 4)
OK: TYPE-ERROR
(ENDP 'X)
OK: TYPE-ERROR
(ENSURE-DIRECTORIES-EXIST "/*/")
OK: FILE-ERROR
(ERROR 42)
OK: TYPE-ERROR
(LET ((X NIL)) (ETYPECASE X))
OK: TYPE-ERROR
(EVERY '(LAMBDA (X) X) NIL)
OK: TYPE-ERROR
(EVERY #'IDENTITY 'X)
OK: TYPE-ERROR
(FBOUNDP '(PSETF AREF))
OK: TYPE-ERROR
(FDEFINITION '(PSETF AREF))
OK: TYPE-ERROR
(FDEFINITION '#:NONEXISTENT)
OK: UNDEFINED-FUNCTION
(FILE-AUTHOR "*")
OK: FILE-ERROR
(FILE-LENGTH *TERMINAL-IO*)
OK: TYPE-ERROR
(WITH-OPEN-FILE (S "./excepsit-tst-foo35.tmp" :DIRECTION :OUTPUT) (FILE-POSITION S 0.0))
OK: ERROR
(WITH-OPEN-FILE (S "./excepsit-tst-foo35.tmp" :DIRECTION :OUTPUT) (FILE-POSITION S -1))
OK: ERROR
(WITH-OPEN-FILE (S "./excepsit-tst-foo35.tmp" :DIRECTION :INPUT) (FILE-POSITION S (+ (FILE-LENGTH S) 1000)))
OK: ERROR
(DELETE-FILE "./excepsit-tst-foo35.tmp")
no error, value: #P"/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/tests/excepsit-tst-foo35.tmp"
OK: NULL
(FILE-WRITE-DATE "*")
OK: FILE-ERROR
(FILL 'X #\x)
OK: TYPE-ERROR
(FILL (MAKE-LIST 3) 'X :START NIL)
OK: TYPE-ERROR
(FILL (MAKE-LIST 3) 'X :START -1)
OK: TYPE-ERROR
(FILL (MAKE-LIST 3) 'X :START 1 :END -1)
OK: TYPE-ERROR
(FILL-POINTER "abc")
OK: TYPE-ERROR
(FIND #\x 'X)
OK: TYPE-ERROR
(FIND-CLASS '#:NONEXISTENT T)
OK: ERROR
(PROGN (DEFGENERIC FOO36 (X Y)) (FIND-METHOD #'FOO36 NIL (LIST (FIND-CLASS 'NUMBER))))
OK: ERROR
(PROGN (DEFGENERIC FOO37 (X)) (FIND-METHOD #'FOO37 NIL (LIST (FIND-CLASS 'NUMBER))))
OK: ERROR
(FINISH-OUTPUT '*TERMINAL-IO*)
OK: TYPE-ERROR
(FLOAT-DIGITS 2/3)
OK: TYPE-ERROR
(FLOAT-PRECISION 2/3)
OK: TYPE-ERROR
(FLOAT-RADIX 2/3)
OK: TYPE-ERROR
(FLOAT-SIGN 2/3)
OK: TYPE-ERROR
(FLOAT-SIGN -4.5 2/3)
OK: TYPE-ERROR
(FMAKUNBOUND '(PSETF AREF))
OK: TYPE-ERROR
(FORCE-OUTPUT '*TERMINAL-IO*)
OK: TYPE-ERROR
(FUNCALL 'FOO38)
OK: UNDEFINED-FUNCTION
(FUNCALL 'AND)
OK: UNDEFINED-FUNCTION
(GCD 4 3/4)
OK: TYPE-ERROR
(GENSYM #\x)
OK: TYPE-ERROR
(GENTEMP 'T)
OK: TYPE-ERROR
(GENTEMP "X" 24)
OK: TYPE-ERROR
(GET "a" 'X)
OK: TYPE-ERROR
(GET-DISPATCH-MACRO-CHARACTER #\0 #\#)
OK: ERROR
(GRAPHIC-CHAR-P 33)
OK: TYPE-ERROR
(HASH-TABLE-REHASH-SIZE *READTABLE*)
OK: TYPE-ERROR
(HASH-TABLE-REHASH-THRESHOLD *PACKAGE*)
OK: TYPE-ERROR
(HASH-TABLE-SIZE *RANDOM-STATE*)
OK: TYPE-ERROR
(HASH-TABLE-TEST '#(A B C))
OK: TYPE-ERROR
(IMAGPART #\c)
OK: TYPE-ERROR
(IN-PACKAGE "FOO39")
OK: PACKAGE-ERROR
(INPUT-STREAM-P (PATHNAME "abc"))
OK: TYPE-ERROR
(INTEGER-DECODE-FLOAT 2/3)
OK: TYPE-ERROR
(INTEGER-LENGTH 0.0)
OK: TYPE-ERROR
(INTERACTIVE-STREAM-P (PATHNAME "abc"))
OK: TYPE-ERROR
(INVOKE-RESTART 'FOO40)
OK: CONTROL-ERROR
(INVOKE-RESTART-INTERACTIVELY 'FOO41)
OK: CONTROL-ERROR
(ISQRT -1)
OK: TYPE-ERROR
(ISQRT #C(3 4))
OK: TYPE-ERROR
(LAST '(A B C) -1)
OK: TYPE-ERROR
(LCM 4/7 8)
OK: TYPE-ERROR
(LENGTH 'X)
OK: TYPE-ERROR
(LIST-LENGTH 'X)
OK: TYPE-ERROR
(LIST-LENGTH '(X . Y))
OK: TYPE-ERROR
(LOAD "./128347234.lsp")
OK: FILE-ERROR
(LOAD "*.lsp")
OK: FILE-ERROR
(LOAD-LOGICAL-PATHNAME-TRANSLATIONS "FOO41")
OK: ERROR
(LOGAND -3 2.3)
OK: TYPE-ERROR
(LOGBITP -1 5)
OK: TYPE-ERROR
(LOGBITP 2 3/7)
OK: TYPE-ERROR
(LOGCOUNT #*01010011)
OK: TYPE-ERROR
(LOGICAL-PATHNAME '#(#\A #\B))
OK: TYPE-ERROR
(LOGICAL-PATHNAME-TRANSLATIONS '#(#\A #\B))
OK: TYPE-ERROR
(LOGICAL-PATHNAME-TRANSLATIONS "FOO41")
OK: TYPE-ERROR
(LOWER-CASE-P 33)
OK: TYPE-ERROR
(MAKE-BROADCAST-STREAM (MAKE-STRING-INPUT-STREAM "abc"))
OK: TYPE-ERROR
(MAKE-CONCATENATED-STREAM (MAKE-STRING-OUTPUT-STREAM))
OK: TYPE-ERROR
(PROGN (DEFCLASS FOO42 NIL NIL) (MAKE-INSTANCE 'FOO42 :X 1))
OK: ERROR
(MAKE-LIST -1)
OK: TYPE-ERROR
(PROGN (DEFSTRUCT FOO43) (MAKE-LOAD-FORM (MAKE-FOO43)))
OK: ERROR
(MAKE-RANDOM-STATE 'X)
OK: TYPE-ERROR
(MAKE-SEQUENCE 'X 5)
OK: TYPE-ERROR
(MAKE-SEQUENCE 'SEQUENCE 5)
OK: TYPE-ERROR
(MAKE-SEQUENCE '(STRING 3) 4)
OK: TYPE-ERROR
(MAKE-SEQUENCE 'NULL 5)
OK: TYPE-ERROR
(MAKE-SEQUENCE 'CONS 0)
OK: TYPE-ERROR
(MAKE-SYMBOL 'X)
OK: TYPE-ERROR
(MAKE-SYNONYM-STREAM *TERMINAL-IO*)
OK: TYPE-ERROR
(MAKE-TWO-WAY-STREAM (MAKE-STRING-INPUT-STREAM "abc") (MAKE-STRING-INPUT-STREAM "def"))
OK: TYPE-ERROR
(MAKE-TWO-WAY-STREAM (MAKE-STRING-OUTPUT-STREAM) (MAKE-STRING-OUTPUT-STREAM))
OK: TYPE-ERROR
(MAKUNBOUND "xx")
OK: TYPE-ERROR
(MAP 'X #'IDENTITY "abc")
OK: TYPE-ERROR
(MAP '(STRING 3) #'IDENTITY "ab")
OK: TYPE-ERROR
(MAX 3 #C(4 0.0))
OK: TYPE-ERROR
(MAP 'LIST #'IDENTITY '(A B . C))
OK: TYPE-ERROR
(LENGTH '(A B . C))
OK: TYPE-ERROR
(REDUCE #'+ '(1 2 . 3))
OK: TYPE-ERROR
(MERGE '(VECTOR * 5) '(3 1) '(2 4) #'<)
OK: TYPE-ERROR
(MIN 3 #C(4 0.0))
OK: TYPE-ERROR
(MINUSP #C(4 -3/4))
OK: TYPE-ERROR
(MUFFLE-WARNING)
OK: CONTROL-ERROR
(NAME-CHAR '#(#\N #\u #\l))
OK: TYPE-ERROR
(NBUTLAST '(A B C) -1)
OK: TYPE-ERROR
(NBUTLAST '#(A B C))
OK: TYPE-ERROR
(NO-APPLICABLE-METHOD #'CONS)
OK: ERROR
(NO-NEXT-METHOD #'PRINT-OBJECT (FIND-METHOD #'PRINT-OBJECT NIL (LIST (FIND-CLASS 'STANDARD-OBJECT) (FIND-CLASS 'T))))
OK: ERROR
(NOTANY '(LAMBDA (X) X) NIL)
OK: TYPE-ERROR
(NOTANY #'IDENTITY 'X)
OK: TYPE-ERROR
(NOTEVERY '(LAMBDA (X) X) NIL)
OK: TYPE-ERROR
(NOTEVERY #'IDENTITY 'X)
OK: TYPE-ERROR
(NTHCDR 2 '(A . B))
OK: TYPE-ERROR
(ODDP 3.5)
OK: TYPE-ERROR
(PROGN (OPEN "/etc/passwd" :DIRECTION :INPUT :IF-EXISTS :ERROR) (/ 0))
OK: DIVISION-BY-ZERO
(PROGN (OPEN "/etc/nonexistent" :DIRECTION :INPUT :IF-EXISTS :ERROR) (/ 0))
OK: FILE-ERROR
(OPEN "./foo44nonexistent" :DIRECTION :INPUT :IF-DOES-NOT-EXIST :ERROR)
OK: FILE-ERROR
(OPEN "./*" :DIRECTION :INPUT)
OK: FILE-ERROR
(OPEN "/etc/mtab" :DIRECTION :INPUT :EXTERNAL-FORMAT 'MTAB-ENTRIES)
OK: ERROR
(OPEN-STREAM-P (PATHNAME "foo45"))
OK: TYPE-ERROR
(OUTPUT-STREAM-P (PATHNAME "foo46"))
OK: TYPE-ERROR
(PACKAGE-NAME 47)
OK: TYPE-ERROR
(PACKAGE-NICKNAMES (PATHNAME "foo47"))
OK: TYPE-ERROR
(PACKAGE-SHADOWING-SYMBOLS (VECTOR 'A 'B 'C))
OK: TYPE-ERROR
(PACKAGE-USE-LIST (LIST 'A 'B 'C))
OK: TYPE-ERROR
(PACKAGE-USED-BY-LIST (LIST 'A 'B 'C))
OK: TYPE-ERROR
(PARSE-INTEGER "x-y")
OK: ERROR
(PARSE-NAMESTRING (COERCE (LIST #\f #\o #\o (CODE-CHAR 0) #\4 #\8) 'STRING))
OK: PARSE-ERROR
(PARSE-NAMESTRING "foo48:a" (LOGICAL-PATHNAME "foo49:"))
OK: ERROR
(PARSE-NAMESTRING "sys:foo.bar." "sys")
OK: PARSE-ERROR
(PATHNAME-MATCH-P 34 "*")
OK: TYPE-ERROR
(PATHNAME-MATCH-P "x" 34)
OK: TYPE-ERROR
(PEEK-CHAR NIL (MAKE-STRING-INPUT-STREAM "") T)
OK: END-OF-FILE
(PEEK-CHAR #\Space (MAKE-STRING-INPUT-STREAM "") T)
OK: END-OF-FILE
(PHASE 'X)
OK: TYPE-ERROR
(PLUSP #C(0 4.2))
OK: TYPE-ERROR
(PPRINT-DISPATCH NIL T)
OK: TYPE-ERROR
(PPRINT-EXIT-IF-LIST-EXHAUSTED)
OK: ERROR
(PPRINT-INDENT NIL 2)
OK: ERROR
(LET ((X (MAKE-STRING-OUTPUT-STREAM))) (PPRINT-LOGICAL-BLOCK (X NIL :PREFIX 24)))
OK: TYPE-ERROR
(LET ((X (MAKE-STRING-OUTPUT-STREAM))) (PPRINT-LOGICAL-BLOCK (X NIL :PREFIX "a" :PER-LINE-PREFIX "b")))
OK: ERROR
(PPRINT-NEWLINE :FRESH)
OK: TYPE-ERROR
(PPRINT-POP)
OK: ERROR
(PPRINT-TAB :PARAGRAPH 0 1)
OK: ERROR
(LET ((*PRINT-READABLY* T)) (PRINT-UNREADABLE-OBJECT (NIL *STANDARD-OUTPUT*)))
OK: PRINT-NOT-READABLE
(LET ((*PRINT-PATHNAMES-ANSI* T) (*PARSE-NAMESTRING-DOT-FILE* :NAME)) (WRITE-TO-STRING (MAKE-PATHNAME :NAME "foo.bar") :READABLY T))
OK: PRINT-NOT-READABLE
(LET ((*PRINT-PATHNAMES-ANSI* T) (*PARSE-NAMESTRING-DOT-FILE* :TYPE)) (WRITE-TO-STRING (MAKE-PATHNAME :NAME "foo.bar") :READABLY T))
OK: PRINT-NOT-READABLE
(LET ((*PRINT-PATHNAMES-ANSI* T) (*PARSE-NAMESTRING-DOT-FILE* :NAME)) (WRITE-TO-STRING (MAKE-PATHNAME :TYPE "bar") :READABLY T))
OK: PRINT-NOT-READABLE
(LET ((*PRINT-PATHNAMES-ANSI* T) (*PARSE-NAMESTRING-DOT-FILE* :TYPE)) (WRITE-TO-STRING (MAKE-PATHNAME :NAME "foo.bar") :READABLY T))
OK: PRINT-NOT-READABLE
(PRINT 1 2)
OK: TYPE-ERROR
(PROBE-FILE "*")
OK: FILE-ERROR
(PROVIDE 25)
OK: TYPE-ERROR
(RANDOM -2.3)
OK: TYPE-ERROR
(RANDOM 1/2)
OK: TYPE-ERROR
(RATIONAL #C(2.4 -0.3))
OK: TYPE-ERROR
(RATIONALIZE #C(2.4 -0.3))
OK: TYPE-ERROR
(READ (MAKE-STRING-INPUT-STREAM "((a b)") NIL)
OK: END-OF-FILE
(READ (MAKE-STRING-INPUT-STREAM " ") T)
OK: END-OF-FILE
(READ-BYTE (PATHNAME "foo50"))
OK: TYPE-ERROR
(READ-BYTE (MAKE-STRING-INPUT-STREAM "abc"))
OK: ERROR
(LET ((FILENAME "./excepsit-tst-foo51.bin")) (WITH-OPEN-FILE (S FILENAME :DIRECTION :OUTPUT :IF-EXISTS :OVERWRITE :IF-DOES-NOT-EXIST :CREATE)) (WITH-OPEN-FILE (S FILENAME :DIRECTION :INPUT :ELEMENT-TYPE '(UNSIGNED-BYTE 8)) (READ-BYTE S T)))
OK: END-OF-FILE
(DELETE-FILE "./excepsit-tst-foo51.bin")
no error, value: #P"/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/tests/excepsit-tst-foo51.bin"
OK: NULL
(LET ((FILENAME "./excepsit-tst-foo52.txt")) (WITH-OPEN-FILE (S FILENAME :DIRECTION :OUTPUT :IF-EXISTS :OVERWRITE :IF-DOES-NOT-EXIST :CREATE)) (WITH-OPEN-FILE (S FILENAME :DIRECTION :INPUT) (READ-CHAR S T)))
OK: END-OF-FILE
(DELETE-FILE "./excepsit-tst-foo52.txt")
no error, value: #P"/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/tests/excepsit-tst-foo52.txt"
OK: NULL
(LET ((FILENAME "./excepsit-tst-foo53.txt")) (WITH-OPEN-FILE (S FILENAME :DIRECTION :OUTPUT :IF-EXISTS :OVERWRITE :IF-DOES-NOT-EXIST :CREATE)) (WITH-OPEN-FILE (S FILENAME :DIRECTION :INPUT) (READ-CHAR-NO-HANG S T)))
OK: END-OF-FILE
(DELETE-FILE "./excepsit-tst-foo53.txt")
no error, value: #P"/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/tests/excepsit-tst-foo53.txt"
OK: NULL
(READ-FROM-STRING "((a b))" NIL NIL :END 6)
OK: END-OF-FILE
(READ-FROM-STRING " () () " T NIL :START 3 :END 4)
OK: END-OF-FILE
(READ-LINE (MAKE-STRING-INPUT-STREAM "") T)
OK: END-OF-FILE
(READ-SEQUENCE (LIST 1 2 3) (MAKE-STRING-INPUT-STREAM "") :START NIL)
OK: TYPE-ERROR
(READ-SEQUENCE (LIST 1 2 3) (MAKE-STRING-INPUT-STREAM "") :END -1)
OK: TYPE-ERROR
(READTABLE-CASE NIL)
OK: TYPE-ERROR
(SETF (READTABLE-CASE *READTABLE*) ':UNKNOWN)
OK: TYPE-ERROR
(WITH-INPUT-FROM-STRING (S "#1=(#1#)") (READ S NIL NIL T))
OK: ERROR
(REALPART #\c)
OK: TYPE-ERROR
(PROGN (DEFCLASS FOO54 NIL NIL) (REINITIALIZE-INSTANCE (MAKE-INSTANCE 'FOO54) :DUMMY 0))
OK: ERROR
(REMOVE #\x 'X)
OK: TYPE-ERROR
(REMOVE-DUPLICATES 'ABBA)
OK: TYPE-ERROR
(REMPROP 55 'ABC)
OK: TYPE-ERROR
(RPLACA NIL 5)
OK: TYPE-ERROR
(RPLACD NIL 5)
OK: TYPE-ERROR
(SCALE-FLOAT 2/3 -1)
OK: TYPE-ERROR
(SCALE-FLOAT 3.4 1.0)
OK: TYPE-ERROR
(SET-DISPATCH-MACRO-CHARACTER #\0 #\# #'(LAMBDA (S C N) (LOOP)))
OK: ERROR
(SET-PPRINT-DISPATCH '(VECTOR * 2) NIL #C(3 4))
OK: ERROR
(SIN 'X)
OK: TYPE-ERROR
(SINH 'X)
OK: TYPE-ERROR
(SLEEP -1)
OK: TYPE-ERROR
(PROGN (DEFCLASS FOO55 NIL (A)) (SLOT-BOUNDP (MAKE-INSTANCE 'FOO55) ':A))
OK: ERROR
(PROGN (DEFCLASS FOO56 NIL (A)) (SLOT-MAKUNBOUND (MAKE-INSTANCE 'FOO56) ':A))
OK: ERROR
(SLOT-MISSING (FIND-CLASS 'T) NIL ':A 'SETF)
OK: ERROR
(SLOT-UNBOUND (FIND-CLASS 'T) NIL ':A)
OK: UNBOUND-SLOT
(PROGN (DEFCLASS FOO57 NIL (A)) (SLOT-VALUE (MAKE-INSTANCE 'FOO57) ':A))
OK: ERROR
(SOME '(LAMBDA (X) X) NIL)
OK: TYPE-ERROR
(SOME #'IDENTITY 'X)
OK: TYPE-ERROR
(SPECIAL-OPERATOR-P '(AND X Y))
OK: TYPE-ERROR
(SPECIAL-OPERATOR-P '(SETF AREF))
OK: TYPE-ERROR
(SQRT 'X)
OK: TYPE-ERROR
(STANDARD-CHAR-P 33)
OK: TYPE-ERROR
(STREAM-ELEMENT-TYPE '*TERMINAL-IO)
OK: TYPE-ERROR
(STRING 33)
OK: TYPE-ERROR
(SYMBOL-FUNCTION 33)
OK: TYPE-ERROR
(SYMBOL-FUNCTION ':COMPILE)
OK: UNDEFINED-FUNCTION
(SYMBOL-MACROLET ((T TRUE)))
OK: PROGRAM-ERROR
(SYMBOL-MACROLET ((*PRINT-PRETTY* (STREAM-PRINT-PRETTY *STANDARD-OUTPUT*))))
OK: PROGRAM-ERROR
(SYMBOL-MACROLET ((FOO58 T)) (DECLARE (SPECIAL FOO58)))
OK: PROGRAM-ERROR
(SYMBOL-NAME '(SETF FOO59))
OK: TYPE-ERROR
(SYMBOL-PACKAGE '(SETF FOO59))
OK: TYPE-ERROR
(SYMBOL-PLIST '(SETF FOO59))
OK: TYPE-ERROR
(SYMBOL-VALUE '(SETF FOO59))
OK: TYPE-ERROR
(SYMBOL-VALUE '#:NONEXISTENT)
OK: UNBOUND-VARIABLE
(TAN 'X)
OK: TYPE-ERROR
(TANH 'X)
OK: TYPE-ERROR
(THROW '#:NONEXISTENT NIL)
OK: CONTROL-ERROR
(TRANSLATE-LOGICAL-PATHNAME (MAKE-BROADCAST-STREAM))
OK: TYPE-ERROR
(TRANSLATE-LOGICAL-PATHNAME (LOGICAL-PATHNAME "foo61:"))
OK: FILE-ERROR
(TRANSLATE-PATHNAME "x" "y" "z")
OK: ERROR
(TRUENAME "./foo62nonexistent")
OK: FILE-ERROR
(TRUENAME "./*/x")
OK: FILE-ERROR
(MAKE-PATHNAME :DIRECTORY '(:ABSOLUTE :UP))
OK: FILE-ERROR
(MAKE-PATHNAME :DIRECTORY '(:ABSOLUTE :BACK))
OK: FILE-ERROR
(MAKE-PATHNAME :DIRECTORY '(:ABSOLUTE :WILD-INFERIORS :UP))
OK: FILE-ERROR
(MAKE-PATHNAME :DIRECTORY '(:RELATIVE :WILD-INFERIORS :BACK))
OK: FILE-ERROR
(TYPEP NIL 'VALUES)
OK: ERROR
(TYPEP #'CONS '(VALUES T))
OK: ERROR
(TYPEP #'CONS '(FUNCTION (T T) LIST))
OK: ERROR
(UNEXPORT ':FOO63)
OK: PACKAGE-ERROR
(UNWIND-PROTECT (PROGN (DEFPACKAGE "FOO64" (:EXPORT "XYZ")) (DEFPACKAGE "FOO65" (:EXPORT "XYZ")) (DEFPACKAGE "FOO66" (:USE "FOO64" "FOO65") (:SHADOW "XYZ")) (UNINTERN (FIND-SYMBOL "XYZ" (FIND-PACKAGE "FOO66")) (FIND-PACKAGE "FOO66"))) (DELETE-PACKAGE "FOO20") (DELETE-PACKAGE "FOO66") (DELETE-PACKAGE "FOO65") (DELETE-PACKAGE "FOO64"))
OK: ERROR
(UPPER-CASE-P 33)
OK: TYPE-ERROR
(VALUES-LIST '(A B . C))
OK: TYPE-ERROR
(VALUES-LIST (MAKE-LIST MULTIPLE-VALUES-LIMIT))
OK: ERROR
(VECTOR-POP "foo67")
OK: TYPE-ERROR
(VECTOR-POP (MAKE-ARRAY 10 :FILL-POINTER 0))
OK: ERROR
(VECTOR-PUSH 'X (MAKE-ARRAY 10))
OK: ERROR
(LET ((A (MAKE-ARRAY 5 :FILL-POINTER 0))) (DOTIMES (I 100) (VECTOR-PUSH-EXTEND 'X A)))
OK: ERROR
(WARN (MAKE-CONDITION 'ERROR))
OK: TYPE-ERROR
(WARN (MAKE-CONDITION 'WARNING) "x")
OK: TYPE-ERROR
(WARN 'ERROR)
OK: TYPE-ERROR
(WILD-PATHNAME-P #\x)
OK: TYPE-ERROR
(WRITE-BYTE 1 (PATHNAME "foo67"))
OK: TYPE-ERROR
(WRITE-BYTE 1 (MAKE-STRING-OUTPUT-STREAM))
OK: ERROR
(WRITE-SEQUENCE '(#\1 #\2 #\3) (MAKE-STRING-OUTPUT-STREAM) :START NIL)
OK: TYPE-ERROR
(WRITE-SEQUENCE '(#\1 #\2 #\3) (MAKE-STRING-OUTPUT-STREAM) :END -1)
OK: TYPE-ERROR
(ZEROP 'X)
OK: TYPE-ERROR
(READ-FROM-STRING "-35/000")
OK: READER-ERROR
(READ-FROM-STRING "31e300")
OK: READER-ERROR
(WITH-STANDARD-IO-SYNTAX (LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "')")))
OK: READER-ERROR
(WITH-STANDARD-IO-SYNTAX (LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#<")))
OK: READER-ERROR
(WITH-STANDARD-IO-SYNTAX (LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "# ")))
OK: READER-ERROR
(WITH-STANDARD-IO-SYNTAX (LET ((*READ-SUPPRESS* T)) (READ-FROM-STRING "#)")))
OK: READER-ERROR
(LOOP FOR X IN '(1 2 3) FOR X IN '(4 5 6) COLLECT X)
OK: PROGRAM-ERROR
(LOOP FOR (X . X) IN '((1 2) (3 4) (5 6)) COLLECT X)
OK: PROGRAM-ERROR
(LOOP FOR E ACROSS (VECTOR '(X . Y) '(U . V)) FOR E FROM 1 TO 5 COLLECT E)
OK: PROGRAM-ERROR
(LOOP FOR X = '(NIL NIL NIL) FOR X = 1 COUNT X UNTIL T)
OK: PROGRAM-ERROR
(LOOP WITH FOO = '(A B) FOR X IN '(C D) COLLECTING X INTO FOO FINALLY (RETURN FOO))
OK: PROGRAM-ERROR
(LOOP 42)
OK: PROGRAM-ERROR
(FDEFINITION (LIST 'SETF (GENSYM)))
OK: UNDEFINED-FUNCTION
(PROCLAIM '(INTEGER . FOO))
OK: TYPE-ERROR
(ASH 1 66610000)
OK: ARITHMETIC-ERROR
(RATIONAL MOST-POSITIVE-LONG-FLOAT)
OK: ARITHMETIC-ERROR
(RATIONAL LEAST-POSITIVE-LONG-FLOAT)
OK: ARITHMETIC-ERROR
(RATIONAL MOST-NEGATIVE-LONG-FLOAT)
OK: ARITHMETIC-ERROR
(RATIONAL LEAST-NEGATIVE-LONG-FLOAT)
OK: ARITHMETIC-ERROR
(EXPT 10 10000000)
OK: ARITHMETIC-ERROR
(APPLY #'CAR '(1 2))
OK: PROGRAM-ERROR
(APPLY #'CAR '(1 . 2))
OK: PROGRAM-ERROR
(APPLY #'LIST 1 2)
OK: PROGRAM-ERROR
(APPLY #'WARN 1 2 3)
OK: PROGRAM-ERROR
(CONVERT-STRING-FROM-BYTES #(1) CHARSET:UCS-4)
OK: SIMPLE-CHARSET-TYPE-ERROR
(PROGN (SYMBOLS-CLEANUP '(FOO01 FOO02 FOO03 FOO04 FOO041 FOO05 FOO06 FOO07 FOO08 FOO09 FOO10 FOO11 FOO12 FOO13 FOO14 FOO15 FOO16-1 FOO16-2 FOO17 FOO18 FOO19 FOO32 FOO33 FOO34 FOO36 FOO37 FOO42 FOO43 FOO54 FOO55 FOO56 FOO57)) (ERROR "no error"))
OK: ERROR
RUN-TEST: finished "excepsit" (0 errors out of 395 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
RUN-TEST: started #<INPUT BUFFERED FILE-STREAM CHARACTER #P"weakptr.tst" @1>
(DEFMACRO WEAKPTR-TEST (&BODY BODY) `(PROGN (MAKE-LIST 100) ,@BODY (MAKE-ARRAY 200) (LIST (EQ CO (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-LIST (WEAK-POINTER-VALUE WP)) (MULTIPLE-VALUE-BIND (V P) (WEAK-POINTER-VALUE WPP) (LIST (TYPE-OF V) P)))))
EQL-OK: WEAKPTR-TEST
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER CO) WPP (MAKE-WEAK-POINTER WP)))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO NIL) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(WEAKPTR-TEST (SETQ CO (CONS 1 2) WP (MAKE-WEAK-POINTER 1)))
EQUAL-OK: (NIL (1 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO) (GC))
EQUAL-OK: (T ((1 . 2) T) (NULL NIL))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 2 (WEAK-POINTER-VALUE WPP) CO) (GC))
EQUAL-OK: (NIL (2 T) (CONS T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) CO (WEAK-POINTER-VALUE WPP) WP) (GC))
EQUAL-OK: (T ((1 . 2) T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) 3 CO NIL) (GC))
EQUAL-OK: (NIL (3 T) (WEAK-POINTER T))
(WEAKPTR-TEST (SETF (WEAK-POINTER-VALUE WP) (CONS 1 2)) (GC))
EQUAL-OK: (T (NIL NIL) (WEAK-POINTER T))
(LET ((*PRINT-CIRCLE* T)) (SETF (WEAK-POINTER-VALUE WP) WPP) (PRIN1-TO-STRING WP))
EQUAL-OK: "#1=#<WEAK-POINTER #<WEAK-POINTER #1#>>"
(SYMBOLS-CLEANUP '(CO WP WPP))
EQL-OK: NIL
(PROGN (GC) (SYMBOL-CLEANUP 'WEAKPTR-TEST))
EQL-OK: T
RUN-TEST: finished "weakptr" (0 errors out of 13 tests)
finished  56 files:               0 errors out of  11,912 tests
  1                   alltest:    0 errors out of     636 tests
  2                     array:    0 errors out of     290 tests
  3                  backquot:    0 errors out of      89 tests
  4                    bin-io:    0 errors out of      15 tests
  5                characters:    0 errors out of     221 tests
  6                      clos:    0 errors out of     496 tests
  7                   defhash:    0 errors out of       6 tests
  8                  encoding:    0 errors out of      36 tests
  9                    eval20:    0 errors out of      50 tests
 10                 ext-clisp:    0 errors out of     131 tests
 11                       ffi:    0 errors out of     263 tests
 12                    floeps:    0 errors out of      20 tests
 13                    format:    0 errors out of     307 tests
 14                 genstream:    0 errors out of      14 tests
 15                      hash:    0 errors out of      48 tests
 16                  hashlong:    0 errors out of      14 tests
 17                 hashtable:    0 errors out of      10 tests
 18                    iofkts:    0 errors out of     228 tests
 19                    lambda:    0 errors out of      90 tests
 20                  lists151:    0 errors out of     201 tests
 21                  lists152:    0 errors out of     255 tests
 22                  lists153:    0 errors out of       1 test
 23                  lists154:    0 errors out of      46 tests
 24                  lists155:    0 errors out of      25 tests
 25                  lists156:    0 errors out of      20 tests
 26                  list-set:    0 errors out of      10 tests
 27                      loop:    0 errors out of     178 tests
 28                    macro8:    0 errors out of     253 tests
 29                       map:    0 errors out of      64 tests
 30                       mop:    0 errors out of     225 tests
 31                    number:    0 errors out of   3,655 tests
 32                   number2:    0 errors out of     331 tests
 33                    pack11:    0 errors out of     211 tests
 34                      path:    0 errors out of     180 tests
 35                 readtable:    0 errors out of      27 tests
 36                      setf:    0 errors out of     210 tests
 37                    socket:    0 errors out of      92 tests
 38                   steele7:    0 errors out of      86 tests
 39                   streams:    0 errors out of     388 tests
 40               streamslong:    0 errors out of      25 tests
 41                   strings:    0 errors out of     409 tests
 42                  symbol10:    0 errors out of     152 tests
 43                   symbols:    0 errors out of       6 tests
 44                      time:    0 errors out of      22 tests
 45                     tread:    0 errors out of     395 tests
 46                      type:    0 errors out of     289 tests
 47                unportable:    0 errors out of      31 tests
 48                      weak:    0 errors out of     120 tests
 49                  weakhash:    0 errors out of      26 tests
 50                 weakhash2:    0 errors out of      47 tests
 51                 bind-eval:    0 errors out of      72 tests
 52              bind-compile:    0 errors out of      72 tests
 53                conditions:    0 errors out of      98 tests
 54                  restarts:    0 errors out of      71 tests
 55                  excepsit:    0 errors out of     395 tests
 56                   weakptr:    0 errors out of     260 tests
Real time: 49.068455 sec.
Run time: 43.758266 sec.
Space: 1075430488 Bytes
GC: 1673, GC time: 13.545354 sec.
0
Bye.
(echo *.erg | grep '*' >/dev/null) || (echo "Test failed:" ; ls -l *erg; echo "To see which tests failed, type" ; echo "    cat "`pwd`"/*.erg" ; exit 1)
echo "Test passed."
Test passed.
make: Leaving directory '/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/tests'
>>> clisp: Entering fakeroot...
test -d boot || (mkdir boot && cd boot && for f in lisp.a libgnu.a libnoreadline.a  modules.h modules.o lisp.run lispinit.mem; do ln -s ../$f .; done && (grep -v '^FILES=' ../makevars; fl=''; for f in lisp.a libgnu.a libnoreadline.a ; do fl=$fl' '`basename $f`; done; echo 'FILES='"'"$fl"'") > makevars) || (rm -rf boot ; exit 1)
mkdir -p i18n
m=`cd /home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/modules/i18n; pwd`; \
if test -f $m/configure && { test ! -f i18n/config.status || test -n "`find $m/configure -prune -newer i18n/config.status`"; } ; then ( cd i18n ;\
    cache=`echo i18n/ | sed -e 's,[^/][^/]*//*,../,g'`config.cache; \
    if test -f ${cache} ; then \
      . ${cache}; \
      if test "${ac_cv_env_CC_set}" = set; then CC="${ac_cv_env_CC_value}"; export CC; fi; \
      if test "${ac_cv_env_CFLAGS_set}" = set; then CFLAGS="${ac_cv_env_CFLAGS_value}"; export CFLAGS; fi; \
      if test "${ac_cv_env_LDFLAGS_set}" = set; then LDFLAGS="${ac_cv_env_LDFLAGS_value}"; export LDFLAGS; fi; \
      if test "${ac_cv_env_LIBS_set}" = set; then LIBS="${ac_cv_env_LIBS_value}"; export LIBS; fi; \
      if test "${ac_cv_env_CPPFLAGS_set}" = set; then CPPFLAGS="${ac_cv_env_CPPFLAGS_value}"; export CPPFLAGS; fi; \
      if test "${ac_cv_env_CPP_set}" = set; then CPP="${ac_cv_env_CPP_value}"; export CPP; fi; \
      if test "${ac_cv_env_CXX_set}" = set; then CXX="${ac_cv_env_CXX_value}"; export CXX; fi; \
      if test "${ac_cv_env_CXXFLAGS_set}" = set; then CXXFLAGS="${ac_cv_env_CXXFLAGS_value}"; export CXXFLAGS; fi; \
      if test "${ac_cv_env_X_LIBS_set}" = set; then X_LIBS="${ac_cv_env_X_LIBS_value}"; export X_LIBS; fi; \
      /bin/sh $m/configure --with-clisp="/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/clisp -K boot  -E UTF-8 -Emisc 1:1 -Epathname 1:1 -norc" --cache-file=${cache} --srcdir=$m '--disable-option-checking' '--prefix=/usr' '--with-ffcall' '--with-dynamic-ffi' '--disable-mmap' '--mandir=/usr/share/man' '--infodir=/usr/share/info' '--with-libsigsegv-prefix=/usr' '--with-libffcall-prefix=/usr' 'CC=cc' 'CFLAGS=-Os -fstack-clash-protection -Wformat -Werror=format-security' 'LDFLAGS=-Wl,--as-needed,-O1,--sort-common -Wl,-z,pack-relative-relocs';\
    else \
      /bin/sh $m/configure --srcdir=$m '--disable-option-checking' '--prefix=/usr' '--with-ffcall' '--with-dynamic-ffi' '--disable-mmap' '--mandir=/usr/share/man' '--infodir=/usr/share/info' '--with-libsigsegv-prefix=/usr' '--with-libffcall-prefix=/usr' 'CC=cc' 'CFLAGS=-Os -fstack-clash-protection -Wformat -Werror=format-security' 'LDFLAGS=-Wl,--as-needed,-O1,--sort-common -Wl,-z,pack-relative-relocs'; \
    fi ) ;\
fi; \
if test -f $m/Makefile && { test ! -f i18n/Makefile || test -n "`find $m/Makefile -prune -newer i18n/Makefile`"; } ; then \
  sed "s,srcdir = .,srcdir = $m," "$m/Makefile" > i18n/Makefile ; \
fi ; \
CLISP="/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/clisp -K boot  -E UTF-8 -Emisc 1:1 -Epathname 1:1 -norc" ; \
cd i18n ; make clisp-module CC="cc" CPPFLAGS=" -I/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/src -I/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/gllib -I/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/src/gllib" CFLAGS=" -Os -fstack-clash-protection -Wformat -Werror=format-security -W -Wswitch -Wcomment -Wpointer-arith -Wreturn-type -Wmissing-declarations -Wimplicit -Wno-sign-compare -Wno-format-nonliteral -Wno-shift-negative-value -O2 -fexpensive-optimizations -fwrapv -fno-strict-aliasing -DNO_SINGLEMAP -DNO_TRIVIALMAP -DNO_ASM -DENABLE_UNICODE -DDYNAMIC_FFI -DNO_GETTEXT" LDFLAGS=" -Wl,--as-needed,-O1,--sort-common -Wl,-z,pack-relative-relocs " LIBS="libgnu.a /usr/lib/libreadline.so -lncurses /usr/lib/libffcall.so  /usr/lib/libsigsegv.so  " RANLIB="ranlib" CLISP="$CLISP -q" SHREXT=.so
make[1]: Entering directory '/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/i18n'
make[1]: Nothing to be done for 'clisp-module'.
make[1]: Leaving directory '/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/i18n'
mkdir -p syscalls
m=`cd /home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/modules/syscalls; pwd`; \
if test -f $m/configure && { test ! -f syscalls/config.status || test -n "`find $m/configure -prune -newer syscalls/config.status`"; } ; then ( cd syscalls ;\
    cache=`echo syscalls/ | sed -e 's,[^/][^/]*//*,../,g'`config.cache; \
    if test -f ${cache} ; then \
      . ${cache}; \
      if test "${ac_cv_env_CC_set}" = set; then CC="${ac_cv_env_CC_value}"; export CC; fi; \
      if test "${ac_cv_env_CFLAGS_set}" = set; then CFLAGS="${ac_cv_env_CFLAGS_value}"; export CFLAGS; fi; \
      if test "${ac_cv_env_LDFLAGS_set}" = set; then LDFLAGS="${ac_cv_env_LDFLAGS_value}"; export LDFLAGS; fi; \
      if test "${ac_cv_env_LIBS_set}" = set; then LIBS="${ac_cv_env_LIBS_value}"; export LIBS; fi; \
      if test "${ac_cv_env_CPPFLAGS_set}" = set; then CPPFLAGS="${ac_cv_env_CPPFLAGS_value}"; export CPPFLAGS; fi; \
      if test "${ac_cv_env_CPP_set}" = set; then CPP="${ac_cv_env_CPP_value}"; export CPP; fi; \
      if test "${ac_cv_env_CXX_set}" = set; then CXX="${ac_cv_env_CXX_value}"; export CXX; fi; \
      if test "${ac_cv_env_CXXFLAGS_set}" = set; then CXXFLAGS="${ac_cv_env_CXXFLAGS_value}"; export CXXFLAGS; fi; \
      if test "${ac_cv_env_X_LIBS_set}" = set; then X_LIBS="${ac_cv_env_X_LIBS_value}"; export X_LIBS; fi; \
      /bin/sh $m/configure --with-clisp="/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/clisp -K boot  -E UTF-8 -Emisc 1:1 -Epathname 1:1 -norc" --cache-file=${cache} --srcdir=$m '--disable-option-checking' '--prefix=/usr' '--with-ffcall' '--with-dynamic-ffi' '--disable-mmap' '--mandir=/usr/share/man' '--infodir=/usr/share/info' '--with-libsigsegv-prefix=/usr' '--with-libffcall-prefix=/usr' 'CC=cc' 'CFLAGS=-Os -fstack-clash-protection -Wformat -Werror=format-security' 'LDFLAGS=-Wl,--as-needed,-O1,--sort-common -Wl,-z,pack-relative-relocs';\
    else \
      /bin/sh $m/configure --srcdir=$m '--disable-option-checking' '--prefix=/usr' '--with-ffcall' '--with-dynamic-ffi' '--disable-mmap' '--mandir=/usr/share/man' '--infodir=/usr/share/info' '--with-libsigsegv-prefix=/usr' '--with-libffcall-prefix=/usr' 'CC=cc' 'CFLAGS=-Os -fstack-clash-protection -Wformat -Werror=format-security' 'LDFLAGS=-Wl,--as-needed,-O1,--sort-common -Wl,-z,pack-relative-relocs'; \
    fi ) ;\
fi; \
if test -f $m/Makefile && { test ! -f syscalls/Makefile || test -n "`find $m/Makefile -prune -newer syscalls/Makefile`"; } ; then \
  sed "s,srcdir = .,srcdir = $m," "$m/Makefile" > syscalls/Makefile ; \
fi ; \
CLISP="/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/clisp -K boot  -E UTF-8 -Emisc 1:1 -Epathname 1:1 -norc" ; \
cd syscalls ; make clisp-module CC="cc" CPPFLAGS=" -I/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/src -I/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/gllib -I/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/src/gllib" CFLAGS=" -Os -fstack-clash-protection -Wformat -Werror=format-security -W -Wswitch -Wcomment -Wpointer-arith -Wreturn-type -Wmissing-declarations -Wimplicit -Wno-sign-compare -Wno-format-nonliteral -Wno-shift-negative-value -O2 -fexpensive-optimizations -fwrapv -fno-strict-aliasing -DNO_SINGLEMAP -DNO_TRIVIALMAP -DNO_ASM -DENABLE_UNICODE -DDYNAMIC_FFI -DNO_GETTEXT" LDFLAGS=" -Wl,--as-needed,-O1,--sort-common -Wl,-z,pack-relative-relocs " LIBS="libgnu.a /usr/lib/libreadline.so -lncurses /usr/lib/libffcall.so  /usr/lib/libsigsegv.so  " RANLIB="ranlib" CLISP="$CLISP -q" SHREXT=.so
make[1]: Entering directory '/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/syscalls'
make[1]: Nothing to be done for 'clisp-module'.
make[1]: Leaving directory '/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/syscalls'
mkdir -p regexp
m=`cd /home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/modules/regexp; pwd`; \
if test -f $m/configure && { test ! -f regexp/config.status || test -n "`find $m/configure -prune -newer regexp/config.status`"; } ; then ( cd regexp ;\
    cache=`echo regexp/ | sed -e 's,[^/][^/]*//*,../,g'`config.cache; \
    if test -f ${cache} ; then \
      . ${cache}; \
      if test "${ac_cv_env_CC_set}" = set; then CC="${ac_cv_env_CC_value}"; export CC; fi; \
      if test "${ac_cv_env_CFLAGS_set}" = set; then CFLAGS="${ac_cv_env_CFLAGS_value}"; export CFLAGS; fi; \
      if test "${ac_cv_env_LDFLAGS_set}" = set; then LDFLAGS="${ac_cv_env_LDFLAGS_value}"; export LDFLAGS; fi; \
      if test "${ac_cv_env_LIBS_set}" = set; then LIBS="${ac_cv_env_LIBS_value}"; export LIBS; fi; \
      if test "${ac_cv_env_CPPFLAGS_set}" = set; then CPPFLAGS="${ac_cv_env_CPPFLAGS_value}"; export CPPFLAGS; fi; \
      if test "${ac_cv_env_CPP_set}" = set; then CPP="${ac_cv_env_CPP_value}"; export CPP; fi; \
      if test "${ac_cv_env_CXX_set}" = set; then CXX="${ac_cv_env_CXX_value}"; export CXX; fi; \
      if test "${ac_cv_env_CXXFLAGS_set}" = set; then CXXFLAGS="${ac_cv_env_CXXFLAGS_value}"; export CXXFLAGS; fi; \
      if test "${ac_cv_env_X_LIBS_set}" = set; then X_LIBS="${ac_cv_env_X_LIBS_value}"; export X_LIBS; fi; \
      /bin/sh $m/configure --with-clisp="/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/clisp -K boot  -E UTF-8 -Emisc 1:1 -Epathname 1:1 -norc" --cache-file=${cache} --srcdir=$m '--disable-option-checking' '--prefix=/usr' '--with-ffcall' '--with-dynamic-ffi' '--disable-mmap' '--mandir=/usr/share/man' '--infodir=/usr/share/info' '--with-libsigsegv-prefix=/usr' '--with-libffcall-prefix=/usr' 'CC=cc' 'CFLAGS=-Os -fstack-clash-protection -Wformat -Werror=format-security' 'LDFLAGS=-Wl,--as-needed,-O1,--sort-common -Wl,-z,pack-relative-relocs';\
    else \
      /bin/sh $m/configure --srcdir=$m '--disable-option-checking' '--prefix=/usr' '--with-ffcall' '--with-dynamic-ffi' '--disable-mmap' '--mandir=/usr/share/man' '--infodir=/usr/share/info' '--with-libsigsegv-prefix=/usr' '--with-libffcall-prefix=/usr' 'CC=cc' 'CFLAGS=-Os -fstack-clash-protection -Wformat -Werror=format-security' 'LDFLAGS=-Wl,--as-needed,-O1,--sort-common -Wl,-z,pack-relative-relocs'; \
    fi ) ;\
fi; \
if test -f $m/Makefile && { test ! -f regexp/Makefile || test -n "`find $m/Makefile -prune -newer regexp/Makefile`"; } ; then \
  sed "s,srcdir = .,srcdir = $m," "$m/Makefile" > regexp/Makefile ; \
fi ; \
CLISP="/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/clisp -K boot  -E UTF-8 -Emisc 1:1 -Epathname 1:1 -norc" ; \
cd regexp ; make clisp-module CC="cc" CPPFLAGS=" -I/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/src -I/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/gllib -I/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/src/gllib" CFLAGS=" -Os -fstack-clash-protection -Wformat -Werror=format-security -W -Wswitch -Wcomment -Wpointer-arith -Wreturn-type -Wmissing-declarations -Wimplicit -Wno-sign-compare -Wno-format-nonliteral -Wno-shift-negative-value -O2 -fexpensive-optimizations -fwrapv -fno-strict-aliasing -DNO_SINGLEMAP -DNO_TRIVIALMAP -DNO_ASM -DENABLE_UNICODE -DDYNAMIC_FFI -DNO_GETTEXT" LDFLAGS=" -Wl,--as-needed,-O1,--sort-common -Wl,-z,pack-relative-relocs " LIBS="libgnu.a /usr/lib/libreadline.so -lncurses /usr/lib/libffcall.so  /usr/lib/libsigsegv.so  " RANLIB="ranlib" CLISP="$CLISP -q" SHREXT=.so
make[1]: Entering directory '/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/regexp'
make[1]: Nothing to be done for 'clisp-module'.
make[1]: Leaving directory '/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/regexp'
mkdir -p readline
m=`cd /home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/modules/readline; pwd`; \
if test -f $m/configure && { test ! -f readline/config.status || test -n "`find $m/configure -prune -newer readline/config.status`"; } ; then ( cd readline ;\
    cache=`echo readline/ | sed -e 's,[^/][^/]*//*,../,g'`config.cache; \
    if test -f ${cache} ; then \
      . ${cache}; \
      if test "${ac_cv_env_CC_set}" = set; then CC="${ac_cv_env_CC_value}"; export CC; fi; \
      if test "${ac_cv_env_CFLAGS_set}" = set; then CFLAGS="${ac_cv_env_CFLAGS_value}"; export CFLAGS; fi; \
      if test "${ac_cv_env_LDFLAGS_set}" = set; then LDFLAGS="${ac_cv_env_LDFLAGS_value}"; export LDFLAGS; fi; \
      if test "${ac_cv_env_LIBS_set}" = set; then LIBS="${ac_cv_env_LIBS_value}"; export LIBS; fi; \
      if test "${ac_cv_env_CPPFLAGS_set}" = set; then CPPFLAGS="${ac_cv_env_CPPFLAGS_value}"; export CPPFLAGS; fi; \
      if test "${ac_cv_env_CPP_set}" = set; then CPP="${ac_cv_env_CPP_value}"; export CPP; fi; \
      if test "${ac_cv_env_CXX_set}" = set; then CXX="${ac_cv_env_CXX_value}"; export CXX; fi; \
      if test "${ac_cv_env_CXXFLAGS_set}" = set; then CXXFLAGS="${ac_cv_env_CXXFLAGS_value}"; export CXXFLAGS; fi; \
      if test "${ac_cv_env_X_LIBS_set}" = set; then X_LIBS="${ac_cv_env_X_LIBS_value}"; export X_LIBS; fi; \
      /bin/sh $m/configure --with-clisp="/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/clisp -K boot  -E UTF-8 -Emisc 1:1 -Epathname 1:1 -norc" --cache-file=${cache} --srcdir=$m '--disable-option-checking' '--prefix=/usr' '--with-ffcall' '--with-dynamic-ffi' '--disable-mmap' '--mandir=/usr/share/man' '--infodir=/usr/share/info' '--with-libsigsegv-prefix=/usr' '--with-libffcall-prefix=/usr' 'CC=cc' 'CFLAGS=-Os -fstack-clash-protection -Wformat -Werror=format-security' 'LDFLAGS=-Wl,--as-needed,-O1,--sort-common -Wl,-z,pack-relative-relocs';\
    else \
      /bin/sh $m/configure --srcdir=$m '--disable-option-checking' '--prefix=/usr' '--with-ffcall' '--with-dynamic-ffi' '--disable-mmap' '--mandir=/usr/share/man' '--infodir=/usr/share/info' '--with-libsigsegv-prefix=/usr' '--with-libffcall-prefix=/usr' 'CC=cc' 'CFLAGS=-Os -fstack-clash-protection -Wformat -Werror=format-security' 'LDFLAGS=-Wl,--as-needed,-O1,--sort-common -Wl,-z,pack-relative-relocs'; \
    fi ) ;\
fi; \
if test -f $m/Makefile && { test ! -f readline/Makefile || test -n "`find $m/Makefile -prune -newer readline/Makefile`"; } ; then \
  sed "s,srcdir = .,srcdir = $m," "$m/Makefile" > readline/Makefile ; \
fi ; \
CLISP="/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/clisp -K boot  -E UTF-8 -Emisc 1:1 -Epathname 1:1 -norc" ; \
cd readline ; make clisp-module CC="cc" CPPFLAGS=" -I/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/src -I/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/gllib -I/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/src/gllib" CFLAGS=" -Os -fstack-clash-protection -Wformat -Werror=format-security -W -Wswitch -Wcomment -Wpointer-arith -Wreturn-type -Wmissing-declarations -Wimplicit -Wno-sign-compare -Wno-format-nonliteral -Wno-shift-negative-value -O2 -fexpensive-optimizations -fwrapv -fno-strict-aliasing -DNO_SINGLEMAP -DNO_TRIVIALMAP -DNO_ASM -DENABLE_UNICODE -DDYNAMIC_FFI -DNO_GETTEXT" LDFLAGS=" -Wl,--as-needed,-O1,--sort-common -Wl,-z,pack-relative-relocs " LIBS="libgnu.a /usr/lib/libreadline.so -lncurses /usr/lib/libffcall.so  /usr/lib/libsigsegv.so  " RANLIB="ranlib" CLISP="$CLISP -q" SHREXT=.so
make[1]: Entering directory '/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/readline'
make[1]: Nothing to be done for 'clisp-module'.
make[1]: Leaving directory '/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/readline'
rm -rf base
MAKE=make CLISP="/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/clisp -K boot  -E UTF-8 -Emisc 1:1 -Epathname 1:1 -norc" with_dynamic_modules=no ./clisp-link add boot base i18n syscalls regexp readline || (rm -rf base ; exit 1)
make[1]: Entering directory '/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/i18n'
make[1]: Nothing to be done for 'clisp-module'.
make[1]: Leaving directory '/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/i18n'
make[1]: Entering directory '/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/syscalls'
make[1]: Nothing to be done for 'clisp-module'.
make[1]: Leaving directory '/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/syscalls'
make[1]: Entering directory '/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/regexp'
make[1]: Nothing to be done for 'clisp-module'.
make[1]: Leaving directory '/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/regexp'
make[1]: Entering directory '/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/readline'
make[1]: Nothing to be done for 'clisp-module'.
make[1]: Leaving directory '/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/readline'
cc -I/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/src -I/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/gllib -I/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/src/gllib -Os -fstack-clash-protection -Wformat -Werror=format-security -W -Wswitch -Wcomment -Wpointer-arith -Wreturn-type -Wmissing-declarations -Wimplicit -Wno-sign-compare -Wno-format-nonliteral -Wno-shift-negative-value -O2 -fexpensive-optimizations -fwrapv -fno-strict-aliasing -DNO_SINGLEMAP -DNO_TRIVIALMAP -DNO_ASM -DENABLE_UNICODE -DDYNAMIC_FFI -DNO_GETTEXT -I/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/linkkit -c modules.c
cc -Os -fstack-clash-protection -Wformat -Werror=format-security -W -Wswitch -Wcomment -Wpointer-arith -Wreturn-type -Wmissing-declarations -Wimplicit -Wno-sign-compare -Wno-format-nonliteral -Wno-shift-negative-value -O2 -fexpensive-optimizations -fwrapv -fno-strict-aliasing -DNO_SINGLEMAP -DNO_TRIVIALMAP -DNO_ASM -DENABLE_UNICODE -DDYNAMIC_FFI -DNO_GETTEXT -Wl,--as-needed,-O1,--sort-common -Wl,-z,pack-relative-relocs modules.o readline.o /usr/lib/libreadline.so -lncurses regexi.o calls.o gettext.o lisp.a libgnu.a /usr/lib/libreadline.so -lncurses /usr/lib/libffcall.so /usr/lib/libsigsegv.so -o lisp.run
boot/lisp.run -B . -M boot/lispinit.mem -norc -q -i i18n/preload.lisp -i syscalls/preload.lisp -i regexp/preload.lisp -x (saveinitmem "base/lispinit.mem")
;; Loading file i18n/preload.lisp ...
;; Loaded file i18n/preload.lisp
;; Loading file syscalls/preload.lisp ...
;; Loaded file syscalls/preload.lisp
;; Loading file regexp/preload.lisp ...
;; Loaded file regexp/preload.lisp
;; Wrote the memory image into base/lispinit.mem (1,972,260 bytes)
Bytes permanently allocated:             89,472
Bytes currently in use:               1,881,384
Bytes available until next GC:           84,600
1881384 ;
84600 ;
89472 ;
2 ;
171752 ;
10554
base/lisp.run -B . -M base/lispinit.mem -norc -q -i i18n/i18n -i syscalls/posix -i regexp/regexp -i readline/readline -x (saveinitmem "base/lispinit.mem")
;; Loading file /home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/i18n/i18n.fas ...
;; Loaded file /home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/i18n/i18n.fas
;; Loading file /home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/syscalls/posix.fas ...
;; Loaded file /home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/syscalls/posix.fas
;; Loading file /home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/regexp/regexp.fas ...
;; Loaded file /home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/regexp/regexp.fas
;; Loading file /home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/readline/readline.fas ...
;; Loaded file /home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/readline/readline.fas
;; Wrote the memory image into base/lispinit.mem (2,245,416 bytes)
Bytes permanently allocated:             93,152
Bytes currently in use:               2,148,264
Bytes available until next GC:           14,304
2148264 ;
14304 ;
93152 ;
3 ;
910536 ;
14286
rm -rf full
MAKE=make CLISP="/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/clisp  -E UTF-8 -Emisc 1:1 -Epathname 1:1 -norc" ./clisp-link add base full  || (rm -rf full ; exit 1)
lisp.run lispinit.mem modules.h modules.o makevars lisp.a libgnu.a libnoreadline.a gettext.o calls.o regexi.o readline.o
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr/lib
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr/lib/clisp-2.49.95+
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr/lib/clisp-2.49.95+/data
/usr/bin/install -c -m 644 data/UnicodeDataFull.txt /home/buildozer/aports/community/clisp/pkg/clisp/usr/lib/clisp-2.49.95+/data/UnicodeDataFull.txt
/usr/bin/install -c -m 644 data/Symbol-Table.text /home/buildozer/aports/community/clisp/pkg/clisp/usr/lib/clisp-2.49.95+/data/Symbol-Table.text
(cd /home/buildozer/aports/community/clisp/pkg/clisp/usr/lib/clisp-2.49.95+ && rm -rf base full)
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr/lib/clisp-2.49.95+/build-aux
for f in  config.rpath depcomp; do /usr/bin/install -c -m 644 build-aux/$f /home/buildozer/aports/community/clisp/pkg/clisp/usr/lib/clisp-2.49.95+/build-aux/$f; done
for d in linkkit base full; do for f in $d/*; do \
  mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr/lib/clisp-2.49.95+/$d; \
  case $f in \
    */lisp.run) /usr/bin/install -c $f /home/buildozer/aports/community/clisp/pkg/clisp/usr/lib/clisp-2.49.95+/$f;; \
    *) /usr/bin/install -c -m 644 $f /home/buildozer/aports/community/clisp/pkg/clisp/usr/lib/clisp-2.49.95+/$f;; \
  esac; \
done; done
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr/bin
/usr/bin/install -c clisp-link /home/buildozer/aports/community/clisp/pkg/clisp/usr/bin/clisp-link
cc -I/home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/src -Os -fstack-clash-protection -Wformat -Werror=format-security -Wl,--as-needed,-O1,--sort-common -Wl,-z,pack-relative-relocs -DLISPLIBDIR='"/usr/lib/clisp-2.49.95+"' -DLOCALEDIR='""' clisp.c -o /home/buildozer/aports/community/clisp/pkg/clisp/usr/bin/clisp
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/emacs/site-lisp
/usr/bin/install -c -m 644 /home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/emacs/clisp-coding.el /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/emacs/site-lisp/clisp-coding.el
/usr/bin/install -c -m 644 /home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/emacs/clisp-indent.el /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/emacs/site-lisp/clisp-indent.el
/usr/bin/install -c -m 644 /home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/emacs/clisp-indent.lisp /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/emacs/site-lisp/clisp-indent.lisp
/usr/bin/install -c -m 644 /home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/emacs/clisp-ffi.el /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/emacs/site-lisp/clisp-ffi.el
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/vim/vimfiles/after/syntax
/usr/bin/install -c -m 644 /home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/emacs/lisp.vim /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/vim/vimfiles/after/syntax/lisp.vim
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/aclocal
/usr/bin/install -c -m 644 /home/buildozer/aports/community/clisp/src/clisp-f66220939ea7d36fd085384afa4a0ec44597d499/src/m4/clisp.m4 /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/aclocal/clisp.m4
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr/share
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/man
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/man/man1
/usr/bin/install -c -m 644 clisp.1 /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/man/man1/clisp.1
/usr/bin/install -c -m 644 clisp-link.1 /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/man/man1/clisp-link.1
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/doc/clisp
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/doc/clisp
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/doc/clisp
/usr/bin/install -c -m 644 clisp.html /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/doc/clisp/clisp.html
/usr/bin/install -c -m 644 clisp-link.html /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/doc/clisp/clisp-link.html
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/doc/clisp
/usr/bin/install -c -m 644 ANNOUNCE COPYRIGHT GNU-GPL SUMMARY NEWS README README.de README.es MAGIC.add /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/doc/clisp/
mkdir -p /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/doc/clisp/doc
/usr/bin/install -c -m 644 clisp.1 clisp.html clisp-link.1 clisp-link.html LISP-tutorial.txt CLOS-guide.txt impnotes.html impnotes.css clisp.png  /home/buildozer/aports/community/clisp/pkg/clisp/usr/share/doc/clisp/doc/
>>> clisp-dev*: Running split function dev...
'usr/share/aclocal' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/share/aclocal'
'usr/lib/clisp-2.49.95+/base/libnoreadline.a' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/base/libnoreadline.a'
'usr/lib/clisp-2.49.95+/base/lisp.a' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/base/lisp.a'
'usr/lib/clisp-2.49.95+/base/libgnu.a' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/base/libgnu.a'
'usr/lib/clisp-2.49.95+/full/libnoreadline.a' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/full/libnoreadline.a'
'usr/lib/clisp-2.49.95+/full/lisp.a' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/full/lisp.a'
'usr/lib/clisp-2.49.95+/full/libgnu.a' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/full/libgnu.a'
'usr/lib/clisp-2.49.95+/base/gettext.o' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/base/gettext.o'
'usr/lib/clisp-2.49.95+/base/calls.o' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/base/calls.o'
'usr/lib/clisp-2.49.95+/base/modules.h' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/base/modules.h'
'usr/lib/clisp-2.49.95+/base/modules.o' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/base/modules.o'
'usr/lib/clisp-2.49.95+/base/regexi.o' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/base/regexi.o'
'usr/lib/clisp-2.49.95+/base/readline.o' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/base/readline.o'
'usr/lib/clisp-2.49.95+/linkkit/modules.c' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/linkkit/modules.c'
'usr/lib/clisp-2.49.95+/linkkit/clisp.h' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/linkkit/clisp.h'
'usr/lib/clisp-2.49.95+/full/gettext.o' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/full/gettext.o'
'usr/lib/clisp-2.49.95+/full/calls.o' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/full/calls.o'
'usr/lib/clisp-2.49.95+/full/modules.h' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/full/modules.h'
'usr/lib/clisp-2.49.95+/full/modules.o' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/full/modules.o'
'usr/lib/clisp-2.49.95+/full/regexi.o' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/full/regexi.o'
'usr/lib/clisp-2.49.95+/full/readline.o' -> '/home/buildozer/aports/community/clisp/pkg/clisp-dev/usr/lib/clisp-2.49.95+/full/readline.o'
>>> clisp-dev*: Preparing subpackage clisp-dev...
>>> clisp-dev*: Stripping binaries
>>> clisp-dev*: Running postcheck for clisp-dev
>>> clisp-doc*: Running split function doc...
'usr/share/doc' -> '/home/buildozer/aports/community/clisp/pkg/clisp-doc/usr/share/doc'
'usr/share/man' -> '/home/buildozer/aports/community/clisp/pkg/clisp-doc/usr/share/man'
>>> clisp-doc*: Preparing subpackage clisp-doc...
>>> clisp-doc*: Running postcheck for clisp-doc
>>> clisp*: Running postcheck for clisp
>>> clisp*: Preparing package clisp...
>>> clisp*: Stripping binaries
>>> clisp-dev*: Scanning shared objects
>>> clisp-doc*: Scanning shared objects
>>> clisp*: Scanning shared objects
>>> clisp-dev*: Tracing dependencies...
>>> clisp-dev*: Package size: 7.5 MB
>>> clisp-dev*: Compressing data...
>>> clisp-dev*: Create checksum...
>>> clisp-dev*: Create clisp-dev-2.49.95_git250727-r1.apk
>>> WARNING: clisp-doc*: The -doc subpackage is unusually large, consider splitting it
>>> clisp-doc*: Tracing dependencies...
>>> clisp-doc*: Package size: 4.0 MB
>>> clisp-doc*: Compressing data...
>>> clisp-doc*: Create checksum...
>>> clisp-doc*: Create clisp-doc-2.49.95_git250727-r1.apk
>>> clisp*: Tracing dependencies...
	so:libc.musl-x86.so.1
	so:libffcall.so.0
	so:libncursesw.so.6
	so:libreadline.so.8
	so:libsigsegv.so.2
>>> clisp*: Package size: 11.2 MB
>>> clisp*: Compressing data...
>>> clisp*: Create checksum...
>>> clisp*: Create clisp-2.49.95_git250727-r1.apk
>>> clisp: Build complete at Sun, 24 Aug 2025 03:03:12 +0000 elapsed time 0h 4m 16s
>>> clisp: Cleaning up srcdir
>>> clisp: Cleaning up pkgdir
>>> clisp: Uninstalling dependencies...
( 1/11) Purging .makedepends-clisp (20250824.025857)
( 2/11) Purging ffcall (2.5-r0)
( 3/11) Purging libsigsegv-dev (2.15-r0)
( 4/11) Purging libsigsegv (2.15-r0)
( 5/11) Purging readline-dev (8.3.1-r0)
( 6/11) Purging libhistory (8.3.1-r0)
( 7/11) Purging ncurses-dev (6.5_p20250816-r0)
( 8/11) Purging libncurses++ (6.5_p20250816-r0)
( 9/11) Purging libpanelw (6.5_p20250816-r0)
(10/11) Purging libformw (6.5_p20250816-r0)
(11/11) Purging libmenuw (6.5_p20250816-r0)
busybox-1.37.0-r22.trigger: Executing script...
OK: 426 MiB in 104 packages
>>> clisp: Updating the community/x86 repository index...
>>> clisp: Signing the index...