&SCons; provides a number of platform-independent functions, called factories, that perform common file system manipulations like copying, moving or deleting files and directories, or making directories. These functions are factories because they don't perform the action at the time they're called, they each return an &Action; object that can be executed at the appropriate time.

Suppose you want to arrange to make a copy of a file, and the &Install; builder isn't appropriate because it may make a hard link on POSIX systems. One way would be to use the &Copy; action factory in conjunction with the &Command; builder: Command("file.out", "file.in", Copy("$TARGET", "$SOURCE")) Notice that the action returned by the &Copy; factory will expand the &cv-TARGET; and &cv-SOURCE; strings at the time &file_out; is built, and that the order of the arguments is the same as that of a builder itself--that is, target first, followed by source: % scons -Q Copy("file.out", "file.in") You can, of course, name a file explicitly instead of using &cv-TARGET; or &cv-SOURCE;: Command("file.out", [], Copy("$TARGET", "file.in")) Which executes as: % scons -Q Copy("file.out", "file.in") The usefulness of the &Copy; factory becomes more apparent when you use it in a list of actions passed to the &Command; builder. For example, suppose you needed to run a file through a utility that only modifies files in-place, and can't "pipe" input to output. One solution is to copy the source file to a temporary file name, run the utility, and then copy the modified temporary file to the target, which the &Copy; factory makes extremely easy: Command("file.out", "file.in", [ Copy("tempfile", "$SOURCE"), "modify tempfile", Copy("$TARGET", "tempfile"), ]) The output then looks like: % scons -Q Copy("tempfile", "file.in") modify tempfile Copy("file.out", "tempfile")

If you need to delete a file, then the &Delete; factory can be used in much the same way as the &Copy; factory. For example, if we want to make sure that the temporary file in our last example doesn't exist before we copy to it, we could add &Delete; to the beginning of the command list: Command("file.out", "file.in", [ Delete("tempfile"), Copy("tempfile", "$SOURCE"), "modify tempfile", Copy("$TARGET", "tempfile"), ]) When then executes as follows: % scons -Q Delete("tempfile") Copy("tempfile", "file.in") modify tempfile Copy("file.out", "tempfile") Of course, like all of these &Action; factories, the &Delete; factory also expands &cv-TARGET; and &cv-SOURCE; variables appropriately. For example: Command("file.out", "file.in", [ Delete("$TARGET"), Copy("$TARGET", "$SOURCE") ]) Executes as: % scons -Q Delete("file.out") Copy("file.out", "file.in") (Note, however, that you typically don't need to call the &Delete; factory explicitly in this way; by default, &SCons; deletes its target(s) for you before executing any action.

The &Move; factory allows you to rename a file or directory. For example, if we don't want to copy the temporary file, we could: Command("file.out", "file.in", [ Copy("tempfile", "$SOURCE"), "modify tempfile", Move("$TARGET", "tempfile"), ]) Which would execute as: % scons -Q Copy("tempfile", "file.in") modify tempfile Move("file.out", "tempfile")

If you just need to update the recorded modification time for a file, use the &Touch; factory: Command("file.out", "file.in", [ Copy("tempfile", "$SOURCE"), "modify tempfile", Move("$TARGET", "tempfile"), ]) Which executes as: % scons -Q Copy("tempfile", "file.in") modify tempfile Move("file.out", "tempfile")

If you need to create a directory, use the &Mkdir; factory. For example, if we need to process a file in a temporary directory in which the processing tool will create other files that we don't care about, you could: Command("file.out", "file.in", [ Delete("tempdir"), Mkdir("tempdir"), Copy("tempdir/${SOURCE.file}", "$SOURCE"), "process tempdir", Move("$TARGET", "tempdir/output_file"), Delete("tempdir"), ]) Which executes as: % scons -Q Delete("tempdir") Mkdir("tempdir") Copy("tempdir/file.in", "file.in") process tempdir Move("file.out", "tempdir/output_file") scons: *** [file.out] No such file or directory

To change permissions on a file or directory, use the &Chmod; factory. The permission argument uses POSIX-style permission bits and should typically be expressed as an octal, not decimal, number: Command("file.out", "file.in", [ Copy("$TARGET", "$SOURCE"), Chmod("$TARGET", 0755), ]) Which executes: % scons -Q Copy("file.out", "file.in") Chmod("file.out", 0755)

We've been showing you how to use &Action; factories in the &Command; function. You can also execute an &Action; returned by a factory (or actually, any &Action;) at the time the &SConscript; file is read by wrapping it up in the &Execute; function. For example, if we need to make sure that a directory exists before we build any targets, Execute(Mkdir('/tmp/my_temp_directory')) Notice that this will create the directory while the &SConscript; file is being read: % scons scons: Reading SConscript files ... Mkdir("/tmp/my_temp_directory") scons: done reading SConscript files. scons: Building targets ... scons: `.' is up to date. scons: done building targets. If you're familiar with Python, you may wonder why you would want to use this instead of just calling the native Python os.mkdir() function. The advantage here is that the &Mkdir; action will behave appropriately if the user specifies the &SCons; -n or -q options--that is, it will print the action but not actually make the directory when -n is specified, or make the directory but not print the action when -q is specified.