asdf.lisp 219 KB
Newer Older
1
;; -*- mode: Common-Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp ; coding: utf-8 -*-
2
;;; This is ASDF 2.26.44: 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.44")
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 fmakunbound)
217
             (let* ((p (ensure-exists name nicknames use)))
218
               #-ecl (ensure-fmakunbound p fmakunbound) #+ecl fmakunbound ;; do it later on ECL
219
               (ensure-unintern p unintern)
220
221
222
223
224
               (ensure-shadow p shadow)
               (ensure-export p export)
               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
                   :fmakunbound ',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 #:component-load-dependencies #:traverse-action
237
            #:component-depends-on #:perform-plan #:mark-operation-done
238
            #:perform-with-restarts #:component-relative-pathname
239
            #:system-source-file #:operate #:find-component #:find-system
240
            #:apply-output-translations #:translate-pathname* #:resolve-location
241
            #:system-relative-pathname
242
            #:source-file-type
243
244
            #:inherit-source-registry #:process-source-registry
            #:process-source-registry-directive
245
            #:compile-file* #:source-file-type #:trivial-system-p)
246
247
           :unintern
           (#:*asdf-revision* #:around #:asdf-method-combination
248
            #:split #:make-collector #:do-dep #:do-one-dep
249
            #:loaded-systems ; makes for annoying SLIME completion
250
            #:output-files-for-system-and-operation) ; obsolete ASDF-BINARY-LOCATION function
251
           :export
252
253
           (#:defsystem #:find-system #:locate-system
            #:oos #:operate #:traverse #:perform-plan
254
            #:system-definition-pathname #:with-system-definitions
255
            #:search-for-system-definition #:find-component #:component-find-path
256
257
            #:compile-system #:load-system #:load-systems
            #:require-system #:test-system #:clear-system
258
259
260
261
            #:operation #:upward-operation #:downward-operation
            #:load-op #:prepare-op #:compile-op #:load-fasl-op
            #:prepare-source-op #:load-source-op #:test-op
            #:feature #:version #:version-satisfies #:upgrade-asdf
262
            #:implementation-identifier #:implementation-type #:hostname
263
            #:input-files #:output-files #:output-file #:perform
264
            #:operation-done-p #:explain #:component-sibling-dependencies
265
266
267
268
269
270
271
272
            #:component-load-dependencies #:run-shell-command ; deprecated, do not use
            #:precompiled-system #:compiled-file
            #+ecl #:make-build #+mkcl #:bundle-system

            #:component #:parent-component #:child-component #:system #:module
            #:source-file #:c-source-file #:java-source-file
            #:cl-source-file #:cl-source-file.cl #:cl-source-file.lsp
            #:static-file #:doc-file #:html-file :text-file
273
274
275
            #:source-file-type
            #:unix-dso

276
277
            #:component-children          ; component accessors
            #:component-children-by-name
278
279
280
281
282
283
284
            #:component-pathname
            #:component-relative-pathname
            #:component-name
            #:component-version
            #:component-parent
            #:component-property
            #:component-system
285
286
            #:component-encoding
            #:component-external-format
287

288
289
290
291
            ;;#:action-depends-on ; future name
            #:module-components ; backwards compatibility
            #:component-depends-on ; backwards compatibility

292
293
294
295
296
297
298
299
300
301
302
            #:system-description
            #:system-long-description
            #:system-author
            #:system-maintainer
            #:system-license
            #:system-licence
            #:system-source-file
            #:system-source-directory
            #:system-relative-pathname
            #:map-systems

303
            #:operation-description
304
305
            #:operation-on-warnings
            #:operation-on-failure
306
            #:component-visited-p
307
308
309

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

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

338
            #:*encoding-detection-hook*
339
340
341
342
            #:*encoding-external-format-hook*
            #:*default-encoding*
            #:*utf-8-external-format*

343
            #:clear-configuration
344
            #:*output-translations-parameter*
345
346
347
348
349
            #:initialize-output-translations
            #:disable-output-translations
            #:clear-output-translations
            #:ensure-output-translations
            #:apply-output-translations
350
            #:compile-file*
351
352
353
            #:compile-file-pathname*
            #:enable-asdf-binary-locations-compatibility
            #:*default-source-registries*
354
            #:*source-registry-parameter*
355
356
357
358
            #:initialize-source-registry
            #:compute-source-registry
            #:clear-source-registry
            #:ensure-source-registry
359
            #:process-source-registry
360
            #:system-registered-p #:registered-systems #:already-loaded-systems
361
            #:resolve-location
362
            #:asdf-message
363
364
365
366
367
368
369
370
            #: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
371

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

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

412
Defaults to T.")
413

414
415
416
417
(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.")
418

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

425
(defvar *verbose-out* nil)
426

427
(defparameter +asdf-methods+
428
  '(perform-with-restarts perform explain output-files operation-done-p))
429

430
431
432
433
434
435
436
437
(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.")

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

446
447
448
449
450
451
452
453
;;;; -------------------------------------------------------------------------
;;;; 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
454
455
                component-children component-children-by-name
                circular-dependency-actions
456
457
458
                condition-arguments condition-form
                condition-format condition-location
                coerce-name)
459
         (ftype (function (&optional t) (values)) initialize-source-registry)
460
         #-(or cormanlisp gcl-pre2.7)
461
         (ftype (function (t t) t) (setf component-children-by-name)))
462
463

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

474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
#.(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))))))"))

493
;;;; -------------------------------------------------------------------------
494
495
;;;; General Purpose Utilities

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

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

526
(defmacro aif (test then &optional else)
527
  "Anaphoric version of IF, On Lisp style"
528
529
  `(let ((it ,test)) (if it ,then ,else)))

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

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

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

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

581
582
583
(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"
584
  (make-pathname
585
586
587
588
589
   :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))))
590

591
(defun* merge-pathnames* (specified &optional (defaults *default-pathname-defaults*))
592
593
594
595
596
  "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.
597
598
599
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))
600
601
602
  #+scl
  (ext:resolve-pathname specified defaults)
  #-scl
603
604
  (let* ((specified (pathname specified))
         (defaults (pathname defaults))
605
         (directory (normalize-pathname-directory-component (pathname-directory specified)))
606
607
608
         (name (or (pathname-name specified) (pathname-name defaults)))
         (type (or (pathname-type specified) (pathname-type defaults)))
         (version (or (pathname-version specified) (pathname-version defaults))))
609
    (labels ((unspecific-handler (p)
610
               (if (typep p 'logical-pathname) #'make-pathname-component-logical #'identity)))
611
      (multiple-value-bind (host device directory unspecific-handler)
612
          (ecase (first directory)
613
614
615
616
617
            ((:absolute)
             (values (pathname-host specified)
                     (pathname-device specified)
                     directory
                     (unspecific-handler specified)))
618
            ((nil :relative)
619
620
             (values (pathname-host defaults)
                     (pathname-device defaults)
621
                     (merge-pathname-directory-components directory (pathname-directory defaults))
622
623
624
625
626
                     (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))))))
627

628
629
630
631
632
(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
633
634
                   :directory (merge-pathname-directory-components
                               '(:relative :back) (pathname-directory pathname))
635
636
                   :defaults pathname)))

637
(define-modify-macro appendf (&rest args)
638
639
640
641
  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
642

643
(defun* first-char (s)
644
645
  (and (stringp s) (plusp (length s)) (char s 0)))

646
(defun* last-char (s)
647
648
  (and (stringp s) (plusp (length s)) (char s (1- (length s)))))

649

650
(defun* asdf-message (format-string &rest format-args)
651
  (declare (dynamic-extent format-args))
652
  (apply 'format *verbose-out* format-string format-args))
653

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

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

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

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

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

738
(defun* getenv (x)
739
  (declare (ignorable x))
740
  #+(or abcl clisp ecl xcl) (ext:getenv x)
741
742
743
  #+allegro (sys:getenv x)
  #+clozure (ccl:getenv x)
  #+(or cmu scl) (cdr (assoc x ext:*environment-list* :test #'string=))
744
745
746
747
748
749
750
751
752
753
  #+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)))
754
755
756
757
758
759
760
  #+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))))
761
  #+mkcl (#.(or (find-symbol* 'getenv :si) (find-symbol* 'getenv :mk-ext)) x)
762
  #+sbcl (sb-ext:posix-getenv x)
763
  #-(or abcl allegro clisp clozure cmu cormanlisp ecl gcl genera lispworks mcl mkcl sbcl scl xcl)
764
  (error "~S is not supported on your implementation" 'getenv))
765

766
(defun* directory-pathname-p (pathname)
767
  "Does PATHNAME represent a directory?
768
769

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

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

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

802
803
#+genera
(unless (fboundp 'ensure-directories-exist)
804
  (defun* ensure-directories-exist (path)
805
806
    (fs:create-directories-recursively (pathname path))))

807
(defun* absolute-pathname-p (pathspec)
808
809
  (and (typep pathspec '(or pathname string))
       (eq :absolute (car (pathname-directory (pathname pathspec))))))
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
(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))))

857
(defun* subpathname* (pathname subpath &key type)
858
859
860
  (and pathname
       (subpathname (ensure-directory-pathname pathname) subpath :type type)))

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

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

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

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

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

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

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

947
948
949
950
951
(defun* resolve-symlinks* (path)
  (if *resolve-symlinks*
      (and path (resolve-symlinks path))
      path))

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