operate.lisp 7.66 KB
Newer Older
1 2
;;;; -------------------------------------------------------------------------
;;;; Invoking Operations
3 4 5

(asdf/package:define-package :asdf/operate
  (:recycle :asdf/operate :asdf)
6
  (:use :asdf/common-lisp :asdf/driver :asdf/upgrade
7 8
   :asdf/component :asdf/system :asdf/operation :asdf/action
   :asdf/find-system :asdf/find-component :asdf/lisp-action :asdf/plan)
9
  (:export
10 11
   #:operate #:oos
   #:*systems-being-operated* #:*asdf-upgrade-already-attempted*
12
   #:build-system
13 14 15 16 17 18
   #:load-system #:load-systems #:compile-system #:test-system #:require-system
   #:*load-system-operation* #:module-provide-asdf
   #:component-loaded-p #:already-loaded-systems
   #:upgrade-asdf #:cleanup-upgraded-asdf #:*post-upgrade-hook*))
(in-package :asdf/operate)

19
(defgeneric* (operate) (operation component &key &allow-other-keys))
20 21
(define-convenience-action-methods
    operate (operation component &key)
22
    :operation-initargs t ;; backward-compatibility with ASDF1. Yuck.
23
    :if-no-component (error 'missing-component :requires component))
24 25 26 27

(defvar *systems-being-operated* nil
  "A boolean indicating that some systems are being operated on")

28
(defmethod operate :around (operation component
29 30 31
                            &key verbose
                              (on-warnings *compile-file-warnings-behaviour*)
                              (on-failure *compile-file-failure-behaviour*) &allow-other-keys)
32
  (declare (ignorable operation component))
33
  ;; Setup proper bindings around any operate call.
34 35 36 37 38 39 40
  (with-system-definitions ()
    (let* ((*asdf-verbose* verbose)
           (*verbose-out* (if verbose *standard-output* (make-broadcast-stream)))
           (*compile-file-warnings-behaviour* on-warnings)
           (*compile-file-failure-behaviour* on-failure))
      (call-next-method))))

41 42
(defmethod operate ((operation operation) (component component)
                    &rest args &key version &allow-other-keys)
43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
  "Operate does three things:

1. It creates an instance of OPERATION-CLASS using any keyword parameters as initargs.
2. It finds the  asdf-system specified by SYSTEM (possibly loading it from disk).
3. It then calls TRAVERSE with the operation and system as arguments

The traverse operation is wrapped in WITH-COMPILATION-UNIT and error handling code.
If a VERSION argument is supplied, then operate also ensures that the system found
satisfies it using the VERSION-SATISFIES method.

Note that dependencies may cause the operation to invoke other operations on the system
or its components: the new operations will be created with the same initargs as the original one.

The :FORCE or :FORCE-NOT argument to OPERATE can be:
  T to force the inside of the specified system to be rebuilt (resp. not),
    without recursively forcing the other systems we depend on.
  :ALL to force all systems including other systems we depend on to be rebuilt (resp. not).
  (SYSTEM1 SYSTEM2 ... SYSTEMN) to force systems named in a given list
:FORCE has precedence over :FORCE-NOT; builtin systems cannot be forced."
62
  (let* (;; I'd like to remove-plist-keys :force :force-not :verbose,
63
         ;; but swank.asd relies on :force (!).
64
         (systems-being-operated *systems-being-operated*)
65 66
         (*systems-being-operated* (or systems-being-operated (make-hash-table :test 'equal)))
         (system (component-system component)))
67
    (setf (gethash (coerce-name system) *systems-being-operated*) system)
68 69
    (unless (version-satisfies component version)
      (error 'missing-component-of-version :requires component :version version))
70
    ;; Before we operate on any system, make sure ASDF is up-to-date,
71 72 73 74 75 76 77 78 79 80 81 82 83 84
    ;; for if an upgrade is ever attempted at any later time, there may be BIG trouble.
    (unless systems-being-operated
      (let ((operation-name (reify-symbol (type-of operation)))
            (component-path (component-find-path component)))
        (when (upgrade-asdf)
          ;; If we were upgraded, restart OPERATE the hardest of ways, for
          ;; its function may have been redefined, its symbol uninterned, its package deleted.
          (return-from operate
            (apply (find-symbol* 'operate :asdf)
                   (unreify-symbol operation-name)
                   component-path args)))))
    (let ((plan (apply 'traverse operation system args)))
      (perform-plan plan)
      (values operation plan))))
85

86 87
(defun* oos (operation component &rest args &key &allow-other-keys)
  (apply 'operate operation component args))
88 89 90 91 92 93 94 95 96 97 98

(setf (documentation 'oos 'function)
      (format nil "Short for _operate on system_ and an alias for the OPERATE function.~%~%~a"
              (documentation 'operate 'function)))


;;;; Common operations

(defvar *load-system-operation* 'load-op
  "Operation used by ASDF:LOAD-SYSTEM. By default, ASDF:LOAD-OP.
You may override it with e.g. ASDF:LOAD-FASL-OP from asdf-bundle,
99 100 101 102
or ASDF:LOAD-SOURCE-OP if your fasl loading is somehow broken.

This may change in the future as we will implement component-based strategy
for how to load or compile stuff")
103

104 105 106 107 108
(defun* build-system (system &rest keys)
  "Shorthand for `(operate 'asdf:build-op system)`."
  (apply 'operate 'build-op system keys)
  t)

109 110 111 112 113 114 115
(defun* load-system (system &rest keys &key force force-not verbose version &allow-other-keys)
  "Shorthand for `(operate 'asdf:load-op system)`. See OPERATE for details."
  (declare (ignore force force-not verbose version))
  (apply 'operate *load-system-operation* system keys)
  t)

(defun* load-systems (&rest systems)
116
  "Loading multiple systems at once."
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
  (map () 'load-system systems))

(defun* compile-system (system &rest args &key force force-not verbose version &allow-other-keys)
  "Shorthand for `(asdf:operate 'asdf:compile-op system)`. See OPERATE for details."
  (declare (ignore force force-not verbose version))
  (apply 'operate 'compile-op system args)
  t)

(defun* test-system (system &rest args &key force force-not verbose version &allow-other-keys)
  "Shorthand for `(asdf:operate 'asdf:test-op system)`. See OPERATE for details."
  (declare (ignore force force-not verbose version))
  (apply 'operate 'test-op system args)
  t)


132
;;;; Define require-system, to be hooked into CL:REQUIRE when possible,
133 134 135 136 137 138 139 140 141 142
;; i.e. for ABCL, CLISP, ClozureCL, CMUCL, ECL, MKCL and SBCL

(defun* component-loaded-p (c)
  (action-already-done-p nil (make-instance 'load-op) (find-component c ())))

(defun* already-loaded-systems ()
  (remove-if-not 'component-loaded-p (registered-systems)))

(defun* require-system (s &rest keys &key &allow-other-keys)
  (apply 'load-system s :force-not (already-loaded-systems) keys))
143

144 145 146 147 148 149 150 151 152 153 154 155 156
(defun* module-provide-asdf (name)
  (handler-bind
      ((style-warning #'muffle-warning)
       (missing-component (constantly nil))
       (error #'(lambda (e)
                  (format *error-output* (compatfmt "~@<ASDF could not load ~(~A~) because ~A.~@:>~%")
                          name e))))
    (let ((*verbose-out* (make-broadcast-stream))
          (system (find-system (string-downcase name) nil)))
      (when system
        (require-system system :verbose nil)
        t))))

157 158 159 160 161

;;;; Some upgrade magic

(defun* reset-asdf-systems ()
  (let ((asdf (find-system :asdf)))
162
    (setf (component-version asdf) (asdf-version))
163 164 165 166 167 168 169 170 171 172 173 174 175 176
    ;; Invalidate all systems but ASDF itself.
    (setf *defined-systems* (make-defined-systems-table))
    (register-system asdf)
    (load-system asdf))) ;; re-load ourselves the right way

(defun* restart-upgraded-asdf ()
  ;; If we're in the middle of something, restart it.
  (when *systems-being-defined*
    (let ((l (loop :for name :being :the :hash-keys :of *systems-being-defined* :collect name)))
      (clrhash *systems-being-defined*)
      (dolist (s l) (find-system s nil)))))

(pushnew 'reset-asdf-systems *post-upgrade-cleanup-hook*)
(pushnew 'restart-upgraded-asdf *post-upgrade-restart-hook*)