%scons; %builders-mod; %functions-mod; %tools-mod; %variables-mod; ]> (target[, ...])

Specify default targets to the &SCons; target selection mechanism. Any call to &f-Default; will cause &SCons; to use the defined default target list instead of its built-in algorithm for determining default targets (see the manpage section "Target Selection"). target may be one or more strings, a list of strings, a NodeList as returned by a Builder, or None. A string target may be the name of a file or directory, or a target previously defined by a call to &f-link-Alias; (defining the alias later will still create the alias, but it will not be recognized as a default). Calls to &f-Default; are additive. A target of None will clear any existing default target list; subsequent calls to &f-Default; will add to the (now empty) default target list like normal. Both forms of this call affect the same global list of default targets; the construction environment method applies construction variable expansion to the targets. The current list of targets added using &f-Default; is available in the &DEFAULT_TARGETS; list (see below). Examples: Default('foo', 'bar', 'baz') env.Default(['a', 'b', 'c']) hello = env.Program('hello', 'hello.c') env.Default(hello)

(major, minor)

Ensure that the Python version is at least major.minor. This function will print out an error message and exit SCons with a non-zero exit code if the actual Python version is not late enough. Example: EnsurePythonVersion(2,2)

(major, minor, [revision])

Ensure that the SCons version is at least major.minor, or major.minor.revision. if revision is specified. This function will print out an error message and exit SCons with a non-zero exit code if the actual SCons version is not late enough. Examples: EnsureSConsVersion(0,14) EnsureSConsVersion(0,96,90)

([value])

This tells &scons; to exit immediately with the specified value. A default exit value of 0 (zero) is used if no value is specified.

([vars...], [key=value...])

Exports variables from the current SConscript file to a global collection where they can be imported by other SConscript files. vars may be one or more strings representing variable names to be exported. If a string contains whitespace, it is split into separate strings, as if multiple string arguments had been given. A vars argument may also be a dictionary, which can be used to map variables to different names when exported. Keyword arguments can be used to provide names and their values. &f-Export; calls are cumulative. Specifying a previously exported variable will overwrite the earlier value. Both local variables and global variables can be exported. Examples: env = Environment() # Make env available for all SConscript files to Import(). Export("env") package = 'my_name' # Make env and package available for all SConscript files:. Export("env", "package") # Make env and package available for all SConscript files: Export(["env", "package"]) # Make env available using the name debug: Export(debug=env) # Make env available using the name debug: Export({"debug": env}) Note that the &f-link-SConscript; function supports an &exports; argument that allows exporting a variable or set of variables to a specific SConscript file or files. See the description below.

()

Returns the absolute path name of the directory from which &scons; was initially invoked. This can be useful when using the -u, -U or -D options, which internally change to the directory in which the &SConstruct; file is found.

(text, append=False)

Specifies a local help message to be printed if the -h argument is given to &scons;. Subsequent calls to &f-Help; append text to the previously defined local help text. For the first call to &f-Help; only, if append is False (the default) any local help message generated through &f-link-AddOption; calls is replaced. If append is True, text is appended to the existing help text.

(vars...)

Imports variables into the current SConscript file. vars must be strings representing names of variables which have been previously exported either by the &f-link-Export; function or by the &exports; argument to &f-link-SConscript;. Variables exported by &f-SConscript; take precedence. Multiple variable names can be passed to &f-Import; as separate arguments or as words in a space-separated string. The wildcard "*" can be used to import all available variables. Examples: Import("env") Import("env", "variable") Import(["env", "variable"]) Import("*")

([vars..., stop=True])

Return to the calling SConscript, optionally returning the values of variables named in vars. Multiple strings contaning variable names may be passed to &f-Return;. A string containing white space is split into individual variable names. Returns the value if one variable is specified, else returns a tuple of values. Returns an empty tuple if vars is omitted. By default &Return; stops processing the current SConscript and returns immediately. The optional stop keyword argument may be set to a false value to continue processing the rest of the SConscript file after the &f-Return; call (this was the default behavior prior to SCons 0.98.) However, the values returned are still the values of the variables in the named vars at the point &f-Return; was called. Examples: # Returns no values (evaluates False) Return() # Returns the value of the 'foo' Python variable. Return("foo") # Returns the values of the Python variables 'foo' and 'bar'. Return("foo", "bar") # Returns the values of Python variables 'val1' and 'val2'. Return('val1 val2')

(scripts, [exports, variant_dir, duplicate, must_exist]) (dirs=subdirs, [name=script, exports, variant_dir, duplicate, must_exist])

Execute one or more subsidiary SConscript (configuration) files. There are two ways to call the &f-SConscript; function. The first calling style is to explicitly specify one or more scripts as the first argument. A single script may be specified as a string; multiple scripts must be specified as a list (either explicitly or as created by a function like &f-link-Split;). Examples: SConscript('SConscript') # run SConscript in the current directory SConscript('src/SConscript') # run SConscript in the src directory SConscript(['src/SConscript', 'doc/SConscript']) config = SConscript('MyConfig.py') The second way to call &f-SConscript; is to specify a list of (sub)directory names as a dirs=subdirs keyword argument. In this case, &scons; will execute a subsidiary configuration file named &SConscript; in each of the specified directories. You may specify a name other than &SConscript; by supplying an optional name=script keyword argument. The first three examples below have the same effect as the first three examples above: SConscript(dirs='.') # run SConscript in the current directory SConscript(dirs='src') # run SConscript in the src directory SConscript(dirs=['src', 'doc']) SConscript(dirs=['sub1', 'sub2'], name='MySConscript') The optional exports argument provides a string or list of strings representing variable names, or a dictionary of named values, to export. These variables are locally exported only to the called SConscript file(s) and do not affect the global pool of variables managed by the &f-link-Export; function. The subsidiary SConscript files must use the &f-link-Import; function to import the variables. Examples: foo = SConscript('sub/SConscript', exports='env') SConscript('dir/SConscript', exports=['env', 'variable']) SConscript(dirs='subdir', exports='env variable') SConscript(dirs=['one', 'two', 'three'], exports='shared_info') If the optional variant_dir argument is present, it causes an effect equivalent to the &f-link-VariantDir; function. The variant_dir argument is interpreted relative to the directory of the calling SConscript file. The optional duplicate argument is interpreted as for &f-link-VariantDir;. If variant_dir is omitted, the duplicate argument is ignored. See the description of &f-link-VariantDir; below for additional details and restrictions. If variant_dir is present, the source directory is the directory in which the SConscript file resides and the SConscript file is evaluated as if it were in the variant_dir directory: SConscript('src/SConscript', variant_dir='build') is equivalent to VariantDir('build', 'src') SConscript('build/SConscript') This later paradigm is often used when the sources are in the same directory as the &SConstruct;: SConscript('SConscript', variant_dir='build') is equivalent to VariantDir('build', '.') SConscript('build/SConscript') If the optional must_exist is True, causes an exception to be raised if a requested SConscript file is not found. The current default is False, causing only a warning to be emitted, but this default is deprecated (since 3.1). For scripts which truly intend to be optional, transition to explicitly supplying must_exist=False to the &f-SConscript; call. Here are some composite examples: # collect the configuration information and use it to build src and doc shared_info = SConscript('MyConfig.py') SConscript('src/SConscript', exports='shared_info') SConscript('doc/SConscript', exports='shared_info') # build debugging and production versions. SConscript # can use Dir('.').path to determine variant. SConscript('SConscript', variant_dir='debug', duplicate=0) SConscript('SConscript', variant_dir='prod', duplicate=0) # build debugging and production versions. SConscript # is passed flags to use. opts = { 'CPPDEFINES' : ['DEBUG'], 'CCFLAGS' : '-pgdb' } SConscript('SConscript', variant_dir='debug', duplicate=0, exports=opts) opts = { 'CPPDEFINES' : ['NODEBUG'], 'CCFLAGS' : '-O' } SConscript('SConscript', variant_dir='prod', duplicate=0, exports=opts) # build common documentation and compile for different architectures SConscript('doc/SConscript', variant_dir='build/doc', duplicate=0) SConscript('src/SConscript', variant_dir='build/x86', duplicate=0) SConscript('src/SConscript', variant_dir='build/ppc', duplicate=0) &f-SConscript; returns the values of any variables named by the executed SConscript(s) in arguments to the &f-link-Return; function (see above for details). If a single &f-SConscript; call causes multiple scripts to be executed, the return value is a tuple containing the returns of all of the scripts. If an executed script does not explicitly call &Return;, it returns None.