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

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

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

48
49
#+xcvb (module ())

50
51
52
(cl:in-package :cl)
(defpackage :asdf-bootstrap (:use :cl))
(in-package :asdf-bootstrap)
53

54
55
56
57
58
59
60
61
62
63
64
65
;; Implementation-dependent tweaks
(eval-when (:compile-toplevel :load-toplevel :execute)
  ;; (declaim (optimize (speed 2) (debug 2) (safety 3)) ; NO: rely on the implementation defaults.
  #+allegro
  (setf excl::*autoload-package-name-alist*
        (remove "asdf" excl::*autoload-package-name-alist*
                :test 'equalp :key 'car))
  #+ecl (require :cmp)
  #+gcl
  (eval-when (:compile-toplevel :load-toplevel)
    (defpackage :asdf-utilities (:use :cl))
    (defpackage :asdf (:use :cl :asdf-utilities))))
66

67
;;;; Create packages in a way that is compatible with hot-upgrade.
68
69
70
;;;; See https://bugs.launchpad.net/asdf/+bug/485687
;;;; See more at the end of the file.

71
(eval-when (:load-toplevel :compile-toplevel :execute)
72
  (let* ((asdf-version ;; the 1+ helps the version bumping script discriminate
73
          (subseq "VERSION:2.120" (1+ (length "VERSION"))))
74
         (existing-asdf (find-package :asdf))
75
76
77
78
         (vername '#:*asdf-version*)
         (versym (and existing-asdf
                      (find-symbol (string vername) existing-asdf)))
         (existing-version (and versym (boundp versym) (symbol-value versym)))
79
80
         (already-there (equal asdf-version existing-version)))
    (unless (and existing-asdf already-there)
81
      #-gcl
82
      (when existing-asdf
83
        (format *trace-output*
84
85
                "~&Upgrading ASDF package ~@[from version ~A ~]to version ~A~%"
                existing-version asdf-version))
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
      (labels
          ((rename-away (package)
             (loop :with name = (package-name package)
               :for i :from 1 :for new = (format nil "~A.~D" name i)
               :unless (find-package new) :do
               (rename-package-name package name new)))
           (rename-package-name (package old new)
             (let* ((old-names (cons (package-name package)
                                     (package-nicknames package)))
                    (new-names (subst new old old-names :test 'equal))
                    (new-name (car new-names))
                    (new-nicknames (cdr new-names)))
               (rename-package package new-name new-nicknames)))
           (ensure-exists (name nicknames use)
             (let* ((previous
                     (remove-duplicates
                      (remove-if
                       #'null
                       (mapcar #'find-package (cons name nicknames)))
                      :from-end t)))
               (cond
                 (previous
                  ;; do away with packages with conflicting (nick)names
                  (map () #'rename-away (cdr previous))
                  ;; reuse previous package with same name
                  (let ((p (car previous)))
                    (rename-package p name nicknames)
                    (ensure-use p use)
                    p))
                 (t
                  (make-package name :nicknames nicknames :use use)))))
           (find-sym (symbol package)
             (find-symbol (string symbol) package))
           (intern* (symbol package)
             (intern (string symbol) package))
           (remove-symbol (symbol package)
             (let ((sym (find-sym symbol package)))
               (when sym
                 (unexport sym package)
                 (unintern sym package))))
           (ensure-unintern (package symbols)
             (dolist (sym symbols) (remove-symbol sym package)))
           (ensure-shadow (package symbols)
             (shadow symbols package))
           (ensure-use (package use)
             (dolist (used (reverse use))
               (do-external-symbols (sym used)
                 (unless (eq sym (find-sym sym package))
                   (remove-symbol sym package)))
               (use-package used package)))
           (ensure-fmakunbound (package symbols)
             (loop :for name :in symbols
               :for sym = (find-sym name package)
               :when sym :do (fmakunbound sym)))
           (ensure-export (package export)
             (let ((syms (loop :for x :in export :collect
                           (intern* x package))))
               (do-external-symbols (sym package)
                 (unless (member sym syms)
                   (remove-symbol sym package)))
               (dolist (sym syms)
                 (export sym package))))
           (ensure-package (name &key nicknames use unintern fmakunbound shadow export)
             (let ((p (ensure-exists name nicknames use)))
               (ensure-unintern p unintern)
               (ensure-shadow p shadow)
               (ensure-export p export)
               (ensure-fmakunbound p fmakunbound)
               p)))
        (macrolet
            ((pkgdcl (name &key nicknames use export
                           redefined-functions unintern fmakunbound shadow)
158
159
160
161
162
                 `(ensure-package
                   ',name :nicknames ',nicknames :use ',use :export ',export
                   :shadow ',shadow
                   :unintern ',(append #-(or gcl ecl) redefined-functions unintern)
                   :fmakunbound ',(append fmakunbound))))
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
          (pkgdcl
           :asdf-utilities
           :nicknames (#:asdf-extensions)
           :use (#:common-lisp)
           :unintern (#:split #:make-collector)
           :export
           (#:absolute-pathname-p
            #:aif
            #:appendf
            #:asdf-message
            #:coerce-name
            #:directory-pathname-p
            #:ends-with
            #:ensure-directory-pathname
            #:getenv
            #:get-uid
            #:length=n-p
            #:merge-pathnames*
            #:pathname-directory-pathname
            #:read-file-forms
            #:remove-keys
            #:remove-keyword
            #:resolve-symlinks
            #:split-string
            #:component-name-to-pathname-components
            #:split-name-type
            #:system-registered-p
            #:truenamize
            #:while-collecting))
          (pkgdcl
           :asdf
           :use (:common-lisp :asdf-utilities)
           :redefined-functions
           (#:perform #:explain #:output-files #:operation-done-p
            #:perform-with-restarts #:component-relative-pathname
198
            #:system-source-file #:operate #:find-component #:find-system
199
            #:apply-output-translations #:translate-pathname*)
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
           :unintern
           (#:*asdf-revision* #:around #:asdf-method-combination
            #:split #:make-collector)
           :fmakunbound
           (#:system-source-file
            #:component-relative-pathname #:system-relative-pathname
            #:process-source-registry
            #:inherit-source-registry #:process-source-registry-directive)
           :export
           (#:defsystem #:oos #:operate #:find-system #:run-shell-command
            #:system-definition-pathname #:find-component ; miscellaneous
            #:compile-system #:load-system #:test-system
            #:compile-op #:load-op #:load-source-op
            #:test-op
            #:operation               ; operations
            #:feature                 ; sort-of operation
            #:version                 ; metaphorically sort-of an operation
            #:version-satisfies

219
            #:input-files #:output-files #:output-file #:perform ; operation methods
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
            #:operation-done-p #:explain

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

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

            #:component-depends-on

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

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

            #:asdf-version

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

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

            #:initialize-output-translations
            #:disable-output-translations
            #:clear-output-translations
            #:ensure-output-translations
            #:apply-output-translations
292
            #:compile-file*
293
294
295
296
297
298
299
300
301
302
            #:compile-file-pathname*
            #:enable-asdf-binary-locations-compatibility

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

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

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

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

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

346
Defaults to T.")
347

348
349
350
351
(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.")
352

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

359
(defvar *verbose-out* nil)
360

361
362
(defvar *asdf-verbose* t)

363
(defparameter +asdf-methods+
364
  '(perform-with-restarts perform explain output-files operation-done-p))
365

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

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

387
(defgeneric* find-system (system &optional error-p))
388
389
390
391
392
393
(defgeneric* perform-with-restarts (operation component))
(defgeneric* perform (operation component))
(defgeneric* operation-done-p (operation component))
(defgeneric* explain (operation component))
(defgeneric* output-files (operation component))
(defgeneric* input-files (operation component))
394
(defgeneric* component-operation-time (operation component))
395
396
397
398
(defgeneric* operation-description (operation component)
  (:documentation "returns a phrase that describes performing this operation
on this component, e.g. \"loading /a/b/c\".
You can put together sentences using this phrase."))
399

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

403
(defgeneric* component-system (component)
404
405
  (:documentation "Find the top-level system containing COMPONENT"))

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

409
(defgeneric* component-relative-pathname (component)
410
411
412
413
414
  (:documentation "Returns a pathname for the component argument intended to be
interpreted relative to the pathname of that component's parent.
Despite the function's name, the return value may be an absolute
pathname, because an absolute pathname may be interpreted relative to
another pathname in a degenerate way."))
415

416
(defgeneric* component-property (component property))
417

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

420
(defgeneric* version-satisfies (component version))
421

422
(defgeneric* find-component (base path)
423
424
  (:documentation "Finds the component with PATH starting from BASE module;
if BASE is nil, then the component is assumed to be a system."))
425

426
(defgeneric* source-file-type (component system))
427

428
(defgeneric* operation-ancestor (operation)
429
430
431
432
  (:documentation
   "Recursively chase the operation's parent pointer until we get to
the head of the tree"))

433
(defgeneric* component-visited-p (operation component)
434
435
436
437
438
  (:documentation "Returns the value stored by a call to
VISIT-COMPONENT, if that has been called, otherwise NIL.
This value stored will be a cons cell, the first element
of which is a computed key, so not interesting.  The
CDR wil be the DATA value stored by VISIT-COMPONENT; recover
439
it as (cdr (component-visited-p op c)).
440
441
442
443
444
  In the current form of ASDF, the DATA value retrieved is
effectively a boolean, indicating whether some operations are
to be performed in order to do OPERATION X COMPONENT.  If the
data value is NIL, the combination had been explored, but no
operations needed to be performed."))
445

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

456
(defgeneric* (setf visiting-component) (new-value operation component))
457

458
(defgeneric* component-visiting-p (operation component))
459

460
(defgeneric* component-depends-on (operation component)
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
  (:documentation
   "Returns a list of dependencies needed by the component to perform
    the operation.  A dependency has one of the following forms:

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

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

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

477
(defgeneric* component-self-dependencies (operation component))
478

479
(defgeneric* traverse (operation component)
480
  (:documentation
481
"Generate and return a plan for performing OPERATION on COMPONENT.
Gary King's avatar
Gary King committed
482

483
484
485
The plan returned is a list of dotted-pairs. Each pair is the CONS
of ASDF operation object and a COMPONENT object. The pairs will be
processed in order by OPERATE."))
486
487


488
489
;;;; -------------------------------------------------------------------------
;;;; General Purpose Utilities
490

491
(defmacro while-collecting ((&rest collectors) &body body)
492
493
494
495
496
497
498
499
500
501
  "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\)."
502
503
504
  (let ((vars (mapcar #'(lambda (x) (gensym (symbol-name x))) collectors))
        (initial-values (mapcar (constantly nil) collectors)))
    `(let ,(mapcar #'list vars initial-values)
505
       (flet ,(mapcar #'(lambda (c v) `(,c (x) (push x ,v) (values))) collectors vars)
506
         ,@body
507
         (values ,@(mapcar #'(lambda (v) `(reverse ,v)) vars))))))
508

509
510
511
(defmacro aif (test then &optional else)
  `(let ((it ,test)) (if it ,then ,else)))

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

518
(defun* merge-pathnames* (specified &optional (defaults *default-pathname-defaults*))
519
  "MERGE-PATHNAMES* is like MERGE-PATHNAMES except that if the SPECIFIED pathname
520
521
522
523
does not have an absolute directory, then the HOST and DEVICE come from the DEFAULTS.
Also, if either argument is NIL, then the other argument is returned unmodified."
  (when (null specified) (return-from merge-pathnames* defaults))
  (when (null defaults) (return-from merge-pathnames* specified))
524
525
526
  (let* ((specified (pathname specified))
         (defaults (pathname defaults))
         (directory (pathname-directory specified))
527
         #-sbcl (directory (if (stringp directory) `(:absolute ,directory) directory))
528
529
530
         (name (or (pathname-name specified) (pathname-name defaults)))
         (type (or (pathname-type specified) (pathname-type defaults)))
         (version (or (pathname-version specified) (pathname-version defaults))))
531
532
533
534
535
    (labels ((ununspecific (x)
               (if (eq x :unspecific) nil x))
             (unspecific-handler (p)
               (if (typep p 'logical-pathname) #'ununspecific #'identity)))
      (multiple-value-bind (host device directory unspecific-handler)
536
          (#-gcl ecase #+gcl case (first directory)
537
538
539
540
541
542
543
544
545
546
547
548
549
            ((nil)
             (values (pathname-host defaults)
                     (pathname-device defaults)
                     (pathname-directory defaults)
                     (unspecific-handler defaults)))
            ((:absolute)
             (values (pathname-host specified)
                     (pathname-device specified)
                     directory
                     (unspecific-handler specified)))
            ((:relative)
             (values (pathname-host defaults)
                     (pathname-device defaults)
550
551
552
                     (if (pathname-directory defaults)
                         (append (pathname-directory defaults) (cdr directory))
                         directory)
553
554
555
556
557
558
559
                     (unspecific-handler defaults)))
            #+gcl
            (t
             (assert (stringp (first directory)))
             (values (pathname-host defaults)
                     (pathname-device defaults)
                     (append (pathname-directory defaults) directory)
560
561
562
563
564
                     (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))))))
565

566
(define-modify-macro appendf (&rest args)
567
568
569
570
  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
571

572
(defun* first-char (s)
573
574
  (and (stringp s) (plusp (length s)) (char s 0)))

575
(defun* last-char (s)
576
577
  (and (stringp s) (plusp (length s)) (char s (1- (length s)))))

578
(defun* asdf-message (format-string &rest format-args)
579
580
581
  (declare (dynamic-extent format-args))
  (apply #'format *verbose-out* format-string format-args))

582
(defun* split-string (string &key max (separator '(#\Space #\Tab)))
583
584
  "Split STRING into a list of components separated by
any of the characters in the sequence SEPARATOR.
585
586
587
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\")."
588
589
590
591
592
593
594
595
596
597
598
599
600
  (block nil
    (let ((list nil) (words 0) (end (length string)))
      (flet ((separatorp (char) (find char separator))
             (done () (return (cons (subseq string 0 end) list))))
        (loop
          :for start = (if (and max (>= words (1- max)))
                           (done)
                           (position-if #'separatorp string :end end :from-end t)) :do
          (when (null start)
            (done))
          (push (subseq string (1+ start) end) list)
          (incf words)
          (setf end start))))))
601

602
(defun* split-name-type (filename)
603
604
605
606
  (let ((unspecific
         ;; Giving :unspecific as argument to make-pathname is not portable.
         ;; See CLHS make-pathname and 19.2.2.2.3.
         ;; We only use it on implementations that support it.
607
         (or #+(or ccl ecl gcl lispworks sbcl) :unspecific)))
608
609
610
611
612
    (destructuring-bind (name &optional (type unspecific))
        (split-string filename :max 2 :separator ".")
      (if (equal name "")
          (values filename unspecific)
          (values name type)))))
613

614
(defun* component-name-to-pathname-components (s &optional force-directory)
615
616
617
618
619
620
621
622
623
624
  "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
625
626
627
628
629
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."
630
  (check-type s string)
631
  (let* ((components (split-string s :separator "/"))
632
633
634
         (last-comp (car (last components))))
    (multiple-value-bind (relative components)
        (if (equal (first components) "")
635
            (if (equal (first-char s) #\/)
636
637
                (values :absolute (cdr components))
                (values :relative nil))
638
          (values :relative components))
639
      (setf components (remove "" components :test #'equal))
640
641
      (cond
        ((equal last-comp "")
642
         (values relative components nil)) ; "" already removed
643
644
645
646
        (force-directory
         (values relative components nil))
        (t
         (values relative (butlast components) last-comp))))))
647

648
(defun* remove-keys (key-names args)
649
650
651
652
653
  (loop :for (name val) :on args :by #'cddr
    :unless (member (symbol-name name) key-names
                    :key #'symbol-name :test 'equal)
    :append (list name val)))

654
(defun* remove-keyword (key args)
655
656
657
  (loop :for (k v) :on args :by #'cddr
    :unless (eq k key)
    :append (list k v)))
658

659
(defun* getenv (x)
660
661
662
663
664
665
666
667
668
669
  (#+abcl ext:getenv
   #+allegro sys:getenv
   #+clisp ext:getenv
   #+clozure ccl:getenv
   #+(or cmu scl) (lambda (x) (cdr (assoc x ext:*environment-list* :test #'string=)))
   #+ecl si:getenv
   #+gcl system:getenv
   #+lispworks lispworks:environment-variable
   #+sbcl sb-ext:posix-getenv
   x))
670

671
(defun* directory-pathname-p (pathname)
672
  "Does PATHNAME represent a directory?
673
674

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

678
Note that this does _not_ check to see that PATHNAME points to an
679
680
actually-existing directory."
  (flet ((check-one (x)
681
           (member x '(nil :unspecific "") :test 'equal)))
682
    (and (check-one (pathname-name pathname))
683
684
         (check-one (pathname-type pathname))
         t)))
685

686
(defun* ensure-directory-pathname (pathspec)
687
  "Converts the non-wild pathname designator PATHSPEC to directory form."
688
689
  (cond
   ((stringp pathspec)
690
    (ensure-directory-pathname (pathname pathspec)))
691
692
693
694
695
696
697
698
699
700
701
702
   ((not (pathnamep pathspec))
    (error "Invalid pathname designator ~S" pathspec))
   ((wild-pathname-p pathspec)
    (error "Can't reliably convert wild pathnames."))
   ((directory-pathname-p pathspec)
    pathspec)
   (t
    (make-pathname :directory (append (or (pathname-directory pathspec)
                                          (list :relative))
                                      (list (file-namestring pathspec)))
                   :name nil :type nil :version nil
                   :defaults pathspec))))
703

704
705
(defun* absolute-pathname-p (pathspec)
  (and pathspec (eq :absolute (car (pathname-directory (pathname pathspec))))))
706

707
(defun* length=n-p (x n) ;is it that (= (length x) n) ?
708
709
710
711
712
713
714
715
  (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)))))

716
(defun* ends-with (s suffix)
717
718
719
720
721
  (check-type s string)
  (check-type suffix string)
  (let ((start (- (length s) (length suffix))))
    (and (<= 0 start)
         (string-equal s suffix :start1 start))))
722

723
(defun* read-file-forms (file)
724
725
726
727
728
729
  (with-open-file (in file)
    (loop :with eof = (list nil)
     :for form = (read in nil eof)
     :until (eq form eof)
     :collect form)))

730
#-(and (or win32 windows mswindows mingw32) (not cygwin))
731
(progn
732
733
  #+ecl #.(cl:and (cl:< ext:+ecl-version-number+ 100601)
                  '(ffi:clines "#include <sys/types.h>" "#include <unistd.h>"))
734
  (defun* get-uid ()
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
    #+allegro (excl.osi:getuid)
    #+clisp (posix:uid)
    #+(or cmu scl) (unix:unix-getuid)
    #+ecl #.(cl:if (cl:< ext:+ecl-version-number+ 100601)
                   '(ffi:c-inline () () :int "getuid()" :one-liner t)
                   '(ext::getuid))
    #+sbcl (sb-unix:unix-getuid)
    #-(or allegro clisp cmu ecl sbcl scl)
    (let ((uid-string
           (with-output-to-string (*verbose-out*)
             (run-shell-command "id -ur"))))
      (with-input-from-string (stream uid-string)
        (read-line stream)
        (handler-case (parse-integer (read-line stream))
          (error () (error "Unable to find out user ID")))))))
750

751
(defun* pathname-root (pathname)
752
753
754
755
756
  (make-pathname :host (pathname-host pathname)
                 :device (pathname-device pathname)
                 :directory '(:absolute)
                 :name nil :type nil :version nil))

757
(defun* probe-file* (p)
758
759
760
  "when given a pathname P, probes the filesystem for a file or directory
with given pathname and if it exists return its truename."
  (and (pathnamep p) (not (wild-pathname-p p))
761
       #+(or allegro clozure cmu ecl sbcl scl) (probe-file p)
762
       #+clisp (ext:probe-pathname p)
763
764
       #-(or allegro clisp clozure cmu ecl sbcl scl)
       (ignore-errors (truename p))))
765

766
(defun* truenamize (p)
767
  "Resolve as much of a pathname as possible"
768
769
  (block nil
    (when (typep p 'logical-pathname) (return p))
770
    (let* ((p (merge-pathnames* p))
771
772
           (directory (pathname-directory p)))
      (when (typep p 'logical-pathname) (return p))
773
774
      (let ((found (probe-file* p)))
        (when found (return found)))
775
776
      #-sbcl (when (stringp directory) (return p))
      (when (not (eq :absolute (car directory))) (return p))
777
      (let ((sofar (probe-file* (pathname-root p))))
778
        (unless sofar (return p))
779
        (flet ((solution (directories)
780
781
                 (merge-pathnames*
                  (make-pathname :host nil :device nil
782
                                 :directory `(:relative ,@directories)
783
784
                                 :name (pathname-name p)
                                 :type (pathname-type p)
785
                                 :version (pathname-version p))
786
787
788
                  sofar)))
          (loop :for component :in (cdr directory)
            :for rest :on (cdr directory)
789
790
791
792
            :for more = (probe-file*
                         (merge-pathnames*
                          (make-pathname :directory `(:relative ,component))
                          sofar)) :do
793
794
            (if more
                (setf sofar more)
795
                (return (solution rest)))
796
797
            :finally
            (return (solution nil))))))))
798

799
(defun* resolve-symlinks (path)
800
801
802
  #-allegro (truenamize path)
  #+allegro (excl:pathname-resolve-symbolic-links path))

803
(defun* default-directory ()
804
805
  (truenamize (pathname-directory-pathname *default-pathname-defaults*)))

806
(defun* lispize-pathname (input-file)
807
808
  (make-pathname :type "lisp" :defaults input-file))

809
810
811
812
(defparameter *wild-path*
  (make-pathname :directory '(:relative :wild-inferiors)
                 :name :wild :type :wild :version :wild))

813
(defun* wilden (path)
814
815
  (merge-pathnames* *wild-path* path))

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

836
837
;;;; -------------------------------------------------------------------------
;;;; Classes, Conditions
Daniel Barlow's avatar
Daniel Barlow committed
838

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

848
849
850
851
852
853
854
855
856
(declaim (ftype (function (t) t)
                format-arguments format-control
                error-name error-pathname error-condition
                duplicate-names-name
                error-component error-operation
                module-components module-components-by-name)
         (ftype (function (t t) t) (setf module-components-by-name)))


Daniel Barlow's avatar
Daniel Barlow committed
857
(define-condition formatted-system-definition-error (system-definition-error)
858
859
860
  ((format-control :initarg :format-control :reader format-control)
   (format-arguments :initarg :format-arguments :reader format-arguments))
  (:report (lambda (c s)
861
             (apply #'format s (format-control c) (format-arguments c)))))
862

863
(define-condition load-system-definition-error (system-definition-error)
864
  ((name :initarg :name :reader error-name)
865
866
   (pathname :initarg :pathname :reader error-pathname)
   (condition :initarg :condition :reader error-condition))
867
  (:report (lambda (c s)
868
869
             (format s "~@<Error while trying to load definition for system ~A from pathname ~A: ~A~@:>"
                     (error-name c) (error-pathname c) (error-condition c)))))
870

Daniel Barlow's avatar
Daniel Barlow committed
871
(define-condition circular-dependency (system-definition-error)
872
873
874
  ((components :initarg :components :reader circular-dependency-components))
  (:report (lambda (c s)
             (format s "~@<Circular dependency: ~S~@:>" (circular-dependency-components c)))))
875

876
(define-condition duplicate-names (system-definition-error)
877
878
879
880
  ((name :initarg :name :reader duplicate-names-name))
  (:report (lambda (c s)
             (format s "~@<Error while defining system: multiple components are given same name ~A~@:>"
                     (duplicate-names-name c)))))
881

882
883
884
885
(define-condition missing-component (system-definition-error)
  ((requires :initform "(unnamed)" :reader missing-requires :initarg :requires)
   (parent :initform nil :reader missing-parent :initarg :parent)))

886
887
888
(define-condition missing-component-of-version (missing-component)
  ((version :initform nil :reader missing-version :initarg :version)))

889
890
891
(define-condition missing-dependency (missing-component)
  ((required-by :initarg :required-by :reader missing-required-by)))

892
(define-condition missing-dependency-of-version (missing-dependency
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
893
                                                 missing-component-of-version)
894
895
  ())

Daniel Barlow's avatar
Daniel Barlow committed
896
897
898
899
(define-condition operation-error (error)
  ((component :reader error-component :initarg :component)
   (operation :reader error-operation :initarg :operation))
  (:report (lambda (c s)
900
901
             (format s "~@<erred while invoking ~A on ~A~@:>"
                     (error-operation c) (error-component c)))))
902
903
904
(define-condition compile-error (operation-error) ())
(define-condition compile-failed (compile-error) ())
(define-condition compile-warned (compile-error) ())
Daniel Barlow's avatar
Daniel Barlow committed
905
906

(defclass component ()
907
  ((name :accessor component-name :initarg :name :documentation
908
         "Component name: designator for a string composed of portable pathname characters")
Daniel Barlow's avatar
Daniel Barlow committed
909
   (version :accessor component-version :initarg :version)
910
911
   (in-order-to :initform nil :initarg :in-order-to
                :accessor component-in-order-to)
912
   ;; This one is used by POIU. Maybe in the future by ASDF instead of in-order-to?
913
914
   ;; POIU is a parallel (multi-process build) extension of ASDF.  See
   ;; http://www.cliki.net/poiu
915
   (load-dependencies :accessor component-load-dependencies :initform nil)
916
   ;; XXX crap name, but it's an official API name!
917
918
   (do-first :initform nil :initarg :do-first
             :accessor component-do-first)
919
920
921
922
   ;; methods defined using the "inline" style inside a defsystem form:
   ;; need to store them somewhere so we can delete them when the system
   ;; is re-evaluated
   (inline-methods :accessor component-inline-methods :initform nil)
Daniel Barlow's avatar
Daniel Barlow committed
923
   (parent :initarg :parent :initform nil :reader component-parent)
Daniel Barlow's avatar
Daniel Barlow committed
924
925
   ;; no direct accessor for pathname, we do this as a method to allow
   ;; it to default in funky ways if not supplied
Daniel Barlow's avatar
   
Daniel Barlow committed
926
   (relative-pathname :initarg :pathname)
927
   (absolute-pathname)
928
   (operation-times :initform (make-hash-table)
929
                    :accessor component-operation-times)
Daniel Barlow's avatar
   
Daniel Barlow committed
930
931
   ;; XXX we should provide some atomic interface for updating the
   ;; component properties
932
   (properties :accessor component-properties :initarg :properties
933
               :initform nil)))
Daniel Barlow's avatar
   
Daniel Barlow committed
934

935
(defun* component-find-path (component)
936
937
938
939
940
941
942
943
944
  (reverse
   (loop :for c = component :then (component-parent c)
     :while c :collect (component-name c))))

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


Daniel Barlow's avatar
   
Daniel Barlow committed
945
946
947
;;;; methods: conditions

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

951
(defun* sysdef-error (format &rest arguments)
952
  (error 'formatted-system-definition-error :format-control
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
953
         format :format-arguments arguments))
Daniel Barlow's avatar
Daniel Barlow committed
954

Daniel Barlow's avatar
   
Daniel Barlow committed
955
956
957
;;;; methods: components

(defmethod print-object ((c missing-component) s)
958
  (format s "~@<component ~S not found~
959
             ~@[ in ~A~]~@:>"
960
961
962
          (missing-requires c)
          (when (missing-parent c)
            (component-name (missing-parent c)))))
Daniel Barlow's avatar
   
Daniel Barlow committed
963

964
965
966
(defmethod print-object ((c missing-component-of-version) s)
  (format s "~@<component ~S does not match version ~A~
              ~@[ in ~A~]~@:>"
967
968
969
970
          (missing-requires c)
          (missing-version c)
          (when (missing-parent c)
            (component-name (missing-parent c)))))
971

Daniel Barlow's avatar
Daniel Barlow committed
972
973
974
975
976
(defmethod component-system ((component component))
  (aif (component-parent component)
       (component-system it)
       component))

977
978
(defvar *default-component-class* 'cl-source-file)

979
(defun* compute-module-components-by-name (module)
980
981
  (let ((hash (make-hash-table :test 'equal)))
    (setf (module-components-by-name module) hash)
982
983
984
985
986
987
988
989
990
    (loop :for c :in (module-components module)
      :for name = (component-name c)
      :for previous = (gethash name (module-components-by-name module))
      :do
      (when previous
        (error 'duplicate-names :name name))
      :do (setf (gethash name (module-components-by-name module)) c))
    hash))

Daniel Barlow's avatar
Daniel Barlow committed
991
(defclass module (component)
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
  ((components
    :initform nil
    :initarg :components
    :accessor module-components)
   (components-by-name
    :accessor module-components-by-name)
   ;; What to do if we can't satisfy a dependency of one of this module's
   ;; components.  This allows a limited form of conditional processing.
   (if-component-dep-fails
    :initform :fail
    :initarg :if-component-dep-fails
    :accessor module-if-component-dep-fails)
   (default-component-class
    :initform *default-component-class*
    :initarg :default-component-class
    :accessor module-default-component-class)))
Daniel Barlow's avatar
Daniel Barlow committed
1008

1009
(defun* component-parent-pathname (component)
1010
1011
1012
1013
1014
1015
1016
  ;; No default anymore (in particular, no *default-pathname-defaults*).
  ;; If you force component to have a NULL pathname, you better arrange
  ;; for any of its children to explicitly provide a proper absolute pathname
  ;; wherever a pathname is actually wanted.
  (let ((parent (component-parent component)))
    (when parent
      (component-pathname parent))))
Daniel Barlow's avatar
   
Daniel Barlow committed
1017
1018

(defmethod component-pathname ((component component))
1019
1020
1021
1022
1023
  (if (slot-boundp component 'absolute-pathname)
      (slot-value component 'absolute-pathname)
      (let ((pathname
             (merge-pathnames*
             (component-relative-pathname component)
1024
             (pathname-directory-pathname (component-parent-pathname component)))))
1025
        (unless (or (null pathname) (absolute-pathname-p pathname))
1026
1027
          (error "Invalid relative pathname ~S for component ~S"
                 pathname (component-find-path component)))
1028
1029
        (setf (slot-value component 'absolute-pathname) pathname)
        pathname)))
Daniel Barlow's avatar
   
Daniel Barlow committed
1030

1031
(defmethod component-property ((c component) property)
Daniel Barlow's avatar
Daniel Barlow committed
1032
  (cdr (assoc property (slot-value c 'properties) :test #'equal)))
1033
1034

(defmethod (setf component-property) (new-value (c component) property)
Daniel Barlow's avatar
Daniel Barlow committed
1035
  (let ((a (assoc property (slot-value c 'properties) :test #'equal)))
1036
    (if a
1037
1038
        (setf (cdr a) new-value)
        (setf (slot-value c 'properties)
Francois-Rene Rideau's avatar
1.675.    
Francois-Rene Rideau committed
1039
1040
              (acons property new-value (slot-value c 'properties)))))
  new-value)
1041

Daniel Barlow's avatar
   
Daniel Barlow committed
1042
1043
(defclass system (module)
  ((description :accessor system-description :initarg :description)
Daniel Barlow's avatar
Daniel Barlow committed
1044
1045
   (long-description
    :accessor system-long-description :initarg :long-description)
Daniel Barlow's avatar
   
Daniel Barlow committed
1046
1047
   (author :accessor system-author :initarg :author)
   (maintainer :accessor system-maintainer :initarg :maintainer)
1048
   (licence :accessor system-licence :initarg :licence
1049
1050
            :accessor system-license :initarg :license)
   (source-file :reader system-source-file :initarg :source-file
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
1051
                :writer %set-system-source-file)))
Daniel Barlow's avatar
   
Daniel Barlow committed
1052

1053
1054
;;;; -------------------------------------------------------------------------
;;;; version-satisfies
Daniel Barlow's avatar
   
Daniel Barlow committed
1055
1056
1057
1058

(defmethod version-satisfies ((c component) version)
  (unless (and version (slot-boundp c 'version))
    (return-from version-satisfies t))
1059
1060
1061
  (version-satisfies (component-version c) version))

(defmethod version-satisfies ((cver string) version)
Daniel Barlow's avatar
   
Daniel Barlow committed
1062
  (let ((x (mapcar #'parse-integer
1063
                   (split-string cver :separator ".")))
1064
        (y (mapcar #'parse-integer
1065
                   (split-string version :separator "."))))
Daniel Barlow's avatar
   
Daniel Barlow committed
1066
    (labels ((bigger (x y)
1067
1068
1069
1070
1071
               (cond ((not y) t)
                     ((not x) nil)
                     ((> (car x) (car y)) t)
                     ((= (car x) (car y))
                      (bigger (cdr x) (cdr y))))))
Daniel Barlow's avatar
   
Daniel Barlow committed
1072
      (and (= (car x) (car y))
1073
           (or (not (cdr y)) (bigger (cdr x) (cdr y)))))))
Daniel Barlow's avatar
   
Daniel Barlow committed
1074

1075
1076
;;;; -------------------------------------------------------------------------
;;;; Finding systems
Daniel Barlow's avatar
   
Daniel Barlow committed
1077

1078
(defun* make-defined-systems-table ()
Gary King's avatar
Gary King committed
1079
1080
  (make-hash-table :test 'equal))

1081
1082
1083
1084
1085
1086
(defvar *defined-systems* (make-defined-systems-table)
  "This is a hash table whose keys are strings, being the
names of the systems, and whose values are pairs, the first
element of which is a universal-time indicating when the
system definition was last updated, and the second element
of which is a system object.")
Gary King's avatar
Gary King committed
1087

1088
(defun* coerce-name (name)
1089
1090
1091
1092
1093
  (typecase name
    (component (component-name name))
    (symbol (string-downcase (symbol-name name)))
    (string name)
    (t (sysdef-error "~@<invalid component designator ~A~@:>" name))))
Daniel Barlow's avatar
   
Daniel Barlow committed
1094

1095
(defun* system-registered-p (name)
1096
1097
  (gethash (coerce-name name) *defined-systems*))

1098
(defun* clear-system (name)
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
  "Clear the entry for a system in the database of systems previously loaded.
Note that this does NOT in any way cause the code of the system to be unloaded."
  ;; There is no "unload" operation in Common Lisp, and a general such operation
  ;; cannot be portably written, considering how much CL relies on side-effects
  ;; of global data structures.
  ;; Note that this does a setf gethash instead of a remhash
  ;; this way there remains a hint in the *defined-systems* table
  ;; that the system was loaded at some point.
  (setf (gethash (coerce-name name) *defined-systems*) nil))

1109
(