asdf.lisp 165 KB
Newer Older
1
;;; -*- mode: common-lisp; Base: 10 ; Syntax: ANSI-Common-Lisp -*-
2
;;; This is ASDF 2.014.8: 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-2011 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 #-genera :common-lisp-user #+genera :future-common-lisp-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
  ;;; make package if it doesn't exist yet.
  ;;; DEFPACKAGE may cause errors on discrepancies, so we avoid it.
  (unless (find-package :asdf)
58
    (make-package :asdf :use '(:common-lisp)))
59
  ;;; 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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
;;; Strip out formating that is not supported on Genera.
(defmacro compatfmt (format)
  #-genera format
  #+genera
  (let ((r '(("~@<" . "")
	     ("; ~@;" . "; ")
	     ("~3i~_" . "")
	     ("~@:>" . "")
	     ("~:>" . ""))))
    (dolist (i r)
      (loop :for found = (search (car i) format) :while found :do
        (setf format (concatenate 'simple-string (subseq format 0 found)
                                  (cdr i)
                                  (subseq format (+ found (length (car i))))))))
    format))

87
;;;; Create packages in a way that is compatible with hot-upgrade.
88
;;;; See https://bugs.launchpad.net/asdf/+bug/485687
89
;;;; See more near the end of the file.
90

91
(eval-when (:load-toplevel :compile-toplevel :execute)
92
93
  (defvar *asdf-version* nil)
  (defvar *upgraded-p* nil)
94
  (defvar *asdf-verbose* t)
95
  (let* (;; For bug reporting sanity, please always bump this version when you modify this file.
96
97
         ;; 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).
98
         ;; Relying on its automation, the version is now redundantly present on top of this file.
99
100
         ;; "2.345" would be an official release
         ;; "2.345.6" would be a development version in the official upstream
101
102
         ;; "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
103
         (asdf-version "2.014.8")
104
105
         (existing-asdf (fboundp 'find-system))
         (existing-version *asdf-version*)
106
107
         (already-there (equal asdf-version existing-version)))
    (unless (and existing-asdf already-there)
108
      (when (and existing-asdf *asdf-verbose*)
109
        (format *trace-output*
110
111
                (compatfmt "~&~@<; ~@;Upgrading ASDF ~@[from version ~A ~]to version ~A~@:>~%")
                existing-version asdf-version))
112
      (labels
113
          ((present-symbol-p (symbol package)
114
             (member (nth-value 1 (find-sym symbol package)) '(:internal :external)))
115
116
117
118
119
120
121
           (present-symbols (package)
             ;; #-genera (loop :for s :being :the :present-symbols :in package :collect s) #+genera
             (let (l)
               (do-symbols (s package)
                 (when (present-symbol-p s package) (push s l)))
               (reverse l)))
           (unlink-package (package)
122
123
             (let ((u (find-package package)))
               (when u
124
                 (ensure-unintern u (present-symbols u))
125
126
127
                 (loop :for p :in (package-used-by-list u) :do
                   (unuse-package u p))
                 (delete-package u))))
128
           (ensure-exists (name nicknames use)
129
130
131
132
133
134
135
136
137
138
             (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
139
140
                    (rename-package p name nicknames)
                    (ensure-use p use)
141
142
143
                    p)
                   (t
                    (make-package name :nicknames nicknames :use use))))))
144
145
146
147
148
149
150
151
           (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)
152
153
                 (unintern sym package)
                 sym)))
154
           (ensure-unintern (package symbols)
155
156
157
158
159
160
161
             (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)))))
162
163
164
165
166
167
168
169
170
171
172
173
174
           (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)
175
176
177
             (let ((formerly-exported-symbols nil)
                   (bothly-exported-symbols nil)
                   (newly-exported-symbols nil))
178
               (do-external-symbols (sym package)
179
180
181
182
183
184
185
186
187
188
189
190
191
192
                 (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)))))
193
           (ensure-package (name &key nicknames use unintern fmakunbound shadow export)
194
             (let* ((p (ensure-exists name nicknames use)))
195
196
197
198
199
200
201
202
               (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)
203
204
205
206
207
                 `(ensure-package
                   ',name :nicknames ',nicknames :use ',use :export ',export
                   :shadow ',shadow
                   :unintern ',(append #-(or gcl ecl) redefined-functions unintern)
                   :fmakunbound ',(append fmakunbound))))
208
209
          (pkgdcl
           :asdf
210
           :nicknames (:asdf-utilities) ;; DEPRECATED! Do not use, for backward compatibility only.
211
           :use (:common-lisp)
212
213
214
           :redefined-functions
           (#:perform #:explain #:output-files #:operation-done-p
            #:perform-with-restarts #:component-relative-pathname
215
            #:system-source-file #:operate #:find-component #:find-system
216
217
            #:apply-output-translations #:translate-pathname* #:resolve-location
            #:compile-file*)
218
219
           :unintern
           (#:*asdf-revision* #:around #:asdf-method-combination
220
            #:split #:make-collector
221
            #:output-files-for-system-and-operation) ; obsolete ASDF-BINARY-LOCATION function
222
223
224
225
226
227
228
           :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
229
            #:system-definition-pathname
230
            #:search-for-system-definition #:find-component ; miscellaneous
231
            #:compile-system #:load-system #:test-system #:clear-system
232
233
234
235
236
237
            #:compile-op #:load-op #:load-source-op
            #:test-op
            #:operation               ; operations
            #:feature                 ; sort-of operation
            #:version                 ; metaphorically sort-of an operation
            #:version-satisfies
238
            #:upgrade-asdf
239

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

277
            #:operation-description
278
279
            #:operation-on-warnings
            #:operation-on-failure
280
            #:component-visited-p
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
            ;;#:*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

310
            #:clear-configuration
311
            #:*output-translations-parameter*
312
313
314
315
316
            #:initialize-output-translations
            #:disable-output-translations
            #:clear-output-translations
            #:ensure-output-translations
            #:apply-output-translations
317
            #:compile-file*
318
319
320
            #:compile-file-pathname*
            #:enable-asdf-binary-locations-compatibility
            #:*default-source-registries*
321
            #:*source-registry-parameter*
322
323
324
325
            #:initialize-source-registry
            #:compute-source-registry
            #:clear-source-registry
            #:ensure-source-registry
326
            #:process-source-registry
327
328
            #:system-registered-p
            #:asdf-message
329

330
331
            ;; Utilities
            #:absolute-pathname-p
332
            ;; #:aif #:it
333
            ;; #:appendf
334
335
            #:coerce-name
            #:directory-pathname-p
336
            ;; #:ends-with
337
338
            #:ensure-directory-pathname
            #:getenv
339
340
            ;; #:get-uid
            ;; #:length=n-p
341
            ;; #:find-symbol*
342
            #:merge-pathnames*
343
            #:coerce-pathname
344
345
            #:pathname-directory-pathname
            #:read-file-forms
346
347
            ;; #:remove-keys
            ;; #:remove-keyword
348
349
350
351
            #:resolve-symlinks
            #:split-string
            #:component-name-to-pathname-components
            #:split-name-type
352
            #:subdirectories
353
354
            #:truenamize
            #:while-collecting)))
355
	#+genera (import 'scl:boolean :asdf)
356
357
358
359
        (setf *asdf-version* asdf-version
              *upgraded-p* (if existing-version
                               (cons existing-version *upgraded-p*)
                               *upgraded-p*))))))
Daniel Barlow's avatar
Daniel Barlow committed
360

361
362
363
;;;; -------------------------------------------------------------------------
;;;; User-visible parameters
;;;;
364
(defun asdf-version ()
365
  "Exported interface to the version of ASDF currently installed. A string.
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
366
You can compare this string with e.g.:
367
(ASDF:VERSION-SATISFIES (ASDF:ASDF-VERSION) \"2.345.67\")."
368
  *asdf-version*)
369

370
371
372
(defvar *resolve-symlinks* t
  "Determine whether or not ASDF resolves symlinks when defining systems.

373
Defaults to T.")
374

375
376
377
378
(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.")
379

380
381
382
383
384
(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
385

386
(defvar *verbose-out* nil)
387

388
(defparameter +asdf-methods+
389
  '(perform-with-restarts perform explain output-files operation-done-p))
390

391
#+allegro
392
(eval-when (:compile-toplevel :execute)
393
394
395
396
397
398
  (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)))

399
;;;; -------------------------------------------------------------------------
400
401
;;;; General Purpose Utilities

402
403
404
405
406
(macrolet
    ((defdef (def* def)
       `(defmacro ,def* (name formals &rest rest)
          `(progn
             #+(or ecl gcl) (fmakunbound ',name)
407
408
409
             #-gcl ; gcl 2.7.0 notinline functions lose secondary return values :-(
             ,(when (and #+ecl (symbolp name)) ; fails for setf functions on ecl
                `(declaim (notinline ,name)))
410
411
412
             (,',def ,name ,formals ,@rest)))))
  (defdef defgeneric* defgeneric)
  (defdef defun* defun))
413

414
(defmacro while-collecting ((&rest collectors) &body body)
415
416
417
418
419
420
421
422
423
424
  "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\)."
425
426
427
  (let ((vars (mapcar #'(lambda (x) (gensym (symbol-name x))) collectors))
        (initial-values (mapcar (constantly nil) collectors)))
    `(let ,(mapcar #'list vars initial-values)
428
       (flet ,(mapcar #'(lambda (c v) `(,c (x) (push x ,v) (values))) collectors vars)
429
         ,@body
430
         (values ,@(mapcar #'(lambda (v) `(reverse ,v)) vars))))))
431

432
433
434
(defmacro aif (test then &optional else)
  `(let ((it ,test)) (if it ,then ,else)))

435
(defun* pathname-directory-pathname (pathname)
436
437
  "Returns a new pathname with same HOST, DEVICE, DIRECTORY as PATHNAME,
and NIL NAME, TYPE and VERSION components"
438
439
  (when pathname
    (make-pathname :name nil :type nil :version nil :defaults pathname)))
440

441
442
(defun* normalize-pathname-directory-component (directory)
  (cond
443
    #-(or cmu sbcl scl)
444
445
446
447
448
449
450
451
    ((stringp directory) `(:absolute ,directory) directory)
    #+gcl
    ((and (consp directory) (stringp (first directory)))
     `(:absolute ,@directory))
    ((or (null directory)
         (and (consp directory) (member (first directory) '(:absolute :relative))))
     directory)
    (t
452
     (error (compatfmt "~@<Unrecognized pathname directory component ~S~@:>") directory))))
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475

(defun* merge-pathname-directory-components (specified defaults)
  (let ((directory (normalize-pathname-directory-component specified)))
    (ecase (first directory)
      ((nil) defaults)
      (:absolute specified)
      (:relative
       (let ((defdir (normalize-pathname-directory-component defaults))
             (reldir (cdr directory)))
         (cond
           ((null defdir)
            directory)
           ((not (eq :back (first reldir)))
            (append defdir reldir))
           (t
            (loop :with defabs = (first defdir)
              :with defrev = (reverse (rest defdir))
              :while (and (eq :back (car reldir))
                          (or (and (eq :absolute defabs) (null defrev))
                              (stringp (car defrev))))
              :do (pop reldir) (pop defrev)
              :finally (return (cons defabs (append (reverse defrev) reldir)))))))))))

476
(defun* merge-pathnames* (specified &optional (defaults *default-pathname-defaults*))
477
  "MERGE-PATHNAMES* is like MERGE-PATHNAMES except that if the SPECIFIED pathname
478
479
480
481
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))
482
483
484
  #+scl
  (ext:resolve-pathname specified defaults)
  #-scl
485
486
  (let* ((specified (pathname specified))
         (defaults (pathname defaults))
487
         (directory (normalize-pathname-directory-component (pathname-directory specified)))
488
489
490
         (name (or (pathname-name specified) (pathname-name defaults)))
         (type (or (pathname-type specified) (pathname-type defaults)))
         (version (or (pathname-version specified) (pathname-version defaults))))
491
492
493
494
495
    (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)
496
          (ecase (first directory)
497
498
499
500
501
            ((:absolute)
             (values (pathname-host specified)
                     (pathname-device specified)
                     directory
                     (unspecific-handler specified)))
502
            ((nil :relative)
503
504
             (values (pathname-host defaults)
                     (pathname-device defaults)
505
                     (merge-pathname-directory-components directory (pathname-directory defaults))
506
507
508
509
510
                     (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))))))
511

512
513
514
515
516
517
518
519
520
(defun* pathname-parent-directory-pathname (pathname)
  "Returns a new pathname with same HOST, DEVICE, DIRECTORY as PATHNAME,
and NIL NAME, TYPE and VERSION components"
  (when pathname
    (make-pathname :name nil :type nil :version nil
                   :directory (merge-pathname-directory-components '(:relative :back) (pathname-directory pathname))
                   :defaults pathname)))


521
(define-modify-macro appendf (&rest args)
522
523
524
525
  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
526

527
(defun* first-char (s)
528
529
  (and (stringp s) (plusp (length s)) (char s 0)))

530
(defun* last-char (s)
531
532
  (and (stringp s) (plusp (length s)) (char s (1- (length s)))))

533

534
(defun* asdf-message (format-string &rest format-args)
535
  (declare (dynamic-extent format-args))
536
  (apply 'format *verbose-out* format-string format-args))
537

538
(defun* split-string (string &key max (separator '(#\Space #\Tab)))
539
540
  "Split STRING into a list of components separated by
any of the characters in the sequence SEPARATOR.
541
542
543
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\")."
544
545
546
547
548
549
550
551
552
553
554
555
556
  (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))))))
557

558
(defun* split-name-type (filename)
559
560
561
562
  (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.
563
         (or #+(or clozure gcl lispworks sbcl) :unspecific)))
564
565
566
567
568
    (destructuring-bind (name &optional (type unspecific))
        (split-string filename :max 2 :separator ".")
      (if (equal name "")
          (values filename unspecific)
          (values name type)))))
569

570
(defun* component-name-to-pathname-components (s &key force-directory force-relative)
571
572
573
574
575
576
577
578
579
580
  "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
581
582
583
584
585
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."
586
  (check-type s string)
587
  (when (find #\: s)
588
    (error (compatfmt "~@<A portable ASDF pathname designator cannot include a #\: character: ~3i~_~S~@:>") s))
589
  (let* ((components (split-string s :separator "/"))
590
591
592
         (last-comp (car (last components))))
    (multiple-value-bind (relative components)
        (if (equal (first components) "")
593
            (if (equal (first-char s) #\/)
594
595
                (progn
                  (when force-relative
596
                    (error (compatfmt "~@<Absolute pathname designator not allowed: ~3i~_~S~@:>") s))
597
                  (values :absolute (cdr components)))
598
                (values :relative nil))
599
          (values :relative components))
600
601
      (setf components (remove-if #'(lambda (x) (member x '("" ".") :test #'equal)) components))
      (setf components (substitute :back ".." components :test #'equal))
602
603
      (cond
        ((equal last-comp "")
604
         (values relative components nil)) ; "" already removed
605
606
607
608
        (force-directory
         (values relative components nil))
        (t
         (values relative (butlast components) last-comp))))))
609

610
(defun* remove-keys (key-names args)
611
612
613
614
615
  (loop :for (name val) :on args :by #'cddr
    :unless (member (symbol-name name) key-names
                    :key #'symbol-name :test 'equal)
    :append (list name val)))

616
(defun* remove-keyword (key args)
617
618
619
  (loop :for (k v) :on args :by #'cddr
    :unless (eq k key)
    :append (list k v)))
620

621
622
623
624
#+mcl
(eval-when (:compile-toplevel :load-toplevel :execute)
  (ccl:define-entry-point (_getenv "getenv") ((name :string)) :string))

625
(defun* getenv (x)
626
  (declare (ignorable x))
627
  #+(or abcl clisp xcl) (ext:getenv x)
628
629
630
631
632
633
634
635
636
637
638
639
  #+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)
640
  #-(or abcl allegro clisp clozure cmu ecl gcl genera lispworks mcl sbcl scl xcl)
641
  (error "getenv not available on your implementation"))
642

643
(defun* directory-pathname-p (pathname)
644
  "Does PATHNAME represent a directory?
645
646

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

650
Note that this does _not_ check to see that PATHNAME points to an
651
actually-existing directory."
652
653
654
655
656
657
658
659
  (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)))))
660

661
(defun* ensure-directory-pathname (pathspec)
662
  "Converts the non-wild pathname designator PATHSPEC to directory form."
663
664
  (cond
   ((stringp pathspec)
665
    (ensure-directory-pathname (pathname pathspec)))
666
   ((not (pathnamep pathspec))
667
    (error (compatfmt "~@<Invalid pathname designator ~S~@:>") pathspec))
668
   ((wild-pathname-p pathspec)
669
    (error (compatfmt "~@<Can't reliably convert wild pathname ~3i~_~S~@:>") pathspec))
670
671
672
673
674
675
676
677
   ((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
682
683
#+genera
(unless (fboundp 'ensure-directories-exist)
  (defun ensure-directories-exist (path)
    (fs:create-directories-recursively (pathname path))))

684
(defun* absolute-pathname-p (pathspec)
685
686
  (and (typep pathspec '(or pathname string))
       (eq :absolute (car (pathname-directory (pathname pathspec))))))
687

688
(defun* length=n-p (x n) ;is it that (= (length x) n) ?
689
690
691
692
693
694
695
696
  (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)))))

697
(defun* ends-with (s suffix)
698
699
700
701
702
  (check-type s string)
  (check-type suffix string)
  (let ((start (- (length s) (length suffix))))
    (and (<= 0 start)
         (string-equal s suffix :start1 start))))
703

704
(defun* read-file-forms (file)
705
706
707
708
709
710
  (with-open-file (in file)
    (loop :with eof = (list nil)
     :for form = (read in nil eof)
     :until (eq form eof)
     :collect form)))

711
#+asdf-unix
712
(progn
713
714
  #+ecl #.(cl:and (cl:< ext:+ecl-version-number+ 100601)
                  '(ffi:clines "#include <sys/types.h>" "#include <unistd.h>"))
715
  (defun* get-uid ()
716
    #+allegro (excl.osi:getuid)
717
    #+ccl (ccl::getuid)
718
    #+clisp (loop :for s :in '("posix:uid" "LINUX:getuid")
719
                  :for f = (ignore-errors (read-from-string s))
720
                  :when f :return (funcall f))
721
722
723
724
725
    #+(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)
726
    #-(or allegro ccl clisp cmu ecl sbcl scl)
727
728
729
730
731
732
733
    (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")))))))
734

735
(defun* pathname-root (pathname)
736
  (make-pathname :directory '(:absolute)
737
                 :name nil :type nil :version nil
738
739
                 :defaults pathname ;; host device, and on scl scheme scheme-specific-part port username password
                 . #.(or #+scl '(:parameters nil :query nil :fragment nil))))
740

741
742
743
(defun* find-symbol* (s p)
  (find-symbol (string s) p))

744
(defun* probe-file* (p)
745
746
  "when given a pathname P, probes the filesystem for a file or directory
with given pathname and if it exists return its truename."
747
748
749
750
751
  (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)
752
753
                     #+clisp (aif (find-symbol (string '#:probe-pathname) :ext) `(ignore-errors (,it p)))
                     '(ignore-errors (truename p)))))))
754

755
(defun* truenamize (p)
756
  "Resolve as much of a pathname as possible"
757
  (block nil
758
    (when (typep p '(or null logical-pathname)) (return p))
759
    (let* ((p (merge-pathnames* p))
760
761
           (directory (pathname-directory p)))
      (when (typep p 'logical-pathname) (return p))
762
763
      (let ((found (probe-file* p)))
        (when found (return found)))
764
      #-(or cmu sbcl scl) (when (stringp directory) (return p))
765
      (when (not (eq :absolute (car directory))) (return p))
766
      (let ((sofar (probe-file* (pathname-root p))))
767
        (unless sofar (return p))
768
        (flet ((solution (directories)
769
770
                 (merge-pathnames*
                  (make-pathname :host nil :device nil
771
                                 :directory `(:relative ,@directories)
772
773
                                 :name (pathname-name p)
                                 :type (pathname-type p)
774
                                 :version (pathname-version p))
775
776
777
                  sofar)))
          (loop :for component :in (cdr directory)
            :for rest :on (cdr directory)
778
779
780
781
            :for more = (probe-file*
                         (merge-pathnames*
                          (make-pathname :directory `(:relative ,component))
                          sofar)) :do
782
783
            (if more
                (setf sofar more)
784
                (return (solution rest)))
785
786
            :finally
            (return (solution nil))))))))
787

788
(defun* resolve-symlinks (path)
789
  #-allegro (truenamize path)
790
791
792
  #+allegro (if (typep path 'logical-pathname)
                path
                (excl:pathname-resolve-symbolic-links path)))
793

794
(defun* default-directory ()
795
796
  (truenamize (pathname-directory-pathname *default-pathname-defaults*)))

797
(defun* lispize-pathname (input-file)
798
799
  (make-pathname :type "lisp" :defaults input-file))

800
801
802
803
804
805
(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))
806
(defparameter *wild-path*
807
  (merge-pathnames *wild-file* *wild-inferiors*))
808

809
(defun* wilden (path)
810
811
  (merge-pathnames* *wild-path* path))

812
#-scl
813
814
815
816
(defun directory-separator-for-host (&optional (pathname *default-pathname-defaults*))
  (let ((foo (make-pathname :directory '(:absolute "FOO") :defaults pathname)))
    (last-char (namestring foo))))

817
#-scl
818
(defun* directorize-pathname-host-device (pathname)
819
820
821
  (let* ((root (pathname-root pathname))
         (wild-root (wilden root))
         (absolute-pathname (merge-pathnames* pathname root))
822
         (separator (directory-separator-for-host root))
823
824
825
         (root-namestring (namestring root))
         (root-string
          (substitute-if #\/
826
827
                         #'(lambda (x) (or (eql x #\:)
                                           (eql x separator)))
828
829
                         root-namestring)))
    (multiple-value-bind (relative path filename)
830
        (component-name-to-pathname-components root-string :force-directory t)
831
832
833
834
835
836
      (declare (ignore relative filename))
      (let ((new-base
             (make-pathname :defaults root
                            :directory `(:absolute ,@path))))
        (translate-pathname absolute-pathname wild-root (wilden new-base))))))

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
#+scl
(defun* directorize-pathname-host-device (pathname)
  (let ((scheme (ext:pathname-scheme pathname))
	(host (pathname-host pathname))
	(port (ext:pathname-port pathname))
	(directory (pathname-directory pathname)))
    (flet ((not-unspecific (component)
	     (and (not (eq component :unspecific)) component)))
      (cond ((or (not-unspecific port)
		 (and (not-unspecific host) (plusp (length host)))
		 (not-unspecific scheme))
	     (let ((prefix ""))
	       (when (not-unspecific port)
		 (setf prefix (format nil ":~D" port)))
	       (when (and (not-unspecific host) (plusp (length host)))
		 (setf prefix (concatenate 'string host prefix)))
	       (setf prefix (concatenate 'string ":" prefix))
	       (when (not-unspecific scheme)
	       (setf prefix (concatenate 'string scheme prefix)))
	       (assert (and directory (eq (first directory) :absolute)))
	       (make-pathname :directory `(:absolute ,prefix ,@(rest directory))
			      :defaults pathname)))
	    (t
	     pathname)))))

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
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
;;;; -------------------------------------------------------------------------
;;;; 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
973
      '(defmethod update-instance-for-redefined-class :after
974
975
976
           ((m module) added deleted plist &key)
         (declare (ignorable deleted plist))
         (when (or *asdf-verbose* *load-verbose*)
977
           (asdf-message (compatfmt "~&~@<; ~@;Updating ~A for ASDF ~A~@:>~%")
978
			 m (asdf-version)))
979
980
         (when (member 'components-by-name added)
           (compute-module-components-by-name m))
981
982
983
984
985
986
         (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*))))))))
987

988
989
;;;; -------------------------------------------------------------------------
;;;; Classes, Conditions
Daniel Barlow's avatar
Daniel Barlow committed
990

991
992
993
994
995
996
997
998
999
(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))

1000
(declaim (ftype (function (t) t)
For faster browsing, not all history is shown. View entire blame