From: Robert STRANDH
Subject: Problems with Gray streams on CMU CL
Date: Tue, 01 Aug 2000 00:00:00 +0000
Message-ID: <6wlmyhibwy.fsf@napperon.labri.u-bordeaux.fr> Hello,
I have problems loading the binaries for Gray streams into my CMU CL.
Here is what happens (sorry for the large amount of text, but I figure
it might be important):
CMU Common Lisp release x86-linux 2.4.19 8 February 2000 build 455, running on merlin
Send bug reports and questions to your local CMU CL maintainer,
or to ········@debian.org
or to ··········@cons.org. (prefered)
type (help) for help, (quit) to exit, and (demo) to see the demos
Loaded subsystems:
Python 1.0, target Intel x86
CLOS based on PCL version: September 16 92 PCL (f)
CLX X Library MIT R5.02
* (compile-file "gray-streams-class.lisp")
Python version 1.0, VM version Intel x86 on 01 AUG 00 11:08:39 am.
Compiling: /tmp/gray-streams-class.lisp 01 AUG 00 11:03:56 am
Comment: $Header: /b/cmucl/CVS-cmucl//src/pcl/gray-streams-class.lisp,v 1.2.2.1 1998/06/23 11:25:33 pw Exp $
Byte Compiling Top-Level Form:
Byte Compiling Top-Level Form:
gray-streams-class.x86f written.
Compilation finished in 0:00:00.
#p"/tmp/gray-streams-class.x86f"
NIL
NIL
* (compile-file "gray-streams.lisp")
Python version 1.0, VM version Intel x86 on 01 AUG 00 11:08:43 am.
Compiling: /tmp/gray-streams.lisp 01 AUG 00 11:03:56 am
Comment: $Header: /b/cmucl/CVS-cmucl//src/pcl/gray-streams.lisp,v 1.2.2.1 1998/06/23 11:25:33 pw Exp $
Converted |(PCL::FAST-METHOD STREAM-ELEMENT-TYPE (LISP-STREAM))|.
Compiling DEFMETHOD STREAM-ELEMENT-TYPE (LISP-STREAM):
Converted |(PCL::FAST-METHOD STREAM-ELEMENT-TYPE (FUNDAMENTAL-CHARACTER-STREAM))|.
Compiling DEFMETHOD STREAM-ELEMENT-TYPE (FUNDAMENTAL-CHARACTER-STREAM):
Byte Compiling Top-Level Form:
Converted |(PCL::FAST-METHOD PCL-OPEN-STREAM-P (LISP-STREAM))|.
Compiling DEFMETHOD PCL-OPEN-STREAM-P (LISP-STREAM):
Converted |(PCL::FAST-METHOD PCL-OPEN-STREAM-P (FUNDAMENTAL-STREAM))|.
Compiling DEFMETHOD PCL-OPEN-STREAM-P (FUNDAMENTAL-STREAM):
Byte Compiling Top-Level Form:
Converted |(PCL::FAST-METHOD PCL-CLOSE (LISP-STREAM))|.
Compiling DEFMETHOD PCL-CLOSE (LISP-STREAM):
Byte Compiling Top-Level Form:
Converted |(PCL::FAST-METHOD INPUT-STREAM-P (LISP-STREAM))|.
Compiling DEFMETHOD INPUT-STREAM-P (LISP-STREAM):
Converted |(PCL::FAST-METHOD INPUT-STREAM-P (FUNDAMENTAL-INPUT-STREAM))|.
Compiling DEFMETHOD INPUT-STREAM-P (FUNDAMENTAL-INPUT-STREAM):
Converted |(PCL::FAST-METHOD OUTPUT-STREAM-P (LISP-STREAM))|.
Compiling DEFMETHOD OUTPUT-STREAM-P (LISP-STREAM):
Byte Compiling Top-Level Form:
Converted |(PCL::FAST-METHOD OUTPUT-STREAM-P (FUNDAMENTAL-OUTPUT-STREAM))|.
Compiling DEFMETHOD OUTPUT-STREAM-P (FUNDAMENTAL-OUTPUT-STREAM):
Byte Compiling Top-Level Form:
Converted |(PCL::FAST-METHOD STREAM-READ-CHAR-NO-HANG (FUNDAMENTAL-CHARACTER-INPUT-STREAM))|.
Compiling DEFMETHOD STREAM-READ-CHAR-NO-HANG (FUNDAMENTAL-CHARACTER-INPUT-STREAM):
Converted |(PCL::FAST-METHOD STREAM-PEEK-CHAR (FUNDAMENTAL-CHARACTER-INPUT-STREAM))|.
Compiling DEFMETHOD STREAM-PEEK-CHAR (FUNDAMENTAL-CHARACTER-INPUT-STREAM):
Byte Compiling Top-Level Form:
Converted |(PCL::FAST-METHOD STREAM-LISTEN (FUNDAMENTAL-CHARACTER-INPUT-STREAM))|.
Compiling DEFMETHOD STREAM-LISTEN (FUNDAMENTAL-CHARACTER-INPUT-STREAM):
Converted |(PCL::FAST-METHOD STREAM-READ-LINE (FUNDAMENTAL-CHARACTER-INPUT-STREAM))|.
Compiling DEFMETHOD STREAM-READ-LINE (FUNDAMENTAL-CHARACTER-INPUT-STREAM):
Byte Compiling Top-Level Form:
[GC threshold exceeded with 2,017,384 bytes in use. Commencing GC.]
[GC completed with 489,392 bytes retained and 1,527,992 bytes freed.]
[GC will next occur when at least 2,489,392 bytes are in use.]
Converted |(PCL::FAST-METHOD STREAM-CLEAR-INPUT (FUNDAMENTAL-CHARACTER-INPUT-STREAM))|.
Compiling DEFMETHOD STREAM-CLEAR-INPUT (FUNDAMENTAL-CHARACTER-INPUT-STREAM):
Byte Compiling Top-Level Form:
Converted |(PCL::FAST-METHOD STREAM-LINE-LENGTH (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM))|.
Compiling DEFMETHOD STREAM-LINE-LENGTH (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM):
Byte Compiling Top-Level Form:
Converted |(PCL::FAST-METHOD STREAM-START-LINE-P (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM))|.
Compiling DEFMETHOD STREAM-START-LINE-P (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM):
Converted |(PCL::FAST-METHOD STREAM-WRITE-STRING (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM T))|.
Compiling DEFMETHOD STREAM-WRITE-STRING (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM T):
Byte Compiling Top-Level Form:
Converted |(PCL::FAST-METHOD STREAM-TERPRI (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM))|.
Compiling DEFMETHOD STREAM-TERPRI (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM):
Converted |(PCL::FAST-METHOD STREAM-FRESH-LINE (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM))|.
Compiling DEFMETHOD STREAM-FRESH-LINE (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM):
Byte Compiling Top-Level Form:
Converted |(PCL::FAST-METHOD STREAM-FINISH-OUTPUT (FUNDAMENTAL-OUTPUT-STREAM))|.
Compiling DEFMETHOD STREAM-FINISH-OUTPUT (FUNDAMENTAL-OUTPUT-STREAM):
Converted |(PCL::FAST-METHOD STREAM-FORCE-OUTPUT (FUNDAMENTAL-OUTPUT-STREAM))|.
Compiling DEFMETHOD STREAM-FORCE-OUTPUT (FUNDAMENTAL-OUTPUT-STREAM):
Byte Compiling Top-Level Form:
Converted |(PCL::FAST-METHOD STREAM-CLEAR-OUTPUT (FUNDAMENTAL-OUTPUT-STREAM))|.
Compiling DEFMETHOD STREAM-CLEAR-OUTPUT (FUNDAMENTAL-OUTPUT-STREAM):
Converted |(PCL::FAST-METHOD STREAM-ADVANCE-TO-COLUMN (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM T))|.
Compiling DEFMETHOD STREAM-ADVANCE-TO-COLUMN (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM T):
Byte Compiling Top-Level Form:
Compiling Load Time Value of (PCL::GET-MAKE-INSTANCE-FUNCTION-SYMBOL
'(CHARACTER-OUTPUT-STREAM # NIL)):
Converted MAKE-CHARACTER-OUTPUT-STREAM.
Compiling DEFUN MAKE-CHARACTER-OUTPUT-STREAM:
Converted |(PCL::FAST-METHOD OPEN-STREAM-P (CHARACTER-OUTPUT-STREAM))|.
Compiling DEFMETHOD OPEN-STREAM-P (CHARACTER-OUTPUT-STREAM):
Byte Compiling Top-Level Form:
Converted |(PCL::FAST-METHOD CLOSE (CHARACTER-OUTPUT-STREAM))|.
Compiling DEFMETHOD CLOSE (CHARACTER-OUTPUT-STREAM):
Converted |(PCL::FAST-METHOD INPUT-STREAM-P (CHARACTER-OUTPUT-STREAM))|.
Compiling DEFMETHOD INPUT-STREAM-P (CHARACTER-OUTPUT-STREAM):
Converted |(PCL::FAST-METHOD OUTPUT-STREAM-P (CHARACTER-OUTPUT-STREAM))|.
Compiling DEFMETHOD OUTPUT-STREAM-P (CHARACTER-OUTPUT-STREAM):
Converted |(PCL::FAST-METHOD STREAM-WRITE-CHAR (CHARACTER-OUTPUT-STREAM T))|.
Compiling DEFMETHOD STREAM-WRITE-CHAR (CHARACTER-OUTPUT-STREAM T):
Byte Compiling Top-Level Form:
Converted |(PCL::FAST-METHOD STREAM-LINE-COLUMN (CHARACTER-OUTPUT-STREAM))|.
Compiling DEFMETHOD STREAM-LINE-COLUMN (CHARACTER-OUTPUT-STREAM):
Converted |(PCL::FAST-METHOD STREAM-LINE-LENGTH (CHARACTER-OUTPUT-STREAM))|.
Compiling DEFMETHOD STREAM-LINE-LENGTH (CHARACTER-OUTPUT-STREAM):
Converted |(PCL::FAST-METHOD STREAM-FINISH-OUTPUT (CHARACTER-OUTPUT-STREAM))|.
Compiling DEFMETHOD STREAM-FINISH-OUTPUT (CHARACTER-OUTPUT-STREAM):
Byte Compiling Top-Level Form:
Converted |(PCL::FAST-METHOD STREAM-FORCE-OUTPUT (CHARACTER-OUTPUT-STREAM))|.
Compiling DEFMETHOD STREAM-FORCE-OUTPUT (CHARACTER-OUTPUT-STREAM):
Converted |(PCL::FAST-METHOD STREAM-CLEAR-OUTPUT (CHARACTER-OUTPUT-STREAM))|.
Compiling DEFMETHOD STREAM-CLEAR-OUTPUT (CHARACTER-OUTPUT-STREAM):
Compiling Load Time Value of (PCL::GET-MAKE-INSTANCE-FUNCTION-SYMBOL
'(CHARACTER-INPUT-STREAM # NIL)):
Converted MAKE-CHARACTER-INPUT-STREAM.
Compiling DEFUN MAKE-CHARACTER-INPUT-STREAM:
[GC threshold exceeded with 2,593,520 bytes in use. Commencing GC.]
[GC completed with 611,288 bytes retained and 1,982,232 bytes freed.]
[GC will next occur when at least 2,611,288 bytes are in use.]
Converted |(PCL::FAST-METHOD OPEN-STREAM-P (CHARACTER-INPUT-STREAM))|.
Compiling DEFMETHOD OPEN-STREAM-P (CHARACTER-INPUT-STREAM):
Converted |(PCL::FAST-METHOD CLOSE (CHARACTER-INPUT-STREAM))|.
Compiling DEFMETHOD CLOSE (CHARACTER-INPUT-STREAM):
Byte Compiling Top-Level Form:
Converted |(PCL::FAST-METHOD INPUT-STREAM-P (CHARACTER-INPUT-STREAM))|.
Compiling DEFMETHOD INPUT-STREAM-P (CHARACTER-INPUT-STREAM):
Converted |(PCL::FAST-METHOD OUTPUT-STREAM-P (CHARACTER-INPUT-STREAM))|.
Compiling DEFMETHOD OUTPUT-STREAM-P (CHARACTER-INPUT-STREAM):
Converted |(PCL::FAST-METHOD STREAM-READ-CHAR (CHARACTER-INPUT-STREAM))|.
Compiling DEFMETHOD STREAM-READ-CHAR (CHARACTER-INPUT-STREAM):
Byte Compiling Top-Level Form:
Compiling Creation Form for #<KERNEL::CLASS-CELL STREAM>:
Converted |(PCL::FAST-METHOD STREAM-UNREAD-CHAR (CHARACTER-INPUT-STREAM T))|.
Compiling DEFMETHOD STREAM-UNREAD-CHAR (CHARACTER-INPUT-STREAM T):
Converted |(PCL::FAST-METHOD STREAM-READ-CHAR-NO-HANG (CHARACTER-INPUT-STREAM))|.
Compiling DEFMETHOD STREAM-READ-CHAR-NO-HANG (CHARACTER-INPUT-STREAM):
Converted |(PCL::FAST-METHOD STREAM-CLEAR-INPUT (CHARACTER-INPUT-STREAM))|.
Compiling DEFMETHOD STREAM-CLEAR-INPUT (CHARACTER-INPUT-STREAM):
Byte Compiling Top-Level Form:
File: /tmp/gray-streams.lisp
In: DEFMETHOD INPUT-STREAM-P (CHARACTER-INPUT-STREAM)
(DEFMETHOD INPUT-STREAM-P
((STREAM CHARACTER-INPUT-STREAM))
(INPUT-STREAM-P (CHARACTER-INPUT-STREAM-LISP-STREAM STREAM)))
--> BLOCK MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
--> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
--> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS
==>
(LET* ((PCL::.ARGS-TAIL. NIL))
(DECLARE (IGNORABLE PCL::.ARGS-TAIL.))
(DECLARE (PCL::CLASS STREAM CHARACTER-INPUT-STREAM))
(PROGN STREAM)
...)
Warning: Undefined type: CHARACTER-INPUT-STREAM
In: DEFMETHOD CLOSE (CHARACTER-INPUT-STREAM)
(DEFMETHOD CLOSE
((STREAM CHARACTER-INPUT-STREAM) &KEY ABORT)
(CLOSE (CHARACTER-INPUT-STREAM-LISP-STREAM STREAM) :ABORT ABORT))
--> BLOCK MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
--> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
--> PCL::BIND-LEXICAL-METHOD-FUNCTIONS PCL::CALL-NEXT-METHOD-BIND LET FLET
--> PCL::BIND-ARGS
==>
(LET* ((PCL::.ARGS-TAIL. PCL::.REST-ARG.) (ABORT #))
(DECLARE (IGNORABLE PCL::.ARGS-TAIL.))
(DECLARE (PCL::CLASS STREAM CHARACTER-INPUT-STREAM))
(PROGN STREAM)
...)
Warning: Undefined type: CHARACTER-INPUT-STREAM
In: DEFMETHOD OPEN-STREAM-P (CHARACTER-INPUT-STREAM)
(DEFMETHOD OPEN-STREAM-P
((STREAM CHARACTER-INPUT-STREAM))
(OPEN-STREAM-P (CHARACTER-INPUT-STREAM-LISP-STREAM STREAM)))
--> BLOCK MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
--> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
--> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS
==>
(LET* ((PCL::.ARGS-TAIL. NIL))
(DECLARE (IGNORABLE PCL::.ARGS-TAIL.))
(DECLARE (PCL::CLASS STREAM CHARACTER-INPUT-STREAM))
(PROGN STREAM)
...)
Warning: Undefined type: CHARACTER-INPUT-STREAM
Warning: 5 more uses of undefined type CHARACTER-INPUT-STREAM.
File: /tmp/gray-streams.lisp
In: DEFMETHOD INPUT-STREAM-P (CHARACTER-OUTPUT-STREAM)
(DEFMETHOD INPUT-STREAM-P
((STREAM CHARACTER-OUTPUT-STREAM))
(INPUT-STREAM-P (CHARACTER-OUTPUT-STREAM-LISP-STREAM STREAM)))
--> BLOCK MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
--> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
--> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS
==>
(LET* ((PCL::.ARGS-TAIL. NIL))
(DECLARE (IGNORABLE PCL::.ARGS-TAIL.))
(DECLARE (PCL::CLASS STREAM CHARACTER-OUTPUT-STREAM))
(PROGN STREAM)
...)
Warning: Undefined type: CHARACTER-OUTPUT-STREAM
In: DEFMETHOD CLOSE (CHARACTER-OUTPUT-STREAM)
(DEFMETHOD CLOSE
((STREAM CHARACTER-OUTPUT-STREAM) &KEY ABORT)
(CLOSE (CHARACTER-OUTPUT-STREAM-LISP-STREAM STREAM) :ABORT ABORT))
--> BLOCK MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
--> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
--> PCL::BIND-LEXICAL-METHOD-FUNCTIONS PCL::CALL-NEXT-METHOD-BIND LET FLET
--> PCL::BIND-ARGS
==>
(LET* ((PCL::.ARGS-TAIL. PCL::.REST-ARG.) (ABORT #))
(DECLARE (IGNORABLE PCL::.ARGS-TAIL.))
(DECLARE (PCL::CLASS STREAM CHARACTER-OUTPUT-STREAM))
(PROGN STREAM)
...)
Warning: Undefined type: CHARACTER-OUTPUT-STREAM
In: DEFMETHOD OPEN-STREAM-P (CHARACTER-OUTPUT-STREAM)
(DEFMETHOD OPEN-STREAM-P
((STREAM CHARACTER-OUTPUT-STREAM))
(OPEN-STREAM-P (CHARACTER-OUTPUT-STREAM-LISP-STREAM STREAM)))
--> BLOCK MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
--> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
--> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS
==>
(LET* ((PCL::.ARGS-TAIL. NIL))
(DECLARE (IGNORABLE PCL::.ARGS-TAIL.))
(DECLARE (PCL::CLASS STREAM CHARACTER-OUTPUT-STREAM))
(PROGN STREAM)
...)
Warning: Undefined type: CHARACTER-OUTPUT-STREAM
Warning: 7 more uses of undefined type CHARACTER-OUTPUT-STREAM.
File: /tmp/gray-streams.lisp
In: DEFMETHOD STREAM-LISTEN (FUNDAMENTAL-CHARACTER-INPUT-STREAM)
(DEFMETHOD STREAM-LISTEN
((STREAM FUNDAMENTAL-CHARACTER-INPUT-STREAM))
(LET (#)
(WHEN # # T)))
--> BLOCK MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
--> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
--> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS
==>
(LET* ((PCL::.ARGS-TAIL. NIL))
(DECLARE (IGNORABLE PCL::.ARGS-TAIL.))
(DECLARE (PCL::CLASS STREAM FUNDAMENTAL-CHARACTER-INPUT-STREAM))
(PROGN STREAM)
...)
Warning: Undefined type: FUNDAMENTAL-CHARACTER-INPUT-STREAM
In: DEFMETHOD STREAM-PEEK-CHAR (FUNDAMENTAL-CHARACTER-INPUT-STREAM)
(DEFMETHOD STREAM-PEEK-CHAR
((STREAM FUNDAMENTAL-CHARACTER-INPUT-STREAM))
(LET (#)
(UNLESS # #)
CHAR))
--> BLOCK MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
--> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
--> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS
==>
(LET* ((PCL::.ARGS-TAIL. NIL))
(DECLARE (IGNORABLE PCL::.ARGS-TAIL.))
(DECLARE (PCL::CLASS STREAM FUNDAMENTAL-CHARACTER-INPUT-STREAM))
(PROGN STREAM)
...)
Warning: Undefined type: FUNDAMENTAL-CHARACTER-INPUT-STREAM
In: DEFMETHOD STREAM-READ-CHAR-NO-HANG (FUNDAMENTAL-CHARACTER-INPUT-STREAM)
(DEFMETHOD STREAM-READ-CHAR-NO-HANG
((STREAM FUNDAMENTAL-CHARACTER-INPUT-STREAM))
(STREAM-READ-CHAR STREAM))
--> BLOCK MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
--> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
--> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS
==>
(LET* ((PCL::.ARGS-TAIL. NIL))
(DECLARE (IGNORABLE PCL::.ARGS-TAIL.))
(DECLARE (PCL::CLASS STREAM FUNDAMENTAL-CHARACTER-INPUT-STREAM))
(PROGN STREAM)
...)
Warning: Undefined type: FUNDAMENTAL-CHARACTER-INPUT-STREAM
Warning: 2 more uses of undefined type FUNDAMENTAL-CHARACTER-INPUT-STREAM.
File: /tmp/gray-streams.lisp
In: DEFMETHOD STREAM-WRITE-STRING (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM T)
(DEFMETHOD STREAM-WRITE-STRING
((STREAM FUNDAMENTAL-CHARACTER-OUTPUT-STREAM) STRING &OPTIONAL
(START 0) END)
(DECLARE (STRING STRING) (FIXNUM START))
(LET (#) ..))
--> BLOCK MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
--> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
--> PCL::BIND-LEXICAL-METHOD-FUNCTIONS PCL::CALL-NEXT-METHOD-BIND LET FLET
--> PCL::BIND-ARGS
==>
(LET* ((PCL::.ARGS-TAIL. PCL::.REST-ARG.) (START #) (END #))
(DECLARE (IGNORABLE PCL::.ARGS-TAIL.))
(DECLARE (FIXNUM START))
(DECLARE (PCL::CLASS STREAM FUNDAMENTAL-CHARACTER-OUTPUT-STREAM))
...)
Warning: Undefined type: FUNDAMENTAL-CHARACTER-OUTPUT-STREAM
In: DEFMETHOD STREAM-START-LINE-P (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM)
(DEFMETHOD STREAM-START-LINE-P
((STREAM FUNDAMENTAL-CHARACTER-OUTPUT-STREAM))
(EQL (STREAM-LINE-COLUMN STREAM) 0))
--> BLOCK MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
--> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
--> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS
==>
(LET* ((PCL::.ARGS-TAIL. NIL))
(DECLARE (IGNORABLE PCL::.ARGS-TAIL.))
(DECLARE (PCL::CLASS STREAM FUNDAMENTAL-CHARACTER-OUTPUT-STREAM))
(PROGN STREAM)
...)
Warning: Undefined type: FUNDAMENTAL-CHARACTER-OUTPUT-STREAM
In: DEFMETHOD STREAM-LINE-LENGTH (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM)
(DEFMETHOD STREAM-LINE-LENGTH
((STREAM FUNDAMENTAL-CHARACTER-OUTPUT-STREAM))
NIL)
--> BLOCK MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
--> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
--> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS
==>
(LET* ((PCL::.ARGS-TAIL. NIL))
(DECLARE (IGNORABLE PCL::.ARGS-TAIL.))
(DECLARE (PCL::CLASS STREAM FUNDAMENTAL-CHARACTER-OUTPUT-STREAM))
(PROGN STREAM)
...)
Warning: Undefined type: FUNDAMENTAL-CHARACTER-OUTPUT-STREAM
Warning: 3 more uses of undefined type FUNDAMENTAL-CHARACTER-OUTPUT-STREAM.
File: /tmp/gray-streams.lisp
In: DEFMETHOD STREAM-ELEMENT-TYPE (FUNDAMENTAL-CHARACTER-STREAM)
(DEFMETHOD STREAM-ELEMENT-TYPE
((STREAM FUNDAMENTAL-CHARACTER-STREAM))
'CHARACTER)
--> BLOCK MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
--> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
--> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS
==>
(LET* ((PCL::.ARGS-TAIL. NIL))
(DECLARE (IGNORABLE PCL::.ARGS-TAIL.))
(DECLARE (PCL::CLASS STREAM FUNDAMENTAL-CHARACTER-STREAM))
(PROGN STREAM)
...)
Warning: Undefined type: FUNDAMENTAL-CHARACTER-STREAM
In: DEFMETHOD INPUT-STREAM-P (FUNDAMENTAL-INPUT-STREAM)
(DEFMETHOD INPUT-STREAM-P ((STREAM FUNDAMENTAL-INPUT-STREAM)) T)
--> BLOCK MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
--> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
--> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS
==>
(LET* ((PCL::.ARGS-TAIL. NIL))
(DECLARE (IGNORABLE PCL::.ARGS-TAIL.))
(DECLARE (PCL::CLASS STREAM FUNDAMENTAL-INPUT-STREAM))
(PROGN STREAM)
...)
Warning: Undefined type: FUNDAMENTAL-INPUT-STREAM
In: DEFMETHOD STREAM-FORCE-OUTPUT (FUNDAMENTAL-OUTPUT-STREAM)
(DEFMETHOD STREAM-FORCE-OUTPUT ((STREAM FUNDAMENTAL-OUTPUT-STREAM)) NIL)
--> BLOCK MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
--> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
--> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS
==>
(LET* ((PCL::.ARGS-TAIL. NIL))
(DECLARE (IGNORABLE PCL::.ARGS-TAIL.))
(DECLARE (PCL::CLASS STREAM FUNDAMENTAL-OUTPUT-STREAM))
(PROGN STREAM)
...)
Warning: Undefined type: FUNDAMENTAL-OUTPUT-STREAM
In: DEFMETHOD STREAM-FINISH-OUTPUT (FUNDAMENTAL-OUTPUT-STREAM)
(DEFMETHOD STREAM-FINISH-OUTPUT ((STREAM FUNDAMENTAL-OUTPUT-STREAM)) NIL)
--> BLOCK MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
--> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
--> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS
==>
(LET* ((PCL::.ARGS-TAIL. NIL))
(DECLARE (IGNORABLE PCL::.ARGS-TAIL.))
(DECLARE (PCL::CLASS STREAM FUNDAMENTAL-OUTPUT-STREAM))
(PROGN STREAM)
...)
Warning: Undefined type: FUNDAMENTAL-OUTPUT-STREAM
In: DEFMETHOD OUTPUT-STREAM-P (FUNDAMENTAL-OUTPUT-STREAM)
(DEFMETHOD OUTPUT-STREAM-P ((STREAM FUNDAMENTAL-OUTPUT-STREAM)) T)
--> BLOCK MACROLET PCL::FAST-LEXICAL-METHOD-FUNCTIONS
--> PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET
--> PCL::BIND-LEXICAL-METHOD-FUNCTIONS LET PCL::BIND-ARGS
==>
(LET* ((PCL::.ARGS-TAIL. NIL))
(DECLARE (IGNORABLE PCL::.ARGS-TAIL.))
(DECLARE (PCL::CLASS STREAM FUNDAMENTAL-OUTPUT-STREAM))
(PROGN STREAM)
...)
Warning: Undefined type: FUNDAMENTAL-OUTPUT-STREAM
Warning: 1 more use of undefined type FUNDAMENTAL-OUTPUT-STREAM.
File: /tmp/gray-streams.lisp
In: DEFMETHOD STREAM-UNREAD-CHAR (CHARACTER-INPUT-STREAM T)
(UNREAD-CHAR CHARACTER (CHARACTER-INPUT-STREAM-LISP-STREAM STREAM))
--> BLOCK LET IN-SYNONYM-OF LET COND IF COND IF COND IF PROGN UNLESS COND IF
--> PROGN ERROR
==>
(#:G11)
Warning: Undefined function: #:G11
In: DEFMETHOD STREAM-READ-CHAR (CHARACTER-INPUT-STREAM)
(READ-CHAR (CHARACTER-INPUT-STREAM-LISP-STREAM STREAM))
--> BLOCK LET IN-SYNONYM-OF LET COND IF COND IF COND IF PROGN UNLESS COND IF
--> PROGN ERROR
==>
(#:G12)
Warning: Undefined function: #:G12
In: SETF (FDEFINITION 'CLOSE)
#'PCL-CLOSE
Warning: Undefined function: PCL-CLOSE
In: DEFGENERIC PCL-CLOSE
(DEFGENERIC PCL-CLOSE
(STREAM &KEY ABORT)
(:DOCUMENTATION
"Closes the given Stream. No more I/O may be performed, but
inquiries may still be made. If :Abort is non-nil, an attempt is made ..))
--> PROGN FUNCTION
==>
#'PCL-CLOSE
Warning: Undefined function: PCL-CLOSE
In: SETF (FDEFINITION 'OPEN-STREAM-P)
#'PCL-OPEN-STREAM-P
Warning: Undefined function: PCL-OPEN-STREAM-P
In: PCL-OPEN-STREAM-P (MAKE-STRING-OUTPUT-STREAM)
(PCL-OPEN-STREAM-P (MAKE-STRING-OUTPUT-STREAM))
Warning: Undefined function: PCL-OPEN-STREAM-P
In: DEFGENERIC PCL-OPEN-STREAM-P
(DEFGENERIC PCL-OPEN-STREAM-P
(STREAM)
(:DOCUMENTATION
"Return true if Stream is not closed. A default method is provided
by class FUNDAMENTAL-STREAM which returns true if CLOSE has not been ..))
--> PROGN FUNCTION
==>
#'PCL-OPEN-STREAM-P
Warning: Undefined function: PCL-OPEN-STREAM-P
In: DEFGENERIC STREAM-ADVANCE-TO-COLUMN
(DEFGENERIC STREAM-ADVANCE-TO-COLUMN
(STREAM COLUMN)
(:DOCUMENTATION
"Writes enough blank space so that the next character will be
written at the specified column. Returns true if the operation is ..))
--> PROGN FUNCTION
==>
#'STREAM-ADVANCE-TO-COLUMN
Warning: Undefined function: STREAM-ADVANCE-TO-COLUMN
In: DEFGENERIC STREAM-CLEAR-INPUT
(DEFGENERIC STREAM-CLEAR-INPUT
(STREAM)
(:DOCUMENTATION
"Implements CLEAR-INPUT for the stream, returning NIL. The default
method does nothing."))
--> PROGN FUNCTION
==>
#'STREAM-CLEAR-INPUT
Warning: Undefined function: STREAM-CLEAR-INPUT
In: DEFGENERIC STREAM-CLEAR-OUTPUT
(DEFGENERIC STREAM-CLEAR-OUTPUT
(STREAM)
(:DOCUMENTATION
"Clears the given output Stream. Implements CLEAR-OUTPUT. The
default method does nothing."))
--> PROGN FUNCTION
==>
#'STREAM-CLEAR-OUTPUT
Warning: Undefined function: STREAM-CLEAR-OUTPUT
In: DEFGENERIC STREAM-FINISH-OUTPUT
(DEFGENERIC STREAM-FINISH-OUTPUT
(STREAM)
(:DOCUMENTATION
"Attempts to ensure that all output sent to the Stream has reached
its destination, and only then returns false. Implements ..))
--> PROGN FUNCTION
==>
#'STREAM-FINISH-OUTPUT
Warning: Undefined function: STREAM-FINISH-OUTPUT
In: DEFGENERIC STREAM-FORCE-OUTPUT
(DEFGENERIC STREAM-FORCE-OUTPUT
(STREAM)
(:DOCUMENTATION
"Attempts to force any buffered output to be sent. Implements
FORCE-OUTPUT. The default method does nothing."))
--> PROGN FUNCTION
==>
#'STREAM-FORCE-OUTPUT
Warning: Undefined function: STREAM-FORCE-OUTPUT
In: DEFGENERIC STREAM-FRESH-LINE
(DEFGENERIC STREAM-FRESH-LINE
(STREAM)
(:DOCUMENTATION
"Outputs a new line to the Stream if it is not positioned at the
begining of a line. Returns T if it output a new line, nil ..))
--> PROGN FUNCTION
==>
#'STREAM-FRESH-LINE
Warning: Undefined function: STREAM-FRESH-LINE
In:
DEFMETHOD STREAM-ADVANCE-TO-COLUMN (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM T)
(STREAM-LINE-COLUMN STREAM)
Warning: Undefined function: STREAM-LINE-COLUMN
In: DEFMETHOD STREAM-START-LINE-P (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM)
(STREAM-LINE-COLUMN STREAM)
Warning: Undefined function: STREAM-LINE-COLUMN
In: DEFGENERIC STREAM-LINE-COLUMN
(DEFGENERIC STREAM-LINE-COLUMN
(STREAM)
(:DOCUMENTATION
"This function returns the column number where the next character
will be written, or NIL if that is not meaningful for this stream. ..))
--> PROGN FUNCTION
==>
#'STREAM-LINE-COLUMN
Warning: Undefined function: STREAM-LINE-COLUMN
In: DEFGENERIC STREAM-LINE-LENGTH
(DEFGENERIC STREAM-LINE-LENGTH
(STREAM)
(:DOCUMENTATION "Return the stream line length or Nil."))
--> PROGN FUNCTION
==>
#'STREAM-LINE-LENGTH
Warning: Undefined function: STREAM-LINE-LENGTH
In: DEFGENERIC STREAM-LISTEN
(DEFGENERIC STREAM-LISTEN
(STREAM)
(:DOCUMENTATION
"Used by LISTEN. Returns true or false. The default method uses
STREAM-READ-CHAR-NO-HANG and STREAM-UNREAD-CHAR. Most streams should ..))
--> PROGN FUNCTION
==>
#'STREAM-LISTEN
Warning: Undefined function: STREAM-LISTEN
In: DEFGENERIC STREAM-PEEK-CHAR
(DEFGENERIC STREAM-PEEK-CHAR
(STREAM)
(:DOCUMENTATION
"Used to implement PEEK-CHAR; this corresponds to peek-type of NIL.
It returns either a character or :EOF. The default method calls ..))
--> PROGN FUNCTION
==>
#'STREAM-PEEK-CHAR
Warning: Undefined function: STREAM-PEEK-CHAR
In: DEFGENERIC STREAM-READ-BYTE
(DEFGENERIC STREAM-READ-BYTE
(STREAM)
(:DOCUMENTATION
"Used by READ-BYTE; returns either an integer, or the symbol :EOF
if the stream is at end-of-file."))
--> PROGN FUNCTION
==>
#'STREAM-READ-BYTE
Warning: Undefined function: STREAM-READ-BYTE
In: DEFMETHOD STREAM-PEEK-CHAR (FUNDAMENTAL-CHARACTER-INPUT-STREAM)
(STREAM-READ-CHAR STREAM)
Warning: Undefined function: STREAM-READ-CHAR
In: DEFMETHOD STREAM-READ-CHAR-NO-HANG (FUNDAMENTAL-CHARACTER-INPUT-STREAM)
(STREAM-READ-CHAR STREAM)
Warning: Undefined function: STREAM-READ-CHAR
In: DEFGENERIC STREAM-READ-CHAR
(DEFGENERIC STREAM-READ-CHAR
(STREAM)
(:DOCUMENTATION
"This reads one character from the stream. It returns either a
character object, or the symbol :EOF if the stream is at end-of-file. ..))
--> PROGN FUNCTION
==>
#'STREAM-READ-CHAR
Warning: Undefined function: STREAM-READ-CHAR
Warning: 2 more uses of undefined function STREAM-READ-CHAR.
File: /tmp/gray-streams.lisp
In: DEFMETHOD STREAM-LISTEN (FUNDAMENTAL-CHARACTER-INPUT-STREAM)
(STREAM-READ-CHAR-NO-HANG STREAM)
Warning: Undefined function: STREAM-READ-CHAR-NO-HANG
In: DEFGENERIC STREAM-READ-CHAR-NO-HANG
(DEFGENERIC STREAM-READ-CHAR-NO-HANG
(STREAM)
(:DOCUMENTATION
"This is used to implement READ-CHAR-NO-HANG. It returns either a
character, or NIL if no input is currently available, or :EOF if ..))
--> PROGN FUNCTION
==>
#'STREAM-READ-CHAR-NO-HANG
Warning: Undefined function: STREAM-READ-CHAR-NO-HANG
In: DEFGENERIC STREAM-READ-LINE
(DEFGENERIC STREAM-READ-LINE
(STREAM)
(:DOCUMENTATION
"Used by READ-LINE. A string is returned as the first value. The
second value is true if the string was terminated by end-of-file ..))
--> PROGN FUNCTION
==>
#'STREAM-READ-LINE
Warning: Undefined function: STREAM-READ-LINE
In: DEFMETHOD STREAM-FRESH-LINE (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM)
(STREAM-START-LINE-P STREAM)
Warning: Undefined function: STREAM-START-LINE-P
In: DEFGENERIC STREAM-START-LINE-P
(DEFGENERIC STREAM-START-LINE-P
(STREAM)
(:DOCUMENTATION
"This is a predicate which returns T if the stream is positioned at
the beginning of a line, else NIL. It is permissible to always return ..))
--> PROGN FUNCTION
==>
#'STREAM-START-LINE-P
Warning: Undefined function: STREAM-START-LINE-P
In: DEFMETHOD STREAM-FRESH-LINE (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM)
(STREAM-TERPRI STREAM)
Warning: Undefined function: STREAM-TERPRI
In: DEFGENERIC STREAM-TERPRI
(DEFGENERIC STREAM-TERPRI
(STREAM)
(:DOCUMENTATION
"Writes an end of line, as for TERPRI. Returns NIL. The default
method does (STREAM-WRITE-CHAR stream #NEWLINE)."))
--> PROGN FUNCTION
==>
#'STREAM-TERPRI
Warning: Undefined function: STREAM-TERPRI
In: DEFMETHOD STREAM-LISTEN (FUNDAMENTAL-CHARACTER-INPUT-STREAM)
(STREAM-UNREAD-CHAR STREAM CHAR)
Warning: Undefined function: STREAM-UNREAD-CHAR
In: DEFMETHOD STREAM-PEEK-CHAR (FUNDAMENTAL-CHARACTER-INPUT-STREAM)
(STREAM-UNREAD-CHAR STREAM CHAR)
Warning: Undefined function: STREAM-UNREAD-CHAR
In: DEFGENERIC STREAM-UNREAD-CHAR
(DEFGENERIC STREAM-UNREAD-CHAR
(STREAM CHARACTER)
(:DOCUMENTATION
"Un-does the last call to STREAM-READ-CHAR, as in UNREAD-CHAR.
Returns NIL. Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM ..))
--> PROGN FUNCTION
==>
#'STREAM-UNREAD-CHAR
Warning: Undefined function: STREAM-UNREAD-CHAR
Warning: 1 more use of undefined function STREAM-UNREAD-CHAR.
File: /tmp/gray-streams.lisp
In: DEFGENERIC STREAM-WRITE-BYTE
(DEFGENERIC STREAM-WRITE-BYTE
(STREAM INTEGER)
(:DOCUMENTATION
"Implements WRITE-BYTE; writes the integer to the stream and
returns the integer as the result."))
--> PROGN FUNCTION
==>
#'STREAM-WRITE-BYTE
Warning: Undefined function: STREAM-WRITE-BYTE
In: DEFMETHOD STREAM-TERPRI (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM)
(STREAM-WRITE-CHAR STREAM #\Linefeed)
Warning: Undefined function: STREAM-WRITE-CHAR
In: DEFMETHOD STREAM-WRITE-STRING (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM T)
(STREAM-WRITE-CHAR STREAM (AREF STRING POS))
Warning: Undefined function: STREAM-WRITE-CHAR
In: DEFGENERIC STREAM-WRITE-CHAR
(DEFGENERIC STREAM-WRITE-CHAR
(STREAM CHARACTER)
(:DOCUMENTATION
"Writes character to the stream and returns the character. Every
subclass of FUNDAMENTAL-CHARACTER-OUTPUT-STREAM must have a method ..))
--> PROGN FUNCTION
==>
#'STREAM-WRITE-CHAR
Warning: Undefined function: STREAM-WRITE-CHAR
Warning: 1 more use of undefined function STREAM-WRITE-CHAR.
File: /tmp/gray-streams.lisp
In: DEFGENERIC STREAM-WRITE-STRING
(DEFGENERIC STREAM-WRITE-STRING
(STREAM STRING &OPTIONAL (START 0) END)
(:DOCUMENTATION
"This is used by WRITE-STRING. It writes the string to the stream,
optionally delimited by start and end, which default to 0 and NIL. ..))
--> PROGN FUNCTION
==>
#'STREAM-WRITE-STRING
Warning: Undefined function: STREAM-WRITE-STRING
Warning: These functions are undefined:
#:G11 #:G12 PCL-CLOSE PCL-OPEN-STREAM-P STREAM-ADVANCE-TO-COLUMN
STREAM-CLEAR-INPUT STREAM-CLEAR-OUTPUT STREAM-FINISH-OUTPUT
STREAM-FORCE-OUTPUT STREAM-FRESH-LINE STREAM-LINE-COLUMN STREAM-LINE-LENGTH
STREAM-LISTEN STREAM-PEEK-CHAR STREAM-READ-BYTE STREAM-READ-CHAR
STREAM-READ-CHAR-NO-HANG STREAM-READ-LINE STREAM-START-LINE-P STREAM-TERPRI
STREAM-UNREAD-CHAR STREAM-WRITE-BYTE STREAM-WRITE-CHAR STREAM-WRITE-STRING
Warning: These types are undefined:
CHARACTER-INPUT-STREAM CHARACTER-OUTPUT-STREAM
FUNDAMENTAL-CHARACTER-INPUT-STREAM FUNDAMENTAL-CHARACTER-OUTPUT-STREAM
FUNDAMENTAL-CHARACTER-STREAM FUNDAMENTAL-INPUT-STREAM
FUNDAMENTAL-OUTPUT-STREAM
Compilation unit finished.
65 warnings
gray-streams.x86f written.
Compilation finished in 0:00:05.
#p"/tmp/gray-streams.x86f"
NIL
NIL
* (load "gray-streams-class.x86f")
; Loading #p"/tmp/gray-streams-class.x86f".
[GC threshold exceeded with 2,616,104 bytes in use. Commencing GC.]
[GC completed with 927,952 bytes retained and 1,688,152 bytes freed.]
[GC will next occur when at least 2,927,952 bytes are in use.]
T
* (load "gray-streams.x86f")
; Loading #p"/tmp/gray-streams.x86f".
Compiling LAMBDA (#:G896 #:G897 #:G900 #:G901):
Compiling Top-Level Form:
Compiling LAMBDA (#:G910 #:G911 #:G913 #:G914):
Compiling Top-Level Form:
Error in function PCL::|(FAST-METHOD NO-APPLICABLE-METHOD (T))|:
No matching method for the generic-function #<Standard-Generic-Function INPUT-STREAM-P (0) {4812F0A1}>,
when called with arguments (#<Stream for file "/tmp/gray-streams.x86f">).
Restarts:
0: [CONTINUE] Retry call to #<Standard-Generic-Function INPUT-STREAM-P (0) {4812F0A1}>
1: Return NIL from load of "gray-streams.x86f".
2: [ABORT ] Return to Top-Level.
Error in function PCL::|(FAST-METHOD NO-APPLICABLE-METHOD (T))|:
No matching method for the generic-function #<Standard-Generic-Function INPUT-STREAM-P (0) {4812F0A1}>,
when called with arguments (#<Synonym Stream to *TERMINAL-IO*>).
Restarts:
0: [CONTINUE] Retry call to #<Standard-Generic-Function INPUT-STREAM-P (0) {4812F0A1}>
1: Return NIL from load of "gray-streams.x86f".
2: [ABORT ] Return to Top-Level.
Error in function PCL::|(FAST-METHOD NO-APPLICABLE-METHOD (T))|:
No matching method for the generic-function #<Standard-Generic-Function INPUT-STREAM-P (0) {4812F0A1}>,
when called with arguments (#<Synonym Stream to *TERMINAL-IO*>).
Restarts:
0: [CONTINUE] Retry call to #<Standard-Generic-Function INPUT-STREAM-P (0) {4812F0A1}>
1: Return NIL from load of "gray-streams.x86f".
2: [ABORT ] Return to Top-Level.
...etc
Any ideas?
--
Robert Strandh
---------------------------------------------------------------------
Greenspun's Tenth Rule of Programming: any sufficiently complicated C
or Fortran program contains an ad hoc informally-specified bug-ridden
slow implementation of half of Common Lisp.
--------------------------------------------------------------------- From: Hannu Koivisto
Subject: Re: Problems with Gray streams on CMU CL
Date: Tue, 01 Aug 2000 00:00:00 +0000
Message-ID: <87aeexs404.fsf@senstation.vvf.fi> Robert STRANDH <·······@labri.u-bordeaux.fr> writes:
| I have problems loading the binaries for Gray streams into my CMU CL.
| Here is what happens (sorry for the large amount of text, but I figure
| it might be important):
Unfortunately that text doesn't reveal which core you are using
(there are three different choices) but my guess would be that you
are using the safe core in which case you cannot use Gray streams.
Use the normal core or consider upgrading to 2.4.20 that may fix
this problem (I haven't tried it, but I recall Peter mentioning
so).
--
Hannu From: Robert STRANDH
Subject: Re: Problems with Gray streams on CMU CL
Date: Wed, 02 Aug 2000 00:00:00 +0000
Message-ID: <6wya2fisqy.fsf@serveur3-1.labri.u-bordeaux.fr> Thanks to everyone for helping me out with this. It was indeed a
problem with the core file. The safe core cannot be used with Gray
streams. Using the normal core worked.
--
Robert Strandh
---------------------------------------------------------------------
Greenspun's Tenth Rule of Programming: any sufficiently complicated C
or Fortran program contains an ad hoc informally-specified bug-ridden
slow implementation of half of Common Lisp.
--------------------------------------------------------------------- From: Pierre R. Mai
Subject: Re: Problems with Gray streams on CMU CL
Date: Tue, 01 Aug 2000 00:00:00 +0000
Message-ID: <87aeexz2m1.fsf@orion.bln.pmsf.de> Robert STRANDH <·······@labri.u-bordeaux.fr> writes:
> Hello,
>
> I have problems loading the binaries for Gray streams into my CMU CL.
> Here is what happens (sorry for the large amount of text, but I figure
> it might be important):
>
> CMU Common Lisp release x86-linux 2.4.19 8 February 2000 build 455, running on merlin
> Send bug reports and questions to your local CMU CL maintainer,
> or to ········@debian.org
> or to ··········@cons.org. (prefered)
Loading of Gray streams does not work with the safe core of the Debian
distribution of CMUCL: Switch to one of the other cores (fast, small,
...) instead, and compiling and loading will work (you should probably
compile and load the *-class.lisp file first, then compile and load
the other file).
Regs, Pierre.
--
Pierre R. Mai <····@acm.org> http://www.pmsf.de/pmai/
The most likely way for the world to be destroyed, most experts agree,
is by accident. That's where we come in; we're computer professionals.
We cause accidents. -- Nathaniel Borenstein