...
 
Commits (87)
......@@ -27,6 +27,11 @@ doc/version.texinfo
doc/*.log
*.tmp
uiop/doc/uiop.html
uiop/doc/uiop.info
uiop/doc/uiop.pdf
uiop/doc/uiop.texinfo
LICENSE
README.html
tmp/
......@@ -66,7 +71,7 @@ debian/files
.pc
/.DS_Store
.DS_Store
core
......
......@@ -160,6 +160,7 @@ push:
doc: ;
website:
${MAKE} -C doc website
${MAKE} -C uiop/doc website
clean_dirs = $(sourceDirectory)
clean_extensions = fasl dfsl cfsl fasl fas lib dx32fsl lx64fsl lx32fsl ufasl o bak x86f vbin amd64f sparcf sparc64f hpf hp64f
......@@ -172,7 +173,7 @@ clean:
find $$dir \( -name "*.$$ext" \) \
-and -not -path \""*/.git/*"\" \
-and -not -path \""*/_darcs/*"\" \
-and -not -path \""*/tags/*"\" -print -delete; \
-and -not -path \""*/tags/*"\" -delete; \
done; \
fi; \
echo "Cleaned $$dir"; \
......@@ -181,6 +182,7 @@ clean:
rm -rf build/ LICENSE test/try-reloading-dependency.asd test/hello-world-example asdf.lisp
rm -rf test/hello-world-example.exe test/mkcl_*.dll # needed only on MS-Windows
${MAKE} -C doc clean
${MAKE} -C uiop/doc clean
mrproper:
git clean -xfd
......
......@@ -150,7 +150,7 @@ Debugging ASDF
To interactively debug ASDF, you may load it in such a way that `M-.` will work,
by installing the source code, and running:
(map () 'load (asdf:input-files :monolithic-concatenate-source-op "asdf"))
(map () 'load (asdf:input-files :monolithic-concatenate-source-op "asdf/defsystem"))
To interactively use the `asdf-tools`, you need to either have
all its dependencies installed and configured.
......@@ -295,4 +295,5 @@ How do I navigate this source tree?
* This file.
* [TODO](TODO)
* Plenty of ideas for how to further improve ASDF.
* Plenty of ideas for how to further improve ASDF
(not all of them guaranteed good ideas.)
......@@ -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)
;; 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"
;; Note that it's polite to sort the defsystem forms in dependency order,
;; and compulsory to sort them in defsystem-depends-on order.
: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))
......@@ -84,13 +93,14 @@
:licence "MIT"
:description "Another System Definition Facility"
:long-description "ASDF builds Common Lisp software organized into defined systems."
:version "3.3.2.2" ;; to be automatically updated by make bump-version
:version "3.3.2.13" ;; to be automatically updated by make bump-version
:depends-on ()
#+asdf3 :encoding #+asdf3 :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"))))
. #-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.
:builtin-system-p t
:in-order-to ((prepare-op (monolithic-concatenate-source-op "asdf/defsystem")))))
......@@ -523,8 +523,17 @@ 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 (coerce-name 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))))
......
......@@ -77,9 +77,9 @@ or NIL for top-level components (a.k.a. systems)"))
(defmethod component-parent ((component null)) nil)
;; Deprecated: Backward compatible way of computing the FILE-TYPE of a component.
;; TODO: find users, have them stop using that, remove it for ASDF4.
(defgeneric source-file-type (component system)
(:documentation "DEPRECATED. Use the FILE-TYPE of a COMPONENT instead."))
(with-asdf-deprecation (:style-warning "3.4")
(defgeneric source-file-type (component system)
(:documentation "DEPRECATED. Use the FILE-TYPE of a COMPONENT instead.")))
(define-condition duplicate-names (system-definition-error)
((name :initarg :name :reader duplicate-names-name))
......
This diff is collapsed.
......@@ -185,7 +185,7 @@ The `:perform` clause in the second system does the testing itself.
In the test system, `fiveam` is the name of a popular test library,
and the content of the `perform` method is how to invoke this library
to run the test suite `:foobar`.
Obvious YMMV if you use a different library.
Obviously your mileage may vary if you use a different library.
#### <a name="notes_asdf2"></a>Note on ASDF 2 compatibility
......@@ -773,7 +773,7 @@ in a separate `.asd` file that you `:defsystem-depends-on`.
Then, `.asd` files are read with the current package being `asdf-user`.
You MAY use any symbols defined in packages `cl`, `asdf` and `uiop`,
and you SHOULD stay in package `asdf-user` if it suffices;
you SHOULD NOT needlessly create a package for you system definition file
you SHOULD NOT needlessly create a package for your system definition file
if you're not going to define any such function nor variable nor macro.
But you MUST NOT pollute that package with bindings that could clash with uses by other systems.
......@@ -830,7 +830,7 @@ to the otherwise deprecated use of read-time conditionals, as in:
If the condition you want to express doesn't have a corresponding `*features*` keyword,
you MAY use a `(when ... (pushnew :my-keyword *features*))` form to add a feature keyword for it.
However, you SHOULD NOT needlessly push new features;
in particular, the mere fact of have loaded your system does not warrant a new feature.
in particular, the mere fact of having loaded your system does not warrant a new feature.
A feature is only warranted if your system is some deep infrastructure
with mostly compatible rivals that it needs to be distinguished from.
......
......@@ -394,10 +394,18 @@ Corman Common Lisp <admin@cormanlisp.com>
<h3>Documentation</h3>
<p>You can read our manual:</p>
<ul>
<li><a href="asdf.html">as one HTML file</a></li>
<li><a href="asdf/">split into one HTML file per section</a></li>
<li><a href="asdf.pdf">as a PDF document</a></li>
<li><a href="https://gitlab.common-lisp.net/asdf/asdf/blob/master/doc/asdf.texinfo">as texinfo source</a></li>
<li>ASDF</li>
<ul>
<li><a href="asdf.html">as one HTML file</a></li>
<li><a href="asdf/">split into one HTML file per section</a></li>
<li><a href="asdf.pdf">as a PDF document</a></li>
<li><a href="https://gitlab.common-lisp.net/asdf/asdf/blob/master/doc/asdf.texinfo">as texinfo source</a></li>
</ul>
<li>UIOP</li>
<ul>
<li><a href="uiop.html">as one HTML file</a></li>
<li><a href="uiop.pdf">as a PDF document</a></li>
</ul>
</ul>
<p>
The first few sections,
......
......@@ -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)
......@@ -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*
......
;;; -*- mode: Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp ; buffer-read-only: t; -*-
;;; This is ASDF 3.3.2.2: Another System Definition Facility.
;;; This is ASDF 3.3.2.13: Another System Definition Facility.
;;;
;;; Feedback, bug reports, and patches are all welcome:
;;; please mail to <asdf-devel@common-lisp.net>.
......@@ -45,3 +45,14 @@
;;; The problem with writing a defsystem replacement is bootstrapping:
;;; we can't use defsystem to compile it. Hence, all in one file.
#+genera
(eval-when (:compile-toplevel :load-toplevel :execute)
(multiple-value-bind (system-major system-minor)
(sct:get-system-version)
(multiple-value-bind (is-major is-minor)
(sct:get-system-version "Intel-Support")
(unless (or (> system-major 452)
(and is-major
(or (> is-major 3)
(and (= is-major 3) (> is-minor 86)))))
(error "ASDF requires either System 453 or later or Intel Support 3.87 or later")))))
......@@ -77,6 +77,7 @@
#:system-maintainer
#:system-license
#:system-licence
#:system-version
#:system-source-file
#:system-source-directory
#:system-relative-pathname
......
......@@ -17,6 +17,8 @@
#:class-for-type #:*default-component-class*
#:determine-system-directory #:parse-component-form
#:non-toplevel-system #:non-system-system #:bad-system-name
#:*known-systems-with-bad-secondary-system-names*
#:known-system-with-bad-secondary-system-names-p
#:sysdef-error-component #:check-component-input
#:explain))
(in-package :asdf/parse-defsystem)
......@@ -169,7 +171,7 @@ Please only define ~S and secondary systems with a name starting with ~S (e.g. ~
;;; "inline methods"
(with-upgradability ()
(defparameter* +asdf-methods+
'(perform-with-restarts perform explain output-files operation-done-p))
'(perform-with-restarts perform explain output-files operation-done-p))
(defun %remove-component-inline-methods (component)
(dolist (name +asdf-methods+)
......@@ -182,19 +184,55 @@ Please only define ~S and secondary systems with a name starting with ~S (e.g. ~
(component-inline-methods component)))
(component-inline-methods component) nil)
(defparameter *standard-method-combination-qualifiers*
'(:around :before :after))
;;; Find inline method definitions of the form
;;;
;;; :perform (test-op :before (operation component) ...)
;;;
;;; in REST (which is the plist of all DEFSYSTEM initargs) and define the specified methods.
(defun %define-component-inline-methods (ret rest)
;; find key-value pairs that look like inline method definitions in REST. For each identified
;; definition, parse it and, if it is well-formed, define the method.
(loop* :for (key value) :on rest :by #'cddr
:for name = (and (keywordp key) (find key +asdf-methods+ :test 'string=))
:when name :do
(destructuring-bind (op &rest body) value
(loop :for arg = (pop body)
:while (atom arg)
:collect arg :into qualifiers
:finally
(destructuring-bind (o c) arg
(pushnew
(eval `(defmethod ,name ,@qualifiers ((,o ,op) (,c (eql ,ret))) ,@body))
(component-inline-methods ret)))))))
;; parse VALUE as an inline method definition of the form
;;
;; (OPERATION-NAME [QUALIFIER] (OPERATION-PARAMETER COMPONENT-PARAMETER) &rest BODY)
(destructuring-bind (operation-name &rest rest) value
(let ((qualifiers '()))
;; ensure that OPERATION-NAME is a symbol.
(unless (and (symbolp operation-name) (not (null operation-name)))
(sysdef-error "Ill-formed inline method: ~S. The first element is not a symbol ~
designating an operation but ~S."
value operation-name))
;; ensure that REST starts with either a cons (potential lambda list, further checked
;; below) or a qualifier accepted by the standard method combination. Everything else
;; is ill-formed. In case of a valid qualifier, pop it from REST so REST now definitely
;; has to start with the lambda list.
(cond
((consp (car rest)))
((not (member (car rest)
*standard-method-combination-qualifiers*))
(sysdef-error "Ill-formed inline method: ~S. Only a single of the standard ~
qualifiers ~{~S~^ ~} is allowed, not ~S."
value *standard-method-combination-qualifiers* (car rest)))
(t
(setf qualifiers (list (pop rest)))))
;; REST must start with a two-element lambda list.
(unless (and (listp (car rest))
(length=n-p (car rest) 2)
(null (cddar rest)))
(sysdef-error "Ill-formed inline method: ~S. The operation name ~S is not followed by ~
a lambda-list of the form (OPERATION COMPONENT) and a method body."
value operation-name))
;; define the method.
(destructuring-bind ((o c) &rest body) rest
(pushnew
(eval `(defmethod ,name ,@qualifiers ((,o ,operation-name) (,c (eql ,ret))) ,@body))
(component-inline-methods ret)))))))
(defun %refresh-component-inline-methods (component rest)
;; clear methods, then add the new ones
......@@ -308,6 +346,13 @@ system names contained using COERCE-NAME. Return the result."
(coerce-name (component-system component))))
component)))
(defparameter* *known-systems-with-bad-secondary-system-names*
(list-to-hash-set '("cl-ppcre")))
(defun known-system-with-bad-secondary-system-names-p (asd-name)
;; Does .asd file with name ASD-NAME contain known exceptions
;; that should be screened out of checking for BAD-SYSTEM-NAME?
(gethash asd-name *known-systems-with-bad-secondary-system-names*))
(defun register-system-definition
(name &rest options &key pathname (class 'system) (source-file () sfp)
defsystem-depends-on &allow-other-keys)
......@@ -325,8 +370,11 @@ system names contained using COERCE-NAME. Return the result."
(let* ((asd-name (and source-file
(equal "asd" (fix-case (pathname-type source-file)))
(fix-case (pathname-name source-file))))
;; note that PRIMARY-NAME is a *syntactically* primary name
(primary-name (primary-system-name name)))
(when (and asd-name (not (equal asd-name primary-name)))
(when (and asd-name
(not (equal asd-name primary-name))
(not (known-system-with-bad-secondary-system-names-p asd-name)))
(warn (make-condition 'bad-system-name :source-file source-file :name name))))
(let* (;; NB: handle defsystem-depends-on BEFORE to create the system object,
;; so that in case it fails, there is no incomplete object polluting the build.
......
......@@ -90,7 +90,7 @@ after having found a .asd file? True by default.")
(recurse-beyond-asds *recurse-beyond-asds*) ignore-cache)
(let ((visited (make-hash-table :test 'equalp)))
(flet ((collectp (dir)
(unless (and (not ignore-cache) (process-source-registry-cache directory collect))
(unless (and (not ignore-cache) (process-source-registry-cache dir collect))
(let ((asds (collect-asds-in-directory dir collect)))
(or recurse-beyond-asds (not asds)))))
(recursep (x) ; x will be a directory pathname
......
......@@ -9,6 +9,7 @@
#:system-source-file #:system-source-directory #:system-relative-pathname
#:system-description #:system-long-description
#:system-author #:system-maintainer #:system-licence #:system-license
#:system-version
#:definition-dependency-list #:definition-dependency-set #:system-defsystem-depends-on
#:system-depends-on #:system-weakly-depends-on
#:component-build-pathname #:build-pathname
......@@ -30,8 +31,10 @@
If no system is found, then signal an error if ERROR-P is true (the default), or else return NIL.
A system designator is usually a string (conventionally all lowercase) or a symbol, designating
the same system as its downcased name; it can also be a system object (designating itself)."))
(defgeneric system-source-file (system)
(:documentation "Return the source file in which system is defined."))
;; This is bad design, but was the easiest kluge I found to let the user specify that
;; some special actions create outputs at locations controled by the user that are not affected
;; by the usual output-translations.
......@@ -50,6 +53,7 @@ NB: This interface is subject to change. Please contact ASDF maintainers if you
(with no argument) when running an image dumped from the COMPONENT.
NB: This interface is subject to change. Please contact ASDF maintainers if you use it."))
(defmethod component-entry-point ((c component))
nil))
......@@ -74,19 +78,21 @@ a SYSTEM is redefined and its class is modified."))
(defclass system (module proto-system)
;; Backward-compatibility: inherit from module. ASDF4: only inherit from parent-component.
(;; {,long-}description is now inherited from component, but we add the legacy accessors
(description :accessor system-description)
(long-description :accessor system-long-description)
(author :accessor system-author :initarg :author :initform nil)
(maintainer :accessor system-maintainer :initarg :maintainer :initform nil)
(licence :accessor system-licence :initarg :licence
:accessor system-license :initarg :license :initform nil)
(homepage :accessor system-homepage :initarg :homepage :initform nil)
(bug-tracker :accessor system-bug-tracker :initarg :bug-tracker :initform nil)
(mailto :accessor system-mailto :initarg :mailto :initform nil)
(long-name :accessor system-long-name :initarg :long-name :initform nil)
(description :writer (setf system-description))
(long-description :writer (setf system-long-description))
(author :writer (setf system-author) :initarg :author :initform nil)
(maintainer :writer (setf system-maintainer) :initarg :maintainer :initform nil)
(licence :writer (setf system-licence) :initarg :licence
:writer (setf system-license) :initarg :license
:initform nil)
(homepage :writer (setf system-homepage) :initarg :homepage :initform nil)
(bug-tracker :writer (setf system-bug-tracker) :initarg :bug-tracker :initform nil)
(mailto :writer (setf system-mailto) :initarg :mailto :initform nil)
(long-name :writer (setf system-long-name) :initarg :long-name :initform nil)
;; Conventions for this slot aren't clear yet as of ASDF 2.27, but whenever they are, they will be enforced.
;; I'm introducing the slot before the conventions are set for maximum compatibility.
(source-control :accessor system-source-control :initarg :source-control :initform nil)
(source-control :writer (setf system-source-control) :initarg :source-control :initform nil)
(builtin-system-p :accessor builtin-system-p :initform nil :initarg :builtin-system-p)
(build-pathname
:initform nil :initarg :build-pathname :accessor component-build-pathname)
......@@ -162,6 +168,35 @@ NB: The onus is unhappily on the user to avoid clashes."
(frob-substrings (coerce-name name) '("/" ":" "\\") "--")))
;;; System virtual slot readers, recursing to the primary system if needed.
(with-upgradability ()
(defvar *system-virtual-slots* '(long-name description long-description
author maintainer mailto
homepage source-control
licence version bug-tracker)
"The list of system virtual slot names.")
(defun system-virtual-slot-value (system slot-name)
"Return SYSTEM's virtual SLOT-NAME value.
If SYSTEM's SLOT-NAME value is NIL and SYSTEM is a secondary system, look in
the primary one."
(or (slot-value system slot-name)
(unless (primary-system-p system)
(slot-value (find-system (primary-system-name system))
slot-name))))
(defmacro define-system-virtual-slot-reader (slot-name)
`(defun* ,(intern (concatenate 'string (string :system-)
(string slot-name)))
(system)
(system-virtual-slot-value system ',slot-name)))
(defmacro define-system-virtual-slot-readers ()
`(progn ,@(mapcar (lambda (slot-name)
`(define-system-virtual-slot-reader ,slot-name))
*system-virtual-slots*)))
(define-system-virtual-slot-readers)
(defun system-license (system)
(system-virtual-slot-value system 'licence)))
;;;; Pathnames
(with-upgradability ()
......
......@@ -372,12 +372,18 @@ upgrade_tags () {
# The 3.3 series provides the asdf3.3 feature, meaning users can rely on
# all its new features (proper phase separation) as well as earlier features.
# 3.3.0 (2017-10-06) first in 3.3 series
# 3.3.1 (2017-11-14) bug fixes, second and latest in 3.3 series
# 3.3.1 (2017-11-14) bug fixes, second
# 3.3.2 (2018-05-03) bug fixes, third and latest in 3.3 series
#
# We return the above designated versions in order of decreasing relevance,
# which pretty much means REQUIRE and most recent first.
# We picked the last and first in each relevant series, plus 2.26.
echo REQUIRE 3.3.1 3.3.0 3.2.1 3.2.0 3.1.7 3.1.2 3.0.3 2.26
if [ "$lisp" = cmucl ]; then
echo REQUIRE 3.3.2 3.3.1 3.3.0
else
echo REQUIRE 3.3.2 3.3.1 3.3.0 3.2.1 3.2.0 3.1.7 3.1.2 3.0.3 2.26
fi
#echo 3.1.7 3.1.6 3.1.5 3.1.4 3.1.3 3.1.2
#echo 3.0.3 3.0.2 3.0.1
......
(defsystem "test-bad-system-name"
:description "Test special handling of CL-PPCRE")
(defsystem "test-bad-system-name-hyphen-separated-subsystem"
:depends-on ("test-bad-system-name"))
;;; -*- Lisp -*-
(defun defsystem-error-handler (form &optional (error 'error))
(declare (ignore error))
(handler-case (eval form)
(error () t)
(:no-error (&rest values)
......@@ -16,3 +17,14 @@
(defsystem-error (non-toplevel-system)
:foo :components ((:system :bar)))
;;; test for my kluge for cl-ppcre
(assert
(catch 'bad-name-warn
(handler-bind
((bad-system-name #'(lambda (c)
(declare (ignorable c))
(format t "~&Catching bad name warning: ~A~%" c)
(throw 'bad-name-warn nil))))
(let ((asdf::*known-systems-with-bad-secondary-system-names*
(list-to-hash-set '("test-bad-system-name"))))
(find-system "test-bad-system-name")))))
;;; -*- Lisp -*-
(signals formatted-system-definition-error
(def-test-system "foo" :perform ((test-op (o c)))))
(leave-test "correctly detected ill-formed system definition." 0)
\ No newline at end of file
;;; -*- Lisp -*-
(in-package :asdf-test)
(when (member :clisp *features*)
(quit 0))
(defparameter *lambda-string* nil)
(defun string-char-codes (s)
......
......@@ -2,10 +2,15 @@
(DBG :foo (current-lisp-file-pathname))
(unless (or #+(or allegro (and clisp os-unix) clozure cmucl
(and ecl (not ecl-bytecmp)) lispworks mkcl sbcl scl) t)
(and ecl (not ecl-bytecmp)) lispworks mkcl sbcl scl)
t)
(DBG "Creating images is not supported on your CL implementation")
(leave-test "Skipping test" 0))
(when (or #+clisp t)
(DBG "clisp does not reliably run test-program.")
(leave-test "Skipping test" 0))
#+(and sbcl openbsd)
(let ((version (run-program "uname -r" :output '(:string :stripped t))))
(when (version-satisfies version "6.0")
......
......@@ -178,7 +178,7 @@
#+allegro :sax
#+clisp (first (remove "asdf" *dynmod-list* :test 'equal))
#+(or clozure cmucl) :defsystem
#+ecl :rt ;; loads faster than :ecl-quicklisp
#+ecl :sockets
#+lispworks "comm"
#+mkcl :walker
#+sbcl :sb-md5
......
......@@ -122,7 +122,17 @@ a command-line executable for LispWorks this way:
(create-image asdf.a (list asdf.o) :kind :lib))))
(defun install-uiop-and-asdf-as-modules ()
(let ((uiop.fasl (uiop-module-fasl)))
(let ((uiop.fasl (uiop-module-fasl))
(uiop.asd (subpathname *asdf-dir* "uiop/uiop.asd")))
;; We need to *explicitly* LOAD UIOP's system definition because FIND-SYSTEM
;; will hide any uiop.asd files with a version that is not strictly greater
;; than the one that is loaded. Because the first step of the install
;; procedure is to load the version of ASDF/UIOP that we're trying to
;; install, that obviously causes issues. We are unable to LOAD-ASD the asd
;; file because UIOP is a PRELOADED system so LOAD-ASD will use the existing
;; system definition (which is essentially empty) to try and find the source
;; files and CLEAR-SYSTEM doesn't help either.
(load uiop.asd)
(with-file-replacement (uiop.fasl)
(operate 'compile-bundle-op "uiop")
(rename-file-overwriting-target (first (output-files 'compile-bundle-op "uiop")) uiop.fasl)
......
......@@ -66,8 +66,9 @@
(defun uiop-files ()
"list files in uiop"
(list* "README.md" "uiop.asd" "asdf-driver.asd" "contrib/debug.lisp"
(system-source-files "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"))))
(defun uiop-name ()
(format nil "uiop-~A" (version-from-file)))
(deftestcmd make-uiop-tarball ()
......
......@@ -106,22 +106,27 @@ Each file starts with a package definition form that lists the exported symbols.
All the exported functions, macros and variables ought to have proper docstrings.
If not, then it's a legitimate bug that we invite you to report.
Maybe some automated tool will extract all that information and
You can extract a manual from the docstrings
by running `make` in the directory `uiop/doc`.
Other automated tools may hopefully extract all that information and
make a webpage from it, at which point it would be nice to insert a link here.
But many tools fail to extract useful data.
One tool with which you can extract all the documentation is HEΛP.
At this time, the interface is not great: it isn't obvious at all that you can indeed
use a scrollbar on the right of the top left side panel to navigate the many packages;
once you click on the package you're interested in, you can see its defined symbols:
<http://bimib.disco.unimib.it/people/Marco.Antoniotti/Projects/CL/HELAMBDAP/tests/asdf-uiop/docs/html/dictionary/dictionary.html>
* <http://bimib.disco.unimib.it/people/Marco.Antoniotti/Projects/CL/HELAMBDAP/tests/asdf-uiop/docs/html/dictionary/dictionary.html>
The next version of [Declt](https://www.lrde.epita.fr/~didier/software/lisp/misc.php#declt)
and through it of QuickRef will support extracting the documentation from UIOP:
<https://quickref.common-lisp.net/>
Another automated documentation tool is quickdocs, but unhappily, at the time of this writing,
it only extracts information from the first package
(see [bug #24](https://github.com/fukamachi/quickdocs/issues/24)):
* <http://quickdocs.org/uiop/api>
<http://quickdocs.org/uiop/api>
Help wanted extracting working documentation from UIOP's docstrings.
......
......@@ -32,7 +32,8 @@ DEPRECATED. Use UIOP:XDG-CONFIG-PATHNAMES instead."
(xdg-config-pathnames "common-lisp"))
(defun system-configuration-directories ()
"Return the list of system configuration directories for common-lisp.
DEPRECATED. Use UIOP:CONFIG-SYSTEM-PATHNAMES instead."
DEPRECATED. Use UIOP:SYSTEM-CONFIG-PATHNAMES (with argument \"common-lisp\"),
instead."
(system-config-pathnames "common-lisp"))
(defun in-first-directory (dirs x &key (direction :input))
"Finds the first appropriate file named X in the list of DIRS for I/O
......
......@@ -29,10 +29,10 @@
;;;; Early meta-level tweaks
#+(or allegro clasp clisp clozure cmucl ecl mezzano mkcl sbcl)
#+(or allegro clasp clisp clozure cmucl ecl lispworks mezzano mkcl sbcl)
(eval-when (:load-toplevel :compile-toplevel :execute)
(when (and #+allegro (member :ics *features*)
#+(or clasp clisp cmucl ecl mkcl) (member :unicode *features*)
#+(or clasp clisp cmucl ecl lispworks mkcl) (member :unicode *features*)
#+clozure (member :openmcl-unicode-strings *features*)
#+sbcl (member :sb-unicode *features*))
;; Check for unicode at runtime, so that a hypothetical FASL compiled with unicode
......
......@@ -3,7 +3,7 @@
(uiop/package:define-package :uiop/configuration
(:recycle :uiop/configuration :asdf/configuration) ;; necessary to upgrade from 2.27.
(:use :uiop/common-lisp :uiop/utility
(:use :uiop/package :uiop/common-lisp :uiop/utility
:uiop/os :uiop/pathname :uiop/filesystem :uiop/stream :uiop/image :uiop/lisp-build)
(:export
#:user-configuration-directories #:system-configuration-directories ;; implemented in backward-driver
......@@ -18,7 +18,8 @@
#:report-invalid-form #:invalid-configuration #:*ignored-configuration-form* #:*user-cache*
#:*clear-configuration-hook* #:clear-configuration #:register-clear-configuration-hook
#:resolve-location #:location-designator-p #:location-function-p #:*here-directory*
#:resolve-relative-location #:resolve-absolute-location #:upgrade-configuration))
#:resolve-relative-location #:resolve-absolute-location #:upgrade-configuration
#:uiop-directory))
(in-package :uiop/configuration)
(with-upgradability ()
......@@ -410,4 +411,25 @@ or just the first one (for direction :output or :io).
"Compute (and return) the location of the default user-cache for translate-output
objects. Side-effects for cached file location computation."
(setf *user-cache* (xdg-cache-home "common-lisp" :implementation)))
(register-image-restore-hook 'compute-user-cache))
(register-image-restore-hook 'compute-user-cache)
(defun uiop-directory ()
"Try to locate the UIOP source directory at runtime"
(labels ((pf (x) (ignore-errors (probe-file* x)))
(sub (x y) (pf (subpathname x y)))
(ssd (x) (ignore-errors (symbol-call :asdf :system-source-directory x))))
;; NB: conspicuously *not* including searches based on #.(current-lisp-pathname)
(or
;; Look under uiop if available as source override, under asdf if avaiable as source
(ssd "uiop")
(sub (ssd "asdf") "uiop/")
;; Look in recommended path for user-visible source installation
(sub (user-homedir-pathname) "common-lisp/asdf/uiop/")
;; Look in XDG paths under known package names for user-invisible source installation
(xdg-data-pathname "common-lisp/source/asdf/uiop/")
(xdg-data-pathname "common-lisp/source/cl-asdf/uiop/") ; traditional Debian location
;; The last one below is useful for Fare, primary (sole?) known user
(sub (user-homedir-pathname) "cl/asdf/uiop/")
(cerror "Configure source registry to include UIOP source directory and retry."
"Unable to find UIOP directory")
(uiop-directory)))))
uiop := uiop
ifeq (${user},)
userat :=
else
userat := ${user}@
endif
website:=${userat}common-lisp.net:/project/asdf/public_html/
output = ${uiop}.html ${uiop}.pdf
webfiles = ${output}
.PHONY: clean html pdf include clean-include clean-crap info doc texinfo website
website: all
rsync -lt --no-g ${webfiles} ${website}
all: pdf html info clean-crap
clean-include:
rm -rf include
clean-crap:
rm -f *.aux *.cp *.fn *.fns *.ky *.log *.pg *.toc *.tp *.tps *.vr *.vrs
clean: clean-include
rm -rf *.pdf *.html *.info ${uiop}.texinfo ${uiop} *.fasl
fasl: docstrings.lisp
sbcl --no-userinit --eval '(require :asdf)' \
--eval '(compile-file "docstrings.lisp")' \
--eval '(quit)'
include: fasl
sbcl --no-userinit --eval '(require :asdf)' \
--load docstrings \
--eval '(sb-texinfo:generate-includes "include/" (list :UIOP/PACKAGE :UIOP/COMMON-LISP :UIOP/UTILITY :UIOP/VERSION :UIOP/OS :UIOP/PATHNAME :UIOP/FILESYSTEM :UIOP/STREAM :UIOP/IMAGE :UIOP/LISP-BUILD :UIOP/LAUNCH-PROGRAM :UIOP/RUN-PROGRAM :UIOP/CONFIGURATION :UIOP/BACKWARD-DRIVER))' \
--eval '(quit)'
texinfo : include
sbcl --no-userinit --eval '(require :asdf)' \
--load docstrings \
--eval "(sb-texinfo:complete-texinfo-template \"template.texinfo\" \"${uiop}.texinfo\" \"include/\")" \
--eval '(quit)'
pdf: texinfo
texi2pdf ${uiop}.texinfo
html: texinfo
makeinfo --html --no-split ${uiop}.texinfo
htmls: texinfo
makeinfo --html ${uiop}.texinfo
info: texinfo
makeinfo ${uiop}.texinfo
This diff is collapsed.
\input texinfo @c -*-texinfo-*-
@c %**start of header
@setfilename uiop.info
@settitle UIOP Manual
@c %**end of header
@c for install-info
@dircategory Software development
@direntry
* uiop: (uiop). Utilities for Implementation and OS Portability (for Common Lisp)
@end direntry
@copying
UIOP is a part of @uref{https://common-lisp.net/project/asdf/, ASDF},
which is released under an MIT style License:
@quotation
Copyright @copyright{} 2001-2018 Daniel Barlow and contributors.
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@end quotation
@end copying
@titlepage
@title UIOP Manual
@c The following two commands start the copyright page.
@page
@vskip 0pt plus 1filll
@insertcopying
@end titlepage
@contents
@include include/ifnottex.texinfo
@ifnottex
@node Top
@comment node-name, next, previous, up
@top UIOP
@insertcopying
@menu
* Introduction::
* UIOP/PACKAGE::
* UIOP/COMMON-LISP::
* UIOP/UTILITY::
* UIOP/VERSION::
* UIOP/OS::
* UIOP/PATHNAME::
* UIOP/FILESYSTEM::
* UIOP/STREAM::
* UIOP/IMAGE::
* UIOP/LISP-BUILD::
* UIOP/LAUNCH-PROGRAM::
* UIOP/RUN-PROGRAM::
* UIOP/CONFIGURATION::
* UIOP/BACKWARD-DRIVER::
* UIOP/DRIVER::
@end menu
@end ifnottex
@node Introduction
@comment node-name, next, previous, up
@chapter Introduction
UIOP is the portability layer of ASDF. It provides utilities that
abstract over discrepancies between implementations, between operating
systems, and between what the standard provides and what programmers
actually need, to write portable Common Lisp programs.
It is organized by topic in many files, each of which defines its own package
according to its topic: e.g @file{pathname.lisp}
will define package @code{uiop/pathname} and contain utilities related to
the handling of pathname objects.
All exported symbols are reexported in a convenience package @code{uiop},
except for those from @code{uiop/common-lisp}.
We recommend package @code{uiop} be used to access all the symbols.
The following API reference is auto-generated from the docstrings in
the code. The chapters are arranged in dependency order.
@node UIOP/PACKAGE
@comment node-name, next, previous, up
@chapter UIOP/PACKAGE
@c REPLACE_ME_WITH UIOP/PACKAGE
@node UIOP/COMMON-LISP
@comment node-name, next, previous, up
@chapter UIOP/COMMON-LISP
@code{uiop/common-lisp} lets you paper over various sub-standard
implementations.
This package reexports all the symbols in @code{common-lisp} package.
@node UIOP/UTILITY
@comment node-name, next, previous, up
@chapter UIOP/UTILITY
@c REPLACE_ME_WITH UIOP/UTILITY
@node UIOP/VERSION
@comment node-name, next, previous, up
@chapter UIOP/VERSION
@c REPLACE_ME_WITH UIOP/VERSION
@node UIOP/OS
@comment node-name, next, previous, up
@chapter UIOP/OS
@c REPLACE_ME_WITH UIOP/OS
@node UIOP/PATHNAME
@comment node-name, next, previous, up
@chapter UIOP/PATHNAME
@c REPLACE_ME_WITH UIOP/PATHNAME
@node UIOP/FILESYSTEM
@comment node-name, next, previous, up
@chapter UIOP/FILESYSTEM
@c REPLACE_ME_WITH UIOP/FILESYSTEM
@node UIOP/STREAM
@comment node-name, next, previous, up
@chapter UIOP/STREAM
@c REPLACE_ME_WITH UIOP/STREAM
@node UIOP/IMAGE
@comment node-name, next, previous, up
@chapter UIOP/IMAGE
@c REPLACE_ME_WITH UIOP/IMAGE
@node UIOP/LISP-BUILD
@comment node-name, next, previous, up
@chapter UIOP/LISP-BUILD
@c REPLACE_ME_WITH UIOP/LISP-BUILD
@node UIOP/LAUNCH-PROGRAM
@comment node-name, next, previous, up
@chapter UIOP/LAUNCH-PROGRAM
@code{uiop/launch-program} semi-portably launches a program as an
asynchronous external subprocess. Available functionality may depend
on the underlying implementation.
@c REPLACE_ME_WITH UIOP/LAUNCH-PROGRAM
@node UIOP/RUN-PROGRAM
@comment node-name, next, previous, up
@chapter UIOP/RUN-PROGRAM
@code{uiop/run-program} fully portably runs a program as a synchronous
external subprocess.
@c REPLACE_ME_WITH UIOP/RUN-PROGRAM
@node UIOP/CONFIGURATION
@comment node-name, next, previous, up
@chapter UIOP/CONFIGURATION
@c REPLACE_ME_WITH UIOP/CONFIGURATION
@node UIOP/BACKWARD-DRIVER
@comment node-name, next, previous, up
@chapter UIOP/BACKWARD-DRIVER
@code{uiop/backward-driver} provides backward-compatibility with
earlier incarnations of this library.
@c REPLACE_ME_WITH UIOP/BACKWARD-DRIVER
@node UIOP/DRIVER
@comment node-name, next, previous, up
@chapter UIOP/DRIVER
@code{uiop/driver} doesn't export any new symbols. It just exists to
reexport all the utilities in a single package @code{uiop}.
@bye
......@@ -71,7 +71,13 @@ a CL pathname satisfying all the specified constraints as per ENSURE-PATHNAME"
(or (ignore-errors (truename p))
;; this is here because trying to find the truename of a directory pathname WITHOUT supplying
;; a trailing directory separator, causes an error on some lisps.
#+(or clisp gcl) (if-let (d (ensure-directory-pathname p nil)) (ignore-errors (truename d)))))))
#+(or clisp gcl) (if-let (d (ensure-directory-pathname p nil)) (ignore-errors (truename d)))
;; On Genera, truename of a directory pathname will probably fail as Genera
;; will merge in a filename/type/version from *default-pathname-defaults* and
;; will try to get the truename of a file that probably doesn't exist.
#+genera (when (directory-pathname-p p)
(let ((d (scl:send p :directory-pathname-as-file)))
(ensure-directory-pathname (ignore-errors (truename d)) nil)))))))
(defun safe-file-write-date (pathname)
"Safe variant of FILE-WRITE-DATE that may return NIL rather than raise an error."
......
......@@ -714,9 +714,10 @@ it will filter them appropriately."
(with-saved-deferred-warnings (warnings-file :source-namestring (namestring input-file))
(with-muffled-compiler-conditions ()
(or #-(or clasp ecl mkcl)
(apply 'compile-file input-file :output-file tmp-file
#+sbcl (if emit-cfasl (list* :emit-cfasl tmp-cfasl keywords) keywords)
#-sbcl keywords)
(let (#+genera (si:*common-lisp-syntax-is-ansi-common-lisp* t))
(apply 'compile-file input-file :output-file tmp-file
#+sbcl (if emit-cfasl (list* :emit-cfasl tmp-cfasl keywords) keywords)
#-sbcl keywords))
#+ecl (apply 'compile-file input-file :output-file
(if object-file
(list* object-file :system-p t keywords)
......@@ -768,19 +769,20 @@ it will filter them appropriately."
(defun load* (x &rest keys &key &allow-other-keys)
"Portable wrapper around LOAD that properly handles loading from a stream."
(with-muffled-loader-conditions ()
(etypecase x
((or pathname string #-(or allegro clozure genera) stream #+clozure file-stream)
(apply 'load x keys))
;; Genera can't load from a string-input-stream
;; ClozureCL 1.6 can only load from file input stream
;; Allegro 5, I don't remember but it must have been broken when I tested.
#+(or allegro clozure genera)
(stream ;; make do this way
(let ((*package* *package*)
(*readtable* *readtable*)
(*load-pathname* nil)
(*load-truename* nil))
(eval-input x))))))
(let (#+genera (si:*common-lisp-syntax-is-ansi-common-lisp* t))
(etypecase x
((or pathname string #-(or allegro clozure genera) stream #+clozure file-stream)
(apply 'load x keys))
;; Genera can't load from a string-input-stream
;; ClozureCL 1.6 can only load from file input stream
;; Allegro 5, I don't remember but it must have been broken when I tested.
#+(or allegro clozure genera)
(stream ;; make do this way
(let ((*package* *package*)
(*readtable* *readtable*)
(*load-pathname* nil)
(*load-truename* nil))
(eval-input x)))))))
(defun load-from-string (string)
"Portably read and evaluate forms from a STRING."
......
......@@ -91,8 +91,8 @@ by the underlying implementation's MAKE-PATHNAME and other primitives"
;; See CLHS make-pathname and 19.2.2.2.3.
;; This will be :unspecific if supported, or NIL if not.
(defparameter *unspecific-pathname-type*
#+(or abcl allegro clozure cmucl genera lispworks sbcl scl) :unspecific
#+(or clasp clisp ecl mkcl gcl xcl #|These haven't been tested:|# cormanlisp mcl mezzano) nil
#+(or abcl allegro clozure cmucl lispworks sbcl scl) :unspecific
#+(or genera clasp clisp ecl mkcl gcl xcl #|These haven't been tested:|# cormanlisp mcl mezzano) nil
"Unspecific type component to use with the underlying implementation's MAKE-PATHNAME")
(defun make-pathname* (&rest keys &key directory host device name type version defaults
......@@ -330,7 +330,14 @@ actually-existing directory."
(make-pathname :directory (append (or (normalize-pathname-directory-component
(pathname-directory pathspec))
(list :relative))
(list (file-namestring pathspec)))
(list #-genera (file-namestring pathspec)
;; On Genera's native filesystem (LMFS),
;; directories have a type and version
;; which must be ignored when converting
;; to a directory pathname
#+genera (if (typep pathspec 'fs:lmfs-pathname)
(pathname-name pathspec)
(file-namestring pathspec))))
:name nil :type nil :version nil :defaults pathspec)
(error (c) (call-function on-error (compatfmt "~@<error while trying to create a directory pathname for ~S: ~A~@:>") pathspec c)))))))
......
......@@ -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")
......@@ -44,7 +40,13 @@ you already have a matching UIOP loaded."
(:file "image" :depends-on ("stream"))
(:file "lisp-build" :depends-on ("image"))
(:file "launch-program" :depends-on ("stream"))
(:file "run-program" :depends-on ("launch-program"))
(:file "run-program" :depends-on ("launch-program" "version"))
(: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)))))
......@@ -83,17 +83,17 @@ to supersede any previous definition."
;;; Magic debugging help. See contrib/debug.lisp
(with-upgradability ()
(defvar *uiop-debug-utility*
'(or (ignore-errors
(probe-file (symbol-call :asdf :system-relative-pathname :uiop "contrib/debug.lisp")))
(probe-file (symbol-call :uiop/pathname :subpathname
(user-homedir-pathname) "common-lisp/asdf/uiop/contrib/debug.lisp")))
'(symbol-call :uiop :subpathname (symbol-call :uiop :uiop-directory) "contrib/debug.lisp")
"form that evaluates to the pathname to your favorite debugging utilities")
(defmacro uiop-debug (&rest keys)
"Load the UIOP debug utility at compile-time as well as runtime"
`(eval-when (:compile-toplevel :load-toplevel :execute)
(load-uiop-debug-utility ,@keys)))
(defun load-uiop-debug-utility (&key package utility-file)
"Load the UIOP debug utility in given PACKAGE (default *PACKAGE*).
Beware: The utility is located by EVAL'uating the UTILITY-FILE form (default *UIOP-DEBUG-UTILITY*)."
(let* ((*package* (if package (find-package package) *package*))
(keyword (read-from-string
(format nil ":DBG-~:@(~A~)" (package-name *package*)))))
......
......@@ -12,7 +12,7 @@
(in-package :uiop/version)
(with-upgradability ()
(defparameter *uiop-version* "3.3.2.2")
(defparameter *uiop-version* "3.3.2.13")
(defun unparse-version (version-list)
"From a parsed version (a list of natural numbers), compute the version string"
......
......@@ -94,7 +94,7 @@ previously-loaded version of ASDF."
;; "3.4.5.67" would be a development version in the official branch, on top of 3.4.5.
;; "3.4.5.0.8" would be your eighth local modification of official release 3.4.5
;; "3.4.5.67.8" would be your eighth local modification of development version 3.4.5.67
(asdf-version "3.3.2.2")
(asdf-version "3.3.2.13")
(existing-version (asdf-version)))
(setf *asdf-version* asdf-version)
(when (and existing-version (not (equal asdf-version existing-version)))
......@@ -107,7 +107,7 @@ previously-loaded version of ASDF."
;;; Upon upgrade, specially frob some functions and classes that are being incompatibly redefined
(when-upgrading ()
(let* ((previous-version (first *previous-asdf-versions*))
(redefined-functions ;; List of functions that changes incompatibly since 2.27:
(redefined-functions ;; List of functions that changed incompatibly since 2.27:
;; gf signature changed (should NOT happen), defun that became a generic function,
;; method removed that will mess up with new ones (especially :around :before :after,
;; more specific or call-next-method'ed method) and/or semantics otherwise modified. Oops.
......@@ -118,8 +118,8 @@ previously-loaded version of ASDF."
;; Also note that we don't include the defgeneric=>defun, because they are
;; done directly with defun* and need not trigger a punt on data.
;; See discussion at https://gitlab.common-lisp.net/asdf/asdf/merge_requests/36
`(,@(when (version<= previous-version "3.1.2") '(#:component-depends-on #:input-files)) ;; crucial methods *removed* before 3.1.2
,@(when (version<= previous-version "3.1.7.20") '(#:find-component))))
`(,@(when (version< previous-version "3.1.2") '(#:component-depends-on #:input-files)) ;; crucial methods *removed* before 3.1.2
,@(when (version< previous-version "3.1.7.20") '(#:find-component))))
(redefined-classes
;; redefining the classes causes interim circularities
;; with the old ASDF during upgrade, and many implementations bork
......