;;;----- Licensing notice ---------------------------------------------------
;;;
-;;; This file is part of the Sensble Object Design, an object system for C.
+;;; This file is part of the Sensible Object Design, an object system for C.
;;;
;;; SOD is free software; you can redistribute it and/or modify
;;; it under the terms of the GNU General Public License as published by
(defun merge-lists (lists &key pick (test #'eql))
"Return a merge of the given LISTS.
- The resulting LIST contains the items of the given lists, with duplicates
+ The resulting list contains the items of the given LISTS, with duplicates
removed. The order of the resulting list is consistent with the orders of
the input LISTS in the sense that if A precedes B in some input list then
A will also precede B in the output list. If the lists aren't consistent
If there is an ambiguity at any point -- i.e., a choice between two or
more possible next items to emit -- then PICK is called to arbitrate.
PICK is called with two arguments: the list of candidate next items, and
- the current output list. It should return one of the candidate items. If
- PICK is omitted then an arbitrary choice is made.
+ the current output list. It should return one of the candidate items.
+ The order of the candidates in the list given to the PICK function
+ reflects their order in the input LISTS: item A will precede item B in the
+ candidates list if and only if an occurrence of A appears in an earlier
+ input list than any occurrence of item B. (This completely determines the
+ order of the candidates: it is not possible that two candidates appear in
+ the same input list would resolve the ambiguity between them.) If PICK is
+ omitted then the item chosen is the one appearing in the earliest of the
+ input lists: i.e., effectively, the default PICK function is
+
+ (lambda (candidates output-so-far)
+ (declare (ignore output-so-far))
+ (car candidates))
The primary use of this function is in computing class precedence lists.
By building the input lists and selecting the PICK function appropriately,
;; one of the other lists other than at the front then we reject it. If
;; we've just rejected everything, then we can make no more progress and
;; the input lists were inconsistent.
- (let* ((candidates (delete-duplicates (mapcar #'car lists) :test test))
+ (let* ((candidates (delete-duplicates (mapcar #'car lists)
+ :test test :from-end t))
(leasts (remove-if (lambda (item)
(some (lambda (list)
(member item (cdr list) :test test))
(,print))
(,print)))))
+(export 'print-ugly-stuff)
+(defun print-ugly-stuff (stream func)
+ "Print not-pretty things to the stream underlying STREAM.
+
+ The Lisp pretty-printing machinery, notably `pprint-logical-block', may
+ interpose additional streams between its body and the original target
+ stream. This makes it difficult to make use of the underlying stream's
+ special features, whatever they might be."
+
+ ;; This is unpleasant. Hacky hacky.
+ #.(or #+sbcl '(if (typep stream 'sb-pretty:pretty-stream)
+ (let ((target (sb-pretty::pretty-stream-target stream)))
+ (pprint-newline :mandatory stream)
+ (funcall func target))
+ (funcall func stream))
+ #+cmu '(if (typep stream 'pp:pretty-stream)
+ (let ((target (pp::pretty-stream-target stream)))
+ (pprint-newline :mandatory stream)
+ (funcall func target))
+ (funcall func stream))
+ '(funcall func stream)))
+
;;;--------------------------------------------------------------------------
;;; Iteration macros.
(,classvar (,instance ,class) (,slotvar (eql ',slot)))
,@docs ,@decls
(declare (ignore ,classvar))
- (setf (slot-value ,instance ',slot) (progn ,@body))))))
+ (setf (slot-value ,instance ',slot) (block ,slot ,@body))))))
;;;----- That's all, folks --------------------------------------------------
~mdw / sod / blobdiff