SCons.Script.SConscript.SConsEnvironment

Package SCons :: Package Script :: Module SConscript :: Class SConsEnvironment

[show private | hide private]

Class SConsEnvironment

SubstitutionEnvironment --+    
                          |    
                       Base --+
                              |
                             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.

Note that not all of the methods of this class have corresponding global functions, there are some private methods.

Method Summary
	`Configure(self, args, *kw)`
	`Default(self, *targets)`
	`EnsurePythonVersion(self, major, minor)` Exit abnormally if the Python version is not late enough.
	`EnsureSConsVersion(self, major, minor, revision)` Exit abnormally if the SCons version is not late enough.
	`Exit(self, value)`
	`Export(self, *vars)`
	`GetLaunchDir(self)`
	`GetOption(self, name)`
	`Help(self, text)`
	`Import(self, *vars)`
	`SConscript(self, ls, *kw)`
	`SConscriptChdir(self, flag)`
	`SetOption(self, name, value)`
	`_exceeds_version(self, major, minor, v_major, v_minor)` Return 1 if 'major' and 'minor' are greater than the version in 'v_major' and 'v_minor', and 0 otherwise.
	`_get_major_minor_revision(self, version_string)` Split a version string into major, minor and (optionally) revision parts.
	`_get_SConscript_filenames(self, ls, kw)` Convert the parameters passed to # SConscript() calls into a list of files and export variables.
Inherited from Base
	`__init__(self, platform, tools, toolpath, options, **kw)` Initialization of a basic SCons construction environment, including setting up special construction variables like BUILDER, PLATFORM, etc., and searching for and applying available Tools.
	`Action(self, args, *kw)`
	`AddPostAction(self, files, action)`
	`AddPreAction(self, files, action)`
	`Alias(self, target, source, action, **kw)`
	`AlwaysBuild(self, *targets)`
	`Append(self, **kw)` Append values to existing construction variables in an Environment.
	`AppendENVPath(self, name, newpath, envname, sep)` Append path elements to the path 'name' in the 'ENV' dictionary for this environment.
	`AppendUnique(self, **kw)` Append values to existing construction variables in an Environment, if they're not already there.
	`BuildDir(self, build_dir, src_dir, duplicate)`
	`Builder(self, **kw)`
	`CacheDir(self, path)`
	`Clean(self, targets, files)`
	`Clone(self, tools, toolpath, **kw)` Return a copy of a construction Environment.
	`Command(self, target, source, action, **kw)` Builds the supplied target files from the supplied source files using the supplied action.
	`Copy(self, args, *kw)`
	`Decider(self, function)`
	`Depends(self, target, dependency)` Explicity specify that 'target's depend on 'dependency'.
	`Detect(self, progs)` Return the first available program in progs.
	`Dictionary(self, *args)`
	`Dir(self, name, args, *kw)`
	`Dump(self, key)` Using the standard Python pretty printer, dump the contents of the scons build environment to stdout.
	`Entry(self, name, args, *kw)`
	`Environment(self, **kw)`
	`Execute(self, action, args, *kw)` Directly execute an action through an Environment
	`File(self, name, args, *kw)`
	`FindFile(self, file, dirs)`
	`FindInstalledFiles(self)` returns the list of all targets of the Install and InstallAs Builder.
	`FindIxes(self, paths, prefix, suffix)` Search a list of paths for something that matches the prefix and suffix.
	`FindSourceFiles(self, node)` returns a list of all source files.
	`Flatten(self, sequence)`
	`get_builder(self, name)` Fetch the builder with the specified name from the environment.
	`get_CacheDir(self)`
	`get_factory(self, factory, default)` Return a factory function for creating Nodes for this construction environment.
	`get_scanner(self, skey)` Find the appropriate scanner given a key (usually a file suffix).
	`get_src_sig_type(self)`
	`get_tgt_sig_type(self)`
	`GetBuildPath(self, files)`
	`Glob(self, pattern, ondisk, source, strings)`
	`Ignore(self, target, dependency)` Ignore a dependency.
	`Literal(self, string)`
	`Local(self, *targets)`
	`NoCache(self, *targets)` Tags a target so that it will not be cached
	`NoClean(self, *targets)` Tags a target so that it will not be cleaned by -c
	`ParseConfig(self, command, function, unique)` Use the specified function to parse the output of the command in order to modify the current environment.
	`ParseDepends(self, filename, must_exist, only_one)` Parse a mkdep-style file for explicit dependencies.
	`Platform(self, platform)`
	`Precious(self, *targets)`
	`Prepend(self, **kw)` Prepend values to existing construction variables in an Environment.
	`PrependENVPath(self, name, newpath, envname, sep)` Prepend path elements to the path 'name' in the 'ENV' dictionary for this environment.
	`PrependUnique(self, **kw)` Append values to existing construction variables in an Environment, if they're not already there.
	`Replace(self, **kw)` Replace existing construction variables in an Environment with new construction variables and/or values.
	`ReplaceIxes(self, path, old_prefix, old_suffix, new_prefix, new_suffix)` Replace old_prefix with new_prefix and old_suffix with new_suffix.
	`Repository(self, dirs, *kw)`
	`Requires(self, target, prerequisite)` Specify that 'prerequisite' must be built before 'target', (but 'target' does not actually depend on 'prerequisite' and need not be rebuilt if it changes).
	`Scanner(self, args, *kw)`
	`scanner_map_delete(self, kw)` Delete the cached scanner map (if we need to).
	`SConsignFile(self, name, dbm_module)`
	`SetDefault(self, **kw)`
	`SideEffect(self, side_effect, target)` Tell scons that side_effects are built as side effects of building targets.
	`SourceCode(self, entry, builder)` Arrange for a source code builder for (part of) a tree.
	`SourceSignatures(self, type)`
	`Split(self, arg)` This function converts a string or list into a list of strings or Nodes.
	`TargetSignatures(self, type)`
	`Tool(self, tool, toolpath, **kw)`
	`Value(self, value, built_value)`
	`WhereIs(self, prog, path, pathext, reject)` Find prog in the path.
	`_changed_build(self, dependency, target, prev_ni)`
	`_changed_content(self, dependency, target, prev_ni)`
	`_changed_source(self, dependency, target, prev_ni)`
	`_changed_timestamp_match(self, dependency, target, prev_ni)`
	`_changed_timestamp_newer(self, dependency, target, prev_ni)`
	`_changed_timestamp_then_content(self, dependency, target, prev_ni)`
	`_copy2_from_cache(self, src, dst)`
	`_copy_from_cache(self, src, dst)`
	`_find_toolpath_dir(self, tp)`
	`_gsm(self)`
	`_update(self, dict)` Update an environment's values directly, bypassing the normal checks that occur when users try to set items.
Inherited from SubstitutionEnvironment
	`__cmp__(self, other)`
	`__delitem__(self, key)`
	`__getitem__(self, key)`
	`__setitem__(self, key, value)`
	`AddMethod(self, function, name)` Adds the specified function as a method of this construction environment with the specified name.
	`arg2nodes(self, args, node_factory, lookup_list, **kw)`
	`backtick(self, command)`
	`get(self, key, default)` Emulates the get() method of dictionaries.
	`gvars(self)`
	`has_key(self, key)`
	`items(self)`
	`lvars(self)`
	`MergeFlags(self, args, unique)` Merge the dict in args into the construction variables.
	`Override(self, overrides)` Produce a modified environment whose variables are overriden by the overrides dictionaries.
	`ParseFlags(self, *flags)` Parse the set of flags and return a dict with the flags placed in the appropriate entry.
	`RemoveMethod(self, function)` Removes the specified function's MethodWrapper from the added_methods list, so we don't re-bind it when making a clone.
	`subst(self, string, raw, target, source, conv)` Recursively interpolates construction variables from the Environment into the specified string, returning the expanded result.
	`subst_kw(self, kw, raw, target, source)`
	`subst_list(self, string, raw, target, source, conv)` Calls through to SCons.Subst.scons_subst_list().
	`subst_path(self, path, target, source)` Substitute a path list, turning EntryProxies into Nodes and leaving Nodes (and other objects) as-is.
	`subst_target_source(self, string, raw, target, source, conv)` Recursively interpolates construction variables from the Environment into the specified string, returning the expanded result.
	`_init_special(self)` Initial the dispatch tables for special handling of special construction variables.

Class Variable Summary
Inherited from Base
`list`	`memoizer_counters` = `[<SCons.Memoize.CountValue instance ...`

Method Details

EnsurePythonVersion(self, major, minor)

Exit abnormally if the Python version is not late enough.

EnsureSConsVersion(self, major, minor, revision=0)

Exit abnormally if the SCons version is not late enough.

_exceeds_version(self, major, minor, v_major, v_minor)

Return 1 if 'major' and 'minor' are greater than the version in 'v_major' and 'v_minor', and 0 otherwise.

_get_major_minor_revision(self, version_string)

Split a version string into major, minor and (optionally) revision parts.

This is complicated by the fact that a version string can be something like 3.2b1.

_get_SConscript_filenames(self, ls, kw)

Convert the parameters passed to # SConscript() calls into a list of files and export variables. If the parameters are invalid, throws SCons.Errors.UserError. Returns a tuple (l, e) where l is a list of SConscript filenames and e is a list of exports.

Generated by Epydoc 2.1 on Wed Dec 12 09:39:32 2007

http://epydoc.sf.net