There are two occasions when &SCons; will,
by default, remove target files.
The first is when &SCons; determines that
an target file needs to be rebuilt
and removes the existing version of the target
before executing
The second is when &SCons; is invoked with the
-c option to "clean"
a tree of its built targets.
These behaviours can be suppressed with the
&Precious; and &NoClean; functions, respectively.
Preventing target removal during build: the &Precious; Function
By default, &SCons; removes targets before building them.
Sometimes, however, this is not what you want.
For example, you may want to update a library incrementally,
not by having it deleted and then rebuilt from all
of the constituent object files.
In such cases, you can use the
&Precious; method to prevent
&SCons; from removing the target before it is built:
env = Environment(RANLIBCOM='')
lib = env.Library('foo', ['f1.c', 'f2.c', 'f3.c'])
env.Precious(lib)
int f1() { }
int f2() { }
int f3() { }
Although the output doesn't look any different,
&SCons; does not, in fact,
delete the target library before rebuilding it:
scons -Q
&SCons; will, however, still delete files marked as &Precious;
when the -c option is used.
Preventing target removal during clean: the &NoClean; Function
By default, &SCons; removes all built targets when invoked
with the -c option to clean a source tree
of built targets.
Sometimes, however, this is not what you want.
For example, you may want to remove only intermediate generated files
(such as object files),
but leave the final targets
(the libraries)
untouched.
In such cases, you can use the &NoClean; method to prevent &SCons;
from removing a target during a clean:
env = Environment(RANLIBCOM='')
lib = env.Library('foo', ['f1.c', 'f2.c', 'f3.c'])
env.NoClean(lib)
int f1() { }
int f2() { }
int f3() { }
Notice that the libfoo.a
is not listed as a removed file:
scons -Q
scons -c
Removing additional files during clean: the &Clean; Function
There may be additional files that you want removed
when the -c option is used,
but which &SCons; doesn't know about
because they're not normal target files.
For example, perhaps a command you invoke
creates a log file as
part of building the target file you want.
You would like the log file cleaned,
but you don't want to have to teach
SCons that the command
"builds" two files.
You can use the &Clean; function to arrange for additional files
to be removed when the -c option is used.
Notice, however, that the &Clean; function takes two arguments,
and the second argument
is the name of the additional file you want cleaned
(foo.log in this example):
t = Command('foo.out', 'foo.in', 'build -o $TARGET $SOURCE')
Clean(t, 'foo.log')
env = DefaultEnvironment()
import os
env['ENV']['PATH'] = env['ENV']['PATH'] + os.pathsep + os.getcwd()
SConscript('S')
foo.in
foo.log
cat $3 > $2
The first argument is the target with which you want
the cleaning of this additional file associated.
In the above example,
we've used the return value from the
&Command; function,
which represents the
foo.out
target.
Now whenever the
foo.out target is cleaned
by the -c option,
the foo.log file
will be removed as well:
scons -Q
scons -Q -c