X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Fpprint.lisp;h=4778e9fd951f20eada881a776dc21f5779dd1989;hb=872175cd9cb5b4966a36d4bd92421cc407a0355b;hp=66b5d60e36f5ad800ab77ce4fe309e7c80a94560;hpb=59f7d9254f3601cfd48f0c299d5c30562111e991;p=sbcl.git diff --git a/src/code/pprint.lisp b/src/code/pprint.lisp index 66b5d60..4778e9f 100644 --- a/src/code/pprint.lisp +++ b/src/code/pprint.lisp @@ -32,7 +32,8 @@ (:out #'pretty-out) (:sout #'pretty-sout) (:misc #'pretty-misc)) - (:constructor make-pretty-stream (target))) + (:constructor make-pretty-stream (target)) + (:copier nil)) ;; Where the output is going to finally go. (target (required-argument) :type stream) ;; Line length we should format to. Cached here so we don't have to keep @@ -55,9 +56,20 @@ ;; zero, but if we end up with a very long line with no breaks in it we ;; might have to output part of it. Then this will no longer be zero. (buffer-start-column (or (sb!impl::charpos target) 0) :type column) - ;; The line number we are currently on. Used for *print-lines* abrevs and - ;; to tell when sections have been split across multiple lines. + ;; The line number we are currently on. Used for *PRINT-LINES* + ;; abbreviations and to tell when sections have been split across + ;; multiple lines. (line-number 0 :type index) + ;; the value of *PRINT-LINES* captured at object creation time. We + ;; use this, instead of the dynamic *PRINT-LINES*, to avoid + ;; weirdness like + ;; (let ((*print-lines* 50)) + ;; (pprint-logical-block .. + ;; (dotimes (i 10) + ;; (let ((*print-lines* 8)) + ;; (print (aref possiblybigthings i) prettystream))))) + ;; terminating the output of the entire logical blockafter 8 lines. + (print-lines *print-lines* :type (or index null) :read-only t) ;; Stack of logical blocks in effect at the buffer start. (blocks (list (make-logical-block)) :type list) ;; Buffer holding the per-line prefix active at the buffer start. @@ -97,6 +109,11 @@ (declare (type posn posn) (type pretty-stream stream) (values posn)) (index-column (posn-index posn stream) stream)) + +;;; Is it OK to do pretty printing on this stream at this time? +(defun print-pretty-on-stream-p (stream) + (and (pretty-stream-p stream) + *print-pretty*)) ;;;; stream interface routines @@ -147,7 +164,7 @@ ;;;; logical blocks -(defstruct logical-block +(defstruct (logical-block (:copier nil)) ;; The column this logical block started in. (start-column 0 :type column) ;; The column the current section started in. @@ -235,13 +252,12 @@ ;;;; the pending operation queue -(defstruct (queued-op (:constructor nil)) +(defstruct (queued-op (:constructor nil) + (:copier nil)) (posn 0 :type posn)) (defmacro enqueue (stream type &rest args) - (let ((constructor (intern (concatenate 'string - "MAKE-" - (symbol-name type))))) + (let ((constructor (symbolicate "MAKE-" type))) (once-only ((stream stream) (entry `(,constructor :posn (index-posn @@ -259,12 +275,13 @@ ,entry)))) (defstruct (section-start (:include queued-op) - (:constructor nil)) + (:constructor nil) + (:copier nil)) (depth 0 :type index) (section-end nil :type (or null newline block-end))) -(defstruct (newline - (:include section-start)) +(defstruct (newline (:include section-start) + (:copier nil)) (kind (required-argument) :type (member :linear :fill :miser :literal :mandatory))) @@ -279,16 +296,16 @@ (setf (section-start-section-end entry) newline)))) (maybe-output stream (or (eq kind :literal) (eq kind :mandatory)))) -(defstruct (indentation - (:include queued-op)) +(defstruct (indentation (:include queued-op) + (:copier nil)) (kind (required-argument) :type (member :block :current)) (amount 0 :type fixnum)) (defun enqueue-indent (stream kind amount) (enqueue stream indentation :kind kind :amount amount)) -(defstruct (block-start - (:include section-start)) +(defstruct (block-start (:include section-start) + (:copier nil)) (block-end nil :type (or null block-end)) (prefix nil :type (or null simple-string)) (suffix nil :type (or null simple-string))) @@ -311,8 +328,8 @@ (setf (pretty-stream-pending-blocks stream) (cons start pending-blocks)))) -(defstruct (block-end - (:include queued-op)) +(defstruct (block-end (:include queued-op) + (:copier nil)) (suffix nil :type (or null simple-string))) (defun end-logical-block (stream) @@ -323,8 +340,8 @@ (pretty-sout stream suffix 0 (length suffix))) (setf (block-start-block-end start) end))) -(defstruct (tab - (:include queued-op)) +(defstruct (tab (:include queued-op) + (:copier nil)) (sectionp nil :type (member t nil)) (relativep nil :type (member t nil)) (colnum 0 :type column) @@ -526,8 +543,10 @@ (defun fits-on-line-p (stream until force-newlines-p) (let ((available (pretty-stream-line-length stream))) - (when (and (not *print-readably*) *print-lines* - (= *print-lines* (pretty-stream-line-number stream))) + (when (and (not *print-readably*) + (pretty-stream-print-lines stream) + (= (pretty-stream-print-lines stream) + (pretty-stream-line-number stream))) (decf available 3) ; for the `` ..'' (decf available (logical-block-suffix-length (car (pretty-stream-blocks stream))))) @@ -561,7 +580,8 @@ (let ((line-number (pretty-stream-line-number stream))) (incf line-number) (when (and (not *print-readably*) - *print-lines* (>= line-number *print-lines*)) + (pretty-stream-print-lines stream) + (>= line-number (pretty-stream-print-lines stream))) (write-string " .." target) (let ((suffix-length (logical-block-suffix-length (car (pretty-stream-blocks stream))))) @@ -657,7 +677,7 @@ ((t) *terminal-io*) ((nil) *standard-output*) (t stream)))) - (when (pretty-stream-p stream) + (when (print-pretty-on-stream-p stream) (enqueue-newline stream kind))) nil) @@ -680,7 +700,7 @@ ((t) *terminal-io*) ((nil) *standard-output*) (t stream)))) - (when (pretty-stream-p stream) + (when (print-pretty-on-stream-p stream) (enqueue-indent stream relative-to n))) nil) @@ -705,7 +725,7 @@ ((t) *terminal-io*) ((nil) *standard-output*) (t stream)))) - (when (pretty-stream-p stream) + (when (print-pretty-on-stream-p stream) (enqueue-tab stream kind colnum colinc))) nil) @@ -768,7 +788,7 @@ (defvar *initial-pprint-dispatch*) (defvar *building-initial-table* nil) -(defstruct pprint-dispatch-entry +(defstruct (pprint-dispatch-entry (:copier nil)) ;; The type specifier for this entry. (type (required-argument) :type t) ;; A function to test to see whether an object is of this time. Pretty must @@ -790,7 +810,7 @@ (pprint-dispatch-entry-priority entry) (pprint-dispatch-entry-initial-p entry)))) -(defstruct pprint-dispatch-table +(defstruct (pprint-dispatch-table (:copier nil)) ;; A list of all the entries (except for CONS entries below) in highest ;; to lowest priority. (entries nil :type list) @@ -869,15 +889,8 @@ (let ((expr (compute-test-expr type 'object))) (cond ((cdr (assoc expr *precompiled-pprint-dispatch-funs* :test #'equal))) - ((fboundp 'compile) - (compile nil `(lambda (object) ,expr))) - (was-cons - (warn "CONS PPRINT dispatch ignored w/o compiler loaded:~% ~S" - type) - #'(lambda (object) (declare (ignore object)) nil)) (t - (let ((ttype (sb!kernel:specifier-type type))) - #'(lambda (object) (sb!kernel:%typep object ttype))))))))) + (compile nil `(lambda (object) ,expr)))))))) (defun copy-pprint-dispatch (&optional (table *print-pprint-dispatch*)) (declare (type (or pprint-dispatch-table null) table)) @@ -955,7 +968,7 @@ (stringp array) (bit-vector-p array)) (output-ugly-object array stream)) - ((and *print-readably* (not (eq (array-element-type array) 't))) + ((and *print-readably* (not (eq (array-element-type array) t))) (let ((*print-readably* nil)) (error 'print-not-readable :object array))) ((vectorp array)