Changeset 14661


Ignore:
Timestamp:
03/25/14 09:04:23 (3 years ago)
Author:
mevenson
Message:

Update to ASDF 3.1.0.103.

Seems to fix loading of Ironclad, and other Quicklisp failures.

Location:
trunk/abcl
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/abcl/doc/asdf/asdf.texinfo

    r14636 r14661  
    247247(In the context of compatibility requirements,
    248248ASDF 2.27, released on Feb 1st 2013, and further 2.x releases up to 2.33,
    249 count as pre-releases of ASDF 3, and define the :asdf3 feature;
     249count as pre-releases of ASDF 3, and define the @code{:asdf3} feature;
    250250still, please use the latest release).
     251Release ASDF 3.1.1 and later also define the @code{:asdf3.1} feature.
    251252
    252253Also note that ASDF is not to be confused with ASDF-Install.
     
    257258If you want to download software from version control instead of tarballs,
    258259so you may more easily modify it, we recommend clbuild.
     260We recommend @file{~/common-lisp/}
     261as a place into which to install Common Lisp software;
     262starting with ASDF 3.1.1, it is included in the default source-registry configuration.
    259263
    260264@node  Quick start summary, Loading ASDF, Introduction, Top
     
    277281For more details, @xref{Configuring ASDF to find your systems}.
    278282The simplest way is simply to put all your lisp code in subdirectories of
    279 @file{~/.local/share/common-lisp/source/}.
     283@file{~/common-lisp/} (starting with ASDF 3.1.1),
     284or @file{~/.local/share/common-lisp/source/}
     285(for ASDF 2 and later, or if you want to keep source in a hidden directory).
    280286Such code will automatically be found.
    281287
     
    434440Still, the ASDF source repository contains a script
    435441@file{bin/install-asdf-as-module} that can help you do that.
    436 It relies on cl-launch 4 for command-line invocation,
     442It relies on @file{cl-launch} 4 for command-line invocation,
    437443which may depend on ASDF being checked out in @file{~/cl/asdf/}
    438444if your implementation doesn't even have an ASDF 2;
    439 but you can run the code it manually if needs be.
     445but if you don't have @file{cl-launch},
     446you can instead @code{(load "bin/install-asdf-as-module")}
     447from your implementation's REPL.
    440448
    441449Finally, if your implementation only provides ASDF 2,
     
    554562@end menu
    555563
    556 @node Configuring ASDF to find your systems, Configuring where ASDF stores object files, Configuring ASDF, Configuring ASDF
     564@node Configuring ASDF to find your systems, Configuring ASDF to find your systems --- old style, Configuring ASDF, Configuring ASDF
    557565@section Configuring ASDF to find your systems
    558566
     
    567575@item
    568576Put all of your systems in subdirectories of
     577@file{~/common-lisp/} or
    569578@file{~/.local/share/common-lisp/source/}.
    570 If you install software there (it can be a symlink),
    571 you don't need further configuration.
     579If you install software there, you don't need further configuration.
     580(NB: @file{~/common-lisp/} is only included in the default configuration
     581starting with ASDF 3.1.1 or later)
    572582
    573583@item
     
    615625(asdf:clear-source-registry)
    616626@end lisp
    617 
    618 @c FIXME: too specific.  Push this down to discussion of dumping an
    619 @c image?
    620 
    621 @c And you probably should do so before you dump your Lisp image,
    622 @c if the configuration may change
    623 @c between the machine where you save it at the time you save it
    624 @c and the machine you resume it at the time you resume it.
    625 @c Actually, you should use @code{(asdf:clear-configuration)}
    626 @c before you dump your Lisp image, which includes the above.
    627627
    628628@item
     
    732732
    733733
    734 @node Configuring where ASDF stores object files,  , Configuring ASDF to find your systems, Configuring ASDF
     734@node Configuring where ASDF stores object files, Resetting the ASDF configuration, Configuring ASDF to find your systems --- old style, Configuring ASDF
    735735@section Configuring where ASDF stores object files
    736736@findex clear-output-translations
     
    829829@end defun
    830830
    831 If you use SBCL, CMUCL or SCL, you may use this snippet
    832 so that the ASDF configuration be cleared automatically as you dump an image:
    833 
    834 @example
    835 #+(or cmu sbcl scl)
    836 (pushnew 'clear-configuration
    837          #+(or cmu scl) ext:*before-save-initializations*
    838          #+sbcl sb-ext:*save-hooks*)
    839 @end example
    840 
    841 For compatibility with all Lisp implementations, however,
    842 you might want instead your build script to explicitly call
    843 @code{(asdf:clear-configuration)} at an appropriate moment before dumping.
     831This function is pushed onto the @code{uiop:*image-dump-hook*} by default,
     832which means that if you save an image using @code{uiop:dump-image},
     833or via @code{asdf:image-op} and @code{asdf:program-op},
     834it will be automatically called to clear your configuration.
     835If for some reason you prefer to call your implementation's underlying functionality,
     836be sure to call @code{clear-configuration} manually,
     837or push it into your implementation's equivalent of @code{uiop:*image-dump-hook*},
     838e.g. @code{sb-ext:*save-hooks*} on SBCL, or @code{ext:*before-save-initializations*}
     839on CMUCL and SCL, etc.
    844840
    845841@node  Using ASDF, Defining systems with defsystem, Configuring ASDF, Top
  • trunk/abcl/src/org/armedbear/lisp/asdf.lisp

    r14636 r14661  
    11;;; -*- mode: Common-Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp ; buffer-read-only: t; -*-
    2 ;;; This is ASDF 3.1.0.94: Another System Definition Facility.
     2;;; This is ASDF 3.1.0.103: Another System Definition Facility.
    33;;;
    44;;; Feedback, bug reports, and patches are all welcome:
     
    868868;;;; Early meta-level tweaks
    869869
    870 #+(or abcl allegro clisp cmu ecl mkcl clozure lispworks sbcl scl)
     870#+(or abcl allegro clisp cmu ecl mkcl clozure lispworks mkcl sbcl scl)
    871871(eval-when (:load-toplevel :compile-toplevel :execute)
    872872  ;; Check for unicode at runtime, so that a hypothetical FASL compiled with unicode
     
    13501350
    13511351
    1352 ;;; CLOS
    1353 (with-upgradability ()
    1354   (defun coerce-class (class &key (package :cl) (super t) (error 'error))
    1355     "Coerce CLASS to a class that is subclass of SUPER if specified,
    1356 or invoke ERROR handler as per CALL-FUNCTION.
    1357 
    1358 A keyword designates the name a symbol, which when found in PACKAGE, designates a class.
    1359 A string is read as a symbol while in PACKAGE, the symbol designates a class.
    1360 
    1361 A class object designates itself.
    1362 NIL designates itself (no class).
    1363 A symbol otherwise designates a class by name."
    1364     (let* ((normalized
    1365              (typecase class
    1366               (keyword (find-symbol* class package nil))
    1367               (string (symbol-call :uiop :safe-read-from-string class :package package))
    1368               (t class)))
    1369            (found
    1370              (etypecase normalized
    1371                ((or standard-class built-in-class) normalized)
    1372                ((or null keyword) nil)
    1373                (symbol (find-class normalized nil nil)))))
    1374       (or (and found
    1375                (or (eq super t) (#-cormanlisp subtypep #+cormanlisp cl::subclassp found super))
    1376                found)
    1377           (call-function error "Can't coerce ~S to a ~@[class~;subclass of ~:*~S]" class super)))))
    1378 
    1379 
    13801352;;; stamps: a REAL or a boolean where NIL=-infinity, T=+infinity
    13811353(eval-when (#-lispworks :compile-toplevel :load-toplevel :execute)
     
    14761448
    14771449
     1450;;; CLOS
     1451(with-upgradability ()
     1452  (defun coerce-class (class &key (package :cl) (super t) (error 'error))
     1453    "Coerce CLASS to a class that is subclass of SUPER if specified,
     1454or invoke ERROR handler as per CALL-FUNCTION.
     1455
     1456A keyword designates the name a symbol, which when found in either PACKAGE, designates a class.
     1457-- for backward compatibility, *PACKAGE* is also accepted for now, but this may go in the future.
     1458A string is read as a symbol while in PACKAGE, the symbol designates a class.
     1459
     1460A class object designates itself.
     1461NIL designates itself (no class).
     1462A symbol otherwise designates a class by name."
     1463    (let* ((normalized
     1464             (typecase class
     1465              (keyword (or (find-symbol* class package nil)
     1466                           (find-symbol* class *package* nil)))
     1467              (string (symbol-call :uiop :safe-read-from-string class :package package))
     1468              (t class)))
     1469           (found
     1470             (etypecase normalized
     1471               ((or standard-class built-in-class) normalized)
     1472               ((or null keyword) nil)
     1473               (symbol (find-class normalized nil nil)))))
     1474      (or (and found
     1475               (or (eq super t) (#-cormanlisp subtypep #+cormanlisp cl::subclassp found super))
     1476               found)
     1477          (call-function error "Can't coerce ~S to a ~@[class~;subclass of ~:*~S]" class super)))))
     1478
     1479
    14781480;;; Hash-tables
    14791481(with-upgradability ()
     
    15651567    #+clozure 'ccl::format-control
    15661568    #+(or cmu scl) 'conditions::format-control
    1567     #+ecl 'si::format-control
     1569    #+(or ecl mkcl) 'si::format-control
    15681570    #+(or gcl lispworks) 'conditions::format-string
    15691571    #+sbcl 'sb-kernel:format-control
    1570     #-(or abcl allegro clisp clozure cmu ecl gcl lispworks sbcl scl) nil
     1572    #-(or abcl allegro clisp clozure cmu ecl gcl lispworks mkcl sbcl scl) nil
    15711573    "Name of the slot for FORMAT-CONTROL in simple-condition")
    15721574
     
    16521654    "Is the underlying operating system Microsoft Windows?"
    16531655    (or #+abcl (featurep :windows)
    1654         #+(and (not (or abcl unix cygwin darwin)) (or win32 windows mswindows mingw32)) t))
     1656        #+(and (not (or abcl unix cygwin darwin)) (or win32 windows mswindows mingw32 mingw64)) t))
    16551657
    16561658  (defun os-genera-p ()
     
    20612063  ;; This will be :unspecific if supported, or NIL if not.
    20622064  (defparameter *unspecific-pathname-type*
    2063     #+(or abcl allegro clozure cmu genera lispworks mkcl sbcl scl) :unspecific
    2064     #+(or clisp ecl gcl xcl #|These haven't been tested:|# cormanlisp mcl) nil
     2065    #+(or abcl allegro clozure cmu genera lispworks sbcl scl) :unspecific
     2066    #+(or clisp ecl mkcl gcl xcl #|These haven't been tested:|# cormanlisp mcl) nil
    20652067    "Unspecific type component to use with the underlying implementation's MAKE-PATHNAME")
    20662068
     
    21602162    ;; MCL has issues with make-pathname, nil and defaulting
    21612163    (declare (ignorable defaults))
    2162     #.`(make-pathname* :directory nil :name nil :type nil :version nil :device nil
    2163                        :host (or #+cmu lisp::*unix-host*)
     2164    #.`(make-pathname* :directory nil :name nil :type nil :version nil
     2165                       :device (or #+(and mkcl unix) :unspecific)
     2166                       :host (or #+cmu lisp::*unix-host* #+(and mkcl unix) "localhost")
    21642167                       #+scl ,@'(:scheme nil :scheme-specific-part nil
    21652168                                 :username nil :password nil :parameters nil :query nil :fragment nil)
     
    21942197            (and (pathnamep p1) (pathnamep p2)
    21952198                 (and (=? pathname-host)
    2196                       (=? pathname-device)
     2199                      #-(and mkcl unix) (=? pathname-device)
    21972200                      (=? normalize-pathname-directory-component pathname-directory)
    21982201                      (=? pathname-name)
    21992202                      (=? pathname-type)
    2200                       (=? pathname-version)))))))
     2203                      #-mkcl (=? pathname-version)))))))
    22012204
    22022205  (defun absolute-pathname-p (pathspec)
     
    33003303               `(progn (require :sb-posix) (symbol-call :sb-posix :rmdir directory-pathname)))
    33013304    #+xcl (symbol-call :uiop :run-program `("rmdir" ,(native-namestring directory-pathname)))
    3302     #-(or abcl allegro clisp clozure cmu cormanlisp digitool ecl gcl lispworks sbcl scl xcl)
     3305    #-(or abcl allegro clisp clozure cmu cormanlisp digitool ecl gcl lispworks mkcl sbcl scl xcl)
    33033306    (error "~S not implemented on ~S" 'delete-empty-directory (implementation-type))) ; genera
    33043307
     
    40054008          ,@(when prefix `(:prefix ,prefix))
    40064009          ,@(when suffix `(:suffix ,suffix))
    4007           ,@(when type `(:suffix ,type))
     4010          ,@(when type `(:type ,type))
    40084011          ,@(when keep `(:keep ,keep))
    40094012          ,@(when after `(:after `#',afterf))
     
    41644167          (debug:*debug-print-length* *print-length*))
    41654168      (debug:backtrace (or count most-positive-fixnum) stream))
    4166     #+ecl
     4169    #+(or ecl mkcl)
    41674170    (let* ((top (si:ihs-top))
    41684171     (repeats (if count (min top count) top))
     
    42794282    #+(or genera mcl) nil
    42804283    #+lispworks sys:*line-arguments-list*
     4284    #+mkcl (loop :for i :from 0 :below (mkcl:argc) :collect (mkcl:argv i))
    42814285    #+sbcl sb-ext:*posix-argv*
    42824286    #+xcl system:*argv*
    4283     #-(or abcl allegro clisp clozure cmu ecl gcl genera lispworks mcl sbcl scl xcl)
     4287    #-(or abcl allegro clisp clozure cmu ecl gcl genera lispworks mcl mkcl sbcl scl xcl)
    42844288    (error "raw-command-line-arguments not implemented yet"))
    42854289
     
    43094313    (cond
    43104314      ((eq *image-dumped-p* :executable) ; yes, this ARGV0 is our argv0 !
    4311        ;; NB: not currently available on ABCL, Corman, Genera, MCL, MKCL
     4315       ;; NB: not currently available on ABCL, Corman, Genera, MCL
    43124316       (or #+(or allegro clisp clozure cmu gcl lispworks sbcl scl xcl)
    43134317           (first (raw-command-line-arguments))
    4314            #+ecl (si:argv 0)))
     4318           #+ecl (si:argv 0) #+mkcl (mkcl:argv 0)))
    43154319      (t ;; argv[0] is the name of the interpreter.
    43164320       ;; The wrapper script can export __CL_ARGV0. cl-launch does as of 4.0.1.8.
     
    44614465           'dump-image filename (nth-value 1 (implementation-type))))
    44624466
    4463   (defun create-image (destination object-files
    4464                        &key kind output-name prologue-code epilogue-code
     4467  (defun create-image (destination lisp-object-files
     4468                       &key kind output-name prologue-code epilogue-code extra-object-files
    44654469                         (prelude () preludep) (postlude () postludep)
    44664470                         (entry-point () entry-point-p) build-args)
    4467     (declare (ignorable destination object-files kind output-name prologue-code epilogue-code
    4468                         prelude preludep postlude postludep entry-point entry-point-p build-args))
     4471    (declare (ignorable destination lisp-object-files extra-object-files kind output-name
     4472                        prologue-code epilogue-code prelude preludep postlude postludep
     4473                        entry-point entry-point-p build-args))
    44694474    "On ECL, create an executable at pathname DESTINATION from the specified OBJECT-FILES and options"
    44704475    ;; Is it meaningful to run these in the current environment?
    44714476    ;; only if we also track the object files that constitute the "current" image,
    44724477    ;; and otherwise simulate dump-image, including quitting at the end.
    4473     #-ecl (error "~S not implemented for your implementation (yet)" 'create-image)
    4474     #+ecl
     4478    #-(or ecl mkcl) (error "~S not implemented for your implementation (yet)" 'create-image)
     4479    #+(or ecl mkcl)
    44754480    (let ((epilogue-forms
    44764481            (append
     
    44834488                (setf kind :program) ;; to ECL, it's just another program.
    44844489                `((setf *image-dumped-p* t)
    4485                   ;; fall through should be equivalent to: (si::top-level t) (quit)
    4486                   ))
     4490                  (si::top-level #+ecl t) (quit)))
    44874491               ((:program)
    44884492                `((setf *image-dumped-p* :executable)
    44894493                  (shell-boolean-exit
    44904494                   (restore-image))))))))
    4491       (check-type kind (member :dll :lib :static-library :program :object :fasl :program))
    4492       (apply 'c::builder
    4493              kind (pathname destination)
    4494              :lisp-files object-files
    4495              :init-name (c::compute-init-name (or output-name destination) :kind kind)
    4496              :prologue-code prologue-code
    4497              :epilogue-code (when epilogue-forms `(progn ,@epilogue-forms))
    4498              build-args))))
     4495      #+ecl (check-type kind (member :dll :lib :static-library :program :object :fasl))
     4496      (apply #+ecl 'c::builder #+ecl kind
     4497             #+mkcl (ecase kind
     4498                      ((:dll) 'compiler::build-shared-library)
     4499                      ((:lib :static-library) 'compiler::build-static-library)
     4500                      ((:fasl) 'compiler::build-bundle)
     4501                      ((:program) 'compiler::build-program))
     4502             (pathname destination)
     4503             #+ecl :lisp-files #+mkcl :lisp-object-files (append lisp-object-files #+ecl extra-object-files)
     4504             #+ecl :init-name #+ecl (c::compute-init-name (or output-name destination) :kind kind)
     4505             (append
     4506              (when prologue-code `(:prologue-code ,prologue-code))
     4507              (when epilogue-forms `(:epilogue-code (progn ,@epilogue-forms)))
     4508              #+mkcl (when extra-object-files `(:object-files ,extra-object-files))
     4509              build-args)))))
    44994510
    45004511
     
    48484859      #+os-windows
    48494860      (string
     4861       #+mkcl (list "cmd" '#:/c command)
    48504862       ;; NB: We do NOT add cmd /c here. You might want to.
    48514863       #+(or allegro clisp) command
     
    48574869       ;; except in the most trivial cases where no quoting is needed.
    48584870       ;; Use at your own risk.
    4859        #-(or allegro clisp clozure) (list "cmd" "/c" command))
     4871       #-(or allegro clisp clozure mkcl) (list "cmd" "/c" command))
    48604872      #+os-windows
    48614873      (list
     
    48844896       #+allegro nil
    48854897       #+clisp :terminal
    4886        #+(or clozure cmu ecl sbcl scl) t)
    4887       #+(or allegro clozure cmu ecl lispworks sbcl scl)
     4898       #+(or clozure cmu ecl mkcl sbcl scl) t)
     4899      #+(or allegro clozure cmu ecl lispworks mkcl sbcl scl)
    48884900      ((eql :output)
    48894901       (if (eq role :error-output)
     
    49164928     PROCESS, EXIT-CODE, INPUT-STREAM, OUTPUT-STREAM, BIDIR-STREAM, ERROR-STREAM."
    49174929    ;; NB: these implementations have unix vs windows set at compile-time.
    4918     (declare (ignorable if-input-does-not-exist if-output-exists if-error-output-exists))
     4930    (declare (ignorable directory if-input-does-not-exist if-output-exists if-error-output-exists))
    49194931    (assert (not (and wait (member :stream (list input output error-output)))))
    4920     #-(or allegro clisp clozure cmu (and lispworks os-unix) sbcl scl)
     4932    #-(or allegro clisp clozure cmu (and lispworks os-unix) mkcl sbcl scl)
    49214933    (progn command keys directory
    49224934           (error "run-program not available"))
    4923     #+(or allegro clisp clozure cmu (and lispworks os-unix) sbcl scl)
     4935    #+(or allegro clisp clozure cmu (and lispworks os-unix) mkcl sbcl scl)
    49244936    (let* ((%command (%normalize-command command))
    49254937           (%input (%normalize-io-specifier input :input))
     
    49414953               :allow-other-keys t keys))
    49424954             #-allegro
    4943              (with-current-directory (#-sbcl directory)
     4955             (with-current-directory (#-(or sbcl mkcl) directory)
    49444956               #+clisp
    49454957               (flet ((run (f x &rest args)
     
    49534965                   (list (run 'ext:run-program (car %command)
    49544966                              :arguments (cdr %command)))))
    4955                #+(or clozure cmu ecl sbcl scl)
    4956                (#-ecl progn #+ecl multiple-value-list
     4967               #+(or clozure cmu ecl mkcl sbcl scl)
     4968               (#-(or ecl mkcl) progn #+(or ecl mkcl) multiple-value-list
    49574969                (apply
    49584970                 '#+(or cmu ecl scl) ext:run-program
    4959                  #+clozure ccl:run-program #+sbcl sb-ext:run-program
     4971                 #+clozure ccl:run-program #+sbcl sb-ext:run-program #+mkcl mk-ext:run-program
    49604972                 (car %command) (cdr %command)
    49614973                 :input %input
     
    49654977                 :allow-other-keys t
    49664978                 (append
    4967                   #+(or clozure cmu sbcl scl)
     4979                  #+(or clozure cmu mkcl sbcl scl)
    49684980                  `(:if-input-does-not-exist ,if-input-does-not-exist
    49694981                    :if-output-exists ,if-output-exists
     
    50325044                  #+(or cmu scl) (ext:process-error process*)
    50335045                  #+sbcl (sb-ext:process-error process*))))
    5034         #+ecl
    5035         (destructuring-bind (stream code process) process*
     5046        #+(or ecl mkcl)
     5047        (destructuring-bind #+ecl (stream code process) #+mkcl (stream process code) process*
    50365048          (let ((mode (+ (if (eq input :stream) 1 0) (if (eq output :stream) 2 0))))
    50375049            (cond
     
    50605072      #+ecl (si:external-process-pid process)
    50615073      #+(or cmu scl) (ext:process-pid process)
     5074      #+mkcl (mkcl:process-id process)
    50625075      #+sbcl (sb-ext:process-pid process)
    5063       #-(or allegro cmu sbcl scl) (error "~S not implemented" '%process-info-pid)))
     5076      #-(or allegro cmu mkcl sbcl scl) (error "~S not implemented" '%process-info-pid)))
    50645077
    50655078  (defun %wait-process-result (process-info)
     
    50855098              (if-let ((f (find-symbol* :pid-exit-status :system nil)))
    50865099                (funcall f process :wait t)))
    5087             #+sbcl (sb-ext:process-exit-code process)))))
     5100            #+sbcl (sb-ext:process-exit-code process)
     5101            #+mkcl (mkcl:join-process process)))))
    50885102
    50895103  (defun %check-result (exit-code &key command process ignore-error-status)
     
    51855199                           &key input output error-output ignore-error-status &allow-other-keys)
    51865200    ;; helper for RUN-PROGRAM when using %run-program
    5187     #+(or abcl cormanlisp gcl (and lispworks os-windows) mcl mkcl xcl)
     5201    #+(or abcl cormanlisp gcl (and lispworks os-windows) mcl xcl)
    51885202    (progn
    51895203      command keys input output error-output ignore-error-status ;; ignore
     
    52955309        #+gcl (system:system %command)
    52965310        #+mcl (ccl::with-cstrs ((%%command %command)) (_system %%command))
    5297         #+mkcl ;; PROBABLY BOGUS -- ask jcb
    5298         (multiple-value-bind (io process exit-code)
    5299             (mkcl:run-program #+windows %command #+windows ()
    5300                               #-windows "/bin/sh" #-windows (list "-c" %command)
    5301                               :input t :output t))
     5311        #+mkcl (mkcl:system %command)
    53025312        #+xcl (system:%run-shell-command %command))))
    53035313
     
    53785388or an indication of failure via the EXIT-CODE of the process"
    53795389    (declare (ignorable ignore-error-status))
    5380     #-(or abcl allegro clisp clozure cmu cormanlisp ecl gcl lispworks mcl sbcl scl xcl)
     5390    #-(or abcl allegro clisp clozure cmu cormanlisp ecl gcl lispworks mcl mkcl sbcl scl xcl)
    53815391    (error "RUN-PROGRAM not implemented for this Lisp")
    53825392    (flet ((default (x xp output) (cond (xp x) ((eq output :interactive) :interactive))))
     
    53865396                     #+(or abcl clisp) (eq :error-output :output)
    53875397                     #+(and lispworks os-unix) (%interactivep input output error-output)
    5388                      #+(or abcl cormanlisp gcl (and lispworks os-windows) mcl mkcl xcl) t)
     5398                     #+(or abcl cormanlisp gcl (and lispworks os-windows) mcl xcl) t)
    53895399                 '%use-system '%use-run-program)
    53905400             command
     
    54605470  (defun get-optimization-settings ()
    54615471    "Get current compiler optimization settings, ready to PROCLAIM again"
    5462     #-(or clisp clozure cmu ecl sbcl scl)
     5472    #-(or clisp clozure cmu ecl mkcl sbcl scl)
    54635473    (warn "~S does not support ~S. Please help me fix that." 'get-optimization-settings (implementation-type))
    54645474    #+clozure (ccl:declaration-information 'optimize nil)
    5465     #+(or clisp cmu ecl sbcl scl)
     5475    #+(or clisp cmu ecl mkcl sbcl scl)
    54665476    (let ((settings '(speed space safety debug compilation-speed #+(or cmu scl) c::brevity)))
    54675477      #.`(loop :for x :in settings
    54685478               ,@(or #+ecl '(:for v :in '(c::*speed* c::*space* c::*safety* c::*debug*))
     5479                     #+mkcl '(:for v :in '(si::*speed* si::*space* si::*safety* si::*debug*))
    54695480                     #+(or cmu scl) '(:for f :in '(c::cookie-speed c::cookie-space c::cookie-safety c::cookie-debug c::cookie-cspeed c::cookie-brevity)))
    54705481               :for y = (or #+clisp (gethash x system::*optimize*)
    5471                             #+(or ecl) (symbol-value v)
     5482                            #+(or ecl mkcl) (symbol-value v)
    54725483                            #+(or cmu scl) (funcall f c::*default-cookie*)
    54735484                            #+sbcl (cdr (assoc x sb-c::*policy*)))
     
    65246535   :uiop/run-program :uiop/lisp-build
    65256536   :uiop/configuration :uiop/backward-driver))
     6537
     6538#+mkcl (provide :uiop)
    65266539;;;; -------------------------------------------------------------------------
    65276540;;;; Handle upgrade as forward- and backward-compatibly as possible
     
    65606573  ;; We need to clear systems from versions yet older than the below:
    65616574  (defparameter *oldest-forward-compatible-asdf-version* "2.33") ;; 2.32.13 renames a slot in component.
    6562   (defmacro defparameter* (var value &optional docstring)
    6563     (let* ((name (string-trim "*" var))
    6564            (valfun (intern (format nil "%~A-~A-~A" :compute name :value)))
    6565            (clearfun (intern (format nil "%~A-~A" :clear name))))
    6566       `(progn
    6567          (defun ,valfun () ,value)
    6568          (defvar ,var (,valfun) ,@(ensure-list docstring))
    6569          (defun ,clearfun () (setf ,var (,valfun)))
    6570          (register-hook-function '*post-upgrade-cleanup-hook* ',clearfun))))
    65716575  (defvar *verbose-out* nil)
    65726576  (defun asdf-message (format-string &rest format-args)
     
    65776581    (and *previous-asdf-versions*
    65786582         (version< (first *previous-asdf-versions*) oldest-compatible-version)))
     6583  (defmacro defparameter* (var value &optional docstring (version *oldest-forward-compatible-asdf-version*))
     6584    (let* ((name (string-trim "*" var))
     6585           (valfun (intern (format nil "%~A-~A-~A" :compute name :value))))
     6586      `(progn
     6587         (defun ,valfun () ,value)
     6588         (defvar ,var (,valfun) ,@(ensure-list docstring))
     6589         (when (upgrading-p ,version)
     6590           (setf ,var (,valfun))))))
    65796591  (defmacro when-upgrading ((&key (version *oldest-forward-compatible-asdf-version*)
    65806592                               (upgrading-p `(upgrading-p ,version)) when) &body body)
     
    65946606         ;; "3.4.5.0.8" would be your eighth local modification of official release 3.4.5
    65956607         ;; "3.4.5.67.8" would be your eighth local modification of development version 3.4.5.67
    6596          (asdf-version "3.1.0.94")
     6608         (asdf-version "3.1.0.103")
    65976609         (existing-version (asdf-version)))
    65986610    (setf *asdf-version* asdf-version)
     
    70947106  (:use :uiop/common-lisp :uiop :asdf/upgrade)
    70957107  (:export #:get-file-stamp #:compute-file-stamp #:register-file-stamp
    7096            #:consult-asdf-cache #:do-asdf-cache #:normalize-namestring
     7108           #:set-asdf-cache-entry #:unset-asdf-cache-entry #:consult-asdf-cache
     7109     #:do-asdf-cache #:normalize-namestring
    70977110           #:call-with-asdf-cache #:with-asdf-cache #:*asdf-cache*))
    70987111(in-package :asdf/cache)
     
    71117124               (setf (gethash key *asdf-cache*) value-list)
    71127125               value-list)))
     7126
     7127  (defun unset-asdf-cache-entry (key)
     7128    (when *asdf-cache*
     7129      (remhash key *asdf-cache*)))
    71137130
    71147131  (defun consult-asdf-cache (key &optional thunk)
     
    71237140    `(consult-asdf-cache ,key #'(lambda () ,@body)))
    71247141
    7125   (defun call-with-asdf-cache (thunk &key override)
    7126     (if (and *asdf-cache* (not override))
    7127         (funcall thunk)
    7128         (let ((*asdf-cache* (make-hash-table :test 'equal)))
    7129           (funcall thunk))))
    7130 
    7131   (defmacro with-asdf-cache ((&key override) &body body)
    7132     `(call-with-asdf-cache #'(lambda () ,@body) :override ,override))
     7142  (defun call-with-asdf-cache (thunk &key override key)
     7143    (let ((fun (if key #'(lambda () (consult-asdf-cache key thunk)) thunk)))
     7144      (if (and *asdf-cache* (not override))
     7145          (funcall fun)
     7146          (let ((*asdf-cache* (make-hash-table :test 'equal)))
     7147            (funcall fun)))))
     7148
     7149  (defmacro with-asdf-cache ((&key key override) &body body)
     7150    `(call-with-asdf-cache #'(lambda () ,@body) :override ,override :key ,key))
    71337151
    71347152  (defun normalize-namestring (pathname)
     
    71597177  (:recycle :asdf/find-system :asdf)
    71607178  (:use :uiop/common-lisp :uiop :asdf/upgrade
    7161    :asdf/component :asdf/system :asdf/cache)
     7179    :asdf/cache :asdf/component :asdf/system)
    71627180  (:export
    71637181   #:remove-entry-from-registry #:coerce-entry-to-directory
    71647182   #:coerce-name #:primary-system-name #:coerce-filename
    7165    #:find-system #:locate-system #:load-asd #:with-system-definitions
     7183   #:find-system #:locate-system #:load-asd
    71667184   #:system-registered-p #:register-system #:registered-systems #:clear-system #:map-systems
    71677185   #:missing-component #:missing-requires #:missing-parent
     
    71707188   #:*system-definition-search-functions* #:search-for-system-definition
    71717189   #:*central-registry* #:probe-asd #:sysdef-central-registry-search
    7172    #:find-system-if-being-defined #:*systems-being-defined*
     7190   #:find-system-if-being-defined
    71737191   #:contrib-sysdef-search #:sysdef-find-asdf ;; backward compatibility symbols, functions removed
    71747192   #:sysdef-preloaded-system-search #:register-preloaded-system #:*preloaded-systems*
    7175    #:clear-defined-systems #:*defined-systems*
     7193   #:clear-defined-system #:clear-defined-systems #:*defined-systems*
    71767194   #:*immutable-systems*
    71777195   ;; defined in source-registry, but specially mentioned here:
     
    72447262                    system)))))
    72457263
     7264  (defun clear-defined-system (system)
     7265    (let ((name (coerce-name system)))
     7266      (remhash name *defined-systems*)
     7267      (unset-asdf-cache-entry `(locate-system ,name))
     7268      (unset-asdf-cache-entry `(find-system ,name))
     7269      nil))
     7270
    72467271  (defun clear-defined-systems ()
    72477272    ;; Invalidate all systems but ASDF itself, if registered.
    7248     (let ((asdf (cdr (system-registered-p :asdf))))
    7249       (setf *defined-systems* (make-hash-table :test 'equal))
    7250       (when asdf
    7251         (setf (component-version asdf) *asdf-version*)
    7252         (setf (builtin-system-p asdf) t)
    7253         (register-system asdf)))
    7254     (values))
     7273    (loop :for name :being :the :hash-keys :of *defined-systems*
     7274    :unless (equal name "asdf")
     7275      :do (clear-defined-system name)))
    72557276
    72567277  (register-hook-function '*post-upgrade-cleanup-hook* 'clear-defined-systems nil)
     
    74097430    (find-system (coerce-name name) error-p))
    74107431
    7411   (defvar *systems-being-defined* nil
    7412     "A hash-table of systems currently being defined keyed by name, or NIL")
    7413 
    74147432  (defun find-system-if-being-defined (name)
    7415     (when *systems-being-defined*
    7416       ;; notable side effect: mark the system as being defined, to avoid infinite loops
    7417       (ensure-gethash (coerce-name name) *systems-being-defined* nil)))
    7418 
    7419   (defun call-with-system-definitions (thunk)
    7420     (if *systems-being-defined*
    7421         (call-with-asdf-cache thunk)
    7422         (let ((*systems-being-defined* (make-hash-table :test 'equal)))
    7423           (call-with-asdf-cache thunk))))
    7424 
    7425   (defun clear-systems-being-defined ()
    7426     (when *systems-being-defined*
    7427       (clrhash *systems-being-defined*)))
    7428 
    7429   (register-hook-function '*post-upgrade-cleanup-hook* 'clear-systems-being-defined)
    7430 
    7431   (defmacro with-system-definitions ((&optional) &body body)
    7432     `(call-with-system-definitions #'(lambda () ,@body)))
     7433    ;; notable side effect: mark the system as being defined, to avoid infinite loops
     7434    (first (gethash `(find-system ,(coerce-name name)) *asdf-cache*)))
    74337435
    74347436  (defun load-asd (pathname &key name (external-format (encoding-external-format (detect-encoding pathname))) &aux (readtable *readtable*) (print-pprint-dispatch *print-pprint-dispatch*))
    74357437    ;; Tries to load system definition with canonical NAME from PATHNAME.
    7436     (with-system-definitions ()
     7438    (with-asdf-cache ()
    74377439      (with-standard-io-syntax
    74387440        (let ((*package* (find-package :asdf-user))
     
    75297531PREVIOUS when not null is a previously loaded SYSTEM object of same name.
    75307532PREVIOUS-TIME when not null is the time at which the PREVIOUS system was loaded."
    7531     (let* ((name (coerce-name name))
    7532            (in-memory (system-registered-p name)) ; load from disk if absent or newer on disk
    7533            (previous (cdr in-memory))
    7534            (previous (and (typep previous 'system) previous))
    7535            (previous-time (car in-memory))
    7536            (found (search-for-system-definition name))
    7537            (found-system (and (typep found 'system) found))
    7538            (pathname (ensure-pathname
    7539                       (or (and (typep found '(or pathname string)) (pathname found))
    7540                           (and found-system (system-source-file found-system))
    7541                           (and previous (system-source-file previous)))
    7542                      :want-absolute t :resolve-symlinks *resolve-symlinks*))
    7543            (foundp (and (or found-system pathname previous) t)))
    7544       (check-type found (or null pathname system))
    7545       (unless (check-not-old-asdf-system name pathname)
    7546         (cond
    7547           (previous (setf found nil pathname nil))
    7548           (t
    7549            (setf found (sysdef-preloaded-system-search "asdf"))
    7550            (assert (typep found 'system))
    7551            (setf found-system found pathname nil))))
    7552       (values foundp found-system pathname previous previous-time)))
     7533    (with-asdf-cache (:key `(locate-system ,name))
     7534      (let* ((name (coerce-name name))
     7535             (in-memory (system-registered-p name)) ; load from disk if absent or newer on disk
     7536             (previous (cdr in-memory))
     7537             (previous (and (typep previous 'system) previous))
     7538             (previous-time (car in-memory))
     7539             (found (search-for-system-definition name))
     7540             (found-system (and (typep found 'system) found))
     7541             (pathname (ensure-pathname
     7542                        (or (and (typep found '(or pathname string)) (pathname found))
     7543                            (and found-system (system-source-file found-system))
     7544                            (and previous (system-source-file previous)))
     7545                        :want-absolute t :resolve-symlinks *resolve-symlinks*))
     7546             (foundp (and (or found-system pathname previous) t)))
     7547        (check-type found (or null pathname system))
     7548        (unless (check-not-old-asdf-system name pathname)
     7549          (cond
     7550            (previous (setf found nil pathname nil))
     7551            (t
     7552             (setf found (sysdef-preloaded-system-search "asdf"))
     7553             (assert (typep found 'system))
     7554             (setf found-system found pathname nil))))
     7555        (values foundp found-system pathname previous previous-time))))
    75537556
    75547557  (defmethod find-system ((name string) &optional (error-p t))
    7555     (with-system-definitions ()
     7558    (with-asdf-cache (:key `(find-system ,name))
    75567559      (let ((primary-name (primary-system-name name)))
    7557         (unless (or (equal name primary-name)
    7558                     (nth-value 1 (gethash primary-name *systems-being-defined*)))
     7560        (unless (equal name primary-name)
    75597561          (find-system primary-name nil)))
    75607562      (loop
     
    75637565                (locate-system name)
    75647566              (when (and found-system (eq found-system previous)
    7565                          (or (gethash name *systems-being-defined*)
     7567                         (or (first (gethash `(find-system ,name) *asdf-cache*))
    75667568                             (and *immutable-systems* (gethash name *immutable-systems*))))
    75677569                (return found-system))
     
    75977599            :report (lambda (s)
    75987600                      (format s (compatfmt "~@<Retry finding system ~A after reinitializing the source-registry.~@:>") name))
     7601      (unset-asdf-cache-entry `(locate-system ,name))
    75997602            (initialize-source-registry)))))))
    76007603
     
    76047607(uiop/package:define-package :asdf/find-component
    76057608  (:recycle :asdf/find-component :asdf)
    7606   (:use :uiop/common-lisp :uiop :asdf/upgrade
     7609  (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/cache
    76077610   :asdf/component :asdf/system :asdf/find-system)
    76087611  (:export
     
    77077710                (and (typep c 'missing-dependency)
    77087711                     (eq (missing-required-by c) component)
    7709                      (equal (missing-requires c) name))))))))
     7712                     (equal (missing-requires c) name))))
     7713    (unless (component-parent component)
     7714      (let ((name (coerce-name name)))
     7715        (unset-asdf-cache-entry `(find-system ,name))
     7716        (unset-asdf-cache-entry `(locate-system ,name))))))))
     7717
    77107718
    77117719  (defun resolve-dependency-spec (component dep-spec)
     
    78467854           (opix (position operation formals))
    78477855           (coix (position component formals))
    7848 
    78497856           (prefix (subseq formals 0 opix))
    78507857           (suffix (subseq formals (1+ coix) len))
     
    79707977each of its declared dependencies must first be loaded as by LOAD-OP."))
    79717978  (defun sideway-operation-depends-on (o c)
    7972     `((,(or (sideway-operation o) o)
    7973        ,@(loop :for dep :in (component-sideway-dependencies c)
    7974                :collect (resolve-dependency-spec c dep)))))
     7979    `((,(or (sideway-operation o) o) ,@(component-sideway-dependencies c))))
    79757980  (defmethod component-depends-on ((o sideway-operation) (c component))
    79767981    `(,@(sideway-operation-depends-on o c) ,@(call-next-method)))
     
    88998904(uiop/package:define-package :asdf/operate
    89008905  (:recycle :asdf/operate :asdf)
    8901   (:use :uiop/common-lisp :uiop :asdf/upgrade
     8906  (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/cache
    89028907   :asdf/component :asdf/system :asdf/operation :asdf/action
    89038908   :asdf/find-system :asdf/find-component :asdf/lisp-action :asdf/plan)
     
    89058910   #:operate #:oos
    89068911   #:*systems-being-operated*
    8907    #:build-op #:build
     8912   #:build-op #:make
    89088913   #:load-system #:load-systems #:load-systems*
    89098914   #:compile-system #:test-system #:require-system
     
    89698974            (apply 'operate (funcall operation-remaker) component-path keys))))
    89708975      ;; Setup proper bindings around any operate call.
    8971       (with-system-definitions ()
     8976      (with-asdf-cache ()
    89728977        (let* ((*verbose-out* (and verbose *standard-output*))
    89738978               (*compile-file-warnings-behaviour* on-warnings)
     
    90059010The default operation may change in the future if we implement a
    90069011component-directed strategy for how to load or compile systems.")
     9012
     9013  (defmethod component-depends-on ((o prepare-op) (s system))
     9014    `((,*load-system-operation* ,@(component-sideway-dependencies s))))
    90079015
    90089016  (defclass build-op (non-propagating-operation) ()
     
    90179025    `((,(or (component-build-operation c) *load-system-operation*) ,c)))
    90189026
    9019   (defun build (system &rest keys)
    9020     "The recommended way to interact with ASDF3.1 is via (ASDF:BUILD :FOO).
     9027  (defun make (system &rest keys)
     9028    "The recommended way to interact with ASDF3.1 is via (ASDF:MAKE :FOO).
    90219029It will build system FOO using the operation BUILD-OP,
    90229030the meaning of which is configurable by the system, and
     
    91189126  (defun restart-upgraded-asdf ()
    91199127    ;; If we're in the middle of something, restart it.
    9120     (when *systems-being-defined*
    9121       (let ((l (loop :for name :being :the :hash-keys :of *systems-being-defined* :collect name)))
    9122         (clrhash *systems-being-defined*)
     9128    (when *asdf-cache*
     9129      (let ((l (loop* :for (x y) :being :the hash-keys :of *asdf-cache*
     9130                      :when (eq x 'find-system) :collect y)))
     9131        (clrhash *asdf-cache*)
    91239132        (dolist (s l) (find-system s nil)))))
    9124 
    91259133  (register-hook-function '*post-upgrade-restart-hook* 'restart-upgraded-asdf))
    91269134
     
    94559463   #:validate-source-registry-directive #:validate-source-registry-form
    94569464   #:validate-source-registry-file #:validate-source-registry-directory
    9457    #:parse-source-registry-string #:wrapping-source-registry #:default-source-registry
     9465   #:parse-source-registry-string #:wrapping-source-registry
     9466   #:default-user-source-registry #:default-system-source-registry
    94589467   #:user-source-registry #:system-source-registry
    94599468   #:user-source-registry-directory #:system-source-registry-directory
     
    95849593      user-source-registry
    95859594      user-source-registry-directory
     9595      default-user-source-registry
    95869596      system-source-registry
    95879597      system-source-registry-directory
    9588       default-source-registry))
     9598      default-system-source-registry)
     9599    "List of default source registries" "3.1.0.102")
    95899600
    95909601  (defparameter *source-registry-file* (parse-unix-namestring "source-registry.conf"))
     
    95949605    `(:source-registry
    95959606      #+(or ecl sbcl) (:tree ,(resolve-symlinks* (lisp-implementation-directory)))
     9607      :inherit-configuration
    95969608      #+mkcl (:tree ,(translate-logical-pathname "CONTRIB:"))
    9597       :inherit-configuration
    95989609      #+cmu (:tree #p"modules:")
    95999610      #+scl (:tree #p"file://modules/")))
    9600   (defun default-source-registry ()
     9611  (defun default-user-source-registry ()
    96019612    `(:source-registry
    9602       #+sbcl (:directory ,(subpathname (user-homedir-pathname) ".sbcl/systems/"))
     9613      (:tree (:home "common-lisp/"))
     9614      #+sbcl (:directory (:home ".sbcl/systems/"))
    96039615      ,@(loop :for dir :in
    96049616              `(,@(when (os-unix-p)
    96059617                    `(,(or (getenv-absolute-directory "XDG_DATA_HOME")
    9606                            (subpathname (user-homedir-pathname) ".local/share/"))
    9607                       ,@(or (getenv-absolute-directories "XDG_DATA_DIRS")
    9608                             '("/usr/local/share" "/usr/share"))))
     9618                           (subpathname (user-homedir-pathname) ".local/share/"))))
    96099619                ,@(when (os-windows-p)
    9610                     (mapcar 'get-folder-path '(:local-appdata :appdata :common-appdata))))
     9620                    (mapcar 'get-folder-path '(:local-appdata :appdata))))
     9621              :collect `(:directory ,(subpathname* dir "common-lisp/systems/"))
     9622              :collect `(:tree ,(subpathname* dir "common-lisp/source/")))
     9623      :inherit-configuration))
     9624  (defun default-system-source-registry ()
     9625    `(:source-registry
     9626      ,@(loop :for dir :in
     9627              `(,@(when (os-unix-p)
     9628                    (or (getenv-absolute-directories "XDG_DATA_DIRS")
     9629                        '("/usr/local/share" "/usr/share")))
     9630                ,@(when (os-windows-p)
     9631                    (list (get-folder-path :common-appdata))))
    96119632              :collect `(:directory ,(subpathname* dir "common-lisp/systems/"))
    96129633              :collect `(:tree ,(subpathname* dir "common-lisp/source/")))
     
    98269847  (:nicknames :asdf/defsystem) ;; previous name, to be compatible with, in case anyone cares
    98279848  (:use :uiop/common-lisp :asdf/driver :asdf/upgrade
    9828    :asdf/component :asdf/system :asdf/cache
     9849   :asdf/cache :asdf/component :asdf/system
    98299850   :asdf/find-system :asdf/find-component :asdf/lisp-action :asdf/operate
    98309851   :asdf/backward-internals)
     
    1005810079    ;; To avoid infinite recursion in cases where you defsystem a system
    1005910080    ;; that is registered to a different location to find-system,
    10060     ;; we also need to remember it in a special variable *systems-being-defined*.
    10061     (with-system-definitions ()
     10081    ;; we also need to remember it in the asdf-cache.
     10082    (with-asdf-cache ()
    1006210083      (let* ((name (coerce-name name))
    1006310084             (source-file (if sfp source-file (resolve-symlinks* (load-pathname))))
     
    1007810099                (append `(:defsystem-depends-on ,(parse-dependency-defs defsystem-depends-on))
    1007910100                        component-options)))
    10080         (setf (gethash name *systems-being-defined*) system)
     10101        (set-asdf-cache-entry `(find-system ,name) (list system))
    1008110102        (load-systems* defsystem-dependencies)
    1008210103        ;; We change-class AFTER we loaded the defsystem-depends-on
     
    1010210123  (:use :uiop/common-lisp :uiop :asdf/upgrade
    1010310124   :asdf/component :asdf/system :asdf/find-system :asdf/find-component :asdf/operation
    10104    :asdf/action :asdf/lisp-action :asdf/plan :asdf/operate)
     10125   :asdf/action :asdf/lisp-action :asdf/plan :asdf/operate :asdf/defsystem)
    1010510126  (:export
    10106    #:bundle-op #:bundle-op-build-args #:bundle-type
     10127   #:bundle-op #:bundle-type #:program-system
    1010710128   #:bundle-system #:bundle-pathname-type #:bundlable-file-p #:direct-dependency-files
    1010810129   #:monolithic-op #:monolithic-bundle-op #:operation-monolithic-p
    10109    #:basic-fasl-op #:prepare-fasl-op #:fasl-op #:load-fasl-op #:monolithic-fasl-op
     10130   #:fasl-op #:load-fasl-op #:monolithic-fasl-op #:binary-op #:monolithic-binary-op
     10131   #:basic-compile-bundle-op #:prepare-bundle-op
     10132   #:compile-bundle-op #:load-bundle-op #:monolithic-compile-bundle-op #:monolithic-load-bundle-op
    1011010133   #:lib-op #:monolithic-lib-op
    1011110134   #:dll-op #:monolithic-dll-op
     
    1011310136   #:program-op #:image-op #:compiled-file #:precompiled-system #:prebuilt-system
    1011410137   #:user-system-p #:user-system #:trivial-system-p
    10115    #+ecl #:make-build
    10116    #:register-pre-built-system
     10138   #:make-build
    1011710139   #:build-args #:name-suffix #:prologue-code #:epilogue-code #:static-library))
    1011810140(in-package :asdf/bundle)
     
    1012010142(with-upgradability ()
    1012110143  (defclass bundle-op (basic-compile-op)
    10122     ((build-args :initarg :args :initform nil :accessor bundle-op-build-args)
     10144    ((build-args :initarg :args :initform nil :accessor extra-build-args)
    1012310145     (name-suffix :initarg :name-suffix :initform nil)
    1012410146     (bundle-type :initform :no-output-file :reader bundle-type)
    10125      #+ecl (lisp-files :initform nil :accessor bundle-op-lisp-files)
    10126      #+mkcl (do-fasb :initarg :do-fasb :initform t :reader bundle-op-do-fasb-p)
    10127      #+mkcl (do-static-library :initarg :do-static-library :initform t :reader bundle-op-do-static-library-p)))
     10147     #+ecl (lisp-files :initform nil :accessor extra-object-files)))
    1012810148
    1012910149  (defclass monolithic-op (operation) ()
     
    1013610156  (defclass monolithic-bundle-op (monolithic-op bundle-op)
    1013710157    ;; Old style way of specifying prologue and epilogue on ECL: in the monolithic operation
    10138     ((prologue-code :accessor prologue-code)
    10139      (epilogue-code :accessor epilogue-code)))
    10140 
    10141   (defclass bundle-system (system)
     10158    ((prologue-code :initform nil :accessor prologue-code)
     10159     (epilogue-code :initform nil :accessor epilogue-code)))
     10160
     10161  (defclass program-system (system)
    1014210162    ;; New style (ASDF3.1) way of specifying prologue and epilogue on ECL: in the system
    10143     ((prologue-code :accessor prologue-code)
    10144      (epilogue-code :accessor epilogue-code)))
     10163    ((prologue-code :initform nil :initarg :prologue-code :reader prologue-code)
     10164     (epilogue-code :initform nil :initarg :epilogue-code :reader epilogue-code)
     10165     (prefix-lisp-object-files :initarg :prefix-lisp-object-files
     10166                               :initform nil :accessor prefix-lisp-object-files)
     10167     (postfix-lisp-object-files :initarg :postfix-lisp-object-files
     10168                                :initform nil :accessor postfix-lisp-object-files)
     10169     (extra-object-files :initarg :extra-object-files
     10170                         :initform nil :accessor extra-object-files)
     10171     (extra-build-args :initarg :extra-build-args
     10172                       :initform nil :accessor extra-build-args)))
    1014510173
    1014610174  (defmethod prologue-code ((x t)) nil)
    1014710175  (defmethod epilogue-code ((x t)) nil)
     10176  (defmethod prefix-lisp-object-files ((x t)) nil)
     10177  (defmethod postfix-lisp-object-files ((x t)) nil)
     10178  (defmethod extra-object-files ((x t)) nil)
     10179  (defmethod extra-build-args ((x t)) nil)
    1014810180
    1014910181  (defclass link-op (bundle-op) ()
     
    1017010202
    1017110203  ;; create a single fasl for the entire library
    10172   (defclass basic-fasl-op (bundle-op)
     10204  (defclass basic-compile-bundle-op (bundle-op)
    1017310205    ((bundle-type :initform :fasl)))
    1017410206
    10175   (defclass prepare-fasl-op (sideway-operation)
    10176     ((sideway-operation :initform #+ecl 'load-fasl-op #-ecl 'load-op :allocation :class)))
     10207  (defclass prepare-bundle-op (sideway-operation)
     10208    ((sideway-operation :initform #+(or ecl mkcl) 'load-bundle-op #-(or ecl mkcl) 'load-op
     10209                        :allocation :class)))
    1017710210
    1017810211  (defclass lib-op (link-op gather-op non-propagating-operation)
     
    1018010213    (:documentation "compile the system and produce linkable (.a) library for it."))
    1018110214
    10182   (defclass fasl-op (basic-fasl-op selfward-operation #+ecl link-op #-ecl gather-op)
    10183     ((selfward-operation :initform '(prepare-fasl-op #+ecl lib-op) :allocation :class)))
    10184 
    10185   (defclass load-fasl-op (basic-load-op selfward-operation)
    10186     ((selfward-operation :initform '(prepare-op fasl-op) :allocation :class)))
     10215  (defclass compile-bundle-op (basic-compile-bundle-op selfward-operation
     10216                               #+(or ecl mkcl) link-op #-ecl gather-op)
     10217    ((selfward-operation :initform '(prepare-bundle-op #+ecl lib-op) :allocation :class)))
     10218
     10219  (defclass load-bundle-op (basic-load-op selfward-operation)
     10220    ((selfward-operation :initform '(prepare-bundle-op compile-bundle-op) :allocation :class)))
    1018710221
    1018810222  ;; NB: since the monolithic-op's can't be sideway-operation's,
    1018910223  ;; if we wanted lib-op, dll-op, deliver-asd-op to be sideway-operation's,
    1019010224  ;; we'd have to have the monolithic-op not inherit from the main op,
    10191   ;; but instead inherit from a basic-FOO-op as with basic-fasl-op above.
     10225  ;; but instead inherit from a basic-FOO-op as with basic-compile-bundle-op above.
    1019210226
    1019310227  (defclass dll-op (link-op gather-op non-propagating-operation)
     
    1019610230
    1019710231  (defclass deliver-asd-op (basic-compile-op selfward-operation)
    10198     ((selfward-operation :initform '(fasl-op #+(or ecl mkcl) lib-op) :allocation :class))
     10232    ((selfward-operation :initform '(compile-bundle-op #+(or ecl mkcl) lib-op) :allocation :class))
    1019910233    (:documentation "produce an asd file for delivering the system as a single fasl"))
    1020010234
    1020110235
    1020210236  (defclass monolithic-deliver-asd-op (monolithic-bundle-op deliver-asd-op)
    10203     ((selfward-operation :initform '(monolithic-fasl-op #+(or ecl mkcl) monolithic-lib-op)
     10237    ((selfward-operation :initform '(monolithic-compile-bundle-op #+(or ecl mkcl) monolithic-lib-op)
    1020410238                         :allocation :class))
    1020510239    (:documentation "produce fasl and asd files for combined system and dependencies."))
    1020610240
    10207   (defclass monolithic-fasl-op (monolithic-bundle-op basic-fasl-op
    10208                                 #+ecl link-op gather-op non-propagating-operation)
    10209     ((gather-op :initform #+(or ecl mkcl) 'lib-op #-(or ecl mkcl) 'fasl-op :allocation :class))
     10241  (defclass monolithic-compile-bundle-op (monolithic-bundle-op basic-compile-bundle-op
     10242                                          #+(or ecl mkcl) link-op gather-op non-propagating-operation)
     10243    ((gather-op :initform #+(or ecl mkcl) 'lib-op #-(or ecl mkcl) 'compile-bundle-op :allocation :class))
    1021010244    (:documentation "Create a single fasl for the system and its dependencies."))
     10245
     10246  (defclass monolithic-load-bundle-op (monolithic-bundle-op load-bundle-op)
     10247    ((selfward-operation :initform 'monolithic-compile-bundle-op :allocation :class))
     10248    (:documentation "Load a single fasl for the system and its dependencies."))
    1021110249
    1021210250  (defclass monolithic-lib-op (monolithic-bundle-op lib-op non-propagating-operation) ()
     
    1021810256
    1021910257  (defclass image-op (monolithic-bundle-op selfward-operation
    10220                       #+ecl link-op #+(or ecl mkcl) gather-op)
     10258                      #+(or ecl mkcl) link-op #+(or ecl mkcl) gather-op)
    1022110259    ((bundle-type :initform :image)
    10222      (selfward-operation :initform '(#-ecl load-op) :allocation :class))
     10260     (selfward-operation :initform '(#-(or ecl mkcl) load-op) :allocation :class))
    1022310261    (:documentation "create an image file from the system and its dependencies"))
    1022410262
     
    1023610274       (compile-file-type :type bundle-type))
    1023710275      ((member :image) "image")
    10238       ((eql :dll) (cond ((os-macosx-p) "dylib") ((os-unix-p) "so") ((os-windows-p) "dll")))
    10239       ((member :lib :static-library) (cond ((os-unix-p) "a") ((os-windows-p) "lib")))
     10276      ((member :dll :shared-library) (cond ((os-macosx-p) "dylib") ((os-unix-p) "so") ((os-windows-p) "dll")))
     10277      ((member :lib :static-library) (cond ((os-unix-p) "a")
     10278             ((os-windows-p) (if (featurep '(:or :mingw32 :mingw64)) "a" "lib"))))
    1024010279      ((eql :program) (cond ((os-unix-p) nil) ((os-windows-p) "exe")))))
    1024110280
     
    1025410293
    1025510294  #-(or ecl mkcl)
    10256   (defmethod perform ((o program-op) (c system))
    10257     (let ((output-file (output-file o c)))
    10258       (setf *image-entry-point* (ensure-function (component-entry-point c)))
    10259       (dump-image output-file :executable t)))
     10295  (progn
     10296    (defmethod perform ((o image-op) (c system))
     10297      (dump-image (output-file o c) :executable (typep o 'program-op)))
     10298    (defmethod perform :before ((o program-op) (c system))
     10299      (setf *image-entry-point* (ensure-function (component-entry-point c)))))
    1026010300
    1026110301  (defclass compiled-file (file-component)
     
    1028610326      (setf (slot-value instance 'name-suffix)
    1028710327            (unless (typep instance 'program-op)
    10288               (if (operation-monolithic-p instance) "--all-systems" #-ecl "--system")))) ; . no good for Logical Pathnames
     10328              (if (operation-monolithic-p instance) "--all-systems" #-(or ecl mkcl) "--system")))) ; . no good for Logical Pathnames
    1028910329    (when (typep instance 'monolithic-bundle-op)
    1029010330      (destructuring-bind (&key lisp-files prologue-code epilogue-code
     
    1029310333        (setf (prologue-code instance) prologue-code
    1029410334              (epilogue-code instance) epilogue-code)
    10295         #-ecl (assert (null (or lisp-files epilogue-code prologue-code)))
    10296         #+ecl (setf (bundle-op-lisp-files instance) lisp-files)))
    10297     (setf (bundle-op-build-args instance)
     10335        #-ecl (assert (null (or lisp-files #-mkcl epilogue-code #-mkcl prologue-code)))
     10336        #+ecl (setf (extra-object-files instance) lisp-files)))
     10337    (setf (extra-build-args instance)
    1029810338          (remove-plist-keys
    1029910339           '(:type :monolithic :name-suffix :epilogue-code :prologue-code :lisp-files)
     
    1030510345      (or #+ecl (or (equalp type (compile-file-type :type :object))
    1030610346                    (equalp type (compile-file-type :type :static-library)))
    10307           #+mkcl (equalp type (compile-file-type :fasl-p nil))
     10347          #+mkcl (or (equalp type (compile-file-type :fasl-p nil))
     10348                     #+(or unix mingw32 mingw64) (equalp type "a") ;; valid on Unix and MinGW
     10349                     #+(and windows (not (or mingw32 mingw64))) (equalp type "lib"))
    1030810350          #+(or abcl allegro clisp clozure cmu lispworks sbcl scl xcl) (equalp type (compile-file-type)))))
    1030910351
     
    1032710369;;;
    1032810370(with-upgradability ()
    10329   (defmethod component-depends-on :around ((o bundle-op) (c component))
    10330     (if-let (op (and (eq (type-of o) 'bundle-op) (component-build-operation c)))
    10331       `((,op ,c))
    10332       (call-next-method)))
    10333 
    1033410371  (defun direct-dependency-files (o c &key (test 'identity) (key 'output-files) &allow-other-keys)
    1033510372    ;; This file selects output files from direct dependencies;
     
    1035210389       (if monolithic 'monolithic-lib-op 'lib-op))
    1035310390      ((:fasl)
    10354        (if monolithic 'monolithic-fasl-op 'fasl-op))
     10391       (if monolithic 'monolithic-compile-bundle-op 'compile-bundle-op))
    1035510392      ((:image)
    1035610393       'image-op)
     
    1035810395       'program-op)))
    1035910396
    10360   ;; This is originally from asdf-ecl.lisp. Does anyone use it?
     10397  ;; DEPRECATED. This is originally from asdf-ecl.lisp. Does anyone use it?
    1036110398  (defun make-build (system &rest args &key (monolithic nil) (type :fasl)
    1036210399                             (move-here nil move-here-p)
     
    1038110418                :do (rename-file-overwriting-target f new-f)
    1038210419                :collect new-f)
    10383           files))))
     10420          files)))
     10421
     10422  ;; DEPRECATED. Does anyone use this?
     10423  (defun bundle-system (system &rest args &key force (verbose t) version &allow-other-keys)
     10424    (declare (ignore force verbose version))
     10425    (apply #'operate 'deliver-asd-op system args)))
    1038410426
    1038510427;;;
    10386 ;;; LOAD-FASL-OP
     10428;;; LOAD-BUNDLE-OP
    1038710429;;;
    10388 ;;; This is like ASDF's LOAD-OP, but using monolithic fasl files.
     10430;;; This is like ASDF's LOAD-OP, but using bundle fasl files.
    1038910431;;;
    1039010432(with-upgradability ()
    10391   (defmethod component-depends-on ((o load-fasl-op) (c system))
    10392     `((,o ,@(loop :for dep :in (component-sideway-dependencies c)
    10393                   :collect (resolve-dependency-spec c dep)))
    10394       (,(if (user-system-p c) 'fasl-op 'load-op) ,c)
     10433  (defmethod component-depends-on ((o load-bundle-op) (c system))
     10434    `((,o ,@(component-sideway-dependencies c))
     10435      (,(if (user-system-p c) 'compile-bundle-op 'load-op) ,c)
    1039510436      ,@(call-next-method)))
    1039610437
    10397   (defmethod input-files ((o load-fasl-op) (c system))
     10438  (defmethod input-files ((o load-bundle-op) (c system))
    1039810439    (when (user-system-p c)
    10399       (output-files (find-operation o 'fasl-op) c)))
    10400 
    10401   (defmethod perform ((o load-fasl-op) (c system))
     10440      (output-files (find-operation o 'compile-bundle-op) c)))
     10441
     10442  (defmethod perform ((o load-bundle-op) (c system))
    1040210443    (when (input-files o c)
    1040310444      (perform-lisp-load-fasl o c)))
    1040410445
    10405   (defmethod mark-operation-done :after ((o load-fasl-op) (c system))
     10446  (defmethod mark-operation-done :after ((o load-bundle-op) (c system))
    1040610447    (mark-operation-done (find-operation o 'load-op) c)))
    1040710448
     
    1042210463  (defmethod perform ((o load-source-op) (c compiled-file))
    1042310464    (perform (find-operation o 'load-op) c))
    10424   (defmethod perform ((o load-fasl-op) (c compiled-file))
    10425     (perform (find-operation o 'load-op) c))
    1042610465  (defmethod perform ((o operation) (c compiled-file))
    1042710466    nil))
     
    1043410473    t)
    1043510474
     10475  (defmethod perform ((o link-op) (c prebuilt-system))
     10476    nil)
     10477
     10478  (defmethod perform ((o basic-compile-bundle-op) (c prebuilt-system))
     10479    nil)
     10480
    1043610481  (defmethod perform ((o lib-op) (c prebuilt-system))
    1043710482    nil)
    1043810483
    10439   (defmethod component-depends-on ((o lib-op) (c prebuilt-system))
     10484  (defmethod perform ((o dll-op) (c prebuilt-system))
    1044010485    nil)
    1044110486
    10442   (defmethod component-depends-on ((o monolithic-lib-op) (c prebuilt-system))
    10443     nil))
     10487  (defmethod component-depends-on ((o gather-op) (c prebuilt-system))
     10488    nil)
     10489
     10490  (defmethod output-files ((o lib-op) (c prebuilt-system))
     10491    (values (list (prebuilt-system-static-library c)) t)))
    1044410492
    1044510493
     
    1045810506           (asd (first (output-files o s)))
    1045910507           (name (if (and fasl asd) (pathname-name asd) (return-from perform)))
     10508           (version (component-version s))
    1046010509           (dependencies
    1046110510             (if (operation-monolithic-p o)
     
    1048710536          (pprint `(defsystem ,name
    1048810537                     :class prebuilt-system
     10538                     :version ,version
    1048910539                     :depends-on ,depends-on
    1049010540                     :components ((:compiled-file ,(pathname-name fasl)))
     
    1049410544
    1049510545  #-(or ecl mkcl)
    10496   (defmethod perform ((o basic-fasl-op) (c system))
     10546  (defmethod perform ((o basic-compile-bundle-op) (c system))
    1049710547    (let* ((input-files (input-files o c))
    1049810548           (fasl-files (remove (compile-file-type) input-files :key #'pathname-type :test-not #'equalp))
     
    1051310563
    1051410564  (defmethod input-files ((o load-op) (s precompiled-system))
    10515     (bundle-output-files (find-operation o 'fasl-op) s))
     10565    (bundle-output-files (find-operation o 'compile-bundle-op) s))
    1051610566
    1051710567  (defmethod perform ((o load-op) (s precompiled-system))
    1051810568    (perform-lisp-load-fasl o s))
    1051910569
    10520   (defmethod component-depends-on ((o load-fasl-op) (s precompiled-system))
     10570  (defmethod component-depends-on ((o load-bundle-op) (s precompiled-system))
    1052110571    #+xcl (declare (ignorable o))
    1052210572    `((load-op ,s) ,@(call-next-method))))
     
    1052910579#+(or ecl mkcl)
    1053010580(with-upgradability ()
    10531   (defun uiop-library-file ()
    10532     (or (and (find-system :uiop nil)
    10533              (system-source-directory :uiop)
    10534              (progn
    10535                (operate 'lib-op :uiop)
    10536                (output-file 'lib-op :uiop)))
    10537         (resolve-symlinks* (c::compile-file-pathname "sys:asdf" :type :lib))))
    10538   (defmethod input-files :around ((o program-op) (c system))
    10539     (let ((files (call-next-method))
    10540           (plan (traverse-sub-actions o c :plan-class 'sequential-plan)))
    10541       (unless (or (and (system-source-directory :uiop)
    10542                        (plan-operates-on-p plan '("uiop")))
    10543                   (and (system-source-directory :asdf)
    10544                        (plan-operates-on-p plan '("asdf"))))
    10545         (pushnew (uiop-library-file) files :test 'pathname-equal))
    10546       files))
    10547 
    10548   (defun register-pre-built-system (name)
    10549     (register-system (make-instance 'system :name (coerce-name name) :source-file nil))))
    10550 
    10551 #+ecl
    10552 (with-upgradability ()
    10553   ;; I think that Juanjo intended for this to be.
    10554   ;; But it might break systems with missing dependencies,
    10555   ;; and there is a weird bug in test-xach-update-bug.script
    10556   ;;(unless (use-ecl-byte-compiler-p)
    10557   ;;  (setf *load-system-operation* 'load-fasl-op))
     10581  ;; I think that Juanjo intended for this to be,
     10582  ;; but beware the weird bug in test-xach-update-bug.script,
     10583  ;; and also it makes mkcl fail test-logical-pathname.script,
     10584  ;; and ecl fail test-bundle.script.
     10585  ;;(unless (or #+ecl (use-ecl-byte-compiler-p))
     10586  ;;  (setf *load-system-operation* 'load-bundle-op))
     10587
     10588  (defun asdf-library-pathname ()
     10589    #+ecl (compile-file-pathname "sys:asdf" :type :lib)
     10590    #+mkcl (make-pathname :type (bundle-pathname-type :lib) :defaults #p"sys:contrib;asdf"))
     10591
     10592  (defun make-library-system (name pathname)
     10593    (make-instance 'prebuilt-system :name name :static-library (resolve-symlinks* pathname)))
     10594
     10595  (defmethod component-depends-on :around ((o image-op) (c system))
     10596    (destructuring-bind ((lib-op . deps)) (call-next-method)
     10597      (flet ((has-it-p (x) (find x deps :test 'equal :key 'coerce-name)))
     10598        `((,lib-op
     10599           #+mkcl ,@(unless (has-it-p "cmp")
     10600                      `(,(make-library-system
     10601                          "cmp" (make-pathname :type (bundle-pathname-type :lib)
     10602                                               :defaults #p"sys:cmp"))))
     10603           ,@(unless (or (has-it-p "asdf") (has-it-p "uiop"))
     10604               `(,(cond
     10605                    ((system-source-directory :uiop) (find-system :uiop))
     10606                    ((system-source-directory :asdf) (find-system :asdf))
     10607                    (t (make-fake-asdf-system "asdf" (asdf-library-pathname))))))
     10608           ,@deps)))))
    1055810609
    1055910610  (defmethod perform ((o link-op) (c system))
     
    1056110612           (output (output-files o c))
    1056210613           (bundle (first output))
    10563            (targetp (eq (type-of o) (component-build-operation c)))
     10614           (programp (typep o 'program-op))
    1056410615           (kind (bundle-type o)))
    1056510616      (when output
    1056610617        (apply 'create-image
    10567                bundle (append object-files (bundle-op-lisp-files o))
     10618               bundle (append
     10619                       (when programp (prefix-lisp-object-files c))
     10620                       object-files
     10621                       (when programp (postfix-lisp-object-files c)))
    1056810622               :kind kind
    10569                :prologue-code (or (prologue-code o) (when targetp (prologue-code c)))
    10570                :epilogue-code (or (epilogue-code o) (when targetp (epilogue-code c)))
    10571                :build-args (bundle-op-build-args o)
    10572                (when targetp `(:entry-point ,(component-entry-point c))))))))
    10573 
    10574 #+mkcl
    10575 (with-upgradability ()
    10576   (defmethod perform ((o lib-op) (s system))
    10577     (apply #'compiler::build-static-library (output-file o c)
    10578            :lisp-object-files (input-files o s) (bundle-op-build-args o)))
    10579 
    10580   (defmethod perform ((o basic-fasl-op) (s system))
    10581     (apply #'compiler::build-bundle (output-file o c) ;; second???
    10582            :lisp-object-files (input-files o s) (bundle-op-build-args o)))
    10583 
    10584   (defun bundle-system (system &rest args &key force (verbose t) version &allow-other-keys)
    10585     (declare (ignore force verbose version))
    10586     (apply #'operate 'deliver-asd-op system args)))
     10623               :prologue-code (or (prologue-code o) (when programp (prologue-code c)))
     10624               :epilogue-code (or (epilogue-code o) (when programp (epilogue-code c)))
     10625               :build-args (or (extra-build-args o) (when programp (extra-build-args c)))
     10626               :extra-object-files (or (extra-object-files o) (when programp (extra-object-files c)))
     10627               (when programp `(:entry-point ,(component-entry-point c))))))))
    1058710628
    1058810629#+(and (not asdf-use-unsafe-mac-bundle-op)
    1058910630       (or (and ecl darwin)
    1059010631           (and abcl darwin (not abcl-bundle-op-supported))))
    10591 (defmethod perform :before ((o basic-fasl-op) (c component))
     10632(defmethod perform :before ((o basic-compile-bundle-op) (c component))
    1059210633  (unless (featurep :asdf-use-unsafe-mac-bundle-op)
    1059310634    (cerror "Continue after modifying *FEATURES*."
    10594             "BASIC-FASL-OP bundle operations are not supported on Mac OS X for this lisp.~%~T~
     10635            "BASIC-COMPILE-BUNDLE-OP operations are not supported on Mac OS X for this lisp.~%~T~
    1059510636To continue, push :asdf-use-unsafe-mac-bundle-op onto *FEATURES*.~%~T~
    1059610637Please report to ASDF-DEVEL if this works for you.")))
     10638
     10639
     10640;;; Backward compatibility with pre-3.1.1 names
     10641(defclass fasl-op (selfward-operation)
     10642  ((selfward-operation :initform 'compile-bundle-op :allocation :class)))
     10643(defclass load-fasl-op (selfward-operation)
     10644  ((selfward-operation :initform 'load-bundle-op :allocation :class)))
     10645(defclass binary-op (selfward-operation)
     10646  ((selfward-operation :initform 'deliver-asd-op :allocation :class)))
     10647(defclass monolithic-fasl-op (selfward-operation)
     10648  ((selfward-operation :initform 'monolithic-compile-bundle-op :allocation :class)))
     10649(defclass monolithic-load-fasl-op (selfward-operation)
     10650  ((selfward-operation :initform 'monolithic-load-bundle-op :allocation :class)))
     10651(defclass monolithic-binary-op (selfward-operation)
     10652  ((selfward-operation :initform 'monolithic-deliver-asd-op :allocation :class)))
    1059710653;;;; -------------------------------------------------------------------------
    1059810654;;;; Concatenate-source
     
    1067410730
    1067510731  (defmethod perform ((o basic-concatenate-source-op) (s system))
    10676     (let ((inputs (input-files o s))
    10677           (output (output-file o s)))
    10678       (concatenate-files inputs output)))
     10732    (let* ((ins (input-files o s))
     10733           (out (output-file o s))
     10734           (tmp (tmpize-pathname out)))
     10735      (concatenate-files ins tmp)
     10736      (rename-file-overwriting-target tmp out)))
    1067910737  (defmethod perform ((o basic-load-concatenated-source-op) (s system))
    1068010738    (perform-lisp-load-source o s))
     
    1099011048  (:recycle :asdf/interface :asdf)
    1099111049  (:unintern
    10992    #:*asdf-revision* #:around #:asdf-method-combination
    10993    #:do-traverse #:do-dep #:do-one-dep #:visit-action #:component-visited-p
    10994    #:split #:make-collector
    1099511050   #:loaded-systems ; makes for annoying SLIME completion
    10996    #:output-files-for-system-and-operation) ; obsolete ASDF-BINARY-LOCATION function
     11051   #:output-files-for-system-and-operation) ; ASDF-BINARY-LOCATION function we use to detect ABL
    1099711052  (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/cache
    1099811053   :asdf/component :asdf/system :asdf/find-system :asdf/find-component
     
    1100111056   :asdf/plan :asdf/operate :asdf/parse-defsystem :asdf/bundle :asdf/concatenate-source
    1100211057   :asdf/backward-internals :asdf/backward-interface :asdf/package-system)
    11003   ;; TODO: automatically generate interface with reexport?
     11058  ;; Note: (1) we are NOT automatically reexporting everything from previous packages.
     11059  ;; (2) we only reexport UIOP functionality when backward-compatibility requires it.
    1100411060  (:export
    1100511061   #:defsystem #:find-system #:locate-system #:coerce-name #:primary-system-name
    1100611062   #:oos #:operate #:make-plan #:perform-plan #:sequential-plan
    11007    #:system-definition-pathname #:with-system-definitions
     11063   #:system-definition-pathname
    1100811064   #:search-for-system-definition #:find-component #:component-find-path
    1100911065   #:compile-system #:load-system #:load-systems #:load-systems*
     
    1101211068   #:upward-operation #:downward-operation #:sideway-operation #:selfward-operation
    1101311069                      #:non-propagating-operation
    11014    #:build-op #:build
     11070   #:build-op #:make
    1101511071   #:load-op #:prepare-op #:compile-op
    1101611072   #:prepare-source-op #:load-source-op #:test-op
    1101711073   #:feature #:version #:version-satisfies #:upgrade-asdf
    1101811074   #:implementation-identifier #:implementation-type #:hostname
    11019    #:input-files #:output-files #:output-file #:perform
     11075   #:input-files #:output-files #:output-file #:perform #:perform-with-restarts
    1102011076   #:operation-done-p #:explain #:action-description #:component-sideway-dependencies
    1102111077   #:needed-in-image-p
    11022    ;; #:run-program ; we can't export it, because SB-GROVEL :use's both ASDF and SB-EXT.
    1102311078   #:component-load-dependencies #:run-shell-command ; deprecated, do not use
    1102411079   #:bundle-op #:monolithic-bundle-op #:precompiled-system #:compiled-file #:bundle-system
    11025    #+ecl #:make-build
    11026    #:basic-fasl-op #:prepare-fasl-op #:fasl-op #:load-fasl-op #:monolithic-fasl-op
     11080   #:program-system #:make-build
     11081   #:fasl-op #:load-fasl-op #:monolithic-fasl-op #:binary-op #:monolithic-binary-op
     11082   #:basic-compile-bundle-op #:prepare-bundle-op
     11083   #:compile-bundle-op #:load-bundle-op #:monolithic-compile-bundle-op #:monolithic-load-bundle-op
    1102711084   #:lib-op #:dll-op #:deliver-asd-op #:program-op #:image-op
    1102811085   #:monolithic-lib-op #:monolithic-dll-op #:monolithic-deliver-asd-op
     
    1118611243  #+(or ecl mkcl)
    1118711244  (progn
    11188     (pushnew '("fasb" . si::load-binary) si:*load-hooks* :test 'equal :key 'car)
     11245    (pushnew '("fasb" . si::load-binary) si::*load-hooks* :test 'equal :key 'car)
    1118911246
    1119011247    #+(or (and ecl win32) (and mkcl windows))
Note: See TracChangeset for help on using the changeset viewer.