The asdf-dependency-grovel Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The asdf-dependency-grovel Reference Manual

This is the asdf-dependency-grovel Reference Manual, version 1.108, generated automatically by Declt version 2.3 "Robert April" on Wed Mar 14 02:54:58 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

Basic Overview
==============

First, I'll give a brief overview of how asdf-dependency-grovel (ADG) works, so
that you'll be better able to understand the nitty-gritty details that come
later.


Constituents
------------

A "constituent" represents a piece of the codebase.  Constituents are arranged
into a tree, with the children of a constituent representing disjoint pieces of
their parent constituent.  The constituent objects are used to store
information about dependencies between different parts of the codebase.

ADG's constituent system is designed to be quite flexible at representing
different shapes and sizes of codebases, but in most cases (including QPX), the
constituent tree will have exactly three levels.  At the top, there is a single
root constituent that represents the whole codebase.  The root constituent has
as children one constituent for each file in the codebase -- these are called
"file-constituents".  Each file-constituent has as children one constituent for
each top-level form in the file -- these are called "form-constituents".  The
goal of ADG is to determine the dependencies between the various
form-constituents, which allows it not only to infer dependencies between
files, but also to determine how the top-level forms could be reorganized
between files so has to eliminate file-level dependency cycles.


Provisions and Uses
-------------------

ADG detects dependencies through the use of the `signal-provider' and
`signal-user' functions.  When a form "provides" something -- for example, a
defun form provides the function being defined -- then ADG will call the
signal-provider function with the name of the thing being provided (as a
symbol) and a symbol indicating what kind of thing was provided.  This will
cause that "provision" -- that is, the name/kind pair -- to be added to the
current constituent's set of provisions.  Similarly, when a form "uses"
something (at compile time), ADG will call the signal-user function with the
name and kind of the thing used, which adds the use to the current
constituent's list of uses.  In general, if constituent A provides X and
constituent B uses X, then we conclude that B depends on A.  This is ADG's
fundamental mechanism for determining dependencies.

This approach is relatively easy to implement, and usually works, but it is
also flawed.  Suppose that we have three forms: A, B, and C.  Forms A and B are
both (defconstant +sqrt2+ 1.41), and form C is (defvar *foo* +sqrt2+).  ADG
will call (signal-provider '+sqrt2+ 'defconstant) for each of forms A and B,
and will call (signal-user '+sqrt2+ 'defconstant) for form C (as well as
calling (signal-provider '*foo* 'defvar)).  ADG will then conclude that form C
depends on _both_ A and B, when in reality, Common Lisp allows it to depend on
_either_ of A or B, since defconstants may be repeated as long as they all have
the same value for the constant.  ADG simply doesn't try to handle this case
correctly, largely because doing so would complicate some of the later stages
with relatively little benefit.

Finally, it should be noted that ADG detects provisions and uses heuristically,
and as a result, will frequently have both false negatives and false positives
when detecting dependencies (we'll see later on why this is, sadly,
unavoidable).  The main trick to making ADG work is to balance these so that
the wrong answer it comes up with is still good enough to successfully
eliminate the dependency cycles in the particular codebase of interest.


Cycle Resolution
----------------

Once ADG has collected all the provisions and uses for each constituent, it
builds a directed graph with form-constituents as nodes and dependencies as
edges.  We will assume that the resulting graph will be acyclic, which should
be true if the code was able to compile and if the dependency detection didn't
have too many false positives.

The goal in this stage is to eliminate dependency cycles between files.  We
could do this by splitting _every_ form into its own file, but that would
create a huge mess.  Or, we could merge everything into one file, but that is a
similarly degenerate solution.  Or, we could drastically rearrange the code,
but that too would be confusing to the poor humans to organized these forms
into each of these files for a reason.  The compromise the ADG takes is to only
ever split existing files into pieces (not to merge anything), and try to make
as few splits as possible.

To do this, ADG starts with the graph of form-constituents, and treats each
form-constituent as though it were a separate file; it then merges together
pairs of nodes into supernodes as much as possible, subject to the constraints
that 1) it may only merge nodes that originally came from the same file, and 2)
it must never perform merges that would introduce a cycle into the graph.  As
it turns out, perfectly minimizing the number of nodes in the final graph is
NP-hard, so ADG uses a greedy algorithm that seems to make for a reasonable
approximation.

Once ADG has finished merging the graph, it sorts the nodes in that graph
topologically to create a new file order.  In order to protect against false
negatives in the dependency detection, ADG uses a _stable_ topological sort,
keeping the files as close to the original file order as possible (thus, if
file B depends on file A and ADG didn't notice, there's still a good chance
that file B won't load until after file A in the new file order).


File Splitting
--------------

Once ADG has determined how to split the files and what order to put the new
files in, we can run its output through a program that will automatically
divide up the actually files.  Here we have to deal with one hitch -- ADG
doesn't really understand the significance of in-package forms, and will treat
them just as any other form, to be put one one piece or another of a split
file.  To deal with this, the program that actually splits up the files will
check for pieces of files that don't have the in-package declaration; for each
such piece, it will check the _original_ file to see if it has only a single
in-package form, and if so, it will copy that form to the top of the split
piece.  If the file has multiple in-package forms (an unusal case), then the
program simply prints a warning, indicating that a human should do it manually.
Fortunately, there are usually no such warnings.




How it _Really_ Works
=====================

Now that you have a basic idea of what ADG does, let's take a look at the nasty
details of how it detects provisions and uses.  Beware -- this will be an
adventuresome journey into just how annoying Common Lisp can be as a language.


Fine-Grain Instrumented Load
----------------------------

The first piece of trickery is how ADG can keep track of which top-level form
in the file it is working with, so that it can instantiate the constituents
correctly.  ADG provides a drop-in replacement for the load function called
fine-grain-instrumented-load that does this.  Intuitively, this simply needs to
pass the file through the Lisp reader to get a list of forms, and then eval
each form in a new form-constituent.  However, the Common Lisp spec requires a
variety of particular, subtle behaviors from the load function, which makes it
much more difficult to provide a portable, drop-in replacement.  Thus, ADG
simply uses a modified copy of the load function from the SBCL source code.
That makes it unportable, but oh, well.  The replacement load function
instantiates a new form-constituent for each top-level form, and also
preprocesses each form before eval-ing it (this step is described in later
sections).  Finally, the replacement load function keeps track of some
anciliary data, such as the index of the form in the file (e.g. 1st form, 2nd
form, etc.), which serves to uniquely identify the form, and the position of
the form in the file as an index into the character stream, which aids in the
automatic file splitting later on.


The Macroexpand-Hook and Handlers
---------------------------------

The primary mechanism that ADG uses to find dependencies is a custom
*macroexpand-hook*.  This is a function that Common Lisp will call whenever it
is about to expand a macro; this gives ADG an opportunity to examine the macro
form, or even to alter it.

In general, when the code expands a macro foo, ADG calls (signal-user 'foo
'defmacro) to indicate that a macro is being used.  However, ADG also has a
number of "handlers" which it uses to give special treatment to a number of
standard Common Lisp macros.  For example, defmacro is itself a macro, and when
ADG's macroexpand-hook sees a defmacro of a macro foo, it calls
(signal-provider 'foo 'defmacro).  When ADG sees a defun macro for a function
foo, it calls (signal-provider 'foo 'defun) and also alters the function
definition to include a call to (signal-user 'foo 'defun), so that if the
function is called at compile time, it will signal a use of the function.  When
ADG sees a defstruct macro, it does all kinds of squirrelly things, because
defstruct is a horrible mess; among the things it does is to insert code after
the defstruct to "retroactively" instrument the accessor functions that are
automatically generated by the defstruct macro.  There are a wide variety of
other handlers defined in ADG, and more can be easily added if necessary.

It should be noted that it is largely a fortunate coincidence that many of the
things that we are interested in (e.g. defmacro, defun, defvar, etc.) happen to
be defined as macros in Common Lisp, and can thus be caught by the
macroexpand-hook.  There are other things we might be interested in, such as
eval-when, that are defined as special forms; we have no easy way to detect
these without walking the code "manually".  (Incidentally, _Common Lisp: The
Language_, second edition, describes a facility called *evalhook* that allows a
user-defined function to be called on _every_ subform as it is evaluated.  Such
a facility would be extremely useful for ADG.  Unfortunately, that facility is
no longer part of the Common Lisp spec, and is not supported by SBCL.)


Detecting Variable Uses
-----------------------

It is generally easy for ADG to detect when global variables (or constants) are
provided, as the macroexpand-hook will notice defvar and defparameter (and
defconstant) forms (ADG treats defvar and defparameter as essentially
equivalent for the purposes of dependency detection -- when it sees a
defparameter form, it signals a provision of kind defvar).  What is harder is
to detect when a global variable or constant is being used at compile time.

The trouble is that there are a lot of different ways to "use" a global
variable at compile time.  You could read the variable and use its value at
compile time.  You could alter the value of the variable at compile time with
setf or setq.  You could dynamically rebind the variable at compile time with
let.  You could even quote the variable name and pass it to a function like
boundp or constantp, at compile time.  And yes, QPX does all of the above.

There are several clever strategies that don't work.  One is to instrument
defvars so that the variable name is actually symbol-macro that expands to some
code that signals a use of the variable and then returns the value.  You can
even write a setf function so that setf will work with such macros.
Unfortunately, this doesn't work with let forms or quoted symbols, since those
are not subject to symbol-macroexpansion.  Another neat idea would be to use
some kind of alternative environment object that could somehow detect when
global variables (or other things!) are being used.  However, there is
explicitly no portable way to do this, and I can't even find a non-portable way
to do it in SBCL.

In the end, what ADG actually does is incredibly stupid.  When it sees a
defvar, not only does it signal a provision, but it adds the symbol to a set
called *suspected-variables*.  Before evaluating each form, ADG performs a
preprocessing step that, among other things (see later sections), walks all the
symbols in the form, looking for ones that are in *suspected-variables*; if it
finds any, then it assumes that that is a use of the variable, and makes an
appropriate call to signal-user.  Of course, this results in a number of false
positives, since many of those appearances will not be relevant at compile
time.  However, amazingly, it seems to be good enough.


The Readtable and Constituent Transfers
---------------------------------------

This is where things start to get a little more hairy.

QPX contains a large number of sharpdot (#.) forms.  These indicate a form that
is to be evaluated at read-time, and the result to be inserted into the code in
place of the sharpdot form.  Of course, these sharpdot forms may well make use
of functions defined in other files, in which case there is a dependency
between the top-level form containing the sharpdot and the top-level form that
provided the function (or whatever) that the sharpdot form used -- in
particular, we must ensure that when we split up and reorder the files, the
file in which the providing form ends up must come before the file in which the
sharpdot ends up.

The trouble is that the evaluation happens while the file is being read, which
is before ADG is able to break the file up into top-level forms and set the
*current-constituent* variable to each form-constituent in turn.  Thus, if the
evaluation of the sharpdot invokes any signal-user calls, the use will not be
added to the correct constituent.

ADG solves this by using a modified *readtable* with a replacement sharpdot
reader macro function (as well as other replacement reader macros -- more on
that later).  The new sharpdot sets the *current-constituent* variable to a
newly instantiated "temp-constituent" object -- a constituent that has no
parent -- before evaluating the form.  Thus, this temp-constituent will catch
any use (or provision) signals caused by the evaluation of the sharpdot form.
Then, the replacement sharpdot function must return a piece of data containing
both the result of the evaluation (which should be inserted into the code) as
well as the temp-constituent object.  When we get around to evaluating the
top-level form in which the sharpdot appeared, we will "transfer" the signals
from the temp-constituent to the new *current-constituent*, so that the form in
which the sharpdot appears will have the proper dependencies.

Now, what should the sharpdot function return to allow us to make this
transfer?  An obvious answer is to have it return a macro call that, when it
expands, performs the transfer and the returns the result value.  Thus, the
sharpdot reader macro function would return something like
`(with-transfer-constituent ,temp-constituent ,result).  Since macroexpansion
won't happen until we evaluate the top-level form in question, and thus when we
have the proper *current-constituent* in place, this seems workable.  The
trouble is that sharpdots may appear in places that are not subject to
macroexpansion.  Instead, we will have the sharpdot reader macro function
return the with-transfer-constituent list as before, but we will perform our
own macroexpansion-like operation during the form preprocessing step described
in the previous section that deals with appearances of
with-transfer-constituent anywhere in the form.

Walking a form and replacing with-transfer-constituent lists is actually much
trickier than it sounds, because there are a number of edge cases.  For
example, one might think that when walking a subform that is a list, one could
simply check each item of the list to see if the item is a list beginning with
the symbol 'with-transfer-constituent.  Not so.  Someone might write something
like (progn . #.(loop ...)), in which case the 'with-transfer-constituent
symbol will appear as the second item in a list.  Yes, that code is legal Lisp.
Yes, QPX does that.  A lot.

All told, this strategy for dealing with sharpdots works pretty well, but it
opens up a can of worms -- there are a handful of very nasty, very subtle
issues that I won't go into here (but that are documented in the code).
Suffice to say that these issues are largely the result of certain parts of
Common Lisp, particularly backquotes and compiler macros, being underspecified
in perilous ways.


Manual Annotations
------------------

Despite all the heuristics ADG uses to try to find dependencies, sometimes you
have to give it some hints.  This is a slightly dicey game, and requires some
familiary with ADG to know how to make it work, but when carefully done it can
help tremendously.

One all too common case is to have a global variable that is a hash table, and
have one file that populates the hash table at compile time, and another file
that requires the hash table to be populated in order to compile.  There's not
really any way for ADG to understand this dependency, but it's usually easy to
annotate manually: the function that adds an entry to the table can make a call
to signal-provider with some appropriate tag, and the function that expects the
entry to be there can call signal-user.  ADG adds the symbol :groveling to
*featuresa* when it's running, so you can use code like

  #+groveling(asdf-dependency-grovel:signal-user foo-key 'foo-table-entry)

to ensure that the codebase won't be affected when you're not using ADG.

Another possible problem is when there are two adjacent forms that should be
kept together, but ADG fails to understand this and happens to try to split
them into separate files.  One example from QPX is code that looks like:

  (defvar *foo*)
  (with-build-version :foobar-3
    (setf *foo* (make-hash-table)))

These are two separate top-level forms, but splitting them up can cause
breakage, and ADG is easily confused by defvar dependencies.  A simple solution
is to simply wrap these two forms into a progn, thus making them a single
top-level form and preventing ADG from splitting them:

  (progn
    (defvar *foo*)
    (with-build-version :foobar-3
      (setf *foo* (make-hash-table))))




How to Use ADG
==============

*** more here ***



--------------------------------------------------------------------------------

First, let's worry about other reader macros.  Sharpdots can appear just about
anywhere, including inside other reader macros.  For example, you could write
something like #+#.(stuff).  Yes, QPX does that too.  Fortunately, that's no
trouble -- we just need to replace other reader macros in the readtable so that
the perform the proper preprocessing step before doing their thing.  While
we're at it, we can instrument sharpquote to signal a use of the function in
question; of course, like sharpdot, it'll have to return a
with-transfer-constituent form so that the signal can get properly transferred
in the preprocessing step.  That's easy enough, until we get to the next issue.

How about backquotes?  What happens when you write `(foo #'(setf ,bar)) after
we replace sharpquote as above?  Actually, the behavior is not portably
defined, because Common Lisp doesn't specify how backquote works, only what it
does when evaluated (in particular, the value of (car (quote `(a ,b))) is
undefined in Common Lisp).  In SBCL, I've found that that snippet causes quotes
to appear in unexpected places, causing the with-transfer-constituent
replacement to get confused.  Mercifully, this sort of thing actually doesn't
seem to crop up in QPX (although it does in QRES), and ADG currently makes no
attempt to deal with it.

Now, how about compiler macros?  Compiler macros have the useful (but not well
specified) property that if a compiler macro function returns the same form
unchanged, then compiler-macroexpansion of that form halts, even though the
resulting form is of course still a valid compiler macro.  Thus, when
performing with-transfer-constituent replacement, we must be


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 asdf-dependency-grovel

Author

Andreas Fuchs, Matthew Steele and Francois-Rene Rideau

Description

Analyse the dependencies in an ASDF system

Long Description

ASDF-DEPENDENCY-GROVEL will analyse the actual dependencies in an ASDF system. Based on an analysis with file granularity ,
it can output an optimized system definition,
based on which compilation can be parallelized.
Based on an analysis with form granularity,
it can output a summary from which you can untangle
the circularities in your build.

Version

1.108

Dependency

asdf

Source

asdf-dependency-grovel.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Modules

Modules are listed depth-first from the system components tree.


Previous: , Up: Modules   [Contents][Index]

3.1 asdf-dependency-grovel/handlers

Dependency

grovel.lisp (file)

Parent

asdf-dependency-grovel (system)

Location

handlers/

Component

00-standard-handlers.lisp (file)


Next: , Previous: , Up: Top   [Contents][Index]

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 asdf-dependency-grovel.asd

Location

asdf-dependency-grovel.asd

Systems

asdf-dependency-grovel (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.2 asdf-dependency-grovel/package.lisp

Parent

asdf-dependency-grovel (system)

Location

package.lisp

Packages

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.3 asdf-dependency-grovel/variables.lisp

Dependency

package.lisp (file)

Parent

asdf-dependency-grovel (system)

Location

variables.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.4 asdf-dependency-grovel/classes.lisp

Dependencies
Parent

asdf-dependency-grovel (system)

Location

classes.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.5 asdf-dependency-grovel/asdf-classes.lisp

Dependency

package.lisp (file)

Parent

asdf-dependency-grovel (system)

Location

asdf-classes.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.6 asdf-dependency-grovel/grovel.lisp

Dependencies
Parent

asdf-dependency-grovel (system)

Location

grovel.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.7 asdf-dependency-grovel/asdf-ops.lisp

Dependencies
Parent

asdf-dependency-grovel (system)

Location

asdf-ops.lisp

Exported Definitions
Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

4.1.8 asdf-dependency-grovel/handlers/00-standard-handlers.lisp

Parent

handlers (module)

Location

handlers/00-standard-handlers.lisp


Next: , Previous: , Up: Top   [Contents][Index]

5 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 asdf-dependency-grovel.lambdas

Source

package.lisp (file)


Next: , Previous: , Up: Packages   [Contents][Index]

5.2 asdf-dependency-grovel.packages

Source

package.lisp (file)


Previous: , Up: Packages   [Contents][Index]

5.3 asdf-dependency-grovel

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.1 Macros

Macro: with-constituent-groveling &body BODY
Package

asdf-dependency-grovel

Source

grovel.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.2 Functions

Function: fine-grain-instrumented-load PATHSPEC &key VERBOSE PRINT IF-DOES-NOT-EXIST EXTERNAL-FORMAT
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: instrumented-compile-file FILE &rest ARGS
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: instrumented-load FILE &rest ARGS
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: print-big-ol-dependency-report &key STREAM
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: read-component-file PATHNAME &rest SYSTEM-NAMES
Package

asdf-dependency-grovel

Source

asdf-ops.lisp (file)

Function: reload ()

Reload the asdf-dependency-grovel system safely.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: signal-provider NAME FORM-TYPE

Signal that symbol ‘name’ of kind ‘form-type’ is being provided by the current constituent. For example, (defun foo ...) would signal with ‘name’ foo and ‘form-type’ defun.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: signal-user NAME FORM-TYPE

Signal that symbol ‘name’ of kind ‘form-type’ is being used by the current constituent. For example, (with-foo ...) might signal with ‘name’ with-foo and ‘form-type’ defmacro.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: systems-in-configuration PATHNAME &rest SYSTEM-NAMES
Package

asdf-dependency-grovel

Source

asdf-ops.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.3 Generic functions

Generic Function: additional-initargs OBJECT
Package

asdf-dependency-grovel

Methods
Method: additional-initargs (COMP instrumented-component) around
Source

asdf-classes.lisp (file)

Method: additional-initargs (INSTRUMENTED-COMPONENT instrumented-component)

automatically generated reader method

Source

asdf-classes.lisp (file)


Previous: , Up: Exported definitions   [Contents][Index]

6.1.4 Classes

Class: component-file ()
Package

asdf-dependency-grovel

Source

asdf-ops.lisp (file)

Direct superclasses

source-file (class)

Direct methods
  • perform (method)
  • operation-done-p (method)
  • input-files (method)
  • output-files (method)
Direct slots
Slot: last-grovel-state
Slot: load-system
Initargs

:load-systems

Slot: merge-systems
Initargs

:merge-systems

Slot: verbose
Initargs

:verbose

Initform

t

Slot: output-file
Initargs

:output-file

Slot: base-pathname
Initargs

:base-pathname

Slot: base-asd-file
Initargs

:base-asd-file

Slot: additional-initargs

A list of mappings from components in systems to additional initargs that the instrumented components should receive. E.g.: ((:foo-system ("module" "component-name") :additional-dependencies ())
(:foo-system ("component2") :data-files ())

Initargs

:additional-initargs

Class: dependency-op ()
Package

asdf-dependency-grovel

Source

asdf-ops.lisp (file)

Direct superclasses

load-source-op (class)

Direct methods
  • perform (method)
  • operation-done-p (method)
  • input-files (method)
  • output-files (method)
Direct slots
Slot: selfward-operation
Initform

(quote asdf-dependency-grovel::prepare-dependency-op)

Class: instrumented-cl-source-file ()
Package

asdf-dependency-grovel

Source

asdf-classes.lisp (file)

Direct superclasses
Direct methods
  • perform (method)
  • perform (method)
  • perform (method)
  • output-files (method)
Class: instrumented-component ()
Package

asdf-dependency-grovel

Source

asdf-classes.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: translated-name
Initargs

:translated-name

Readers

translated-name (generic function)

Slot: translated-pathname
Initargs

:translated-pathname-form

Readers

translated-pathname (generic function)

Slot: output-file-type
Initargs

:output-file-type

Readers

output-file-type (generic function)

Slot: additional-dependencies
Initargs

:additional-dependencies

Readers

additional-dependencies (generic function)

Slot: overridden-dependencies
Initargs

:override-dependencies

Readers

overridden-dependencies (generic function)

Slot: additional-initargs
Initargs

:additional-initargs

Readers

additional-initargs (generic function)

Class: instrumented-module ()
Package

asdf-dependency-grovel

Source

asdf-classes.lisp (file)

Direct superclasses
Direct Default Initargs
InitargValue
:default-component-class(quote asdf-dependency-grovel:instrumented-cl-source-file)

Previous: , Up: Definitions   [Contents][Index]

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Special variables

Special Variable: *check-internal-symbols-p*

If non-nil, then pay attention to dependencies that might be caused by
an :import-from or :shadowing-import-from in a defpackage. If nil, then signal-internal-symbols becomes a no-op, and the defpackage and in-package handlers do less work.

Package

asdf-dependency-grovel

Source

variables.lisp (file)

Special Variable: *constituent-table*

Hash table mapping constituent designators to constituent objects (initialized by with-constituent-groveling).

Package

asdf-dependency-grovel

Source

variables.lisp (file)

Special Variable: *current-constituent*

The lowest-level constituent that we are currently inside.

Package

asdf-dependency-grovel

Source

variables.lisp (file)

Special Variable: *debug-trace*

When non-nil, enables all kinds of output for debugging ADG.

Package

asdf-dependency-grovel

Source

variables.lisp (file)

Special Variable: *default-component-class*
Package

asdf-dependency-grovel

Source

asdf-ops.lisp (file)

Special Variable: *global-mutations*

Experimental – likely to be removed in the future. (msteele)

Package

asdf-dependency-grovel

Source

variables.lisp (file)

Special Variable: *grovel-dir-suffix*

Bound to a value that is unique once per operating on each dependency-groveling system.

Package

asdf-dependency-grovel

Source

variables.lisp (file)

Special Variable: *macroexpansion-handlers*
Package

asdf-dependency-grovel

Source

variables.lisp (file)

Special Variable: *old-macroexpand-hook*

When the override macroexpand hook is active, this is bound to the old value of *macroexpand-hook*.

Package

asdf-dependency-grovel

Source

variables.lisp (file)

Special Variable: *preprocess-form-p*

Used to let the groveling-macroexpand-hook know when it needs to preprocess a form before macroexpanding it. It starts out as t, but is bound to nil within the instrumented-eval function.

Package

asdf-dependency-grovel

Source

variables.lisp (file)

Special Variable: *previous-package*

The most recent package to be set by in-package. We use *previous-package* instead of *package* directly because after loading a file, we need to know which package we were in just before the load finished, but the load function resets *package* when the load finishes.

Package

asdf-dependency-grovel

Source

variables.lisp (file)

Special Variable: *previously-interned-symbols*

The symbols that were already interned in *previous-package*. This gets updated each time we finish a constituent, and each time we hit an in-package form. Note that there’s subtlety involved in making sure this works regardless of whether or not we are groveling at the granularity of top-level forms.

Package

asdf-dependency-grovel

Source

variables.lisp (file)

Special Variable: *suspected-constants*

Hash table containing the symbols that should be treated as if they were constants (as if by defconstant) when used in forms.

Package

asdf-dependency-grovel

Source

variables.lisp (file)

Special Variable: *suspected-variables*

Hash table containing the symbols that should be treated as if they were variables (as if by defvar/defparameter) when used in forms.

Package

asdf-dependency-grovel

Source

variables.lisp (file)

Special Variable: *system-base-dir*

Designates the directory under which ADG will create its temporary directory for instrumented dependency-discovery FASLs.
When nil, ADG will use the base-pathname of the target system;
when non-nil, ADG will use that value as a pathname designator for it.

Package

asdf-dependency-grovel

Source

variables.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.2 Macros

Macro: do-hashset (ITEM HASHSET) &body BODY

Like dolist, but for hashsets.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Macro: do-until CONDITION &body BODY
Package

asdf-dependency-grovel

Source

classes.lisp (file)

Macro: do-walk-symbols (SYM FORM) &body BODY

Visit each symbol in ‘form’ one at a time, bind ‘sym’ to that symbol, and execute the body. Note that this will not visit non-symbols, such as numeric literals.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Macro: does-macroexpand (FUNCTION ENV &key MACROEXPAND-HOOK) NEW-MACRO-BODY
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Macro: does-macroexpand-with-epilogue (FUNCTION ENV &key MACROEXPAND-HOOK) NEW-MACRO-BODY EPILOGUE
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Macro: does-macroexpand-with-prologue (FUNCTION ENV &key MACROEXPAND-HOOK) PROLOGUE NEW-MACRO-BODY
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Macro: loop-hashset (ITEM HASHSET) &rest REST

Loop macro for hashsets.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Macro: noticing-*feature*-changes &rest BODY
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Macro: operating-on-asdf-component-constituent (COMPONENT) &body BODY

Used internally; not exported.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Macro: operating-on-file-constituent (PATH) &body BODY

Used internally; not exported.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Macro: operating-on-form-constituent (INDEX POS SUMMARY) &body BODY
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Macro: symbol-macroify OPERATOR NAME &rest ARGS
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Macro: walk-constituents-postorder (CONSTITUENT TOP) &body BODY

Like dolist, but visits constituents in a postorder traversal.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Macro: walk-constituents-preorder (CONSTITUENT TOP) &body BODY

Like dolist, but visits constituents in a preorder traversal.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Macro: with-dependency-tracking COMP &body BODY
Package

asdf-dependency-grovel

Source

asdf-ops.lisp (file)

Macro: with-gensyms (&rest NAMES) &body BODY
Package

asdf-dependency-grovel

Source

classes.lisp (file)

Macro: with-groveling-macroexpand-hook &body BODY

Turn on the groveling-macroexpand-hook within the body. This macro is idempotent, so it’s safe to nest it (and we occasionally do).

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Macro: with-groveling-readtable &body BODY

Turn on the groveling readtable within the body.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.3 Functions

Function: %comp-file-reader PATHNAME SYSTEM-NAMES COLLECTOR
Package

asdf-dependency-grovel

Source

asdf-ops.lisp (file)

Function: additional-dependencies* COMPONENT

Walk the tree up through all parent components and collect their :additional-dependencies.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: asdf-system-file-components SYSTEM

Flatten the tree of modules/components into a list that contains only the non-module components.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: build-merged-graph TOP-CONSTITUENT
Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: call-with-constituent-groveling THUNK
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: call-with-dependency-tracking COMP THUNK
Package

asdf-dependency-grovel

Source

asdf-ops.lisp (file)

Function: canonical-package-name PACKAGE-DESIGNATOR

Return the name of a package as a symbol, given either a package object or a string or symbol naming the package. Note that given a package nickname as a string or symbol, it returns a symbol for that nickname, not for the primary name of that package.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: check-for-transfers FORM

Peform any transfers appearing in the given form, and return a copy of the form with transfers removed; if the given contains no transfers, return the original form object (rather than a copy).

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: coerce-class-name MAYBE-CLASS
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: collect-slots OBJECT SLOTS
Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: constituent-add-provision PROVISION CON

Add a provision to the constituent. The provision should be a list of two elements: the name of the thing provided, and a symbol indicating the kind of thing provided, e.g. ’(*foo* defvar).

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: constituent-add-use USE CON

Add a use to the constituent. The use should be a list of two elements: the name of the thing used, and a symbol indicating the kind of thing used, e.g. ’(*foo* defvar).

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: constituent-dependency-forms TOP INTERESTING-SYSTEMS
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: constituent-dependency-table TOP

Create a table mapping constituents to constituents to lists of reasons.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: constituent-descendant-p CON1 CON2

Return t if con1 is a descendant of con2, nil otherwise.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: constituent-provision-table TOP

Create a hash table mapping provisions to constituents that provide them.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: cyclic-reachable-p GRAPH START-NODE END-NODE

Return t if ‘end-node’ is cyclic-reachable from ‘start-node’, nil othewise. If nodes A and B have the same parent, then node B is said to be cyclic-reachable from a node A if there is a way to get from A to B that passes through a node with a different parent (this implies that merging nodes A and B would create a cycle between two nodes with different parents).

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: does-not-macroexpand ()

A handler can return (does-not-macroexpand) to indicate that does not wish to provide any special expansion, and will thus defer to the normal expansion for the macro.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: dwim-stringify-component-spec COMPONENT-SPEC
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: enough-component-spec C
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: escaped-around-compile-hook COMPONENT
Package

asdf-dependency-grovel

Source

asdf-classes.lisp (file)

Function: fail-if-not-acyclic GRAPH MESSAGE
Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: find-a-cycle-if-any GRAPH

If the graph contains a cycle, return a list of the dnodes involved; if there is no cycle, return nil.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: get-file-constituents TOP

Return a list of file-constituents that are descendants of the given constituent.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: groveling-macroexpand-hook FUN FORM ENV

A substitute for ‘*macroexpand-hook*’ that provides the entry into the magic of asdf-dependency-grovel.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: handle-macroexpansion NAME FORM FUNCTION ENVIRONMENT

Handle macroexpansion of a macro called ‘name’ on ‘form’ with macro function ‘function’ in ‘environment’. Either dispatch to the appropriate handler, or else simply signal the use of the macro, and provide no special expansion. Return two values: first, a boolean indicating whether any special expansion was done, and second, the special expansion form (or nil if none).

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: hashset-add ITEM HASHSET

Add an item to the hashset.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: hashset-contains-p ITEM HASHSET

Return t if the item is in the hashset, nil otherwise.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: hashset-count HASHSET

Return the number of items in the hashset.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: hashset-empty-p HASHSET

Return t if the hashset is empty, nil otherwise.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: hashset-pop HASHSET

Remove and return an arbitrary item from the hashset.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: hashset-remove ITEM HASHSET

Remove an item from the hashset.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: hashset-subset-p SET1 SET2

Return t if ‘set1’ is a subset of ‘set2’, nil otherwise.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: heap-count HEAP

Return the number of elements in the heap.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: heap-empty-p HEAP

Return t if the heap is empty, nil otherwise.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: heap-insert OBJ HEAP

Add an element to the heap.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: heap-pop HEAP

Remove the element with the smallest priority-value from the heap and return two values: the element removed (or nil if the heap was already empty), and a boolean that is nil if the heap was indeed already empty or t otherwise.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: initially-grovel-dependencies SYSTEMS STREAM INTERESTING-SYSTEMS &key VERBOSE BASE-PATHNAME
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: instrument-defun-body BODY FORM

Insert FORM into list of defun body forms BODY such that the return value of BODY is the same as it would be without FORM, keeping declarations intact.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: instrumented-eval FORM

Like eval, but preprocess the form first, and then eval it with the groveling-macroexpand-hook in place.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: instrumented-sharp+ STREAM SUBCHAR NUMARG
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: instrumented-sharp- STREAM SUBCHAR NUMARG
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: instrumented-sharp-s STREAM SUBCHAR NUMARG
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: instrumented-sharpdot STREAM SUBCHAR NUMARG
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: instrumented-sharpquote STREAM SUBCHAR NUMARG
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: load-instrumented-systems SYSTEMS ADDITIONAL-INITARGS
Package

asdf-dependency-grovel

Source

asdf-ops.lisp (file)

Function: make-dnode CONSTITUENT

Create a new dnode containing a single constituent.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: make-hashset &key TEST

Create a new hashset with the specified test function.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: make-heap &key KEY

Make an empty min-heap. The :key argument should be a function mapping elements of the heap to a priority value (typically a number) by which that item will be sorted. If no :key function is given, the element itself is used as the priority value.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: make-instrumented-readtable ()
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: map-over-instrumented-component-and-parents COMPONENT SLOT-NAME
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: maybe-translated-component-class COMPONENT
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: maybe-translated-component-name COMPONENT &key INCLUDE-PATHNAME
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: new-temp-constituent ()

Create a new temp-constituent with an automatically generated label.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: normalize-pathname-directory PATHNAME
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: normalize-pathname-directory-component* PATHNAME-DIRECTORY
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: normalized-component-name C
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: operate-on-asdf-component-constituent COMPONENT THUNK
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: operate-on-constituent DESIGNATOR MAKER THUNK
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: operate-on-file-constituent PATH THUNK
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: operate-on-file-level-constituent DESIGNATOR MAKER THUNK
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: operate-on-form-constituent INDEX POS SUMMARY THUNK
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: output-component-file STREAM DEPENDENCIES &key OUTPUT-SYSTEMS-AND-DEPENDENCIES-P
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: overridden-dependencies* COMPONENT
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: preprocess-form FORM

Walk the form, signaling any suspected variables or constants, and uses of symbols from defpackages.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: print-constituent-dependency-report &key STREAM
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: print-constituent-file-splitting-strategy &key STREAM
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: propagate-constituent-downward CON

Copy all uses and provisions from the constituent to all its descendants, and do the same for each descendant.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: propagate-constituent-upward CON

Copy all uses and provisions from the constituent’s descendants to it, and do the same for each descendant.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: replace-transfers FORM

Return a form similar to the one given, but replace with-transfer-constituent subforms with their included results, while transferring the included constituents.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: signal-new-internal-symbols &key POPULATE

This should be called by the in-package handler as well as at the end of each constituent (at every level). It looks for symbols that have been added to *previous-package* since the last time *previously-interned-symbols* was populated, and signals that the current constituent provided them. Uses of these symbols are picked up in the :import-from and :shadowing-import-from clauses of a defpackage. The :populate keyword, if non-nil, tells signal-new-internal-symbols to populate *previously-interned-symbols* with any missing symbols (after signaling provisions).

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: signal-symbol-macroexpansion NAME EXPANSION
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Setf Expander

(setf signal-symbol-macroexpansion) (setf expander)

Setf Expander: (setf signal-symbol-macroexpansion) NAME EXPRESSION
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Reader

signal-symbol-macroexpansion (function)

Function: signal-typespec TYPESPEC

Traverse a type specification and signal-user as appropriate.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: simple-print-object OBJECT STREAM &key IDENTITY SLOTS
Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: state-of OP COMPONENT
Function: (setf state-of) NEW-VAL OP COMPONENT
Package

asdf-dependency-grovel

Source

asdf-ops.lisp (file)

Function: strip-extension NAME EXTENSION
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: strip/ NAME
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: summarize-form FORM
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: topologically-stable-sort-graph GRAPH PARENTS
Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: transfer-constituent CON

Add all provisions and uses in the given constituent to the current constituent. Typically, the given constituent will be a temp-constituent, for example one produced by our instrumented sharpdot reader-macro.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Function: try-to-merge-dnodes GRAPH DNODE1 DNODE2

Either merge the nodes and return t, or do nothing and return nil.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Function: wtf STRING &rest ARGS

WTF stands for When-Trace-Format. When *debug-trace* is non-nil, it will format some debug info to stdout.

Package

asdf-dependency-grovel

Source

grovel.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.4 Generic functions

Generic Function: additional-dependencies OBJECT
Package

asdf-dependency-grovel

Methods
Method: additional-dependencies (INSTRUMENTED-COMPONENT instrumented-component)

automatically generated reader method

Source

asdf-classes.lisp (file)

Generic Function: asdf-component-constituent-component OBJECT
Package

asdf-dependency-grovel

Methods
Method: asdf-component-constituent-component (ASDF-COMPONENT-CONSTITUENT asdf-component-constituent)

The ASDF component.

Source

classes.lisp (file)

Generic Function: constituent-children OBJECT
Package

asdf-dependency-grovel

Methods
Method: constituent-children (CONSTITUENT constituent)

A list of direct children of this constituent.

Source

classes.lisp (file)

Generic Function: constituent-designator CON

Return the unique designator of the constituent.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Methods
Method: constituent-designator (CON file-constituent)
Method: constituent-designator (CON asdf-component-constituent)
Method: constituent-designator (CON form-constituent)
Method: constituent-designator (CON constituent)
Method: constituent-designator (CON top-constituent)
Method: constituent-designator (CON null)
Generic Function: constituent-index OBJECT
Package

asdf-dependency-grovel

Methods
Method: constituent-index (CONSTITUENT constituent)

The index of this constituent within its parent (if any).

Source

classes.lisp (file)

Generic Function: constituent-parent OBJECT
Package

asdf-dependency-grovel

Methods
Method: constituent-parent (CONSTITUENT constituent)

The parent constituent directly containing this one, or nil if the constituent has no parent.

Source

classes.lisp (file)

Generic Function: constituent-provisions OBJECT
Generic Function: (setf constituent-provisions) NEW-VALUE OBJECT
Package

asdf-dependency-grovel

Methods
Method: constituent-provisions (CONSTITUENT constituent)
Method: (setf constituent-provisions) NEW-VALUE (CONSTITUENT constituent)

A hashset of things provided by this constituent.

Source

classes.lisp (file)

Generic Function: constituent-summary CON

Return a summary of the identity of the constituent.

Package

asdf-dependency-grovel

Source

classes.lisp (file)

Methods
Method: constituent-summary (CON temp-constituent)
Method: constituent-summary (CON form-constituent)
Method: constituent-summary (CON constituent)
Generic Function: constituent-uses OBJECT
Generic Function: (setf constituent-uses) NEW-VALUE OBJECT
Package

asdf-dependency-grovel

Methods
Method: constituent-uses (CONSTITUENT constituent)
Method: (setf constituent-uses) NEW-VALUE (CONSTITUENT constituent)

A hashset of things used by this constituent.

Source

classes.lisp (file)

Generic Function: dnode-constituents OBJECT
Package

asdf-dependency-grovel

Methods
Method: dnode-constituents (DNODE dnode)

The set of constituents in this node.

Source

classes.lisp (file)

Generic Function: dnode-parent OBJECT
Package

asdf-dependency-grovel

Methods
Method: dnode-parent (DNODE dnode)

The parent of all constituents in this node.

Source

classes.lisp (file)

Generic Function: dnodes-needed-by OBJECT
Package

asdf-dependency-grovel

Methods
Method: dnodes-needed-by (DNODE dnode)

The set of nodes that this node depends on.

Source

classes.lisp (file)

Generic Function: dnodes-that-depend-on OBJECT
Package

asdf-dependency-grovel

Methods
Method: dnodes-that-depend-on (DNODE dnode)

The set of nodes that depend on this node.

Source

classes.lisp (file)

Generic Function: enclosing-file-constituent CONSTITUENT
Package

asdf-dependency-grovel

Source

grovel.lisp (file)

Methods
Method: enclosing-file-constituent X
Method: enclosing-file-constituent (X asdf-component-constituent)
Method: enclosing-file-constituent (X file-constituent)
Method: enclosing-file-constituent (X form-constituent)
Generic Function: file-constituent-path OBJECT
Package

asdf-dependency-grovel

Methods
Method: file-constituent-path (FILE-CONSTITUENT file-constituent)

The path of the file.

Source

classes.lisp (file)

Generic Function: form-constituent-position OBJECT
Package

asdf-dependency-grovel

Methods
Method: form-constituent-position (FORM-CONSTITUENT form-constituent)

The position in the file at which the form starts.

Source

classes.lisp (file)

Generic Function: form-constituent-summary OBJECT
Package

asdf-dependency-grovel

Methods
Method: form-constituent-summary (FORM-CONSTITUENT form-constituent)

A human-readable string summarizing the form.

Source

classes.lisp (file)

Generic Function: output-file-type OBJECT
Package

asdf-dependency-grovel

Methods
Method: output-file-type (INSTRUMENTED-COMPONENT instrumented-component)

automatically generated reader method

Source

asdf-classes.lisp (file)

Generic Function: overridden-dependencies OBJECT
Package

asdf-dependency-grovel

Methods
Method: overridden-dependencies (INSTRUMENTED-COMPONENT instrumented-component)

automatically generated reader method

Source

asdf-classes.lisp (file)

Generic Function: slots-to-print OBJECT
Package

asdf-dependency-grovel

Source

classes.lisp (file)

Method Combination

append (short method combination)

Options: :most-specific-first

Methods
Method: slots-to-print (CON temp-constituent) append
Method: slots-to-print (CON asdf-component-constituent) append
Method: slots-to-print (CON constituent) append
Generic Function: temp-constituent-label OBJECT
Package

asdf-dependency-grovel

Methods
Method: temp-constituent-label (TEMP-CONSTITUENT temp-constituent)

The label to use as the summary of this constituent.

Source

classes.lisp (file)

Generic Function: translated-name OBJECT
Package

asdf-dependency-grovel

Methods
Method: translated-name (INSTRUMENTED-COMPONENT instrumented-component)

automatically generated reader method

Source

asdf-classes.lisp (file)

Generic Function: translated-pathname OBJECT
Package

asdf-dependency-grovel

Methods
Method: translated-pathname (INSTRUMENTED-COMPONENT instrumented-component)

automatically generated reader method

Source

asdf-classes.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

6.2.5 Classes

Class: asdf-component-constituent ()
Package

asdf-dependency-grovel

Source

classes.lisp (file)

Direct superclasses

constituent (class)

Direct methods
Direct slots
Slot: component

The ASDF component.

Initargs

:component

Initform

(error "must supply a component")

Readers

asdf-component-constituent-component (generic function)

Class: constituent ()
Package

asdf-dependency-grovel

Source

classes.lisp (file)

Direct superclasses

simple-print-object-mixin (class)

Direct subclasses
Direct methods
Direct slots
Slot: parent

The parent constituent directly containing this one, or nil if the constituent has no parent.

Initargs

:parent

Readers

constituent-parent (generic function)

Slot: children

A list of direct children of this constituent.

Readers

constituent-children (generic function)

Slot: index

The index of this constituent within its parent (if any).

Initform

0

Readers

constituent-index (generic function)

Slot: uses

A hashset of things used by this constituent.

Initform

(asdf-dependency-grovel::make-hashset :test (quote equal))

Readers

constituent-uses (generic function)

Writers

(setf constituent-uses) (generic function)

Slot: provisions

A hashset of things provided by this constituent.

Initform

(asdf-dependency-grovel::make-hashset :test (quote equal))

Readers

constituent-provisions (generic function)

Writers

(setf constituent-provisions) (generic function)

Class: dnode ()
Package

asdf-dependency-grovel

Source

classes.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: parent

The parent of all constituents in this node.

Initargs

:parent

Initform

(error "must supply a parent")

Readers

dnode-parent (generic function)

Slot: constituents

The set of constituents in this node.

Initform

(asdf-dependency-grovel::make-hashset :test (quote eql))

Readers

dnode-constituents (generic function)

Slot: that-depend-on

The set of nodes that depend on this node.

Initform

(asdf-dependency-grovel::make-hashset :test (quote eql))

Readers

dnodes-that-depend-on (generic function)

Slot: needs

The set of nodes that this node depends on.

Initform

(asdf-dependency-grovel::make-hashset :test (quote eql))

Readers

dnodes-needed-by (generic function)

Class: file-constituent ()
Package

asdf-dependency-grovel

Source

classes.lisp (file)

Direct superclasses

constituent (class)

Direct methods
Direct slots
Slot: path

The path of the file.

Initargs

:path

Initform

(error "must supply a path")

Readers

file-constituent-path (generic function)

Class: form-constituent ()
Package

asdf-dependency-grovel

Source

classes.lisp (file)

Direct superclasses

constituent (class)

Direct methods
Direct slots
Slot: position

The position in the file at which the form starts.

Initargs

:position

Readers

form-constituent-position (generic function)

Slot: summary

A human-readable string summarizing the form.

Initargs

:summary

Readers

form-constituent-summary (generic function)

Class: prepare-dependency-op ()
Package

asdf-dependency-grovel

Source

asdf-ops.lisp (file)

Direct superclasses

prepare-source-op (class)

Direct slots
Slot: sideway-operation
Initform

(quote asdf-dependency-grovel:dependency-op)

Class: simple-print-object-mixin ()
Package

asdf-dependency-grovel

Source

classes.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

constituent (class)

Direct methods

print-object (method)

Class: temp-constituent ()
Package

asdf-dependency-grovel

Source

classes.lisp (file)

Direct superclasses

constituent (class)

Direct methods
Direct slots
Slot: label

The label to use as the summary of this constituent.

Initargs

:label

Initform

(error "must supply a label")

Readers

temp-constituent-label (generic function)

Class: top-constituent ()
Package

asdf-dependency-grovel

Source

classes.lisp (file)

Direct superclasses

constituent (class)

Direct methods

constituent-designator (method)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   A   F   L   M  
Index Entry  Section

A
asdf-dependency-grovel.asd: The asdf-dependency-grovel<dot>asd file
asdf-dependency-grovel/asdf-classes.lisp: The asdf-dependency-grovel/asdf-classes<dot>lisp file
asdf-dependency-grovel/asdf-ops.lisp: The asdf-dependency-grovel/asdf-ops<dot>lisp file
asdf-dependency-grovel/classes.lisp: The asdf-dependency-grovel/classes<dot>lisp file
asdf-dependency-grovel/grovel.lisp: The asdf-dependency-grovel/grovel<dot>lisp file
asdf-dependency-grovel/handlers: The asdf-dependency-grovel/handlers module
asdf-dependency-grovel/handlers/00-standard-handlers.lisp: The asdf-dependency-grovel/handlers/00-standard-handlers<dot>lisp file
asdf-dependency-grovel/package.lisp: The asdf-dependency-grovel/package<dot>lisp file
asdf-dependency-grovel/variables.lisp: The asdf-dependency-grovel/variables<dot>lisp file

F
File, Lisp, asdf-dependency-grovel.asd: The asdf-dependency-grovel<dot>asd file
File, Lisp, asdf-dependency-grovel/asdf-classes.lisp: The asdf-dependency-grovel/asdf-classes<dot>lisp file
File, Lisp, asdf-dependency-grovel/asdf-ops.lisp: The asdf-dependency-grovel/asdf-ops<dot>lisp file
File, Lisp, asdf-dependency-grovel/classes.lisp: The asdf-dependency-grovel/classes<dot>lisp file
File, Lisp, asdf-dependency-grovel/grovel.lisp: The asdf-dependency-grovel/grovel<dot>lisp file
File, Lisp, asdf-dependency-grovel/handlers/00-standard-handlers.lisp: The asdf-dependency-grovel/handlers/00-standard-handlers<dot>lisp file
File, Lisp, asdf-dependency-grovel/package.lisp: The asdf-dependency-grovel/package<dot>lisp file
File, Lisp, asdf-dependency-grovel/variables.lisp: The asdf-dependency-grovel/variables<dot>lisp file

L
Lisp File, asdf-dependency-grovel.asd: The asdf-dependency-grovel<dot>asd file
Lisp File, asdf-dependency-grovel/asdf-classes.lisp: The asdf-dependency-grovel/asdf-classes<dot>lisp file
Lisp File, asdf-dependency-grovel/asdf-ops.lisp: The asdf-dependency-grovel/asdf-ops<dot>lisp file
Lisp File, asdf-dependency-grovel/classes.lisp: The asdf-dependency-grovel/classes<dot>lisp file
Lisp File, asdf-dependency-grovel/grovel.lisp: The asdf-dependency-grovel/grovel<dot>lisp file
Lisp File, asdf-dependency-grovel/handlers/00-standard-handlers.lisp: The asdf-dependency-grovel/handlers/00-standard-handlers<dot>lisp file
Lisp File, asdf-dependency-grovel/package.lisp: The asdf-dependency-grovel/package<dot>lisp file
Lisp File, asdf-dependency-grovel/variables.lisp: The asdf-dependency-grovel/variables<dot>lisp file

M
Module, asdf-dependency-grovel/handlers: The asdf-dependency-grovel/handlers module

Jump to:   A   F   L   M  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   R   S   T   W  
Index Entry  Section

%
%comp-file-reader: Internal functions

(
(setf constituent-provisions): Internal generic functions
(setf constituent-provisions): Internal generic functions
(setf constituent-uses): Internal generic functions
(setf constituent-uses): Internal generic functions
(setf signal-symbol-macroexpansion): Internal functions
(setf state-of): Internal functions

A
additional-dependencies: Internal generic functions
additional-dependencies: Internal generic functions
additional-dependencies*: Internal functions
additional-initargs: Exported generic functions
additional-initargs: Exported generic functions
additional-initargs: Exported generic functions
asdf-component-constituent-component: Internal generic functions
asdf-component-constituent-component: Internal generic functions
asdf-system-file-components: Internal functions

B
build-merged-graph: Internal functions

C
call-with-constituent-groveling: Internal functions
call-with-dependency-tracking: Internal functions
canonical-package-name: Internal functions
check-for-transfers: Internal functions
coerce-class-name: Internal functions
collect-slots: Internal functions
constituent-add-provision: Internal functions
constituent-add-use: Internal functions
constituent-children: Internal generic functions
constituent-children: Internal generic functions
constituent-dependency-forms: Internal functions
constituent-dependency-table: Internal functions
constituent-descendant-p: Internal functions
constituent-designator: Internal generic functions
constituent-designator: Internal generic functions
constituent-designator: Internal generic functions
constituent-designator: Internal generic functions
constituent-designator: Internal generic functions
constituent-designator: Internal generic functions
constituent-designator: Internal generic functions
constituent-index: Internal generic functions
constituent-index: Internal generic functions
constituent-parent: Internal generic functions
constituent-parent: Internal generic functions
constituent-provision-table: Internal functions
constituent-provisions: Internal generic functions
constituent-provisions: Internal generic functions
constituent-summary: Internal generic functions
constituent-summary: Internal generic functions
constituent-summary: Internal generic functions
constituent-summary: Internal generic functions
constituent-uses: Internal generic functions
constituent-uses: Internal generic functions
cyclic-reachable-p: Internal functions

D
dnode-constituents: Internal generic functions
dnode-constituents: Internal generic functions
dnode-parent: Internal generic functions
dnode-parent: Internal generic functions
dnodes-needed-by: Internal generic functions
dnodes-needed-by: Internal generic functions
dnodes-that-depend-on: Internal generic functions
dnodes-that-depend-on: Internal generic functions
do-hashset: Internal macros
do-until: Internal macros
do-walk-symbols: Internal macros
does-macroexpand: Internal macros
does-macroexpand-with-epilogue: Internal macros
does-macroexpand-with-prologue: Internal macros
does-not-macroexpand: Internal functions
dwim-stringify-component-spec: Internal functions

E
enclosing-file-constituent: Internal generic functions
enclosing-file-constituent: Internal generic functions
enclosing-file-constituent: Internal generic functions
enclosing-file-constituent: Internal generic functions
enclosing-file-constituent: Internal generic functions
enough-component-spec: Internal functions
escaped-around-compile-hook: Internal functions

F
fail-if-not-acyclic: Internal functions
file-constituent-path: Internal generic functions
file-constituent-path: Internal generic functions
find-a-cycle-if-any: Internal functions
fine-grain-instrumented-load: Exported functions
form-constituent-position: Internal generic functions
form-constituent-position: Internal generic functions
form-constituent-summary: Internal generic functions
form-constituent-summary: Internal generic functions
Function, %comp-file-reader: Internal functions
Function, (setf state-of): Internal functions
Function, additional-dependencies*: Internal functions
Function, asdf-system-file-components: Internal functions
Function, build-merged-graph: Internal functions
Function, call-with-constituent-groveling: Internal functions
Function, call-with-dependency-tracking: Internal functions
Function, canonical-package-name: Internal functions
Function, check-for-transfers: Internal functions
Function, coerce-class-name: Internal functions
Function, collect-slots: Internal functions
Function, constituent-add-provision: Internal functions
Function, constituent-add-use: Internal functions
Function, constituent-dependency-forms: Internal functions
Function, constituent-dependency-table: Internal functions
Function, constituent-descendant-p: Internal functions
Function, constituent-provision-table: Internal functions
Function, cyclic-reachable-p: Internal functions
Function, does-not-macroexpand: Internal functions
Function, dwim-stringify-component-spec: Internal functions
Function, enough-component-spec: Internal functions
Function, escaped-around-compile-hook: Internal functions
Function, fail-if-not-acyclic: Internal functions
Function, find-a-cycle-if-any: Internal functions
Function, fine-grain-instrumented-load: Exported functions
Function, get-file-constituents: Internal functions
Function, groveling-macroexpand-hook: Internal functions
Function, handle-macroexpansion: Internal functions
Function, hashset-add: Internal functions
Function, hashset-contains-p: Internal functions
Function, hashset-count: Internal functions
Function, hashset-empty-p: Internal functions
Function, hashset-pop: Internal functions
Function, hashset-remove: Internal functions
Function, hashset-subset-p: Internal functions
Function, heap-count: Internal functions
Function, heap-empty-p: Internal functions
Function, heap-insert: Internal functions
Function, heap-pop: Internal functions
Function, initially-grovel-dependencies: Internal functions
Function, instrument-defun-body: Internal functions
Function, instrumented-compile-file: Exported functions
Function, instrumented-eval: Internal functions
Function, instrumented-load: Exported functions
Function, instrumented-sharp+: Internal functions
Function, instrumented-sharp-: Internal functions
Function, instrumented-sharp-s: Internal functions
Function, instrumented-sharpdot: Internal functions
Function, instrumented-sharpquote: Internal functions
Function, load-instrumented-systems: Internal functions
Function, make-dnode: Internal functions
Function, make-hashset: Internal functions
Function, make-heap: Internal functions
Function, make-instrumented-readtable: Internal functions
Function, map-over-instrumented-component-and-parents: Internal functions
Function, maybe-translated-component-class: Internal functions
Function, maybe-translated-component-name: Internal functions
Function, new-temp-constituent: Internal functions
Function, normalize-pathname-directory: Internal functions
Function, normalize-pathname-directory-component*: Internal functions
Function, normalized-component-name: Internal functions
Function, operate-on-asdf-component-constituent: Internal functions
Function, operate-on-constituent: Internal functions
Function, operate-on-file-constituent: Internal functions
Function, operate-on-file-level-constituent: Internal functions
Function, operate-on-form-constituent: Internal functions
Function, output-component-file: Internal functions
Function, overridden-dependencies*: Internal functions
Function, preprocess-form: Internal functions
Function, print-big-ol-dependency-report: Exported functions
Function, print-constituent-dependency-report: Internal functions
Function, print-constituent-file-splitting-strategy: Internal functions
Function, propagate-constituent-downward: Internal functions
Function, propagate-constituent-upward: Internal functions
Function, read-component-file: Exported functions
Function, reload: Exported functions
Function, replace-transfers: Internal functions
Function, signal-new-internal-symbols: Internal functions
Function, signal-provider: Exported functions
Function, signal-symbol-macroexpansion: Internal functions
Function, signal-typespec: Internal functions
Function, signal-user: Exported functions
Function, simple-print-object: Internal functions
Function, state-of: Internal functions
Function, strip-extension: Internal functions
Function, strip/: Internal functions
Function, summarize-form: Internal functions
Function, systems-in-configuration: Exported functions
Function, topologically-stable-sort-graph: Internal functions
Function, transfer-constituent: Internal functions
Function, try-to-merge-dnodes: Internal functions
Function, wtf: Internal functions

G
Generic Function, (setf constituent-provisions): Internal generic functions
Generic Function, (setf constituent-uses): Internal generic functions
Generic Function, additional-dependencies: Internal generic functions
Generic Function, additional-initargs: Exported generic functions
Generic Function, asdf-component-constituent-component: Internal generic functions
Generic Function, constituent-children: Internal generic functions
Generic Function, constituent-designator: Internal generic functions
Generic Function, constituent-index: Internal generic functions
Generic Function, constituent-parent: Internal generic functions
Generic Function, constituent-provisions: Internal generic functions
Generic Function, constituent-summary: Internal generic functions
Generic Function, constituent-uses: Internal generic functions
Generic Function, dnode-constituents: Internal generic functions
Generic Function, dnode-parent: Internal generic functions
Generic Function, dnodes-needed-by: Internal generic functions
Generic Function, dnodes-that-depend-on: Internal generic functions
Generic Function, enclosing-file-constituent: Internal generic functions
Generic Function, file-constituent-path: Internal generic functions
Generic Function, form-constituent-position: Internal generic functions
Generic Function, form-constituent-summary: Internal generic functions
Generic Function, output-file-type: Internal generic functions
Generic Function, overridden-dependencies: Internal generic functions
Generic Function, slots-to-print: Internal generic functions
Generic Function, temp-constituent-label: Internal generic functions
Generic Function, translated-name: Internal generic functions
Generic Function, translated-pathname: Internal generic functions
get-file-constituents: Internal functions
groveling-macroexpand-hook: Internal functions

H
handle-macroexpansion: Internal functions
hashset-add: Internal functions
hashset-contains-p: Internal functions
hashset-count: Internal functions
hashset-empty-p: Internal functions
hashset-pop: Internal functions
hashset-remove: Internal functions
hashset-subset-p: Internal functions
heap-count: Internal functions
heap-empty-p: Internal functions
heap-insert: Internal functions
heap-pop: Internal functions

I
initially-grovel-dependencies: Internal functions
instrument-defun-body: Internal functions
instrumented-compile-file: Exported functions
instrumented-eval: Internal functions
instrumented-load: Exported functions
instrumented-sharp+: Internal functions
instrumented-sharp-: Internal functions
instrumented-sharp-s: Internal functions
instrumented-sharpdot: Internal functions
instrumented-sharpquote: Internal functions

L
load-instrumented-systems: Internal functions
loop-hashset: Internal macros

M
Macro, do-hashset: Internal macros
Macro, do-until: Internal macros
Macro, do-walk-symbols: Internal macros
Macro, does-macroexpand: Internal macros
Macro, does-macroexpand-with-epilogue: Internal macros
Macro, does-macroexpand-with-prologue: Internal macros
Macro, loop-hashset: Internal macros
Macro, noticing-*feature*-changes: Internal macros
Macro, operating-on-asdf-component-constituent: Internal macros
Macro, operating-on-file-constituent: Internal macros
Macro, operating-on-form-constituent: Internal macros
Macro, symbol-macroify: Internal macros
Macro, walk-constituents-postorder: Internal macros
Macro, walk-constituents-preorder: Internal macros
Macro, with-constituent-groveling: Exported macros
Macro, with-dependency-tracking: Internal macros
Macro, with-gensyms: Internal macros
Macro, with-groveling-macroexpand-hook: Internal macros
Macro, with-groveling-readtable: Internal macros
make-dnode: Internal functions
make-hashset: Internal functions
make-heap: Internal functions
make-instrumented-readtable: Internal functions
map-over-instrumented-component-and-parents: Internal functions
maybe-translated-component-class: Internal functions
maybe-translated-component-name: Internal functions
Method, (setf constituent-provisions): Internal generic functions
Method, (setf constituent-uses): Internal generic functions
Method, additional-dependencies: Internal generic functions
Method, additional-initargs: Exported generic functions
Method, additional-initargs: Exported generic functions
Method, asdf-component-constituent-component: Internal generic functions
Method, constituent-children: Internal generic functions
Method, constituent-designator: Internal generic functions
Method, constituent-designator: Internal generic functions
Method, constituent-designator: Internal generic functions
Method, constituent-designator: Internal generic functions
Method, constituent-designator: Internal generic functions
Method, constituent-designator: Internal generic functions
Method, constituent-index: Internal generic functions
Method, constituent-parent: Internal generic functions
Method, constituent-provisions: Internal generic functions
Method, constituent-summary: Internal generic functions
Method, constituent-summary: Internal generic functions
Method, constituent-summary: Internal generic functions
Method, constituent-uses: Internal generic functions
Method, dnode-constituents: Internal generic functions
Method, dnode-parent: Internal generic functions
Method, dnodes-needed-by: Internal generic functions
Method, dnodes-that-depend-on: Internal generic functions
Method, enclosing-file-constituent: Internal generic functions
Method, enclosing-file-constituent: Internal generic functions
Method, enclosing-file-constituent: Internal generic functions
Method, enclosing-file-constituent: Internal generic functions
Method, file-constituent-path: Internal generic functions
Method, form-constituent-position: Internal generic functions
Method, form-constituent-summary: Internal generic functions
Method, output-file-type: Internal generic functions
Method, overridden-dependencies: Internal generic functions
Method, slots-to-print: Internal generic functions
Method, slots-to-print: Internal generic functions
Method, slots-to-print: Internal generic functions
Method, temp-constituent-label: Internal generic functions
Method, translated-name: Internal generic functions
Method, translated-pathname: Internal generic functions

N
new-temp-constituent: Internal functions
normalize-pathname-directory: Internal functions
normalize-pathname-directory-component*: Internal functions
normalized-component-name: Internal functions
noticing-*feature*-changes: Internal macros

O
operate-on-asdf-component-constituent: Internal functions
operate-on-constituent: Internal functions
operate-on-file-constituent: Internal functions
operate-on-file-level-constituent: Internal functions
operate-on-form-constituent: Internal functions
operating-on-asdf-component-constituent: Internal macros
operating-on-file-constituent: Internal macros
operating-on-form-constituent: Internal macros
output-component-file: Internal functions
output-file-type: Internal generic functions
output-file-type: Internal generic functions
overridden-dependencies: Internal generic functions
overridden-dependencies: Internal generic functions
overridden-dependencies*: Internal functions

P
preprocess-form: Internal functions
print-big-ol-dependency-report: Exported functions
print-constituent-dependency-report: Internal functions
print-constituent-file-splitting-strategy: Internal functions
propagate-constituent-downward: Internal functions
propagate-constituent-upward: Internal functions

R
read-component-file: Exported functions
reload: Exported functions
replace-transfers: Internal functions

S
Setf Expander, (setf signal-symbol-macroexpansion): Internal functions
signal-new-internal-symbols: Internal functions
signal-provider: Exported functions
signal-symbol-macroexpansion: Internal functions
signal-typespec: Internal functions
signal-user: Exported functions
simple-print-object: Internal functions
slots-to-print: Internal generic functions
slots-to-print: Internal generic functions
slots-to-print: Internal generic functions
slots-to-print: Internal generic functions
state-of: Internal functions
strip-extension: Internal functions
strip/: Internal functions
summarize-form: Internal functions
symbol-macroify: Internal macros
systems-in-configuration: Exported functions

T
temp-constituent-label: Internal generic functions
temp-constituent-label: Internal generic functions
topologically-stable-sort-graph: Internal functions
transfer-constituent: Internal functions
translated-name: Internal generic functions
translated-name: Internal generic functions
translated-pathname: Internal generic functions
translated-pathname: Internal generic functions
try-to-merge-dnodes: Internal functions

W
walk-constituents-postorder: Internal macros
walk-constituents-preorder: Internal macros
with-constituent-groveling: Exported macros
with-dependency-tracking: Internal macros
with-gensyms: Internal macros
with-groveling-macroexpand-hook: Internal macros
with-groveling-readtable: Internal macros
wtf: Internal functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   R   S   T   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *  
A   B   C   I   L   M   N   O   P   S   T   U   V  
Index Entry  Section

*
*check-internal-symbols-p*: Internal special variables
*constituent-table*: Internal special variables
*current-constituent*: Internal special variables
*debug-trace*: Internal special variables
*default-component-class*: Internal special variables
*global-mutations*: Internal special variables
*grovel-dir-suffix*: Internal special variables
*macroexpansion-handlers*: Internal special variables
*old-macroexpand-hook*: Internal special variables
*preprocess-form-p*: Internal special variables
*previous-package*: Internal special variables
*previously-interned-symbols*: Internal special variables
*suspected-constants*: Internal special variables
*suspected-variables*: Internal special variables
*system-base-dir*: Internal special variables

A
additional-dependencies: Exported classes
additional-initargs: Exported classes
additional-initargs: Exported classes

B
base-asd-file: Exported classes
base-pathname: Exported classes

C
children: Internal classes
component: Internal classes
constituents: Internal classes

I
index: Internal classes

L
label: Internal classes
last-grovel-state: Exported classes
load-system: Exported classes

M
merge-systems: Exported classes

N
needs: Internal classes

O
output-file: Exported classes
output-file-type: Exported classes
overridden-dependencies: Exported classes

P
parent: Internal classes
parent: Internal classes
path: Internal classes
position: Internal classes
provisions: Internal classes

S
selfward-operation: Exported classes
sideway-operation: Internal classes
Slot, additional-dependencies: Exported classes
Slot, additional-initargs: Exported classes
Slot, additional-initargs: Exported classes
Slot, base-asd-file: Exported classes
Slot, base-pathname: Exported classes
Slot, children: Internal classes
Slot, component: Internal classes
Slot, constituents: Internal classes
Slot, index: Internal classes
Slot, label: Internal classes
Slot, last-grovel-state: Exported classes
Slot, load-system: Exported classes
Slot, merge-systems: Exported classes
Slot, needs: Internal classes
Slot, output-file: Exported classes
Slot, output-file-type: Exported classes
Slot, overridden-dependencies: Exported classes
Slot, parent: Internal classes
Slot, parent: Internal classes
Slot, path: Internal classes
Slot, position: Internal classes
Slot, provisions: Internal classes
Slot, selfward-operation: Exported classes
Slot, sideway-operation: Internal classes
Slot, summary: Internal classes
Slot, that-depend-on: Internal classes
Slot, translated-name: Exported classes
Slot, translated-pathname: Exported classes
Slot, uses: Internal classes
Slot, verbose: Exported classes
Special Variable, *check-internal-symbols-p*: Internal special variables
Special Variable, *constituent-table*: Internal special variables
Special Variable, *current-constituent*: Internal special variables
Special Variable, *debug-trace*: Internal special variables
Special Variable, *default-component-class*: Internal special variables
Special Variable, *global-mutations*: Internal special variables
Special Variable, *grovel-dir-suffix*: Internal special variables
Special Variable, *macroexpansion-handlers*: Internal special variables
Special Variable, *old-macroexpand-hook*: Internal special variables
Special Variable, *preprocess-form-p*: Internal special variables
Special Variable, *previous-package*: Internal special variables
Special Variable, *previously-interned-symbols*: Internal special variables
Special Variable, *suspected-constants*: Internal special variables
Special Variable, *suspected-variables*: Internal special variables
Special Variable, *system-base-dir*: Internal special variables
summary: Internal classes

T
that-depend-on: Internal classes
translated-name: Exported classes
translated-pathname: Exported classes

U
uses: Internal classes

V
verbose: Exported classes

Jump to:   *  
A   B   C   I   L   M   N   O   P   S   T   U   V  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   A   C   D   F   I   P   S   T  
Index Entry  Section

A
asdf-component-constituent: Internal classes
asdf-dependency-grovel: The asdf-dependency-grovel system
asdf-dependency-grovel: The asdf-dependency-grovel package
asdf-dependency-grovel.lambdas: The asdf-dependency-grovel<dot>lambdas package
asdf-dependency-grovel.packages: The asdf-dependency-grovel<dot>packages package

C
Class, asdf-component-constituent: Internal classes
Class, component-file: Exported classes
Class, constituent: Internal classes
Class, dependency-op: Exported classes
Class, dnode: Internal classes
Class, file-constituent: Internal classes
Class, form-constituent: Internal classes
Class, instrumented-cl-source-file: Exported classes
Class, instrumented-component: Exported classes
Class, instrumented-module: Exported classes
Class, prepare-dependency-op: Internal classes
Class, simple-print-object-mixin: Internal classes
Class, temp-constituent: Internal classes
Class, top-constituent: Internal classes
component-file: Exported classes
constituent: Internal classes

D
dependency-op: Exported classes
dnode: Internal classes

F
file-constituent: Internal classes
form-constituent: Internal classes

I
instrumented-cl-source-file: Exported classes
instrumented-component: Exported classes
instrumented-module: Exported classes

P
Package, asdf-dependency-grovel: The asdf-dependency-grovel package
Package, asdf-dependency-grovel.lambdas: The asdf-dependency-grovel<dot>lambdas package
Package, asdf-dependency-grovel.packages: The asdf-dependency-grovel<dot>packages package
prepare-dependency-op: Internal classes

S
simple-print-object-mixin: Internal classes
System, asdf-dependency-grovel: The asdf-dependency-grovel system

T
temp-constituent: Internal classes
top-constituent: Internal classes

Jump to:   A   C   D   F   I   P   S   T