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

Merge branch 'upstream'

parents 4149709d ae82047e

.gitignore

+7 −9
Original line number Diff line number Diff line 
# really this is private to my build process

make/

common-lisp.net

.vcs

init-lisp.lisp

website/changelog.xml

push

resbcl

reccl

reecl

regcl



# Temporary files from documentation build

doc/asdf/
@@ -26,17 +23,18 @@ doc/asdf.tp 
doc/asdf.vr

doc/asdf.vrs



# We build these at various stages in the make process

# We build these at various stages in the build and test process

LICENSE

website/output/

tmp/

lift-local.config

*.dribble

*.fasl

*.dfsl

*.cfsl

*.fas

*.lib

*.o

*.[oahcisS]

*.*fsl

*.bak

*.data

test/try-reloading-dependency.asd

test/fileMissing.lisp

GNUmakefile

+11 −11
Original line number Diff line number Diff line
@@ -7,11 +7,12 @@ clnet_home := "/project/asdf/public_html/" 


sourceDirectory := $(shell pwd)



lisps = allegro allegromodern ccl clisp sbcl

lisps ?= allegro ccl clisp ecl sbcl

## not tested by me: abcl allegromodern cmucl lisworks

## FAIL: gclcvs

## maybe supported by asdf, not supported yet by our tests: cormancl mcl scl



ifndef lisp

lisp := sbcl

endif

lisp ?= sbcl



# website, tag, install
@@ -26,11 +27,12 @@ archive: FORCE 
	bin/build-tarball.sh



archive-copy: archive

	git checkout release

	bin/rsync-cp.sh tmp/asdf*.tar.gz $(webhome_private)/archives

	bin/link-tarball.sh $(clnet_home) $(user)

	bin/rsync-cp.sh tmp/asdf.lisp $(webhome_private)

	git push cl.net

	git push --tags cl.net

	git push cl.net release

	git push --tags cl.net release



website:

	make -C doc website
@@ -54,13 +56,11 @@ clean: FORCE 
	make -C doc clean



test: FORCE

	@cd test; make clean;./run-tests.sh $(lisp) $(test-regex)

	@cd test; make clean;./run-tests.sh ${lisp} ${test-glob}



test-all: FORCE

	@for lisp in $(lisps); do \

		make test lisp=$$lisp; \

	@for lisp in ${lisps} ; do \

		make test lisp=$$lisp || exit 1 ; \

	done

	sbcl --userinit /dev/null --sysinit /dev/null --load bin/make-helper.lisp \

		--eval "(write-test-web-pages)" --eval "(quit)"



FORCE:

README

+8 −8
Original line number Diff line number Diff line 
ASDF: another system definition facility

========================================



If you want to use ASDF to load systems, see the getting

started guide at:

If you want to use ASDF, read our manual:



    http://common-lisp.net/project/asdf/getting-started.html

    http://common-lisp.net/project/asdf/asdf.html



If you want to define your own systems, see the manual at:

The first few sections, Loading ASDF, Configuring ASDF and Using ASDF,

will get you started as a simple user.



    http://common-lisp.net/project/asdf/manual.html

If you want to define your own systems, further read the section

Defining systems with defsystem.



More information and additional links can be found on ASDF's

home page at:



    http://common-lisp.net/project/asdf

    http://common-lisp.net/project/asdf/







last updated Saturday; July 18, 2009, 10:20 AM EDT
 
last updated Wednesday; May 5, 2010

asdf-ecl.lisp

+112 −29
Original line number Diff line number Diff line
@@ -5,14 +5,14 @@ 
;;;   License as published by the Free Software Foundation; either

;;;   version 2 of the License, or (at your option) any later version.

;;;

;;;   See file '../../Copyright' for full details.

;;;   See file 'ecl/Copyright' for full details.

;;;

;;; ECL SPECIFIC OPERATIONS FOR ASDF

;;;

#+xcvb (module (:depends-on ("asdf")))



(in-package :asdf)

(require 'cmp)

(require :cmp)



;;;

;;; COMPILE-OP / LOAD-OP
@@ -52,12 +52,12 @@ 
   (prologue-code :accessor monolithic-op-prologue-code)

   (epilogue-code :accessor monolithic-op-epilogue-code)))



(defclass monolithic-fasl-op (fasl-op monolithic-bundle-op) ())

(defclass monolithic-fasl-op (monolithic-bundle-op fasl-op) ())



(defclass monolithic-lib-op (lib-op monolithic-bundle-op)

(defclass monolithic-lib-op (monolithic-bundle-op lib-op)

  ((type :initform :lib)))



(defclass monolithic-dll-op (dll-op monolithic-bundle-op)

(defclass monolithic-dll-op (monolithic-bundle-op dll-op)

  ((type :initform :dll)))



(defclass program-op (monolithic-bundle-op)
@@ -66,6 +66,7 @@ 
(defmethod initialize-instance :after ((instance bundle-op) &rest initargs

                                       &key (name-suffix nil name-suffix-p)

                                       &allow-other-keys)

  (declare (ignorable initargs name-suffix))

  (unless name-suffix-p

    (setf (slot-value instance 'name-suffix)

          (if (bundle-op-monolithic-p instance) "-mono" "")))
@@ -84,6 +85,7 @@ 
(defvar *force-load-p* nil)



(defmethod operation-done-p :around ((operation load-op) c)

  (declare (ignorable operation c))

  (if *force-load-p* nil (call-next-method)))



(defun gather-components (op-type system &key filter-system filter-type include-self)
@@ -122,6 +124,7 @@ 
;;; Gather the static libraries of all components.

;;;

(defmethod bundle-sub-operations ((o monolithic-bundle-op) c)

  (declare (ignorable o))

  (gather-components 'lib-op c :filter-type 'system :include-self t))

;;;

;;; STATIC LIBRARIES
@@ -141,6 +144,7 @@ 
;;; with the static library of this module.

;;;

(defmethod bundle-sub-operations ((o dll-op) c)

  (declare (ignorable o))

  (list (cons (make-instance 'lib-op) c)))

;;;

;;; FASL FILES
@@ -148,6 +152,7 @@ 
;;; Gather the statically linked library of this component.

;;;

(defmethod bundle-sub-operations ((o fasl-op) c)

  (declare (ignorable o))

  (list (cons (make-instance 'lib-op) c)))



(defmethod component-depends-on ((o bundle-op) (c system))
@@ -157,9 +162,11 @@ 
                   (component-name dep))))



(defmethod component-depends-on ((o lib-op) (c system))

  (declare (ignorable o))

  (list (list 'compile-op (component-name c))))



(defmethod component-depends-on ((o bundle-op) c)

  (declare (ignorable o c))

  nil)



(defmethod input-files ((o bundle-op) (c system))
@@ -173,17 +180,21 @@ 
                            (component-relative-pathname c)))))



(defmethod output-files ((o fasl-op) (c system))

  (declare (ignorable o c))

  (loop for file in (call-next-method)

     collect (make-pathname :type "fasb" :defaults file)))



(defmethod perform ((o bundle-op) (c t))

  (declare (ignorable o c))

  t)



(defmethod operation-done-p ((o bundle-op) (c source-file))

  (declare (ignorable o c))

  t)



(defmethod perform ((o bundle-op) (c system))

  (let* ((object-files (remove "fas" (input-files o c) :key #'pathname-type :test #'string=))

  (let* ((object-files (remove "fas" (input-files o c)

                               :key #'pathname-type :test #'string=))

         (output (output-files o c)))

    (ensure-directories-exist (first output))

    (apply #'c::builder (bundle-op-type o) (first output) :lisp-files object-files
@@ -197,6 +208,8 @@ 


(defun select-operation (monolithic type)

  (ecase type

    ((:binary)

     (if monolithic 'monolithic-binary-op 'binary-op))

    ((:dll :shared-library)

     (if monolithic 'monolithic-dll-op 'dll-op))

    ((:lib :static-library)
@@ -206,37 +219,31 @@ 
    ((:program)

     'program-op)))





(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))

         (move-here-path (if (and move-here

                                  (typep move-here '(or pathname string)))

                             (pathname move-here)

                             (merge-pathnames "./asdf-output/")))

         (operation (apply #'operate operation-name

                           system

                           (remove-keys '(monolithic type move-here) args)))

         (system (find-system system))

         (files (and system (output-files operation system))))

    (print files)

    (print move-here)

    (if (or move-here

            (and (null move-here-p)

                 (member operation-name '(:program))))

        (loop for path in files

           for filename = (namestring (truename path))

           for new-path = (make-pathname :name (pathname-name path)

                                         :type (pathname-type path)

                                         :defaults *default-pathname-defaults*)

           for new-filename = (namestring new-path)

           for command =

             #+windows

             (format nil "move ~S ~S" filename new-filename)

             #-windows

             (format nil "mv ~S ~S" filename new-filename)

           do (unless (equalp new-filename filename)

                (when (plusp (si::system (print command)))

                  (error "Unable to move file~&  ~S~&to new location~&  ~S"

                         path new-path)))

           collect new-path)

    (if (or move-here (and (null move-here-p)

                           (member operation-name '(:program :binary))))

        (loop with dest-path = (truename (ensure-directories-exist move-here-path))

           for f in files

           for new-f = (make-pathname :name (pathname-name f)

                                      :type (pathname-type f)

                                      :defaults dest-path)

           do (progn

                (when (probe-file new-f)

                  (delete-file new-f))

                (rename-file f new-f))

           collect new-f)

        files)))



;;;
@@ -251,16 +258,19 @@ 
  (every #'(lambda (c) (typep c 'compiled-file)) (module-components c)))



(defmethod component-depends-on ((o load-fasl-op) (c system))

  (declare (ignorable o))

  (unless (trivial-system-p c)

    (subst 'load-fasl-op 'load-op

           (subst 'fasl-op 'compile-op

                  (component-depends-on (make-instance 'load-op) c)))))



(defmethod input-files ((o load-fasl-op) (c system))

  (declare (ignore o))

  (unless (trivial-system-p c)

    (output-files (make-instance 'fasl-op) c)))



(defmethod perform ((o load-fasl-op) (c t))

  (declare (ignore o c))

  nil)



(defmethod perform ((o load-fasl-op) (c system))
@@ -287,14 +297,19 @@ 
    :type "fas")))



(defmethod output-files (o (c compiled-file))

  (declare (ignore o c))

  nil)

(defmethod input-files (o (c compiled-file))

  (declare (ignore o c))

  nil)

(defmethod perform ((o load-op) (c compiled-file))

  (declare (ignore o))

  (load (component-pathname c)))

(defmethod perform ((o load-fasl-op) (c compiled-file))

  (declare (ignore o))

  (load (component-pathname c)))

(defmethod perform (o (c compiled-file))

  (declare (ignore o c))

  nil)



;;;
@@ -304,6 +319,7 @@ 
  ((static-library :accessor prebuilt-system-static-library :initarg :lib)))



(defmethod output-files ((o lib-op) (c prebuilt-system))

  (declare (ignore o))

  (values (list (compile-file-pathname (prebuilt-system-static-library c)

                                       :type :lib))

          t ; Advertise that we do not want this path renamed
@@ -313,22 +329,89 @@ 
  (car (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))

  (declare (ignorable o c))

  nil)



(defmethod bundle-sub-operations ((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

;;;



(defclass binary-op (bundle-op)

  ())



(defclass monolithic-binary-op (binary-op monolithic-bundle-op)

  ())



(defun binary-op-dependencies (o s)

  (let (lib-op fasl-op)

    (if (bundle-op-monolithic-p o)

        (setf lib-op 'monolithic-lib-op

              fasl-op 'monolithic-fasl-op)

        (setf lib-op 'lib-op

              fasl-op 'fasl-op))

    (list (list (make-instance lib-op :args (bundle-op-build-args o))

                s)

          (list (make-instance fasl-op :args (bundle-op-build-args o))

                s))))



(defmethod component-depends-on ((o binary-op) (s system))

  (loop for dep in (binary-op-dependencies o s)

     append (apply #'component-depends-on dep)))



(defmethod input-files ((o binary-op) (s system))

  (loop for dep in (binary-op-dependencies o s)

     append (apply #'input-files dep)))



(defmethod output-files ((o binary-op) (s system))

  (list* (merge-pathnames* (make-pathname :name (component-name s)

                                          :type "asd")

                           (component-relative-pathname s))

         (loop for dep in (binary-op-dependencies o s)

            append (apply #'output-files dep))))



(defmethod perform ((o binary-op) (s system))

  (let* ((dependencies (binary-op-dependencies o s))

         (library (first (apply #'output-files (first dependencies))))

         (fasl (first (apply #'output-files (second dependencies))))

         (filename (first (output-files o s)))

         (name (component-name s))

         (name-keyword (intern (string name) (find-package :keyword))))

    (loop for dep in dependencies

       do (apply #'perform dep))

    (with-open-file (s filename :direction :output :if-exists :supersede

                       :if-does-not-exist :create)

      (format s ";;; Prebuilt ASDF definition for system ~A" name)

      (format s ";;; Built for ~A ~A on a ~A/~A ~A"

              (lisp-implementation-type)

              (lisp-implementation-version)

              (software-type)

              (machine-type)

              (software-version))

      (let ((*package* (find-package :keyword)))

        (pprint `(defsystem ,name-keyword

                     :class asdf::prebuilt-system

                     :components ((:compiled-file ,(pathname-name fasl)))

                     :lib ,(make-pathname :name (pathname-name library)

                                          :type (pathname-type library)))

                s)))))



;;;

;;; Final integration steps

;;;



(export '(make-build load-fasl-op))

(export '(make-build load-fasl-op prebuilt-system))

(push '("fasb" . si::load-binary) si::*load-hooks*)



(require 'cmp)

asdf-install.lisp

deleted100644 → 0
+0 −299

File deleted.

Preview size limit exceeded, changes collapsed.