Module Hierarchy

• SCons: SCons The main package for the SCons software construction utility.
  • Action: SCons.Action This encapsulates information about executing any sort of action that can build one or more target Nodes (typically files) from one or more source Nodes (also typically files) given a specific Environment.
  • Builder: SCons.Builder Builder object subsystem.
  • CacheDir: CacheDir support...
  • compat: SCons compatibility package for old Python versions This subpackage holds modules that provide backwards-compatible implementations of various things that we'd like to use in SCons but which only show up in later versions of Python than the early, old version(s) we still support.
    • builtins: Compatibility idioms for __builtin__ names This module adds names to the __builtin__ module for things that we want to use in SCons but which don't show up until later Python versions than the earliest ones we support.
  • Conftest: SCons.Conftest Autoconf-like configuration support; low level implementation of tests.
  • cpp: SCons C Pre-Processor module...
  • dblite
  • Debug: SCons.Debug Code for debugging SCons internal things.
  • Defaults: SCons.Defaults Builders and other things for the local site.
  • Environment: SCons.Environment Base class for construction Environments.
  • Errors: SCons.Errors This file contains the exception classes used to handle internal and user errors in SCons.
  • Executor: SCons.Executor A module for executing actions with specific lists of target and source Nodes.
  • exitfuncs: SCons.exitfuncs Register functions which are executed when SCons exits for any reason.
  • Job: SCons.Job This module defines the Serial and Parallel classes that execute tasks to complete a build.
  • Memoize: Memoizer A metaclass implementation to count hits and misses of the computed values that various methods cache in memory.
  • Node: SCons.Node The Node package for the SCons software construction utility.
    • Alias: scons.Node.Alias Alias nodes.
    • FS: scons.Node.FS File system nodes.
    • Python: scons.Node.Python Python nodes.
  • PathList: SCons.PathList A module for handling lists of directory paths (the sort of things that get set as CPPPATH, LIBPATH, etc.) with as much caching of data and efficiency as we can while still keeping the evaluation delayed so that we Do the Right Thing (almost) regardless of how the variable is specified.
  • Scanner: SCons.Scanner The Scanner package for the SCons software construction utility.
    • C: SCons.Scanner.C This module implements the depenency scanner for C/C++ code.
    • D: SCons.Scanner.D Scanner for the Digital Mars "D" programming language.
    • Dir
    • Fortran: SCons.Scanner.Fortran This module implements the dependency scanner for Fortran code.
    • IDL: SCons.Scanner.IDL This module implements the depenency scanner for IDL (Interface Definition Language) files.
    • LaTeX: SCons.Scanner.LaTeX This module implements the dependency scanner for LaTeX code.
    • Prog
  • SConf: SCons.SConf Autoconf-like configuration support.
  • SConsign: SCons.SConsign Writing and reading information to the .sconsign file or files.
  • Script: SCons.Script This file implements the main() function used by the scons script.
    • Main: SCons.Script This file implements the main() function used by the scons script.
    • SConscript: SCons.Script.SConscript This module defines the Python API provided to SConscript and SConstruct files.
  • Sig: Place-holder for the old SCons.Sig module hierarchy This is no longer used, but code out there (such as the NSIS module on the SCons wiki) may try to import SCons.Sig.
  • Subst: SCons.Subst SCons string substitution.
  • Taskmaster: Generic Taskmaster module for the SCons build engine.
  • Util: SCons.Util Various utility functions go here.
  • Warnings: SCons.Warnings This file implements the warnings framework for SCons.

Class Hierarchy

• 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.CommandGeneratorAction: Class for command-generator actions.
    • SCons.Action.LazyAction
  • SCons.Action.ListAction: Class for lists of other actions.
• 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.Builder.BuilderBase: Base class for Builders, objects that create output nodes (files) from input nodes (files).
• SCons.Builder.EmitterProxy: This is a callable class that can act as a Builder emitter.
• SCons.CacheDir.CacheDir
• 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.Defaults.Variable_Method_Caller: A class for finding a construction variable on the stack and calling one of its methods.
• SCons.Environment.MethodWrapper: A generic Wrapper class that associates a method (which can actually be any callable) with an object.
  • SCons.Environment.BuilderWrapper: A MethodWrapper subclass that that associates an environment with a Builder.
• SCons.Environment.SubstitutionEnvironment: Base class for different flavors of construction environments.
  • SCons.Environment.Base: Base class for "real" construction Environments.
    • 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.Executor: A class for controlling instances of executing an action.
  • SCons.Executor.Null: A null Executor, with a null build Environment, that does nothing when the rest of the methods call it.
• SCons.Job.Jobs: An instance of this class initializes N jobs, and provides methods for starting, stopping, and waiting on all N jobs.
• 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.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.
• SCons.Job.ThreadPool: This class is responsible for spawning and managing worker threads.
• SCons.Memoize.Counter: Base class for counting memoization hits and misses.
  • SCons.Memoize.CountDict: A counter class for memoized values stored in a dictionary, with keys based on the method's input arguments.
  • SCons.Memoize.CountValue: A counter class for simple, atomic memoized values.
• SCons.Memoize.Memoizer: Object which performs caching of method calls for its 'primary' instance.
• SCons.Node.Attrs
• SCons.Node.BuildInfoBase: The generic base class for build information for a Node.
  • SCons.Node.Alias.AliasBuildInfo
  • SCons.Node.FS.DirBuildInfo
  • SCons.Node.FS.FileBuildInfo
    • SCons.SConf.SConfBuildInfo: Special build info for targets of configure tests.
  • SCons.Node.Python.ValueBuildInfo
• SCons.Node.FS.DiskChecker
• SCons.Node.FS.FileFinder
• SCons.Node.FS.LocalFS
  • SCons.Node.FS.FS
• SCons.Node.Node: The base Node class, for entities that we know how to build, or use to build other Nodes.
  • SCons.Node.Alias.Alias
  • SCons.Node.FS.Base: A generic class for file system entries.
    • SCons.Node.FS.Dir: A class for directories in a file system.
      • SCons.Node.FS.RootDir: A class for the root directory of a file system.
    • 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.
    • SCons.Node.FS.File: A class for files in a file system.
  • 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.Node.NodeInfoBase: The generic base class for signature information for a Node.
  • SCons.Node.Alias.AliasNodeInfo
  • SCons.Node.FS.DirNodeInfo
  • SCons.Node.FS.FileNodeInfo
  • SCons.Node.Python.ValueNodeInfo
• SCons.Node.Walker: An iterator for walking a Node tree.
• SCons.SConf.CheckContext: Provides a context for configure tests.
• SCons.SConf.SConfBase: This is simply a class to represent a configure context.
• SCons.SConf.Streamer: 'Sniffer' for a file-like writable object.
• SCons.SConf.TestWrapper: A wrapper around Tests (to ensure sanity)
• SCons.SConsign.Base: This is the controlling class for the signatures for the collection of entries associated with a specific directory.
  • 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.Dir
    • SCons.SConsign.DirFile: Encapsulates reading and writing a per-directory .sconsign file.
• SCons.SConsign.SConsignEntry: Wrapper class for the generic entry in a .sconsign file.
• SCons.Scanner.Base: The base class for dependency scanners.
  • 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.D.D
      • SCons.Scanner.Fortran.F90Scanner: A Classic Scanner subclass for Fortran source files which takes into account both USE and INCLUDE statements.
      • SCons.Scanner.LaTeX.LaTeX: Class for scanning LaTeX files for included files.
  • SCons.Scanner.Selector: A class for selecting a more specific scanner based on the scanner_key() (suffix) for a specific Node.
• SCons.Scanner.FindPathDirs: A class to bind a specific *PATH variable name to a function that will return all of the *path directories.
• SCons.Script.Main.FakeOptionParser: A do-nothing option parser, used for the initial OptionsParser variable.
• SCons.Script.Main.FakeOptionValues
• SCons.Script.Main.Progressor
• SCons.Script.Main.Stats
  • SCons.Script.Main.CountStats
  • SCons.Script.Main.MemStats
• SCons.Script.Main.TreePrinter
• SCons.Script.SConscript.DefaultEnvironmentCall: A class that implements "global function" calls of Environment methods by fetching the specified method from the DefaultEnvironment's class.
• SCons.Script.SConscript.Frame: A frame on the SConstruct/SConscript call stack
• SCons.Subst.Literal: A wrapper for a string.
• SCons.Subst.NLWrapper: A wrapper class that delays turning a list of sources or targets into a NodeList until it's needed.
• 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.
• SCons.Subst.Target_or_Source: A class that implements $TARGET or $SOURCE expansions by in turn wrapping a NLWrapper.
• SCons.Taskmaster.Stats: A simple class for holding statistics about the disposition of a Node by the Taskmaster.
• SCons.Taskmaster.Task: Default SCons build engine task.
  • SCons.Script.Main.BuildTask: An SCons build task.
  • SCons.Script.Main.CleanTask: An SCons clean task.
  • SCons.Script.Main.QuestionTask: An SCons task for the -q (question) option.
  • SCons.SConf.SConfBuildTask: This is almost the same as SCons.Script.BuildTask.
• SCons.Taskmaster.Taskmaster: The Taskmaster for walking the dependency DAG.
• SCons.Util.DisplayEngine
• SCons.Util.LogicalLines
• SCons.Util.Null: Null objects always and reliably "do nothging."
  • SCons.Sig.MD5Null
  • SCons.CacheDir.Null
  • SCons.Sig.TimeStampNull
• SCons.Util.Proxy: A simple generic Proxy class, forwarding all calls to subject.
  • 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.Node.FS.EntryProxy
• SCons.Util.Unbuffered: A proxy class that wraps a file object, flushing after every write, and delegating everything else to the wrapped object.
• SCons.cpp.FunctionEvaluator: Handles delayed evaluation of a #define function call.
• SCons.cpp.PreProcessor: The main workhorse class for handling C pre-processing.
  • 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.dblite.dblite
• UserDict.UserDict
  • SCons.Node.Alias.AliasNameSpace
  • SCons.Environment.BuilderDict: This is a dictionary-like class used by an Environment to hold the Builders.
  • SCons.Util.OrderedDict
    • SCons.Util.Selector: A callable ordered dictionary that maps file suffixes to dictionary values.
      • SCons.Builder.CallableSelector: A callable dictionary that will, in turn, call the value it finds if it can.
      • SCons.Builder.DictCmdGenerator: This is a callable class that can be used as a command generator function.
      • SCons.Builder.DictEmitter: A callable dictionary that maps file suffixes to emitters.
  • SCons.Builder.OverrideWarner: A class for warning about keyword arguments that we use as overrides in a Builder call.
• UserList.UserList
  • SCons.Util.CallableComposite: A simple composite callable class that, when called, will invoke all of its contained callables with the same arguments.
  • 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.Node.NodeList
  • SCons.Util.NodeList: This class is almost exactly like a regular list of Nodes (actually it can hold any object), with one important difference.
  • SCons.Script.TargetList
  • SCons.Subst.Targets_or_Sources: A class that implements $TARGETS or $SOURCES expansions by in turn wrapping a NLWrapper.
  • SCons.Util.UniqueList
• UserString.UserString
  • SCons.Subst.CmdStringHolder: This is a special class used to hold strings generated by scons_subst() and scons_subst_list().
• __builtin__.object: The most base type
  • exceptions.BaseException: Common base class for all exceptions
    • exceptions.Exception: Common base class for all non-exit exceptions.
      • SCons.Errors.BuildError
      • SCons.Errors.EnvironmentError
      • SCons.Errors.ExplicitExit
      • SCons.Errors.InternalError
      • SCons.Script.SConscript.SConscriptReturn
      • SCons.Script.Main.SConsPrintHelpException
      • SCons.Errors.StopError
      • SCons.Errors.TaskmasterException
      • SCons.Errors.UserError
        • SCons.SConf.SConfError
          • SCons.SConf.ConfigureCacheError: Raised when a use explicitely requested the cache feature, but the test is run the first time.
          • SCons.SConf.ConfigureDryRunError: Raised when a file or directory needs to be updated during a Configure process, but the user requested a dry-run
        • SCons.Warnings.Warning
          • SCons.Warnings.CacheWriteErrorWarning
          • SCons.Warnings.CorruptSConsignWarning
          • SCons.Warnings.DependencyWarning
          • SCons.Warnings.DeprecatedWarning
          • SCons.Warnings.DuplicateEnvironmentWarning
          • SCons.Warnings.MisleadingKeywordsWarning
          • SCons.Warnings.MissingSConscriptWarning
          • SCons.Warnings.NoMD5ModuleWarning
          • SCons.Warnings.NoMetaclassSupportWarning
          • SCons.Warnings.NoObjectCountWarning
          • SCons.Warnings.NoParallelSupportWarning
          • SCons.Warnings.ReservedVariableWarning
          • SCons.SConf.SConfWarning
  • __builtin__.type: type(object) -> the object's type type(name, bases, dict) -> a new type
    • SCons.Memoize.Memoized_Metaclass