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

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


;;;; Component classes
20 21 22 23 24 25 26
(with-upgradability ()
  (defclass cl-source-file (source-file)
    ((type :initform "lisp")))
  (defclass cl-source-file.cl (cl-source-file)
    ((type :initform "cl")))
  (defclass cl-source-file.lsp (cl-source-file)
    ((type :initform "lsp"))))
27 28 29


;;;; Operation classes
30 31 32 33 34 35
(with-upgradability ()
  (defclass basic-load-op (operation) ())
  (defclass basic-compile-op (operation)
    ((proclamations :initarg :proclamations :accessor compile-op-proclamations :initform nil)
     (flags :initarg :flags :accessor compile-op-flags
            :initform nil))))
36 37

;;; Our default operations: loading into the current lisp image
38 39 40 41 42 43
(with-upgradability ()
  (defclass load-op (basic-load-op downward-operation sibling-operation) ())
  (defclass prepare-op (upward-operation sibling-operation)
    ((sibling-operation :initform 'load-op :allocation :class)))
  (defclass compile-op (basic-compile-op downward-operation)
    ((downward-operation :initform 'load-op :allocation :class)))
44

45 46 47
  (defclass load-source-op (basic-load-op downward-operation) ())
  (defclass prepare-source-op (upward-operation sibling-operation)
    ((sibling-operation :initform 'load-source-op :allocation :class)))
48

49
  (defclass test-op (operation) ()))
50 51 52 53 54


;;;; prepare-op, compile-op and load-op

;;; prepare-op
55 56 57 58 59 60 61 62 63 64 65 66 67
(with-upgradability ()
  (defmethod action-description ((o prepare-op) (c component))
    (declare (ignorable o))
    (format nil (compatfmt "~@<loading dependencies of ~3i~_~A~@:>") c))
  (defmethod perform ((o prepare-op) (c component))
    (declare (ignorable o c))
    nil)
  (defmethod input-files ((o prepare-op) (c component))
    (declare (ignorable o c))
    nil)
  (defmethod input-files ((o prepare-op) (s system))
    (declare (ignorable o))
    (if-let (it (system-source-file s)) (list it))))
68 69

;;; compile-op
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
(with-upgradability ()
  (defmethod action-description ((o compile-op) (c component))
    (declare (ignorable o))
    (format nil (compatfmt "~@<compiling ~3i~_~A~@:>") c))
  (defmethod action-description ((o compile-op) (c parent-component))
    (declare (ignorable o))
    (format nil (compatfmt "~@<completing compilation for ~3i~_~A~@:>") c))
  (defgeneric call-with-around-compile-hook (component thunk))
  (defmethod call-with-around-compile-hook ((c component) function)
    (call-around-hook (around-compile-hook c) function))
  (defun perform-lisp-compilation (o c)
    (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)))
          ;; on some implementations, there are more than one output-file,
          ;; 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
                 #+clisp lib-file
                 #+(or ecl mkcl) object-file
                 #+(or clozure sbcl) warnings-file) outputs
            (call-with-around-compile-hook
             c #'(lambda (&rest flags)
                   (with-muffled-compiler-conditions ()
                     (apply 'compile-file* input-file
                            :output-file output-file
                            :external-format (component-external-format c)
                            (append
                             #+clisp (list :lib-file lib-file)
                             #+(or ecl mkcl) (list :object-file object-file)
                             #+(or clozure sbcl) (list :warnings-file warnings-file)
                             flags (compile-op-flags o)))))))
        (check-lisp-compile-results output warnings-p failure-p
                                    "~/asdf-action::format-action/" (list (cons o c))))))

  (defun report-file-p (f)
    (equal (pathname-type f) "build-report"))
  (defun perform-lisp-warnings-check (o c)
    (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))
  (defmethod output-files ((o compile-op) (c cl-source-file))
    (declare (ignorable o))
    (let* ((i (first (input-files o c)))
           (f (compile-file-pathname
               i #+mkcl :fasl-p #+mkcl t #+ecl :type #+ecl :fasl)))
      `(,f ;; the fasl is the primary output, in first position
        #+clisp
        ,@`(,(make-pathname :type "lib" :defaults f))
        #+(or clozure sbcl)
        ,@(let ((s (component-system c)))
            (unless (builtin-system-p s) ; includes ASDF itself
              `(,(make-pathname :type (warnings-file-type) :defaults f))))
        #+ecl
        ,@(unless (use-ecl-byte-compiler-p)
            `(,(compile-file-pathname i :type :object)))
        #+mkcl
        ,(compile-file-pathname i :fasl-p nil)))) ;; object file
  (defmethod component-depends-on ((o compile-op) (c component))
    (declare (ignorable o))
    `((prepare-op ,c) ,@(call-next-method)))
  (defmethod perform ((o compile-op) (c static-file))
    (declare (ignorable o c))
    nil)
  (defmethod output-files ((o compile-op) (c static-file))
    (declare (ignorable o c))
    nil)
  (defmethod perform ((o compile-op) (c system))
    (when *warnings-file-type*
      (perform-lisp-warnings-check o c)))
  (defmethod input-files ((o compile-op) (c system))
    (when *warnings-file-type*
      (unless (builtin-system-p c)
        ;; The most correct way to do it would be to use:
        ;; (traverse-sub-actions o c :other-systems nil :keep-operation 'compile-op :keep-component 'cl-source-file)
        ;; 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))))))
  (defmethod output-files ((o compile-op) (c system))
    (when (and *warnings-file-type* (not (builtin-system-p c)))
      (if-let ((pathname (component-pathname c)))
        (list (subpathname pathname (component-name c) :type "build-report"))))))
166 167

;;; load-op
168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
(with-upgradability ()
  (defmethod action-description ((o load-op) (c cl-source-file))
    (declare (ignorable o))
    (format nil (compatfmt "~@<loading FASL for ~3i~_~A~@:>") c))
  (defmethod action-description ((o load-op) (c parent-component))
    (declare (ignorable o))
    (format nil (compatfmt "~@<completing load for ~3i~_~A~@:>") c))
  (defmethod action-description ((o load-op) component)
    (declare (ignorable o))
    (format nil (compatfmt "~@<loading ~3i~_~A~@:>")
            component))
  (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)
    (if-let (fasl (first (input-files o c)))
      (with-muffled-loader-conditions () (load* fasl))))
  (defmethod perform ((o load-op) (c cl-source-file))
    (perform-lisp-load-fasl o c))
  (defmethod perform ((o load-op) (c static-file))
    (declare (ignorable o c))
    nil)
  (defmethod component-depends-on ((o load-op) (c component))
    (declare (ignorable o))
    ;; NB: even though compile-op depends-on on prepare-op,
    ;; it is not needed-in-image-p, whereas prepare-op is,
    ;; so better not omit prepare-op and think it will happen.
    `((prepare-op ,c) (compile-op ,c) ,@(call-next-method))))
202 203 204 205 206


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

;;; prepare-source-op
207 208 209 210 211 212 213 214 215 216 217 218 219
(with-upgradability ()
  (defmethod action-description ((o prepare-source-op) (c component))
    (declare (ignorable o))
    (format nil (compatfmt "~@<loading source for dependencies of ~3i~_~A~@:>") c))
  (defmethod input-files ((o prepare-source-op) (c component))
    (declare (ignorable o c))
    nil)
  (defmethod input-files ((o prepare-source-op) (s system))
    (declare (ignorable o))
    (if-let (it (system-source-file s)) (list it)))
  (defmethod perform ((o prepare-source-op) (c component))
    (declare (ignorable o c))
    nil))
220 221

;;; load-source-op
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246
(with-upgradability ()
  (defmethod action-description ((o load-source-op) c)
    (declare (ignorable o))
    (format nil (compatfmt "~@<Loading source of ~3i~_~A~@:>") c))
  (defmethod action-description ((o load-source-op) (c parent-component))
    (declare (ignorable o))
    (format nil (compatfmt "~@<Loaded source of ~3i~_~A~@:>") c))
  (defmethod component-depends-on ((o load-source-op) (c component))
    (declare (ignorable o))
    `((prepare-source-op ,c) ,@(call-next-method)))
  (defun perform-lisp-load-source (o c)
    (call-with-around-compile-hook
     c #'(lambda ()
           (with-muffled-loader-conditions ()
             (load* (first (input-files o c))
                    :external-format (component-external-format c))))))

  (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))
    (declare (ignorable o c))
    nil)
  (defmethod output-files ((o load-source-op) (c component))
    (declare (ignorable o c))
    nil))
247 248 249


;;;; test-op
250 251 252 253 254 255 256 257 258 259 260
(with-upgradability ()
  (defmethod perform ((o test-op) (c component))
    (declare (ignorable o c))
    nil)
  (defmethod operation-done-p ((o test-op) (c system))
    "Testing a system is _never_ done."
    (declare (ignorable o c))
    nil)
  (defmethod component-depends-on ((o test-op) (c system))
    (declare (ignorable o))
    `((load-op ,c) ,@(call-next-method))))
261