Loading asdf.asd +26 −16 Original line number Diff line number Diff line Loading @@ -3,28 +3,37 @@ ;;; ;;; ;;; Free Software available under an MIT-style license. ;;; ;;; ;;; ;;; Copyright (c) 2001-2016 Daniel Barlow and contributors ;;; ;;; Copyright (c) 2001-2018 Daniel Barlow and contributors ;;; ;;; ;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (in-package :asdf) #+asdf3 (defsystem "asdf/prelude" ;; We can't rely on it being defined in uiop.asd, since that file isn't loaded. (defun call-without-redefinition-warnings (thunk) (handler-bind (((or #+allegro simple-warning #+clozure ccl:compiler-warning #+cmucl kernel:simple-style-warning #-(or allegro clozure cmucl) warning) #'muffle-warning)) (funcall thunk))) ;; Note that it's polite to sort the defsystem forms in dependency order, ;; and compulsory to sort them in defsystem-depends-on order. #+asdf3 (defsystem "asdf/prelude" :version (:read-file-form "version.lisp-expr") :around-compile call-without-redefinition-warnings ;; we need be the same as uiop :encoding :utf-8 :components ((:file "header"))) :components ((:file "header"))) #+asdf3 (defsystem "asdf/driver" ;; This is the same as "uiop", but used for transclusion in asdf.lisp. ;; Because asdf.asd can't afford to depend on reading uiop.asd ;; (which would cause circularity, since everything depends on reading asdf.asd), ;; we can't "just" :depends-on ("uiop") like we used to do. ;; Since ASDF 3.3, asdf.asd can't afford to depend on reading uiop.asd, ;; which would cause circularity, since everything depends on reading asdf.asd. ;; Therefore, we can't "just" :depends-on ("uiop") like we used to do, and instead ;; we transclude the list of uiop component into this secondary system. :pathname "uiop" :around-compile call-without-redefinition-warnings ;; we need be the same as uiop :components #.(getf (read-file-form (subpathname *load-pathname* "uiop/uiop.asd") :at 2) :components)) Loading Loading @@ -86,11 +95,12 @@ :long-description "ASDF builds Common Lisp software organized into defined systems." :version "3.3.2.5" ;; to be automatically updated by make bump-version :depends-on () #+asdf3 :encoding #+asdf3 :utf-8 :components ((:module "build" :components ((:file "asdf")))) . #-asdf3 () #+asdf3 (:encoding :utf-8 :class #+asdf3.1 package-inferred-system #-asdf3.1 system ;; For most purposes, asdf itself specially counts as a builtin system. ;; If you want to link it or do something forbidden to builtin systems, ;; specify separate dependencies on uiop (aka asdf-driver) and asdf/defsystem. #+asdf3 :builtin-system-p #+asdf3 t :components ((:module "build" :components ((:file "asdf")))) :in-order-to (#+asdf3 (prepare-op (monolithic-concatenate-source-op "asdf/defsystem")))) ;; specify separate dependencies on uiop (aka asdf/driver) and asdf/defsystem. :builtin-system-p t :in-order-to ((prepare-op (monolithic-concatenate-source-op "asdf/defsystem"))))) bundle.lisp +8 −1 Original line number Diff line number Diff line Loading @@ -523,8 +523,15 @@ which is probably not what you want; you probably need to tweak your output tran :static-library (resolve-symlinks* pathname)))) (defun linkable-system (x) (or (if-let (s (find-system x)) (or ;; If the system is available as source, use it. (if-let (s (find-system x)) (and (output-files 'lib-op s) s)) ;; If an ASDF upgrade is available from source, but not a UIOP upgrade to that, ;; then use the asdf/driver system instead of ;; the UIOP that was disabled by check-not-old-asdf-system. (if-let (s (and (equal x "uiop") (output-files 'lib-op "asdf") (find-system "asdf/driver"))) (and (output-files 'lib-op s) s)) ;; If there was no source upgrade, look for modules provided by the implementation. (if-let (p (system-module-pathname (coerce-name x))) (make-prebuilt-system x p)))) Loading find-system.lisp +9 −5 Original line number Diff line number Diff line Loading @@ -141,8 +141,9 @@ Do NOT try to load a .asd file directly with CL:LOAD. Always use ASDF:LOAD-ASD." (defvar *old-asdf-systems* (make-hash-table :test 'equal)) ;; (Private) function to check that a system that was found isn't an asdf downgrade. ;; Returns T if everything went right, NIL if the system was an ASDF of the same or older version, ;; that shall not be loaded. Also issue a warning if it was a strictly older version of ASDF. ;; Returns T if everything went right, NIL if the system was an ASDF at an older version, ;; or UIOP of the same or older version, that shall not be loaded. ;; Also issue a warning if it was a strictly older version of ASDF. (defun check-not-old-asdf-system (name pathname) (or (not (member name '("asdf" "uiop") :test 'equal)) (null pathname) Loading @@ -153,9 +154,12 @@ Do NOT try to load a .asd file directly with CL:LOAD. Always use ASDF:LOAD-ASD." (read-file-form version-pathname :at (if asdfp '(0) '(2 2 2))))) (old-version (asdf-version))) (cond ;; Don't load UIOP of the exact same version: we already loaded it as part of ASDF. ((and (equal old-version version) (equal name "uiop")) nil) ((version<= old-version version) t) ;; newer or same version: Good! ;; Same version is OK for ASDF, to allow loading from modified source. ;; However, do *not* load UIOP of the exact same version: ;; it was already loaded it as part of ASDF and would only be double-loading. ;; Be quiet about it, though, since it's a normal situation. ((equal old-version version) asdfp) ((version< old-version version) t) ;; newer version: Good! (t ;; old version: bad (ensure-gethash (list (namestring pathname) version) *old-asdf-systems* Loading tools/release.lisp +3 −2 Original line number Diff line number Diff line Loading @@ -66,8 +66,9 @@ (defun uiop-files () "list files in uiop" (let ((*asdf-version* "3")) ;; prevent check-not-old-asdf-system from hiding uiop.asd. (list* "README.md" "uiop.asd" "asdf-driver.asd" "contrib/debug.lisp" (system-source-files "uiop"))) (system-source-files "uiop")))) (defun uiop-name () (format nil "uiop-~A" (version-from-file))) (deftestcmd make-uiop-tarball () Loading uiop/uiop.asd +7 −5 Original line number Diff line number Diff line Loading @@ -27,10 +27,6 @@ It is transcluded into asdf.lisp together with ASDF/DEFSYSTEM, so if you did (re you already have a matching UIOP loaded." :author "Francois-Rene Rideau" :licence "MIT" :class #+asdf3.1 package-system #-asdf3.1 system #+asdf3.1 :version #+asdf3.1 (:read-file-form "version.lisp" :at (2 2 2)) #+asdf3 :encoding #+asdf3 :utf-8 #+asdf3 :around-compile #+asdf3 call-without-redefinition-warnings :components ((:static-file "contrib/debug.lisp") (:file "package") Loading @@ -47,4 +43,10 @@ you already have a matching UIOP loaded." (:file "run-program" :depends-on ("launch-program")) (:file "configuration" :depends-on ("image")) (:file "backward-driver" :depends-on ("lisp-build" "run-program" "configuration" "version")) (:file "driver" :depends-on ("backward-driver")))) (:file "driver" :depends-on ("backward-driver"))) . #-asdf3 () #+asdf3 (:encoding :utf-8 :around-compile call-without-redefinition-warnings . #-asdf3.1 () #+asdf3.1 (:class package-system :version (:read-file-form "version.lisp" :at (2 2 2))))) Loading
asdf.asd +26 −16 Original line number Diff line number Diff line Loading @@ -3,28 +3,37 @@ ;;; ;;; ;;; Free Software available under an MIT-style license. ;;; ;;; ;;; ;;; Copyright (c) 2001-2016 Daniel Barlow and contributors ;;; ;;; Copyright (c) 2001-2018 Daniel Barlow and contributors ;;; ;;; ;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (in-package :asdf) #+asdf3 (defsystem "asdf/prelude" ;; We can't rely on it being defined in uiop.asd, since that file isn't loaded. (defun call-without-redefinition-warnings (thunk) (handler-bind (((or #+allegro simple-warning #+clozure ccl:compiler-warning #+cmucl kernel:simple-style-warning #-(or allegro clozure cmucl) warning) #'muffle-warning)) (funcall thunk))) ;; Note that it's polite to sort the defsystem forms in dependency order, ;; and compulsory to sort them in defsystem-depends-on order. #+asdf3 (defsystem "asdf/prelude" :version (:read-file-form "version.lisp-expr") :around-compile call-without-redefinition-warnings ;; we need be the same as uiop :encoding :utf-8 :components ((:file "header"))) :components ((:file "header"))) #+asdf3 (defsystem "asdf/driver" ;; This is the same as "uiop", but used for transclusion in asdf.lisp. ;; Because asdf.asd can't afford to depend on reading uiop.asd ;; (which would cause circularity, since everything depends on reading asdf.asd), ;; we can't "just" :depends-on ("uiop") like we used to do. ;; Since ASDF 3.3, asdf.asd can't afford to depend on reading uiop.asd, ;; which would cause circularity, since everything depends on reading asdf.asd. ;; Therefore, we can't "just" :depends-on ("uiop") like we used to do, and instead ;; we transclude the list of uiop component into this secondary system. :pathname "uiop" :around-compile call-without-redefinition-warnings ;; we need be the same as uiop :components #.(getf (read-file-form (subpathname *load-pathname* "uiop/uiop.asd") :at 2) :components)) Loading Loading @@ -86,11 +95,12 @@ :long-description "ASDF builds Common Lisp software organized into defined systems." :version "3.3.2.5" ;; to be automatically updated by make bump-version :depends-on () #+asdf3 :encoding #+asdf3 :utf-8 :components ((:module "build" :components ((:file "asdf")))) . #-asdf3 () #+asdf3 (:encoding :utf-8 :class #+asdf3.1 package-inferred-system #-asdf3.1 system ;; For most purposes, asdf itself specially counts as a builtin system. ;; If you want to link it or do something forbidden to builtin systems, ;; specify separate dependencies on uiop (aka asdf-driver) and asdf/defsystem. #+asdf3 :builtin-system-p #+asdf3 t :components ((:module "build" :components ((:file "asdf")))) :in-order-to (#+asdf3 (prepare-op (monolithic-concatenate-source-op "asdf/defsystem")))) ;; specify separate dependencies on uiop (aka asdf/driver) and asdf/defsystem. :builtin-system-p t :in-order-to ((prepare-op (monolithic-concatenate-source-op "asdf/defsystem")))))
bundle.lisp +8 −1 Original line number Diff line number Diff line Loading @@ -523,8 +523,15 @@ which is probably not what you want; you probably need to tweak your output tran :static-library (resolve-symlinks* pathname)))) (defun linkable-system (x) (or (if-let (s (find-system x)) (or ;; If the system is available as source, use it. (if-let (s (find-system x)) (and (output-files 'lib-op s) s)) ;; If an ASDF upgrade is available from source, but not a UIOP upgrade to that, ;; then use the asdf/driver system instead of ;; the UIOP that was disabled by check-not-old-asdf-system. (if-let (s (and (equal x "uiop") (output-files 'lib-op "asdf") (find-system "asdf/driver"))) (and (output-files 'lib-op s) s)) ;; If there was no source upgrade, look for modules provided by the implementation. (if-let (p (system-module-pathname (coerce-name x))) (make-prebuilt-system x p)))) Loading
find-system.lisp +9 −5 Original line number Diff line number Diff line Loading @@ -141,8 +141,9 @@ Do NOT try to load a .asd file directly with CL:LOAD. Always use ASDF:LOAD-ASD." (defvar *old-asdf-systems* (make-hash-table :test 'equal)) ;; (Private) function to check that a system that was found isn't an asdf downgrade. ;; Returns T if everything went right, NIL if the system was an ASDF of the same or older version, ;; that shall not be loaded. Also issue a warning if it was a strictly older version of ASDF. ;; Returns T if everything went right, NIL if the system was an ASDF at an older version, ;; or UIOP of the same or older version, that shall not be loaded. ;; Also issue a warning if it was a strictly older version of ASDF. (defun check-not-old-asdf-system (name pathname) (or (not (member name '("asdf" "uiop") :test 'equal)) (null pathname) Loading @@ -153,9 +154,12 @@ Do NOT try to load a .asd file directly with CL:LOAD. Always use ASDF:LOAD-ASD." (read-file-form version-pathname :at (if asdfp '(0) '(2 2 2))))) (old-version (asdf-version))) (cond ;; Don't load UIOP of the exact same version: we already loaded it as part of ASDF. ((and (equal old-version version) (equal name "uiop")) nil) ((version<= old-version version) t) ;; newer or same version: Good! ;; Same version is OK for ASDF, to allow loading from modified source. ;; However, do *not* load UIOP of the exact same version: ;; it was already loaded it as part of ASDF and would only be double-loading. ;; Be quiet about it, though, since it's a normal situation. ((equal old-version version) asdfp) ((version< old-version version) t) ;; newer version: Good! (t ;; old version: bad (ensure-gethash (list (namestring pathname) version) *old-asdf-systems* Loading
tools/release.lisp +3 −2 Original line number Diff line number Diff line Loading @@ -66,8 +66,9 @@ (defun uiop-files () "list files in uiop" (let ((*asdf-version* "3")) ;; prevent check-not-old-asdf-system from hiding uiop.asd. (list* "README.md" "uiop.asd" "asdf-driver.asd" "contrib/debug.lisp" (system-source-files "uiop"))) (system-source-files "uiop")))) (defun uiop-name () (format nil "uiop-~A" (version-from-file))) (deftestcmd make-uiop-tarball () Loading
uiop/uiop.asd +7 −5 Original line number Diff line number Diff line Loading @@ -27,10 +27,6 @@ It is transcluded into asdf.lisp together with ASDF/DEFSYSTEM, so if you did (re you already have a matching UIOP loaded." :author "Francois-Rene Rideau" :licence "MIT" :class #+asdf3.1 package-system #-asdf3.1 system #+asdf3.1 :version #+asdf3.1 (:read-file-form "version.lisp" :at (2 2 2)) #+asdf3 :encoding #+asdf3 :utf-8 #+asdf3 :around-compile #+asdf3 call-without-redefinition-warnings :components ((:static-file "contrib/debug.lisp") (:file "package") Loading @@ -47,4 +43,10 @@ you already have a matching UIOP loaded." (:file "run-program" :depends-on ("launch-program")) (:file "configuration" :depends-on ("image")) (:file "backward-driver" :depends-on ("lisp-build" "run-program" "configuration" "version")) (:file "driver" :depends-on ("backward-driver")))) (:file "driver" :depends-on ("backward-driver"))) . #-asdf3 () #+asdf3 (:encoding :utf-8 :around-compile call-without-redefinition-warnings . #-asdf3.1 () #+asdf3.1 (:class package-system :version (:read-file-form "version.lisp" :at (2 2 2)))))