asdf.lisp 216 KB
Newer Older
1
;;; -*- mode: Common-Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp ; coding: utf-8 -*-
2
;;; This is ASDF 2.26.10: 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-2012 Daniel Barlow and contributors
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining
;;; a copy of this software and associated documentation files (the
;;; "Software"), to deal in the Software without restriction, including
;;; without limitation the rights to use, copy, modify, merge, publish,
;;; distribute, sublicense, and/or sell copies of the Software, and to
;;; permit persons to whom the Software is furnished to do so, subject to
;;; the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
;;; LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
;;; OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
;;; WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
42
43
;;;
;;; -- LICENSE END
44

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

48
49
#+xcvb (module ())

50
51
(cl:in-package :common-lisp-user)
#+genera (in-package :future-common-lisp-user)
52

53
#-(or abcl allegro clisp clozure cmu cormanlisp ecl gcl genera lispworks mcl mkcl sbcl scl xcl)
54
(error "ASDF is not supported on your implementation. Please help us port it.")
55

56
57
58
59
;;;; Create and setup packages in a way that is compatible with hot-upgrade.
;;;; See https://bugs.launchpad.net/asdf/+bug/485687
;;;; See these two eval-when forms, and more near the end of the file.

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

62
63
(eval-when (:load-toplevel :compile-toplevel :execute)
  ;;; Before we do anything, some implementation-dependent tweaks
64
  ;; (declaim (optimize (speed 1) (debug 3) (safety 3))) ; NO: trust implementation defaults.
65
66
67
  #+allegro
  (setf excl::*autoload-package-name-alist*
        (remove "asdf" excl::*autoload-package-name-alist*
68
                :test 'equalp :key 'car)) ; need that BEFORE any mention of package ASDF as below
69
70
  #+gcl ;; Debian's GCL 2.7 has bugs with compiling multiple-value stuff, but can run ASDF 2.011
  (when (or (< system::*gcl-major-version* 2) ;; GCL 2.6 fails to fully compile ASDF at all
71
72
73
            (and (= system::*gcl-major-version* 2)
                 (< system::*gcl-minor-version* 7)))
    (pushnew :gcl-pre2.7 *features*))
74
75
  #+(or abcl (and allegro ics) (and (or clisp cmu ecl mkcl) unicode)
        clozure lispworks (and sbcl sb-unicode) scl)
76
  (pushnew :asdf-unicode *features*)
77
78
79
80
  ;;; 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 '(:common-lisp))))
81
82

(in-package :asdf)
83

84
(eval-when (:load-toplevel :compile-toplevel :execute)
85
  ;;; This would belong amongst implementation-dependent tweaks above,
86
  ;;; except that the defun has to be in package asdf.
87
88
  #+ecl (defun use-ecl-byte-compiler-p () (and (member :ecl-bytecmp *features*) t))
  #+ecl (unless (use-ecl-byte-compiler-p) (require :cmp))
89
  #+mkcl (require :cmp)
90
  #+mkcl (setq clos::*redefine-class-in-place* t) ;; Make sure we have strict ANSI class redefinition semantics
91
92

  ;;; Package setup, step 2.
93
94
  (defvar *asdf-version* nil)
  (defvar *upgraded-p* nil)
95
  (defvar *asdf-verbose* nil) ; was t from 2.000 to 2.014.12.
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
96
97
  (defun find-symbol* (s p)
    (find-symbol (string s) p))
98
99
  ;; Strip out formatting that is not supported on Genera.
  ;; Has to be inside the eval-when to make Lispworks happy (!)
100
101
  (defun strcat (&rest strings)
    (apply 'concatenate 'string strings))
102
  (defmacro compatfmt (format)
103
104
    #-(or gcl genera) format
    #+(or gcl genera)
105
    (loop :for (unsupported . replacement) :in
106
107
108
      (append
       '(("~3i~_" . ""))
       #+genera '(("~@<" . "") ("; ~@;" . "; ") ("~@:>" . "") ("~:>" . ""))) :do
109
      (loop :for found = (search unsupported format) :while found :do
110
111
        (setf format (strcat (subseq format 0 found) replacement
                             (subseq format (+ found (length unsupported)))))))
112
    format)
113
  (let* (;; For bug reporting sanity, please always bump this version when you modify this file.
114
115
         ;; 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).
116
         ;; Relying on its automation, the version is now redundantly present on top of this file.
117
118
         ;; "2.345" would be an official release
         ;; "2.345.6" would be a development version in the official upstream
119
120
         ;; "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
121
         (asdf-version "2.26.10")
122
         (existing-asdf (find-class 'component nil))
123
         (existing-version *asdf-version*)
124
125
         (already-there (equal asdf-version existing-version)))
    (unless (and existing-asdf already-there)
126
      (when (and existing-asdf *asdf-verbose*)
127
        (format *trace-output*
128
129
                (compatfmt "~&~@<; ~@;Upgrading ASDF ~@[from version ~A ~]to version ~A~@:>~%")
                existing-version asdf-version))
130
      (labels
131
          ((present-symbol-p (symbol package)
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
132
             (member (nth-value 1 (find-symbol* symbol package)) '(:internal :external)))
133
134
135
136
137
138
139
           (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)
140
141
             (let ((u (find-package package)))
               (when u
142
                 (ensure-unintern u (present-symbols u))
143
144
145
                 (loop :for p :in (package-used-by-list u) :do
                   (unuse-package u p))
                 (delete-package u))))
146
           (ensure-exists (name nicknames use)
147
148
149
150
151
152
153
154
155
156
             (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
157
158
                    (rename-package p name nicknames)
                    (ensure-use p use)
159
160
161
                    p)
                   (t
                    (make-package name :nicknames nicknames :use use))))))
162
163
164
           (intern* (symbol package)
             (intern (string symbol) package))
           (remove-symbol (symbol package)
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
165
             (let ((sym (find-symbol* symbol package)))
166
               (when sym
167
                 #-cormanlisp (unexport sym package)
168
169
                 (unintern sym package)
                 sym)))
170
           (ensure-unintern (package symbols)
171
172
173
174
175
             (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
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
176
                 (when (eq removed (find-symbol* sym p))
177
                   (unintern removed p)))))
178
179
180
           (ensure-shadow (package symbols)
             (shadow symbols package))
           (ensure-use (package use)
181
182
183
184
185
186
             (dolist (used (package-use-list package))
               (unless (member (package-name used) use :test 'string=)
                 (unuse-package used)
                 (do-external-symbols (sym used)
                   (when (eq sym (find-symbol* sym package))
                     (remove-symbol sym package)))))
187
188
             (dolist (used (reverse use))
               (do-external-symbols (sym used)
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
189
                 (unless (eq sym (find-symbol* sym package))
190
191
192
193
                   (remove-symbol sym package)))
               (use-package used package)))
           (ensure-fmakunbound (package symbols)
             (loop :for name :in symbols
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
194
               :for sym = (find-symbol* name package)
195
196
               :when sym :do (fmakunbound sym)))
           (ensure-export (package export)
197
198
199
             (let ((formerly-exported-symbols nil)
                   (bothly-exported-symbols nil)
                   (newly-exported-symbols nil))
200
               (do-external-symbols (sym package)
201
202
203
204
                 (if (member sym export :test 'string-equal)
                     (push sym bothly-exported-symbols)
                     (push sym formerly-exported-symbols)))
               (loop :for sym :in export :do
205
                 (unless (member sym bothly-exported-symbols :test 'equal)
206
207
208
209
                   (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
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
210
                   :for old = (find-symbol* new user)
211
212
213
214
                   :when (and old (not (member old shadowing)))
                   :do (unintern old user)))
               (loop :for x :in newly-exported-symbols :do
                 (export (intern* x package)))))
215
           (ensure-package (name &key nicknames use unintern
216
                                 shadow export redefined-functions)
217
             (let* ((p (ensure-exists name nicknames use)))
218
               (ensure-unintern p unintern)
219
220
               (ensure-shadow p shadow)
               (ensure-export p export)
221
               (ensure-fmakunbound p redefined-functions)
222
223
224
               p)))
        (macrolet
            ((pkgdcl (name &key nicknames use export
225
                           redefined-functions unintern shadow)
226
227
228
                 `(ensure-package
                   ',name :nicknames ',nicknames :use ',use :export ',export
                   :shadow ',shadow
229
                   :unintern ',unintern
230
                   :redefined-functions ',redefined-functions)))
231
232
          (pkgdcl
           :asdf
233
           :use (:common-lisp)
234
           :redefined-functions
235
           (#:perform #:explain #:output-files #:operation-done-p #:do-traverse
236
            #:visit-action #:compute-action-stamp
237
            #:perform-with-restarts #:component-relative-pathname
238
            #:system-source-file #:operate #:find-component #:find-system
239
            #:apply-output-translations #:translate-pathname* #:resolve-location
240
241
242
            #:system-relative-pathname
            #:inherit-source-registry #:process-source-registry
            #:process-source-registry-directive
243
            #:compile-file* #:source-file-type #:trivial-system-p)
244
245
           :unintern
           (#:*asdf-revision* #:around #:asdf-method-combination
246
            #:split #:make-collector #:do-dep #:do-one-dep
247
            #:resolve-relative-location-component #:resolve-absolute-location-component
248
            #:output-files-for-system-and-operation) ; obsolete ASDF-BINARY-LOCATION function
249
           :export
250
           (#:defsystem #:oos #:operate #:find-system #:locate-system #:run-shell-command
251
            #:system-definition-pathname #:with-system-definitions
252
            #:search-for-system-definition #:find-component #:component-find-path
253
254
            #:compile-system #:load-system #:load-systems
            #:require-system #:test-system #:clear-system
255
256
            #:operation #:compile-op #:load-op #:load-source-op #:test-op
            #:feature #:version #:version-satisfies
257
            #:upgrade-asdf
258
            #:implementation-identifier #:implementation-type #:hostname
259
            #:input-files #:output-files #:output-file #:perform
260
            #:operation-done-p #:explain #:component-load-dependencies
261
262
263

            #:component #:source-file
            #:c-source-file #:cl-source-file #:java-source-file
264
            #:cl-source-file.cl #:cl-source-file.lsp
265
266
267
268
269
270
271
272
273
274
            #:static-file
            #:doc-file
            #:html-file
            #:text-file
            #:source-file-type
            #:module                     ; components
            #:system
            #:unix-dso

            #:module-components          ; component accessors
275
            #:module-components-by-name
276
277
278
279
280
281
282
283
            #:component-pathname
            #:component-relative-pathname
            #:component-name
            #:component-version
            #:component-parent
            #:component-property
            #:component-system
            #:component-depends-on
284
285
            #:component-encoding
            #:component-external-format
286
287
288
289
290
291
292
293
294
295
296
297

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

298
            #:operation-description
299
300
            #:operation-on-warnings
            #:operation-on-failure
301
            #:component-visited-p
302
303
304

            #:*system-definition-search-functions*   ; variables
            #:*central-registry*
305
306
307
            #:*compile-file-warnings-behaviour*
            #:*compile-file-failure-behaviour*
            #:*resolve-symlinks*
308
            #:*load-system-operation*
309
            #:*asdf-verbose*
310
            #:*verbose-out*
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332

            #: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

333
            #:*encoding-detection-hook*
334
335
336
337
            #:*encoding-external-format-hook*
            #:*default-encoding*
            #:*utf-8-external-format*

338
            #:clear-configuration
339
            #:*output-translations-parameter*
340
341
342
343
344
            #:initialize-output-translations
            #:disable-output-translations
            #:clear-output-translations
            #:ensure-output-translations
            #:apply-output-translations
345
            #:compile-file*
346
347
348
            #:compile-file-pathname*
            #:enable-asdf-binary-locations-compatibility
            #:*default-source-registries*
349
            #:*source-registry-parameter*
350
351
352
353
            #:initialize-source-registry
            #:compute-source-registry
            #:clear-source-registry
            #:ensure-source-registry
354
            #:process-source-registry
355
            #:system-registered-p #:registered-systems #:loaded-systems
356
            #:resolve-location
357
            #:asdf-message
358
359
360
361
362
363
364
365
            #:user-output-translations-pathname
            #:system-output-translations-pathname
            #:user-output-translations-directory-pathname
            #:system-output-translations-directory-pathname
            #:user-source-registry
            #:system-source-registry
            #:user-source-registry-directory
            #:system-source-registry-directory
366
367
            #:load-fasl-op #:precompiled-system
            #+ecl #:make-build #+mkcl #:bundle-system
368

369
370
            ;; Utilities: please use asdf-utils instead
            #|
371
            ;; #:aif #:it
372
            ;; #:appendf #:orf
373
374
            #:length=n-p
            #:remove-keys #:remove-keyword
375
            #:first-char #:last-char #:string-suffix-p
376
            #:coerce-name
377
378
            #:directory-pathname-p #:ensure-directory-pathname
            #:absolute-pathname-p #:ensure-pathname-absolute #:pathname-root
379
            #:getenv #:getenv-pathname #:getenv-pathnames
380
            #:getenv-absolute-directory #:getenv-absolute-directories
381
            #:probe-file*
382
            #:find-symbol* #:strcat
383
384
385
            #:make-pathname-component-logical #:make-pathname-logical
            #:merge-pathnames* #:coerce-pathname #:subpathname #:subpathname*
            #:pathname-directory-pathname #:pathname-parent-directory-pathname
386
            #:read-file-forms
387
            #:resolve-symlinks #:truenamize
388
389
390
            #:split-string
            #:component-name-to-pathname-components
            #:split-name-type
391
392
393
394
            #:subdirectories #:directory-files
            #:while-collecting
            #:*wild* #:*wild-file* #:*wild-directory* #:*wild-inferiors*
            #:*wild-path* #:wilden
395
            #:directorize-pathname-host-device|#
396
            )))
397
        #+genera (import 'scl:boolean :asdf)
398
399
400
401
        (setf *asdf-version* asdf-version
              *upgraded-p* (if existing-version
                               (cons existing-version *upgraded-p*)
                               *upgraded-p*))))))
Daniel Barlow's avatar
Daniel Barlow committed
402

403
404
405
;;;; -------------------------------------------------------------------------
;;;; User-visible parameters
;;;;
406
407
408
(defvar *resolve-symlinks* t
  "Determine whether or not ASDF resolves symlinks when defining systems.

409
Defaults to T.")
410

411
412
413
414
(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.")
415

416
(defvar *compile-file-failure-behaviour*
417
  (or #+(or mkcl sbcl) :error #+clisp :ignore :warn)
418
419
420
  "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
421

422
(defvar *verbose-out* nil)
423

424
(defparameter +asdf-methods+
425
  '(perform-with-restarts perform explain output-files operation-done-p))
426

427
428
429
430
431
432
433
434
(defvar *load-system-operation* 'load-op
  "Operation used by ASDF:LOAD-SYSTEM. By default, ASDF:LOAD-OP.
You may override it with e.g. ASDF:LOAD-FASL-OP from asdf-bundle,
or ASDF:LOAD-SOURCE-OP if your fasl loading is somehow broken.")

(defvar *compile-op-compile-file-function* 'compile-file*
  "Function used to compile lisp files.")

435
#+allegro
436
(eval-when (:compile-toplevel :execute)
437
438
439
440
441
442
  (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)))

443
444
445
446
447
448
449
450
451
452
453
454
455
;;;; -------------------------------------------------------------------------
;;;; Resolve forward references

(declaim (ftype (function (t) t)
                format-arguments format-control
                error-name error-pathname error-condition
                duplicate-names-name
                error-component error-operation
                module-components module-components-by-name
                circular-dependency-components
                condition-arguments condition-form
                condition-format condition-location
                coerce-name)
456
         (ftype (function (&optional t) (values)) initialize-source-registry)
457
         #-(or cormanlisp gcl-pre2.7)
458
459
460
         (ftype (function (t t) t) (setf module-components-by-name)))

;;;; -------------------------------------------------------------------------
461
;;;; Compatibility various implementations
462
463
464
#+cormanlisp
(progn
  (deftype logical-pathname () nil)
465
  (defun make-broadcast-stream () *error-output*)
466
  (defun translate-logical-pathname (x) x)
467
  (defun file-namestring (p)
468
    (setf p (pathname p))
469
    (format nil "~@[~A~]~@[.~A~]" (pathname-name p) (pathname-type p))))
470

471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
#.(or #+mcl ;; the #$ doesn't work on other lisps, even protected by #+mcl
      (read-from-string
       "(eval-when (:compile-toplevel :load-toplevel :execute)
          (ccl:define-entry-point (_getenv \"getenv\") ((name :string)) :string)
          (ccl:define-entry-point (_system \"system\") ((name :string)) :int)
          ;; Note: ASDF may expect user-homedir-pathname to provide
          ;; the pathname of the current user's home directory, whereas
          ;; MCL by default provides the directory from which MCL was started.
          ;; See http://code.google.com/p/mcl/wiki/Portability
          (defun current-user-homedir-pathname ()
            (ccl::findfolder #$kuserdomain #$kCurrentUserFolderType))
          (defun probe-posix (posix-namestring)
            \"If a file exists for the posix namestring, return the pathname\"
            (ccl::with-cstrs ((cpath posix-namestring))
              (ccl::rlet ((is-dir :boolean)
                          (fsref :fsref))
                (when (eq #$noerr (#_fspathmakeref cpath fsref is-dir))
                  (ccl::%path-from-fsref fsref is-dir))))))"))

490
;;;; -------------------------------------------------------------------------
491
492
;;;; General Purpose Utilities

493
494
495
496
(macrolet
    ((defdef (def* def)
       `(defmacro ,def* (name formals &rest rest)
          `(progn
497
             #+(or ecl (and gcl (not gcl-pre2.7))) (fmakunbound ',name)
498
499
500
             #-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)))
501
502
503
             (,',def ,name ,formals ,@rest)))))
  (defdef defgeneric* defgeneric)
  (defdef defun* defun))
504

505
(defmacro while-collecting ((&rest collectors) &body body)
506
507
508
509
510
511
512
513
514
515
  "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\)."
516
517
518
  (let ((vars (mapcar #'(lambda (x) (gensym (symbol-name x))) collectors))
        (initial-values (mapcar (constantly nil) collectors)))
    `(let ,(mapcar #'list vars initial-values)
519
       (flet ,(mapcar #'(lambda (c v) `(,c (x) (push x ,v) (values))) collectors vars)
520
         ,@body
521
         (values ,@(mapcar #'(lambda (v) `(reverse ,v)) vars))))))
522

523
(defmacro aif (test then &optional else)
524
  "Anaphoric version of IF, On Lisp style"
525
526
  `(let ((it ,test)) (if it ,then ,else)))

527
(defun* pathname-directory-pathname (pathname)
528
529
  "Returns a new pathname with same HOST, DEVICE, DIRECTORY as PATHNAME,
and NIL NAME, TYPE and VERSION components"
530
531
  (when pathname
    (make-pathname :name nil :type nil :version nil :defaults pathname)))
532

533
(defun* normalize-pathname-directory-component (directory)
534
  "Given a pathname directory component, return an equivalent form that is a list"
535
  (cond
536
    #-(or cmu sbcl scl) ;; these implementations already normalize directory components.
537
538
539
540
541
542
543
544
    ((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
545
     (error (compatfmt "~@<Unrecognized pathname directory component ~S~@:>") directory))))
546
547

(defun* merge-pathname-directory-components (specified defaults)
548
  ;; Helper for merge-pathnames* that handles directory components.
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
  (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)))))))))))

570
(defun* make-pathname-component-logical (x)
571
  "Make a pathname component suitable for use in a logical-pathname"
572
573
574
575
576
577
  (typecase x
    ((eql :unspecific) nil)
    #+clisp (string (string-upcase x))
    #+clisp (cons (mapcar 'make-pathname-component-logical x))
    (t x)))

578
579
580
(defun* make-pathname-logical (pathname host)
  "Take a PATHNAME's directory, name, type and version components,
and make a new pathname with corresponding components and specified logical HOST"
581
  (make-pathname
582
583
584
585
586
   :host host
   :directory (make-pathname-component-logical (pathname-directory pathname))
   :name (make-pathname-component-logical (pathname-name pathname))
   :type (make-pathname-component-logical (pathname-type pathname))
   :version (make-pathname-component-logical (pathname-version pathname))))
587

588
(defun* merge-pathnames* (specified &optional (defaults *default-pathname-defaults*))
589
590
591
592
593
  "MERGE-PATHNAMES* is like MERGE-PATHNAMES except that
if the SPECIFIED pathname does not have an absolute directory,
then the HOST and DEVICE both come from the DEFAULTS, whereas
if the SPECIFIED pathname does have an absolute directory,
then the HOST and DEVICE both come from the SPECIFIED.
594
595
596
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))
597
598
599
  #+scl
  (ext:resolve-pathname specified defaults)
  #-scl
600
601
  (let* ((specified (pathname specified))
         (defaults (pathname defaults))
602
         (directory (normalize-pathname-directory-component (pathname-directory specified)))
603
604
605
         (name (or (pathname-name specified) (pathname-name defaults)))
         (type (or (pathname-type specified) (pathname-type defaults)))
         (version (or (pathname-version specified) (pathname-version defaults))))
606
    (labels ((unspecific-handler (p)
607
               (if (typep p 'logical-pathname) #'make-pathname-component-logical #'identity)))
608
      (multiple-value-bind (host device directory unspecific-handler)
609
          (ecase (first directory)
610
611
612
613
614
            ((:absolute)
             (values (pathname-host specified)
                     (pathname-device specified)
                     directory
                     (unspecific-handler specified)))
615
            ((nil :relative)
616
617
             (values (pathname-host defaults)
                     (pathname-device defaults)
618
                     (merge-pathname-directory-components directory (pathname-directory defaults))
619
620
621
622
623
                     (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))))))
624

625
626
627
628
629
(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
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
630
631
                   :directory (merge-pathname-directory-components
                               '(:relative :back) (pathname-directory pathname))
632
633
                   :defaults pathname)))

634
(define-modify-macro appendf (&rest args)
635
636
637
638
  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
639

640
(defun* first-char (s)
641
642
  (and (stringp s) (plusp (length s)) (char s 0)))

643
(defun* last-char (s)
644
645
  (and (stringp s) (plusp (length s)) (char s (1- (length s)))))

646

647
(defun* asdf-message (format-string &rest format-args)
648
  (declare (dynamic-extent format-args))
649
  (apply 'format *verbose-out* format-string format-args))
650

651
(defun* split-string (string &key max (separator '(#\Space #\Tab)))
652
653
  "Split STRING into a list of components separated by
any of the characters in the sequence SEPARATOR.
654
655
656
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\")."
657
  (catch nil
658
659
    (let ((list nil) (words 0) (end (length string)))
      (flet ((separatorp (char) (find char separator))
660
             (done () (throw nil (cons (subseq string 0 end) list))))
661
662
663
664
665
666
667
668
669
        (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))))))
670

671
(defun* split-name-type (filename)
672
673
674
  (let ((unspecific
         ;; Giving :unspecific as argument to make-pathname is not portable.
         ;; See CLHS make-pathname and 19.2.2.2.3.
675
         ;; We only use it on implementations that support it,
676
         #+(or abcl allegro clozure cmu gcl genera lispworks mkcl sbcl scl xcl) :unspecific
677
         #+(or clisp ecl #|These haven't been tested:|# cormanlisp mcl) nil))
678
679
680
681
682
    (destructuring-bind (name &optional (type unspecific))
        (split-string filename :max 2 :separator ".")
      (if (equal name "")
          (values filename unspecific)
          (values name type)))))
683

684
(defun* component-name-to-pathname-components (s &key force-directory force-relative)
685
686
687
688
689
690
691
692
693
694
  "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
695
696
697
698
699
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."
700
  (check-type s string)
701
  (when (find #\: s)
702
    (error (compatfmt "~@<A portable ASDF pathname designator cannot include a #\: character: ~3i~_~S~@:>") s))
703
  (let* ((components (split-string s :separator "/"))
704
705
706
         (last-comp (car (last components))))
    (multiple-value-bind (relative components)
        (if (equal (first components) "")
707
            (if (equal (first-char s) #\/)
708
709
                (progn
                  (when force-relative
710
                    (error (compatfmt "~@<Absolute pathname designator not allowed: ~3i~_~S~@:>") s))
711
                  (values :absolute (cdr components)))
712
                (values :relative nil))
713
          (values :relative components))
714
715
      (setf components (remove-if #'(lambda (x) (member x '("" ".") :test #'equal)) components))
      (setf components (substitute :back ".." components :test #'equal))
716
717
      (cond
        ((equal last-comp "")
718
         (values relative components nil)) ; "" already removed
719
720
721
722
        (force-directory
         (values relative components nil))
        (t
         (values relative (butlast components) last-comp))))))
723

724
(defun* remove-keys (key-names args)
725
726
727
728
729
  (loop :for (name val) :on args :by #'cddr
    :unless (member (symbol-name name) key-names
                    :key #'symbol-name :test 'equal)
    :append (list name val)))

730
(defun* remove-keyword (key args)
731
732
733
  (loop :for (k v) :on args :by #'cddr
    :unless (eq k key)
    :append (list k v)))
734

735
(defun* getenv (x)
736
  (declare (ignorable x))
737
  #+(or abcl clisp ecl xcl) (ext:getenv x)
738
739
740
  #+allegro (sys:getenv x)
  #+clozure (ccl:getenv x)
  #+(or cmu scl) (cdr (assoc x ext:*environment-list* :test #'string=))
741
742
743
744
745
746
747
748
749
750
  #+cormanlisp
  (let* ((buffer (ct:malloc 1))
         (cname (ct:lisp-string-to-c-string x))
         (needed-size (win:getenvironmentvariable cname buffer 0))
         (buffer1 (ct:malloc (1+ needed-size))))
    (prog1 (if (zerop (win:getenvironmentvariable cname buffer1 needed-size))
               nil
               (ct:c-string-to-lisp-string buffer1))
      (ct:free buffer)
      (ct:free buffer1)))
751
752
753
754
755
756
757
  #+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))))
758
  #+mkcl (#.(or (find-symbol* 'getenv :si) (find-symbol* 'getenv :mk-ext)) x)
759
  #+sbcl (sb-ext:posix-getenv x)
760
  #-(or abcl allegro clisp clozure cmu cormanlisp ecl gcl genera lispworks mcl mkcl sbcl scl xcl)
761
  (error "~S is not supported on your implementation" 'getenv))
762

763
(defun* directory-pathname-p (pathname)
764
  "Does PATHNAME represent a directory?
765
766

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

770
Note that this does _not_ check to see that PATHNAME points to an
771
actually-existing directory."
772
773
774
775
776
777
778
779
  (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)))))
780

781
(defun* ensure-directory-pathname (pathspec)
782
  "Converts the non-wild pathname designator PATHSPEC to directory form."
783
784
  (cond
   ((stringp pathspec)
785
    (ensure-directory-pathname (pathname pathspec)))
786
   ((not (pathnamep pathspec))
787
    (error (compatfmt "~@<Invalid pathname designator ~S~@:>") pathspec))
788
   ((wild-pathname-p pathspec)
789
    (error (compatfmt "~@<Can't reliably convert wild pathname ~3i~_~S~@:>") pathspec))
790
791
792
793
794
795
796
797
   ((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))))
798

799
800
#+genera
(unless (fboundp 'ensure-directories-exist)
801
  (defun* ensure-directories-exist (path)
802
803
    (fs:create-directories-recursively (pathname path))))

804
(defun* absolute-pathname-p (pathspec)
805
806
  (and (typep pathspec '(or pathname string))
       (eq :absolute (car (pathname-directory (pathname pathspec))))))
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
(defun* coerce-pathname (name &key type defaults)
  "coerce NAME into a PATHNAME.
When given a string, portably decompose it into a relative pathname:
#\\/ separates subdirectories. The last #\\/-separated string is as follows:
if TYPE is NIL, its last #\\. if any separates name and type from from type;
if TYPE is a string, it is the type, and the whole string is the name;
if TYPE is :DIRECTORY, the string is a directory component;
if the string is empty, it's a directory.
Any directory named .. is read as :BACK.
Host, device and version components are taken from DEFAULTS."
  ;; The defaults are required notably because they provide the default host
  ;; to the below make-pathname, which may crucially matter to people using
  ;; merge-pathnames with non-default hosts,  e.g. for logical-pathnames.
  ;; NOTE that the host and device slots will be taken from the defaults,
  ;; but that should only matter if you later merge relative pathnames with
  ;; CL:MERGE-PATHNAMES instead of ASDF:MERGE-PATHNAMES*
  (etypecase name
    ((or null pathname)
     name)
    (symbol
     (coerce-pathname (string-downcase name) :type type :defaults defaults))
    (string
     (multiple-value-bind (relative path filename)
         (component-name-to-pathname-components name :force-directory (eq type :directory)
                                                :force-relative t)
       (multiple-value-bind (name type)
           (cond
             ((or (eq type :directory) (null filename))
              (values nil nil))
             (type
              (values filename type))
             (t
              (split-name-type filename)))
         (apply 'make-pathname :directory (cons relative path) :name name :type type
                (when defaults `(:defaults ,defaults))))))))

(defun* merge-component-name-type (name &key type defaults)
  ;; For backwards compatibility only, for people using internals.
  ;; Will be removed in a future release, e.g. 2.016.
  (warn "Please don't use ASDF::MERGE-COMPONENT-NAME-TYPE. Use ASDF:COERCE-PATHNAME.")
  (coerce-pathname name :type type :defaults defaults))

(defun* subpathname (pathname subpath &key type)
  (and pathname (merge-pathnames* (coerce-pathname subpath :type type)
                                  (pathname-directory-pathname pathname))))

(defun subpathname* (pathname subpath &key type)
  (and pathname
       (subpathname (ensure-directory-pathname pathname) subpath :type type)))

858
(defun* length=n-p (x n) ;is it that (= (length x) n) ?
859
860
861
862
863
864
865
866
  (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)))))

867
(defun* string-suffix-p (s suffix)
868
869
870
871
872
  (check-type s string)
  (check-type suffix string)
  (let ((start (- (length s) (length suffix))))
    (and (<= 0 start)
         (string-equal s suffix :start1 start))))
873

874
(defun* read-file-forms (file)
875
876
877
878
879
880
  (with-open-file (in file)
    (loop :with eof = (list nil)
     :for form = (read in nil eof)
     :until (eq form eof)
     :collect form)))

881
(defun* pathname-root (pathname)
882
  (make-pathname :directory '(:absolute)
883
                 :name nil :type nil :version nil
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
884
885
                 :defaults pathname ;; host device, and on scl, *some*
                 ;; scheme-specific parts: port username password, not others:
886
                 . #.(or #+scl '(:parameters nil :query nil :fragment nil))))
887

888
(defun* probe-file* (p)
889
890
  "when given a pathname P, probes the filesystem for a file or directory
with given pathname and if it exists return its truename."
891
  (etypecase p
892
893
894
    (null nil)
    (string (probe-file* (parse-namestring p)))
    (pathname (unless (wild-pathname-p p)
895
                #.(or #+(or allegro clozure cmu cormanlisp ecl lispworks mkcl sbcl scl)
896
                      '(probe-file p)
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
897
898
                      #+clisp (aif (find-symbol* '#:probe-pathname :ext)
                                   `(ignore-errors (,it p)))
899
                      '(ignore-errors (truename p)))))))
900

901
(defun* truenamize (pathname &optional (defaults *default-pathname-defaults*))
902
  "Resolve as much of a pathname as possible"
903
  (block nil
904
905
    (when (typep pathname '(or null logical-pathname)) (return pathname))
    (let ((p (merge-pathnames* pathname defaults)))
906
      (when (typep p 'logical-pathname) (return p))
907
908
      (let ((found (probe-file* p)))
        (when found (return found)))
909
910
911
912
913
      (unless (absolute-pathname-p p)
        (let ((true-defaults (ignore-errors (truename defaults))))
          (when true-defaults
            (setf p (merge-pathnames pathname true-defaults)))))
      (unless (absolute-pathname-p p) (return p))
914
      (let ((sofar (probe-file* (pathname-root p))))
915
        (unless sofar (return p))
916
        (flet ((solution (directories)
917
918
                 (merge-pathnames*
                  (make-pathname :host nil :device nil
919
                                 :directory `(:relative ,@directories)
920
921
                                 :name (pathname-name p)
                                 :type (pathname-type p)
922
                                 :version (pathname-version p))
923
                  sofar)))
924
925
926
          (loop :with directory = (normalize-pathname-directory-component
                                   (pathname-directory p))
            :for component :in (cdr directory)
927
            :for rest :on (cdr directory)
928
929
930
931
            :for more = (probe-file*
                         (merge-pathnames*
                          (make-pathname :directory `(:relative ,component))
                          sofar)) :do
932
933
            (if more
                (setf sofar more)
934
                (return (solution rest)))
935
936
            :finally
            (return (solution nil))))))))
937

938
(defun* resolve-symlinks (path)
939
  #-allegro (truenamize path)
940
941
942
  #+allegro (if (typep path 'logical-pathname)
                path
                (excl:pathname-resolve-symbolic-links path)))
943

944
945
946
947
948
(defun* resolve-symlinks* (path)
  (if *resolve-symlinks*
      (and path (resolve-symlinks path))
      path))

949
(defun* ensure-pathname-absolute (path)