Newer
Older
((subtypep (type-of o) dep-o)
o)
(t
(apply #'make-instance dep-o
:parent o :original-initargs args args)))))
(defmethod visit-component ((o operation) (c component) data)
(unless (component-visited-p o c)
(push (cons (node-for o c) data)
(operation-visited-nodes (operation-ancestor o)))))
(defmethod component-visited-p ((o operation) (c component))
(operation-visited-nodes (operation-ancestor o))
:test 'equal))
(defmethod (setf visiting-component) (new-value operation component)
;; MCL complains about unused lexical variables
(declare (ignorable new-value operation component)))
(defmethod (setf visiting-component) (new-value (o operation) (c component))
(let ((node (node-for o c))
(if new-value
(pushnew node (operation-visiting-nodes a) :test 'equal)
(setf (operation-visiting-nodes a)
(remove node (operation-visiting-nodes a) :test 'equal)))))
(defmethod component-visiting-p ((o operation) (c component))
(let ((node (node-for o c)))
(member node (operation-visiting-nodes (operation-ancestor o))
(defmethod component-depends-on ((op-spec symbol) (c component))
(component-depends-on (make-instance op-spec) c))
(defmethod component-depends-on ((o operation) (c component))
(cdr (assoc (class-name (class-of o))
Francois-Rene Rideau
committed
(component-in-order-to c))))
(defmethod component-self-dependencies ((o operation) (c component))
(let ((all-deps (component-depends-on o c)))
(remove-if-not (lambda (x)
(member (component-name c) (cdr x) :test #'string=))
all-deps)))
(defmethod input-files ((operation operation) (c component))
(let ((parent (component-parent c))
(self-deps (component-self-dependencies operation c)))
(mapcan (lambda (dep)
(destructuring-bind (op name) dep
(output-files (make-instance op)
(find-component parent name))))
self-deps)
;; no previous operations needed? I guess we work with the
;; original source file, then
(list (component-pathname c)))))
(defmethod input-files ((operation operation) (c module)) nil)

Daniel Barlow
committed
(flet ((fwd-or-return-t (file)
(let ((date (safe-file-write-date file)))
(cond
(date)
(warn "~@<Missing FILE-WRITE-DATE for ~S: treating ~
operation ~S on component ~S as done.~@:>"
file o c)
(return-from operation-done-p t))))))
(let ((out-files (output-files o c))
(in-files (input-files o c)))
(cond ((and (not in-files) (not out-files))
;; arbitrary decision: an operation that uses nothing to
;; produce nothing probably isn't doing much
t)
(let ((op-done
(gethash (type-of o)
(component-operation-times c))))
(and op-done
(>= op-done
(apply #'max
(mapcar #'fwd-or-return-t in-files))))))
((not in-files) nil)
(t
(and
(every #'probe-file out-files)
(> (apply #'min (mapcar #'safe-file-write-date out-files))
(apply #'max (mapcar #'fwd-or-return-t in-files)))))))))
;;; So you look at this code and think "why isn't it a bunch of
;;; methods". And the answer is, because standard method combination
;;; runs :before methods most->least-specific, which is back to front
(defmethod traverse ((operation operation) (c component))
(labels ((%do-one-dep (required-op required-c required-v)
(let* ((dep-c (or (find-component
(component-parent c)
;; XXX tacky. really we should build the
;; in-order-to slot with canonicalized
;; names instead of coercing this late
(coerce-name required-c) required-v)
(if required-v
(error 'missing-dependency-of-version
:required-by c
:version required-v
:requires required-c)
(error 'missing-dependency
:required-by c
:requires required-c))))
(op (make-sub-operation c operation dep-c required-op)))
(traverse op dep-c)))
(restart-case
(return (%do-one-dep required-op required-c required-v))
(retry ()
:report (lambda (s)
(format s "~@<Retry loading component ~S.~@:>"
required-c))
:test
(lambda (c)
(print (list :c1 c (typep c 'missing-dependency)))
(when (typep c 'missing-dependency)
(print (list :c2 (missing-requires c) required-c
(equalp (missing-requires c)
required-c))))
(and (typep c 'missing-dependency)
(equalp (missing-requires c)
required-c)))))))
(do-dep (op dep)
(cond ((eq op 'feature)
(or (member (car dep) *features*)
:requires (car dep))))
(cond ((string-equal
(symbol-name (first d))
"VERSION")
(appendf
forced
(do-one-dep op (second d) (third d))))
((and (string-equal
(symbol-name (first d))
"FEATURE")
(find (second d) *features*
:test 'string-equal))
(appendf
forced
(do-one-dep op (second d) (third d))))
(t
(error "Bad dependency ~a. Dependencies must be (:version <version>), (:feature <feature>), or a name" d))))
(t
(appendf forced (do-one-dep op d nil)))))))))
(aif (component-visited-p operation c)
(return-from traverse
(if (cdr it) (list (cons 'pruned-op c)) nil)))
(error 'circular-dependency :components (list c)))
(loop :for (required-op . deps) :in
(component-depends-on operation c)
:do (do-dep required-op deps))
;; constituent bits
(let ((module-ops
(when (typep c 'module)
(let ((at-least-one nil)
(forced nil)
(error nil))
(dolist (kid (module-components c))
(handler-case
(appendf forced (traverse operation kid))
(missing-dependency (condition)
(if (eq (module-if-component-dep-fails c)
:fail)
(error condition))
(setf error condition))
(:no-error (c)
(declare (ignore c))
(setf at-least-one t))))
(when (and (eq (module-if-component-dep-fails c)
:try-next)
(not at-least-one))
(error error))
forced))))
;; now the thing itself
(when (or forced module-ops
(not (operation-done-p operation c))
(let ((f (operation-forced
(operation-ancestor operation))))
(and f (or (not (consp f))
(member (component-name
(operation-ancestor operation))
(mapcar #'coerce-name f)
:test #'string=)))))
(let ((do-first (cdr (assoc (class-name (class-of operation))
Francois-Rene Rideau
committed
(component-do-first c)))))
(loop :for (required-op . deps) :in do-first
:do (do-dep required-op deps)))
(setf forced (append (delete 'pruned-op forced :key #'car)
(delete 'pruned-op module-ops :key #'car)
(list (cons operation c)))))))
(setf (visiting-component operation c) nil))
(defmethod perform ((operation operation) (c source-file))
Christophe Rhodes
committed
"~@<required method PERFORM not implemented ~
for operation ~A, component ~A~@:>"
(class-of operation) (class-of c)))
(defmethod perform ((operation operation) (c module))
nil)
(defmethod explain ((operation operation) (component component))
(asdf-message "~&;;; ~A on ~A~%" operation component))
;;;; -------------------------------------------------------------------------
;;;; compile-op
(defclass compile-op (operation)
((proclamations :initarg :proclamations :accessor compile-op-proclamations :initform nil)
:initform *compile-file-warnings-behaviour*)
:initform *compile-file-failure-behaviour*)
(flags :initarg :system-p :accessor compile-op-flags :initform nil)))
(defmethod perform :before ((operation compile-op) (c source-file))
(map nil #'ensure-directories-exist (output-files operation c)))
(defmethod perform :after ((operation operation) (c component))
(setf (gethash (type-of operation) (component-operation-times c))
;;; perform is required to check output-files to find out where to put
;;; its answers, in case it has been overridden for site policy
(defmethod perform ((operation compile-op) (c cl-source-file))

Daniel Barlow
committed
(let ((source-file (component-pathname c))
(output-file (car (output-files operation c))))
(apply #'compile-file source-file :output-file output-file
(compile-op-flags operation))
(case (operation-on-warnings operation)
(:warn (warn
"~@<COMPILE-FILE warned while performing ~A on ~A.~@:>"
operation c))
(:error (error 'compile-warned :component c :operation operation))
(:ignore nil)))
(case (operation-on-failure operation)
(:warn (warn
"~@<COMPILE-FILE failed while performing ~A on ~A.~@:>"
operation c))
(:error (error 'compile-failed :component c :operation operation))
(:ignore nil)))
(unless output
(error 'compile-error :component c :operation operation)))))
(defmethod output-files ((operation compile-op) (c cl-source-file))
#-:broken-fasl-loader (list (compile-file-pathname (component-pathname c)))
#+:broken-fasl-loader (list (component-pathname c)))
(defmethod perform ((operation compile-op) (c static-file))
nil)
(defmethod output-files ((operation compile-op) (c static-file))
nil)
(defmethod input-files ((op compile-op) (c static-file))
nil)
;;;; -------------------------------------------------------------------------
;;;; load-op
(defclass basic-load-op (operation) ())
(defclass load-op (basic-load-op) ())
(defmethod perform ((o load-op) (c cl-source-file))
(defmethod perform around ((o load-op) (c cl-source-file))
Gary King
committed
(let ((state :initial))
(loop :until (or (eq state :success)
(eq state :failure)) :do
(case state
(:recompiled
(setf state :failure)
(call-next-method)
(setf state :success))
(:failed-load
(setf state :recompiled)
(perform (make-instance 'asdf:compile-op) c))
(t
(with-simple-restart
(try-recompiling "Recompile ~a and try loading it again"
(component-name c))
(setf state :failed-load)
(call-next-method)
(setf state :success)))))))
Gary King
committed
(defmethod perform around ((o compile-op) (c cl-source-file))
Gary King
committed
(let ((state :initial))
(loop :until (or (eq state :success)
(eq state :failure)) :do
(case state
(:recompiled
(setf state :failure)
(call-next-method)
(setf state :success))
(:failed-compile
(setf state :recompiled)
(perform (make-instance 'asdf:compile-op) c))
(t
(with-simple-restart
(try-recompiling "Try recompiling ~a"
(component-name c))
(setf state :failed-compile)
(call-next-method)
(setf state :success)))))))
Gary King
committed
(defmethod perform ((operation load-op) (c static-file))
nil)
Gary King
committed
(defmethod operation-done-p ((operation load-op) (c static-file))
t)
(defmethod component-depends-on ((operation load-op) (c component))
(cons (list 'compile-op (component-name c))
(call-next-method)))
;;;; -------------------------------------------------------------------------
;;;; load-source-op
(defclass load-source-op (basic-load-op) ())
(defmethod perform ((o load-source-op) (c cl-source-file))

Kevin Rosenberg
committed
(let ((source (component-pathname c)))
(setf (component-property c 'last-loaded-as-source)
(and (load source)
(get-universal-time)))))
(defmethod perform ((operation load-source-op) (c static-file))
nil)
(defmethod output-files ((operation load-source-op) (c component))
nil)
;;; FIXME: we simply copy load-op's dependencies. this is Just Not Right.
(defmethod component-depends-on ((o load-source-op) (c component))
(let ((what-would-load-op-do (cdr (assoc 'load-op
Francois-Rene Rideau
committed
(component-in-order-to c)))))

Kevin Rosenberg
committed
(mapcar (lambda (dep)
(if (eq (car dep) 'load-op)
(cons 'load-source-op (cdr dep))
dep))
what-would-load-op-do)))
(defmethod operation-done-p ((o load-source-op) (c source-file))
(if (or (not (component-property c 'last-loaded-as-source))
(> (safe-file-write-date (component-pathname c))
(component-property c 'last-loaded-as-source)))

Kevin Rosenberg
committed
nil t))
;;;; -------------------------------------------------------------------------
;;;; test-op
(defclass test-op (operation) ())
(defmethod perform ((operation test-op) (c component))
nil)
(defmethod operation-done-p ((operation test-op) (c system))
"Testing a system is _never_ done."
nil)
(defmethod component-depends-on :around ((o test-op) (c system))
(cons `(load-op ,(component-name c)) (call-next-method)))
;;;; -------------------------------------------------------------------------
;;;; Invoking Operations
(defun operate (operation-class system &rest args &key (verbose t) version force
(let* ((*package* *package*)
(*readtable* *readtable*)
(op (apply #'make-instance operation-class
:original-initargs args
args))
(*verbose-out* (if verbose *standard-output* (make-broadcast-stream)))
(system (if (typep system 'component) system (find-system system))))
(unless (version-satisfies system version)
Gary King
committed
(error 'missing-component-of-version :requires system :version version))
(let ((steps (traverse op system)))
(with-compilation-unit ()
(loop :for (op . component) :in steps :do
(loop
(restart-case
(progn (perform op component)
(return))
(retry ()
:report
(lambda (s)
(format s "~@<Retry performing ~S on ~S.~@:>"
op component)))
(accept ()
:report
(lambda (s)
(format s "~@<Continue, treating ~S on ~S as ~
op component))
(setf (gethash (type-of op)
(component-operation-times component))
(get-universal-time))
(return)))))))
(defun oos (operation-class system &rest args &key force (verbose t) version
Gary King
committed
(declare (ignore force verbose version))
(apply #'operate operation-class system args))
(let ((operate-docstring
"Operate does three things:
1. It creates an instance of `operation-class` using any keyword parameters
as initargs.
2. It finds the asdf-system specified by `system` (possibly loading
it from disk).
3. It then calls `traverse` with the operation and system as arguments
The traverse operation is wrapped in `with-compilation-unit` and error
handling code. If a `version` argument is supplied, then operate also
ensures that the system found satisfies it using the `version-satisfies`
method.
Note that dependencies may cause the operation to invoke other
operations on the system or its components: the new operations will be
created with the same initargs as the original one.
"))
(setf (documentation 'oos 'function)
(format nil
"Short for _operate on system_ and an alias for the [operate][] function. ~&~&~a"
operate-docstring))
(setf (documentation 'operate 'function)
(defun load-system (system &rest args &key force (verbose t) version)
"Shorthand for `(operate 'asdf:load-op system)`. See [operate][] for details."
(declare (ignore force verbose version))
(apply #'operate 'load-op system args))
(defun compile-system (system &rest args &key force (verbose t) version)
"Shorthand for `(operate 'asdf:compile-op system)`. See [operate][] for details."
(declare (ignore force verbose version))
(apply #'operate 'compile-op system args))
(defun test-system (system &rest args &key force (verbose t) version)
"Shorthand for `(operate 'asdf:test-op system)`. See [operate][] for details."
(declare (ignore force verbose version))
(apply #'operate 'test-op system args))
;;;; -------------------------------------------------------------------------
;;;; Defsystem
(defun determine-system-pathname (pathname pathname-supplied-p)
;; called from the defsystem macro.
;; the pathname of a system is either
;; 2. derived from the *load-truename* (see below), or
;; 3. taken from *default-pathname-defaults*
;;
;; if using *load-truename*, then we also deal with whether or not
;; to resolve symbolic links. If not resolving symlinks, then we use
;; *load-pathname* instead of *load-truename* since in some
;; implementations, the latter has *already resolved it.
(or (and pathname-supplied-p pathname)
(pathname-sans-name+type
(if *resolve-symlinks*
(resolve-symlinks *load-truename*)
*load-pathname*)))
*default-pathname-defaults*))
(destructuring-bind (&key (pathname nil pathname-arg-p) (class 'system)
options
(let ((component-options (remove-keyword :class options)))
;; system must be registered before we parse the body, otherwise
;; we recur when trying to find an existing system of the same name
;; to reuse options (e.g. pathname) from
(let ((s (system-registered-p ',name)))
(cond ((and s (eq (type-of (cdr s)) ',class))
(setf (car s) (get-universal-time)))
(s
(change-class (cdr s) ',class))
(t
(register-system (quote ,name)
(make-instance ',class :name ',name))))
(%set-system-source-file *load-truename*
nil (apply
#'list
:module (coerce-name ',name)
:pathname
,(determine-system-pathname pathname pathname-arg-p)
',component-options))))))
(defun class-for-type (parent type)
(let* ((extra-symbols (list (find-symbol (symbol-name type) *package*)
Gary King
committed
(load-time-value
(class (dolist (symbol (if (keywordp type)
extra-symbols
(cons type extra-symbols)))
(find-class symbol nil)
(subtypep symbol 'component))
(return (find-class symbol))))))
(and (eq type :file)
(or (module-default-component-class parent)
(find-class 'cl-source-file)))
(sysdef-error "~@<don't recognize component type ~A~@:>" type))))
(defun maybe-add-tree (tree op1 op2 c)
"Add the node C at /OP1/OP2 in TREE, unless it's there already.
Returns the new tree (which probably shares structure with the old one)"
(let ((first-op-tree (assoc op1 tree)))
(if first-op-tree
(progn
(aif (assoc op2 (cdr first-op-tree))
(if (find c (cdr it))
nil
(setf (cdr it) (cons c (cdr it))))
(setf (cdr first-op-tree)
(acons op2 (list c) (cdr first-op-tree))))
tree)
(acons op1 (list (list op2 c)) tree))))
(defun union-of-dependencies (&rest deps)
(let ((new-tree nil))
(dolist (dep deps)
(dolist (op-tree dep)
(dolist (op (cdr op-tree))
(dolist (c (cdr op))
(setf new-tree
(maybe-add-tree new-tree (car op-tree) (car op) c))))))
(defvar *serial-depends-on*)
(defun sysdef-error-component (msg type name value)
(sysdef-error (concatenate 'string msg
"~&The value specified for ~(~A~) ~A is ~W")
type name value))
(defun check-component-input (type name weakly-depends-on
"A partial test of the values of a component."
(unless (listp depends-on)
(sysdef-error-component ":depends-on must be a list."
type name depends-on))
(unless (listp weakly-depends-on)
(sysdef-error-component ":weakly-depends-on must be a list."
type name weakly-depends-on))
(unless (listp components)
(sysdef-error-component ":components must be NIL or a list of components."
type name components))
(unless (and (listp in-order-to) (listp (car in-order-to)))
(sysdef-error-component ":in-order-to must be NIL or a list of components."
type name in-order-to)))
(defun %remove-component-inline-methods (component)
(dolist (name +asdf-methods+)
(map ()
;; this is inefficient as most of the stored
;; methods will not be for this particular gf n
;; But this is hardly performance-critical
(lambda (m)
(remove-method (symbol-function name) m))
(component-inline-methods component)))
;; clear methods, then add the new ones
(setf (component-inline-methods component) nil))
(defun %define-component-inline-methods (ret rest)
(dolist (name +asdf-methods+)
(let ((keyword (intern (symbol-name name) :keyword)))
(loop :for data = rest :then (cddr data)
:for key = (first data)
:for value = (second data)
:while data
:when (eq key keyword) :do
(destructuring-bind (op qual (o c) &body body) value
(pushnew
(eval `(defmethod ,name ,qual ((,o ,op) (,c (eql ,ret)))
,@body))
(component-inline-methods ret)))))))
(defun %refresh-component-inline-methods (component rest)
(%remove-component-inline-methods component)
(%define-component-inline-methods component rest))
(defun parse-component-form (parent options)
Gary King
committed
(type name &rest rest &key
;; the following list of keywords is reproduced below in the
;; remove-keys form. important to keep them in sync
components pathname default-component-class
perform explain output-files operation-done-p
weakly-depends-on
depends-on serial in-order-to
;; list ends
&allow-other-keys) options
(declare (ignorable perform explain output-files operation-done-p))
(check-component-input type name weakly-depends-on depends-on components in-order-to)
(when (and parent
(find-component parent name)
;; ignore the same object when rereading the defsystem
(not
(typep (find-component parent name)
(class-for-type parent type))))
(error 'duplicate-names :name name))
(let* ((other-args (remove-keys
'(components pathname default-component-class
perform explain output-files operation-done-p
weakly-depends-on
depends-on serial in-order-to)
rest))
(ret
(or (find-component parent name)
(make-instance (class-for-type parent type)))))
(setf depends-on (append depends-on (remove-if (complement #'find-system) weakly-depends-on))))
(when (boundp '*serial-depends-on*)
(setf depends-on
(concatenate 'list *serial-depends-on* depends-on)))
(apply #'reinitialize-instance ret
:name (coerce-name name)
:pathname pathname
:parent parent
other-args)
(when (typep ret 'module)
(setf (module-default-component-class ret)
(or default-component-class
(and (typep parent 'module)
(module-default-component-class parent))))
(let ((*serial-depends-on* nil))
(setf (module-components ret)
(loop :for c-form :in components
:for c = (parse-component-form ret c-form)
:collect c
:if serial
:do (push (component-name c) *serial-depends-on*))))
;; check for duplicate names
(let ((name-hash (make-hash-table :test #'equal)))
(loop :for c in (module-components ret) :do
(if (gethash (component-name c)
name-hash)
(error 'duplicate-names
:name (component-name c))
(setf (gethash (component-name c)
name-hash)
t)))))
Francois-Rene Rideau
committed
(setf (component-in-order-to ret)
(union-of-dependencies
in-order-to
`((compile-op (compile-op ,@depends-on))
(load-op (load-op ,@depends-on))))
Francois-Rene Rideau
committed
(component-do-first ret) `((compile-op (load-op ,@depends-on))))
Gary King
committed
ret)))
Francois-Rene Rideau
committed
;;;; ---------------------------------------------------------------------------
;;;; run-shell-command
;;;;
;;;; run-shell-command functions for other lisp implementations will be
;;;; gratefully accepted, if they do the same thing.
;;;; If the docstring is ambiguous, send a bug report.
Francois-Rene Rideau
committed
;;;;
;;;; We probably should move this functionality to its own system and deprecate
;;;; use of it from the asdf package. However, this would break unspecified
;;;; existing software, so until a clear alternative exists, we can't deprecate
;;;; it, and even after it's been deprecated, we will support it for a few
;;;; years so everyone has time to migrate away from it. -- fare 2009-12-01
"Interpolate `args` into `control-string` as if by `format`, and
synchronously execute the result using a Bourne-compatible shell, with
output to `*verbose-out*`. Returns the shell's exit code."
(let ((command (apply #'format nil control-string args)))
(asdf-message "; $ ~A~%" command)
#+sbcl
(apply #'sb-ext:run-program
#+win32 "sh" #-win32 "/bin/sh"
(list "-c" command)
:input nil :output *verbose-out*
#+win32 '(:search t) #-win32 nil))
#+(or cmu scl)

Daniel Barlow
committed
:input nil :output *verbose-out*))
#+allegro
;; will this fail if command has embedded quotes - it seems to work
(multiple-value-bind (stdout stderr exit-code)
(format nil "~a -c \"~a\""
#+mswindows "sh" #-mswindows "/bin/sh" command)
:input nil :whole nil
#+mswindows :show-window #+mswindows :hide)
(format *verbose-out* "~{~&; ~a~%~}~%" stderr)
(format *verbose-out* "~{~&; ~a~%~}~%" stdout)
exit-code)
#+lispworks
(system:call-system-showing-output
command
:shell-type "/bin/sh"

Daniel Barlow
committed
:output-stream *verbose-out*)
#+clisp ;XXX not exactly *verbose-out*, I know
(ext:run-shell-command command :output :terminal :wait t)
#+openmcl
(nth-value 1
(ccl:external-process-status
(ccl:run-program "/bin/sh" (list "-c" command)
:input nil :output *verbose-out*
:wait t)))
#+ecl ;; courtesy of Juan Jose Garcia Ripoll
(si:system command)
#-(or openmcl clisp lispworks allegro scl cmu sbcl ecl)
(error "RUN-SHELL-COMMAND not implemented for this Lisp")
Francois-Rene Rideau
committed
;;;; ---------------------------------------------------------------------------
;;;; system-relative-pathname
(defmethod system-source-file ((system-name t))
(system-source-file (find-system system-name)))
(defun system-source-directory (system-name)
(make-pathname :name nil
:type nil
:defaults (system-source-file system-name)))
Francois-Rene Rideau
committed
(defun relativize-directory (directory)
(if (eq (car directory) :absolute)
(cons :relative (cdr directory))
directory))
(defun relativize-pathname-directory (pathspec)
(let ((p (pathname pathspec)))
(make-pathname
:directory (relativize-directory (pathname-directory p))
:defaults p)))
(defun system-relative-pathname (system pathname &key name type)
(let ((directory (pathname-directory pathname)))
(merge-pathnames
(make-pathname :name (or name (pathname-name pathname))
:type (or type (pathname-type pathname))
Francois-Rene Rideau
committed
:directory (relativize-directory directory))
(system-source-directory system))))
Francois-Rene Rideau
committed
;;; ---------------------------------------------------------------------------
Francois-Rene Rideau
committed
;;; implementation-identifier
Francois-Rene Rideau
committed
;;; produce a string to identify current implementation.
;;; Initially stolen from SLIME's SWANK, hacked since.
(defparameter *implementation-features*
Francois-Rene Rideau
committed
'(:allegro :lispworks :sbcl :clozure :digitool :cmu :clisp
:corman :cormanlisp :armedbear :gcl :ecl :scl))
(defparameter *os-features*
Francois-Rene Rideau
committed
'((:windows :mswindows :win32 :mingw32)
(:solaris :sunos)
:macosx :darwin :apple
:freebsd :netbsd :openbsd :bsd
:linux :unix))
(defparameter *architecture-features*
Francois-Rene Rideau
committed
'((:x86-64 :amd64 :x86_64 :x8664-target)
(:x86 :i686 :i586 :pentium3 :i486 :i386 :pc386 :iapx386 :x8632-target :pentium4)
:hppa64 :hppa :ppc64 (:ppc32 :ppc :powerpc) :sparc64 :sparc))
(defun lisp-version-string ()
Francois-Rene Rideau
committed
(let ((s (lisp-implementation-version)))
(declare (ignorable s))
#+(or scl sbcl ecl armedbear cormanlisp mcl) s
#+cmu (substitute #\- #\/ s)
#+clozure (format nil "~d.~d~@[-~d~]"
Francois-Rene Rideau
committed
#+lispworks (format nil "~A~@[~A~]" s
(when (member :lispworks-64bit *features*) "-64bit"))
#+allegro (format nil
"~A~A~A~A"
excl::*common-lisp-version-number*
Francois-Rene Rideau
committed
;; ANSI vs MoDeRn - thanks to Robert Goldman and Charley Cox
(if (eq excl:*current-case-mode*
:case-sensitive-lower) "M" "A")
;; Note if not using International ACL
;; see http://www.franz.com/support/documentation/8.1/doc/operators/excl/ics-target-case.htm
(excl:ics-target-case
Francois-Rene Rideau
committed
(:-ics "8")
(:+ics ""))
(if (member :64bit *features*) "-64bit" ""))
Francois-Rene Rideau
committed
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
#+(or clisp gcl) (subseq s 0 (position #\space s))
#+digitool (subseq s 8)))
(defun first-feature (features)
(labels
((fp (thing)
(etypecase thing
(symbol
(let ((feature (find thing *features*)))
(when feature (return-from fp feature))))
;; allows features to be lists of which the first
;; member is the "main name", the rest being aliases
(cons
(dolist (subf thing)
(when (find subf *features*) (return-from fp (first thing))))))
nil))
(loop :for f :in features
:when (fp f) :return :it)))
(defun implementation-type ()
(first-feature *implementation-features*))
(defun implementation-identifier ()
(labels
((maybe-warn (value fstring &rest args)
(cond (value)
(t (apply #'warn fstring args)
"unknown"))))
(let ((lisp (maybe-warn (implementation-type)
"No implementation feature found in ~a."
*implementation-features*))
(os (maybe-warn (first-feature *os-features*)
"No os feature found in ~a." *os-features*))
(arch (maybe-warn (first-feature *architecture-features*)
"No architecture feature found in ~a."
*architecture-features*))
(version (maybe-warn (lisp-version-string)
"Don't know how to get Lisp ~
Francois-Rene Rideau
committed
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
(substitute-if
#\_ (lambda (x) (find x " /:\\(){}[]$#`'\""))
(format nil "~(~@{~a~^-~}~)" lisp version os arch)))))
;;; ---------------------------------------------------------------------------
;;; Generic support for configuration files
(defun user-configuration-directory ()
(merge-pathnames #p".config/" (user-homedir-pathname)))
(defun system-configuration-directory ()
#p"/etc/")
(defun configuration-inheritance-directive-p (x)
(let ((kw '(:inherit-configuration :ignore-inherited-configuration)))
(or (member x kw)
(and (length=n-p x 1) (member (car x) kw)))))
(defun validate-configuration-form (form tag directive-validator
&optional (description tag))
(unless (and (consp form) (eq (car form) tag))
(error "Error: Form doesn't specify ~A ~S~%" description form))
(loop :with inherit = 0
:for directive :in (cdr form) :do
(if (configuration-inheritance-directive-p directive)
(incf inherit)
(funcall directive-validator directive))
:finally
(unless (= inherit 1)
(error "One and only one of ~S or ~S is required"
:inherit-configuration :ignore-inherited-configuration)))
form)
(defun validate-configuration-file (file validator description)
(let ((forms (read-file-forms file)))
(unless (length=n-p forms 1)
(error "One and only one form allowed for ~A. Got: ~S~%" description forms))
(funcall validator (car forms))))
(defun validate-configuration-directory (directory tag validator)
(let ((files (sort (ignore-errors
(directory (merge-pathnames
(make-pathname :name :wild :type :wild)
directory)
#+sbcl :resolve-symlinks #+sbcl nil))
#'string< :key #'namestring)))
`(,tag
,@(loop :for file :in files :append
(mapcar validator (read-file-forms file)))
:inherit-configuration)))
;;; ---------------------------------------------------------------------------
;;; asdf-output-translations
;;;
;;; this code is heavily inspired from
;;; asdf-binary-translations, common-lisp-controller and cl-launch.
;;; ---------------------------------------------------------------------------
(defvar *output-translations* ()
"Either NIL (for uninitialized), or a list of one element,
said element itself being a sorted list of mappings.
Each mapping is a pair of a source pathname and destination pathname,
and the order is by decreasing length of namestring of the source pathname.")
(defvar *user-cache* '(:home ".cache" "common-lisp" :implementation))
(defvar *system-cache* '(:root "var" "cache" "common-lisp" :uid :implementation))
(defun output-translations ()
(car *output-translations*))
(defun (setf output-translations) (x)
(setf *output-translations*
(list
(stable-sort (copy-list x) #'>
:key (lambda (x) (length (pathname-directory (car x))))))))
(defun output-translations-initialized-p ()
(and *output-translations* t))
(defun clear-output-translations ()
"Undoes any initialization of the output translations.
You might want to call that before you dump an image that would be resumed
with a different configuration, so the configuration would be re-read then."
(setf *output-translations* '())
(values))
(defun resolve-location (x)
(if (atom x)
(resolve-absolute-location-component x nil)
(loop :with path = (resolve-absolute-location-component (car x) t)
:for (component . morep) :on (cdr x)
:do (setf path (resolve-relative-location-component path component morep))
:finally (return path))))
(defun resolve-absolute-location-component (x morep)
(let* ((r
(etypecase x
(pathname x)
(string (ensure-directory-pathname x))
((eql :home) (user-homedir-pathname))
((eql :user-cache) (resolve-location *user-cache*))
((eql :system-cache) (resolve-location *system-cache*))
((eql :current-directory) (truenamize *default-pathname-defaults*))