diff --git a/Makefile b/Makefile index ece2783821ad7453377b5f28523a29633465f15a..2d3f2d4661bc91102ceba3e3770db16eb621f5bc 100644 --- a/Makefile +++ b/Makefile @@ -37,7 +37,7 @@ XCL ?= xcl # website, tag, install header_lisp := header.lisp -driver_lisp := package.lisp compatibility.lisp utility.lisp pathname.lisp stream.lisp os.lisp image.lisp run-program.lisp lisp-build.lisp configuration.lisp backward-driver.lisp driver.lisp +driver_lisp := package.lisp common-lisp.lisp utility.lisp pathname.lisp stream.lisp os.lisp image.lisp run-program.lisp lisp-build.lisp configuration.lisp backward-driver.lisp driver.lisp defsystem_lisp := upgrade.lisp component.lisp system.lisp find-system.lisp find-component.lisp operation.lisp action.lisp lisp-action.lisp plan.lisp operate.lisp output-translations.lisp source-registry.lisp backward-internals.lisp defsystem.lisp bundle.lisp concatenate-source.lisp backward-interface.lisp interface.lisp footer.lisp # Making ASDF itself should be our first, default, target: diff --git a/action.lisp b/action.lisp index 7630d81282340ae2579b1f229040604d3ef5ab9e..942db98526f201888f370f628244e9f454e28b2c 100644 --- a/action.lisp +++ b/action.lisp @@ -4,9 +4,8 @@ (asdf/package:define-package :asdf/action (:nicknames :asdf-action) (:recycle :asdf/action :asdf) - (:use :common-lisp :asdf/driver :asdf/upgrade + (:use :asdf/common-lisp :asdf/driver :asdf/upgrade :asdf/component :asdf/system :asdf/find-system :asdf/find-component :asdf/operation) - #+gcl<2.7 (:shadowing-import-from :asdf/compatibility #:type-of) (:intern #:stamp #:done-p) (:export #:action #:define-convenience-action-methods @@ -111,10 +110,10 @@ You can put together sentences using this phrase.")) (defmethod component-self-dependencies ((o operation) (c component)) ;; NB: result in the same format as component-depends-on - (loop :for (o-spec . c-spec) :in (component-depends-on o c) - :unless (eq o-spec 'feature) ;; avoid the FEATURE "feature" - :when (find c c-spec :key #'(lambda (dep) (resolve-dependency-spec c dep))) - :collect (list o-spec c))) + (loop* :for (o-spec . c-spec) :in (component-depends-on o c) + :unless (eq o-spec 'feature) ;; avoid the FEATURE "feature" + :when (find c c-spec :key #'(lambda (dep) (resolve-dependency-spec c dep))) + :collect (list o-spec c))) ;;;; upward-operation, downward-operation ;; These together handle actions that propagate along the component hierarchy. @@ -194,8 +193,8 @@ You can put together sentences using this phrase.")) nil) (defmethod input-files ((o operation) (c component)) - (or (loop :for (dep-o) :in (component-self-dependencies o c) - :append (or (output-files dep-o c) (input-files dep-o c))) + (or (loop* :for (dep-o) :in (component-self-dependencies o c) + :append (or (output-files dep-o c) (input-files dep-o c))) ;; no non-trivial previous operations needed? ;; I guess we work with the original source file, then (if-let ((pathname (component-pathname c))) diff --git a/asdf-driver.asd b/asdf-driver.asd index b5928d3e075b86382683b05489e4526b924be676..158dda3a6b1e09932931f5609cb29cf9f63a36f8 100644 --- a/asdf-driver.asd +++ b/asdf-driver.asd @@ -7,17 +7,16 @@ (defsystem :asdf-driver :licence "MIT" - :description "Basic general-purpose utilities used by ASDF" - :long-description "Basic general-purpose utilities that is in such a need + :description "Runtime support for Common Lisp programs" + :long-description "Basic general-purpose utilities that are in such a need that you can't portably construct a complete program without using them." #+asdf2.27 :version #+asdf2.27 (:read-file-form "version.lisp-expr") - :defsystem-depends-on (#+(and (not asdf2.27) (or clisp xcl)) :asdf) :around-compile call-without-redefinition-warnings :components ((:static-file "version.lisp-expr") (:file "package") - (:file "compatibility" :depends-on ("package")) - (:file "utility" :depends-on ("compatibility")) + (:file "common-lisp" :depends-on ("package")) + (:file "utility" :depends-on ("common-lisp")) (:file "pathname" :depends-on ("utility")) (:file "stream" :depends-on ("pathname")) (:file "os" :depends-on ("stream")) diff --git a/asdf.asd b/asdf.asd index 1c00546cf19404709be4a4734b2f1ea2f6bf128a..47ce7862662ddaa6744ca542912e69c3deae7355 100644 --- a/asdf.asd +++ b/asdf.asd @@ -11,6 +11,9 @@ #+asdf2.27 (defsystem :asdf/header + ;; 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") :components ((:static-file "header.lisp"))) @@ -18,12 +21,11 @@ (defsystem :asdf/defsystem :licence "MIT" :description "The defsystem part of ASDF" - :description "Generate asdf.lisp based on this and monolithic-concatenate-source-op" + :long-description "Another System Definition Facility, the portable defsystem for Common Lisp" :version (:read-file-form "version.lisp-expr") - :class :bundle-system :build-operation monolithic-concatenate-source-op - :bundle-pathname "build/asdf" - :around-compile call-without-redefinition-warnings ;; be the same as asdf-driver + :build-pathname "build/asdf" ;; our target + :around-compile call-without-redefinition-warnings ;; we need be the same as asdf-driver :depends-on (:asdf/header :asdf-driver) :components ((:file "upgrade") @@ -34,7 +36,7 @@ (:file "operation" :depends-on ("upgrade")) (:file "action" :depends-on ("find-component" "operation")) (:file "lisp-action" :depends-on ("action")) - (:file "plan" :depends-on ("action")) + (:file "plan" :depends-on ("lisp-action")) (:file "operate" :depends-on ("plan")) (:file "output-translations" :depends-on ("operate")) (:file "source-registry" :depends-on ("find-system")) @@ -42,7 +44,7 @@ (:file "defsystem" :depends-on ("backward-internals")) (:file "bundle" :depends-on ("lisp-action")) (:file "concatenate-source" :depends-on ("bundle")) - (:file "backward-interface" :depends-on ("lisp-action")) + (:file "backward-interface" :depends-on ("operate" "output-translations")) (:file "interface" :depends-on ("defsystem" "concatenate-source" "backward-interface" "backward-internals" @@ -55,12 +57,14 @@ :licence "MIT" :description "Another System Definition Facility" :long-description "ASDF builds Common Lisp software organized into defined systems." - :version "2.26.141" ;; to be automatically updated by make bump-version + :version "2.26.142" ;; to be automatically updated by make bump-version :depends-on () :components ((:module "build" :components - ((:file "asdf" - :in-order-to (#-asdf2.27 (compile-op (load-source-op "asdf"))))))) + (#-gcl2.6 + (:file "asdf" + #-asdf2.27 :do-first #-asdf2.27 ((compile-op (load-source-op "asdf"))) + )))) :in-order-to (#+asdf2.27 (compile-op (monolithic-load-concatenated-source-op asdf/defsystem)))) diff --git a/backward-driver.lisp b/backward-driver.lisp index 2a81121aad952de3f5b0dae7d459bde95390b315..8d5df834c863f33ca49c4122aecf67e91b5acfcd 100644 --- a/backward-driver.lisp +++ b/backward-driver.lisp @@ -3,8 +3,7 @@ (asdf/package:define-package :asdf/backward-driver (:recycle :asdf/backward-driver :asdf) - (:use :common-lisp - :asdf/package :asdf/compatibility :asdf/utility + (:use :asdf/common-lisp :asdf/package :asdf/utility :asdf/pathname :asdf/stream :asdf/os :asdf/image :asdf/run-program :asdf/lisp-build :asdf/configuration) diff --git a/backward-interface.lisp b/backward-interface.lisp index df5fd046d3ca3c00062d0d345594bcce887a048a..b94cfba9f44f7d1fdf93b99dc2c8f4293f64891f 100644 --- a/backward-interface.lisp +++ b/backward-interface.lisp @@ -3,7 +3,7 @@ (asdf/package:define-package :asdf/backward-interface (:recycle :asdf/backward-interface :asdf) - (:use :common-lisp :asdf/driver :asdf/upgrade + (:use :asdf/common-lisp :asdf/driver :asdf/upgrade :asdf/component :asdf/system :asdf/operation :asdf/action :asdf/lisp-build :asdf/operate :asdf/output-translations) (:export @@ -39,8 +39,8 @@ (defgeneric* operation-on-warnings (operation)) (defgeneric* operation-on-failure (operation)) -#-gcl<2.7 (defgeneric* (setf operation-on-warnings) (x operation)) -#-gcl<2.7 (defgeneric* (setf operation-on-failure) (x operation)) +#-gcl2.6 (defgeneric* (setf operation-on-warnings) (x operation)) +#-gcl2.6 (defgeneric* (setf operation-on-failure) (x operation)) (defmethod operation-on-warnings ((o operation)) (declare (ignorable o)) *compile-file-warnings-behaviour*) (defmethod operation-on-failure ((o operation)) diff --git a/backward-internals.lisp b/backward-internals.lisp index 39cded0a3f11ef91a714d2a8586b47c294fb4332..8dad8ee8ef294d0a204e93f16bf2a21a402821ae 100644 --- a/backward-internals.lisp +++ b/backward-internals.lisp @@ -3,7 +3,7 @@ (asdf/package:define-package :asdf/backward-internals (:recycle :asdf/backward-internals :asdf) - (:use :common-lisp :asdf/driver :asdf/upgrade + (:use :asdf/common-lisp :asdf/driver :asdf/upgrade :asdf/system :asdf/component :asdf/find-system :asdf/action) (:export ;; for internal use #:%refresh-component-inline-methods @@ -62,9 +62,9 @@ (unless (eq if-component-dep-fails :fail) (loop :with o = (make-instance 'compile-op) :for c :in (component-children component) :do - (loop :for (feature? feature) :in (component-depends-on o c) - :when (eq feature? 'feature) :do - (setf (component-if-feature c) feature))))) + (loop* :for (feature? feature) :in (component-depends-on o c) + :when (eq feature? 'feature) :do + (setf (component-if-feature c) feature))))) (when-upgrade (:when (fboundp 'make-sub-operation)) (defun* make-sub-operation (c o dep-c dep-o) diff --git a/bundle.lisp b/bundle.lisp index e36c9e46341f4a550418118fc2c7872a63b0ddcb..047cc0f8aa0eafc82323662e51dec25b8f8b6e78 100644 --- a/bundle.lisp +++ b/bundle.lisp @@ -3,7 +3,7 @@ (asdf/package:define-package :asdf/bundle (:recycle :asdf/bundle :asdf) - (:use :common-lisp :asdf/driver :asdf/upgrade + (:use :asdf/common-lisp :asdf/driver :asdf/upgrade :asdf/component :asdf/system :asdf/find-system :asdf/find-component :asdf/operation :asdf/action :asdf/lisp-action :asdf/plan :asdf/operate) (:export @@ -18,7 +18,6 @@ #+ecl #:make-build #:register-pre-built-system #:build-args #:name-suffix #:prologue-code #:epilogue-code #:static-library - #:component-bundle-pathname #:bundle-pathname #:component-entry-point #:entry-point)) (in-package :asdf/bundle) @@ -78,20 +77,14 @@ ;; All: create an executable file from the system and its dependencies ((bundle-type :initform :program))) -(defgeneric* component-bundle-pathname (component)) (defgeneric* component-entry-point (component)) -(defmethod component-bundle-pathname ((c component)) - (declare (ignorable c)) - nil) (defmethod component-entry-point ((c component)) (declare (ignorable c)) nil) (defclass bundle-system (system) - ((bundle-pathname - :initform nil :initarg :bundle-pathname :accessor component-bundle-pathname) - (entry-point + ((entry-point :initform nil :initarg :entry-point :accessor component-entry-point))) (defun* bundle-pathname-type (bundle-type) @@ -110,7 +103,7 @@ (defun* bundle-output-files (o c) (let ((bundle-type (bundle-type o))) (unless (eq bundle-type :no-output-file) ;; NIL already means something regarding type. - (let ((name (or (component-bundle-pathname c) + (let ((name (or (component-build-pathname c) (format nil "~A~@[~A~]" (component-name c) (slot-value o 'name-suffix)))) (type (bundle-pathname-type bundle-type))) (values (list (subpathname (component-pathname c) name :type type)) @@ -134,10 +127,10 @@ ((type :initform #-(or ecl mkcl) (compile-file-type) #+(or ecl mkcl) "fasb"))) (defclass precompiled-system (system) - ((bundle-pathname :initarg :fasl))) + ((build-pathname :initarg :fasl))) (defclass prebuilt-system (system) - ((bundle-pathname :initarg :static-library :initarg :lib + ((build-pathname :initarg :static-library :initarg :lib :accessor prebuilt-system-static-library))) ;;; diff --git a/compatibility.lisp b/common-lisp.lisp similarity index 80% rename from compatibility.lisp rename to common-lisp.lisp index 3b7139820ff57836bf9ee535d5a3ceb4b2232caf..17986481d3b357cd9492831239c1e49fa2e2037f 100644 --- a/compatibility.lisp +++ b/common-lisp.lisp @@ -3,23 +3,25 @@ ;;; This file is for papering over the deficiencies and peculiarities ;;; of various Common Lisp implementations. ;;; For implementation-specific access to the system, see os.lisp instead. - -(asdf/package:define-package :asdf/compatibility - (:use :common-lisp :asdf/package) - (:recycle :asdf/compatibility :asdf) +;;; A few functions are defined here, but actually exported from utility; +;;; from this package only common-lisp symbols are exported. + +(asdf/package:define-package :asdf/common-lisp + (:nicknames :asdf/cl) + (:use #-genera :common-lisp #+genera :future-common-lisp :asdf/package) + (:reexport :common-lisp) + (:recycle :asdf/common-lisp :asdf) #+allegro (:intern #:*acl-warn-save*) #+cormanlisp (:export #:logical-pathname #:translate-logical-pathname #:make-broadcast-stream #:file-namestring) - #+ecl (:export #:use-ecl-byte-compiler-p) - ;;#+gcl (:shadow #:type-of #:with-standard-io-syntax) ; causes errors when loading fasl(!) - #+genera (:import-from :scl #:boolean) + #+gcl2.6 (:shadow #:type-of #:with-standard-io-syntax) ; causes errors when loading fasl(!) + #+gcl2.6 (:shadowing-import-from :system #:*load-pathname*) + #+genera (:shadowing-import-from :scl #:boolean) #+genera (:export #:boolean #:ensure-directories-exist) - #+mcl (:export #:probe-posix #:current-user-homedir-pathname) - (:export - #:strcat #:compatfmt)) -(in-package :asdf/compatibility) + #+mcl (:shadow #:user-homedir-pathname)) +(in-package :asdf/common-lisp) #-(or abcl allegro clisp clozure cmu cormanlisp ecl gcl genera lispworks mcl mkcl sbcl scl xcl) (error "ASDF is not supported on your implementation. Please help us port it.") @@ -43,6 +45,15 @@ (setf excl:*warn-on-nested-reader-conditionals* nil)) (setf *print-readably* nil)) +#+cormanlisp +(progn + (deftype logical-pathname () nil) + (defun make-broadcast-stream () *error-output*) + (defun translate-logical-pathname (x) x) + (defun file-namestring (p) + (setf p (pathname p)) + (format nil "~@[~A~]~@[.~A~]" (pathname-name p) (pathname-type p)))) + #+ecl (eval-when (:load-toplevel :compile-toplevel :execute) (setf *load-verbose* nil) @@ -51,39 +62,24 @@ #+gcl ;; Debian's GCL 2.7 has bugs with compiling multiple-value stuff, but can run ASDF 2.011 (eval-when (:load-toplevel :compile-toplevel :execute) - (when (or (< system::*gcl-major-version* 2) ;; GCL 2.6 lacks output-translations and more. - (and (= system::*gcl-major-version* 2) - (< system::*gcl-minor-version* 7))) - (shadow 'type-of :asdf/compatibility) - ;;(shadow 'with-standard-io-syntax :asdf/compatibility) - ;;(format t "Detected an old GCL 2.6. Only limited functionality available.~%") - (pushnew 'ignorable pcl::*variable-declarations-without-argument*) - (pushnew :gcl<2.7 *features*)) (unless (member :ansi-cl *features*) (error "ASDF only supports GCL in ANSI mode. Aborting.~%")) (setf compiler::*compiler-default-type* (pathname "") compiler::*lsp-ext* "")) -#+mkcl -(eval-when (:load-toplevel :compile-toplevel :execute) - (require :cmp) - (setq clos::*redefine-class-in-place* t)) ;; Make sure we have strict ANSI class redefinition semantics - +#+gcl2.6 +(eval-when (:compile-toplevel :load-toplevel :execute) + (shadow 'type-of :asdf/common-lisp) + (shadowing-import 'system:*load-pathname* :asdf/common-lisp)) -;;;; Compatibility layers +#+gcl2.6 +(eval-when (:compile-toplevel :load-toplevel :execute) + (export 'type-of :asdf/common-lisp) + (export 'system:*load-pathname* :asdf/common-lisp)) -#+cormanlisp -(progn - (deftype logical-pathname () nil) - (defun make-broadcast-stream () *error-output*) - (defun translate-logical-pathname (x) x) - (defun file-namestring (p) - (setf p (pathname p)) - (format nil "~@[~A~]~@[.~A~]" (pathname-name p) (pathname-type p)))) - -#+gcl<2.7 +#+gcl2.6 (progn ;; Doesn't support either logical-pathnames or output-translations. - (defvar *gcl<2.7* t) + (defvar *gcl2.6* t) (deftype logical-pathname () nil) (defun type-of (x) (class-name (class-of x))) (defun wild-pathname-p (path) (declare (ignore path)) nil) @@ -121,7 +117,7 @@ ;; the pathname of the current user's home directory, whereas ;; MCL by default provides the directory from which MCL was started. ;; See http://code.google.com/p/mcl/wiki/Portability - (defun current-user-homedir-pathname () + (defun user-homedir-pathname () (ccl::findfolder #$kuserdomain #$kCurrentUserFolderType)) (defun probe-posix (posix-namestring) \"If a file exists for the posix namestring, return the pathname\" @@ -131,9 +127,17 @@ (when (eq #$noerr (#_fspathmakeref cpath fsref is-dir)) (ccl::%path-from-fsref fsref is-dir))))))")) +#+mkcl +(eval-when (:load-toplevel :compile-toplevel :execute) + (require :cmp) + (setq clos::*redefine-class-in-place* t)) ;; Make sure we have strict ANSI class redefinition semantics + ;;;; compatfmt: avoid fancy format directives when unsupported -;; Confirm (?) has to be inside an eval-when to make Lispworks happy + +(defmacro loop* (&rest rest) + #-genera `(loop ,@rest) + #+genera `(lisp:loop ,@rest)) ;; In genera, CL:LOOP can't destructure, so we use LOOP*. Sigh. (eval-when (:load-toplevel :compile-toplevel :execute) (defun strcat (&rest strings) @@ -141,10 +145,10 @@ (defmacro compatfmt (format) #+(or gcl genera) - (loop :for (unsupported . replacement) - :in (append - '(("~3i~_" . "")) - #+(or genera gcl<2.7) '(("~@<" . "") ("; ~@;" . "; ") ("~@:>" . "") ("~:>" . ""))) :do + (loop* :for (unsupported . replacement) + :in (append + '(("~3i~_" . "")) + #+(or genera gcl2.6) '(("~@<" . "") ("; ~@;" . "; ") ("~@:>" . "") ("~:>" . ""))) :do (loop :for found = (search unsupported format) :while found :do (setf format (strcat (subseq format 0 found) replacement (subseq format (+ found (length unsupported))))))) diff --git a/component.lisp b/component.lisp index 45a51daed86713914235a94d3c682877ad70c1e5..4488da5c4234e2d1b19166045c24299d50de27ad 100644 --- a/component.lisp +++ b/component.lisp @@ -3,7 +3,7 @@ (asdf/package:define-package :asdf/component (:recycle :asdf/component :asdf) - (:use :common-lisp :asdf/driver :asdf/upgrade) + (:use :asdf/common-lisp :asdf/driver :asdf/upgrade) (:export #:component #:component-find-path #:component-name #:component-pathname #:component-relative-pathname @@ -50,7 +50,7 @@ Despite the function's name, the return value may be an absolute pathname, because an absolute pathname may be interpreted relative to another pathname in a degenerate way.")) (defgeneric* component-property (component property)) -#-gcl<2.7 +#-gcl2.6 (defgeneric* (setf component-property) (new-value component property)) (defgeneric* component-external-format (component)) (defgeneric* component-encoding (component)) diff --git a/concatenate-source.lisp b/concatenate-source.lisp index c70bf25ad7f34c891c6259457cb02bb0e0b0880d..43cfcddccc51ff59b5e8dcbfb9173678ed62b7b2 100644 --- a/concatenate-source.lisp +++ b/concatenate-source.lisp @@ -3,7 +3,7 @@ (asdf/package:define-package :asdf/concatenate-source (:recycle :asdf/concatenate-source :asdf) - (:use :common-lisp :asdf/driver :asdf/upgrade + (:use :asdf/common-lisp :asdf/driver :asdf/upgrade :asdf/component :asdf/operation :asdf/system :asdf/find-system :asdf/defsystem :asdf/action :asdf/lisp-action :asdf/bundle) diff --git a/configuration.lisp b/configuration.lisp index 57672cb0ba0bd4ec95649e569cf92bc78bf83a4a..898fe2b47aa27f76ff18092232fd0f6f887ef1e4 100644 --- a/configuration.lisp +++ b/configuration.lisp @@ -3,7 +3,7 @@ (asdf/package:define-package :asdf/configuration (:recycle :asdf/configuration :asdf) - (:use :common-lisp :asdf/compatibility :asdf/utility + (:use :asdf/common-lisp :asdf/utility :asdf/pathname :asdf/stream :asdf/os :asdf/image) (:export #:get-folder-path @@ -243,7 +243,7 @@ directive.") (when directory (setf ensure-directory t)) ;; :directory backward compatibility, until 2014-01-16. (if (atom x) (resolve-absolute-location x :ensure-directory ensure-directory :wilden wilden) - (loop :with (first . rest) = x + (loop* :with (first . rest) = x :with path = (resolve-absolute-location first :ensure-directory (and (or ensure-directory rest) t) :wilden (and wilden (null rest))) diff --git a/debian/changelog b/debian/changelog index 8e893836eee6593aa591c4df0c1650a3474e379d..64f2354520222af2460f5a8eac11a9a5df65d38a 100644 --- a/debian/changelog +++ b/debian/changelog @@ -84,12 +84,23 @@ cl-asdf (2:2.27-1) unstable; urgency=low or do the same while including all other system dependencies. ASDF was broken up into lots of small files, to be delivered that way. + * FOO/BAR/BAZ names will be recognized by defsystem as having to be located + in a file called foo.asd. This is backward compatible in the case where + you somehow arranged to load foo.asd before to use the other subsystems, + except now ASDF can find the subsystems by name without the main system + definition having been loaded. See uses of function PRIMARY-SYSTEM-NAME. + + * BUILD-OP is a generic operation that can do the "right thing" for + each system, without users having to maintain the knowledge of + what the right thing is for each system they may indirectly depend on. + * Packages were introduced as ASDF was broken up into small files. Each file now has its own package, importing and exporting functionality, following the style made popular by faslpath and quick-build. A macro DEFINE-PACKAGE was defined in replacement to DEFPACKAGE to manage the same effects while making every effort to - Do The Right Thing(tm) in case of hot upgrade. + Do The Right Thing(tm) in case of hot upgrade. It also provides + new forms :MIX and :REEXPORT which can be quite practical. * ASDF-DRIVER is a separately-usable library for Common Lisp runtime support. It is transcluded in asdf.lisp (i.e. when delivering ASDF as a separate @@ -104,14 +115,41 @@ cl-asdf (2:2.27-1) unstable; urgency=low from platform to platform. See notably in pathname.lisp, MERGE-PATHNAMES*, SUBPATHNAME, PARSE-UNIX-NAMESTRING, PARSE-NATIVE-NAMESTRING, ENSURE-PATHNAME, and many many more. + Although we strongly disrecommended the use of logical pathnames + (so called), ASDF better supports them than ever; + the actual support also depends on your implementation. * Image lifecycle support is included in ASDF-DRIVER (and thus ASDF); this standardizes things like access to *COMMAND-LINE-ARGUMENTS*, declaring an entry-point to a program, hook functions and/or a prelude to run before to start the main entry, and a postlude and/or hook functions to run before to dump an image, dumping or creating an image, etc. - ASDF provides initial implementations of an operation program-op - to create standalone executables (if available on your implementation). + + * PROGRAM-OP allows you to create standalone executables on implementations + that support it: CLISP, Clozure CL, CMUCL ECL, LispWorks, SBCL, SCL. + A hello-world-example system shows demonstrates how to use it. + + * Run-program is a replacement for the old run-shell-command. + Unlike run-shell-command, it is portable to Windows as well as Unix, + it can avoid going through a shell and will sensibly escape arguments + when it does go through a shell, it has a usable interface + to either capture program output or run the program interactively. + This supersedes run-program/ previously available from xcvb-driver. + + * Conditions can be selectively muffled around compilation + thanks to around-compile hook and the *UNINTERESTING-COMPILER-CONDITIONS* + parameter and the additional *UNINTERESTING-LOADER-CONDITIONS*. + This supersedes the functionality previously available from xcvb-driver. + + * Deferred warnings for yet undefined functions, that in a single-session + build are usually signaled at the end of a compilation unit will be saved + and reassembled to make each system a compilation unit of its own, + even when compilation of file happens across multiple sessions; + only CCL and SBCL support this feature at this time. + + * COMPILE-FILE* was beefed up to support all these features and more, + doing the right thing on all implementations, including + support for their various extensions. * Internals have been refactored, and some sorry features were excised. The semantics of OPERATION-DONE-P is simplified and now well-specified. @@ -120,18 +158,47 @@ cl-asdf (2:2.27-1) unstable; urgency=low Many internal accessors were renamed, after checking on Quicklisp that no one was using them. + * Per-file packages are now used by ASDF internally, in the style of + quick-build or faslpath. ASDF does not yet include builtin support + for quick-build or faslpath systems and dependencies, however. + * Portability updates were done for ABCL, CLISP, Clozure CL, CMUCL, ECL, LispWorks Personal Edition, MKCL, XCL. Working support for GCL 2.6 was restored, with notable limitations including lack of support for output-translations or logical-pathnames. - * Documentation received some small updates. - - * Tests were updated, notably including support for bundles and encodings. - They were successfully run on ccl clisp sbcl ecl ecl_bytecodes - cmucl abcl scl allegro lispworks allegromodern xcl. - Manual tests were run on lispworks-personal-edition genera. - Untested were cormancl mkcl rmcl. + * TRUENAME resolution can be reliably turned off in all cases where + ASDF was using them by setting the variable *RESOLVE-SYMLINKS* to NIL. + This is useful if your operating system makes that operation slow, + or if your build system uses symlinks to content-addressed storage + in which case TRUENAME just does the wrong thing. + + * VERSION strings can now be specified as having to be fetched + from a file using a (:read-file-form <path>) specification, + that can use an optional :at keyword argument to specify + a form or subform other than the first form in the file, + as per the utility asdf-driver:access-at. + This makes it easier for developers to manage versioning + of one or multiple systems with a single master version location. + + * self-upgrage of ASDF will happen automatically as the first thing + before any attempt to build anything, as it was determined that + doing it in the midst of a build breaks everything, and it is not + otherwise possible to reliably detect in advance whether ASDF may + be needed in such midst. If you don't want an ASDF upgrade, just + don't configure your source-registry to include any copy of ASDF. + + * Documentation received some updates. + + * Tests were updated, notably including support for bundles, encodings, + run-program, and more. They were successfully run on + ccl clisp sbcl ecl ecl_bytecodes + cmucl abcl scl allegro lispworks allegromodern xcl + Manual tests were manually run on lispworks-personal-edition genera. + Untested remain cormancl mkcl rmcl. + + * asdf-debug is a simple utility to make your favorite debugging primitives + available in the package you're debugging. * POIU was updated. This extension is still distributed separately from ASDF. It is now much simplified and made correct by construction by @@ -143,13 +210,12 @@ cl-asdf (2:2.27-1) unstable; urgency=low * SLIME support for ASDF was significantly enhanced. It is distributed separately from ASDF, with SLIME. - See latest checkin from 2012-12-26. + See latest checkin from 2013-01-20. We recommend that in your ~/.swank.lisp you should: (in-package :swank) - (defparameter *upgrade-asdf-p* t) (pushnew 'try-compile-file-with-asdf *compile-file-for-emacs-hook*) - -- Francois-Rene Rideau <fare@tunes.org> Thu, 10 Jan 2012 22:59:44 -0500 + -- Francois-Rene Rideau <fare@tunes.org> Thu, 22 Jan 2013 22:59:44 -0500 cl-asdf (2:2.26-1) unstable; urgency=low diff --git a/defsystem.lisp b/defsystem.lisp index 59e7fdce35fb49cbe5b499cb43c8436b4bff701b..f6f42f7a38ceecf2efac5ec14a53f16b1995d4ae 100644 --- a/defsystem.lisp +++ b/defsystem.lisp @@ -3,11 +3,10 @@ (asdf/package:define-package :asdf/defsystem (:recycle :asdf/defsystem :asdf) - (:use :common-lisp :asdf/driver :asdf/upgrade + (:use :asdf/common-lisp :asdf/driver :asdf/upgrade :asdf/component :asdf/system :asdf/find-system :asdf/find-component :asdf/lisp-action :asdf/operate :asdf/backward-internals) - #+gcl<2.7 (:shadowing-import-from :asdf/compatibility #:type-of) (:export #:defsystem #:register-system-definition #:class-for-type #:*default-component-class* @@ -32,9 +31,13 @@ ;; and may be from within the EVAL-WHEN of a file compilation. ;; If no absolute pathname was found, we return NIL. (check-type pathname (or null string pathname)) - (absolutize-pathnames - (list pathname (load-pathname) *default-pathname-defaults* (getcwd)) - :type :directory :resolve-symlinks *resolve-symlinks*)) + (let ((pathname (parse-unix-namestring pathname :type :directory)) + (load-pathname (load-pathname))) + (when (or pathname load-pathname) + (pathname-directory-pathname + (absolutize-pathnames + (list pathname load-pathname *default-pathname-defaults* (getcwd)) + :resolve-symlinks *resolve-symlinks*))))) ;;; Component class diff --git a/driver.lisp b/driver.lisp index e53bf87b236681dd581ba1087ede74b97c05278c..138a99651837f01e5ea51e01ff51c913242c631b 100644 --- a/driver.lisp +++ b/driver.lisp @@ -3,13 +3,14 @@ (asdf/package:define-package :asdf/driver (:nicknames :d :asdf-driver :asdf-utils) - (:use :common-lisp - :asdf/package :asdf/compatibility :asdf/utility + (:use :asdf/common-lisp :asdf/package :asdf/utility :asdf/pathname :asdf/stream :asdf/os :asdf/image :asdf/run-program :asdf/lisp-build :asdf/configuration :asdf/backward-driver) (:reexport - :asdf/package :asdf/compatibility :asdf/utility + ;; NB: excluding asdf/common-lisp + ;; which include all of CL with compatibility modifications on select platforms. + :asdf/package :asdf/utility :asdf/pathname :asdf/stream :asdf/os :asdf/image :asdf/run-program :asdf/lisp-build :asdf/configuration)) diff --git a/find-component.lisp b/find-component.lisp index e693f6c6a0e5e2165f2a7d19f093e970283a2077..b25c014aeae9d1108b9e6e9ae4c994ffd3981a53 100644 --- a/find-component.lisp +++ b/find-component.lisp @@ -3,7 +3,8 @@ (asdf/package:define-package :asdf/find-component (:recycle :asdf/find-component :asdf) - (:use :common-lisp :asdf/driver :asdf/upgrade :asdf/component :asdf/system :asdf/find-system) + (:use :asdf/common-lisp :asdf/driver :asdf/upgrade + :asdf/component :asdf/system :asdf/find-system) (:export #:find-component #:resolve-dependency-name #:resolve-dependency-spec diff --git a/find-system.lisp b/find-system.lisp index 016c6e385f6abbe224a421da6280c43333657c8e..028fa5dfb257fc8a49f7d4e799272bc128f98891 100644 --- a/find-system.lisp +++ b/find-system.lisp @@ -3,7 +3,8 @@ (asdf/package:define-package :asdf/find-system (:recycle :asdf/find-system :asdf) - (:use :common-lisp :asdf/driver :asdf/upgrade :asdf/component :asdf/system) + (:use :asdf/common-lisp :asdf/driver :asdf/upgrade + :asdf/component :asdf/system) (:export #:remove-entry-from-registry #:coerce-entry-to-directory #:coerce-name #:primary-system-name @@ -15,8 +16,8 @@ #:*system-definition-search-functions* #:search-for-system-definition #:*central-registry* #:probe-asd #:sysdef-central-registry-search #:make-temporary-package #:find-system-if-being-defined #:*systems-being-defined* - #:find-system-fallback #:sysdef-find-asdf #:contrib-sysdef-search - #:system-find-pre-loaded-system #:*pre-loaded-systems* + #:contrib-sysdef-search #:sysdef-find-asdf ;; backward compatibility symbols, functions removed + #:system-find-preloaded-system #:register-preloaded-system #:*preloaded-systems* #:make-defined-systems-table #:*defined-systems* ;; defined in source-registry, but specially mentioned here: #:initialize-source-registry #:sysdef-source-registry-search)) @@ -81,8 +82,8 @@ of which is a system object.") (gethash (coerce-name name) *defined-systems*)) (defun* registered-systems () - (loop :for (() . system) :being :the :hash-values :of *defined-systems* - :collect (coerce-name system))) + (loop :for registered :being :the :hash-values :of *defined-systems* + :collect (coerce-name (cdr registered)))) (defun* register-system (system) (check-type system system) @@ -108,8 +109,8 @@ Note that this does NOT in any way cause the code of the system to be unloaded." FN should be a function of one argument. It will be called with an object of type asdf:system." - (loop :for (nil . system) :being :the hash-values :of *defined-systems* - :do (funcall fn system))) + (loop :for registered :being :the :hash-values :of *defined-systems* + :do (funcall fn (cdr registered)))) ;;; for the sake of keeping things reasonably neat, we adopt a ;;; convention that functions in this list are prefixed SYSDEF- @@ -129,7 +130,7 @@ called with an object of type asdf:system." (remove-if #'(lambda (x) (member x *system-definition-search-functions*)) '(sysdef-central-registry-search sysdef-source-registry-search - sysdef-find-pre-loaded-systems))))) + sysdef-find-preloaded-systems))))) (cleanup-system-definition-search-functions) (defun* search-for-system-definition (system) @@ -332,19 +333,19 @@ PREVIOUS-TIME when not null is the time at which the PREVIOUS system was loaded. (format s (compatfmt "~@<Retry finding system ~A after reinitializing the source-registry.~@:>") name)) (initialize-source-registry)))))) -(defun* find-system-fallback (requested fallback &rest keys &key source-file &allow-other-keys) - (setf fallback (coerce-name fallback) - requested (coerce-name requested)) - (when (equal requested fallback) - (let ((registered (cdr (gethash fallback *defined-systems*)))) - (or registered - (apply 'make-instance 'system :name fallback :source-file source-file keys))))) +(defvar *preloaded-systems* (make-hash-table :test 'equal)) -(defvar *pre-loaded-systems* `(("asdf") ("asdf-driver"))) +(defun* sysdef-find-preloaded-systems (requested) + (let ((name (coerce-name requested))) + (multiple-value-bind (keys foundp) (gethash name *preloaded-systems*) + (when foundp + (apply 'make-instance 'system :name name :source-file (getf keys :source-file) keys))))) -(defun* sysdef-find-pre-loaded-systems (requested) - (loop :for (provided . keys) :in *pre-loaded-systems* - :thereis (apply 'find-system-fallback requested provided keys))) +(defun register-preloaded-system (system-name &rest keys) + (setf (gethash (coerce-name system-name) *preloaded-systems*) keys)) + +(register-preloaded-system "asdf") +(register-preloaded-system "asdf-driver") ;;;; Beware of builtin systems (defmethod builtin-system-p ((s system)) diff --git a/footer.lisp b/footer.lisp index 2cb277d8b807b3dc7285cb513f7d1e89911aeaba..b02565b73e3700dbc03f29d9a3a62284408ced51 100644 --- a/footer.lisp +++ b/footer.lisp @@ -3,7 +3,7 @@ (asdf/package:define-package :asdf/footer (:recycle :asdf/footer :asdf) - (:use :common-lisp :asdf/driver :asdf/upgrade + (:use :asdf/common-lisp :asdf/driver :asdf/upgrade :asdf/find-system :asdf/find-component :asdf/operation :asdf/action :asdf/lisp-action :asdf/operate :asdf/bundle :asdf/concatenate-source :asdf/output-translations :asdf/source-registry @@ -59,7 +59,7 @@ #+allegro (eval-when (:compile-toplevel :execute) (when (boundp 'excl:*warn-on-nested-reader-conditionals*) - (setf excl:*warn-on-nested-reader-conditionals* asdf/compatibility::*acl-warn-save*))) + (setf excl:*warn-on-nested-reader-conditionals* asdf/common-lisp::*acl-warn-save*))) (dolist (f '(:asdf :asdf2 :asdf2.27)) (pushnew f *features*)) diff --git a/header.lisp b/header.lisp index 5f41557aa4fa74038618c1ace099c497eb5e9f39..b113fe0018e0bbba7aaa0aa8836a7c68d20b1984 100644 --- a/header.lisp +++ b/header.lisp @@ -1,5 +1,5 @@ -;; -*- mode: Common-Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp ; coding: utf-8 -*- -;;; This is ASDF 2.26.141: Another System Definition Facility. +;; -*- mode: Common-Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp -*- +;;; This is ASDF 2.26.142: Another System Definition Facility. ;;; ;;; Feedback, bug reports, and patches are all welcome: ;;; please mail to <asdf-devel@common-lisp.net>. diff --git a/image.lisp b/image.lisp index 2ac9af46f520c41a8c8824b1708db924ef878e0c..4edcf455c905e48925c58a6fe13fed6aab841fd4 100644 --- a/image.lisp +++ b/image.lisp @@ -3,7 +3,7 @@ (asdf/package:define-package :asdf/image (:recycle :asdf/image :xcvb-driver) - (:use :common-lisp :asdf/package :asdf/utility :asdf/pathname :asdf/stream :asdf/os) + (:use :asdf/common-lisp :asdf/package :asdf/utility :asdf/pathname :asdf/stream :asdf/os) (:export #:*image-dumped-p* #:raw-command-line-arguments #:*command-line-arguments* #:command-line-arguments #:raw-command-line-arguments #:setup-command-line-arguments @@ -194,10 +194,11 @@ This is designed to abstract away the implementation specific quit forms." #+(or cmu scl) extensions:*command-line-strings* #+ecl (loop :for i :from 0 :below (si:argc) :collect (si:argv i)) #+gcl si:*command-args* + #+genera nil #+lispworks sys:*line-arguments-list* #+sbcl sb-ext:*posix-argv* #+xcl system:*argv* - #-(or abcl allegro clisp clozure cmu ecl gcl lispworks sbcl scl xcl) + #-(or abcl allegro clisp clozure cmu ecl gcl genera lispworks sbcl scl xcl) (error "raw-command-line-arguments not implemented yet")) (defun* command-line-arguments (&optional (arguments (raw-command-line-arguments))) @@ -243,7 +244,7 @@ if we are not called from a directly executable image." (setf *image-dumped-p* (if executable :executable t)) (standard-eval-thunk *image-postlude*) (call-image-dump-hook) - #-(or clisp clozure cmu lispworks sbcl) + #-(or clisp clozure cmu lispworks sbcl scl) (when executable (error "Dumping an executable is not supported on this implementation! Aborting.")) #+allegro diff --git a/interface.lisp b/interface.lisp index 23cfdbb4a8550b5b92b399db26d1d8cda8897988..b446a0cfd7634c506581a065fa7479bddb2df77c 100644 --- a/interface.lisp +++ b/interface.lisp @@ -10,7 +10,7 @@ #:split #:make-collector #:loaded-systems ; makes for annoying SLIME completion #:output-files-for-system-and-operation) ; obsolete ASDF-BINARY-LOCATION function - (:use :common-lisp :asdf/driver :asdf/upgrade + (:use :asdf/common-lisp :asdf/driver :asdf/upgrade :asdf/component :asdf/system :asdf/find-system :asdf/find-component :asdf/operation :asdf/action :asdf/lisp-action :asdf/output-translations :asdf/source-registry diff --git a/lisp-action.lisp b/lisp-action.lisp index f986ba7f53bb91532c142881775b2efb112f6256..9ed41712e7b413daec6e6382a45db8471c28f516 100644 --- a/lisp-action.lisp +++ b/lisp-action.lisp @@ -4,7 +4,7 @@ (asdf/package:define-package :asdf/lisp-action (:recycle :asdf/lisp-action :asdf) (:intern #:proclamations #:flags) - (:use :common-lisp :asdf/driver :asdf/upgrade + (:use :asdf/common-lisp :asdf/driver :asdf/upgrade :asdf/component :asdf/system :asdf/find-component :asdf/operation :asdf/action) (:export #:try-recompiling @@ -146,12 +146,12 @@ (defmethod input-files ((o compile-op) (c system)) (declare (ignorable o c)) (unless (builtin-system-p c) - (loop :for (sub-o . sub-c) - :in (traverse-sub-actions - o c :other-systems nil - :keep-operation 'compile-op :keep-component 'cl-source-file) - :append (remove-if-not 'warnings-file-p - (output-files sub-o sub-c))))) + (loop* :for (sub-o . sub-c) + :in (traverse-sub-actions + o c :other-systems nil + :keep-operation 'compile-op :keep-component 'cl-source-file) + :append (remove-if-not 'warnings-file-p + (output-files sub-o sub-c))))) #+sbcl (defmethod output-files ((o compile-op) (c system)) (unless (builtin-system-p c) diff --git a/lisp-build.lisp b/lisp-build.lisp index 2bbc38b2bf95877d2f5604e0ba51ba64aab62d2e..241f2d2d9ff06301dc157e046440d1a80b3654fa 100644 --- a/lisp-build.lisp +++ b/lisp-build.lisp @@ -3,7 +3,7 @@ (asdf/package:define-package :asdf/lisp-build (:recycle :asdf/interface :asdf :asdf/lisp-build) - (:use :common-lisp :asdf/package :asdf/compatibility :asdf/utility + (:use :asdf/common-lisp :asdf/package :asdf/utility :asdf/pathname :asdf/stream :asdf/os :asdf/image) (:export ;; Variables @@ -457,7 +457,7 @@ it will filter them appropriately." (let* ((keywords (remove-plist-keys `(:output-file :compile-check :warnings-file #+clisp :lib-file #+(or ecl mkcl) :object-file - #+gcl<2.7 ,@'(:external-format :print :verbose)) keys)) + #+gcl2.6 ,@'(:external-format :print :verbose)) keys)) (output-file (or output-file (apply 'compile-file-pathname* input-file :output-file output-file keywords))) @@ -510,13 +510,13 @@ it will filter them appropriately." (defun* load* (x &rest keys &key &allow-other-keys) (etypecase x - ((or pathname string #-(or gcl<2.7 clozure allegro) stream) + ((or pathname string #-(or allegro clozure gcl2.6 genera) stream) (apply 'load x - #-gcl<2.7 keys #+gcl<2.7 (remove-plist-key :external-format keys))) - #-(or gcl<2.7 clozure allegro) - ;; GCL 2.6 can't load from a string-input-stream + #-gcl2.6 keys #+gcl2.6 (remove-plist-key :external-format keys))) + ;; GCL 2.6, 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 gcl2.6 genera) (stream ;; make do this way (let ((*package* *package*) (*readtable* *readtable*) diff --git a/operate.lisp b/operate.lisp index 78f57539322bc3015ebfac814f1e0d3a54f1548c..0420b226d3ff70199c08d62a2c352e52829b2fc8 100644 --- a/operate.lisp +++ b/operate.lisp @@ -3,7 +3,7 @@ (asdf/package:define-package :asdf/operate (:recycle :asdf/operate :asdf) - (:use :common-lisp :asdf/driver :asdf/upgrade + (:use :asdf/common-lisp :asdf/driver :asdf/upgrade :asdf/component :asdf/system :asdf/operation :asdf/action :asdf/find-system :asdf/find-component :asdf/lisp-action :asdf/plan) (:export diff --git a/operation.lisp b/operation.lisp index 3fa4bfc021d918670f0de9a8d0ef6d8b2d391f7a..53296c53e333366d5c878eb92f3cda5d79fc619d 100644 --- a/operation.lisp +++ b/operation.lisp @@ -3,7 +3,7 @@ (asdf/package:define-package :asdf/operation (:recycle :asdf/operation :asdf) - (:use :common-lisp :asdf/driver :asdf/upgrade) + (:use :asdf/common-lisp :asdf/driver :asdf/upgrade) (:export #:operation #:operation-original-initargs ;; backward-compatibility only. DO NOT USE. diff --git a/os.lisp b/os.lisp index 91ce089a397f97d57ce9c60db91d1f83825e6236..08cc87c3c4ab16ddcca757b8716df22a71d610d7 100644 --- a/os.lisp +++ b/os.lisp @@ -3,7 +3,7 @@ (asdf/package:define-package :asdf/os (:recycle :asdf/os :asdf) - (:use :cl :asdf/package :asdf/compatibility :asdf/utility :asdf/pathname :asdf/stream) + (:use :asdf/common-lisp :asdf/package :asdf/utility :asdf/pathname :asdf/stream) (:export #:featurep #:os-unix-p #:os-windows-p ;; features #:getenv #:getenvp ;; environment variables @@ -37,14 +37,18 @@ (defun* os-windows-p () (and (not (os-unix-p)) (featurep '(:or :win32 :windows :mswindows :mingw32)))) + (defun* os-genera-p () + (featurep :genera)) + (defun* detect-os () (flet ((yes (yes) (pushnew yes *features*)) (no (no) (setf *features* (remove no *features*)))) (cond ((os-unix-p) (yes :os-unix) (no :os-windows)) ((os-windows-p) (yes :os-windows) (no :os-unix)) + ((os-genera-p) (no :os-unix) (no :os-windows)) (t (error "Congratulations for trying XCVB on an operating system~%~ -that is neither Unix, nor Windows.~%Now you port it."))))) +that is neither Unix, nor Windows, nor even Genera.~%Now you port it."))))) (detect-os)) @@ -335,14 +339,14 @@ a CL pathname satisfying all the specified constraints as per ENSURE-PATHNAME" (defun setup-temporary-directory () (setf *temporary-directory* (default-temporary-directory)) ;; basic lack fixed after gcl 2.7.0-61, but ending / required still on 2.7.0-64.1 - #+(and gcl (not gcl<2.7)) (setf system::*tmp-dir* *temporary-directory*)) + #+(and gcl (not gcl2.6)) (setf system::*tmp-dir* *temporary-directory*)) (defun* call-with-temporary-file (thunk &key prefix keep (direction :io) (element-type *default-stream-element-type*) (external-format :default)) - #+gcl<2.7 (declare (ignorable external-format)) + #+gcl2.6 (declare (ignorable external-format)) (check-type direction (member :output :io)) (loop :with prefix = (or prefix (format nil "~Atmp" (native-namestring (temporary-directory)))) @@ -354,7 +358,7 @@ a CL pathname satisfying all the specified constraints as per ENSURE-PATHNAME" (with-open-file (stream pathname :direction direction :element-type element-type - #-gcl<2.7 :external-format #-gcl<2.7 external-format + #-gcl2.6 :external-format #-gcl2.6 external-format :if-exists nil :if-does-not-exist :create) (when stream (return diff --git a/output-translations.lisp b/output-translations.lisp index c120bdafb5e53c4c90d8c1ac963536e6baaf0860..ce7efe1b703a846e01491dfa2ce54d6b5ae17e05 100644 --- a/output-translations.lisp +++ b/output-translations.lisp @@ -3,7 +3,7 @@ (asdf/package:define-package :asdf/output-translations (:recycle :asdf/output-translations :asdf) - (:use :common-lisp :asdf/driver :asdf/upgrade) + (:use :asdf/common-lisp :asdf/driver :asdf/upgrade) (:export #:*output-translations* #:*output-translations-parameter* #:invalid-output-translation @@ -209,7 +209,7 @@ and the order is by decreasing length of namestring of the source pathname.") (inherit *default-output-translations*) collect) (process-output-translations (funcall x) :inherit inherit :collect collect)) -(defmethod process-output-translations ((pathname #-gcl<2.7 pathname #+gcl<2.7 t) &key inherit collect) +(defmethod process-output-translations ((pathname #-gcl2.6 pathname #+gcl2.6 t) &key inherit collect) (cond ((directory-pathname-p pathname) (process-output-translations (validate-output-translations-directory pathname) @@ -267,7 +267,7 @@ effectively disabling the output translation facility." path) ((or pathname string) (ensure-output-translations) - (loop :with p = (resolve-symlinks* path) + (loop* :with p = (resolve-symlinks* path) :for (source destination) :in (car *output-translations*) :for root = (when (or (eq source t) (and (pathnamep source) diff --git a/package.lisp b/package.lisp index 4cb9ea1a2ac37cf2916c18bcf287ffc14fc56f40..260802a360d0ab877c2924de90c6642dffdfce01 100644 --- a/package.lisp +++ b/package.lisp @@ -13,7 +13,8 @@ (defpackage :asdf/package (:use :common-lisp) (:export - #:find-package* #:find-symbol* #:symbol-call #:intern* #:unintern* #:make-symbol* + #:find-package* #:find-symbol* #:symbol-call + #:intern* #:unintern* #:export* #:make-symbol* #:symbol-shadowing-p #:home-package-p #:rehome-symbol #:symbol-package-name #:standard-common-lisp-symbol-p #:reify-package #:unreify-package #:reify-symbol #:unreify-symbol @@ -56,6 +57,10 @@ or when loading the package is optional." (apply (find-symbol* name package) args)) (defun intern* (name package-designator &optional (error t)) (intern (string name) (find-package* package-designator error))) + (defun export* (name package-designator) + (let* ((package (find-package* package-designator)) + (symbol (intern* name package))) + (export (or symbol (list symbol)) package))) (defun make-symbol* (name) (etypecase name (string (make-symbol name)) @@ -240,9 +245,9 @@ or when loading the package is optional." (when foundp (unintern overwritten-setf))) (when (eq old-status :external) - (export symbol old-package)) + (export* symbol old-package)) (when (eq overwritten-symbol-status :external) - (export symbol package)))) + (export* symbol package)))) (values overwritten-symbol overwritten-symbol-status)))) (defun ensure-package-unused (package) (loop :for p :in (package-used-by-list package) :do @@ -340,6 +345,7 @@ or when loading the package is optional." import-from export intern recycle mix reexport unintern) + (declare (ignorable documentation)) (macrolet ((when-fishy (&body body) `(when-package-fishiness ,@body)) (fishy (&rest info) `(note-package-fishiness ,@info))) (let* ((package-name (string name)) @@ -490,7 +496,7 @@ or when loading the package is optional." (ensure-exported (name sym p) (dolist (u (package-used-by-list p)) (ensure-exported-to-user name sym u)) - (export sym p)) + (export* sym p)) (ensure-exported-to-user (name sym u) (multiple-value-bind (usym ustat) (find-symbol name u) (unless (and ustat (eq sym usym)) @@ -508,7 +514,7 @@ or when loading the package is optional." t))))) (when (and accessible (eq ustat :external)) (ensure-exported name sym u))))))) - #-gcl (setf (documentation package t) documentation) #+gcl documentation + #-(or gcl genera) (setf (documentation package t) documentation) #+gcl documentation (loop :for p :in (set-difference (package-use-list package) (append mix use)) :do (fishy :use (package-names p)) (unuse-package p package)) (loop :for p :in discarded @@ -563,10 +569,10 @@ or when loading the package is optional." (do-external-symbols (sym p) (ensure-inherited (string sym) sym p nil)) (use-package p package)) (loop :for name :being :the :hash-keys :of exported :do - (ensure-symbol (string name) t) + (ensure-symbol name t) (ensure-export name package)) (dolist (name intern) - (ensure-symbol (string name) t)) + (ensure-symbol name t)) (do-symbols (sym package) (ensure-symbol (symbol-name sym))) (map () 'delete-package* to-delete) @@ -607,22 +613,35 @@ or when loading the package is optional." (defmacro define-package (package &rest clauses) (let ((ensure-form `(apply 'ensure-package ',(parse-define-package-form package clauses)))) - (eval ensure-form) `(progn #+clisp (eval-when (:compile-toplevel :load-toplevel :execute) ,ensure-form) - #+(or ecl gcl) (defpackage ,package (:use)) - #+clisp ,(package-definition-form - package :nicknamesp nil :usep nil :internp nil :exportp nil - :error nil) + #+(or clisp ecl gcl) (defpackage ,package (:use)) (eval-when (:compile-toplevel :load-toplevel :execute) ,ensure-form)))) ;;;; Final tricks to keep various implementations happy. +;; We want most such tricks in common-lisp.lisp, +;; but these need to be done before the define-package form there, +;; that we nevertheless want to be the very first form. (eval-when (:load-toplevel :compile-toplevel :execute) #+allegro ;; We need to disable autoloading BEFORE any mention of package ASDF. (setf excl::*autoload-package-name-alist* (remove "asdf" excl::*autoload-package-name-alist* - :test 'equalp :key 'car))) + :test 'equalp :key 'car)) + #+gcl + ;; Debian's GCL 2.7 has bugs with compiling multiple-value stuff, + ;; but can run ASDF 2.011. GCL 2.6 has even more issues. + (cond + ((or (< system::*gcl-major-version* 2) + (and (= system::*gcl-major-version* 2) + (< system::*gcl-minor-version* 6))) + (error "GCL 2.6 or later required to use ASDF")) + ((and (= system::*gcl-major-version* 2) + (= system::*gcl-minor-version* 6)) + (pushnew 'ignorable pcl::*variable-declarations-without-argument*) + (pushnew :gcl2.6 *features*)) + (t + (pushnew :gcl2.7 *features*)))) diff --git a/pathname.lisp b/pathname.lisp index e67f63f3bd1a1dd911571d47aa54acdea9eb0f7e..ac078288ad2472d15333193cccb2e1a25116cd14 100644 --- a/pathname.lisp +++ b/pathname.lisp @@ -3,8 +3,7 @@ (asdf/package:define-package :asdf/pathname (:recycle :asdf/pathname :asdf) - #+gcl<2.7 (:shadowing-import-from :system :*load-pathname*) ;; GCL 2.6 sucks - (:use :common-lisp :asdf/package :asdf/compatibility :asdf/utility) + (:use :asdf/common-lisp :asdf/package :asdf/utility) (:export #:*resolve-symlinks* ;; Making and merging pathnames, portably @@ -71,25 +70,25 @@ Defaults to T.") (defun* normalize-pathname-directory-component (directory) "Given a pathname directory component, return an equivalent form that is a list" - #+gcl<2.7 (setf directory (substitute :back :parent directory)) + #+gcl2.6 (setf directory (substitute :back :parent directory)) (cond #-(or cmu sbcl scl) ;; these implementations already normalize directory components. ((stringp directory) `(:absolute ,directory)) - #+gcl<2.7 + #+gcl2.6 ((and (consp directory) (eq :root (first directory))) `(:absolute ,@(rest directory))) ((or (null directory) (and (consp directory) (member (first directory) '(:absolute :relative)))) directory) - #+gcl<2.7 + #+gcl2.6 ((consp directory) `(:relative ,@directory)) (t (error (compatfmt "~@<Unrecognized pathname directory component ~S~@:>") directory)))) (defun* denormalize-pathname-directory-component (directory-component) - #-gcl<2.7 directory-component - #+gcl<2.7 + #-gcl2.6 directory-component + #+gcl2.6 (let ((d (substitute-if :parent (lambda (x) (member x '(:up :back))) directory-component))) (cond @@ -329,8 +328,8 @@ Returns the (parsed) PATHNAME when true" ;;; Wildcard pathnames (defparameter *wild* (or #+cormanlisp "*" :wild)) -(defparameter *wild-directory-component* (or #+gcl<2.7 "*" :wild)) -(defparameter *wild-inferiors-component* (or #+gcl<2.7 "**" :wild-inferiors)) +(defparameter *wild-directory-component* (or #+gcl2.6 "*" :wild)) +(defparameter *wild-inferiors-component* (or #+gcl2.6 "**" :wild-inferiors)) (defparameter *wild-file* (make-pathname :directory nil :name *wild* :type *wild* :version (or #-(or allegro abcl xcl) *wild*))) @@ -380,7 +379,7 @@ or the original (parsed) pathname if it is false (the default)." '(probe-file p) #+clisp (if-let (it (find-symbol* '#:probe-pathname :ext nil)) `(ignore-errors (,it p))) - #+gcl<2.7 + #+gcl2.6 '(or (probe-file p) (and (directory-pathname-p p) (ignore-errors diff --git a/plan.lisp b/plan.lisp index 9920b1e41a98e204df33ebef902badcbc2cc2bdd..9a1c9f7b4a6517f7cf9c14d057262af8ab3394a0 100644 --- a/plan.lisp +++ b/plan.lisp @@ -3,10 +3,9 @@ (asdf/package:define-package :asdf/plan (:recycle :asdf/plan :asdf) - (:use :common-lisp :asdf/driver :asdf/upgrade + (:use :asdf/common-lisp :asdf/driver :asdf/upgrade :asdf/component :asdf/operation :asdf/system :asdf/find-system :asdf/find-component :asdf/operation :asdf/action) - #+gcl<2.7 (:shadowing-import-from :asdf/compatibility #:type-of) (:export #:component-operation-time #:mark-operation-done #:plan-traversal #:sequential-plan #:*default-plan-class* @@ -171,18 +170,18 @@ the action of OPERATION on COMPONENT in the PLAN")) ;;;; Visiting dependencies of an action and computing action stamps (defun* map-direct-dependencies (operation component fun) - (loop :for (dep-o-spec . dep-c-specs) :in (component-depends-on operation component) - :unless (eq dep-o-spec 'feature) ;; avoid the "FEATURE" misfeature - :do (loop :with dep-o = (find-operation operation dep-o-spec) - :for dep-c-spec :in dep-c-specs - :for dep-c = (resolve-dependency-spec component dep-c-spec) - :do (funcall fun dep-o dep-c)))) + (loop* :for (dep-o-spec . dep-c-specs) :in (component-depends-on operation component) + :unless (eq dep-o-spec 'feature) ;; avoid the "FEATURE" misfeature + :do (loop :with dep-o = (find-operation operation dep-o-spec) + :for dep-c-spec :in dep-c-specs + :for dep-c = (resolve-dependency-spec component dep-c-spec) + :do (funcall fun dep-o dep-c)))) (defun* reduce-direct-dependencies (operation component combinator seed) (map-direct-dependencies operation component - (lambda (dep-o dep-c) - (setf seed (funcall combinator dep-o dep-c seed)))) + #'(lambda (dep-o dep-c) + (setf seed (funcall combinator dep-o dep-c seed)))) seed) (defun* direct-dependencies (operation component) @@ -191,9 +190,9 @@ the action of OPERATION on COMPONENT in the PLAN")) (defun* visit-dependencies (plan operation component dependency-stamper &aux stamp) (map-direct-dependencies operation component - (lambda (dep-o dep-c) - (when (action-valid-p plan dep-o dep-c) - (latest-stamp-f stamp (funcall dependency-stamper dep-o dep-c))))) + #'(lambda (dep-o dep-c) + (when (action-valid-p plan dep-o dep-c) + (latest-stamp-f stamp (funcall dependency-stamper dep-o dep-c))))) stamp) (defmethod compute-action-stamp (plan (o operation) (c component) &key just-done) @@ -381,7 +380,7 @@ processed in order by OPERATE.")) (defmethod perform-plan ((steps list) &key) (let ((*package* *package*) (*readtable* *readtable*)) - (loop :for (op . component) :in steps :do + (loop* :for (op . component) :in steps :do (perform-with-restarts op component)))) (defmethod plan-operates-on-p ((plan list) (component-path list)) @@ -413,7 +412,7 @@ processed in order by OPERATE.")) (defmethod traverse-actions (actions &rest keys &key plan-class &allow-other-keys) (let ((plan (apply 'make-instance (or plan-class 'filtered-sequential-plan) keys))) - (loop :for (o . c) :in actions :do + (loop* :for (o . c) :in actions :do (traverse-action plan o c t)) (plan-actions plan))) @@ -423,10 +422,10 @@ processed in order by OPERATE.")) (defmethod plan-actions ((plan filtered-sequential-plan)) (with-slots (keep-operation keep-component) plan - (loop :for (o . c) :in (call-next-method) - :when (and (typep o keep-operation) - (typep c keep-component)) - :collect (cons o c)))) + (loop* :for (o . c) :in (call-next-method) + :when (and (typep o keep-operation) + (typep c keep-component)) + :collect (cons o c)))) (defmethod required-components (system &rest keys &key (goal-operation 'load-op) &allow-other-keys) (remove-duplicates diff --git a/run-program.lisp b/run-program.lisp index e3bc42bf629affbc651af00da359adfdd2b27baa..f2c19e006fe3aec47bcb65f59b96c4dcd35493d2 100644 --- a/run-program.lisp +++ b/run-program.lisp @@ -3,7 +3,7 @@ (asdf/package:define-package :asdf/run-program (:recycle :asdf/run-program :xcvb-driver) - (:use :common-lisp :asdf/utility :asdf/pathname :asdf/stream :asdf/os) + (:use :asdf/common-lisp :asdf/utility :asdf/pathname :asdf/stream :asdf/os) (:export ;;; Escaping the command invocation madness #:easy-sh-character-p #:escape-sh-token #:escape-sh-command @@ -33,9 +33,9 @@ as either a recognizing function or a sequence of characters." ((functionp bad-chars) bad-chars) ((and good-chars (typep good-chars 'sequence)) - (lambda (c) (not (find c good-chars)))) + #'(lambda (c) (not (find c good-chars)))) ((and bad-chars (typep bad-chars 'sequence)) - (lambda (c) (find c bad-chars))) + #'(lambda (c) (find c bad-chars))) (t (error "requires-escaping-p: no good-char criterion"))) token)) @@ -61,7 +61,7 @@ for use within a MS Windows command-line, outputing to S." ((#\") (issue-backslash 1) (issue #\") (setf i i+1)) ((#\\) (let* ((j (and (< i+1 l) (position-if-not - (lambda (c) (eql c #\\)) x :start i+1))) + #'(lambda (c) (eql c #\\)) x :start i+1))) (n (- (or j l) i))) (cond ((null j) @@ -136,14 +136,14 @@ by /bin/sh in POSIX" (defgeneric* slurp-input-stream (processor input-stream &key &allow-other-keys)) -#-(or gcl<2.7 genera) +#-(or gcl2.6 genera) (defmethod slurp-input-stream ((function function) input-stream &key &allow-other-keys) (funcall function input-stream)) (defmethod slurp-input-stream ((list cons) input-stream &key &allow-other-keys) (apply (first list) (cons input-stream (rest list)))) -#-(or gcl<2.7 genera) +#-(or gcl2.6 genera) (defmethod slurp-input-stream ((output-stream stream) input-stream &key linewise prefix (element-type 'character) buffer-size &allow-other-keys) (copy-stream-to-stream @@ -179,9 +179,9 @@ by /bin/sh in POSIX" &allow-other-keys) (declare (ignorable stream linewise prefix element-type buffer-size)) (cond - #+(or gcl<2.7 genera) + #+(or gcl2.6 genera) ((functionp x) (funcall x stream)) - #+(or gcl<2.7 genera) + #+(or gcl2.6 genera) ((output-stream-p x) (copy-stream-to-stream input-stream output-stream @@ -377,7 +377,7 @@ Use ELEMENT-TYPE and EXTERNAL-FORMAT for the stream passed to the OUTPUT process :direction :input :if-does-not-exist :error :element-type element-type - #-gcl<2.7 :external-format #-gcl<2.7 external-format) + #-gcl2.6 :external-format #-gcl2.6 external-format) (slurp-input-stream output stream))) (call-system (system-command command) :interactive interactive))))) (if (and (not force-shell) diff --git a/source-registry.lisp b/source-registry.lisp index a5bbfff0021c83c642d03af6965c05b7e6c89894..92e6dd58a3bb947e0c09cd94fc95dafb4ae4a073 100644 --- a/source-registry.lisp +++ b/source-registry.lisp @@ -4,7 +4,7 @@ (asdf/package:define-package :asdf/source-registry (:recycle :asdf/source-registry :asdf) - (:use :common-lisp :asdf/driver :asdf/upgrade :asdf/find-system) + (:use :asdf/common-lisp :asdf/driver :asdf/upgrade :asdf/find-system) (:export #:*source-registry* #:*source-registry-parameter* #:*default-source-registries* #:invalid-source-registry @@ -218,7 +218,7 @@ system names to pathnames of .asd files") (defmethod process-source-registry ((x symbol) &key inherit register) (process-source-registry (funcall x) :inherit inherit :register register)) -(defmethod process-source-registry ((pathname #-gcl<2.7 pathname #+gcl<2.7 t) &key inherit register) +(defmethod process-source-registry ((pathname #-gcl2.6 pathname #+gcl2.6 t) &key inherit register) (cond ((directory-pathname-p pathname) (let ((*here-directory* (resolve-symlinks* pathname))) diff --git a/stream.lisp b/stream.lisp index 2edda75c24d64247db96b6f14bc6770d850b34f3..f7c4fa89a2ce5c9029fe1eb3d04284e823138e04 100644 --- a/stream.lisp +++ b/stream.lisp @@ -3,8 +3,7 @@ (asdf/package:define-package :asdf/stream (:recycle :asdf/stream) - (:use :cl :asdf/package :asdf/compatibility :asdf/utility :asdf/pathname) - #+gcl<2.7 (:shadowing-import-from :asdf/compatibility #:with-standard-io-syntax) + (:use :asdf/common-lisp :asdf/package :asdf/utility :asdf/pathname) (:export #:*default-stream-element-type* #:*stderr* #:setup-stderr #:with-safe-io-syntax #:call-with-safe-io-syntax @@ -115,10 +114,10 @@ as per CALL-WITH-INPUT, and evaluate BODY within the scope of this binding." (if-does-not-exist :error)) "Open FILE for input with given recognizes options, call THUNK with the resulting stream. Other keys are accepted but discarded." - #+gcl<2.7 (declare (ignore external-format)) + #+gcl2.6 (declare (ignore external-format)) (with-open-file (s pathname :direction :input :element-type element-type - #-gcl<2.7 :external-format #-gcl<2.7 external-format + #-gcl2.6 :external-format #-gcl2.6 external-format :if-does-not-exist if-does-not-exist) (funcall thunk s))) @@ -160,13 +159,13 @@ If LINEWISE is true, then read and copy the stream line by line, with an optiona Otherwise, using WRITE-SEQUENCE using a buffer of size BUFFER-SIZE." (with-open-stream (input input) (if linewise - (loop :for (line eof) = (multiple-value-list (read-line input nil nil)) - :while line :do - (when prefix (princ prefix output)) - (princ line output) - (unless eof (terpri output)) - (finish-output output) - (when eof (return))) + (loop* :for (line eof) = (multiple-value-list (read-line input nil nil)) + :while line :do + (when prefix (princ prefix output)) + (princ line output) + (unless eof (terpri output)) + (finish-output output) + (when eof (return))) (loop :with buffer-size = (or buffer-size 8192) :for buffer = (make-array (list buffer-size) :element-type (or element-type 'character)) diff --git a/system.lisp b/system.lisp index 37afffd9eb0a4fbdf5254fdef5bb8a57db2dc5f0..286834ddc936a238a0d7e6650f323b6bbd3606c2 100644 --- a/system.lisp +++ b/system.lisp @@ -3,7 +3,7 @@ (asdf/package:define-package :asdf/system (:recycle :asdf :asdf/system) - (:use :common-lisp :asdf/driver :asdf/upgrade :asdf/component) + (:use :asdf/common-lisp :asdf/driver :asdf/upgrade :asdf/component) (:export #:system #:proto-system #:system-source-file #:system-source-directory #:system-relative-pathname @@ -11,6 +11,7 @@ #:system-description #:system-long-description #:system-author #:system-maintainer #:system-licence #:system-license #:system-defsystem-depends-on + #:component-build-pathname #:build-pathname #:find-system #:builtin-system-p)) ;; forward-reference, defined in find-system (in-package :asdf/system) @@ -18,6 +19,7 @@ (defgeneric* (system-source-file) (system) (:documentation "Return the source file in which system is defined.")) (defgeneric* builtin-system-p (system)) +(defgeneric* component-build-pathname (component)) ;;;; The system class @@ -35,6 +37,8 @@ (maintainer :accessor system-maintainer :initarg :maintainer) (licence :accessor system-licence :initarg :licence :accessor system-license :initarg :license) + (build-pathname + :initform nil :initarg :build-pathname :accessor component-build-pathname) (source-file :initform nil :initarg :source-file :accessor system-source-file) (defsystem-depends-on :reader system-defsystem-depends-on :initarg :defsystem-depends-on))) @@ -74,4 +78,6 @@ in which the system specification (.asd file) is located." (defmethod component-parent-pathname ((system system)) (system-source-directory system)) - +(defmethod component-build-pathname ((c component)) + (declare (ignorable c)) + nil) diff --git a/test/asdf-pathname-test.script b/test/asdf-pathname-test.script index e8bb1cd53973c066a44c0130b8eb1d044e79e11b..18db94d1e9db9b4646e0f329cca574cb7a3e9207 100644 --- a/test/asdf-pathname-test.script +++ b/test/asdf-pathname-test.script @@ -61,7 +61,7 @@ (cons "asdf-src" path))) (bin-dir (&rest path) (append (or (pathname-directory root) (list :relative)) (cons "asdf-bin" path)))) - #-gcl<2.7 + #-gcl2.6 (setf (logical-pathname-translations "ASDFTEST") `((,(format nil "**;*.~a" bin-type) ,(make-pathname :directory (bin-dir :wild-inferiors) @@ -320,7 +320,7 @@ (format t "output translations: ~S~%" (asdf::output-translations)) #+gcl (format t "~&~A~&" (progn (defvar *x* -1) (incf *x*))) - #-(or xcl gcl<2.7) ;;---*** pathnames are known to be massively broken on XCL and GCL 2.6 + #-(or xcl gcl2.6) ;;---*** pathnames are known to be massively broken on XCL and GCL 2.6 (flet ((same (s1 s2 p1 p2) (unless (equal (namestring p1) (namestring p2)) (describe p1) (describe p2) @@ -335,7 +335,7 @@ #-gcl (x (resolve-location '("/foo" "bar" :**/ "baz" #p"*.*") :ensure-directory nil :wilden t) #p"/foo/bar/**/baz/*.*"))) - #-(or xcl gcl<2.7) ;;---*** pathnames are known to be massively broken on XCL and GCL 2.6 + #-(or xcl gcl2.6) ;;---*** pathnames are known to be massively broken on XCL and GCL 2.6 (or (test-component-pathnames :delete-host t :support-string-pathnames nil) (leave-test "test failed" 1))) diff --git a/test/script-support.lisp b/test/script-support.lisp index e0851c81b99d0386a7e66a249ddc89299860c28c..8c4f3df7be82f4dfdfc2f8f1d1fb4ac75c0ec558 100644 --- a/test/script-support.lisp +++ b/test/script-support.lisp @@ -60,9 +60,9 @@ Some constraints: :test 'equalp :key 'car)) ; We need that BEFORE any mention of package ASDF. #+cmucl (setf ext:*gc-verbose* nil) #+gcl - (when (or (< system::*gcl-major-version* 2) - (and (= system::*gcl-major-version* 2) - (< system::*gcl-minor-version* 7))) + (when (and (= system::*gcl-major-version* 2) + (= system::*gcl-minor-version* 6)) + (pushnew :gcl2.6 *features*) (shadowing-import 'system:*load-pathname* :asdf-test)) #+lispworks (setf system:*stack-overflow-behaviour* :warn)) @@ -164,7 +164,7 @@ Some constraints: (defun touch-file (file &key (offset 0) timestamp) (let ((timestamp (or timestamp (+ offset (get-universal-time))))) - (multiple-value-bind (sec min hr day month year) (decode-universal-time timestamp #+gcl<2.7 -5) + (multiple-value-bind (sec min hr day month year) (decode-universal-time timestamp #+gcl2.6 -5) (acall :run-program `("touch" "-t" ,(format nil "~4,'0D~2,'0D~2,'0D~2,'0D~2,'0D.~2,'0D" year month day hr min sec) @@ -324,6 +324,7 @@ is bound, write a message and exit on an error. If (defun compile-asdf-script () (with-test () + #-gcl2.6 (ecase (with-asdf-conditions () (maybe-compile-asdf)) (:not-found (leave-test "Testsuite failed: unable to find ASDF source" 3)) @@ -423,6 +424,7 @@ is bound, write a message and exit on an error. If (set (asym :*asdf-verbose*) t)) (defun load-asdf (&optional tag) + #+gcl2.6 (load-asdf-lisp tag) #-gcl2.6 (load-asdf-fasl tag) (use-package :asdf :asdf-test) (use-package :asdf/driver :asdf-test) diff --git a/test/test-compile-file-failure.script b/test/test-compile-file-failure.script index bd612ca6a2c488cd03281eac82504e445aef225f..a52a093b89f798f855935f17abe7023b12e3362b 100644 --- a/test/test-compile-file-failure.script +++ b/test/test-compile-file-failure.script @@ -2,13 +2,13 @@ (in-package :asdf) -#-gcl<2.7 +#-gcl2.6 (assert (handler-case (let ((*compile-file-failure-behaviour* :warn)) (load-system 'test-compile-file-failure :force t) t) (compile-file-error () nil))) -#-gcl<2.7 +#-gcl2.6 (assert (handler-case (let ((*compile-file-failure-behaviour* :error)) (load-system 'test-compile-file-failure :force t) diff --git a/test/test-configuration.script b/test/test-configuration.script index 1682c87ea6931a19ac20cb004891698b2a7712a9..398b0d7c96615b1e3fffab58f922218b8ed2f78a 100644 --- a/test/test-configuration.script +++ b/test/test-configuration.script @@ -4,7 +4,7 @@ (in-package :asdf) (use-package :asdf-test) -#+gcl<2.7 (defmacro with-standard-io-syntax (&body body) `(progn ,@body)) +#+gcl2.6 (defmacro with-standard-io-syntax (&body body) `(progn ,@body)) (defparameter *tmp-directory* (subpathname *asdf-directory* "build/")) (setf *central-registry* nil) diff --git a/test/test-logical-pathname.script b/test/test-logical-pathname.script index 57a28c3146875f1b7b7b79ce30be2b27b439f42f..f0c284e857b6000c1713054c0dc47da2d4f7dd40 100644 --- a/test/test-logical-pathname.script +++ b/test/test-logical-pathname.script @@ -2,7 +2,7 @@ -#-gcl<2.7 +#-gcl2.6 (setf (logical-pathname-translations "ASDF") #+(or allegro clisp) `(("**;*.*.*" ,(asdf::wilden *asdf-directory*))) @@ -13,20 +13,20 @@ `(,*asdf-directory* "build/fasls" :implementation "logical-host-asdf") :wilden t)))) -#-gcl<2.7 +#-gcl2.6 (DBG :logical (logical-pathname-translations "ASDF") (translate-logical-pathname "ASDF:test;test-force.asd") (truename "ASDF:test;test-force.asd")) -#-(or xcl gcl<2.7) +#-(or xcl gcl2.6) (progn (DBG "Test logical pathnames in central registry") (setf *central-registry* '(#p"ASDF:test;")) (initialize-source-registry '(:source-registry :ignore-inherited-configuration)) (DBG "loading" (oos 'load-op :test-logical-pathname :force t))) -#-(or xcl gcl<2.7) +#-(or xcl gcl2.6) (progn (DBG "Test logical pathnames in source-registry, non-recursive") (clear-system :test-logical-pathname) @@ -35,7 +35,7 @@ '(:source-registry (:directory #p"ASDF:test;") :ignore-inherited-configuration)) (load-system :test-logical-pathname :force t :verbose t)) -#-(or xcl gcl<2.7) +#-(or xcl gcl2.6) (progn (DBG "Test logical pathnames in source-registry, recursive") (clear-system :test-logical-pathname) diff --git a/test/wild-module.script b/test/wild-module.script index 48c372e1c2d44d59ab8a063d39661fc8545bfa29..fb0dd1b8cea8e1af731e2838dfe0636f2f3f863a 100644 --- a/test/wild-module.script +++ b/test/wild-module.script @@ -6,5 +6,5 @@ (def-test-system :wild-module :version "0.0" :components ((:wild-module "systems" :pathname #p"*.asd"))) - #-gcl<2.7 + #-gcl2.6 (load-system :wild-module)) diff --git a/upgrade.lisp b/upgrade.lisp index 55a5eaf06935665d3a9c7f9e49377e684355e594..98eda9e80603d6a1d0594c752d19751229156016 100644 --- a/upgrade.lisp +++ b/upgrade.lisp @@ -4,7 +4,7 @@ (asdf/package:define-package :asdf/upgrade (:recycle :asdf/upgrade :asdf) - (:use :common-lisp :asdf/package :asdf/compatibility :asdf/utility) + (:use :asdf/common-lisp :asdf/package :asdf/utility) (:export #:upgrade-asdf #:asdf-upgrade-error #:when-upgrade #:*asdf-upgrade-already-attempted* @@ -35,7 +35,7 @@ ;; "2.345.6" would be a development version in the official upstream ;; "2.345.0.7" would be your seventh local modification of official release 2.345 ;; "2.345.6.7" would be your seventh local modification of development version 2.345.6 - (asdf-version "2.26.141") + (asdf-version "2.26.142") (existing-asdf (find-class (find-symbol* :component :asdf nil) nil)) (existing-version *asdf-version*) (already-there (equal asdf-version existing-version)) diff --git a/utility.lisp b/utility.lisp index 50711302935243a33289334032514534d0fde736..c4416be0b7bd4c9eac89d25f676a570ea391c074 100644 --- a/utility.lisp +++ b/utility.lisp @@ -3,8 +3,12 @@ (asdf/package:define-package :asdf/utility (:recycle :asdf/utility :asdf) - (:use :common-lisp :asdf/package :asdf/compatibility) - #+gcl<2.7 (:shadowing-import-from :asdf/compatibility #:with-standard-io-syntax) + (:use :asdf/common-lisp :asdf/package) + ;; import and reexport a few things defined in :asdf/common-lisp + (:import-from :asdf/common-lisp #:strcat #:compatfmt #:loop* + #+ecl #:use-ecl-byte-compiler-p #+mcl #:probe-posix) + (:export #:nil #:strcat #:compatfmt #:loop* + #+ecl #:use-ecl-byte-compiler-p #+mcl #:probe-posix) (:export ;; magic helper to define debugging functions: #:asdf-debug #:load-asdf-debug-utility #:*asdf-debug-utility* @@ -36,7 +40,7 @@ (defun undefine-function (function-spec) (cond ((symbolp function-spec) - #+(and clisp (or)) + #+clisp (let ((f (and (fboundp function-spec) (fdefinition function-spec)))) (when (typep f 'clos:standard-generic-function) (loop :for m :in (clos:generic-function-methods f) @@ -44,7 +48,7 @@ (fmakunbound function-spec)) ((and (consp function-spec) (eq (car function-spec) 'setf) (consp (cdr function-spec)) (null (cddr function-spec))) - #-(or gcl<2.7) (fmakunbound function-spec)) + #-gcl2.6 (fmakunbound function-spec)) (t (error "bad function spec ~S" function-spec)))) (defun undefine-functions (function-spec-list) (map () 'undefine-function function-spec-list))) @@ -63,7 +67,7 @@ ;; We usually try to do it only for the functions that need it, ;; which happens in asdf/upgrade - however, for ECL, we need this hammer, ;; (which causes issues in clisp) - ,@(when (or #-clisp supersede #+(or ecl (and gcl (not gcl-pre2.7))) t) ; XXX + ,@(when (or #-clisp supersede #+(or ecl gcl2.7) t) ; XXX `((undefine-function ',name))) #-gcl ; gcl 2.7.0 notinline functions lose secondary return values :-( ,@(when (and #+ecl (symbolp name)) ; fails for setf functions on ecl @@ -139,13 +143,13 @@ Returns two values: \(A B C\) and \(1 2 3\)." ;;; remove a key from a plist, i.e. for keyword argument cleanup (defun* remove-plist-key (key plist) "Remove a single key from a plist" - (loop :for (k v) :on plist :by #'cddr + (loop* :for (k v) :on plist :by #'cddr :unless (eq k key) :append (list k v))) (defun* remove-plist-keys (keys plist) "Remove a list of keys from a plist" - (loop :for (k v) :on plist :by #'cddr + (loop* :for (k v) :on plist :by #'cddr :unless (member k keys) :append (list k v))) @@ -210,7 +214,7 @@ starting the separation from the end, e.g. when called with arguments (defun* find-class* (x &optional (errorp t) environment) (etypecase x ((or standard-class built-in-class) x) - #+gcl<2.7 (keyword nil) + #+gcl2.6 (keyword nil) (symbol (find-class x errorp environment)))) diff --git a/version.lisp-expr b/version.lisp-expr index 7123b6d46eb1895f568e2b0f43de72be523d3bfe..89382cd4a3e6554b928909fde79aea9040a18054 100644 --- a/version.lisp-expr +++ b/version.lisp-expr @@ -1 +1 @@ -"2.26.141" +"2.26.142"