# Controlling Removal of Targets

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')
def_env = DefaultEnvironment() def_env.AppendENVPath('PATH', Dir('.')) 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