X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Fearly-extensions.lisp;h=b73ac29033f7c44aa273907cbd28a163c7728f1e;hb=83ff95b8a70b1dc7cfffdf0a6bb7f4500ebe1ca1;hp=9ed8d28c4c5d6f4cdd748bea5581ef7b639cbe6b;hpb=47f408ca8480937ac946db8455b7c3d3e0b353bb;p=sbcl.git diff --git a/src/code/early-extensions.lisp b/src/code/early-extensions.lisp index 9ed8d28..b73ac29 100644 --- a/src/code/early-extensions.lisp +++ b/src/code/early-extensions.lisp @@ -30,18 +30,23 @@ (def!type hash () `(integer 0 ,max-hash)) -;;; a type used for indexing into arrays, and for related quantities -;;; like lengths of lists +;;; a type used for indexing into sequences, and for related +;;; quantities like lengths of lists and other sequences. ;;; -;;; It's intentionally limited to one less than the -;;; ARRAY-DIMENSION-LIMIT for efficiency reasons, because in SBCL -;;; ARRAY-DIMENSION-LIMIT is MOST-POSITIVE-FIXNUM, and staying below -;;; that lets the system know it can increment a value of this type -;;; without having to worry about using a bignum to represent the -;;; result. +;;; A more correct value for the exclusive upper bound for indexing +;;; would be (1- ARRAY-DIMENSION-LIMIT) since ARRAY-DIMENSION-LIMIT is +;;; the exclusive maximum *size* of one array dimension (As specified +;;; in CLHS entries for MAKE-ARRAY and "valid array dimensions"). The +;;; current value is maintained to avoid breaking existing code that +;;; also uses that type for upper bounds on indices (e.g. sequence +;;; length). ;;; -;;; (It should be safe to use ARRAY-DIMENSION-LIMIT as an exclusive -;;; bound because ANSI specifies it as an exclusive bound.) +;;; In SBCL, ARRAY-DIMENSION-LIMIT is arranged to be a little smaller +;;; than MOST-POSITIVE-FIXNUM, for implementation (see comment above +;;; ARRAY-DIMENSION-LIMIT) and efficiency reasons: staying below +;;; MOST-POSITIVE-FIXNUM lets the system know it can increment a value +;;; of type INDEX without having to worry about using a bignum to +;;; represent the result. (def!type index () `(integer 0 (,sb!xc:array-dimension-limit))) ;;; like INDEX, but only up to half the maximum. Used by hash-table @@ -430,7 +435,6 @@ (eq (car clause) 'ignore)))) (cdr decl)))) decls)) - ;;; just like DOLIST, but with one-dimensional arrays (defmacro dovector ((elt vector &optional result) &body body) (multiple-value-bind (forms decls) (parse-body body :doc-string-allowed nil) @@ -464,6 +468,19 @@ `(with-locked-system-table (,n-table) ,iter-form) iter-form)))))) + +;;; Executes BODY for all entries of PLIST with KEY and VALUE bound to +;;; the respective keys and values. +(defmacro doplist ((key val) plist &body body) + (with-unique-names (tail) + `(let ((,tail ,plist) ,key ,val) + (loop (when (null ,tail) (return nil)) + (setq ,key (pop ,tail)) + (when (null ,tail) + (error "malformed plist, odd number of elements")) + (setq ,val (pop ,tail)) + (progn ,@body))))) + ;;;; hash cache utility @@ -698,13 +715,13 @@ ;;; our equality tests, because MEMBER and friends refer to EQLity. ;;; So: (defun equal-but-no-car-recursion (x y) - (cond - ((eql x y) t) - ((consp x) - (and (consp y) - (eql (car x) (car y)) - (equal-but-no-car-recursion (cdr x) (cdr y)))) - (t nil))) + (do () (()) + (cond ((eql x y) (return t)) + ((and (consp x) + (consp y) + (eql (pop x) (pop y)))) + (t + (return))))) ;;;; package idioms @@ -1154,9 +1171,11 @@ ;;; - SB-C::MERGE-TAIL-CALLS (policy), since 1.0.53.74 (11/2011) -> Late: 11/2012 ;;; - SB-EXT:QUIT, since 1.0.56.55 (05/2012) -> Late: 05/2013 ;;; - SB-UNIX:UNIX-EXIT, since 1.0.56.55 (05/2012) -> Late: 05/2013 +;;; - SB-DEBUG:*SHOW-ENTRY-POINT-DETAILS*, since 1.1.4.9 (02/2013) -> Late: 02/2014 ;;; ;;; LATE: ;;; - SB-SYS:OUTPUT-RAW-BYTES, since 1.0.8.16 (06/2007) -> Final: anytime +;;; Note: make sure CLX doesn't use it anymore! ;;; - SB-C::STACK-ALLOCATE-DYNAMIC-EXTENT (policy), since 1.0.19.7 -> Final: anytime ;;; - SB-C::STACK-ALLOCATE-VECTOR (policy), since 1.0.19.7 -> Final: anytime ;;; - SB-C::STACK-ALLOCATE-VALUE-CELLS (policy), since 1.0.19.7 -> Final: anytime @@ -1191,6 +1210,21 @@ (setf (compiler-macro-function ',name) (deprecation-compiler-macro ,state ,since ',name ',replacements))))) +(defun check-deprecated-variable (name) + (let ((info (info :variable :deprecated name))) + (when info + (deprecation-warning (car info) (cdr info) name nil)))) + +(defmacro define-deprecated-variable (state since name &key (value nil valuep) replacement) + `(progn + (setf (info :variable :deprecated ',name) (cons ,state ,since)) + ,@(when (member state '(:early :late)) + `((defvar ,name ,@(when valuep (list value)) + ,(let ((*package* (find-package :keyword))) + (format nil + "~@<~S has been deprecated as of SBCL ~A~@[, use ~S instead~].~:>" + name since replacement))))))) + ;;; Anaphoric macros (defmacro awhen (test &body body) `(let ((it ,test)) @@ -1300,12 +1334,16 @@ ;;; Returns a list of members of LIST. Useful for dealing with circular lists. ;;; For a dotted list returns a secondary value of T -- in which case the ;;; primary return value does not include the dotted tail. -(defun list-members (list) +;;; If the maximum length is reached, return a secondary value of :MAYBE. +(defun list-members (list &key max-length) (when list (do ((tail (cdr list) (cdr tail)) - (members (list (car list)) (cons (car tail) members))) - ((or (not (consp tail)) (eq tail list)) - (values members (not (listp tail))))))) + (members (list (car list)) (cons (car tail) members)) + (count 0 (1+ count))) + ((or (not (consp tail)) (eq tail list) + (and max-length (>= count max-length))) + (values members (or (not (listp tail)) + (and (>= count max-length) :maybe))))))) ;;; Default evaluator mode (interpeter / compiler) @@ -1398,3 +1436,16 @@ to :INTERPRET, an interpreter will be used.") (list (list :line lineno) (list :column colno) (list :file-position pos))))))) + +(declaim (inline schwartzian-stable-sort-list)) +(defun schwartzian-stable-sort-list (list comparator &key key) + (if (null key) + (stable-sort (copy-list list) comparator) + (let* ((key (if (functionp key) + key + (symbol-function key))) + (wrapped (mapcar (lambda (x) + (cons x (funcall key x))) + list)) + (sorted (stable-sort wrapped comparator :key #'cdr))) + (map-into sorted #'car sorted))))