cmd.Cmd:
A simple framework for writing line-oriented command interpreters.
SCons.Script.Interactive.SConsInteractiveCmd:
build [TARGETS] Build the specified TARGETS and their dependencies. 'b' is a synonym.
clean [TARGETS] Clean (remove) the specified TARGETS and their dependencies. 'c' is a synonym.
exit Exit SCons interactive mode.
help [COMMAND] Prints help for the specified COMMAND. 'h' and '?' are synonyms.
shell [COMMANDLINE] Execute COMMANDLINE in a subshell. 'sh' and '!' are synonyms.
version Prints SCons version information.
SCons.Environment.BuilderDict:
This is a dictionary-like class used by an Environment to hold
the Builders. We need to do this because every time someone changes
the Builders in the Environment's BUILDERS dictionary, we must
update the Environment's attributes.
SCons.Builder.OverrideWarner:
A class for warning about keyword arguments that we use as
overrides in a Builder call.
object:
The most base type
SCons.Action.ActionBase:
Base class for all types of action objects that can be held by
other objects (Builders, Executors, etc.) This provides the
common methods for manipulating and combining those actions.
SCons.Action.LazyAction:
A LazyAction is a kind of hybrid generator and command action for
strings of the form "$VAR". These strings normally expand to other
strings (think "$CCCOM" to "$CC -c -o $TARGET $SOURCE"), but we also
want to be able to replace them with functions in the construction
environment. Consequently, we want lazy evaluation and creation of
an Action in the case of the function, but that's overkill in the more
normal case of expansion to other strings.
SCons.Action.LazyAction:
A LazyAction is a kind of hybrid generator and command action for
strings of the form "$VAR". These strings normally expand to other
strings (think "$CCCOM" to "$CC -c -o $TARGET $SOURCE"), but we also
want to be able to replace them with functions in the construction
environment. Consequently, we want lazy evaluation and creation of
an Action in the case of the function, but that's overkill in the more
normal case of expansion to other strings.
SCons.Action.ActionCaller:
A class for delaying calling an Action function with specific
(positional and keyword) arguments until the Action is actually
executed.
SCons.Action.ActionFactory:
A factory class that will wrap up an arbitrary function
as an SCons-executable Action object.
SCons.Platform.win32.ArchDefinition:
Determine which windows CPU were running on.
A class for defining architecture-specific settings and logic.
SCons.SConsign.Base:
This is the controlling class for the signatures for the collection of
entries associated with a specific directory. The actual directory
association will be maintained by a subclass that is specific to
the underlying storage method. This class provides a common set of
methods for fetching and storing the individual bits of information
that make up signature entry.
SCons.SConsign.DB:
A Base subclass that reads and writes signature information
from a global .sconsign.db* file--the actual file suffix is
determined by the database module.
SCons.SConsign.DirFile:
Encapsulates reading and writing a per-directory .sconsign file.
SCons.Scanner.Base:
The base class for dependency scanners. This implements
straightforward, single-pass scanning of a single file.
SCons.Scanner.Current:
A class for scanning files that are source files (have no builder)
or are derived files and are current (which implies that they exist,
either locally or in a repository).
SCons.Scanner.Classic:
A Scanner subclass to contain the common logic for classic CPP-style
include scanning, but which can be customized to use different
regular expressions to find the includes.
SCons.Scanner.ClassicCPP:
A Classic Scanner subclass which takes into account the type of
bracketing used to include the file, and uses classic CPP rules
for searching for the files based on the bracketing.
SCons.Scanner.Fortran.F90Scanner:
A Classic Scanner subclass for Fortran source files which takes
into account both USE and INCLUDE statements. This scanner will
work for both F77 and F90 (and beyond) compilers.
SCons.Node.DeciderNeedsNode:
Indicate that the decider needs the node as well as the target and the dependency.
Normally the node and the target are the same, but in the case of repository
They may be different. Also the NodeInfo is retrieved from the node
exceptions.StandardError:
Base class for all standard Python exceptions that do not represent
interpreter exiting.
exceptions.AttributeError:
Attribute not found.
SCons.Node.FS.EntryProxyAttributeError:
An AttributeError subclass for recording and displaying the name
of the underlying Entry involved in an AttributeError exception.
exceptions.EnvironmentError:
Base class for I/O related errors.
SCons.SConf.SConfBuildInfo:
Special build info for targets of configure tests. Additional members
are result (did the builder succeed last time?) and string, which
contains messages of the original build phase.
SCons.Util.NodeList:
This class is almost exactly like a regular list of Nodes
(actually it can hold any object), with one important difference.
If you try to get an attribute from this list, it will return that
attribute from every item in the list. For example:
SCons.Executor.TSList:
A class that implements $TARGETS or $SOURCES expansions by wrapping
an executor Method. This class is used in the Executor.lvars()
to delay creation of NodeList objects until they're needed.
SCons.Subst.Targets_or_Sources:
A class that implements $TARGETS or $SOURCES expansions by in turn
wrapping a NLWrapper. This class handles the different methods used
to access the list, calling the NLWrapper to create proxies on demand.
SCons.Subst.CmdStringHolder:
This is a special class used to hold strings generated by
scons_subst() and scons_subst_list(). It defines a special method
escape(). When passed a function with an escape algorithm for a
particular platform, it will return the contained string with the
proper escape sequences inserted.
SCons.Script.SConscript'.DefaultEnvironmentCall:
A class that implements "global function" calls of
Environment methods by fetching the specified method from the
DefaultEnvironment's class. Note that this uses an intermediate
proxy class instead of calling the DefaultEnvironment method
directly so that the proxy can override the subst() method and
thereby prevent expansion of construction variables (since from
the user's point of view this was called as a global function,
with no associated construction environment).
SCons.Util.Delegate:
A Python Descriptor class that delegates attribute fetches
to an underlying wrapped subject of a Proxy. Typical use:
SCons.Builder.EmitterProxy:
This is a callable class that can act as a
Builder emitter. It holds on to a string that
is a key into an Environment dictionary, and will
look there at actual build time to see if it holds
a callable. If so, we will call that as the actual
emitter.
SCons.Util.NodeList:
This class is almost exactly like a regular list of Nodes
(actually it can hold any object), with one important difference.
If you try to get an attribute from this list, it will return that
attribute from every item in the list. For example:
SCons.Executor.TSList:
A class that implements $TARGETS or $SOURCES expansions by wrapping
an executor Method. This class is used in the Executor.lvars()
to delay creation of NodeList objects until they're needed.
SCons.Subst.Targets_or_Sources:
A class that implements $TARGETS or $SOURCES expansions by in turn
wrapping a NLWrapper. This class handles the different methods used
to access the list, calling the NLWrapper to create proxies on demand.
SCons.Subst.CmdStringHolder:
This is a special class used to hold strings generated by
scons_subst() and scons_subst_list(). It defines a special method
escape(). When passed a function with an escape algorithm for a
particular platform, it will return the contained string with the
proper escape sequences inserted.
SCons.Job.Jobs:
An instance of this class initializes N jobs, and provides
methods for starting, stopping, and waiting on all N jobs.
SCons.Subst.Literal:
A wrapper for a string. If you use this object wrapped
around a string, then it will be interpreted as literal.
When passed to the command interpreter, all special
characters will be escaped.
SCons.Node.FS.LocalFS:
This class implements an abstraction layer for operations involving
a local file system. Essentially, this wraps any function in
the os, os.path or shutil modules that we use to actually go do
anything with or to the local file system.
SCons.Environment.MethodWrapper:
A generic Wrapper class that associates a method (which can
actually be any callable) with an object. As part of creating this
MethodWrapper object an attribute with the specified (by default,
the name of the supplied method) is added to the underlying object.
When that new "method" is called, our __call__() method adds the
object as the first argument, simulating the Python behavior of
supplying "self" on method calls.
SCons.Subst.NLWrapper:
A wrapper class that delays turning a list of sources or targets
into a NodeList until it's needed. The specified function supplied
when the object is initialized is responsible for turning raw nodes
into proxies that implement the special attributes like .abspath,
.source, etc. This way, we avoid creating those proxies just
"in case" someone is going to use $TARGET or the like, and only
go through the trouble if we really have to.
SCons.Node.Node:
The base Node class, for entities that we know how to
build, or use to build other Nodes.
SCons.Node.FS.Base:
A generic class for file system entries. This class is for
when we don't know yet whether the entry being looked up is a file
or a directory. Instances of this class can morph into either
Dir or File objects by a later, more precise lookup.
SCons.Node.FS.Entry:
This is the class for generic Node.FS entries--that is, things
that could be a File or a Dir, but we're just not sure yet.
Consequently, the methods in this class really exist just to
transform their associated object into the right class when the
time comes, and then call the same-named method in the transformed
class.
SCons.Node.Python.Value:
A class for Python variables, typically passed on the command line
or generated by a script, but not from a file or some other source.
SCons.Defaults.NullCmdGenerator:
This is a callable class that can be used in place of other
command generators if you don't want them to do anything.
SCons.Job.Parallel:
This class is used to execute tasks in parallel, and is somewhat
less efficient than Serial, but is appropriate for parallel builds.
SCons.cpp.DumbPreProcessor:
A preprocessor that ignores all #if/#elif/#else/#endif directives
and just reports back all of the #include files (like the classic
SCons scanner did).
SCons.Util.Proxy:
A simple generic Proxy class, forwarding all calls to
subject. So, for the benefit of the python newbie, what does
this really mean? Well, it means that you can take an object, let's
call it 'objA', and wrap it in this Proxy class, with a statement
like this
SCons.Builder.CompositeBuilder:
A Builder Proxy whose main purpose is to always have
a DictCmdGenerator as its action, and to provide access
to the DictCmdGenerator's add_action() method.
SCons.SConf.SConfBase:
This is simply a class to represent a configure context. After
creating a SConf object, you can call any tests. After finished with your
tests, be sure to call the Finish() method, which returns the modified
environment.
Some words about caching: In most cases, it is not necessary to cache
Test results explicitly. Instead, we use the scons dependency checking
mechanism. For example, if one wants to compile a test program
(SConf.TryLink), the compiler is only called, if the program dependencies
have changed. However, if the program could not be compiled in a former
SConf run, we need to explicitly cache this error.
SCons.SConsign.SConsignEntry:
Wrapper class for the generic entry in a .sconsign file.
The Node subclass populates it with attributes as it pleases.
SCons.Job.Serial:
This class is used to execute tasks in series, and is more efficient
than Parallel, but is only appropriate for non-parallel builds. Only
one instance of this class should be in existence at a time.
_abcoll.Sized
_abcoll.Sequence:
All the operations on a read-only sequence.
_abcoll.MutableSequence:
All the operations on a read-only sequence.
UserList.UserList
SCons.Util.CLVar:
A class for command-line construction variables.
SCons.Builder.ListEmitter:
A callable list of emitters that calls each in sequence,
returning the result.
SCons.Util.NodeList:
This class is almost exactly like a regular list of Nodes
(actually it can hold any object), with one important difference.
If you try to get an attribute from this list, it will return that
attribute from every item in the list. For example:
SCons.Executor.TSList:
A class that implements $TARGETS or $SOURCES expansions by wrapping
an executor Method. This class is used in the Executor.lvars()
to delay creation of NodeList objects until they're needed.
SCons.Subst.Targets_or_Sources:
A class that implements $TARGETS or $SOURCES expansions by in turn
wrapping a NLWrapper. This class handles the different methods used
to access the list, calling the NLWrapper to create proxies on demand.
SCons.Subst.CmdStringHolder:
This is a special class used to hold strings generated by
scons_subst() and scons_subst_list(). It defines a special method
escape(). When passed a function with an escape algorithm for a
particular platform, it will return the contained string with the
proper escape sequences inserted.
SCons.Subst.SpecialAttrWrapper:
This is a wrapper for what we call a 'Node special attribute.'
This is any of the attributes of a Node that we can reference from
Environment variable substitution, such as $TARGET.abspath or
$SOURCES[1].filebase. We implement the same methods as Literal
so we can handle special characters, plus a for_signature method,
such that we can return some canonical string during signature
calculation to avoid unnecessary rebuilds.
SCons.Taskmaster.Stats:
A simple class for holding statistics about the disposition of a
Node by the Taskmaster. If we're collecting statistics, each Node
processed by the Taskmaster gets one of these attached, in which case
the Taskmaster records its decision each time it processes the Node.
(Ideally, that's just once per Node.)
SCons.SConf.Streamer:
'Sniffer' for a file-like writable object. Similar to the unix tool tee.
SCons.Environment.Base:
Base class for "real" construction Environments. These are the
primary objects used to communicate dependency and construction
information to the build engine.
SCons.Environment.OverrideEnvironment:
A proxy that overrides variables in a wrapped construction
environment by returning values from an overrides dictionary in
preference to values from the underlying subject environment.
SCons.Script.SConscript'.SConsEnvironment:
An Environment subclass that contains all of the methods that
are particular to the wrapper SCons interface and which aren't
(or shouldn't be) part of the build engine itself.
SCons.Executor.TSObject:
A class that implements $TARGET or $SOURCE expansions by wrapping
an Executor method.
SCons.Subst.Target_or_Source:
A class that implements $TARGET or $SOURCE expansions by in turn
wrapping a NLWrapper. This class handles the different methods used
to access an individual proxy Node, calling the NLWrapper to create
a proxy on demand.
threading.Thread:
A class that represents a thread of control.
SCons.Job.Worker:
A worker thread waits on a task to be posted to its request queue,
dequeues the task, executes it, and posts a tuple including the task
and a boolean indicating whether the task executed successfully.
SCons.dblite.dblite:
Squirrel away references to the functions in various modules
that we'll use when our __del__() method calls our sync() method
during shutdown. We might get destroyed when Python is in the midst
of tearing down the different modules we import in an essentially
arbitrary order, and some of the various modules's global attributes
may already be wiped out from under us.
dict:
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
(key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
d = {}
for k, v in iterable:
d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
in the keyword argument list.
collections.OrderedDict:
Dictionary that remembers insertion order
SCons.Util.Selector:
A callable ordered dictionary that maps file suffixes to
dictionary values. We preserve the order in which items are added
so that get_suffix() calls always return the first suffix added.
SCons.Builder.DictCmdGenerator:
This is a callable class that can be used as a
command generator function. It holds on to a dictionary
mapping file suffixes to Actions. It uses that dictionary
to return the proper action based on the file suffix of
the source file.
SCons.Builder.DictEmitter:
A callable dictionary that maps file suffixes to emitters.
When called, it finds the right emitter in its dictionary for the
suffix of the first source file, and calls that emitter to get the
right lists of targets and sources to return. If there's no emitter
for the suffix in its dictionary, the original target and source are
returned.