Common Lisp Package: XCVB-DRIVER

README:

FUNCTION

Public

BNL (BUILD &REST KEYS &KEY XCVB-PROGRAM REQUIRED-XCVB-VERSION SETUP SOURCE-REGISTRY OUTPUT-PATH LISP-IMPLEMENTATION LISP-BINARY-PATH LISP-IMAGE-PATH FEATURES-DEFINED FEATURES-UNDEFINED DISABLE-CFASL USE-BASE-IMAGE CACHE OBJECT-CACHE WORKSPACE INSTALL-PREFIX INSTALL-PROGRAM INSTALL-CONFIGURATION INSTALL-DATA INSTALL-LIBRARY INSTALL-IMAGE INSTALL-LISP VERBOSITY DEBUGGING PROFILING)

Short hand for BUILD-AND-LOAD

BORK (CONDITION)

Depending on whether *DEBUGGING* is set, enter debugger or die

BUILD-AND-LOAD (BUILD &REST ARGS &KEY XCVB-PROGRAM REQUIRED-XCVB-VERSION SETUP SOURCE-REGISTRY OUTPUT-PATH LISP-IMPLEMENTATION LISP-BINARY-PATH LISP-IMAGE-PATH FEATURES-DEFINED FEATURES-UNDEFINED DISABLE-CFASL USE-BASE-IMAGE CACHE OBJECT-CACHE WORKSPACE INSTALL-PREFIX INSTALL-PROGRAM INSTALL-CONFIGURATION INSTALL-DATA INSTALL-LIBRARY INSTALL-IMAGE INSTALL-LISP VERBOSITY DEBUGGING PROFILING)

Entry point for users to call XCVB to build and load a system.

BUILD-IN-SLAVE (BUILD &REST ARGS &KEY (XCVB-PROGRAM *XCVB-PROGRAM*) (REQUIRED-XCVB-VERSION *REQUIRED-XCVB-VERSION*) (SETUP *XCVB-SETUP*) (SOURCE-REGISTRY *SOURCE-REGISTRY*) (OUTPUT-PATH NIL) (LISP-IMPLEMENTATION *LISP-IMPLEMENTATION-TYPE*) (LISP-BINARY-PATH *LISP-EXECUTABLE-PATHNAME*) (LISP-IMAGE-PATH *LISP-IMAGE-PATHNAME*) (FEATURES-DEFINED *FEATURES-DEFINED*) (FEATURES-UNDEFINED *FEATURES-UNDEFINED*) (DISABLE-CFASL *DISABLE-CFASLS*) (USE-BASE-IMAGE *USE-BASE-IMAGE*) (CACHE *CACHE*) (OBJECT-CACHE *OBJECT-CACHE*) (WORKSPACE *WORKSPACE*) (INSTALL-PREFIX *INSTALL-PREFIX*) (INSTALL-PROGRAM *INSTALL-PROGRAM*) (INSTALL-CONFIGURATION *INSTALL-CONFIGURATION*) (INSTALL-DATA *INSTALL-DATA*) (INSTALL-LIBRARY *INSTALL-LIBRARY*) (INSTALL-IMAGE *INSTALL-IMAGE*) (INSTALL-LISP *INSTALL-LISP*) (VERBOSITY *XCVB-VERBOSITY*) (DEBUGGING *LISP-ALLOW-DEBUGGER*) (PROFILING NIL))

Entry point to call XCVB to build (but not necessarily load) a system.

CALL (PACKAGE NAME &REST ARGS)

Call a function associated with symbol of given name in given package, with given ARGS. Useful when the call is read before the package is loaded, or when loading the package is optional.

CHDIR (X)

Change current directory, as per POSIX chdir(2)

COMMAND-LINE-ARGUMENTS (&OPTIONAL (ARGUMENTS (RAW-COMMAND-LINE-ARGUMENTS)))

Extract user arguments from command-line invocation of current process. Assume the calling conventions of an XCVB-generated script if we are not called from a directly executable image dumped by XCVB.

COPY-STREAM-TO-STREAM (INPUT OUTPUT &KEY (ELEMENT-TYPE 'CHARACTER))

Copy the contents of the INPUT stream into the OUTPUT stream, using WRITE-SEQUENCE and a sensibly sized buffer.

COPY-STREAM-TO-STREAM-LINE-BY-LINE (INPUT OUTPUT &KEY PREFIX)

Copy the contents of the INPUT stream into the OUTPUT stream, reading contents line by line.

DEBUGGING (&OPTIONAL (DEBUG T))

Enable (or with NIL argument, disable) verbose debugging output from XCVB

DIE (FORMAT &REST ARGUMENTS)

Die in error with some error message

EMPTYP (X)

Predicate that is true for an empty sequence

ESCAPE-COMMAND (COMMAND &OPTIONAL S (ESCAPER 'ESCAPE-SHELL-TOKEN))

Given a COMMAND as a list of tokens, return a string of the spaced, escaped tokens, using ESCAPER to escape.

ESCAPE-SH-COMMAND (COMMAND &OPTIONAL S)

Escape a list of command-line arguments into a string suitable for parsing by /bin/sh in POSIX

ESCAPE-SH-TOKEN (TOKEN &OPTIONAL S)

Escape a string TOKEN within double-quotes if needed for use within a POSIX Bourne shell, outputing to S.

ESCAPE-TOKEN (TOKEN &KEY STREAM QUOTE GOOD-CHARS BAD-CHARS ESCAPER)

Call the ESCAPER function on TOKEN string if it needs escaping as per REQUIRES-ESCAPING-P using GOOD-CHARS and BAD-CHARS, otherwise output TOKEN, using STREAM as output (or returning result as a string if NIL)

ESCAPE-WINDOWS-COMMAND (COMMAND &OPTIONAL S)

Escape a list of command-line arguments into a string suitable for parsing by CommandLineToArgv in MS Windows

ESCAPE-WINDOWS-TOKEN (TOKEN &OPTIONAL S)

Escape a string TOKEN within double-quotes if needed for use within a MS Windows command-line, outputing to S.

EVAL-STRING (STRING)

Evaluate a form read from a string

FATAL-CONDITION-P (CONDITION)

match CONDITION against any of the patterns of *FATAL-CONDITIONS*

FIND-SYMBOL* (NAME PACKAGE-NAME &OPTIONAL (ERROR T))

Find a symbol in a package of given string'ified NAME; unless CL:FIND-SYMBOL, work well with 'modern' case sensitive syntax by letting you supply a symbol or keyword for the name; also works well when the package is not present. If optional ERROR argument is NIL, return NIL instead of an error when the symbol is not found.

FINISH-OUTPUTS

Finish output on the main output streams. Useful for portably flushing I/O before user input or program exit.

FORMAT! (STREAM FORMAT &REST ARGS)

Just like format, but call finish-outputs before and after the output.

GETCWD

Get the current working directory as per POSIX getcwd(3)

GETENV (X)

Query the libc runtime environment. See getenv(3).

GETENVP (X)

Predicate that is true if the named variable is present in the libc environment, then returning the non-empty string value of the variable

LOAD-STREAM (&OPTIONAL (STREAM *STANDARD-INPUT*))

Portably read and evaluate forms from a STREAM.

LOAD-STRING (STRING)

Portably read and evaluate forms from a STRING.

NATIVE-NAMESTRING (X)

From a CL pathname, a namestring suitable for use by the OS shell

PARSE-NATIVE-NAMESTRING (X)

From a native namestring suitable for use by the OS shell, a CL pathname

PROCLAIM-OPTIMIZATION-SETTINGS

Proclaim the optimization settings in *OPTIMIZATION-SETTINGS*

QUIT (&OPTIONAL (CODE 0) (FINISH-OUTPUT T))

Quits from the Lisp world, with the given exit status if provided. This is designed to abstract away the implementation specific quit forms.

RAW-COMMAND-LINE-ARGUMENTS

Find what the actual command line for this process was.

READ-FIRST-FILE-FORM (PATHNAME &KEY (PACKAGE CL) EOF-ERROR-P EOF-VALUE)

Reads the first form from the top of a file

READ-FUNCTION (STRING)

Read a form from a string in function context, return a function

RUN-PROGRAM/ (COMMAND &REST KEYS &KEY OUTPUT IGNORE-ERROR-STATUS FORCE-SHELL (ELEMENT-TYPE *DEFAULT-ELEMENT-TYPE*) (EXTERNAL-FORMAT DEFAULT) &ALLOW-OTHER-KEYS)

Run program specified by COMMAND, either a list of strings specifying a program and list of arguments, or a string specifying a shell command (/bin/sh on Unix, CMD.EXE on Windows); have its output processed by the OUTPUT processor function as per SLURP-INPUT-STREAM, or merely output to the inherited standard output if it's NIL. Always call a shell (rather than directly execute the command) if FORCE-SHELL is specified. Issue an error if the process wasn't successful unless IGNORE-ERROR-STATUS is specified. Return the exit status code of the process that was called. Use ELEMENT-TYPE and EXTERNAL-FORMAT for the stream passed to the OUTPUT processor.

SETUP-ENVIRONMENT

Setup the XCVB environment with respect to debugging, profiling, performance

SHELL-BOOLEAN (X)

Quit with a return code that is 0 iff argument X is true

SLURP-FILE-FORMS (FILE &REST KEYS)

Open FILE with option KEYS, read its contents as a list of forms

SLURP-FILE-LINES (FILE &REST KEYS)

Open FILE with option KEYS, read its contents as a list of lines

SLURP-FILE-STRING (FILE &REST KEYS)

Open FILE with option KEYS, read its contents as a string

SLURP-STREAM-FORMS (INPUT)

Read the contents of the INPUT stream as a list of forms

SLURP-STREAM-LINES (INPUT)

Read the contents of the INPUT stream as a list of lines

SLURP-STREAM-STRING (INPUT &KEY (ELEMENT-TYPE 'CHARACTER))

Read the contents of the INPUT stream as a string

UNINTERESTING-CONDITION-P (CONDITION)

match CONDITION against any of the patterns of *UNINTERESTING-CONDITIONS*

Undocumented

DUMP-IMAGE (FILENAME &KEY OUTPUT-NAME EXECUTABLE PRE-IMAGE-DUMP POST-IMAGE-RESTART ENTRY-POINT PACKAGE)

EASY-SH-CHARACTER-P (X)

LOAD-FULLNAME-MAPPINGS (FILE)

REGISTER-FULLNAME (&KEY FULLNAME PATHNAME TTHSUM LOGICAL-PATHNAME)

REGISTER-FULLNAMES (MAPPINGS &KEY (DEFAULTS *LOAD-TRUENAME*))

REGISTERED-FULLNAME-PATHNAME (FULLNAME)

RESUME

RUN-PROGRAM/ECHO-OUTPUT (COMMAND &REST KEYS &KEY PREFIX (STREAM T) &ALLOW-OTHER-KEYS)

Private

ASDF-SYSTEM-NEEDS-COMPILATION-P (SYSTEM)

Takes a name of an asdf system (or the system itself) and a asdf operation and returns a boolean indicating whether or not anything needs to be done in order to perform the given operation on the given system. This returns whether or not the operation has already been performed, and none of the source files in the system have changed since then

ASDF-SYSTEMS-UP-TO-DATE (&REST SYSTEMS)

Are all the loaded systems up to date?

ASDF-SYSTEMS-UP-TO-DATE-P (SYSTEMS)

Takes a list of names of asdf systems, and exits lisp with a status code indicating whether or not all of those systems were up-to-date or not.

CALL-WITH-INPUT-FILE (PATHNAME THUNK &KEY (ELEMENT-TYPE *DEFAULT-ELEMENT-TYPE*) (EXTERNAL-FORMAT DEFAULT))

Open FILE for input with given options, call THUNK with the resulting stream.

ESCAPE-SH-TOKEN-WITHIN-DOUBLE-QUOTES (X S &KEY 'T)

Escape a string TOKEN within double-quotes for use within a POSIX Bourne shell, outputing to S; omit the outer double-quotes if key argument :QUOTE is NIL

ESCAPE-SHELL-COMMAND (COMMAND &OPTIONAL STREAM)

Escape a command for the current operating system's shell

ESCAPE-WINDOWS-TOKEN-WITHIN-DOUBLE-QUOTES (X &OPTIONAL S)

Escape a string token X within double-quotes for use within a MS Windows command-line, outputing to S.

GET-OPTIMIZATION-SETTINGS

Get current compiler optimization settings, ready to PROCLAIM again

MATCH-ANY-CONDITION-P (CONDITION CONDITIONS)

match CONDITION against any of the patterns of CONDITIONS supplied

MATCH-CONDITION-P (X CONDITION)

Compare received CONDITION to some pattern X: a symbol naming a condition class, a simple vector of length 2, arguments to find-symbol* with result as above, or a string describing the format-control of a simple-condition.

PATHNAME-DIRECTORY-PATHNAME (PATHNAME)

Pathname for the directory containing given PATHNAME

REQUIRES-ESCAPING-P (TOKEN &KEY GOOD-CHARS BAD-CHARS)

Does this token require escaping, given the specification of either good chars that don't need escaping or bad chars that do need escaping, as either a recognizing function or a sequence of characters.

RUN-COMMAND (COMMAND)

Run a single command. Entry point for XCVB-DRIVER when used by XCVB's farmer

SAVE-FORWARD-REFERENCES (FORWARD-REFERENCES)

Save forward reference conditions so they may be issued at a latter time, possibly in a different process.

STRING-ENCLOSED-P (PREFIX STRING SUFFIX)

Does STRING begin with PREFIX and end with SUFFIX?

STRING-PREFIX-P (PREFIX STRING)

Does STRING begin with PREFIX?

STRING-SUFFIX-P (STRING SUFFIX)

Does STRING end with SUFFIX?

TWEAK-IMPLEMENTATION

Common performance tweaks for various CL implementations.

Undocumented

ASDF-SYMBOL (X)

BUILD-SLAVE-COMMAND-LINE (BUILD &KEY (XCVB-PROGRAM *XCVB-PROGRAM*) (REQUIRED-XCVB-VERSION *REQUIRED-XCVB-VERSION*) (SETUP *XCVB-SETUP*) (SOURCE-REGISTRY *SOURCE-REGISTRY*) (OUTPUT-PATH NIL) (LISP-IMPLEMENTATION *LISP-IMPLEMENTATION-TYPE*) (LISP-BINARY-PATH *LISP-EXECUTABLE-PATHNAME*) (LISP-IMAGE-PATH *LISP-IMAGE-PATHNAME*) (FEATURES-DEFINED *FEATURES-DEFINED*) (FEATURES-UNDEFINED *FEATURES-UNDEFINED*) (DISABLE-CFASL *DISABLE-CFASLS*) (USE-BASE-IMAGE *USE-BASE-IMAGE*) (CACHE *CACHE*) (OBJECT-CACHE *OBJECT-CACHE*) (WORKSPACE *WORKSPACE*) (INSTALL-PREFIX *INSTALL-PREFIX*) (INSTALL-PROGRAM *INSTALL-PROGRAM*) (INSTALL-CONFIGURATION *INSTALL-CONFIGURATION*) (INSTALL-DATA *INSTALL-DATA*) (INSTALL-LIBRARY *INSTALL-LIBRARY*) (INSTALL-IMAGE *INSTALL-IMAGE*) (INSTALL-LISP *INSTALL-LISP*) (VERBOSITY *XCVB-VERBOSITY*) (DEBUGGING *LISP-ALLOW-DEBUGGER*) (PROFILING NIL))

CALL-WITH-CODED-EXIT (THUNK)

CALL-WITH-CONTROLLED-COMPILER-CONDITIONS (THUNK)

CALL-WITH-CONTROLLED-LOADER-CONDITIONS (THUNK)

CALL-WITH-CURRENT-DIRECTORY (DIR THUNK)

CALL-WITH-DETERMINISM (SEED THUNK)

CALL-WITH-MAYBE-PROFILING (THUNK WHAT GOAL)

CALL-WITH-SAFE-IO-SYNTAX (THUNK &KEY (PACKAGE CL))

CALL-WITH-TEMPORARY-FILE (THUNK &KEY PREFIX KEEP (DIRECTION IO) (ELEMENT-TYPE *DEFAULT-ELEMENT-TYPE*) (EXTERNAL-FORMAT DEFAULT))

CALL-WITH-XCVB-COMPILATION-UNIT (THUNK &KEY FORWARD-REFERENCES)

CL-REQUIRE (X)

COMPILE-LISP (SPEC &REST DEPENDENCIES)

CREATE-IMAGE (SPEC &REST DEPENDENCIES)

CREATE-XCVB-PROGRAM (&OPTIONAL (PROGRAM *XCVB-PROGRAM*))

DEFAULT-TEMPORARY-DIRECTORY

DEFAULT-XCVB-PROGRAM

DETECT-OS

DO-COMPILE-LISP (DEPENDENCIES SOURCE FASL &KEY CFASL AROUND-COMPILE ENCODING)

DO-CREATE-IMAGE (IMAGE DEPENDENCIES &REST FLAGS)

DO-LOAD (X &KEY ENCODING)

DO-RESUME (&KEY (POST-IMAGE-RESTART *POST-IMAGE-RESTART*) (ENTRY-POINT *ENTRY-POINT*))

DO-RUN (COMMANDS)

ENCODING-EXTERNAL-FORMAT (ENCODING)

ENSURE-XCVB-PRESENT (&OPTIONAL (PROGRAM *XCVB-PROGRAM*))

ESCAPE-SHELL-TOKEN (TOKEN &OPTIONAL S)

FEATUREP (X &OPTIONAL (*FEATURES* *FEATURES*))

FUNCTION-FOR-COMMAND (DESIGNATOR)

INITIALIZE-ASDF

INITIALIZE-MANIFEST (PATHNAME)

LOAD-ASDF (X &KEY PARALLEL (VERBOSE *COMPILE-VERBOSE*))

LOAD-FILE (X &KEY ENCODING)

LOAD-MANIFEST (PATHNAME)

OS-UNIX-P

OS-WINDOWS-P

OUTPUT-STRING (STRING &OPTIONAL STREAM)

PROCESS-CFFI-GROVEL-FILE (INPUT C EXE OUTPUT &KEY CC-FLAGS)

PROCESS-CFFI-WRAPPER-FILE (INPUT C SO OUTPUT &KEY CC-FLAGS)

PROCESS-MANIFEST (MANIFEST)

PROCESS-MANIFEST-ENTRY (&REST ENTRY &KEY COMMAND PATHNAME TTHSUM ENCODING &ALLOW-OTHER-KEYS)

REGISTER-ASDF-DIRECTORY (X)

REQUIRE-ASDF

REQUIRE-XCVB

RUN-COMMANDS (COMMANDS)

RUN-XCVB-COMMAND (PROGRAM COMMAND)

SEED-RANDOM-STATE (SEED)

XCVB-PRESENT-P (&OPTIONAL (PROGRAM *XCVB-PROGRAM*))

MACRO

Public

WITH-CODED-EXIT ((&OPTIONAL) &BODY BODY)

Run BODY, BORKing on error and otherwise exiting with a success status

WITH-CONTROLLED-COMPILER-CONDITIONS ((&OPTIONAL) &BODY BODY)

Run BODY while suppressing conditions patterned after *UNINTERESTING-CONDITIONS*

WITH-CONTROLLED-LOADER-CONDITIONS ((&OPTIONAL) &BODY BODY)

Run BODY while suppressing conditions patterned after *UNINTERESTING-CONDITIONS* plus a few others that don't matter at load-time.

WITH-CURRENT-DIRECTORY ((DIR) &BODY BODY)

Call BODY while the POSIX current working directory is set to DIR

WITH-OUTPUT ((X &OPTIONAL (VALUE X)) &BODY BODY)

Bind X to an output stream, coercing VALUE (default: previous binding of X) as per FORMAT, and evaluate BODY within the scope of this binding.

WITH-PROFILING (WHAT &BODY BODY)

Macro to run a BODY of code, and profile it under some profiling name when *PROFILING* is enabled.

WITH-SAFE-IO-SYNTAX ((&KEY (PACKAGE CL)) &BODY BODY)

Establish safe CL reader options around the evaluation of BODY

WITH-TEMPORARY-FILE ((&KEY (STREAM (GENSYM STREAM) STREAMP) (PATHNAME (GENSYM PATHNAME) PATHNAMEP) PREFIX KEEP DIRECTION ELEMENT-TYPE EXTERNAL-FORMAT) &BODY BODY)

Evaluate BODY where the symbols specified by keyword arguments STREAM and PATHNAME are bound corresponding to a newly created temporary file ready for I/O. Unless KEEP is specified, delete the file afterwards.

WITH-XCVB-COMPILATION-UNIT ((&KEY FORWARD-REFERENCES) &BODY BODY)

Like WITH-COMPILATION-UNIT, but saving forward-reference issues for processing later (possibly in a different process).

Undocumented

RUN-PROGRAM/FOR-SIDE-EFFECTS (COMMAND &REST KEYS)

RUN-PROGRAM/PROCESS-OUTPUT-STREAM (COMMAND OUTPUT-PROCESSOR &REST KEYS)

RUN-PROGRAM/READ-OUTPUT-FORM (COMMAND &REST KEYS)

RUN-PROGRAM/READ-OUTPUT-FORMS (COMMAND &REST KEYS)

RUN-PROGRAM/READ-OUTPUT-LINES (COMMAND &REST KEYS)

RUN-PROGRAM/READ-OUTPUT-STRING (COMMAND &REST KEYS)

WITH-INPUT-FILE ((VAR PATHNAME &REST KEYS &KEY ELEMENT-TYPE EXTERNAL-FORMAT) &BODY BODY)

Private

RUN (&REST COMMANDS)

Run a series of XCVB-DRIVER commands, then exit. Entry point for XCVB-DRIVER when used by XCVB

WITH-DETERMINISM (GOAL &BODY BODY)

Attempt to recreate deterministic conditions for the building a component.

GENERIC-FUNCTION

Public

Undocumented

SLURP-INPUT-STREAM (PROCESSOR INPUT-STREAM &KEY (ELEMENT-TYPE 'CHARACTER) &ALLOW-OTHER-KEYS)

SUBPROCESS-ERROR-CODE (CONDITION)

SUBPROCESS-ERROR-COMMAND (CONDITION)

SUBPROCESS-ERROR-PROCESS (CONDITION)

Private

CALL-WITH-OUTPUT (X THUNK)

Calls FUN with an actual stream argument, behaving like FORMAT with respect to stream'ing: If OBJ is a stream, use it as the stream. If OBJ is NIL, use a STRING-OUTPUT-STREAM as the stream, and return the resulting string. If OBJ is T, use *STANDARD-OUTPUT* as the stream. If OBJ is a string with a fill-pointer, use it as a string-output-stream. Otherwise, signal an error.

VARIABLE

Public

*ARGUMENTS*

Command-line arguments

*CACHE*

where to store object files, etc. NIL: default to $XDG_CACHE_HOME/xcvb/ or $HOME/.cache/xcvb/, see docs

*DEBUGGING*

boolean: should we enter the debugger on failure?

*DEFAULT-ELEMENT-TYPE*

default element-type for open (depends on the current CL implementation)

*DEFERRED-WARNINGS*

Warnings the handling of which is deferred until the end of the compilation unit

*DISABLE-CFASLS*

Should we disable CFASL support when the target Lisp has it?

*DUMPED*

Is this a dumped image? As a standalone executable?

*ENTRY-POINT*

a function with which to restart the dumped image when execution is resumed from it.

*FATAL-CONDITIONS*

Conditions to be considered fatal during compilation.

*FEATURES-DEFINED*

What additional features to define in the target image

*FEATURES-UNDEFINED*

What additional features to undefine in the target image

*GOAL*

what is the name of the goal toward which we execute commands?

*INSTALL-CONFIGURATION*

where to install configuration files. NIL: default to *install-prefix*/etc, see docs

*INSTALL-DATA*

where to install shared (architecture-independent) data files. NIL: default to *install-prefix*/share, see docs

*INSTALL-IMAGE*

where to install common-lisp image (architecture- and implementation- dependent) files. NIL: default to *install-library*/common-lisp/images/, see docs

*INSTALL-LIBRARY*

where to install library (architecture-dependent) files. NIL: default to *install-prefix*/lib, see docs

*INSTALL-LISP*

where to install common-lisp source code and systems, etc. NIL: default to *install-data*/common-lisp/, see docs

*INSTALL-PREFIX*

where to install files. NIL: default to /usr/local/, see docs "/": default to /, with special defaults for other paths. T: use home directory with special defaults for other paths below.

*INSTALL-PROGRAM*

where to install program 'binary' (executable) files. NIL: default to *install-prefix*/bin, see docs

*LISP-ALLOW-DEBUGGER*

Should we allow interactive debugging of failed build attempts?

*LISP-EXECUTABLE-PATHNAME*

Path to the Lisp implementation to use for the target system. NIL, or a string. Default: what's in your PATH.

*LISP-FLAGS*

What options do we need invoke the target Lisp with? A list of strings, or the keyword :DEFAULT.

*LISP-IMAGE-PATHNAME*

What path to a Lisp image do we need invoke the target Lisp with? Default: whatever's the default for your implementation.

*LISP-IMPLEMENTATION-DIRECTORY*

Where is the home directory for the Lisp implementation, in case we need it to (require ...) special features? Default: whatever's the default for your implementation.

*LISP-IMPLEMENTATION-TYPE*

Type of Lisp implementation for the target system. A keyword. Default: same as XCVB itself.

*MANIFEST*

an alist of the XCVB load commands executed in this image, with associated pathnames and tthsums.

*OBJECT-CACHE*

Path to the object cache. NIL: default to *cache*/*implementation-identifier*/, see docs

*POST-IMAGE-RESTART*

a string containing forms to read and evaluate when the image is restarted, but before the entry point is called.

*PROFILING*

boolean: should we compute and display the time spend in each command?

*REQUIRED-XCVB-VERSION*

Minimal version of XCVB required for use with this version of the xcvb-driver

*SOURCE-REGISTRY*

CL source registry specification. A sexp or string. Will override the shell variable CL_SOURCE_REGISTRY when calling slaves.

*STDERR*

the original error output stream at startup

*TEMPORARY-DIRECTORY*

pathname of directory where to store temporary files

*UNINTERESTING-CONDITIONS*

Conditions that may be skipped. type symbols, predicates or strings

*UNINTERESTING-LOAD-CONDITIONS*

Additional conditions that may be skipped while loading. type symbols, predicates or strings

*USE-BASE-IMAGE*

Should we be using a base image for all builds?

*WORKSPACE*

where to store test and intermediate files private to current run NIL: default to <current-directory>/workspace/, see docs

*XCVB-PROGRAM*

Path to the XCVB binary (a string), OR t if you want to use an in-image XCVB

*XCVB-VERBOSITY*

Level of verbosity of XCVB: 0 - silent except for emergency 5 - usual warnings 9 - plenty of debug info

Undocumented

*OPTIMIZATION-SETTINGS*

+XCVB-SLAVE-FAREWELL+

+XCVB-SLAVE-GREETING+

Private

*INITIAL-RANDOM-STATE*

initial random state to preserve determinism

*PATHNAME-MAPPINGS*

Mappings from xcvb fullname to plist of (physical) :pathname, :logical-pathname, :tthsum digest, etc.

*UTF-8-EXTERNAL-FORMAT*

Default :external-format argument to pass to CL:OPEN and also CL:LOAD or CL:COMPILE-FILE to best process a UTF-8 encoded file. On modern implementations, this will decode UTF-8 code points as CL characters. On legacy implementations, it may fall back on some 8-bit encoding, with non-ASCII code points being read as several CL characters; hopefully, if done consistently, that won't affect program behavior too much.

*XCVB-SETUP*

Lisp file to load to setup the target build system, if any

Undocumented

*ASDF-VERSION-REQUIRED-FOR-XCVB*

*BNL-KEYS*

*BNL-KEYS-WITH-DEFAULTS*

*IMPLEMENTATION-SETTINGS*

*PREVIOUS-OPTIMIZATION-SETTINGS*

*XCVB-PRESENT*

CONDITION

Public

Undocumented

SUBPROCESS-ERROR