Commit aa5cba5d authored by Francois-Rene Rideau's avatar Francois-Rene Rideau
Browse files

2.26.100: checkpointing a lot of progress.

* Pathname support has been cleaned up, yet again,
 extending and renaming COERCE-PATHNAME into PARSE-UNIX-NAMESTRING,
 also ENSURE-PATHNAME, many docstrings, and plenty of small enhancements.
* Bundles were refactored to take advantage of the new, more sensible,
 component-depends-on semantics.
* Image support was cleaned up again, and program-op was implemented
 to produce a standalone executable on supported platforms;
 a working hello-world-example is included amongst tests.
* The *compile-file-function* indirection was removed, with the
 ECL and MKCL object file support
 being folded into compile-file* instead.
* systems now can have NIL as component-pathname,
 instead of providing a non-sensible bogus pathname
 when no sensible pathname was determined.
 Most of our pathname functions have sensible default behavior
 when provided NIL instead of a pathname as an argument.
parent 0af76dd1
......@@ -37,6 +37,7 @@ tmp/
*.~*~
test/try-reloading-dependency.asd
test/fileMissing.lisp
test/hello-world-example
build-stamp
debian/cl-asdf.debhelper.log
......
......@@ -4,17 +4,24 @@ webhome_public := "http://common-lisp.net/project/asdf/"
clnet_home := "/project/asdf/public_html/"
sourceDirectory := $(shell pwd)
#### Common Lisp implementations available for testing.
## export ASDF_TEST_LISPS to override the default list of such implementations,
## or specify a lisps= argument at the make command-line
ifdef ASDF_TEST_LISPS
lisps ?= ${ASDF_TEST_LISPS}
else
lisps ?= ccl clisp sbcl ecl ecl_bytecodes cmucl abcl scl allegro lispworks allegromodern xcl gcl
endif
## NOT SUPPORTED BY OUR AUTOMATED TESTS:
## cormancl genera lispworks-personal-edition mkcl rmcl
## Some are manually tested once in a while.
## MAJOR FAIL: gclcvs -- Compiler bug fixed upstream, but gcl fails to compile on modern Linuxen.
## grep for #+/#- features in the test/ directory to see plenty of disabled tests.
## Make sure testing remains within the confines of this filesystem tree
export ASDF_OUTPUT_TRANSLATIONS := (:output-translations (t ("${sourceDirectory}/build/fasls" :implementation)) :ignore-inherited-configuration)
export CL_SOURCE_REGISTRY := (:source-registry (:tree "${sourceDirectory}") :ignore-inherited-configuration)
## MAJOR FAIL: gclcvs -- COMPILER BUG! Upstream fixed it, but upstream fails to compile.
## NOT SUPPORTED BY OUR TESTS: cormancl genera lispworks-personal-edition mkcl rmcl. Manually tested once in a while.
lisp ?= sbcl
......@@ -37,10 +44,15 @@ XCL ?= xcl
driver_lisp := header.lisp package.lisp compatibility.lisp utility.lisp pathname.lisp stream.lisp os.lisp image.lisp run-program.lisp lisp-build.lisp configuration.lisp driver.lisp
asdf_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:
build/asdf.lisp: $(wildcard *.lisp)
mkdir -p build
cat $(driver_lisp) $(asdf_lisp) > $@
# This quickly locates such mistakes as unbalanced parentheses:
load:
rlwrap sbcl `for i in $(driver_lisp) $(asdf_lisp) ; do echo --load $$i ; done`
install: archive-copy
archive:
......@@ -56,18 +68,13 @@ archive-copy: archive build/asdf.lisp
${MAKE} push
git checkout master
### Count lines separately for asdf-driver and asdf itself:
wc:
@wc $(driver_lisp) | sort -n ; echo ; \
wc $(asdf_lisp) | sort -n ; \
echo ; \
wc $(driver_lisp) $(asdf_lisp) | tail -n 1
wc-driver:
wc $(driver_lisp)
wc-asdf:
wc $(asdf_lisp)
push:
git status
git push --tags cl.net release master
......@@ -136,12 +143,12 @@ debian-package: mrproper
: $${RELEASE:="$$(git tag -l '2.[0-9][0-9]' | tail -n 1)"} ; \
git-buildpackage --git-debian-branch=release --git-upstream-branch=$$RELEASE --git-tag --git-retag --git-ignore-branch
# Replace SBCL's ASDF with the current one. -- Not recommended now that SBCL has ASDF2.
# Replace SBCL's ASDF with the current one. -- NOT recommended now that SBCL has ASDF2.
# for casual users, just use (asdf:load-system :asdf)
replace-sbcl-asdf: build/asdf.lisp
${SBCL} --eval '(compile-file "$<" :output-file (format nil "~Aasdf/asdf.fasl" (sb-int:sbcl-homedir-pathname)))' --eval '(quit)'
# Replace CCL's ASDF with the current one. -- Not recommended now that CCL has ASDF2.
# Replace CCL's ASDF with the current one. -- NOT recommended now that CCL has ASDF2.
# for casual users, just use (asdf:load-system :asdf)
replace-ccl-asdf: build/asdf.lisp
${CCL} --eval '(progn(compile-file "$<" :output-file (compile-file-pathname (format nil "~Atools/asdf.lisp" (ccl::ccl-directory))))(quit))'
......@@ -150,6 +157,7 @@ WRONGFUL_TAGS := 1.37 1.1720 README RELEASE STABLE
# Delete wrongful tags from local repository
fix-local-git-tags:
for i in ${WRONGFUL_TAGS} ; do git tag -d $$i ; done
git tag 1.37 c7738c62 # restore the *correct* 1.37 tag.
# Delete wrongful tags from remote repository
fix-remote-git-tags:
......
......@@ -112,10 +112,17 @@ You can put together sentences using this phrase."))
"Translate output files, unless asked not to"
operation component ;; hush genera, not convinced by declare ignorable(!)
(values
(multiple-value-bind (files fixedp) (call-next-method)
(if fixedp
files
(mapcar *output-translation-function* files)))
(multiple-value-bind (pathnames fixedp) (call-next-method)
;; 1- Make sure we have absolute pathnames
(let* ((directory (pathname-directory-pathname (component-pathname component)))
(absolute-pathnames
(loop :for pathname :in pathnames
:collect (ensure-pathname
(subpathname directory pathname) :want-absolute t))))
;; 2- Translate those pathnames as required
(if fixedp
absolute-pathnames
(mapcar *output-translation-function* absolute-pathnames))))
t))
(defmethod output-files ((o operation) (c component))
(declare (ignorable o c))
......
;;; -*- mode: lisp -*-
(defpackage :asdf-driver-system (:use :cl :asdf))
(defun call-without-redefinition-warnings (thunk)
(handler-bind (#+clozure (ccl:compiler-warning #'muffle-warning))
(funcall thunk)))
(defsystem :asdf-driver
:licence "MIT"
......@@ -6,6 +11,8 @@
:long-description "Basic general-purpose utilities that is 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
((:file "header")
(:file "package")
......
......@@ -15,7 +15,7 @@
:licence "MIT"
:description "Another System Definition Facility"
:long-description "ASDF builds Common Lisp software organized into defined systems."
:version "2.26.99" ;; to be automatically updated by bin/bump-revision
:version "2.26.100" ;; to be automatically updated by bin/bump-revision
:depends-on ()
:components ((:module "build" :components ((:file "asdf"))))
:in-order-to (#+asdf2.27 (compile-op (monolithic-load-concatenated-source-op generate-asdf))))
......
......@@ -10,7 +10,6 @@
#:*asdf-verbose*
#:component-load-dependencies
#:enable-asdf-binary-locations-compatibility
#:merge-component-name-type
#:operation-forced
#:operation-on-failure
#:operation-on-warnings
......@@ -22,11 +21,12 @@
;; Old deprecated name for the same thing. Please update your software.
(component-sibling-dependencies component))
(defun* merge-component-name-type (name &key type defaults)
;; For backward-compatibility only, for people using internals.
;; Will be removed in a future release, e.g. 2.016.
(warn "Please don't use ASDF::MERGE-COMPONENT-NAME-TYPE. Use ASDF:COERCE-PATHNAME.")
(coerce-pathname name :type type :defaults defaults))
(defun* coerce-pathname (name &key type defaults)
;; For backward-compatibility only, for people using internals
;; Reported users in quicklisp: hu.dwim.asdf, asdf-utils, xcvb
;; Will be removed in a future release, e.g. 2.30.
(warn "Please don't use ASDF::COERCE-PATHNAME. Use ASDF/PATHNAME:PARSE-UNIX-NAMESTRING.")
(parse-unix-namestring name :type type :defaults defaults))
(defgeneric* operation-forced (operation)) ;; Used by swank.asd for swank-loader.
(defmethod operation-forced ((o operation)) (getf (operation-original-initargs o) :force))
......@@ -71,7 +71,7 @@ if that's whay you mean." ;;)
#+(or clisp ecl mkcl)
(when (null map-all-source-files)
(error "asdf:enable-asdf-binary-locations-compatibility doesn't support :map-all-source-files nil on CLISP, ECL and MKCL"))
(let* ((fasl-type (fasl-type))
(let* ((fasl-type (compile-file-type))
(mapped-files (if map-all-source-files *wild-file*
(make-pathname :type fasl-type :defaults *wild-file*)))
(destination-directory
......
......@@ -7,41 +7,52 @@
:asdf/component :asdf/system :asdf/find-system :asdf/find-component :asdf/operation
:asdf/action :asdf/lisp-action :asdf/plan :asdf/operate)
(:export
#:bundle-op #:bundle-op-build-args
#:bundle-op #:bundle-op-build-args #:bundle-type #:bundle-system
#:fasl-op #:load-fasl-op #:lib-op #:dll-op #:binary-op
#:monolithic-op #:monolithic-bundle-op
#:monolithic-binary-op #:monolithic-fasl-op #:monolithic-lib-op #:monolithic-dll-op
#:program-op #:compiled-file #:precompiled-system #:prebuild-system
#:program-op #:program-system
#:compiled-file #:precompiled-system #:prebuilt-system
#:operation-monolithic-p
#:user-system-p #:user-system #:trivial-system-p
#:bundle-sub-operations #:gather-components
#+ecl #:make-build
#+mkcl #:mkcl-bundle-sub-operations #+mkcl #:files-to-bundle #+mkcl #:bundle-system
#+(or ecl mkcl) #:register-pre-built-system
#:gather-actions #:gather-components
#+ecl #:make-build #+mkcl #:bundle-system
#:register-pre-built-system
#:build-args #:name-suffix #:prologue-code #:epilogue-code #:static-library
#:system-fasl))
#:component-translate-output-p #:translate-output-p
#:component-bundle-pathname #:bundle-pathname
#:component-bundle-operation #:bundle-operation
#:component-entry-point #:entry-point))
(in-package :asdf/bundle)
(defclass bundle-op (operation)
((build-args :initarg :args :initform nil :accessor bundle-op-build-args)
(name-suffix :initarg :name-suffix :initform nil)
#+ecl (type :reader bundle-op-type)
(bundle-type :reader bundle-type)
#+ecl (lisp-files :initform nil :accessor bundle-op-lisp-files)
#+mkcl (do-fasb :initarg :do-fasb :initform t :reader bundle-op-do-fasb-p)
#+mkcl (do-static-library :initarg :do-static-library :initform t :reader bundle-op-do-static-library-p)))
(defclass fasl-op (bundle-op)
((type :initform :fasl)))
;; create a single fasl for the entire library
((bundle-type :initform :fasl)))
(defclass load-fasl-op (basic-load-op) ())
(defclass load-fasl-op (basic-load-op)
;; load a single fasl for the entire library
())
(defclass lib-op (bundle-op)
((type :initform :lib)))
;; On ECL: compile the system and produce linkable .a library for it.
;; On others: just compile the system.
((bundle-type :initform #+(or ecl mkcl) :lib #-(or ecl mkcl) :no-output-file)))
(defclass dll-op (bundle-op)
((type :initform :dll)))
;; Link together all the dynamic library used by this system into a single one.
((bundle-type :initform :dll)))
(defclass binary-op (bundle-op)
;; On ECL: produce lib and fasl for the system.
;; On "normal" Lisps: produce just the fasl.
())
(defclass monolithic-op (operation) ()) ;; operation on a system and its dependencies
......@@ -51,27 +62,98 @@
(epilogue-code :accessor monolithic-op-epilogue-code)))
(defclass monolithic-binary-op (binary-op monolithic-bundle-op)
;; On ECL: produce lib and fasl for combined system and dependencies.
;; On "normal" Lisps: produce an image file from system and dependencies.
())
(defclass monolithic-fasl-op (monolithic-bundle-op fasl-op) ())
(defclass monolithic-fasl-op (monolithic-bundle-op fasl-op)
;; Create a single fasl for the system and its dependencies.
())
(defclass monolithic-lib-op (monolithic-bundle-op lib-op)
((type :initform :lib)))
;; ECL: Create a single linkable library for the system and its dependencies.
((bundle-type :initform :lib)))
(defclass monolithic-dll-op (monolithic-bundle-op dll-op)
((type :initform :dll)))
((bundle-type :initform :dll)))
(defclass program-op (monolithic-bundle-op)
((type :initform :program)))
;; All: create an executable file from the system and its dependencies
((bundle-type :initform :program)))
(defgeneric* component-bundle-pathname (component))
(defgeneric* component-translate-output-p (component))
(defgeneric* component-entry-point (component))
(defmethod component-bundle-pathname ((c component))
(declare (ignorable c))
nil)
(defmethod component-translate-output-p ((c component))
(declare (ignorable c))
t)
(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)
(bundle-operation
:initarg :bundle-operation :accessor component-bundle-operation)
(entry-point
:initform nil :initarg :entry-point :accessor component-entry-point)
(translate-output-p
:initform nil :initarg :translate-output-p :accessor component-translate-output-p)))
(defclass program-system (bundle-system)
((bundle-pathname :initarg :executable-name)
(bundle-operation :initform 'program-op)))
(defun* bundle-pathname-type (bundle-type)
(etypecase bundle-type
((eql :no-output-file) nil) ;; should we error out instead?
((or null string) bundle-type)
((eql :fasl) #-(or ecl mkcl) (compile-file-type) #+(or ecl mkcl) "fasb")
#+ecl
((member :binary :dll :lib :static-library :program :object)
(compile-file-type :type bundle-type))
((eql :binary) "image")
((eql :dll) (cond ((os-unix-p) "so") ((os-windows-p) "dll")))
((member :lib :static-library) (cond ((os-unix-p) "a") ((os-windows-p) "lib")))
((eql :program) (cond ((os-unix-p) nil) ((os-windows-p) "exe")))))
(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)
(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))
(not (component-translate-output-p c)))))))
(defmethod output-files ((o bundle-op) (c system))
(bundle-output-files o c))
#-(or ecl mkcl)
(progn
(defmethod perform ((o program-op) (c system))
(let ((output-file (output-file o c)))
(setf *image-entry-point* (ensure-function (component-entry-point c)))
(dump-image output-file :executable t)))
(defmethod perform ((o monolithic-binary-op) (c system))
(let ((output-file (output-file o c)))
(dump-image output-file))))
(defclass compiled-file (file-component)
((type :initform #-(or ecl mkcl) (fasl-type) #+(or ecl mkcl) "fasb")))
((type :initform #-(or ecl mkcl) (compile-file-type) #+(or ecl mkcl) "fasb")))
(defclass precompiled-system (system)
((fasl :initarg :fasl :reader %system-fasl)))
((bundle-pathname :initarg :fasl)))
(defclass prebuilt-system (system)
((static-library :accessor prebuilt-system-static-library :initarg :lib)))
((bundle-pathname :initarg :static-library :initarg :lib
:accessor prebuilt-system-static-library)))
;;;
;;; BUNDLE-OP
......@@ -89,10 +171,10 @@
&key (name-suffix nil name-suffix-p)
&allow-other-keys)
(declare (ignorable initargs name-suffix))
(format t "IIBO a ~S with ~S" (type-of instance) initargs)
(unless name-suffix-p
(setf (slot-value instance 'name-suffix)
(if (operation-monolithic-p instance) ".all-systems" ".system")))
(unless (typep instance 'program-op)
(if (operation-monolithic-p instance) ".all-systems" #-ecl ".system"))))
(when (typep instance 'monolithic-bundle-op)
(destructuring-bind (&rest original-initargs
&key lisp-files prologue-code epilogue-code
......@@ -102,7 +184,7 @@
(remove-keys '(lisp-files epilogue-code prologue-code) original-initargs)
(monolithic-op-prologue-code instance) prologue-code
(monolithic-op-epilogue-code instance) epilogue-code)
#-ecl (assert (null lisp-files))
#-ecl (assert (null (or lisp-files epilogue-code prologue-code)))
#+ecl (setf (bundle-op-lisp-files instance) lisp-files)))
(setf (bundle-op-build-args instance)
(remove-keys '(type monolithic name-suffix)
......@@ -114,22 +196,42 @@
(remf args :ld-flags)
args))
(defun* gather-components (operation system
&key other-systems filter-type include-self)
;; This function creates a list of actions pairing the operation with sub-components of system
;; and its dependencies if requested.
(defclass filtered-sequential-plan (sequential-plan)
((action-filter :initarg :action-filter :reader plan-action-filter)))
(defmethod action-valid-p ((plan filtered-sequential-plan) o c)
(and (funcall (plan-action-filter plan) o c) (call-next-method)))
(defun* gather-actions (operation component &key other-systems (filter t))
;; This function creates a list of sub-actions performed
;; while building the targeted action.
;; This list may be restricted to sub-components of SYSTEM
;; if GATHER-ALL = NIL (default), and it may include the system itself.
(let ((tree (traverse-sequentially (make-operation 'load-op) system
:force (if other-systems :all t)
:force-not (if other-systems nil :all))))
`(,@(loop :for (op . component) :in tree
:when (and (typep op 'load-op)
(typep component filter-type))
:collect (progn
(when (eq component system) (setf include-self nil))
`(,operation . ,component)))
,@(and include-self `((,operation . ,system))))))
;; if OTHER-SYSTEMS is NIL (default).
(traverse operation component
:plan-class 'filtered-sequential-plan
:action-filter (ensure-function filter)
:force (if other-systems :all t)
:force-not (if other-systems nil :all)))
(defun* bundlable-file-p (pathname)
(let ((type (pathname-type pathname)))
(or #+ecl (or (equal type (compile-file-type :object))
(equal type (compile-file-type :static-library)))
#+mkcl (equal type (compile-file-type :fasl-p nil))
#+(or allegro clisp clozure cmu lispworks sbcl scl xcl) (equal type (compile-file-type)))))
(defun* gather-components (system &key (goal-operation 'load-op) (keep-operation goal-operation)
(component-type t) other-systems)
(let ((goal-op (make-operation goal-operation)))
(flet ((filter (o c)
(declare (ignore o))
(or (eq c system)
(typep c component-type))))
(loop :for (o . c) :in (gather-actions goal-op system
:other-systems other-systems
:filter #'filter)
:when (typep o keep-operation)
:collect c))))
(defgeneric* trivial-system-p (component))
......@@ -140,15 +242,6 @@
(deftype user-system () '(and system (satisfies user-system-p)))
;;;
;;; BUNDLE-SUB-OPERATIONS
;;;
;;; Builds a list of pairs (operation . component)
;;; which contains all the dependencies of this bundle.
;;; This list is used by TRAVERSE and also by INPUT-FILES.
;;; The dependencies depend on the strategy, as explained below.
;;;
(defgeneric* bundle-sub-operations (operation component))
;;;
;;; First we handle monolithic bundles.
;;; These are standalone systems which contain everything,
......@@ -157,68 +250,59 @@
;;;
;;; MONOLITHIC SHARED LIBRARIES, PROGRAMS, FASL
;;;
;;; Gather the static libraries of all components.
;;;
(defmethod bundle-sub-operations ((o monolithic-bundle-op) c)
(gather-components (find-operation o 'lib-op) c :filter-type 'user-system :include-self t))
;;;
;;; STATIC LIBRARIES
;;;
;;; Gather the object files of all components
;;; and, if monolithic, also of systems and subsystems.
;;;
(defmethod bundle-sub-operations ((o lib-op) c)
(gather-components (find-operation o 'compile-op) c
:other-systems (operation-monolithic-p o)
:filter-type '(not system)))
;;;
;;; SHARED LIBRARIES
;;;
;;; Gather the dynamically linked libraries of all components.
;;; They will be linked into this new shared library,
;;; together with the static library of this module.
;;;
(defmethod bundle-sub-operations ((o dll-op) c)
`((,(find-operation o 'lib-op) . ,c)))
;;;
;;; FASL FILES
;;;
;;; Gather the statically linked library of this component.
;;;
(defmethod bundle-sub-operations ((o fasl-op) c)
`((,(find-operation o 'lib-op) . ,c)))
(defmethod component-depends-on ((o monolithic-lib-op) (c system))
(declare (ignorable o))
`((lib-op ,@(gather-components c :other-systems t :component-type 'system
:goal-operation 'load-op
:keep-operation 'load-op))))
#-mkcl
(defmethod component-depends-on ((o bundle-op) (c system))
`(,@(loop :for (op . dep) :in (bundle-sub-operations o c)
:when (user-system-p dep) :collect (list op dep))
,@(call-next-method)))
(defmethod component-depends-on ((o monolithic-fasl-op) (c system))
(declare (ignorable o))
`((fasl-op ,@(gather-components c :other-systems t :component-type 'system
:goal-operation 'load-fasl-op
:keep-operation 'load-fasl-op))))
(defmethod component-depends-on ((o program-op) (c system))
(declare (ignorable o))
`((#+(or ecl mkcl) monolithic-lib-op #-(or ecl mkcl) load-op ,c)))
(defmethod component-depends-on ((o binary-op) (c system))
(declare (ignorable o))
`((fasl-op ,c)
(lib-op ,c)))
(defmethod component-depends-on ((o monolithic-binary-op) (c system))
`((,(find-operation o 'monolithic-fasl-op) ,c)
(,(find-operation o 'monolithic-lib-op) ,c)))
(defmethod component-depends-on ((o lib-op) (c system))
(declare (ignorable o))
`((compile-op ,c) ,@(call-next-method)))
`((compile-op ,@(gather-components c :other-systems nil :component-type '(not system)
:goal-operation 'load-op
:keep-operation 'load-op))))
(defmethod component-depends-on ((o fasl-op) (c system))
(declare (ignorable o))
#+ecl `((lib-op ,c))
#-ecl
(component-depends-on (find-operation o 'lib-op) c))
(defmethod component-depends-on ((o dll-op) c)
(component-depends-on (find-operation o 'lib-op) c))
(defmethod component-depends-on ((o bundle-op) c)
(declare (ignorable o c))
nil)
#-mkcl
(defmethod input-files ((o bundle-op) (c system))
(loop :for (sub-op . sub-c) :in (bundle-sub-operations o c)
:nconc (output-files sub-op sub-c)))
(while-collecting (collect)
(visit-dependencies
() o c #'(lambda (sub-o sub-c)
(loop :for f :in (output-files sub-o sub-c)
:when (bundlable-file-p f) :do (collect f))))))
#-mkcl
(defmethod output-files ((o bundle-op) (c system))
(list (compile-file-pathname
(make-pathname
:name (strcat (component-name c) (slot-value o 'name-suffix)
#|"-" (string-downcase (implementation-type))|#)
:type "lisp"
:defaults (system-source-directory c))
#+ecl :type #+ecl (bundle-op-type o))))
(defun* select-operation (monolithic type)
(defun* select-bundle-operation (type &optional monolithic)
(ecase type
((:binary)
(if monolithic 'monolithic-binary-op 'binary-op))
......@@ -234,7 +318,7 @@
(defun* make-build (system &rest args &key (monolithic nil) (type :fasl)
(move-here nil move-here-p)
&allow-other-keys)
(let* ((operation-name (select-operation monolithic type))
(let* ((operation-name (select-bundle-operation type monolithic))
(move-here-path (if (and move-here
(typep move-here '(or pathname string)))
(pathname move-here)
......@@ -263,8 +347,8 @@
(defmethod component-depends-on ((o load-fasl-op) (c system))
(declare (ignorable o))
`((load-fasl-op ,@(loop :for dep :in (component-sibling-dependencies c)
:collect (resolve-dependency-spec c dep)))
`((,o ,@(loop :for dep :in (component-sibling-dependencies c)
:collect (resolve-dependency-spec c dep)))
(,(if (user-system-p c) 'fasl-op 'load-op) ,c)
,@(call-next-method)))
......@@ -280,7 +364,7 @@
(perform-lisp-load-fasl o c))
(defmethod mark-operation-done :after ((o load-fasl-op) (c system))
(mark-operation-done (find-operation o 'load-op) c)) ; need we recurse on gather-components?
(mark-operation-done (find-operation o 'load-op) c))
;;;
;;; PRECOMPILED FILES
......@@ -315,68 +399,36 @@
(declare (ignorable s))
t)
(defmethod output-files ((o lib-op) (c prebuilt-system))
(declare (ignorable o))
(values (list (prebuilt-system-static-library c))
t)) ; Advertise that we do not want this path renamed by asdf-output-translations
(defmethod perform ((o lib-op) (c prebuilt-system))
(first (output-files o c)))
(defmethod component-depends-on ((o lib-op) (c prebuilt-system))
(declare (ignorable o c))
nil)
(defmethod bundle-sub-operations ((o lib-op) (c prebuilt-system))
(defmethod component-depends-on ((o lib-op) (c prebuilt-system))
(declare (ignorable o c))
nil)
(defmethod bundle-sub-operations ((o monolithic-lib-op) (c prebuilt-system))
(defmethod component-depends-on ((o monolithic-lib-op) (c prebuilt-system))
(declare (ignorable o))
(error "Prebuilt system ~S shipped with ECL can not be used in a monolithic library operation." c))
(defmethod bundle-sub-operations ((o monolithic-bundle-op) (c prebuilt-system))
(declare (ignorable o c))
nil)
;;;
;;; PREBUILT SYSTEM CREATOR
;;;
(defun* binary-op-dependencies (o s)
(multiple-value-bind (lib-op fasl-op)
(if (operation-monolithic-p o)
(values 'monolithic-lib-op 'monolithic-fasl-op)
(values 'lib-op 'fasl-op))