lisp-action.lisp 11.8 KB
Newer Older
1 2 3
;;;; -------------------------------------------------------------------------
;;;; Actions to build Common Lisp software

4
(uiop/package:define-package :asdf/lisp-action
5
  (:recycle :asdf/lisp-action :asdf)
6
  (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/session
7
   :asdf/component :asdf/system :asdf/operation :asdf/action)
8
  (:export
9
   #:try-recompiling
10
   #:cl-source-file #:cl-source-file.cl #:cl-source-file.lsp
11
   #:basic-load-op #:basic-compile-op
12 13
   #:load-op #:prepare-op #:compile-op #:test-op #:load-source-op #:prepare-source-op
   #:call-with-around-compile-hook
14
   #:perform-lisp-compilation #:perform-lisp-load-fasl #:perform-lisp-load-source
15
   #:lisp-compilation-output-files))
16 17 18 19
(in-package :asdf/lisp-action)


;;;; Component classes
20 21
(with-upgradability ()
  (defclass cl-source-file (source-file)
22
    ((type :initform "lisp"))
Robert Goldman's avatar
Robert Goldman committed
23
    (:documentation "Component class for a Common Lisp source file (using type \"lisp\")"))
24
  (defclass cl-source-file.cl (cl-source-file)
25
    ((type :initform "cl"))
Robert Goldman's avatar
Robert Goldman committed
26
    (:documentation "Component class for a Common Lisp source file using type \"cl\""))
27
  (defclass cl-source-file.lsp (cl-source-file)
28
    ((type :initform "lsp"))
Robert Goldman's avatar
Robert Goldman committed
29
    (:documentation "Component class for a Common Lisp source file using type \"lsp\"")))
30 31 32


;;;; Operation classes
33
(with-upgradability ()
34
  (defclass basic-load-op (operation) ()
Robert Goldman's avatar
Robert Goldman committed
35
    (:documentation "Base class for operations that apply the load-time effects of a file"))
36
  (defclass basic-compile-op (operation) ()
Robert Goldman's avatar
Robert Goldman committed
37
    (:documentation "Base class for operations that apply the compile-time effects of a file")))
38

39 40

;;; Our default operations: loading into the current lisp image
41
(with-upgradability ()
42
  (defclass prepare-op (upward-operation sideway-operation)
43
    ((sideway-operation :initform 'load-op :allocation :class))
44
    (:documentation "Load the dependencies for the COMPILE-OP or LOAD-OP of a given COMPONENT."))
45
  (defclass load-op (basic-load-op downward-operation selfward-operation)
46
    ;; NB: even though compile-op depends on prepare-op it is not needed-in-image-p,
47
    ;; so we need to directly depend on prepare-op for its side-effects in the current image.
48 49
    ((selfward-operation :initform '(prepare-op compile-op) :allocation :class))
    (:documentation "Operation for loading the compiled FASL for a Lisp file"))
50
  (defclass compile-op (basic-compile-op downward-operation selfward-operation)
51 52 53
    ((selfward-operation :initform 'prepare-op :allocation :class))
    (:documentation "Operation for compiling a Lisp file to a FASL"))

54

55
  (defclass prepare-source-op (upward-operation sideway-operation)
56 57
    ((sideway-operation :initform 'load-source-op :allocation :class))
    (:documentation "Operation for loading the dependencies of a Lisp file as source."))
58
  (defclass load-source-op (basic-load-op downward-operation selfward-operation)
59 60
    ((selfward-operation :initform 'prepare-source-op :allocation :class))
    (:documentation "Operation for loading a Lisp file as source."))
61

62
  (defclass test-op (selfward-operation)
63 64 65
    ((selfward-operation :initform 'load-op :allocation :class))
    (:documentation "Operation for running the tests for system.
If the tests fail, an error will be signaled.")))
66 67


68
;;;; Methods for prepare-op, compile-op and load-op
69 70

;;; prepare-op
71 72 73 74 75 76 77
(with-upgradability ()
  (defmethod action-description ((o prepare-op) (c component))
    (format nil (compatfmt "~@<loading dependencies of ~3i~_~A~@:>") c))
  (defmethod perform ((o prepare-op) (c component))
    nil)
  (defmethod input-files ((o prepare-op) (s system))
    (if-let (it (system-source-file s)) (list it))))
78 79

;;; compile-op
80 81 82 83 84
(with-upgradability ()
  (defmethod action-description ((o compile-op) (c component))
    (format nil (compatfmt "~@<compiling ~3i~_~A~@:>") c))
  (defmethod action-description ((o compile-op) (c parent-component))
    (format nil (compatfmt "~@<completing compilation for ~3i~_~A~@:>") c))
85
  (defgeneric call-with-around-compile-hook (component thunk)
Robert Goldman's avatar
Robert Goldman committed
86 87 88 89
    (:documentation "A method to be called around the PERFORM'ing of actions that apply the
compile-time side-effects of file (i.e., COMPILE-OP or LOAD-SOURCE-OP). This method can be used
to setup readtables and other variables that control reading, macroexpanding, and compiling, etc.
Note that it will NOT be called around the performing of LOAD-OP."))
90 91 92
  (defmethod call-with-around-compile-hook ((c component) function)
    (call-around-hook (around-compile-hook c) function))
  (defun perform-lisp-compilation (o c)
93
    "Perform the compilation of the Lisp file associated to the specified action (O . C)."
94 95 96
    (let (;; Before 2.26.53, that was unfortunately component-pathname. Now,
          ;; we consult input-files, the first of which should be the one to compile-file
          (input-file (first (input-files o c)))
97
          ;; On some implementations, there are more than one output-file,
98 99 100 101 102 103
          ;; but the first one should always be the primary fasl that gets loaded.
          (outputs (output-files o c)))
      (multiple-value-bind (output warnings-p failure-p)
          (destructuring-bind
              (output-file
               &optional
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
104
                 #+(or clasp ecl mkcl) object-file
105
                 #+clisp lib-file
106 107 108 109 110 111 112
                 warnings-file &rest rest) outputs
            ;; Allow for extra outputs that are not of type warnings-file
            ;; The way we do it is kludgy. In ASDF4, output-files shall not be positional.
            (declare (ignore rest))
            (when warnings-file
              (unless (equal (pathname-type warnings-file) (warnings-file-type))
                (setf warnings-file nil)))
113 114
            (call-with-around-compile-hook
             c #'(lambda (&rest flags)
115 116 117 118 119 120
                   (apply 'compile-file* input-file
                          :output-file output-file
                          :external-format (component-external-format c)
                          :warnings-file warnings-file
                          (append
                           #+clisp (list :lib-file lib-file)
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
121
                           #+(or clasp ecl mkcl) (list :object-file object-file)
122
                           flags)))))
123 124 125
        (check-lisp-compile-results output warnings-p failure-p
                                    "~/asdf-action::format-action/" (list (cons o c))))))
  (defun report-file-p (f)
Robert Goldman's avatar
Robert Goldman committed
126
    "Is F a build report file containing, e.g., warnings to check?"
127
    (equalp (pathname-type f) "build-report"))
128
  (defun perform-lisp-warnings-check (o c)
Robert Goldman's avatar
Robert Goldman committed
129
    "Check the warnings associated with the dependencies of an action."
130 131 132 133 134 135 136 137 138 139 140 141 142 143
    (let* ((expected-warnings-files (remove-if-not #'warnings-file-p (input-files o c)))
           (actual-warnings-files (loop :for w :in expected-warnings-files
                                        :when (get-file-stamp w)
                                          :collect w
                                        :else :do (warn "Missing warnings file ~S while ~A"
                                                        w (action-description o c)))))
      (check-deferred-warnings actual-warnings-files)
      (let* ((output (output-files o c))
             (report (find-if #'report-file-p output)))
        (when report
          (with-open-file (s report :direction :output :if-exists :supersede)
            (format s ":success~%"))))))
  (defmethod perform ((o compile-op) (c cl-source-file))
    (perform-lisp-compilation o c))
144
  (defun lisp-compilation-output-files (o c)
Robert Goldman's avatar
Robert Goldman committed
145 146
    "Compute the output-files for compiling the Lisp file for the specified action (O . C),
an OPERATION and a COMPONENT."
147 148
    (let* ((i (first (input-files o c)))
           (f (compile-file-pathname
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
149 150
               i #+clasp :output-type #+ecl :type #+(or clasp ecl) :fasl
               #+mkcl :fasl-p #+mkcl t)))
151
      `(,f ;; the fasl is the primary output, in first position
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
152 153 154
        #+clasp
        ,@(unless nil ;; was (use-ecl-byte-compiler-p)
            `(,(compile-file-pathname i :output-type :object)))
155 156 157 158 159 160
        #+clisp
        ,@`(,(make-pathname :type "lib" :defaults f))
        #+ecl
        ,@(unless (use-ecl-byte-compiler-p)
            `(,(compile-file-pathname i :type :object)))
        #+mkcl
161 162 163
        ,(compile-file-pathname i :fasl-p nil) ;; object file
        ,@(when (and *warnings-file-type* (not (builtin-system-p (component-system c))))
            `(,(make-pathname :type *warnings-file-type* :defaults f))))))
164 165
  (defmethod output-files ((o compile-op) (c cl-source-file))
    (lisp-compilation-output-files o c))
166 167
  (defmethod perform ((o compile-op) (c static-file))
    nil)
168 169

  ;; Performing compile-op on a system will check the deferred warnings for the system
170
  (defmethod perform ((o compile-op) (c system))
171
    (when (and *warnings-file-type* (not (builtin-system-p c)))
172 173
      (perform-lisp-warnings-check o c)))
  (defmethod input-files ((o compile-op) (c system))
174 175
    (when (and *warnings-file-type* (not (builtin-system-p c)))
      ;; The most correct way to do it would be to use:
176
      ;; (collect-dependencies o c :other-systems nil :keep-operation 'compile-op :keep-component 'cl-source-file)
177 178 179
      ;; but it's expensive and we don't care too much about file order or ASDF extensions.
      (loop :for sub :in (sub-components c :type 'cl-source-file)
            :nconc (remove-if-not 'warnings-file-p (output-files o sub)))))
180 181 182
  (defmethod output-files ((o compile-op) (c system))
    (when (and *warnings-file-type* (not (builtin-system-p c)))
      (if-let ((pathname (component-pathname c)))
183
        (list (subpathname pathname (coerce-filename c) :type "build-report"))))))
184 185

;;; load-op
186 187 188 189 190
(with-upgradability ()
  (defmethod action-description ((o load-op) (c cl-source-file))
    (format nil (compatfmt "~@<loading FASL for ~3i~_~A~@:>") c))
  (defmethod action-description ((o load-op) (c parent-component))
    (format nil (compatfmt "~@<completing load for ~3i~_~A~@:>") c))
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
191 192
  (defmethod action-description ((o load-op) (c component))
    (format nil (compatfmt "~@<loading ~3i~_~A~@:>") c))
193 194 195 196 197 198 199 200 201 202
  (defmethod perform-with-restarts ((o load-op) (c cl-source-file))
    (loop
      (restart-case
          (return (call-next-method))
        (try-recompiling ()
          :report (lambda (s)
                    (format s "Recompile ~a and try loading it again"
                            (component-name c)))
          (perform (find-operation o 'compile-op) c)))))
  (defun perform-lisp-load-fasl (o c)
Robert Goldman's avatar
Robert Goldman committed
203 204
    "Perform the loading of a FASL associated to specified action (O . C),
an OPERATION and a COMPONENT."
205
    (if-let (fasl (first (input-files o c)))
206
      (load* fasl)))
207 208 209
  (defmethod perform ((o load-op) (c cl-source-file))
    (perform-lisp-load-fasl o c))
  (defmethod perform ((o load-op) (c static-file))
210
    nil))
211 212 213 214 215


;;;; prepare-source-op, load-source-op

;;; prepare-source-op
216 217 218 219 220 221 222
(with-upgradability ()
  (defmethod action-description ((o prepare-source-op) (c component))
    (format nil (compatfmt "~@<loading source for dependencies of ~3i~_~A~@:>") c))
  (defmethod input-files ((o prepare-source-op) (s system))
    (if-let (it (system-source-file s)) (list it)))
  (defmethod perform ((o prepare-source-op) (c component))
    nil))
223 224

;;; load-source-op
225
(with-upgradability ()
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
226
  (defmethod action-description ((o load-source-op) (c component))
227 228 229 230
    (format nil (compatfmt "~@<Loading source of ~3i~_~A~@:>") c))
  (defmethod action-description ((o load-source-op) (c parent-component))
    (format nil (compatfmt "~@<Loaded source of ~3i~_~A~@:>") c))
  (defun perform-lisp-load-source (o c)
231
    "Perform the loading of a Lisp file as associated to specified action (O . C)"
232 233
    (call-with-around-compile-hook
     c #'(lambda ()
234 235
           (load* (first (input-files o c))
                  :external-format (component-external-format c)))))
236 237 238 239 240

  (defmethod perform ((o load-source-op) (c cl-source-file))
    (perform-lisp-load-source o c))
  (defmethod perform ((o load-source-op) (c static-file))
    nil))
241 242 243


;;;; test-op
244 245 246 247 248
(with-upgradability ()
  (defmethod perform ((o test-op) (c component))
    nil)
  (defmethod operation-done-p ((o test-op) (c system))
    "Testing a system is _never_ done."
249
    nil))