asdf.lisp 135 KB
Newer Older
1
;;; -*- mode: common-lisp; package: asdf; -*-
Francois-Rene Rideau's avatar
1.647:    
Francois-Rene Rideau committed
2
;;; This is ASDF: Another System Definition Facility.
3
;;;
4
5
;;; Feedback, bug reports, and patches are all welcome:
;;; please mail to <asdf-devel@common-lisp.net>.
Francois-Rene Rideau's avatar
1.647:    
Francois-Rene Rideau committed
6
;;; Note first that the canonical source for ASDF is presently
7
;;; <URL:http://common-lisp.net/project/asdf/>.
8
9
10
11
12
;;;
;;; If you obtained this copy from anywhere else, and you experience
;;; trouble using it, or find bugs, you may want to check at the
;;; location above for a more recent version (and for documentation
;;; and test files, if your copy came without them) before reporting
13
;;; bugs.  There are usually two "supported" revisions - the git HEAD
14
15
16
;;; is the latest development version, whereas the revision tagged
;;; RELEASE may be slightly older but is considered `stable'

17
;;; -- LICENSE START
18
;;; (This is the MIT / X Consortium license as taken from
19
20
21
;;;  http://www.opensource.org/licenses/mit-license.html on or about
;;;  Monday; July 13, 2009)
;;;
22
;;; Copyright (c) 2001-2010 Daniel Barlow and contributors
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining
;;; a copy of this software and associated documentation files (the
;;; "Software"), to deal in the Software without restriction, including
;;; without limitation the rights to use, copy, modify, merge, publish,
;;; distribute, sublicense, and/or sell copies of the Software, and to
;;; permit persons to whom the Software is furnished to do so, subject to
;;; the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
;;; LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
;;; OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
;;; WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
42
43
;;;
;;; -- LICENSE END
44

45
46
;;; The problem with writing a defsystem replacement is bootstrapping:
;;; we can't use defsystem to compile it.  Hence, all in one file.
Daniel Barlow's avatar
Daniel Barlow committed
47

48
49
#+xcvb (module ())

50
51
(cl:in-package :cl-user)

52
53
#|(declaim (optimize (speed 2) (debug 2) (safety 3))
#+sbcl (sb-ext:muffle-conditions sb-ext:compiler-note))|#
54

55
#+ecl (require :cmp)
56

57
;;;; Create packages in a way that is compatible with hot-upgrade.
58
59
60
;;;; See https://bugs.launchpad.net/asdf/+bug/485687
;;;; See more at the end of the file.

61
62
63
64
65
#+gcl
(eval-when (:compile-toplevel :load-toplevel)
  (defpackage :asdf-utilities (:use :cl))
  (defpackage :asdf (:use :cl :asdf-utilities)))

66
(eval-when (:load-toplevel :compile-toplevel :execute)
67
68
  #+allegro
  (setf excl::*autoload-package-name-alist*
69
70
        (remove "asdf" excl::*autoload-package-name-alist*
                :test 'equalp :key 'car))
71
  (let* ((asdf-version
72
          ;; the 1+ helps the version bumping script discriminate
73
          (subseq "VERSION:2.000" (1+ (length "VERSION"))))
74
         (existing-asdf (find-package :asdf))
75
76
77
78
         (vername '#:*asdf-version*)
         (versym (and existing-asdf
                      (find-symbol (string vername) existing-asdf)))
         (existing-version (and versym (boundp versym) (symbol-value versym)))
79
80
         (already-there (equal asdf-version existing-version)))
    (unless (and existing-asdf already-there)
81
      #-gcl
82
      (when existing-asdf
83
        (format *trace-output*
84
85
                "~&Upgrading ASDF package ~@[from version ~A ~]to version ~A~%"
                existing-version asdf-version))
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
      (labels
          ((rename-away (package)
             (loop :with name = (package-name package)
               :for i :from 1 :for new = (format nil "~A.~D" name i)
               :unless (find-package new) :do
               (rename-package-name package name new)))
           (rename-package-name (package old new)
             (let* ((old-names (cons (package-name package)
                                     (package-nicknames package)))
                    (new-names (subst new old old-names :test 'equal))
                    (new-name (car new-names))
                    (new-nicknames (cdr new-names)))
               (rename-package package new-name new-nicknames)))
           (ensure-exists (name nicknames use)
             (let* ((previous
                     (remove-duplicates
                      (remove-if
                       #'null
                       (mapcar #'find-package (cons name nicknames)))
                      :from-end t)))
               (cond
                 (previous
                  ;; do away with packages with conflicting (nick)names
                  (map () #'rename-away (cdr previous))
                  ;; reuse previous package with same name
                  (let ((p (car previous)))
                    (rename-package p name nicknames)
                    (ensure-use p use)
                    p))
                 (t
                  (make-package name :nicknames nicknames :use use)))))
           (find-sym (symbol package)
             (find-symbol (string symbol) package))
           (intern* (symbol package)
             (intern (string symbol) package))
           (remove-symbol (symbol package)
             (let ((sym (find-sym symbol package)))
               (when sym
                 (unexport sym package)
                 (unintern sym package))))
           (ensure-unintern (package symbols)
             (dolist (sym symbols) (remove-symbol sym package)))
           (ensure-shadow (package symbols)
             (shadow symbols package))
           (ensure-use (package use)
             (dolist (used (reverse use))
               (do-external-symbols (sym used)
                 (unless (eq sym (find-sym sym package))
                   (remove-symbol sym package)))
               (use-package used package)))
           (ensure-fmakunbound (package symbols)
             (loop :for name :in symbols
               :for sym = (find-sym name package)
               :when sym :do (fmakunbound sym)))
           (ensure-export (package export)
             (let ((syms (loop :for x :in export :collect
                           (intern* x package))))
               (do-external-symbols (sym package)
                 (unless (member sym syms)
                   (remove-symbol sym package)))
               (dolist (sym syms)
                 (export sym package))))
           (ensure-package (name &key nicknames use unintern fmakunbound shadow export)
             (let ((p (ensure-exists name nicknames use)))
               (ensure-unintern p unintern)
               (ensure-shadow p shadow)
               (ensure-export p export)
               (ensure-fmakunbound p fmakunbound)
               p)))
        (macrolet
            ((pkgdcl (name &key nicknames use export
                           redefined-functions unintern fmakunbound shadow)
               `(ensure-package
                 ',name :nicknames ',nicknames :use ',use :export ',export
                 :shadow ',shadow
                 :unintern ',(append #-(or gcl ecl) redefined-functions
                                     unintern)
                 :fmakunbound ',(append #+(or gcl ecl) redefined-functions
                                        fmakunbound))))
          (pkgdcl
           :asdf-utilities
           :nicknames (#:asdf-extensions)
           :use (#:common-lisp)
           :unintern (#:split #:make-collector)
           :export
           (#:absolute-pathname-p
            #:aif
            #:appendf
            #:asdf-message
            #:coerce-name
            #:directory-pathname-p
            #:ends-with
            #:ensure-directory-pathname
            #:getenv
            #:get-uid
            #:length=n-p
            #:merge-pathnames*
            #:pathname-directory-pathname
            #:read-file-forms
            #:remove-keys
            #:remove-keyword
            #:resolve-symlinks
            #:split-string
            #:component-name-to-pathname-components
            #:split-name-type
            #:system-registered-p
            #:truenamize
            #:while-collecting))
          (pkgdcl
           :asdf
           :use (:common-lisp :asdf-utilities)
           :redefined-functions
           (#:perform #:explain #:output-files #:operation-done-p
            #:perform-with-restarts #:component-relative-pathname
            #:system-source-file #:operate #:find-component)
           :unintern
           (#:*asdf-revision* #:around #:asdf-method-combination
            #:split #:make-collector)
           :fmakunbound
           (#:system-source-file
            #:component-relative-pathname #:system-relative-pathname
            #:process-source-registry
            #:inherit-source-registry #:process-source-registry-directive)
           :export
           (#:defsystem #:oos #:operate #:find-system #:run-shell-command
            #:system-definition-pathname #:find-component ; miscellaneous
            #:compile-system #:load-system #:test-system
            #:compile-op #:load-op #:load-source-op
            #:test-op
            #:operation               ; operations
            #:feature                 ; sort-of operation
            #:version                 ; metaphorically sort-of an operation
            #:version-satisfies

            #:input-files #:output-files #:perform ; operation methods
            #:operation-done-p #:explain

            #:component #:source-file
            #:c-source-file #:cl-source-file #:java-source-file
            #:static-file
            #:doc-file
            #:html-file
            #:text-file
            #:source-file-type
            #:module                     ; components
            #:system
            #:unix-dso

            #:module-components          ; component accessors
            #:module-components-by-name  ; component accessors
            #:component-pathname
            #:component-relative-pathname
            #:component-name
            #:component-version
            #:component-parent
            #:component-property
            #:component-system

            #:component-depends-on

            #:system-description
            #:system-long-description
            #:system-author
            #:system-maintainer
            #:system-license
            #:system-licence
            #:system-source-file
            #:system-source-directory
            #:system-relative-pathname
            #:map-systems

            #:operation-on-warnings
            #:operation-on-failure
            ;;#:*component-parent-pathname*
            #:*system-definition-search-functions*
            #:*central-registry*         ; variables
            #:*compile-file-warnings-behaviour*
            #:*compile-file-failure-behaviour*
            #:*resolve-symlinks*
            #:*asdf-verbose*

            #:asdf-version

            #:operation-error #:compile-failed #:compile-warned #:compile-error
            #:error-name
            #:error-pathname
            #:load-system-definition-error
            #:error-component #:error-operation
            #:system-definition-error
            #:missing-component
            #:missing-component-of-version
            #:missing-dependency
            #:missing-dependency-of-version
            #:circular-dependency        ; errors
            #:duplicate-names

            #:try-recompiling
            #:retry
            #:accept                     ; restarts
            #:coerce-entry-to-directory
            #:remove-entry-from-registry

            #:initialize-output-translations
            #:disable-output-translations
            #:clear-output-translations
            #:ensure-output-translations
            #:apply-output-translations
            #:compile-file-pathname*
            #:enable-asdf-binary-locations-compatibility

            #:*default-source-registries*
            #:initialize-source-registry
            #:compute-source-registry
            #:clear-source-registry
            #:ensure-source-registry
            #:process-source-registry)))
        (let* ((version (intern* vername :asdf))
303
304
305
306
307
308
               (upvar (intern* '#:*upgraded-p* :asdf))
               (upval0 (and (boundp upvar) (symbol-value upvar)))
               (upval1 (if existing-version (cons existing-version upval0) upval0)))
          (eval `(progn
                   (defparameter ,version ,asdf-version)
                   (defparameter ,upvar ',upval1))))))))
309

310
(in-package :asdf)
Daniel Barlow's avatar
Daniel Barlow committed
311

312
;; More cleanups in case of hot-upgrade. See https://bugs.launchpad.net/asdf/+bug/485687
313
314
315
316
#+gcl
(eval-when (:compile-toplevel :load-toplevel)
  (defvar *asdf-version* nil)
  (defvar *upgraded-p* nil))
317
318
(when *upgraded-p*
   #+ecl
319
320
321
322
323
324
325
326
327
328
329
   (when (find-class 'compile-op nil)
     (defmethod update-instance-for-redefined-class :after
         ((c compile-op) added deleted plist &key)
       (declare (ignore added deleted))
       (let ((system-p (getf plist 'system-p)))
         (when system-p (setf (getf (slot-value c 'flags) :system-p) system-p)))))
   (when (find-class 'module nil)
     (eval
      '(defmethod update-instance-for-redefined-class :after
           ((m module) added deleted plist &key)
         (declare (ignorable deleted plist))
330
         (format *trace-output* "Updating ~A~%" m)
331
332
         (when (member 'components-by-name added)
           (compute-module-components-by-name m))))))
333

334
335
336
;;;; -------------------------------------------------------------------------
;;;; User-visible parameters
;;;;
337
(defun asdf-version ()
338
  "Exported interface to the version of ASDF currently installed. A string.
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
339
You can compare this string with e.g.:
340
(ASDF:VERSION-SATISFIES (ASDF:ASDF-VERSION) \"2.000\")."
341
  *asdf-version*)
342

343
344
345
346
347
(defvar *resolve-symlinks* t
  "Determine whether or not ASDF resolves symlinks when defining systems.

Defaults to `t`.")

348
(defvar *compile-file-warnings-behaviour* :warn)
349

350
(defvar *compile-file-failure-behaviour* #+sbcl :error #-sbcl :warn)
Daniel Barlow's avatar
   
Daniel Barlow committed
351

352
(defvar *verbose-out* nil)
353

354
355
(defvar *asdf-verbose* t)

356
(defparameter +asdf-methods+
357
  '(perform-with-restarts perform explain output-files operation-done-p))
358

359
#+allegro
360
(eval-when (:compile-toplevel :execute)
361
362
363
364
365
366
  (defparameter *acl-warn-save*
                (when (boundp 'excl:*warn-on-nested-reader-conditionals*)
                  excl:*warn-on-nested-reader-conditionals*))
  (when (boundp 'excl:*warn-on-nested-reader-conditionals*)
    (setf excl:*warn-on-nested-reader-conditionals* nil)))

367
368
369
;;;; -------------------------------------------------------------------------
;;;; ASDF Interface, in terms of generic functions.

370
371
372
373
374
375
(defgeneric perform-with-restarts (operation component))
(defgeneric perform (operation component))
(defgeneric operation-done-p (operation component))
(defgeneric explain (operation component))
(defgeneric output-files (operation component))
(defgeneric input-files (operation component))
376
(defgeneric component-operation-time (operation component))
377
378
379
380
381
382
383
384
385
386
387

(defgeneric system-source-file (system)
  (:documentation "Return the source file in which system is defined."))

(defgeneric component-system (component)
  (:documentation "Find the top-level system containing COMPONENT"))

(defgeneric component-pathname (component)
  (:documentation "Extracts the pathname applicable for a particular component."))

(defgeneric component-relative-pathname (component)
388
389
390
391
392
  (:documentation "Returns a pathname for the component argument intended to be
interpreted relative to the pathname of that component's parent.
Despite the function's name, the return value may be an absolute
pathname, because an absolute pathname may be interpreted relative to
another pathname in a degenerate way."))
393
394
395
396
397
398
399

(defgeneric component-property (component property))

(defgeneric (setf component-property) (new-value component property))

(defgeneric version-satisfies (component version))

400
401
402
(defgeneric find-component (base path)
  (:documentation "Finds the component with PATH starting from BASE module;
if BASE is nil, then the component is assumed to be a system."))
403
404
405
406
407
408
409
410

(defgeneric source-file-type (component system))

(defgeneric operation-ancestor (operation)
  (:documentation
   "Recursively chase the operation's parent pointer until we get to
the head of the tree"))

411
412
413
414
415
416
(defgeneric component-visited-p (operation component)
  (:documentation "Returns the value stored by a call to
VISIT-COMPONENT, if that has been called, otherwise NIL.
This value stored will be a cons cell, the first element
of which is a computed key, so not interesting.  The
CDR wil be the DATA value stored by VISIT-COMPONENT; recover
417
it as (cdr (component-visited-p op c)).
418
419
420
421
422
  In the current form of ASDF, the DATA value retrieved is
effectively a boolean, indicating whether some operations are
to be performed in order to do OPERATION X COMPONENT.  If the
data value is NIL, the combination had been explored, but no
operations needed to be performed."))
423
424
425
426
427
428
429
430
431
432

(defgeneric visit-component (operation component data)
  (:documentation "Record DATA as being associated with OPERATION
and COMPONENT.  This is a side-effecting function:  the association
will be recorded on the ROOT OPERATION \(OPERATION-ANCESTOR of the
OPERATION\).
  No evidence that DATA is ever interesting, beyond just being
non-NIL.  Using the data field is probably very risky; if there is
already a record for OPERATION X COMPONENT, DATA will be quietly
discarded instead of recorded."))
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456

(defgeneric (setf visiting-component) (new-value operation component))

(defgeneric component-visiting-p (operation component))

(defgeneric component-depends-on (operation component)
  (:documentation
   "Returns a list of dependencies needed by the component to perform
    the operation.  A dependency has one of the following forms:

      (<operation> <component>*), where <operation> is a class
        designator and each <component> is a component
        designator, which means that the component depends on
        <operation> having been performed on each <component>; or

      (FEATURE <feature>), which means that the component depends
        on <feature>'s presence in *FEATURES*.

    Methods specialized on subclasses of existing component types
    should usually append the results of CALL-NEXT-METHOD to the
    list."))

(defgeneric component-self-dependencies (operation component))

Gary King's avatar
Gary King committed
457
(defgeneric traverse (operation component)
458
  (:documentation
459
"Generate and return a plan for performing OPERATION on COMPONENT.
Gary King's avatar
Gary King committed
460

461
462
463
The plan returned is a list of dotted-pairs. Each pair is the CONS
of ASDF operation object and a COMPONENT object. The pairs will be
processed in order by OPERATE."))
464
465


466
467
;;;; -------------------------------------------------------------------------
;;;; General Purpose Utilities
468

469
470
471
472
(defmacro while-collecting ((&rest collectors) &body body)
  (let ((vars (mapcar #'(lambda (x) (gensym (symbol-name x))) collectors))
        (initial-values (mapcar (constantly nil) collectors)))
    `(let ,(mapcar #'list vars initial-values)
473
       (flet ,(mapcar #'(lambda (c v) `(,c (x) (push x ,v) (values))) collectors vars)
474
         ,@body
475
         (values ,@(mapcar #'(lambda (v) `(reverse ,v)) vars))))))
476

477
478
479
(defmacro aif (test then &optional else)
  `(let ((it ,test)) (if it ,then ,else)))

480
481
482
(defun pathname-directory-pathname (pathname)
  "Returns a new pathname with same HOST, DEVICE, DIRECTORY as PATHNAME,
and NIL NAME, TYPE and VERSION components"
483
484
  (when pathname
    (make-pathname :name nil :type nil :version nil :defaults pathname)))
485

486
487
(defun merge-pathnames* (specified &optional (defaults *default-pathname-defaults*))
  "MERGE-PATHNAMES* is like MERGE-PATHNAMES except that if the SPECIFIED pathname
488
489
490
491
does not have an absolute directory, then the HOST and DEVICE come from the DEFAULTS.
Also, if either argument is NIL, then the other argument is returned unmodified."
  (when (null specified) (return-from merge-pathnames* defaults))
  (when (null defaults) (return-from merge-pathnames* specified))
492
493
494
  (let* ((specified (pathname specified))
         (defaults (pathname defaults))
         (directory (pathname-directory specified))
495
         #-sbcl (directory (if (stringp directory) `(:absolute ,directory) directory))
496
497
498
         (name (or (pathname-name specified) (pathname-name defaults)))
         (type (or (pathname-type specified) (pathname-type defaults)))
         (version (or (pathname-version specified) (pathname-version defaults))))
499
500
501
502
503
    (labels ((ununspecific (x)
               (if (eq x :unspecific) nil x))
             (unspecific-handler (p)
               (if (typep p 'logical-pathname) #'ununspecific #'identity)))
      (multiple-value-bind (host device directory unspecific-handler)
504
          (#-gcl ecase #+gcl case (first directory)
505
506
507
508
509
510
511
512
513
514
515
516
517
            ((nil)
             (values (pathname-host defaults)
                     (pathname-device defaults)
                     (pathname-directory defaults)
                     (unspecific-handler defaults)))
            ((:absolute)
             (values (pathname-host specified)
                     (pathname-device specified)
                     directory
                     (unspecific-handler specified)))
            ((:relative)
             (values (pathname-host defaults)
                     (pathname-device defaults)
518
519
520
                     (if (pathname-directory defaults)
                         (append (pathname-directory defaults) (cdr directory))
                         directory)
521
522
523
524
525
526
527
                     (unspecific-handler defaults)))
            #+gcl
            (t
             (assert (stringp (first directory)))
             (values (pathname-host defaults)
                     (pathname-device defaults)
                     (append (pathname-directory defaults) directory)
528
529
530
531
532
                     (unspecific-handler defaults))))
        (make-pathname :host host :device device :directory directory
                       :name (funcall unspecific-handler name)
                       :type (funcall unspecific-handler type)
                       :version (funcall unspecific-handler version))))))
533

534
(define-modify-macro appendf (&rest args)
535
536
537
538
  append "Append onto list") ;; only to be used on short lists.

(define-modify-macro orf (&rest args)
  or "or a flag")
Daniel Barlow's avatar
   
Daniel Barlow committed
539

540
541
542
543
544
545
(defun first-char (s)
  (and (stringp s) (plusp (length s)) (char s 0)))

(defun last-char (s)
  (and (stringp s) (plusp (length s)) (char s (1- (length s)))))

546
547
548
549
(defun asdf-message (format-string &rest format-args)
  (declare (dynamic-extent format-args))
  (apply #'format *verbose-out* format-string format-args))

550
(defun split-string (string &key max (separator '(#\Space #\Tab)))
551
552
  "Split STRING into a list of components separated by
any of the characters in the sequence SEPARATOR.
553
554
555
If MAX is specified, then no more than max(1,MAX) components will be returned,
starting the separation from the end, e.g. when called with arguments
 \"a.b.c.d.e\" :max 3 :separator \".\" it will return (\"a.b.c\" \"d\" \"e\")."
556
557
558
559
560
561
562
563
564
565
566
567
568
  (block nil
    (let ((list nil) (words 0) (end (length string)))
      (flet ((separatorp (char) (find char separator))
             (done () (return (cons (subseq string 0 end) list))))
        (loop
          :for start = (if (and max (>= words (1- max)))
                           (done)
                           (position-if #'separatorp string :end end :from-end t)) :do
          (when (null start)
            (done))
          (push (subseq string (1+ start) end) list)
          (incf words)
          (setf end start))))))
569
570

(defun split-name-type (filename)
571
572
573
574
  (let ((unspecific
         ;; Giving :unspecific as argument to make-pathname is not portable.
         ;; See CLHS make-pathname and 19.2.2.2.3.
         ;; We only use it on implementations that support it.
575
         (or #+(or ccl ecl gcl lispworks sbcl) :unspecific)))
576
577
578
579
580
    (destructuring-bind (name &optional (type unspecific))
        (split-string filename :max 2 :separator ".")
      (if (equal name "")
          (values filename unspecific)
          (values name type)))))
581

582
(defun component-name-to-pathname-components (s &optional force-directory)
583
584
585
586
587
588
589
590
591
592
  "Splits the path string S, returning three values:
A flag that is either :absolute or :relative, indicating
   how the rest of the values are to be interpreted.
A directory path --- a list of strings, suitable for
   use with MAKE-PATHNAME when prepended with the flag
   value.
A filename with type extension, possibly NIL in the
   case of a directory pathname.
FORCE-DIRECTORY forces S to be interpreted as a directory
pathname \(third return value will be NIL, final component
593
594
595
596
597
of S will be treated as part of the directory path.

The intention of this function is to support structured component names,
e.g., \(:file \"foo/bar\"\), which will be unpacked to relative
pathnames."
598
  (check-type s string)
599
  (let* ((components (split-string s :separator "/"))
600
601
602
         (last-comp (car (last components))))
    (multiple-value-bind (relative components)
        (if (equal (first components) "")
603
            (if (equal (first-char s) #\/)
604
605
                (values :absolute (cdr components))
                (values :relative nil))
606
607
608
609
610
611
612
613
          (values :relative components))
      (cond
        ((equal last-comp "")
         (values relative (butlast components) nil))
        (force-directory
         (values relative components nil))
        (t
         (values relative (butlast components) last-comp))))))
614

615
(defun remove-keys (key-names args)
616
617
618
619
620
621
622
623
624
  (loop :for (name val) :on args :by #'cddr
    :unless (member (symbol-name name) key-names
                    :key #'symbol-name :test 'equal)
    :append (list name val)))

(defun remove-keyword (key args)
  (loop :for (k v) :on args :by #'cddr
    :unless (eq k key)
    :append (list k v)))
625

626
(defun getenv (x)
Francois-Rene Rideau's avatar
1.642:    
Francois-Rene Rideau committed
627
628
  #+abcl
  (ext:getenv x)
629
630
631
  #+sbcl
  (sb-ext:posix-getenv x)
  #+clozure
632
  (ccl:getenv x)
633
634
635
636
637
  #+clisp
  (ext:getenv x)
  #+cmu
  (cdr (assoc (intern x :keyword) ext:*environment-list*))
  #+lispworks
638
  (lispworks:environment-variable x)
639
640
641
642
643
644
645
  #+allegro
  (sys:getenv x)
  #+gcl
  (system:getenv x)
  #+ecl
  (si:getenv x))

646
(defun directory-pathname-p (pathname)
647
  "Does PATHNAME represent a directory?
648
649

A directory-pathname is a pathname _without_ a filename. The three
650
651
ways that the filename components can be missing are for it to be NIL,
:UNSPECIFIC or the empty string.
652

653
Note that this does _not_ check to see that PATHNAME points to an
654
655
actually-existing directory."
  (flet ((check-one (x)
656
           (member x '(nil :unspecific "") :test 'equal)))
657
    (and (check-one (pathname-name pathname))
658
659
         (check-one (pathname-type pathname))
         t)))
660

661
662
(defun ensure-directory-pathname (pathspec)
  "Converts the non-wild pathname designator PATHSPEC to directory form."
663
664
  (cond
   ((stringp pathspec)
665
    (ensure-directory-pathname (pathname pathspec)))
666
667
668
669
670
671
672
673
674
675
676
677
   ((not (pathnamep pathspec))
    (error "Invalid pathname designator ~S" pathspec))
   ((wild-pathname-p pathspec)
    (error "Can't reliably convert wild pathnames."))
   ((directory-pathname-p pathspec)
    pathspec)
   (t
    (make-pathname :directory (append (or (pathname-directory pathspec)
                                          (list :relative))
                                      (list (file-namestring pathspec)))
                   :name nil :type nil :version nil
                   :defaults pathspec))))
678

679
680
681
(defun absolute-pathname-p (pathspec)
  (eq :absolute (car (pathname-directory (pathname pathspec)))))

682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
(defun length=n-p (x n) ;is it that (= (length x) n) ?
  (check-type n (integer 0 *))
  (loop
    :for l = x :then (cdr l)
    :for i :downfrom n :do
    (cond
      ((zerop i) (return (null l)))
      ((not (consp l)) (return nil)))))

(defun ends-with (s suffix)
  (check-type s string)
  (check-type suffix string)
  (let ((start (- (length s) (length suffix))))
    (and (<= 0 start)
         (string-equal s suffix :start1 start))))
697

698
699
700
701
702
703
704
(defun read-file-forms (file)
  (with-open-file (in file)
    (loop :with eof = (list nil)
     :for form = (read in nil eof)
     :until (eq form eof)
     :collect form)))

705
#-(and (or win32 windows mswindows mingw32) (not cygwin))
706
(progn
707
#+clisp (defun get-uid () (posix:uid))
708
709
#+sbcl (defun get-uid () (sb-unix:unix-getuid))
#+cmu (defun get-uid () (unix:unix-getuid))
710
#+ecl (ffi:clines "#include <sys/types.h>" "#include <unistd.h>")
711
712
713
714
715
#+ecl (defun get-uid () (ffi:c-inline () () :int "getuid()" :one-liner t))
#+allegro (defun get-uid () (excl.osi:getuid))
#-(or cmu sbcl clisp allegro ecl)
(defun get-uid ()
  (let ((uid-string
716
         (with-output-to-string (*verbose-out*)
717
           (run-shell-command "id -ur"))))
718
719
720
721
722
    (with-input-from-string (stream uid-string)
      (read-line stream)
      (handler-case (parse-integer (read-line stream))
        (error () (error "Unable to find out user ID")))))))

723
724
725
726
727
728
(defun pathname-root (pathname)
  (make-pathname :host (pathname-host pathname)
                 :device (pathname-device pathname)
                 :directory '(:absolute)
                 :name nil :type nil :version nil))

729
730
(defun truenamize (p)
  "Resolve as much of a pathname as possible"
731
732
  (block nil
    (when (typep p 'logical-pathname) (return p))
733
    (let* ((p (merge-pathnames* p))
734
735
736
           (directory (pathname-directory p)))
      (when (typep p 'logical-pathname) (return p))
      (ignore-errors (return (truename p)))
737
738
      #-sbcl (when (stringp directory) (return p))
      (when (not (eq :absolute (car directory))) (return p))
739
      (let ((sofar (ignore-errors (truename (pathname-root p)))))
740
        (unless sofar (return p))
741
        (flet ((solution (directories)
742
743
                 (merge-pathnames*
                  (make-pathname :host nil :device nil
744
                                 :directory `(:relative ,@directories)
745
746
                                 :name (pathname-name p)
                                 :type (pathname-type p)
747
                                 :version (pathname-version p))
748
749
750
751
752
753
754
755
756
757
                  sofar)))
          (loop :for component :in (cdr directory)
            :for rest :on (cdr directory)
            :for more = (ignore-errors
                          (truename
                           (merge-pathnames*
                            (make-pathname :directory `(:relative ,component))
                            sofar))) :do
            (if more
                (setf sofar more)
758
                (return (solution rest)))
759
760
            :finally
            (return (solution nil))))))))
761

762
763
764
765
766
767
768
(defun resolve-symlinks (path)
  #-allegro (truenamize path)
  #+allegro (excl:pathname-resolve-symbolic-links path))

(defun default-directory ()
  (truenamize (pathname-directory-pathname *default-pathname-defaults*)))

769
770
771
(defun lispize-pathname (input-file)
  (make-pathname :type "lisp" :defaults input-file))

772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
(defparameter *wild-path*
  (make-pathname :directory '(:relative :wild-inferiors)
                 :name :wild :type :wild :version :wild))

(defun wilden (path)
  (merge-pathnames* *wild-path* path))

(defun directorize-pathname-host-device (pathname)
  (let* ((root (pathname-root pathname))
         (wild-root (wilden root))
         (absolute-pathname (merge-pathnames* pathname root))
         (foo (make-pathname :directory '(:absolute "FOO") :defaults root))
         (separator (last-char (namestring foo)))
         (root-namestring (namestring root))
         (root-string
          (substitute-if #\/
                         (lambda (x) (or (eql x #\:)
                                         (eql x separator)))
                         root-namestring)))
    (multiple-value-bind (relative path filename)
        (component-name-to-pathname-components root-string t)
      (declare (ignore relative filename))
      (let ((new-base
             (make-pathname :defaults root
                            :directory `(:absolute ,@path))))
        (translate-pathname absolute-pathname wild-root (wilden new-base))))))

799
800
;;;; -------------------------------------------------------------------------
;;;; Classes, Conditions
Daniel Barlow's avatar
Daniel Barlow committed
801

802
803
804
805
806
807
808
809
810
(define-condition system-definition-error (error) ()
  ;; [this use of :report should be redundant, but unfortunately it's not.
  ;; cmucl's lisp::output-instance prefers the kernel:slot-class-print-function
  ;; over print-object; this is always conditions::%print-condition for
  ;; condition objects, which in turn does inheritance of :report options at
  ;; run-time.  fortunately, inheritance means we only need this kludge here in
  ;; order to fix all conditions that build on it.  -- rgr, 28-Jul-02.]
  #+cmu (:report print-object))

811
812
813
814
815
816
817
818
819
(declaim (ftype (function (t) t)
                format-arguments format-control
                error-name error-pathname error-condition
                duplicate-names-name
                error-component error-operation
                module-components module-components-by-name)
         (ftype (function (t t) t) (setf module-components-by-name)))


Daniel Barlow's avatar
Daniel Barlow committed
820
(define-condition formatted-system-definition-error (system-definition-error)
821
822
823
  ((format-control :initarg :format-control :reader format-control)
   (format-arguments :initarg :format-arguments :reader format-arguments))
  (:report (lambda (c s)
824
             (apply #'format s (format-control c) (format-arguments c)))))
825

826
(define-condition load-system-definition-error (system-definition-error)
827
  ((name :initarg :name :reader error-name)
828
829
   (pathname :initarg :pathname :reader error-pathname)
   (condition :initarg :condition :reader error-condition))
830
  (:report (lambda (c s)
831
832
             (format s "~@<Error while trying to load definition for system ~A from pathname ~A: ~A~@:>"
                     (error-name c) (error-pathname c) (error-condition c)))))
833

Daniel Barlow's avatar
Daniel Barlow committed
834
(define-condition circular-dependency (system-definition-error)
835
  ((components :initarg :components :reader circular-dependency-components)))
836

837
(define-condition duplicate-names (system-definition-error)
838
839
840
841
  ((name :initarg :name :reader duplicate-names-name))
  (:report (lambda (c s)
             (format s "~@<Error while defining system: multiple components are given same name ~A~@:>"
                     (duplicate-names-name c)))))
842

843
844
845
846
(define-condition missing-component (system-definition-error)
  ((requires :initform "(unnamed)" :reader missing-requires :initarg :requires)
   (parent :initform nil :reader missing-parent :initarg :parent)))

847
848
849
(define-condition missing-component-of-version (missing-component)
  ((version :initform nil :reader missing-version :initarg :version)))

850
851
852
(define-condition missing-dependency (missing-component)
  ((required-by :initarg :required-by :reader missing-required-by)))

853
(define-condition missing-dependency-of-version (missing-dependency
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
854
                                                 missing-component-of-version)
855
856
  ())

Daniel Barlow's avatar
Daniel Barlow committed
857
858
859
860
(define-condition operation-error (error)
  ((component :reader error-component :initarg :component)
   (operation :reader error-operation :initarg :operation))
  (:report (lambda (c s)
861
862
             (format s "~@<erred while invoking ~A on ~A~@:>"
                     (error-operation c) (error-component c)))))
863
864
865
(define-condition compile-error (operation-error) ())
(define-condition compile-failed (compile-error) ())
(define-condition compile-warned (compile-error) ())
Daniel Barlow's avatar
Daniel Barlow committed
866
867

(defclass component ()
868
  ((name :accessor component-name :initarg :name :documentation
869
         "Component name: designator for a string composed of portable pathname characters")
Daniel Barlow's avatar
Daniel Barlow committed
870
   (version :accessor component-version :initarg :version)
871
872
   (in-order-to :initform nil :initarg :in-order-to
                :accessor component-in-order-to)
873
874
   ;; This one is used by POIU. Maybe in the future by ASDF instead of in-order-to?
   (load-dependencies :accessor component-load-dependencies :initform nil)
875
   ;; XXX crap name, but it's an official API name!
876
877
   (do-first :initform nil :initarg :do-first
             :accessor component-do-first)
878
879
880
881
   ;; methods defined using the "inline" style inside a defsystem form:
   ;; need to store them somewhere so we can delete them when the system
   ;; is re-evaluated
   (inline-methods :accessor component-inline-methods :initform nil)
Daniel Barlow's avatar
Daniel Barlow committed
882
   (parent :initarg :parent :initform nil :reader component-parent)
Daniel Barlow's avatar
Daniel Barlow committed
883
884
   ;; no direct accessor for pathname, we do this as a method to allow
   ;; it to default in funky ways if not supplied
Daniel Barlow's avatar
   
Daniel Barlow committed
885
   (relative-pathname :initarg :pathname)
886
   (absolute-pathname)
887
   (operation-times :initform (make-hash-table)
888
                    :accessor component-operation-times)
Daniel Barlow's avatar
   
Daniel Barlow committed
889
890
   ;; XXX we should provide some atomic interface for updating the
   ;; component properties
891
   (properties :accessor component-properties :initarg :properties
892
               :initform nil)))
Daniel Barlow's avatar
   
Daniel Barlow committed
893

894
895
896
897
898
899
900
901
902
903
(defun component-find-path (component)
  (reverse
   (loop :for c = component :then (component-parent c)
     :while c :collect (component-name c))))

(defmethod print-object ((c component) stream)
  (print-unreadable-object (c stream :type t :identity nil)
    (format stream "~@<~{~S~^ ~}~@:>" (component-find-path c))))


Daniel Barlow's avatar
   
Daniel Barlow committed
904
905
906
;;;; methods: conditions

(defmethod print-object ((c missing-dependency) s)
907
  (format s "~@<~A, required by ~A~@:>"
908
          (call-next-method c nil) (missing-required-by c)))
Daniel Barlow's avatar
   
Daniel Barlow committed
909
910

(defun sysdef-error (format &rest arguments)
911
  (error 'formatted-system-definition-error :format-control
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
912
         format :format-arguments arguments))
Daniel Barlow's avatar
Daniel Barlow committed
913

Daniel Barlow's avatar
   
Daniel Barlow committed
914
915
916
;;;; methods: components

(defmethod print-object ((c missing-component) s)
917
   (format s "~@<component ~S not found~
918
             ~@[ in ~A~]~@:>"
919
920
921
          (missing-requires c)
          (when (missing-parent c)
            (component-name (missing-parent c)))))
Daniel Barlow's avatar
   
Daniel Barlow committed
922

923
924
925
926
927
(defmethod print-object ((c missing-component-of-version) s)
  (format s "~@<component ~S does not match version ~A~
              ~@[ in ~A~]~@:>"
           (missing-requires c)
           (missing-version c)
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
928
929
           (when (missing-parent c)
             (component-name (missing-parent c)))))
930

Daniel Barlow's avatar
Daniel Barlow committed
931
932
933
934
935
(defmethod component-system ((component component))
  (aif (component-parent component)
       (component-system it)
       component))

936
937
938
(defvar *default-component-class* 'cl-source-file)

(defun compute-module-components-by-name (module)
939
940
  (let ((hash (make-hash-table :test 'equal)))
    (setf (module-components-by-name module) hash)
941
942
943
944
945
946
947
948
949
    (loop :for c :in (module-components module)
      :for name = (component-name c)
      :for previous = (gethash name (module-components-by-name module))
      :do
      (when previous
        (error 'duplicate-names :name name))
      :do (setf (gethash name (module-components-by-name module)) c))
    hash))

Daniel Barlow's avatar
Daniel Barlow committed
950
(defclass module (component)
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
  ((components
    :initform nil
    :initarg :components
    :accessor module-components)
   (components-by-name
    :accessor module-components-by-name)
   ;; What to do if we can't satisfy a dependency of one of this module's
   ;; components.  This allows a limited form of conditional processing.
   (if-component-dep-fails
    :initform :fail
    :initarg :if-component-dep-fails
    :accessor module-if-component-dep-fails)
   (default-component-class
    :initform *default-component-class*
    :initarg :default-component-class
    :accessor module-default-component-class)))
Daniel Barlow's avatar
Daniel Barlow committed
967

Daniel Barlow's avatar
   
Daniel Barlow committed
968
(defun component-parent-pathname (component)
969
970
971
972
973
974
975
  ;; No default anymore (in particular, no *default-pathname-defaults*).
  ;; If you force component to have a NULL pathname, you better arrange
  ;; for any of its children to explicitly provide a proper absolute pathname
  ;; wherever a pathname is actually wanted.
  (let ((parent (component-parent component)))
    (when parent
      (component-pathname parent))))
Daniel Barlow's avatar
   
Daniel Barlow committed
976
977

(defmethod component-pathname ((component component))
978
979
980
981
982
  (if (slot-boundp component 'absolute-pathname)
      (slot-value component 'absolute-pathname)
      (let ((pathname
             (merge-pathnames*
             (component-relative-pathname component)
983
             (pathname-directory-pathname (component-parent-pathname component)))))
984
985
986
987
        (unless (or (null pathname) (absolute-pathname-p pathname))
          (error "Invalid relative pathname ~S for component ~S" pathname component))
        (setf (slot-value component 'absolute-pathname) pathname)
        pathname)))
Daniel Barlow's avatar
   
Daniel Barlow committed
988

989
(defmethod component-property ((c component) property)
Daniel Barlow's avatar
Daniel Barlow committed
990
  (cdr (assoc property (slot-value c 'properties) :test #'equal)))
991
992

(defmethod (setf component-property) (new-value (c component) property)
Daniel Barlow's avatar
Daniel Barlow committed
993
  (let ((a (assoc property (slot-value c 'properties) :test #'equal)))
994
    (if a
995
996
        (setf (cdr a) new-value)
        (setf (slot-value c 'properties)
Francois-Rene Rideau's avatar
1.675.    
Francois-Rene Rideau committed
997
998
              (acons property new-value (slot-value c 'properties)))))
  new-value)
999

Daniel Barlow's avatar
   
Daniel Barlow committed
1000
1001
(defclass system (module)
  ((description :accessor system-description :initarg :description)
Daniel Barlow's avatar
Daniel Barlow committed
1002
1003
   (long-description
    :accessor system-long-description :initarg :long-description)
Daniel Barlow's avatar
   
Daniel Barlow committed
1004
1005
   (author :accessor system-author :initarg :author)
   (maintainer :accessor system-maintainer :initarg :maintainer)
1006
   (licence :accessor system-licence :initarg :licence
1007
1008
            :accessor system-license :initarg :license)
   (source-file :reader system-source-file :initarg :source-file
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
1009
                :writer %set-system-source-file)))
Daniel Barlow's avatar
   
Daniel Barlow committed
1010

1011
1012
;;;; -------------------------------------------------------------------------
;;;; version-satisfies
Daniel Barlow's avatar
   
Daniel Barlow committed
1013
1014
1015
1016

(defmethod version-satisfies ((c component) version)
  (unless (and version (slot-boundp c 'version))
    (return-from version-satisfies t))
1017
1018
1019
  (version-satisfies (component-version c) version))

(defmethod version-satisfies ((cver string) version)
Daniel Barlow's avatar
   
Daniel Barlow committed
1020
  (let ((x (mapcar #'parse-integer
1021
                   (split-string cver :separator ".")))
1022
        (y (mapcar #'parse-integer
1023
                   (split-string version :separator "."))))
Daniel Barlow's avatar
   
Daniel Barlow committed
1024
    (labels ((bigger (x y)
1025
1026
1027
1028
1029
               (cond ((not y) t)
                     ((not x) nil)
                     ((> (car x) (car y)) t)
                     ((= (car x) (car y))
                      (bigger (cdr x) (cdr y))))))
Daniel Barlow's avatar
   
Daniel Barlow committed
1030
      (and (= (car x) (car y))
1031
           (or (not (cdr y)) (bigger (cdr x) (cdr y)))))))
Daniel Barlow's avatar
   
Daniel Barlow committed
1032

1033
1034
;;;; -------------------------------------------------------------------------
;;;; Finding systems
Daniel Barlow's avatar
   
Daniel Barlow committed
1035

Gary King's avatar
Gary King committed
1036
1037
1038
(defun make-defined-systems-table ()
  (make-hash-table :test 'equal))

1039
1040
1041
1042
1043
1044
(defvar *defined-systems* (make-defined-systems-table)
  "This is a hash table whose keys are strings, being the
names of the systems, and whose values are pairs, the first
element of which is a universal-time indicating when the
system definition was last updated, and the second element
of which is a system object.")
Gary King's avatar
Gary King committed
1045

Daniel Barlow's avatar
   
Daniel Barlow committed
1046
(defun coerce-name (name)
1047
1048
1049
1050
1051
  (typecase name
    (component (component-name name))
    (symbol (string-downcase (symbol-name name)))
    (string name)
    (t (sysdef-error "~@<invalid component designator ~A~@:>" name))))
Daniel Barlow's avatar
   
Daniel Barlow committed
1052

1053
1054
1055
(defun system-registered-p (name)
  (gethash (coerce-name name) *defined-systems*))

Gary King's avatar
Gary King committed
1056
(defun map-systems (fn)
1057
  "Apply FN to each defined system.
Gary King's avatar
Gary King committed
1058

1059
FN should be a function of one argument. It will be
Gary King's avatar
Gary King committed
1060
1061
called with an object of type asdf:system."
  (maphash (lambda (_ datum)
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
1062
1063
1064
1065
1066
             (declare (ignore _))
             (destructuring-bind (_ . def) datum
               (declare (ignore _))
               (funcall fn def)))
           *defined-systems*))
1067

1068
1069
1070
;;; for the sake of keeping things reasonably neat, we adopt a
;;; convention that functions in this list are prefixed SYSDEF-

1071
(defparameter *system-definition-search-functions*
1072
1073
1074
1075
1076
1077
1078
1079
1080
  '(sysdef-central-registry-search sysdef-source-registry-search sysdef-find-asdf))

(defun sysdef-find-asdf (system)
  (let ((name (coerce-name system)))
    (when (equal name "asdf")
      (eval
       `(defsystem :asdf
          :pathname ,(or *compile-file-truename* *load-truename*)
          :depends-on () :components ())))))
1081

1082
(defun system-definition-pathname (system)
1083
1084
1085
  (let ((system-name (coerce-name system)))
    (or
     (some (lambda (x) (funcall x system-name))
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
1086
           *system-definition-search-functions*)
1087
     (let ((system-pair (system-registered-p system-name)))
1088
       (and system-pair
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
1089
            (system-source-file (cdr system-pair)))))))
1090

Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
1091
(defvar *central-registry* nil
1092
1093
"A list of 'system directory designators' ASDF uses to find systems.

Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
1094
A 'system directory designator' is a pathname or an expression
1095
1096
1097
1098
1099
1100
which evaluates to a pathname. For example:

    (setf asdf:*central-registry*
          (list '*default-pathname-defaults*
                #p\"/home/me/cl/systems/\"
                #p\"/usr/share/common-lisp/systems/\"))
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
1101
1102
1103

This is for backward compatibilily.
Going forward, we recommend new users should be using the source-registry.
1104
")
1105

1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
(defun probe-asd (name defaults)
  (block nil
    (when (directory-pathname-p defaults)
      (let ((file
             (make-pathname
              :defaults defaults :version :newest :case :local
              :name name
              :type "asd")))
        (when (probe-file file)
          (return file)))
      #+(and (or win32 windows mswindows mingw32) (not cygwin) (not clisp))
      (let ((shortcut
             (make-pathname
              :defaults defaults :version :newest :case :local
              :name (concatenate 'string name ".asd")
              :type "lnk")))
        (when (probe-file shortcut)
          (let ((target (parse-windows-shortcut shortcut)))
            (when target
              (return (pathname target)))))))))

1127
(defun sysdef-central-registry-search (system)
1128
  (let ((name (coerce-name system))
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
1129
1130
        (to-remove nil)
        (to-replace nil))
1131
    (block nil
1132
      (unwind-protect
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
1133
1134
1135
1136
           (dolist (dir *central-registry*)
             (let ((defaults (eval dir)))
               (when defaults
                 (cond ((directory-pathname-p defaults)
1137
1138
1139
                        (let ((file (probe-asd name defaults)))
                          (when file
                            (return file))))
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
1140
1141
1142
1143
1144
                       (t
                        (restart-case
                            (let* ((*print-circle* nil)
                                   (message
                                    (format nil
1145
1146
                                            "~@<While searching for system ~S: ~S evaluated ~
to ~S which is not a directory.~@:>"
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
                                            system dir defaults)))
                              (error message))
                          (remove-entry-from-registry ()
                            :report "Remove entry from *central-registry* and continue"
                            (push dir to-remove))
                          (coerce-entry-to-directory ()
                            :report (lambda (s)
                                      (format s "Coerce entry to ~a, replace ~a and continue."
                                              (ensure-directory-pathname defaults) dir))
                            (push (cons dir (ensure-directory-pathname defaults)) to-replace))))))))
        ;; cleanup
        (dolist (dir to-remove)
          (setf *central-registry* (remove dir *central-registry*)))
        (dolist (pair to-replace)
          (let* ((current (car pair))
                 (new (cdr pair))
                 (position (position current *central-registry*)))
            (setf *central-registry*
                  (append (subseq *central-registry* 0 position)
                          (list new)
                          (subseq *central-registry* (1+ position))))))))))
1168

Christophe Rhodes's avatar
Fixes    
Christophe Rhodes committed
1169
1170
1171
(defun make-temporary-package ()
  (flet ((try (counter)
           (ignore-errors
1172
             (make-package (format nil "~A~D" :asdf counter)
1173
                           :use '(:cl :asdf)))))
Christophe Rhodes's avatar
Fixes    
Christophe Rhodes committed
1174
1175
1176
    (do* ((counter 0 (+ counter 1))
          (package (try counter) (try counter)))
         (package package))))
1177

1178
(defun safe-file-write-date (pathname)
1179
1180
1181
1182
1183
1184
1185
1186
  ;; If FILE-WRITE-DATE returns NIL, it's possible that
  ;; the user or some other agent has deleted an input file.
  ;; Also, generated files will not exist at the time planning is done
  ;; and calls operation-done-p which calls safe-file-write-date.
  ;; So it is very possible that we can't get a valid file-write-date,
  ;; and we can survive and we will continue the planning
  ;; as if the file were very old.
  ;; (or should we treat the case in a different, special way?)
1187
  (or (and pathname (probe-file pathname) (file-write-date pathname))
1188
      (progn
1189
1190
1191
        (when pathname
          (warn "Missing FILE-WRITE-DATE for ~S: treating it as zero."
                pathname))
1192
        0)))
1193

Daniel Barlow's avatar
   
Daniel Barlow committed
1194
1195
(defun find-system (name &optional (error-p t))
  (let* ((name (coerce-name name))
1196
         (in-memory (system-registered-p name))
1197
         (on-disk (system-definition-pathname name)))
Daniel Barlow's avatar
   
Daniel Barlow committed
1198
    (when (and on-disk
1199
               (or (not in-memory)
1200
                   (< (car in-memory) (safe-file-write-date on-disk))))
Christophe Rhodes's avatar
Fixes    
Christophe Rhodes committed
1201
1202
      (let ((package (make-temporary-package)))
        (unwind-protect
1203
1204
1205
1206
1207
1208
1209
1210
             (handler-bind
                 ((error (lambda (condition)
                           (error 'load-system-definition-error
                                  :name name :pathname on-disk
                                  :condition condition))))
               (let ((*package* package))
                 (asdf-message
                  "~&~@<; ~@;loading system definition from ~A into ~A~@:>~%"
1211
                  on-disk *package*)
1212
                 (load on-disk)))
Christophe Rhodes's avatar
Fixes    
Christophe Rhodes committed
1213
          (delete-package package))))
1214
    (let ((in-memory (system-registered-p name)))
Daniel Barlow's avatar
   
Daniel Barlow committed
1215
      (if in-memory