Merge branch 'master' of ssh://common-lisp.net/project/asdf/public_html/asdf

test-all-no-stop:

	-make doc ; for l in ${lisps} ; do make t l=$$l ; make u l=$$l ; done ; true

extract: extract-all-tagged-asdf

extract-all-tagged-asdf: build/asdf.lisp

	./test/run-tests.sh -H

;;;; Convenience methods

(with-upgradability ()

  (defmacro define-convenience-action-methods

      (function (operation component &optional keyp)

       &key if-no-operation if-no-component operation-initargs)

      (function formals &key if-no-operation if-no-component operation-initargs)

    (let* ((rest (gensym "REST"))

           (found (gensym "FOUND"))

           (keyp (equal (last formals) '(&key)))

           (formals-no-key (if keyp (butlast formals) formals))

           (len (length formals-no-key))

           (operation 'operation)

           (component 'component)

           (opix (position operation formals))

           (coix (position component formals))

           (prefix (subseq formals 0 opix))

           (suffix (subseq formals (1+ coix) len))

           (more-args (when keyp `(&rest ,rest &key &allow-other-keys))))

      (assert (and (integerp opix) (integerp coix) (= coix (1+ opix))))

      (flet ((next-method (o c)

               (if keyp

                   `(apply ',function ,o ,c ,rest)

                   `(,function ,o ,c))))

                   `(apply ',function ,@prefix ,o ,c ,@suffix ,rest)

                   `(,function ,@prefix ,o ,c ,@suffix))))

        `(progn

           (defmethod ,function ((,operation symbol) ,component ,@more-args)

           (defmethod ,function (,@prefix (,operation symbol) component ,@suffix ,@more-args)

             (if ,operation

                 ,(next-method

                   (if operation-initargs ;backward-compatibility with ASDF1's operate. Yuck.

                       `(make-operation ,operation))

                   `(or (find-component () ,component) ,if-no-component))

                 ,if-no-operation))

           (defmethod ,function ((,operation operation) ,component ,@more-args)

           (defmethod ,function (,@prefix (,operation operation) ,component ,@suffix ,@more-args)

             (if (typep ,component 'component)

                 (error "No defined method for ~S on ~/asdf-action:format-action/"

                        ',function (cons ,operation ,component))

                 (let ((,found (find-component () ,component)))

                   (if ,found

                 (if-let (,found (find-component () ,component))

                    ,(next-method operation found)

                       ,if-no-component)))))))))

                    ,if-no-component))))))))

;;;; self-description

  :licence "MIT"

  :description "Another System Definition Facility"

  :long-description "ASDF builds Common Lisp software organized into defined systems."

  :version "3.0.1.3" ;; to be automatically updated by make bump-version

  :version "3.0.1.7" ;; to be automatically updated by make bump-version

  :depends-on ()

  #+asdf3 :encoding #+asdf3 :utf-8

  ;; For most purposes, asdf itself specially counts as a builtin system.

  (:recycle :asdf/backward-interface :asdf)

  (:use :uiop/common-lisp :uiop :asdf/upgrade

   :asdf/component :asdf/system :asdf/find-system :asdf/operation :asdf/action

   :asdf/lisp-action :asdf/operate :asdf/output-translations)

   :asdf/lisp-action :asdf/plan :asdf/operate :asdf/output-translations)

  (:export

   #:*asdf-verbose*

   #:operation-error #:compile-error #:compile-failed #:compile-warned

   #:error-component #:error-operation

   #:error-component #:error-operation #:traverse

   #:component-load-dependencies

   #:enable-asdf-binary-locations-compatibility

   #:operation-forced

for a mostly compatible replacement that we're supporting,

or even ASDF:SYSTEM-SOURCE-DIRECTORY or ASDF:SYSTEM-RELATIVE-PATHNAME

if that's whay you mean." ;;)

    (system-source-file x)))

    (system-source-file x))

  (defgeneric* (traverse) (operation component &key &allow-other-keys)

    (:documentation

     "Generate and return a plan for performing OPERATION on COMPONENT.

The plan returned is a list of dotted-pairs. Each pair is the CONS

of ASDF operation object and a COMPONENT object. The pairs will be

processed in order by OPERATE."))

  (define-convenience-action-methods traverse (operation component &key))

  (defmethod traverse ((o operation) (c component) &rest keys &key plan-class &allow-other-keys)

    (plan-actions (apply 'make-plan plan-class o c keys))))

;;;; ASDF-Binary-Locations compatibility

;;; -*- mode: Common-Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp -*-

;;; This is ASDF 3.0.1.3: Another System Definition Facility.

;;; This is ASDF 3.0.1.7: Another System Definition Facility.

;;;

;;; Feedback, bug reports, and patches are all welcome:

;;; please mail to <asdf-devel@common-lisp.net>.