asdf.lisp 153 KB
Newer Older
1
;;; -*- mode: common-lisp; package: asdf; -*-
2
;;; This is ASDF 2.012.6: 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
14
15
;;; bugs.  There are usually two "supported" revisions - the git master
;;; branch is the latest development version, whereas the git release
;;; branch may be slightly older but is considered `stable'
16

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
(cl:in-package :cl-user)
51

52
53
#+gcl (defpackage :asdf (:use :cl)) ;; GCL treats defpackage magically and needs this

54
(eval-when (:compile-toplevel :load-toplevel :execute)
55
56
57
58
59
  ;;; make package if it doesn't exist yet.
  ;;; DEFPACKAGE may cause errors on discrepancies, so we avoid it.
  (unless (find-package :asdf)
    (make-package :asdf :use '(:cl)))
  ;;; Implementation-dependent tweaks
60
  ;; (declaim (optimize (speed 2) (debug 2) (safety 3))) ; NO: rely on the implementation defaults.
61
62
63
64
  #+allegro
  (setf excl::*autoload-package-name-alist*
        (remove "asdf" excl::*autoload-package-name-alist*
                :test 'equalp :key 'car))
65
  #+(and ecl (not ecl-bytecmp)) (require :cmp)
66
67
  #+(and (or win32 windows mswindows mingw32) (not cygwin)) (pushnew :asdf-windows *features*)
  #+(or unix cygwin) (pushnew :asdf-unix *features*))
68
69

(in-package :asdf)
70

71
;;;; Create packages in a way that is compatible with hot-upgrade.
72
;;;; See https://bugs.launchpad.net/asdf/+bug/485687
73
;;;; See more near the end of the file.
74

75
(eval-when (:load-toplevel :compile-toplevel :execute)
76
77
  (defvar *asdf-version* nil)
  (defvar *upgraded-p* nil)
78
  (let* (;; For bug reporting sanity, please always bump this version when you modify this file.
79
80
         ;; Please also modify asdf.asd to reflect this change. The script bin/bump-version
         ;; can help you do these changes in synch (look at the source for documentation).
81
         ;; Relying on its automation, the version is now redundantly present on top of this file.
82
83
         ;; "2.345" would be an official release
         ;; "2.345.6" would be a development version in the official upstream
84
85
         ;; "2.345.0.7" would be your seventh local modification of official release 2.345
         ;; "2.345.6.7" would be your seventh local modification of development version 2.345.6
86
         (asdf-version "2.012.6")
87
88
         (existing-asdf (fboundp 'find-system))
         (existing-version *asdf-version*)
89
90
         (already-there (equal asdf-version existing-version)))
    (unless (and existing-asdf already-there)
91
      (when existing-asdf
92
93
94
        (format *trace-output*
         "~&~@<; ~@;Upgrading ASDF package ~@[from version ~A ~]to version ~A~@:>~%"
         existing-version asdf-version))
95
      (labels
96
97
98
99
100
101
102
103
          ((unlink-package (package)
             (let ((u (find-package package)))
               (when u
                 (ensure-unintern u
                   (loop :for s :being :each :present-symbol :in u :collect s))
                 (loop :for p :in (package-used-by-list u) :do
                   (unuse-package u p))
                 (delete-package u))))
104
           (ensure-exists (name nicknames use)
105
106
107
108
109
110
111
112
113
114
             (let ((previous
                    (remove-duplicates
                     (mapcar #'find-package (cons name nicknames))
                     :from-end t)))
               ;; do away with packages with conflicting (nick)names
               (map () #'unlink-package (cdr previous))
               ;; reuse previous package with same name
               (let ((p (car previous)))
                 (cond
                   (p
115
116
                    (rename-package p name nicknames)
                    (ensure-use p use)
117
118
119
                    p)
                   (t
                    (make-package name :nicknames nicknames :use use))))))
120
121
122
123
124
125
126
127
           (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)
128
129
                 (unintern sym package)
                 sym)))
130
           (ensure-unintern (package symbols)
131
132
133
134
135
136
137
             (loop :with packages = (list-all-packages)
               :for sym :in symbols
               :for removed = (remove-symbol sym package)
               :when removed :do
               (loop :for p :in packages :do
                 (when (eq removed (find-sym sym p))
                   (unintern removed p)))))
138
139
140
141
142
143
144
145
146
147
148
149
150
           (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)
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
             (let ((formerly-exported-symbols nil)
                   (bothly-exported-symbols nil)
                   (newly-exported-symbols nil))
               (loop :for sym :being :each :external-symbol :in package :do
                 (if (member sym export :test 'string-equal)
                     (push sym bothly-exported-symbols)
                     (push sym formerly-exported-symbols)))
               (loop :for sym :in export :do
                 (unless (member sym bothly-exported-symbols :test 'string-equal)
                   (push sym newly-exported-symbols)))
               (loop :for user :in (package-used-by-list package)
                 :for shadowing = (package-shadowing-symbols user) :do
                 (loop :for new :in newly-exported-symbols
                   :for old = (find-sym new user)
                   :when (and old (not (member old shadowing)))
                   :do (unintern old user)))
               (loop :for x :in newly-exported-symbols :do
                 (export (intern* x package)))))
169
           (ensure-package (name &key nicknames use unintern fmakunbound shadow export)
170
             (let* ((p (ensure-exists name nicknames use)))
171
172
173
174
175
176
177
178
               (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)
179
180
181
182
183
                 `(ensure-package
                   ',name :nicknames ',nicknames :use ',use :export ',export
                   :shadow ',shadow
                   :unintern ',(append #-(or gcl ecl) redefined-functions unintern)
                   :fmakunbound ',(append fmakunbound))))
184
185
          (pkgdcl
           :asdf
186
           :nicknames (:asdf-utilities) ;; DEPRECATED! Do not use, for backward compatibility only.
187
           :use (:common-lisp)
188
189
190
           :redefined-functions
           (#:perform #:explain #:output-files #:operation-done-p
            #:perform-with-restarts #:component-relative-pathname
191
            #:system-source-file #:operate #:find-component #:find-system
192
193
            #:apply-output-translations #:translate-pathname* #:resolve-location
            #:compile-file*)
194
195
           :unintern
           (#:*asdf-revision* #:around #:asdf-method-combination
196
197
            #:split #:make-collector
            #:output-files-for-system-and-operation) ; obsolete ASDF-BINARY-LOCATION function
198
199
200
201
202
203
204
205
           :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
206
            #:compile-system #:load-system #:test-system #:clear-system
207
208
209
210
211
212
213
            #:compile-op #:load-op #:load-source-op
            #:test-op
            #:operation               ; operations
            #:feature                 ; sort-of operation
            #:version                 ; metaphorically sort-of an operation
            #:version-satisfies

214
            #:input-files #:output-files #:output-file #:perform ; operation methods
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
            #: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

251
            #:operation-description
252
253
            #:operation-on-warnings
            #:operation-on-failure
254
            #:component-visited-p
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
            ;;#:*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

284
            #:clear-configuration
285
286
287
288
289
            #:initialize-output-translations
            #:disable-output-translations
            #:clear-output-translations
            #:ensure-output-translations
            #:apply-output-translations
290
            #:compile-file*
291
292
293
294
295
296
297
            #:compile-file-pathname*
            #:enable-asdf-binary-locations-compatibility
            #:*default-source-registries*
            #:initialize-source-registry
            #:compute-source-registry
            #:clear-source-registry
            #:ensure-source-registry
298
            #:process-source-registry
299
300
            #:system-registered-p
            #:asdf-message
301

302
303
            ;; Utilities
            #:absolute-pathname-p
304
            ;; #:aif #:it
305
            ;; #:appendf
306
307
            #:coerce-name
            #:directory-pathname-p
308
            ;; #:ends-with
309
310
            #:ensure-directory-pathname
            #:getenv
311
312
            ;; #:get-uid
            ;; #:length=n-p
313
            ;; #:find-symbol*
314
315
316
            #:merge-pathnames*
            #:pathname-directory-pathname
            #:read-file-forms
317
318
            ;; #:remove-keys
            ;; #:remove-keyword
319
320
321
322
            #:resolve-symlinks
            #:split-string
            #:component-name-to-pathname-components
            #:split-name-type
323
            #:subdirectories
324
325
326
327
328
329
            #:truenamize
            #:while-collecting)))
        (setf *asdf-version* asdf-version
              *upgraded-p* (if existing-version
                               (cons existing-version *upgraded-p*)
                               *upgraded-p*))))))
Daniel Barlow's avatar
Daniel Barlow committed
330

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

340
341
342
(defvar *resolve-symlinks* t
  "Determine whether or not ASDF resolves symlinks when defining systems.

343
Defaults to T.")
344

345
346
347
348
(defvar *compile-file-warnings-behaviour*
  (or #+clisp :ignore :warn)
  "How should ASDF react if it encounters a warning when compiling a file?
Valid values are :error, :warn, and :ignore.")
349

350
351
352
353
354
(defvar *compile-file-failure-behaviour*
  (or #+sbcl :error #+clisp :ignore :warn)
  "How should ASDF react if it encounters a failure (per the ANSI spec of COMPILE-FILE)
when compiling a file?  Valid values are :error, :warn, and :ignore.
Note that ASDF ALWAYS raises an error if it fails to create an output file when compiling.")
Daniel Barlow's avatar
   
Daniel Barlow committed
355

356
(defvar *verbose-out* nil)
357

358
359
(defvar *asdf-verbose* t)

360
(defparameter +asdf-methods+
361
  '(perform-with-restarts perform explain output-files operation-done-p))
362

363
#+allegro
364
(eval-when (:compile-toplevel :execute)
365
366
367
368
369
370
  (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)))

371
;;;; -------------------------------------------------------------------------
372
373
;;;; General Purpose Utilities

374
375
376
377
378
379
380
381
382
383
(macrolet
    ((defdef (def* def)
       `(defmacro ,def* (name formals &rest rest)
          `(progn
             #+(or ecl gcl) (fmakunbound ',name)
             ,(when (and #+ecl (symbolp name))
                `(declaim (notinline ,name))) ; fails for setf functions on ecl
             (,',def ,name ,formals ,@rest)))))
  (defdef defgeneric* defgeneric)
  (defdef defun* defun))
384

385
(defmacro while-collecting ((&rest collectors) &body body)
386
387
388
389
390
391
392
393
394
395
  "COLLECTORS should be a list of names for collections.  A collector
defines a function that, when applied to an argument inside BODY, will
add its argument to the corresponding collection.  Returns multiple values,
a list for each collection, in order.
   E.g.,
\(while-collecting \(foo bar\)
           \(dolist \(x '\(\(a 1\) \(b 2\) \(c 3\)\)\)
             \(foo \(first x\)\)
             \(bar \(second x\)\)\)\)
Returns two values: \(A B C\) and \(1 2 3\)."
396
397
398
  (let ((vars (mapcar #'(lambda (x) (gensym (symbol-name x))) collectors))
        (initial-values (mapcar (constantly nil) collectors)))
    `(let ,(mapcar #'list vars initial-values)
399
       (flet ,(mapcar #'(lambda (c v) `(,c (x) (push x ,v) (values))) collectors vars)
400
         ,@body
401
         (values ,@(mapcar #'(lambda (v) `(reverse ,v)) vars))))))
402

403
404
405
(defmacro aif (test then &optional else)
  `(let ((it ,test)) (if it ,then ,else)))

406
(defun* pathname-directory-pathname (pathname)
407
408
  "Returns a new pathname with same HOST, DEVICE, DIRECTORY as PATHNAME,
and NIL NAME, TYPE and VERSION components"
409
410
  (when pathname
    (make-pathname :name nil :type nil :version nil :defaults pathname)))
411

412
(defun* merge-pathnames* (specified &optional (defaults *default-pathname-defaults*))
413
  "MERGE-PATHNAMES* is like MERGE-PATHNAMES except that if the SPECIFIED pathname
414
415
416
417
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))
418
419
420
  (let* ((specified (pathname specified))
         (defaults (pathname defaults))
         (directory (pathname-directory specified))
421
422
         (directory
          (cond
423
            #-(or sbcl cmu scl)
424
425
            ((stringp directory) `(:absolute ,directory) directory)
            #+gcl
426
427
            ((and (consp directory) (not (member (first directory) '(:absolute :relative))))
             `(:relative ,@directory))
428
429
430
431
432
            ((or (null directory)
                 (and (consp directory) (member (first directory) '(:absolute :relative))))
             directory)
            (t
             (error "Unrecognized directory component ~S in pathname ~S" directory specified))))
433
434
435
         (name (or (pathname-name specified) (pathname-name defaults)))
         (type (or (pathname-type specified) (pathname-type defaults)))
         (version (or (pathname-version specified) (pathname-version defaults))))
436
437
438
439
440
    (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)
441
          (ecase (first directory)
442
443
444
445
446
447
448
449
450
451
452
453
454
            ((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)
455
456
457
                     (if (pathname-directory defaults)
                         (append (pathname-directory defaults) (cdr directory))
                         directory)
458
459
460
461
462
                     (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))))))
463

464
(define-modify-macro appendf (&rest args)
465
466
467
468
  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
469

470
(defun* first-char (s)
471
472
  (and (stringp s) (plusp (length s)) (char s 0)))

473
(defun* last-char (s)
474
475
  (and (stringp s) (plusp (length s)) (char s (1- (length s)))))

476
(defun* asdf-message (format-string &rest format-args)
477
478
479
  (declare (dynamic-extent format-args))
  (apply #'format *verbose-out* format-string format-args))

480
(defun* split-string (string &key max (separator '(#\Space #\Tab)))
481
482
  "Split STRING into a list of components separated by
any of the characters in the sequence SEPARATOR.
483
484
485
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\")."
486
487
488
489
490
491
492
493
494
495
496
497
498
  (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))))))
499

500
(defun* split-name-type (filename)
501
502
503
504
  (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.
505
         (or #+(or clozure gcl lispworks sbcl) :unspecific)))
506
507
508
509
510
    (destructuring-bind (name &optional (type unspecific))
        (split-string filename :max 2 :separator ".")
      (if (equal name "")
          (values filename unspecific)
          (values name type)))))
511

512
(defun* component-name-to-pathname-components (s &key force-directory force-relative)
513
514
515
516
517
518
519
520
521
522
  "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
523
524
525
526
527
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."
528
  (check-type s string)
529
530
  (when (find #\: s)
    (error "a portable ASDF pathname designator cannot include a #\: character: ~S" s))
531
  (let* ((components (split-string s :separator "/"))
532
533
534
         (last-comp (car (last components))))
    (multiple-value-bind (relative components)
        (if (equal (first components) "")
535
            (if (equal (first-char s) #\/)
536
537
538
539
                (progn
                  (when force-relative
                    (error "absolute pathname designator not allowed: ~S" s))
                  (values :absolute (cdr components)))
540
                (values :relative nil))
541
          (values :relative components))
542
      (setf components (remove "" components :test #'equal))
543
544
      (cond
        ((equal last-comp "")
545
         (values relative components nil)) ; "" already removed
546
547
548
549
        (force-directory
         (values relative components nil))
        (t
         (values relative (butlast components) last-comp))))))
550

551
(defun* remove-keys (key-names args)
552
553
554
555
556
  (loop :for (name val) :on args :by #'cddr
    :unless (member (symbol-name name) key-names
                    :key #'symbol-name :test 'equal)
    :append (list name val)))

557
(defun* remove-keyword (key args)
558
559
560
  (loop :for (k v) :on args :by #'cddr
    :unless (eq k key)
    :append (list k v)))
561

562
563
564
565
#+mcl
(eval-when (:compile-toplevel :load-toplevel :execute)
  (ccl:define-entry-point (_getenv "getenv") ((name :string)) :string))

566
(defun* getenv (x)
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
  (declare (ignorable x))
  #+(or abcl clisp) (ext:getenv x)
  #+allegro (sys:getenv x)
  #+clozure (ccl:getenv x)
  #+(or cmu scl) (cdr (assoc x ext:*environment-list* :test #'string=))
  #+ecl (si:getenv x)
  #+gcl (system:getenv x)
  #+genera nil
  #+lispworks (lispworks:environment-variable x)
  #+mcl (ccl:with-cstrs ((name x))
          (let ((value (_getenv name)))
            (unless (ccl:%null-ptr-p value)
              (ccl:%get-cstring value))))
  #+sbcl (sb-ext:posix-getenv x)
  #-(or abcl allegro clisp clozure cmu ecl gcl genera lispworks mcl sbcl scl)
  (error "getenv not available on your implementation"))
583

584
(defun* directory-pathname-p (pathname)
585
  "Does PATHNAME represent a directory?
586
587

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

591
Note that this does _not_ check to see that PATHNAME points to an
592
actually-existing directory."
593
594
595
596
597
598
599
600
  (when pathname
    (let ((pathname (pathname pathname)))
      (flet ((check-one (x)
               (member x '(nil :unspecific "") :test 'equal)))
        (and (not (wild-pathname-p pathname))
             (check-one (pathname-name pathname))
             (check-one (pathname-type pathname))
             t)))))
601

602
(defun* ensure-directory-pathname (pathspec)
603
  "Converts the non-wild pathname designator PATHSPEC to directory form."
604
605
  (cond
   ((stringp pathspec)
606
    (ensure-directory-pathname (pathname pathspec)))
607
608
609
   ((not (pathnamep pathspec))
    (error "Invalid pathname designator ~S" pathspec))
   ((wild-pathname-p pathspec)
610
    (error "Can't reliably convert wild pathname ~S" pathspec))
611
612
613
614
615
616
617
618
   ((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))))
619

620
(defun* absolute-pathname-p (pathspec)
621
622
  (and (typep pathspec '(or pathname string))
       (eq :absolute (car (pathname-directory (pathname pathspec))))))
623

624
(defun* length=n-p (x n) ;is it that (= (length x) n) ?
625
626
627
628
629
630
631
632
  (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)))))

633
(defun* ends-with (s suffix)
634
635
636
637
638
  (check-type s string)
  (check-type suffix string)
  (let ((start (- (length s) (length suffix))))
    (and (<= 0 start)
         (string-equal s suffix :start1 start))))
639

640
(defun* read-file-forms (file)
641
642
643
644
645
646
  (with-open-file (in file)
    (loop :with eof = (list nil)
     :for form = (read in nil eof)
     :until (eq form eof)
     :collect form)))

647
#+asdf-unix
648
(progn
649
650
  #+ecl #.(cl:and (cl:< ext:+ecl-version-number+ 100601)
                  '(ffi:clines "#include <sys/types.h>" "#include <unistd.h>"))
651
  (defun* get-uid ()
652
    #+allegro (excl.osi:getuid)
653
    #+clisp (loop :for s :in '("posix:uid" "LINUX:getuid")
654
                  :for f = (ignore-errors (read-from-string s))
655
                  :when f :return (funcall f))
656
657
658
659
660
661
662
663
664
665
666
667
668
    #+(or cmu scl) (unix:unix-getuid)
    #+ecl #.(cl:if (cl:< ext:+ecl-version-number+ 100601)
                   '(ffi:c-inline () () :int "getuid()" :one-liner t)
                   '(ext::getuid))
    #+sbcl (sb-unix:unix-getuid)
    #-(or allegro clisp cmu ecl sbcl scl)
    (let ((uid-string
           (with-output-to-string (*verbose-out*)
             (run-shell-command "id -ur"))))
      (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")))))))
669

670
(defun* pathname-root (pathname)
671
672
673
674
675
  (make-pathname :host (pathname-host pathname)
                 :device (pathname-device pathname)
                 :directory '(:absolute)
                 :name nil :type nil :version nil))

676
677
678
(defun* find-symbol* (s p)
  (find-symbol (string s) p))

679
(defun* probe-file* (p)
680
681
  "when given a pathname P, probes the filesystem for a file or directory
with given pathname and if it exists return its truename."
682
683
684
685
686
  (etypecase p
   (null nil)
   (string (probe-file* (parse-namestring p)))
   (pathname (unless (wild-pathname-p p)
               #.(or #+(or allegro clozure cmu ecl sbcl scl) '(probe-file p)
687
688
                     #+clisp (aif (find-symbol (string '#:probe-pathname) :ext) `(ignore-errors (,it p)))
                     '(ignore-errors (truename p)))))))
689

690
(defun* truenamize (p)
691
  "Resolve as much of a pathname as possible"
692
693
  (block nil
    (when (typep p 'logical-pathname) (return p))
694
    (let* ((p (merge-pathnames* p))
695
696
           (directory (pathname-directory p)))
      (when (typep p 'logical-pathname) (return p))
697
698
      (let ((found (probe-file* p)))
        (when found (return found)))
699
      #-(or sbcl cmu) (when (stringp directory) (return p))
700
      (when (not (eq :absolute (car directory))) (return p))
701
      (let ((sofar (probe-file* (pathname-root p))))
702
        (unless sofar (return p))
703
        (flet ((solution (directories)
704
705
                 (merge-pathnames*
                  (make-pathname :host nil :device nil
706
                                 :directory `(:relative ,@directories)
707
708
                                 :name (pathname-name p)
                                 :type (pathname-type p)
709
                                 :version (pathname-version p))
710
711
712
                  sofar)))
          (loop :for component :in (cdr directory)
            :for rest :on (cdr directory)
713
714
715
716
            :for more = (probe-file*
                         (merge-pathnames*
                          (make-pathname :directory `(:relative ,component))
                          sofar)) :do
717
718
            (if more
                (setf sofar more)
719
                (return (solution rest)))
720
721
            :finally
            (return (solution nil))))))))
722

723
(defun* resolve-symlinks (path)
724
  #-allegro (truenamize path)
725
726
727
  #+allegro (if (typep path 'logical-pathname)
                path
                (excl:pathname-resolve-symbolic-links path)))
728

729
(defun* default-directory ()
730
731
  (truenamize (pathname-directory-pathname *default-pathname-defaults*)))

732
(defun* lispize-pathname (input-file)
733
734
  (make-pathname :type "lisp" :defaults input-file))

735
736
737
738
739
740
(defparameter *wild-file*
  (make-pathname :name :wild :type :wild :version :wild :directory nil))
(defparameter *wild-directory*
  (make-pathname :directory '(:relative :wild) :name nil :type nil :version nil))
(defparameter *wild-inferiors*
  (make-pathname :directory '(:relative :wild-inferiors) :name nil :type nil :version nil))
741
(defparameter *wild-path*
742
  (merge-pathnames *wild-file* *wild-inferiors*))
743

744
(defun* wilden (path)
745
746
  (merge-pathnames* *wild-path* path))

747
748
749
750
(defun directory-separator-for-host (&optional (pathname *default-pathname-defaults*))
  (let ((foo (make-pathname :directory '(:absolute "FOO") :defaults pathname)))
    (last-char (namestring foo))))

751
(defun* directorize-pathname-host-device (pathname)
752
753
754
  (let* ((root (pathname-root pathname))
         (wild-root (wilden root))
         (absolute-pathname (merge-pathnames* pathname root))
755
         (separator (directory-separator-for-host root))
756
757
758
759
760
761
762
         (root-namestring (namestring root))
         (root-string
          (substitute-if #\/
                         (lambda (x) (or (eql x #\:)
                                         (eql x separator)))
                         root-namestring)))
    (multiple-value-bind (relative path filename)
763
        (component-name-to-pathname-components root-string :force-directory t)
764
765
766
767
768
769
      (declare (ignore relative filename))
      (let ((new-base
             (make-pathname :defaults root
                            :directory `(:absolute ,@path))))
        (translate-pathname absolute-pathname wild-root (wilden new-base))))))

770
771
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
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
;;;; -------------------------------------------------------------------------
;;;; ASDF Interface, in terms of generic functions.
(defgeneric* find-system (system &optional error-p))
(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))
(defgeneric* component-operation-time (operation component))
(defgeneric* operation-description (operation component)
  (:documentation "returns a phrase that describes performing this operation
on this component, e.g. \"loading /a/b/c\".
You can put together sentences using this phrase."))

(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)
  (: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."))

(defgeneric* component-property (component property))

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

(defgeneric* version-satisfies (component version))

(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."))

(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"))

(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
it as (cdr (component-visited-p op c)).
  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."))

(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.
  Starting with 2.006, TRAVERSE will store an integer in data,
so that nodes can be sorted in decreasing order of traversal."))


(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))

(defgeneric* traverse (operation component)
  (:documentation
"Generate and return a plan for performing OPERATION on COMPONENT.

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."))


;;;; -------------------------------------------------------------------------
;;; Methods in case of hot-upgrade. See https://bugs.launchpad.net/asdf/+bug/485687
(when *upgraded-p*
   (when (find-class 'module nil)
     (eval
      `(defmethod update-instance-for-redefined-class :after
           ((m module) added deleted plist &key)
         (declare (ignorable deleted plist))
         (when (or *asdf-verbose* *load-verbose*)
           (asdf-message "~&~@<; ~@; Updating ~A for ASDF ~A~@:>~%" m ,(asdf-version)))
         (when (member 'components-by-name added)
           (compute-module-components-by-name m))
888
889
890
891
892
893
         (when (typep m 'system)
           (when (member 'source-file added)
             (%set-system-source-file
              (probe-asd (component-name m) (component-pathname m)) m)
             (when (equal (component-name m) "asdf")
               (setf (component-version m) *asdf-version*))))))))
894

895
896
;;;; -------------------------------------------------------------------------
;;;; Classes, Conditions
Daniel Barlow's avatar
Daniel Barlow committed
897

898
899
900
901
902
903
904
905
906
(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))

907
908
909
910
911
(declaim (ftype (function (t) t)
                format-arguments format-control
                error-name error-pathname error-condition
                duplicate-names-name
                error-component error-operation
912
913
                module-components module-components-by-name
                circular-dependency-components)
914
915
916
         (ftype (function (t t) t) (setf module-components-by-name)))


Daniel Barlow's avatar
Daniel Barlow committed
917
(define-condition formatted-system-definition-error (system-definition-error)
918
919
920
  ((format-control :initarg :format-control :reader format-control)
   (format-arguments :initarg :format-arguments :reader format-arguments))
  (:report (lambda (c s)
921
             (apply #'format s (format-control c) (format-arguments c)))))
922

923
(define-condition load-system-definition-error (system-definition-error)
924
  ((name :initarg :name :reader error-name)
925
926
   (pathname :initarg :pathname :reader error-pathname)
   (condition :initarg :condition :reader error-condition))
927
  (:report (lambda (c s)
928
929
             (format s "~@<Error while trying to load definition for system ~A from pathname ~A: ~A~@:>"
                     (error-name c) (error-pathname c) (error-condition c)))))
930

Daniel Barlow's avatar
Daniel Barlow committed
931
(define-condition circular-dependency (system-definition-error)
932
933
934
  ((components :initarg :components :reader circular-dependency-components))
  (:report (lambda (c s)
             (format s "~@<Circular dependency: ~S~@:>" (circular-dependency-components c)))))
935

936
(define-condition duplicate-names (system-definition-error)
937
938
939
940
  ((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)))))
941

942
943
944
945
(define-condition missing-component (system-definition-error)
  ((requires :initform "(unnamed)" :reader missing-requires :initarg :requires)
   (parent :initform nil :reader missing-parent :initarg :parent)))

946
947
948
(define-condition missing-component-of-version (missing-component)
  ((version :initform nil :reader missing-version :initarg :version)))

949
950
951
(define-condition missing-dependency (missing-component)
  ((required-by :initarg :required-by :reader missing-required-by)))

952
(define-condition missing-dependency-of-version (missing-dependency
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
953
                                                 missing-component-of-version)
954
955
  ())

Daniel Barlow's avatar
Daniel Barlow committed
956
957
958
959
(define-condition operation-error (error)
  ((component :reader error-component :initarg :component)
   (operation :reader error-operation :initarg :operation))
  (:report (lambda (c s)
960
961
             (format s "~@<erred while invoking ~A on ~A~@:>"
                     (error-operation c) (error-component c)))))
962
963
964
(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
965

966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
(define-condition invalid-configuration ()
  ((form :reader condition-form :initarg :form)
   (location :reader condition-location :initarg :location)
   (format :reader condition-format :initarg :format)
   (arguments :reader condition-arguments :initarg :arguments :initform nil))
  (:report (lambda (c s)
             (format s "~@<~? (will be skipped)~@:>"
                     (condition-format c)
                     (list* (condition-form c) (condition-location c)
                            (condition-arguments c))))))
(define-condition invalid-source-registry (invalid-configuration warning)
  ((format :initform "~@<invalid source registry ~S~@[ in ~S~]~@{ ~@?~}~>")))
(define-condition invalid-output-translation (invalid-configuration warning)
  ((format :initform "~@<invalid asdf output-translation ~S~@[ in ~S~]~@{ ~@?~}~>")))

Daniel Barlow's avatar
Daniel Barlow committed
981
(defclass component ()
982
  ((name :accessor component-name :initarg :name :documentation
983
         "Component name: designator for a string composed of portable pathname characters")
Daniel Barlow's avatar
Daniel Barlow committed
984
   (version :accessor component-version :initarg :version)
985
   ;; This one is used by POIU. Maybe in the future by ASDF instead of in-order-to?
986
987
   ;; POIU is a parallel (multi-process build) extension of ASDF.  See
   ;; http://www.cliki.net/poiu
988
   (load-dependencies :accessor component-load-dependencies :initform nil)
989
990
991
992
993
994
995
996
997
998
999
1000
   ;; In the ASDF object model, dependencies exist between *actions*
   ;; (an action is a pair of operation and component). They are represented
   ;; alists of operations to dependencies (other actions) in each component.
   ;; There are two kinds of dependencies, each stored in its own slot:
   ;; in-order-to and do-first dependencies. These two kinds are related to
   ;; the fact that some actions modify the filesystem,
   ;; whereas other actions modify the current image, and
   ;; this implies a difference in how to interpret timestamps.
   ;; in-order-to dependencies will trigger re-performing the action
   ;; when the timestamp of some dependency
   ;; makes the timestamp of current action out-of-date;
   ;; do-first dependencies do not trigger such re-performing.
For faster browsing, not all history is shown. View entire blame