0.6.11.30:

[sbcl.git] / src / code / print.lisp

diff --git a/src/code/print.lisp b/src/code/print.lisp
index 3a52072..53507ee 100644 (file)
--- a/src/code/print.lisp
+++ b/src/code/print.lisp
@@ -260,7 +260,7 @@
     (cond ((print-pretty-on-stream-p stream)
           ;; Since we're printing prettily on STREAM, format the
           ;; object within a logical block. PPRINT-LOGICAL-BLOCK does
-          ;; not rebind the stream when it is already a pretty stream
+          ;; not rebind the stream when it is already a pretty stream,
           ;; so output from the body will go to the same stream.
           (pprint-logical-block (stream nil :prefix "#<" :suffix ">")
             (print-description)))
@@ -612,7 +612,8 @@
 ;;; character has. At characters have at least one bit set, so we can
 ;;; search for any character with a positive test.
 (defvar *character-attributes*
-  (make-array char-code-limit :element-type '(unsigned-byte 16)
+  (make-array char-code-limit
+             :element-type '(unsigned-byte 16)
              :initial-element 0))
 (declaim (type (simple-array (unsigned-byte 16) (#.char-code-limit))
               *character-attributes*))
@@ -954,34 +955,34 @@
 (defun output-vector (vector stream)
   (declare (vector vector))
   (cond ((stringp vector)
-          (cond ((or *print-escape* *print-readably*)
-                  (write-char #\" stream)
-                  (quote-string vector stream)
-                  (write-char #\" stream))
-                (t
-                  (write-string vector stream))))
+        (cond ((or *print-escape* *print-readably*)
+               (write-char #\" stream)
+               (quote-string vector stream)
+               (write-char #\" stream))
+              (t
+               (write-string vector stream))))
        ((not (or *print-array* *print-readably*))
-          (output-terse-array vector stream))
+        (output-terse-array vector stream))
        ((bit-vector-p vector)
-          (write-string "#*" stream)
-          (dotimes (i (length vector))
-            (output-object (aref vector i) stream)))
+        (write-string "#*" stream)
+        (dotimes (i (length vector))
+          (output-object (aref vector i) stream)))
        (t
-          (when (and *print-readably*
-                     (not (eq (array-element-type vector) 't)))
-            (error 'print-not-readable :object vector))
-          (descend-into (stream)
-                        (write-string "#(" stream)
-                        (dotimes (i (length vector))
-                          (unless (zerop i)
-                            (write-char #\space stream))
-                          (punt-print-if-too-long i stream)
-                          (output-object (aref vector i) stream))
-                        (write-string ")" stream)))))
-
-;;; This function outputs a string quoting characters sufficiently that so
-;;; someone can read it in again. Basically, put a slash in front of an
-;;; character satisfying NEEDS-SLASH-P
+        (when (and *print-readably*
+                   (not (eq (array-element-type vector) 't)))
+          (error 'print-not-readable :object vector))
+        (descend-into (stream)
+                      (write-string "#(" stream)
+                      (dotimes (i (length vector))
+                        (unless (zerop i)
+                          (write-char #\space stream))
+                        (punt-print-if-too-long i stream)
+                        (output-object (aref vector i) stream))
+                      (write-string ")" stream)))))
+
+;;; This function outputs a string quoting characters sufficiently
+;;; that so someone can read it in again. Basically, put a slash in
+;;; front of an character satisfying NEEDS-SLASH-P.
 (defun quote-string (string stream)
   (macrolet ((needs-slash-p (char)
               ;; KLUDGE: We probably should look at the readtable, but just do
@@ -1437,9 +1438,8 @@
                  (long-float #\L))
                plusp exp))))
 
-;;;    Write out an infinity using #. notation, or flame out if
-;;; *print-readably* is true and *read-eval* is false.
-#!+sb-infinities
+;;; Write out an infinity using #. notation, or flame out if
+;;; *PRINT-READABLY* is true and *READ-EVAL* is false.
 (defun output-float-infinity (x stream)
   (declare (type float x) (type stream stream))
   (cond (*read-eval*