1.023: compile files the modern ASDF way, with various hooks (around-compile,
authorFrancois-Rene Rideau <tunes@google.com>
Fri, 10 Aug 2012 09:47:55 +0000 (05:47 -0400)
committerFrancois-Rene Rideau <tunes@google.com>
Fri, 10 Aug 2012 09:47:55 +0000 (05:47 -0400)
external-format, *compile-op-compile-file-function*, compile-flags).
For that, depend on ASDF 2.21 or later (2.23 or later preferred).
Also, override any with-compilation-unit when compiling in a fork.
If that causes warnings you don't like to be emitted...
use asdf-condition-control.

poiu.asd
poiu.lisp

index 8999c3c..583c071 100644 (file)
--- a/poiu.asd
+++ b/poiu.asd
@@ -13,7 +13,7 @@
 
 (let ((old-ver (asdf-version)))
   (load-system :asdf)
-  (let ((min "2.017.12")
+  (let ((min "2.21")
        (ver (asdf-version)))
     (unless (or (version-satisfies old-ver "2.014.8") ; first version to do magic upgrade
                (equal ver old-ver))
@@ -32,5 +32,5 @@ POIU is a variant of ASDF that may operate on your systems in parallel.
 POIU will notably compile each Lisp file in its own forked process,
 in parallel with other operations (compilation or loading).
 However, it will load FASLs serially as they become available."
-    :depends-on ((:version :asdf "2.017.12")) ; for ensure-all-directories-exist
+    :depends-on ((:version :asdf "2.21")) ; for external-format support.
     :components ((:file "poiu")))
index ce6e019..885be59 100644 (file)
--- a/poiu.lisp
+++ b/poiu.lisp
@@ -1,8 +1,8 @@
 ;;; This is POIU: Parallel Operator on Independent Units
 (cl:in-package :asdf)
 (eval-when (:compile-toplevel :load-toplevel :execute)
-(defparameter *poiu-version* "1.022")
-(defparameter *asdf-version-required-by-poiu* "2.017.12"))
+(defparameter *poiu-version* "1.023")
+(defparameter *asdf-version-required-by-poiu* "2.21"))
 #|
 POIU is a modification of ASDF that may operate on your systems in parallel.
 This version of POIU was designed to work with ASDF no earlier than specified.
@@ -31,7 +31,7 @@ with a chance to debug the issue and restart the operation.
 
 POIU was currently only made to work with SBCL, CCL and CLISP.
 Porting to another Lisp implementation that supports ASDF
-should not be difficult. [Note: CLISP port somehow seems less stable.]
+should not be difficult. [Note: the CLISP port somehow seems less stable.]
 
 Warning to CCL users: you need to save a CCL image that doesn't start threads
 at startup in order to use POIU (or anything that uses fork).
@@ -767,19 +767,28 @@ Operation-executed-p is at plan execution time."))
   (ensure-all-directories-exist (asdf:output-files operation c)))
 
 (defmethod perform ((op parallel-compile-op) (c cl-source-file))
-  (let ((compile-status (list
-                         :input-file (car (input-files op c))
-                         :performed-p t
-                         :output-truename (car (output-files op c))
-                         :warnings-p nil
-                         :failure-p t))
-        warnings-p failure-p output-truename)
+  (let* ((source-file (component-pathname c))
+        ;; on some implementations, there are more than one output-file,
+        ;; but the first one should always be the primary fasl that gets loaded.
+        (output-file (first (output-files op c)))
+        (compile-status (list
+                         :input-file source-file
+                         :performed-p t
+                         :output-truename output-file
+                         :warnings-p nil
+                         :failure-p t))
+        warnings-p failure-p output-truename)
     (unwind-protect (progn
                       (multiple-value-setq (output-truename warnings-p failure-p)
-                          (compile-file (car (input-files op c))
-                                        :output-file (car (output-files op c))))
+                       (with-compilation-unit (:override t)
+                         (call-with-around-compile-hook
+                          c #'(lambda (&rest flags)
+                                (apply *compile-op-compile-file-function* source-file
+                                       :output-file output-file
+                                       :external-format (component-external-format c)
+                                       (append flags (compile-op-flags op)))))))
                       (setf compile-status
-                            (list :input-file (car (input-files op c))
+                            (list :input-file source-file
                                   :performed-p t
                                   :output-truename output-truename
                                   :warnings-p warnings-p