Changeset 14150


Ignore:
Timestamp:
09/08/12 08:14:05 (9 years ago)
Author:
Mark Evenson
Message:

Upgrade to asdf-2.24.

Location:
trunk/abcl
Files:
2 edited

Legend:

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

    r14013 r14150  
    221221As of the writing of this manual,
    222222the following implementations provide ASDF 2 this way:
    223 abcl allegro ccl clisp cmucl ecl lispworks sbcl xcl.
     223abcl allegro ccl clisp cmucl ecl lispworks mkcl sbcl xcl.
    224224The following implementation doesn't provide it yet but will in a future release:
    225225scl.
    226226The following implementations are obsolete, not actively maintained,
    227227and most probably will never bundle it:
    228 cormancl gcl genera mcl.
     228cormanlisp gcl genera mcl.
    229229
    230230If the implementation you are using doesn't provide ASDF 2,
     
    638638
    639639On some implementations (namely recent versions of
    640 ABCL, Clozure CL, CLISP, CMUCL, ECL, SBCL and SCL),
     640ABCL, Allegro CL, Clozure CL, CMUCL, ECL, GNU CLISP, LispWorks, MKCL, SBCL and XCL),
    641641ASDF hooks into the @code{CL:REQUIRE} facility
    642642and you can just use:
     
    29182918
    29192919Note that there is no around-load hook. This is on purpose.
    2920 Some implementations such as ECL or GCL link object files,
     2920Some implementations such as ECL, GCL or MKCL link object files,
    29212921which allows for no such hook.
    29222922Other implementations allow for concatenating FASL files,
  • trunk/abcl/src/org/armedbear/lisp/asdf.lisp

    r14013 r14150  
    11;;; -*- mode: Common-Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp ; coding: utf-8 -*-
    2 ;;; This is ASDF 2.23: Another System Definition Facility.
     2;;; This is ASDF 2.24: Another System Definition Facility.
    33;;;
    44;;; Feedback, bug reports, and patches are all welcome:
     
    5151#+genera (in-package :future-common-lisp-user)
    5252
    53 #-(or abcl allegro clisp clozure cmu cormanlisp ecl gcl genera lispworks mcl sbcl scl xcl)
     53#-(or abcl allegro clisp clozure cmu cormanlisp ecl gcl genera lispworks mcl mkcl sbcl scl xcl)
    5454(error "ASDF is not supported on your implementation. Please help us port it.")
    5555
     
    7272                 (< system::*gcl-minor-version* 7)))
    7373    (pushnew :gcl-pre2.7 *features*))
    74   #+(or abcl (and allegro ics) (and clisp unicode) clozure (and cmu unicode)
    75         (and ecl unicode) lispworks (and sbcl sb-unicode) scl)
     74  #+(or abcl (and allegro ics) (and (or clisp cmu ecl mkcl) unicode)
     75        clozure lispworks (and sbcl sb-unicode) scl)
    7676  (pushnew :asdf-unicode *features*)
    7777  ;;; make package if it doesn't exist yet.
     
    8787  #+ecl (defun use-ecl-byte-compiler-p () (and (member :ecl-bytecmp *features*) t))
    8888  #+ecl (unless (use-ecl-byte-compiler-p) (require :cmp))
     89  #+mkcl (require :cmp)
     90  #+mkcl (setq clos::*redefine-class-in-place* t) ;; Make sure we have strict ANSI class redefinition semantics
    8991
    9092  ;;; Package setup, step 2.
     
    117119         ;; "2.345.0.7" would be your seventh local modification of official release 2.345
    118120         ;; "2.345.6.7" would be your seventh local modification of development version 2.345.6
    119          (asdf-version "2.23")
     121         (asdf-version "2.24")
    120122         (existing-asdf (find-class 'component nil))
    121123         (existing-version *asdf-version*)
     
    304306            #:*compile-file-failure-behaviour*
    305307            #:*resolve-symlinks*
    306             #:*require-asdf-operator*
     308            #:*load-system-operation*
    307309            #:*asdf-verbose*
    308310            #:*verbose-out*
     
    368370            #:length=n-p
    369371            #:remove-keys #:remove-keyword
    370             #:first-char #:last-char #:ends-with
     372            #:first-char #:last-char #:string-suffix-p
    371373            #:coerce-name
    372374            #:directory-pathname-p #:ensure-directory-pathname
    373375            #:absolute-pathname-p #:ensure-pathname-absolute #:pathname-root
    374             #:getenv #:getenv-pathname #:getenv-pathname
     376            #:getenv #:getenv-pathname #:getenv-pathnames
    375377            #:getenv-absolute-directory #:getenv-absolute-directories
    376378            #:probe-file*
     
    419421(defparameter +asdf-methods+
    420422  '(perform-with-restarts perform explain output-files operation-done-p))
     423
     424(defvar *load-system-operation* 'load-op
     425  "Operation used by ASDF:LOAD-SYSTEM. By default, ASDF:LOAD-OP.
     426You may override it with e.g. ASDF:LOAD-FASL-OP from asdf-bundle,
     427or ASDF:LOAD-SOURCE-OP if your fasl loading is somehow broken.")
     428
     429(defvar *compile-op-compile-file-function* 'compile-file*
     430  "Function used to compile lisp files.")
     431
     432
    421433
    422434#+allegro
     
    660672         ;; See CLHS make-pathname and 19.2.2.2.3.
    661673         ;; We only use it on implementations that support it,
    662          #+(or abcl allegro clozure cmu gcl genera lispworks sbcl scl xcl) :unspecific
     674         #+(or abcl allegro clozure cmu gcl genera lispworks mkcl sbcl scl xcl) :unspecific
    663675         #+(or clisp ecl #|These haven't been tested:|# cormanlisp mcl) nil))
    664676    (destructuring-bind (name &optional (type unspecific))
     
    742754            (unless (ccl:%null-ptr-p value)
    743755              (ccl:%get-cstring value))))
     756  #+mkcl (#.(or (find-symbol* 'getenv :si) (find-symbol* 'getenv :mk-ext)) x)
    744757  #+sbcl (sb-ext:posix-getenv x)
    745   #-(or abcl allegro clisp clozure cmu cormanlisp ecl gcl genera lispworks mcl sbcl scl xcl)
     758  #-(or abcl allegro clisp clozure cmu cormanlisp ecl gcl genera lispworks mcl mkcl sbcl scl xcl)
    746759  (error "~S is not supported on your implementation" 'getenv))
    747760
     
    850863      ((not (consp l)) (return nil)))))
    851864
    852 (defun* ends-with (s suffix)
     865(defun* string-suffix-p (s suffix)
    853866  (check-type s string)
    854867  (check-type suffix string)
     
    878891    (string (probe-file* (parse-namestring p)))
    879892    (pathname (unless (wild-pathname-p p)
    880                 #.(or #+(or allegro clozure cmu cormanlisp ecl lispworks sbcl scl)
     893                #.(or #+(or allegro clozure cmu cormanlisp ecl lispworks mkcl sbcl scl)
    881894                      '(probe-file p)
    882895                      #+clisp (aif (find-symbol* '#:probe-pathname :ext)
     
    24512464        (funcall thunk))))
    24522465
    2453 (defvar *compile-op-compile-file-function* 'compile-file*
    2454   "Function used to compile lisp files.")
    2455 
    24562466;;; perform is required to check output-files to find out where to put
    24572467;;; its answers, in case it has been overridden for site policy
    24582468(defmethod perform ((operation compile-op) (c cl-source-file))
    2459   #-:broken-fasl-loader
    24602469  (let ((source-file (component-pathname c))
    24612470        ;; on some implementations, there are more than one output-file,
     
    24902499(defmethod output-files ((operation compile-op) (c cl-source-file))
    24912500  (declare (ignorable operation))
    2492   (let ((p (lispize-pathname (component-pathname c))))
    2493     #-broken-fasl-loader (list (compile-file-pathname p))
    2494     #+broken-fasl-loader (list p)))
     2501  (let* ((p (lispize-pathname (component-pathname c)))
     2502         (f (compile-file-pathname ;; fasl
     2503             p #+mkcl :fasl-p #+mkcl t #+ecl :type #+ecl :fasl))
     2504         #+mkcl (o (compile-file-pathname p :fasl-p nil))) ;; object file
     2505    #+ecl (if (use-ecl-byte-compiler-p)
     2506              (list f)
     2507              (list (compile-file-pathname p :type :object) f))
     2508    #+mkcl (list o f)
     2509    #-(or ecl mkcl) (list f)))
    24952510
    24962511(defmethod perform ((operation compile-op) (c static-file))
     
    25332548
    25342549(defmethod perform ((o load-op) (c cl-source-file))
    2535   (map () #'load (input-files o c)))
     2550  (map () #'load
     2551       #-(or ecl mkcl)
     2552       (input-files o c)
     2553       #+(or ecl mkcl)
     2554       (loop :for i :in (input-files o c)
     2555       :unless (string= (pathname-type i) "fas")
     2556       :collect (compile-file-pathname (lispize-pathname i)))))
    25362557
    25372558(defmethod perform ((operation load-op) (c static-file))
     
    27372758        operate-docstring))
    27382759
    2739 (defun* load-system (system &rest args &key force verbose version &allow-other-keys)
     2760(defun* load-system (system &rest keys &key force verbose version &allow-other-keys)
    27402761  "Shorthand for `(operate 'asdf:load-op system)`.
    27412762See OPERATE for details."
    27422763  (declare (ignore force verbose version))
    2743   (apply 'operate 'load-op system args)
     2764  (apply 'operate *load-system-operation* system keys)
    27442765  t)
    27452766
     
    27532774  (remove-if-not 'component-loaded-p (registered-systems)))
    27542775
    2755 (defun require-system (s)
    2756   (load-system s :force-not (loaded-systems)))
     2776(defun require-system (s &rest keys &key &allow-other-keys)
     2777  (apply 'load-system s :force-not (loaded-systems) keys))
    27572778
    27582779(defun* compile-system (system &rest args &key force verbose version
     
    30973118    (ccl::with-cstrs ((%command command)) (_system %command))
    30983119
     3120    #+mkcl
     3121    ;; This has next to no chance of working on basic Windows!
     3122    ;; Your best hope is that Cygwin or MSYS is somewhere in the PATH.
     3123    (multiple-value-bind (io process exit-code)
     3124  (apply #'mkcl:run-program #+windows "sh" #-windows "/bin/sh"
     3125                                  (list "-c" command)
     3126                                  :input nil :output t #|*verbose-out*|# ;; will be *verbose-out* when we support it
     3127                                  #-windows '(:search nil))
     3128      (declare (ignore io process))
     3129      exit-code)
     3130
    30993131    #+sbcl
    31003132    (sb-ext:process-exit-code
     
    31083140    (ext:run-shell-command command)
    31093141
    3110     #-(or abcl allegro clisp clozure cmu ecl gcl lispworks mcl sbcl scl xcl)
     3142    #-(or abcl allegro clisp clozure cmu ecl gcl lispworks mcl mkcl sbcl scl xcl)
    31113143    (error "RUN-SHELL-COMMAND not implemented for this Lisp")))
    31123144
     
    31983230  (first-feature
    31993231   '(:abcl (:acl :allegro) (:ccl :clozure) :clisp (:corman :cormanlisp) :cmu
    3200      :ecl :gcl (:lw :lispworks) :mcl :sbcl :scl :symbolics :xcl)))
     3232     :ecl :gcl (:lw :lispworks) :mcl :mkcl :sbcl :scl :symbolics :xcl)))
    32013233
    32023234(defun operating-system ()
     
    32333265     (list
    32343266      #+allegro
    3235       (format nil "~A~A~@[~A~]"
     3267      (format nil "~A~@[~A~]~@[~A~]~@[~A~]"
    32363268              excl::*common-lisp-version-number*
    3237               ;; ANSI vs MoDeRn - thanks to Robert Goldman and Charley Cox
    3238               (if (eq excl:*current-case-mode* :case-sensitive-lower) "M" "A")
     3269              ;; M means "modern", as opposed to ANSI-compatible mode (which I consider default)
     3270              (and (eq excl:*current-case-mode* :case-sensitive-lower) "M")
    32393271              ;; Note if not using International ACL
    32403272              ;; see http://www.franz.com/support/documentation/8.1/doc/operators/excl/ics-target-case.htm
    3241               (excl:ics-target-case (:-ics "8")))
     3273              (excl:ics-target-case (:-ics "8"))
     3274        (and (member :smp *features*) "S"))
    32423275      #+armedbear (format nil "~a-fasl~a" s system::*fasl-version*)
    32433276      #+clisp
     
    32733306(defun* hostname ()
    32743307  ;; Note: untested on RMCL
    3275   #+(or abcl clozure cmucl ecl genera lispworks mcl sbcl scl xcl) (machine-instance)
     3308  #+(or abcl clozure cmucl ecl genera lispworks mcl mkcl sbcl scl xcl) (machine-instance)
    32763309  #+cormanlisp "localhost" ;; is there a better way? Does it matter?
    32773310  #+allegro (excl.osi:gethostname)
     
    33053338                      x :separator (string (inter-directory-separator)))
    33063339        :collect (apply 'ensure-pathname* dir want-absolute want-directory fmt args)))
    3307 (defun getenv-pathname (x &key want-absolute want-directory &aux (s (getenv x)))
     3340(defun* getenv-pathname (x &key want-absolute want-directory &aux (s (getenv x)))
    33083341  (ensure-pathname* s want-absolute want-directory "from (getenv ~S)" x))
    3309 (defun getenv-pathnames (x &key want-absolute want-directory &aux (s (getenv x)))
     3342(defun* getenv-pathnames (x &key want-absolute want-directory &aux (s (getenv x)))
    33103343  (and (plusp (length s))
    33113344       (split-pathnames* s want-absolute want-directory "from (getenv ~S) = ~S" x s)))
    3312 (defun getenv-absolute-directory (x)
     3345(defun* getenv-absolute-directory (x)
    33133346  (getenv-pathname x :want-absolute t :want-directory t))
    3314 (defun getenv-absolute-directories (x)
     3347(defun* getenv-absolute-directories (x)
    33153348  (getenv-pathnames x :want-absolute t :want-directory t))
    33163349
     
    36993732              (when h `((,(truenamize h) ,*wild-inferiors*) ())))
    37003733    ;; The below two are not needed: no precompiled ASDF system there
    3701     #+ecl (,(translate-logical-pathname "SYS:**;*.*") ())
     3734    #+(or ecl mkcl) (,(translate-logical-pathname "SYS:**;*.*") ())
     3735    #+mkcl (,(translate-logical-pathname "CONTRIB:") ())
    37023736    ;; #+clozure ,(ignore-errors (list (wilden (let ((*default-pathname-defaults* #p"")) (truename #p"ccl:"))) ()))
    37033737    ;; All-import, here is where we want user stuff to be:
     
    39553989         (subpathname (user-homedir) ".fasls/")) ;; Use ".cache/common-lisp/" instead ???
    39563990     (include-per-user-information nil)
    3957      (map-all-source-files (or #+(or ecl clisp) t nil))
     3991     (map-all-source-files (or #+(or clisp ecl mkcl) t nil))
    39583992     (source-to-target-mappings nil))
    3959   #+(or ecl clisp)
     3993  #+(or clisp ecl mkcl)
    39603994  (when (null map-all-source-files)
    3961     (error "asdf:enable-asdf-binary-locations-compatibility doesn't support :map-all-source-files nil on ECL and CLISP"))
     3995    (error "asdf:enable-asdf-binary-locations-compatibility doesn't support :map-all-source-files nil on CLISP, ECL and MKCL"))
    39623996  (let* ((fasl-type (pathname-type (compile-file-pathname "foo.lisp")))
    39633997         (mapped-files (if map-all-source-files *wild-file*
     
    41624196             (setf inherit t)
    41634197             (push ':inherit-configuration directives))
    4164             ((ends-with s "//") ;; TODO: allow for doubling of separator even outside Unix?
     4198            ((string-suffix-p s "//") ;; TODO: allow for doubling of separator even outside Unix?
    41654199             (push `(:tree ,(check (subseq s 0 (- (length s) 2)))) directives))
    41664200            (t
     
    41934227(defun* wrapping-source-registry ()
    41944228  `(:source-registry
     4229    #+mkcl (:tree ,(translate-logical-pathname "CONTRIB:"))
    41954230    #+sbcl (:tree ,(truenamize (getenv-pathname "SBCL_HOME" :want-directory t)))
    41964231    :inherit-configuration
     
    42014236    #+sbcl (:directory ,(subpathname (user-homedir) ".sbcl/systems/"))
    42024237    (:directory ,(default-directory))
    4203       ,@(loop :for dir :in
    4204           `(,@(when (os-unix-p)
    4205                 `(,(or (getenv-absolute-directory "XDG_DATA_HOME")
    4206                        (subpathname (user-homedir) ".local/share/"))
    4207                   ,@(or (getenv-absolute-directories "XDG_DATA_DIRS")
    4208                         '("/usr/local/share" "/usr/share"))))
    4209             ,@(when (os-windows-p)
    4210                 `(,(or #+lispworks (sys:get-folder-path :local-appdata)
    4211                        (getenv-absolute-directory "LOCALAPPDATA"))
    4212                   ,(or #+lispworks (sys:get-folder-path :appdata)
    4213                        (getenv-absolute-directory "APPDATA"))
    4214                   ,(or #+lispworks (sys:get-folder-path :common-appdata)
    4215                        (getenv-absolute-directory "ALLUSERSAPPDATA")
    4216                        (subpathname* (getenv-absolute-directory "ALLUSERSPROFILE") "Application Data/")))))
    4217           :collect `(:directory ,(subpathname* dir "common-lisp/systems/"))
    4218           :collect `(:tree ,(subpathname* dir "common-lisp/source/")))
    4219       :inherit-configuration))
     4238    ,@(loop :for dir :in
     4239        `(,@(when (os-unix-p)
     4240              `(,(or (getenv-absolute-directory "XDG_DATA_HOME")
     4241                     (subpathname (user-homedir) ".local/share/"))
     4242                ,@(or (getenv-absolute-directories "XDG_DATA_DIRS")
     4243                      '("/usr/local/share" "/usr/share"))))
     4244          ,@(when (os-windows-p)
     4245              `(,(or #+lispworks (sys:get-folder-path :local-appdata)
     4246                     (getenv-absolute-directory "LOCALAPPDATA"))
     4247                ,(or #+lispworks (sys:get-folder-path :appdata)
     4248                     (getenv-absolute-directory "APPDATA"))
     4249                ,(or #+lispworks (sys:get-folder-path :common-appdata)
     4250                     (getenv-absolute-directory "ALLUSERSAPPDATA")
     4251                     (subpathname* (getenv-absolute-directory "ALLUSERSPROFILE") "Application Data/")))))
     4252        :collect `(:directory ,(subpathname* dir "common-lisp/systems/"))
     4253        :collect `(:tree ,(subpathname* dir "common-lisp/source/")))
     4254    :inherit-configuration))
    42204255(defun* user-source-registry (&key (direction :input))
    42214256  (in-user-configuration-directory *source-registry-file* :direction direction))
     
    43634398
    43644399
    4365 ;;; ECL support for COMPILE-OP / LOAD-OP
     4400;;; ECL and MKCL support for COMPILE-OP / LOAD-OP
    43664401;;;
    4367 ;;; In ECL, these operations produce both FASL files and the
    4368 ;;; object files that they are built from. Having both of them allows
    4369 ;;; us to later on reuse the object files for bundles, libraries,
    4370 ;;; standalone executables, etc.
     4402;;; In ECL and MKCL, these operations produce both
     4403;;; FASL files and the object files that they are built from.
     4404;;; Having both of them allows us to later on reuse the object files
     4405;;; for bundles, libraries, standalone executables, etc.
    43714406;;;
    43724407;;; This has to be in asdf.lisp and not asdf-ecl.lisp, or else it becomes
    43734408;;; a problem for asdf on ECL to compile asdf-ecl.lisp after loading asdf.lisp.
    43744409;;;
    4375 #+ecl
     4410;;; Also, register-pre-built-system.
     4411
     4412#+(or ecl mkcl)
    43764413(progn
    4377   (setf *compile-op-compile-file-function* 'ecl-compile-file)
    4378 
    4379   (defun ecl-compile-file (input-file &rest keys &key &allow-other-keys)
    4380     (if (use-ecl-byte-compiler-p)
    4381         (apply 'compile-file* input-file keys)
    4382         (multiple-value-bind (object-file flags1 flags2)
    4383             (apply 'compile-file* input-file :system-p t keys)
    4384           (values (and object-file
    4385                        (c::build-fasl (compile-file-pathname object-file :type :fasl)
    4386                                       :lisp-files (list object-file))
    4387                        object-file)
    4388                   flags1
    4389                   flags2))))
    4390 
    4391   (defmethod output-files ((operation compile-op) (c cl-source-file))
    4392     (declare (ignorable operation))
    4393     (let* ((p (lispize-pathname (component-pathname c)))
    4394            (f (compile-file-pathname p :type :fasl)))
    4395       (if (use-ecl-byte-compiler-p)
    4396           (list f)
    4397           (list (compile-file-pathname p :type :object) f))))
    4398 
    4399   (defmethod perform ((o load-op) (c cl-source-file))
    4400     (map () #'load
    4401          (loop :for i :in (input-files o c)
    4402            :unless (string= (pathname-type i) "fas")
    4403                :collect (compile-file-pathname (lispize-pathname i))))))
    4404 
    4405 ;;;; -----------------------------------------------------------------
    4406 ;;;; Hook into REQUIRE for ABCL, CLISP, ClozureCL, CMUCL, ECL and SBCL
     4414  (defun register-pre-built-system (name)
     4415    (register-system (make-instance 'system :name (coerce-name name) :source-file nil)))
     4416
     4417  #+(or (and ecl win32) (and mkcl windows))
     4418  (unless (assoc "asd" #+ecl ext:*load-hooks* #+mkcl si::*load-hooks* :test 'equal)
     4419    (appendf #+ecl ext:*load-hooks* #+mkcl si::*load-hooks* '(("asd" . si::load-source))))
     4420
     4421  (setf #+ecl ext:*module-provider-functions* #+mkcl mk-ext::*module-provider-functions*
     4422        (loop :for f :in #+ecl ext:*module-provider-functions*
     4423          #+mkcl mk-ext::*module-provider-functions*
     4424          :unless (eq f 'module-provide-asdf)
     4425          :collect #'(lambda (name)
     4426                       (let ((l (multiple-value-list (funcall f name))))
     4427                         (and (first l) (register-pre-built-system (coerce-name name)))
     4428                         (values-list l)))))
     4429
     4430  (setf *compile-op-compile-file-function* 'compile-file-keeping-object)
     4431
     4432  (defun compile-file-keeping-object (input-file &rest keys &key &allow-other-keys)
     4433    (#+ecl if #+ecl (use-ecl-byte-compiler-p) #+ecl (apply 'compile-file* input-file keys)
     4434     #+mkcl progn
     4435     (multiple-value-bind (object-file flags1 flags2)
     4436         (apply 'compile-file* input-file
     4437                #+ecl :system-p #+ecl t #+mkcl :fasl-p #+mkcl nil keys)
     4438       (values (and object-file
     4439                    (compiler::build-fasl
     4440                     (compile-file-pathname object-file
     4441                                            #+ecl :type #+ecl :fasl #+mkcl :fasl-p #+mkcl t)
     4442                     #+ecl :lisp-files #+mkcl :lisp-object-files (list object-file))
     4443                    object-file)
     4444               flags1
     4445               flags2)))))
     4446
     4447;;;; -----------------------------------------------------------------------
     4448;;;; Hook into REQUIRE for ABCL, CLISP, ClozureCL, CMUCL, ECL, MKCL and SBCL
    44074449;;;;
    4408 (defvar *require-asdf-operator* 'load-op)
    4409 
    44104450(defun* module-provide-asdf (name)
    44114451  (handler-bind
     
    44194459          (system (find-system (string-downcase name) nil)))
    44204460      (when system
    4421         (operate *require-asdf-operator* system :verbose nil :force-not (loaded-systems))
     4461        (require-system system :verbose nil)
    44224462        t))))
    44234463
    4424 #+(or abcl clisp clozure cmu ecl sbcl)
     4464#+(or abcl clisp clozure cmu ecl mkcl sbcl)
    44254465(let ((x (and #+clisp (find-symbol* '#:*module-provider-functions* :custom))))
    44264466  (when x
     
    44304470            #+clozure ccl:*module-provider-functions*
    44314471            #+(or cmu ecl) ext:*module-provider-functions*
     4472            #+mkcl mk-ext:*module-provider-functions*
    44324473            #+sbcl sb-ext:*module-provider-functions*))))
    44334474
     
    44494490  (asdf-message ";; ASDF, version ~a~%" (asdf-version)))
    44504491
     4492#+mkcl
     4493(progn
     4494  (defvar *loading-asdf-bundle* nil)
     4495  (unless *loading-asdf-bundle*
     4496    (let ((*central-registry*
     4497           (cons (translate-logical-pathname #P"CONTRIB:asdf-bundle;") *central-registry*))
     4498    (*loading-asdf-bundle* t))
     4499      (clear-system :asdf-bundle) ;; we hope to force a reload.
     4500      (multiple-value-bind (result bundling-error)
     4501          (ignore-errors (asdf:oos 'asdf:load-op :asdf-bundle))
     4502        (unless result
     4503    (format *error-output*
     4504      "~&;;; ASDF: Failed to load package 'asdf-bundle'!~%;;; ASDF: Reason is: ~A.~%"
     4505      bundling-error))))))
     4506
    44514507#+allegro
    44524508(eval-when (:compile-toplevel :execute)
Note: See TracChangeset for help on using the changeset viewer.