Skip to content
GitLab
Projects
Groups
Snippets
Help
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
A
asdf
Project overview
Project overview
Details
Activity
Releases
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Issues
15
Issues
15
List
Boards
Labels
Service Desk
Milestones
Merge Requests
9
Merge Requests
9
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Operations
Operations
Incidents
Environments
Analytics
Analytics
CI / CD
Repository
Value Stream
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
asdf
asdf
Commits
4d376d35
Commit
4d376d35
authored
Sep 15, 2014
by
Francois-Rene Rideau
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
Re-remove bin/load-asdf.lisp, which was wrongly merged from master.
parent
8b2c3daf
Changes
1
Show whitespace changes
Inline
Side-by-side
Showing
1 changed file
with
0 additions
and
218 deletions
+0
-218
bin/load-asdf.lisp
bin/load-asdf.lisp
+0
-218
No files found.
bin/load-asdf.lisp
deleted
100644 → 0
View file @
8b2c3daf
;;; The code below exemplifies how to load and configure ASDF
;;; as part of your own deterministic build.
;;; See "User-configurable parts" for where you'd customize it to suit your build.
;;;
;;; We have to play games with packages because on some implementations,
;;; an ASDF upgrade from ASDF 2 can throw away the previous package.
;;;
;;; Everything is MUCH simpler if you can assume your implementation has a recent-enough ASDF 3:
;;; see the commented out alternative below.
;;;
;;; To use the user-configured ASDF rather than a deterministic self-contained project build,
;;; see instead how cl-launch 4.0.4 loads ASDF.
;;; Actually, if you can assume that your implementation or distribution provides ASDF 3,
;;; you may simply use cl-launch, and achieve a deterministic self-contained project build
;;; by having your shell configuration or some shell wrapper script export a proper values
;;; for the CL_SOURCE_REGISTRY and ASDF_OUTPUT_TRANSLATIONS environment variables.
(
in-package
:cl-user
)
;; That may be default, but let's make double sure and tell SLIME.
;; Do everything in eval-when, so this works
;; whether this file is being loaded directly or compiled first.
(
eval-when
(
:compile-toplevel
:load-toplevel
:execute
)
(
labels
((
asdf-symbol
(
name
)
(
and
(
find-package
:asdf
)
(
find-symbol
(
string
name
)
:asdf
)))
(
asdf-call
(
name
&rest
args
)
(
apply
(
asdf-symbol
name
)
args
))
(
asdf-version
()
(
when
(
find-package
:asdf
)
(
or
(
symbol-value
(
or
(
asdf-symbol
'*asdf-version*
)
(
asdf-symbol
'*asdf-revision*
)))
"1.0"
)))
(
subpath
(
parent
&key
directory
name
type
version
)
;; We need subpath here, because we can't yet assume ASDF 3 and its subpathname
(
merge-pathnames
(
make-pathname
:defaults
parent
:directory
(
cons
:relative
directory
)
:name
name
:type
type
:version
version
)
(
make-pathname
:name
nil
:type
nil
:version
nil
:defaults
parent
)))
(
here-directory
()
(
subpath
(
or
*compile-file-truename*
*load-truename*
(
truename
*default-pathname-defaults*
))))
(
try-load
(
x
)
(
ignore-errors
(
and
(
probe-file
x
)
(
load
x
))))
(
load-and-configure-asdf
()
;; First, try to require ASDF from the implementation, if not already loaded.
;; Most implementations provide ASDF 3.0, LispWorks still lags with ASDF 2.019,
;; and some unmaintained implementations, or obsolete implementations or versions thereof
;; only provide ASDF 2, ASDF 1, or don't provide ASDF.
;; Note that CLISP is case-sensitive, so we need to specify a lowercase string,
;; and not the keyword :asdf or symbol 'asdf; old CLISP versions that don't provide ASDF
;; may error at compile-time if we call (require "asdf") directly.
(
ignore-errors
(
funcall
'require
"asdf"
))
;; If ASDF 2 isn't provided, load our ASDF from source.
;; ASDF 1 is not enough, because it won't heed our project's output-translations.
;; (Beside, no one serious provides ASDF 1 anymore.)
(
unless
(
member
:asdf2
*features*
)
(
or
(
and
(
try-load
(
asdf-lisp
))
(
member
:asdf2
*features*
))
(
error
"This Lisp implementation fails to provide ASDF 2 or later. ~
Please install it in ~A"
(
asdf-lisp
))))
;; Configure ASDF
(
configure-asdf
)
(
let
((
provided-version
(
asdf-version
)))
;; Upgrade ASDF to what we configured it to be.
(
asdf-call
'load-system
:asdf
)
;; If the implementation-provided version was too old,
;; we need to re-configure, because old configuration may have been moved away.
(
unless
(
asdf-call
'version-satisfies
provided-version
"2.27"
)
(
configure-asdf
)))
(
unless
(
asdf-call
'version-satisfies
(
asdf-version
)
(
required-asdf-version
))
(
error
"This program needs ASDF ~A but could only find ASDF ~A"
(
required-asdf-version
)
(
asdf-version
)))
;; Here, we specifically want the ASDF in the current git checkout over
;; whatever quicklisp is providing, so we load quicklisp last.
;; If the checkout weren't providing ASDF and we wanted to rely on Quicklisp
;; to provide a copy of ASDF that the implementation might be lacking,
;; we'd move this form right below the (funcall 'require "asdf") above.
;; See also notes in try-load-quicklisp.
(
try-load-quicklisp
))
;; User-configurable parts
(
required-asdf-version
()
"3.1.2"
)
;; In the end, we want at least ASDF 3.1.2
(
asdf-lisp
()
;; Here, define where your Lisp source code hierarchy stores its copy of ASDF.
;; In your project, that might be :directory '("libraries" "asdf" "build")
;; Or NIL, if you don't do use any fancy ASDF feature, and
;; trust your implementation to provide a recent enough copy.
(
subpath
(
here-directory
)
:directory
'
(
:back
"build"
)
:name
"asdf"
:type
"lisp"
))
(
try-load-quicklisp
()
;; In a controlled environment, either you'd use your own quicklisp
;; instead of the one in the user's homedir, or you wouldn't use quicklisp at all.
;; Edit this function as desired to reflect that and/or remove the call above.
;; Also, if you rely on quicklisp to load a recent ASDF rather than provide it
;; yourself in your code checkout (see above), you should be using the less portable
;; (merge-pathnames "..." (user-homedir-pathname)) rather than subpathname.
(
or
(
try-load
(
asdf-call
'subpathname
(
user-homedir-pathname
)
"quicklisp/setup.lisp"
))
(
try-load
(
asdf-call
'subpathname
(
user-homedir-pathname
)
".quicklisp/setup.lisp"
))))
(
configure-asdf
()
(
let*
((
source-directory
;; Here, define the top of your Lisp source code hierarchy.
;; If you can assume an implementation that has ASDF 2 or later
;; (you should: all serious ones do), you might compute it based on
;; (asdf-call 'getenv "MY_PROJECT_ROOT") instead of (here-directory).
;; If you can assume an implementation that has ASDF 3 or later
;; (you probably can: most serious ones do), you might use instead
;; (asdf-call 'getenv-pathname "MY_PROJECT_ROOT"
;; :want-absolute t :ensure-directory t)
(
subpath
(
here-directory
)
:directory
'
(
:back
)))
(
source-registry
(
or
(
asdf-call
'getenv
"ASDF_DEVEL_SOURCE_REGISTRY"
)
`
(
:source-registry
(
:directory
,
source-directory
)
(
:directory
(
,
source-directory
"uiop"
))
(
:directory
(
,
source-directory
"tools"
))
(
:tree
(
,
source-directory
"ext"
))
;; In a fully controlled build, you'd :ignore-inherited-configuration instead:
:inherit-configuration
)))
(
output-directory
;; There again, you might want to use some getenv variant.
;; Also, "fasls" might be redundant for your project.
(
subpath
source-directory
:directory
'
(
"build"
"fasls"
)))
(
output-translations
`
(
:output-translations
;; Segregate output by ABI.
;; You could replace "asdf" below by the name of your project,
;; or not need it at all if everything is under your source-directory.
(
,
source-directory
(
,
output-directory
:implementation
"asdf"
))
;; In a fully controlled build, we shouldn't be using code outside
;; our source-directory, but in case we do, we still want to control the output,
;; and easily detect the fact by looking at this directory
(
t
(
,
output-directory
:implementation
"root"
))
;; The above should already cover all paths that we use;
;; we don't want user configuration to interfere with the build.
:ignore-inherited-configuration
)))
;; No more user-configurable parts below.
(
asdf-call
'initialize-source-registry
source-registry
)
(
asdf-call
'initialize-output-translations
output-translations
))))
;; Configure the printer
(
setf
*print-readably*
nil
; allegro 5.0 may bork without this
*print-level*
nil
)
;; Hush the compiler and loader
(
setf
*load-verbose*
nil
*load-print*
nil
*compile-verbose*
nil
*compile-print*
nil
)
;; Load and configure ASDF
(
load-and-configure-asdf
)))
#|
;;; Here is the much simpler code when you can assume
;;; your implementation provides ASDF 3 (i.e. at least pre-release ASDF 2.27).
;;; No package madness.
(eval-when (:compile-toplevel :load-toplevel :execute)
(require "asdf"))
#-asdf3 (error "Your implementation fails to provide ASDF 3")
(in-package :asdf)
(eval-when (:compile-toplevel :load-toplevel :execute)
(let* ((here-directory
(pathname-directory-pathname
(or *compile-file-truename* *load-truename*
(truename *default-pathname-defaults*))))
;; User-configurable parts start here
(required-asdf-version "3.1.2") ;; In the end, we want at least ASDF 3.1.2
(source-directory
;; Here, define the top of your source code hierarchy.
;; For your project, it could be something like
;; (or (getenv-pathname "MY_PROJECT_ROOT"
;; :want-absolute t :ensure-directory t)
;; (subpathname here-directory "../../"))
(subpathname here-directory "../"))
(source-registry
;; Here, define your source registry.
;; For your project, it would be based solely on source-directory above,
;; and in a fully controlled build, you'd :ignore-inherited-configuration
(or (getenvp "ASDF_DEVEL_SOURCE_REGISTRY")
`(:source-registry
(:directory ,source-directory)
(:directory (,source-directory "uiop"))
(:directory (,source-directory "tools"))
(:tree (,source-directory "ext"))
;; In a fully controlled build, you'd :ignore-inherited-configuration instead:
:inherit-configuration)))
(output-directory
;; There again, you might want to use some getenvp variant.
;; Also, "fasls" might be redundant for your project.
(subpathname source-directory "build/fasls/"))
(output-translations
`(:output-translations
;; Segregate output by ABI.
;; You could replace "asdf" below by the name of your project,
;; or not need it at all if everything is under your source-directory.
(,source-directory (,output-directory :implementation "asdf"))
;; In a fully controlled build, we shouldn't be using code outside
;; our source-directory, but in case we do, we still want to control the output,
;; and easily detect the fact by looking at this directory
(t (,output-directory :implementation "root"))
;; The above should already cover all paths that we use;
;; we don't want user configuration to interfere with the build.
:ignore-inherited-configuration)))
;; No more user-configurable parts below.
;; Configure the printer
(setf *print-readably* nil ; allegro 5.0 may bork without this
*print-level* nil)
;; Hush the compiler and loader
(setf *load-verbose* nil *load-print* nil
*compile-verbose* nil *compile-print* nil)
;; Configure ASDF
(initialize-source-registry source-registry)
(initialize-output-translations output-translations)
;; Upgrade to the latest configured version
(upgrade-asdf)
;; Load Quicklisp --- see remarks in uncommented version above
(if-let (x (or (probe-file (subpathname (user-homedir-pathname) "quicklisp/setup.lisp"))
(probe-file (subpathname (user-homedir-pathname) ".quicklisp/setup.lisp"))))
(load x))
;; Check that we have a satisfactorily version
(unless (version-satisfies (asdf-version) required-asdf-version)
(error "Please install an ASDF ~A or later" required-asdf-version))))
|#
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment