remove stray debugging code from condition-related patches

[sbcl.git] / src / pcl / gray-streams.lisp

diff --git a/src/pcl/gray-streams.lisp b/src/pcl/gray-streams.lisp
index fbf769a..38eb79e 100644 (file)
--- a/src/pcl/gray-streams.lisp
+++ b/src/pcl/gray-streams.lisp
@@ -88,7 +88,13 @@
   (setf (stream-open-p stream) nil)
   t)
 
   (setf (stream-open-p stream) nil)
   t)
 

-(setf (fdefinition 'close) #'pcl-close)
+(progn
+  ;; KLUDGE: Get in a call to PCL-CLOSE with a string-output-stream before
+  ;; setting it as CLOSE. Otherwise using NAMED-LAMBDAs as DFUNs causes a
+  ;; vicious metacircle from FORMAT NIL somewhere in the compiler. This is
+  ;; enough to get the dispatch settled down before we need it.
+  (pcl-close (make-string-output-stream))
+  (setf (fdefinition 'close) #'pcl-close))

 \f
 (let ()
   (fmakunbound 'input-stream-p)
 \f
 (let ()
   (fmakunbound 'input-stream-p)

@@ -96,20 +102,42 @@
   (defgeneric input-stream-p (stream)
     #+sb-doc
     (:documentation "Can STREAM perform input operations?"))
   (defgeneric input-stream-p (stream)
     #+sb-doc
     (:documentation "Can STREAM perform input operations?"))

-  
+

   (defmethod input-stream-p ((stream ansi-stream))
     (ansi-stream-input-stream-p stream))
   (defmethod input-stream-p ((stream ansi-stream))
     (ansi-stream-input-stream-p stream))

-  
+
+  (defmethod input-stream-p ((stream fundamental-stream))
+    nil)
+

   (defmethod input-stream-p ((stream fundamental-input-stream))
     t)
 
   (defmethod input-stream-p ((stream stream))
     (bug-or-error stream 'input-stream-p))
   (defmethod input-stream-p ((stream fundamental-input-stream))
     t)
 
   (defmethod input-stream-p ((stream stream))
     (bug-or-error stream 'input-stream-p))

-  
+

   (defmethod input-stream-p ((non-stream t))
     (error 'type-error :datum non-stream :expected-type 'stream)))
 \f
 (let ()
   (defmethod input-stream-p ((non-stream t))
     (error 'type-error :datum non-stream :expected-type 'stream)))
 \f
 (let ()

+  (fmakunbound 'interactive-stream-p)
+
+  (defgeneric interactive-stream-p (stream)
+    #+sb-doc
+    (:documentation "Is STREAM an interactive stream?"))
+
+  (defmethod interactive-stream-p ((stream ansi-stream))
+    (funcall (ansi-stream-misc stream) stream :interactive-p))
+
+  (defmethod interactive-stream-p ((stream fundamental-stream))
+    nil)
+
+  (defmethod interactive-stream-p ((stream stream))
+    (bug-or-error stream 'interactive-stream-p))
+
+  (defmethod interactive-stream-p ((non-stream t))
+    (error 'type-error :datum non-stream :expected-type 'stream)))
+\f
+(let ()

   (fmakunbound 'output-stream-p)
 
   (defgeneric output-stream-p (stream)
   (fmakunbound 'output-stream-p)
 
   (defgeneric output-stream-p (stream)

@@ -119,6 +147,9 @@
   (defmethod output-stream-p ((stream ansi-stream))
     (ansi-stream-output-stream-p stream))
 
   (defmethod output-stream-p ((stream ansi-stream))
     (ansi-stream-output-stream-p stream))
 

+  (defmethod output-stream-p ((stream fundamental-stream))
+    nil)
+

   (defmethod output-stream-p ((stream fundamental-output-stream))
     t)
 
   (defmethod output-stream-p ((stream fundamental-output-stream))
     t)
 

@@ -199,22 +230,22 @@
 
 (defmethod stream-read-line ((stream fundamental-character-input-stream))
   (let ((res (make-string 80))
 
 (defmethod stream-read-line ((stream fundamental-character-input-stream))
   (let ((res (make-string 80))

-       (len 80)
-       (index 0))
+        (len 80)
+        (index 0))

     (loop
      (let ((ch (stream-read-char stream)))
        (cond ((eq ch :eof)
     (loop
      (let ((ch (stream-read-char stream)))
        (cond ((eq ch :eof)

-             (return (values (shrink-vector res index) t)))
-            (t
-             (when (char= ch #\newline)
-               (return (values (shrink-vector res index) nil)))
-             (when (= index len)
-               (setq len (* len 2))
-               (let ((new (make-string len)))
-                 (replace new res)
-                 (setq res new)))
-             (setf (schar res index) ch)
-             (incf index)))))))
+              (return (values (%shrink-vector res index) t)))
+             (t
+              (when (char= ch #\newline)
+                (return (values (%shrink-vector res index) nil)))
+              (when (= index len)
+                (setq len (* len 2))
+                (let ((new (make-string len)))
+                  (replace new res)
+                  (setq res new)))
+              (setf (schar res index) ch)
+              (incf index)))))))

 
 (defgeneric stream-clear-input (stream)
   #+sb-doc
 
 (defgeneric stream-clear-input (stream)
   #+sb-doc

@@ -230,6 +261,7 @@
   (error 'type-error :datum non-stream :expected-type 'stream))
 
 (defgeneric stream-read-sequence (stream seq &optional start end)
   (error 'type-error :datum non-stream :expected-type 'stream))
 
 (defgeneric stream-read-sequence (stream seq &optional start end)

+  #+sb-doc

   (:documentation
    "This is like CL:READ-SEQUENCE, but for Gray streams."))
 
   (:documentation
    "This is like CL:READ-SEQUENCE, but for Gray streams."))
 

@@ -241,11 +273,11 @@
 ;;; not updated, and the index of the next element is returned.
 (defun basic-io-type-stream-read-sequence (stream seq start end read-fun)
   (declare (type sequence seq)
 ;;; not updated, and the index of the next element is returned.
 (defun basic-io-type-stream-read-sequence (stream seq start end read-fun)
   (declare (type sequence seq)

-          (type stream stream)
-          (type index start)
-          (type sequence-end end)
+           (type stream stream)
+           (type index start)
+           (type sequence-end end)

            (type function read-fun)
            (type function read-fun)

-          (values index))
+           (values index))

   (let ((end (or end (length seq))))
     (declare (type index end))
     (etypecase seq
   (let ((end (or end (length seq))))
     (declare (type index end))
     (etypecase seq

@@ -347,13 +379,13 @@
   STREAM-WRITE-CHAR."))
 
 (defmethod stream-write-string ((stream fundamental-character-output-stream)
   STREAM-WRITE-CHAR."))
 
 (defmethod stream-write-string ((stream fundamental-character-output-stream)

-                               string &optional (start 0) end)
+                                string &optional (start 0) end)

   (declare (string string)
   (declare (string string)

-          (fixnum start))
+           (fixnum start))

   (let ((end (or end (length string))))
     (declare (fixnum end))
     (do ((pos start (1+ pos)))
   (let ((end (or end (length string))))
     (declare (fixnum end))
     (do ((pos start (1+ pos)))

-       ((>= pos end))
+        ((>= pos end))

       (declare (type index pos))
       (stream-write-char stream (aref string pos))))
   string)
       (declare (type index pos))
       (stream-write-char stream (aref string pos))))
   string)

@@ -431,26 +463,27 @@
   #\SPACE character; it returns NIL if STREAM-LINE-COLUMN returns NIL."))
 
 (defmethod stream-advance-to-column ((stream fundamental-character-output-stream)
   #\SPACE character; it returns NIL if STREAM-LINE-COLUMN returns NIL."))
 
 (defmethod stream-advance-to-column ((stream fundamental-character-output-stream)

-                                    column)
+                                     column)

   (let ((current-column (stream-line-column stream)))
     (when current-column
       (let ((fill (- column current-column)))
   (let ((current-column (stream-line-column stream)))
     (when current-column
       (let ((fill (- column current-column)))

-       (dotimes (i fill)
-         (stream-write-char stream #\Space)))
+        (dotimes (i fill)
+          (stream-write-char stream #\Space)))

       T)))
 
 (defgeneric stream-write-sequence (stream seq &optional start end)
       T)))
 
 (defgeneric stream-write-sequence (stream seq &optional start end)

+  #+sb-doc

   (:documentation
    "This is like CL:WRITE-SEQUENCE, but for Gray streams."))
 
 ;;; Write the elements of SEQ bounded by START and END to STREAM.
 (defun basic-io-type-stream-write-sequence (stream seq start end write-fun)
   (declare (type sequence seq)
   (:documentation
    "This is like CL:WRITE-SEQUENCE, but for Gray streams."))
 
 ;;; Write the elements of SEQ bounded by START and END to STREAM.
 (defun basic-io-type-stream-write-sequence (stream seq start end write-fun)
   (declare (type sequence seq)

-          (type stream stream)
-          (type index start)
-          (type sequence-end end)
+           (type stream stream)
+           (type index start)
+           (type sequence-end end)

            (type function write-fun)
            (type function write-fun)

-          (values sequence))
+           (values sequence))

   (let ((end (or end (length seq))))
     (declare (type index start end))
     (etypecase seq
   (let ((end (or end (length seq))))
     (declare (type index start end))
     (etypecase seq

@@ -492,12 +525,22 @@
    "Used by READ-BYTE; returns either an integer, or the symbol :EOF
   if the stream is at end-of-file."))
 
    "Used by READ-BYTE; returns either an integer, or the symbol :EOF
   if the stream is at end-of-file."))
 

+(defmethod stream-read-byte ((stream stream))
+  (bug-or-error stream 'stream-read-byte))
+(defmethod stream-read-byte ((non-stream t))
+  (error 'type-error :datum non-stream :expected-type 'stream))
+

 (defgeneric stream-write-byte (stream integer)
   #+sb-doc
   (:documentation
    "Implements WRITE-BYTE; writes the integer to the stream and
   returns the integer as the result."))
 
 (defgeneric stream-write-byte (stream integer)
   #+sb-doc
   (:documentation
    "Implements WRITE-BYTE; writes the integer to the stream and
   returns the integer as the result."))
 

+(defmethod stream-write-byte ((stream stream) integer)
+  (bug-or-error stream 'stream-write-byte))
+(defmethod stream-write-byte ((non-stream t) integer)
+  (error 'type-error :datum non-stream :expected-type 'stream))
+

 ;; Provide a reasonable default for binary Gray streams.  We might be
 ;; able to do better by specializing on the sequence type, but at
 ;; least the behaviour is reasonable. --tony 2003/05/08.
 ;; Provide a reasonable default for binary Gray streams.  We might be
 ;; able to do better by specializing on the sequence type, but at
 ;; least the behaviour is reasonable. --tony 2003/05/08.

@@ -507,6 +550,18 @@
   (basic-io-type-stream-write-sequence stream seq start end
                                        #'stream-write-byte))
 
   (basic-io-type-stream-write-sequence stream seq start end
                                        #'stream-write-byte))
 

+(defgeneric stream-file-position (stream &optional position-spec)
+  #+sb-doc
+  (:documentation
+   "Used by FILE-POSITION. Returns or changes the current position within STREAM."))
+
+(defmethod stream-file-position ((stream ansi-stream) &optional position-spec)
+  (ansi-stream-file-position stream position-spec))
+
+(defmethod stream-file-position ((stream t) &optional position-spec)
+  (declare (ignore stream position-spec))
+  nil)
+

 \f
 ;;; This is not in the Gray stream proposal, so it is left here
 ;;; as example code.
 \f
 ;;; This is not in the Gray stream proposal, so it is left here
 ;;; as example code.