Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the overlord Reference Manual, version 51, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed Jun 15 05:29:38 2022 GMT+0.
Next: Systems, Previous: The overlord Reference Manual, Up: The overlord Reference Manual [Contents][Index]
Overlord is a build system in Common Lisp. It is a real build system, with all the modern features: rules with multiple outputs, parallel builds, immunity to clock issues, and dynamic dependencies.
But Overlord is more than another build system. Overlord is a uniform approach to dependencies inside or outside of a Lisp image. Conceptually, Overlord is to Make what Lisp macros are to C macros.
Overlord uses a persistent store to track dependencies. This small overhead translates into drastically simplified semantics for the programmer. Much like garbage collection allows programmers largely not to have to think about lifetimes, persistent dependencies allow programmers largely not to have to think about phasing.
For more discussion, consult the wiki. If you are a Lisper, you might want to jump straight to the tutorial for Lispers.
Note that, to run the test suite, you will need to
download Core Lisp, and, if not on Windows, you must have the
touch program in your search path. (On Windows, Powershell is
used instead).
Overlord stores its persistent data structures in a cache directory.
On Linux, this is $XDG_CACHE_HOME/overlord. The data structures
stored there are versioned. It might worth checking the cache
directory from time to time to delete obsolete files.
Overlord is developed and tested on Clozure and SBCL. In the future it may officially support other Lisp implementations, but that is not a priority.
Here are some projects that make direct use of Overlord:
cl-https-everywhere. In-process HTTPS Everywhere rulesets, automatically fetched from the HTTPS Everywhere repository and compiled into Lisp code.
Proctor. Proctor treats tests as build targets, allowing you to precisely specify their dependencies and re-run tests only when necessary.
Vernacular. Provides a module system for embedding languages, with arbitrary syntaxes, into Common Lisp systems.
Next: Files, Previous: Introduction, Up: The overlord Reference Manual [Contents][Index]
The main system appears first, followed by any subsystem dependency.
Next: overlord/all, Previous: Systems, Up: Systems [Contents][Index]
Experimental build system.
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
51
overlord/all (system).
Next: overlord/types, Previous: overlord, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/message, Previous: overlord/all, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/global-state, Previous: overlord/types, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/util, Previous: overlord/message, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
serapeum (system).
Next: overlord/specials, Previous: overlord/global-state, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/asdf, Previous: overlord/util, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/redo, Previous: overlord/specials, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/target-protocol, Previous: overlord/asdf, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/stamp, Previous: overlord/redo, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/target-table, Previous: overlord/target-protocol, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/build-env, Previous: overlord/stamp, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/kernel, Previous: overlord/target-table, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/db, Previous: overlord/build-env, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/cache, Previous: overlord/kernel, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/makespan, Previous: overlord/db, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/base, Previous: overlord/cache, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/target, Previous: overlord/makespan, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/digest, Previous: overlord/base, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/freeze, Previous: overlord/target, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/oracle, Previous: overlord/digest, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: overlord/project-system, Previous: overlord/freeze, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Previous: overlord/oracle, Up: Systems [Contents][Index]
Paul M. Rodriguez <pmr@ruricolist.com>
MIT
Next: Packages, Previous: Systems, Up: The overlord Reference Manual [Contents][Index]
Files are sorted by type and then listed depth-first from the systems components trees.
Next: overlord/all/file-type.lisp, Previous: Lisp, Up: Lisp [Contents][Index]
overlord (system).
Next: overlord/types/file-type.lisp, Previous: overlord/overlord.asd, Up: Lisp [Contents][Index]
overlord/all (system).
Next: overlord/message/file-type.lisp, Previous: overlord/all/file-type.lisp, Up: Lisp [Contents][Index]
overlord/types (system).
Next: overlord/global-state/file-type.lisp, Previous: overlord/types/file-type.lisp, Up: Lisp [Contents][Index]
overlord/message (system).
Next: overlord/util/file-type.lisp, Previous: overlord/message/file-type.lisp, Up: Lisp [Contents][Index]
overlord/global-state (system).
Next: overlord/specials/file-type.lisp, Previous: overlord/global-state/file-type.lisp, Up: Lisp [Contents][Index]
overlord/util (system).
Next: overlord/asdf/file-type.lisp, Previous: overlord/util/file-type.lisp, Up: Lisp [Contents][Index]
overlord/specials (system).
Next: overlord/redo/file-type.lisp, Previous: overlord/specials/file-type.lisp, Up: Lisp [Contents][Index]
overlord/asdf (system).
Next: overlord/target-protocol/file-type.lisp, Previous: overlord/asdf/file-type.lisp, Up: Lisp [Contents][Index]
overlord/redo (system).
Next: overlord/stamp/file-type.lisp, Previous: overlord/redo/file-type.lisp, Up: Lisp [Contents][Index]
overlord/target-protocol (system).
Next: overlord/target-table/file-type.lisp, Previous: overlord/target-protocol/file-type.lisp, Up: Lisp [Contents][Index]
overlord/stamp (system).
Next: overlord/build-env/file-type.lisp, Previous: overlord/stamp/file-type.lisp, Up: Lisp [Contents][Index]
overlord/target-table (system).
Next: overlord/kernel/file-type.lisp, Previous: overlord/target-table/file-type.lisp, Up: Lisp [Contents][Index]
overlord/build-env (system).
Next: overlord/db/file-type.lisp, Previous: overlord/build-env/file-type.lisp, Up: Lisp [Contents][Index]
overlord/kernel (system).
Next: overlord/cache/file-type.lisp, Previous: overlord/kernel/file-type.lisp, Up: Lisp [Contents][Index]
overlord/db (system).
Next: overlord/makespan/file-type.lisp, Previous: overlord/db/file-type.lisp, Up: Lisp [Contents][Index]
overlord/cache (system).
Next: overlord/base/file-type.lisp, Previous: overlord/cache/file-type.lisp, Up: Lisp [Contents][Index]
overlord/makespan (system).
Next: overlord/target/file-type.lisp, Previous: overlord/makespan/file-type.lisp, Up: Lisp [Contents][Index]
overlord/base (system).
Next: overlord/digest/file-type.lisp, Previous: overlord/base/file-type.lisp, Up: Lisp [Contents][Index]
overlord/target (system).
Next: overlord/freeze/file-type.lisp, Previous: overlord/target/file-type.lisp, Up: Lisp [Contents][Index]
overlord/digest (system).
Next: overlord/oracle/file-type.lisp, Previous: overlord/digest/file-type.lisp, Up: Lisp [Contents][Index]
overlord/freeze (system).
Next: overlord/project-system/file-type.lisp, Previous: overlord/freeze/file-type.lisp, Up: Lisp [Contents][Index]
overlord/oracle (system).
Previous: overlord/oracle/file-type.lisp, Up: Lisp [Contents][Index]
overlord/project-system (system).
Next: Definitions, Previous: Files, Up: The overlord Reference Manual [Contents][Index]
Packages are listed by definition order.
Next: overlord/redo, Previous: Packages, Up: Packages [Contents][Index]
Next: overlord/project-system, Previous: overlord/types, Up: Packages [Contents][Index]
redo
Next: overlord/base, Previous: overlord/redo, Up: Packages [Contents][Index]
Very basic, experimental ASDF extension. Looks for
a package with the same name as the system and a symbol named ‘all’ in
that package, and builds that.
Use ‘asdf:make’ to get the desired behavior.
Next: overlord/freeze, Previous: overlord/project-system, Up: Packages [Contents][Index]
Next: overlord/cache, Previous: overlord/base, Up: Packages [Contents][Index]
Next: overlord/makespan, Previous: overlord/freeze, Up: Packages [Contents][Index]
Next: overlord/oracle, Previous: overlord/cache, Up: Packages [Contents][Index]
Next: overlord/global-state, Previous: overlord/makespan, Up: Packages [Contents][Index]
Next: overlord/target-table, Previous: overlord/oracle, Up: Packages [Contents][Index]
Next: overlord-user, Previous: overlord/global-state, Up: Packages [Contents][Index]
Next: overlord/specials, Previous: overlord/target-table, Up: Packages [Contents][Index]
Next: overlord/target, Previous: overlord-user, Up: Packages [Contents][Index]
Next: overlord/build-env, Previous: overlord/specials, Up: Packages [Contents][Index]
Next: overlord/asdf, Previous: overlord/target, Up: Packages [Contents][Index]
Environment for builds, including (but not limited to) caching already built targets.
Next: overlord/digest, Previous: overlord/build-env, Up: Packages [Contents][Index]
This package contains wrappers for ASDF functions.
The idea is to be able to trivially audit exactly how Overlord uses ASDF.
If you want to call an ASDF function in another package, don’t! Add a wrapper for it here and import that.
Next: overlord/stamp, Previous: overlord/asdf, Up: Packages [Contents][Index]
Next: overlord/util, Previous: overlord/digest, Up: Packages [Contents][Index]
Next: overlord/target-protocol, Previous: overlord/stamp, Up: Packages [Contents][Index]
Next: overlord/message, Previous: overlord/util, Up: Packages [Contents][Index]
Next: overlord/all, Previous: overlord/target-protocol, Up: Packages [Contents][Index]
Next: overlord/kernel, Previous: overlord/message, Up: Packages [Contents][Index]
overlord
Next: overlord/db, Previous: overlord/all, Up: Packages [Contents][Index]
Previous: overlord/kernel, Up: Packages [Contents][Index]
Next: Indexes, Previous: Packages, Up: The overlord Reference Manual [Contents][Index]
Definitions are sorted by export status, category, package, and then by lexicographic order.
Next: Internals, Previous: Definitions, Up: Definitions [Contents][Index]
Next: Symbol macros, Previous: Public Interface, Up: Public Interface [Contents][Index]
The current base.
The package relative to which (if bound) the base should be computed.
Are we running on a CLI?
Versioning for fasls.
Incrementing this should be sufficient to invalidate old fasls.
Whether to force rebuilding.
The stream printed to by the default message handler.
The chain of parents being built.
Should we cache which targets are already built?
Note that this can safely be rebound around part of a build when non-caching behavior is desired.
Next: Macros, Previous: Special variables, Up: Public Interface [Contents][Index]
Next: Compiler macros, Previous: Symbol macros, Up: Public Interface [Contents][Index]
Define a conf with dependencies.
A dependency can be a file or another variable.
If any of those files or variables change, then the variable is rebuilt.
Lower-level version of ‘deftask’.
Unlike tasks defined using ‘deftask’, tasks defined using ‘define-target-task’ are built before freezing.
Define a variable with dependencies.
A dependency can be a file or another variable.
If any of those files or variables change, then the variable is rebuilt.
Like ‘defvar’, but also re-evaluate if EXPR changes.
Define a file pattern named NAME.
Some build systems let you define file patterns based on extensions or
regular expressions. That won’t work for Overlord, because there is no
special namespace for targets, so such a rule would apply everywhere.
It has to have a name.
The behavior of ‘defpattern’ changes based on the bindings you
request. IN is bound to the name of the input file or files.
For the meaning of OUT and DEST, compare the documentation for ‘file-target’.
Define a task – a target that only has dependencies.
This is essentially a convenience to let you use script syntax to specify the dependencies you want to build.
Like SXHASH, but try to stack-allocate EXPR.
Define PATHNAME as a target.
If supplied, PATHNAME may be a literal pathname or a string (in which
case it is parsed with ‘uiop:parse-unix-namestring’). Using a string
is preferred for programs that care about portability. If not
supplied, PATHNAME defaults to NAME, as a string, with its case
inverted, and any earmuffs removed.
NAME is not a target; it is a binding that serves as a convenient
handle for the name of the target. (It is also necessary to be able to
recognize that the file is out of date when BODY changes.) The binding
is a lexical binding, unless NAME has earmuffs (‘*NAME*’) in which
case it is bound as a special variable.
The behavior of ‘file-target’ depends on which, if any, bindings are
requested. If DEST is supplied, then it is simply bound to PATHNAME,
after it has been resolved. If only DEST is supplied, or if no
bindings are requested, then you must write directly to the
destination file.
If a binding for OUT is supplied, however, the behavior of
‘file-target’ changes: OUT is bound to a temporary file, and after
BODY has finished the destination file is atomically overwritten
with OUT.
You should generally prefer OUT to DEST. DEST is most useful when you are using an external program that lets you specify the input file but not the output file (a bad design, but unfortunately a common one).
There are legitimate cases where you might want to use both OUT and DEST: for example, while writing to OUT, you might still need to know the name of the destination file in order to derive the names of input files to depend on dynamically.
Modify macro for removing from an Fset map or set.
At compile time, parse STRING using ‘uiop:parse-unix-namestring’.
The result is a relative pathname object.
This is an alternative to literal pathname syntax for greater portability.
Force BODY to be evaluated both at compile time AND load time (but
not run time).
Note that BODY should be idempotent, as it may be evaluated more than once.
Macro wrapper for ‘call/saving-database’.
Set the base and/or system, for the current package, at compile time as well as load time.
Like ‘define-target-var’, but does not actually evaluate anything.
Modify macro for augmenting an Fset map or set.
Next: Ordinary functions, Previous: Macros, Up: Public Interface [Contents][Index]
Next: Generic functions, Previous: Compiler macros, Up: Public Interface [Contents][Index]
An oracle that monitors the version of COMMAND (by calling it with an argument of ‘–version’.
Get a token from the current build environment.
Return the current base, which is either the current value of ‘*base*’ (if that is bound) or the base of the current package.
Build TARGET/S, a single target or a list of targets.
Return T if anything is being built.
Lock every target in TARGETS, then call FN.
Before locking, targets are ordered according to the global order established by ‘fset:compare’, to avoid deadlocks.
Like ‘call/temp-file-pathnames‘, but for a single file.
Create a set of temp files, call FN on them, and then copy the temp files into DESTS.
Clear the current prerequisites of PACKAGE. Return PACKAGE.
The current Overlord cache directory.
The path includes the Overlord major version, as well as the Lisp
implementation and version, so if Overlord is updated, or the Lisp
implementation is upgraded, the old cache is automatically
invalidated.
Return the current directory.
If ‘*default-pathname-defaults*’ is an absolute directory pathname, return that.
Otherwise, resolve ‘*default-pathname-defaults*’ to an absolute directory, set ‘*default-pathname-defaults*’ to the new value, and return the new value.
Retrieve or infer the system the current package comes from.
Depend on today’s date.
This is for targets that should be no more than one a day.
Clear the DB out of memory in such a way that it will not be reloaded on demand.
Delete a property from OBJ.
Delete all targets in TARGETS, in no particular order. Lists of targets in TARGETS are flattened.
Delete a specific version of the database. The database is always implicitly versioned.
Depend on the targets in TARGETS not existing. Descends into lists.
Depend on each target in TARGETS, in no particular order. Descends into lists.
Like ‘depends-on’, but in order.
Wrap NAME as a directory reference.
Terminate the Overlord kernel.
Ensure that TARGET is recorded as a prerequisite.
If there is no current parent, make TARGET a prerequisite of the
current package.
Evaluate EXPR by compiling it to a thunk, then calling that thunk.
Parse PATH as a Unix namestring and resolve it. If PATH is wild, expand it.
As ‘file-write-date’, but check if the file exists first.
This is provided in case we ever want to offer more precise timestamps
on Lisp/OS/filesystem combinations that support it, and for
implementations which signal an error rather than returning nil when
PATHNAME does not exist.
Get or set the current freeze policy.
The freeze policy determines what Overlord does when saving an image.
A freeze policy of ‘t’ (the default) disables module loading, but can
be reversed with ‘overlord:unfreeze’.
A freeze policy of ‘nil‘ does nothing. This should only be used for
local development.
A freeze policy of ‘:hard’ does the same thing as ‘t’, but cannot be reversed. This should be used when the image is intended to be distributed.
Test if an object has a property in the database.
List the current prerequisites of PACKAGE.
Make a shadow tree with prefix PREFIX. PREFIX may be a string or a list of strings.
Given MACHINE-COUNT, a sequence of TARGETS, and a sequence of BUILD-TIMES for each target, distribute TARGETS into batches, at most one batch per machine (but possibly less), in such a way as to minimize their makespan – the time until the last machine is done with the last task.
Retrieve or infer the base of PACKAGE.
Retrieve or infer the system PACKAGE comes from.
Make a pattern reference.
Look up a property for an object in the database.
Set an object’s property in the database.
Unconditionally build each target in TARGETS.
Unconditionally build each target in TARGETS.
Depend on an impossible prerequisite.
This ensures that the script for the current target is always run, no
matter what.
Rebuild each target in TARGETS if it is out of date.
Rebuild each target in TARGETS if it is out of date.
Depend on the non-existence of each target in TARGETS.
Depend on the non-existence of each target in TARGETS.
Register VAR as a variable that should be propagated into worker threads.
Register each var in VARS, as with ‘register-worker-special’.
Load the DB.
Restore Overlord’s global state to its value when first loaded.
This is intended to be the practical equivalent of quitting Lisp and
reloading: it completely resets Overlord’s internal state.
Note that this does not reset *just* Overlord’s state. It also resets a number of Lisp global variables to their default values.
Like ‘find-package’, but make sure the package is resolved in absolute terms even if the Lisp implementation supports local package nicknames.
Return TOKEN to the current build environment.
Entry point for scripts.
Save the current database.
Return a path equivalent to PATH in shadow tree TREE. PATH must be an absolute path.
Is stamp NEW practically equivalent to (but not necessarily the same as) OLD?
Initialize a new Overlord project.
If DIRECTORY is relative, it is created as a subdirectory of
Return PATHNAME without its directory (or device).
Skip hitting the filesystem to check if a target exists if we already built it.
Skip hitting the filesystem to check a target’s stamp if we already built it.
Is TS1 greater than TS2?
Return a list of (target . deps), where each dep is also a target
tree.
As a second value, return the non-existent prereqs.
Return the difference between END and START, two timestamps, in nanoseconds.
Is TS1 greater than TS2?
Clear the DB out of memory in such a way that it can still be reloaded on demand.
Stop VAR from being propagated into worker threads.
Unregister each var in VARS as with ‘unregister-worker-special’.
Like ‘use-all’, but variadic.
Like ‘use-all*’, but targets are shuffled.
Return a function suitable for passing to a worker that, that
lexically closes over the current dynamic value of every special that has been registered for propagation to worker threads.
Write DATA into FILE only if FILE would change.
DATA may be a string or a byte vector.
Return T if the file was written to, NIL otherwise.
Next: Standalone methods, Previous: Ordinary functions, Up: Public Interface [Contents][Index]
Call FN with TARGET locked.
Lock the directory (file), not target.
Make call-with-target-meta-locked the default for call-with-target-locked.
Delete TARGET, if it can be deleted.
Can TARGET be used as a key in a EQUAL hash table?
Hash TARGET.
Two targets that are equal under ‘target=’ should always have the same hash (though the reverse is not necessarily true).
Build OUTPUTS from INPUTS according to PATTERN.
automatically generated reader method
name.
automatically generated reader method
automatically generated reader method
name.
Record TARGET as a prerequisite of the current parent.
Resolve any relative pathnames in TARGET.
TARGET may be returned unchanged if there are no pathnames to resolve, but it must not be mutated. If there are pathnames to resolve, TARGET should be copied.
How long (in internal time units) a target took to build.
Does TARGET exists?
Has TARGET been built before?
Return a string suitable for logging (for humans) what target is being built.
Return the stamp of TARGET.
automatically generated reader method
name.
Return the timestamp of TARGET.
Set the timestamp of TARGET.
Not every target type supports this.
Are TARGET1 and TARGET2 the same?
Next: Conditions, Previous: Generic functions, Up: Public Interface [Contents][Index]
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
fset.
automatically generated reader method
serapeum.
lock.
asdf/operate.
Next: Structures, Previous: Standalone methods, Up: Public Interface [Contents][Index]
condition.
Next: Classes, Previous: Conditions, Up: Public Interface [Contents][Index]
%read-only-struct.
common-lisp.
string
(alexandria:required-argument (quote package-name))
This slot is read-only.
common-lisp.
string
(alexandria:required-argument (quote symbol-name))
This slot is read-only.
%unit.
The hash of a file.
We store both the size and the hash of the file to further reduce the
already negligible possibility of a collision.
%read-only-struct.
(integer 0 *)
(alexandria:required-argument (quote overlord/stamp::size))
This slot is read-only.
string
(alexandria:required-argument (quote overlord/stamp::hash))
This slot is read-only.
Metadata to track whether a file has changed.
%read-only-struct.
(integer 0 *)
(alexandria:required-argument (quote overlord/stamp::size))
This slot is read-only.
local-time.
overlord/stamp:target-timestamp
(alexandria:required-argument (quote local-time:timestamp))
This slot is read-only.
The target that is always out of date.
%unit.
%unit.
A resolved file.
This enables a relative file as a target to register as changed if the
file it resolves to changes.
This is intended for cases (like the ‘system-resource’ target class) where ‘redo-ifcreate’ isn’t enough to detect when a resource has been shadowed.
%read-only-struct.
serapeum:file-pathname
(alexandria:required-argument (quote overlord/stamp::path))
This slot is read-only.
(or overlord/stamp:file-meta overlord/stamp:file-hash)
(alexandria:required-argument (quote overlord/stamp::meta))
This slot is read-only.
The root target.
Building this builds all targets defined in this session (not all targets in the database).
%unit.
A table for storing targets.
This wraps an Fset map (for custom target types) and a hash table (for built-in types) and keeps them in sync.
structure-object.
common-lisp.
fset:map
(fset:empty-map)
common-lisp.
hash-table
(make-hash-table :test (quote equal) :size 1024)
This slot is read-only.
(bordeaux-threads:make-recursive-lock)
This slot is read-only.
serapeum.
boolean
This slot is read-only.
A task.
%read-only-struct.
overlord/target::target
(alexandria:required-argument (quote overlord/target::target))
This slot is read-only.
function
(alexandria:required-argument (quote overlord/target::thunk))
This slot is read-only.
overlord/target::target
(alexandria:required-argument (quote overlord/target::script))
This slot is read-only.
(or null serapeum:directory-pathname)
(alexandria:required-argument (quote overlord/base:base))
This slot is read-only.
The target that is never out of date.
%unit.
Next: Types, Previous: Structures, Up: Public Interface [Contents][Index]
A reference to a directory.
An oracle that reports the current version of a
Quicklisp dist.
By default this is the Quicklisp dist itself.
| Initarg | Value |
|---|---|
| :name | quicklisp |
string
:name
This slot is read-only.
Oracle that wraps an environment variable.
| Initarg | Value |
|---|---|
| :name | (required-argument name) |
string
:name
This slot is read-only.
An oracle that wraps whether a particular keyword is present in ‘*features*’.
keyword
:feature
This slot is read-only.
An oracle for a user-supplied function.
The function must be supplied as a symbol.
Oracles let you depend on aspects of the Lisp or OS
environment.
When you depend on an oracle, Overlord remembers the answer the oracle gave at the time of the dependency (or the lack of an answer, if the oracle was unbound). If that answer changes, then any targets that depend on the oracle are considered out of date.
:question
This slot is read-only.
system.
(string (quote overlord/project-system::all))
:target-name
This slot is read-only.
A file-to-file build pattern.
| Initarg | Value |
|---|---|
| :input-defaults | nil |
| :output-defaults | nil |
| :script | trivial-prereq |
(overlord/types:list-of overlord/target::pathname)
:input-defaults
This slot is read-only.
(overlord/types:list-of overlord/target::pathname)
:output-defaults
This slot is read-only.
overlord/target::target
:script
This slot is read-only.
ref.
| Initarg | Value |
|---|---|
| :inputs | (quote nil) |
| :outputs | (quote nil) |
(or symbol standard-object overlord/types:delayed-symbol)
:pattern
This slot is read-only.
(overlord/types:list-of overlord/target::pathname)
:inputs
This slot is read-only.
(overlord/types:list-of overlord/target::pathname)
:outputs
This slot is read-only.
overlord/target::pathname
(overlord/base:base)
This slot is read-only.
Using a system version oracle, you can depend on
the major version of an ASDF system.
Note that if the system is not known to ASDF, then the version recorded is simply nil.
string
:name
This slot is read-only.
Oracle that wraps a special variable.
Oracles for Lisp variables are intended to allow a target to record the fact that it depends on some aspect of the compile time or read time environment (e.g. ‘*read-base*’) and should be considered out of date if that changes.
Previous: Classes, Up: Public Interface [Contents][Index]
Possible values for a readtable’s case mode.
Possible formats for the timestamp of a target.
Previous: Public Interface, Up: Definitions [Contents][Index]
Next: Special variables, Previous: Internals, Up: Internals [Contents][Index]
Next: Symbol macros, Previous: Constants, Up: Internals [Contents][Index]
Environment for the current build.
The database.
Is the build system frozen?
Lparallel kernel for fetching target metadata.
Is there a save pending?
Set of registered scripts.
Whether to allow parallelism.
List of special variables that should be propagated into worker threads.
Next: Macros, Previous: Special variables, Up: Internals [Contents][Index]
Next: Compiler macros, Previous: Symbol macros, Up: Internals [Contents][Index]
Like ‘cl:cond’, but require a default clause.
Like ‘cl:defclass’, but try to force slot types to be checked. Works for SBCL, at least.
Like ‘cl:defmethod’, but raise an error is NAME is not already bound as a generic function.
Like ‘cl:if’, but require two branches.
Like ‘alexandria:if-let’, but require two branches.
Like ‘var-target’, but does not actually declare a variable.
Macro wrapper for ‘call/standard-io-syntax’.
Next: Ordinary functions, Previous: Macros, Up: Internals [Contents][Index]
Next: Generic functions, Previous: Compiler macros, Up: Internals [Contents][Index]
Is X an absolute directory pathname?
Turn PATH, an absolute pathname, into a relative pathname whose
directory components are the same as the directory components of
PATH.
On Windows the suffix includes the device as a directory component.
Compute the difference between CURRENT-MAP and LAST-SAVED-MAP and
write it into LOG.
If there is no difference, write nothing.
Get the build time for TARGET from the database, but if there is no
recorded build time, fall back to using the size of FILE.
This heuristic ensures that, in the absence of other information, larger files will be built before smaller files.
Like ‘build-time-from-file’, but the size is a sum over FILES.
Call THUNK, saving the database afterwards, unless a save is already pending.
Like ‘with-standard-io-syntax’, but if there is an error, unwind the stack so the error itself can be printed.
Check that NAME is bound to a generic function.
Check that the database version matches the Overlord system version.
Nix all symbols registered as scripts.
Compute a stamp for a config.
If VALUE is simple enough to hash, return a hash.
Otherwise nil.
Copy an instance of DELAYED-SYMBOL, optionally overriding some or all of its slots.
Copy an instance of FILE-HASH, optionally overriding some or all of its slots.
Copy an instance of FILE-META, optionally overriding some or all of its slots.
Copy an instance of RESOLVED-FILE, optionally overriding some or all of its slots.
Copy an instance of TASK, optionally overriding some or all of its slots.
Copy an instance of TASK, optionally overriding some or all of its slots.
The current parent. If we are building, it is the target being built; otherwise it is the current package.
Get the current database, loading it if necessary.
Return the database’s data as an alist. For debugging.
Access KEY in the current database.
Access KEY in the current database.
Write OBJ to STREAM using the database syntax.
Resolve X as an absolute directory pathname.
When possible, Guess the number of arguments required by FORMAT-STRING.
Freeze targets.
Does SYM have earmuffs?
That is, does it begin and end with an asterisk?
Check if an object in the database has all of the supplied properties.
Load the data from LOG-FILE.
Compute the path of the log file for the current database version.
Return the size on disk of LOG-FILE.
Look for the nearest .asd file and return its name.
Implement the Longest Processing Time algorithm.
MACHINE-COUNT should be an integer.
Times should be given as integers.
Return T if TARGET needs rebuilding.
Note that this rebuilds any previously saved dependencies of TARGET
that are themselves out of date.
Like ‘map’, but possibly parallel.
Take SAVED-PREREQ, which has slots for a target and its last stamp, and return T if the stamp has changed.
Print the current directory to STREAM.
If the value of ‘*default-pathname-defaults*’ and a call to
‘uiop:getcwd’ differ, then print them both.
Access the database record keyed by OBJ and PROP.
Access the database record keyed by OBJ and PROP.
Convert OBJ and PROP into a single key.
Like ‘some’, but possibly parallel.
Save TARGET as a prerequisite of PACKAGE. Return TARGET.
Save TARGET as a prerequisite of the current PACKAGE. Return TARGET.
Rebuild TARGET if it is out of date.
Unconditionally build TARGET.
Register NAME as a script.
Reload the current version of the database from its log file.
Write DATA into DEST
Find a build script for TARGET, and depend on it. If there is no script for TARGET, signal an error.
Do some basic sanity-checking with format-control and format-arguments.
If a base has been set for PACKAGE, return it.
If a system has been set for PACKAGE, return it.
Make a saved prereq object.
Set the base and/or system, for the current package.
Set the base and/or system of PACKAGE.
Get the root directory of SHADOW-TREE.
If needed, write a compacted version of LOG-DATA into LOG-FILE.
Strip key-value pairs with tombstone values from MAP.
lock.
map.
Is TARGET actually a target (not a source file)?
Try to force delayed symbol DELAY.
If forcing was successful, return the symbol and, as a second value, T.
If forcing failed, returned nil and, as a second value, T.
If DELAY is not a delayed symbol, return it (second value T).
Look for globs in TARGETS, and replace them with the expansion of the glob, and an oracle that recomputes the expansion of the glob.
Update the stamp for NAME with VAL.
Like ‘use’, but ordered.
Depend on each target in TARGET – as a normal prereq if TARGET exists, and as a non-existent prereq if TARGET does not exist.
Call FN on each targets in TARGETS, in some order, and possibly in parallel.
Next: Standalone methods, Previous: Ordinary functions, Up: Internals [Contents][Index]
automatically generated reader method
Try to avoid writing symbols or package objects into the database. This allows the database to be reloaded without those packages being required.
Delete a key in the database.
Lookup KEY in DB.
Set the value of KEY in DB.
Sync the database to disk.
automatically generated reader method
name.
automatically generated reader method
automatically generated reader method
automatically generated reader method
automatically generated reader method
name.
automatically generated reader method
automatically generated reader method
args.
automatically generated reader method
append.
:most-specific-first
Create a lockfile for the DB.
automatically generated reader method
automatically generated reader method
base.
automatically generated reader method
Print some information about the target being built.
automatically generated reader method
Record TARGET as a prerequisite of PARENT.
automatically generated reader method
automatically generated reader method
This should be used after a token is obtained to track how many
threads are being used.
The idea is to be able to tell how many of the allocated threads are actually being used, so we know how many to allocate for the next run.
Remove the lockfile for the DB.
automatically generated reader method
Next: Conditions, Previous: Generic functions, Up: Internals [Contents][Index]
serapeum.
serapeum.
serapeum.
serapeum.
serapeum.
serapeum.
serapeum.
serapeum.
serapeum.
serapeum.
serapeum.
serapeum.
Next: Structures, Previous: Standalone methods, Up: Internals [Contents][Index]
:saved-pid
:designator
:target
This slot is read-only.
Next: Classes, Previous: Conditions, Up: Internals [Contents][Index]
The database.
structure-object.
(overlord/types:db-version)
This slot is read-only.
pathname
(overlord/db::log-file-path)
This slot is read-only.
fset:map
(fset:empty-map)
fset:map
(fset:empty-map)
The data recovered from a log file.
A single record in a log file.
%read-only-struct.
(integer 0 *)
(get-universal-time)
This slot is read-only.
fset:map
(alexandria:required-argument (quote overlord/db::data))
This slot is read-only.