Version 4.8.1
Copyright © 2004 - 2024 The SCons Foundation
Released: Mon, 07 Jul 2024 17:17:52 -0700
Table of Contents
Glob
Decider
Function
Decider
Function
$CPPPATH
Construction Variable
Depends
Function
ParseDepends
Function
Ignore
Function
Requires
Function
AlwaysBuild
Function
Environment
Function
subst
Method
DefaultEnvironment
Function
Clone
Method
Replace
Method
SetDefault
Method
Append
Method
AppendUnique
Method
Prepend
Method
PrependUnique
Method
SCONSFLAGS
Environment Variable
GetOption
Function
SetOption
Function
AddOption
Function
variable
=value
Build Variables
UnknownVariables
Function
Install
Builder
Copy
Factory
Delete
Factory
Move
Factory
Touch
Factory
Mkdir
Factory
Chmod
Factory
Execute
Function
SConscript
Call
VariantDir
Function
VariantDir
With an SConscript
File
Glob
with VariantDir
Command
Builder
typedef
--random
Option
EnsurePythonVersion
Function
EnsureSConsVersion
Function
GetSConsVersion
Function
SConscript
Files: the Exit
Function
FindFile
Function
Flatten
Function
GetLaunchDir
Function
SideEffect
Function
--debug=explain
Option
Dump
Method
--tree
Option
--debug=presub
Option
--debug=findlibs
Option
--debug=stacktrace
Option
--taskmastertrace
Option
--debug=prepare
Option
--debug=duplicate
Option
List of Examples
Thank you for taking the time to read about SCons. SCons is a modern software construction tool - a software utility for building software (or other files) and keeping built software up-to-date whenever the underlying input files change.
The most distinctive thing about SCons is that its configuration files are actually scripts, written in the Python programming language. This is in contrast to most alternative build tools, which typically invent a new language to configure the build. SCons still has a learning curve, of course, because you have to know what functions to call to set up your build properly, but the underlying syntax used should be familiar to anyone who has ever looked at a Python script.
Paradoxically, using Python as the configuration file format makes SCons easier for non-programmers to learn than the cryptic languages of other build tools, which are usually invented by programmers for other programmers. This is in no small part due to the consistency and readability that are hallmarks of Python. It just so happens that making a real, live scripting language the basis for the configuration files makes it a snap for more accomplished programmers to do more complicated things with builds, as necessary.
There are a few overriding principles the SCons team tries to follow in the design and implementation.
First and foremost, by default, SCons guarantees a correct build even if it means sacrificing performance a little. We strive to guarantee the build is correct regardless of how the software being built is structured, how it may have been written, or how unusual the tools are that build it.
Given that the build is correct, we try to make SCons build software as quickly as possible. In particular, wherever we may have needed to slow down the default SCons behavior to guarantee a correct build, we also try to make it easy to speed up SCons through optimization options that let you trade off guaranteed correctness in all end cases for a speedier build in the usual cases.
SCons tries to do as much for you out of the box as reasonable, including detecting the right tools on your system and using them correctly to build the software.
In a nutshell, we try hard to make SCons just "do the right thing" and build software correctly, with a minimum of hassles.
This guide intends to coach you how to use SCons effectively and efficiently, by providing a range of examples and usage scenarios. As such it is not exactly a tutorial (as usually those build a single example topic from start to finish), but if you are just starting with SCons it is recommended you step through the first 10 chapters in sequence as this will give a solid grounding in the principles of working with SCons. If you follow that trail, you can feel free to initially skip sections on extending SCons, such as Writing your own Decider Function, and come back to those if the need arises.
The remaining chapters cover more advanced topics that not all build systems will need, and can be used in more of a single-topic way, to read if you find you need that particular information.
It is often useful to keep SCons man page open in a separate browser tab or window to refer to as a complement to this Guide, as the User Guide does not attempt to provide every detail. While this Guide's Appendices A-D do duplicate information that appears in the man page (this is to allow intra-document links to definitions of construction variables, builders, tools and environment methods to work), the rest of the man page is unique content.
SCons is a volunteer-run open source project. As such, the SCons documentation isn't always completely up-to-date with all the available features - somehow it's almost harder to write high quality, easy to use documentation than it is to implement a feature in software. In other words, there may be a lot that SCons can do that isn't yet covered in this User's Guide.
Although this User's Guide may not be as complete as it could be, the development process does emphasize making sure that the SCons man page is kept up-to-date with new features. So if you're trying to figure out how to do something that SCons supports but can't find enough (or any) information here, it would be worth your while to look at the man page to see if the information is covered there. And if you do, maybe you'd even consider contributing a section to the User's Guide so the next person looking for that information won't have to go through the same thing...?
SCons would not exist without a lot of help from a lot of people, many of whom may not even be aware that they helped or served as inspiration. So in no particular order, and at the risk of leaving out someone:
First and foremost, SCons owes a tremendous debt to Bob Sidebotham, the original author of the classic Perl-based Cons tool which Bob first released to the world back around 1996. Bob's work on Cons classic provided the underlying architecture and model of specifying a build configuration using a real scripting language. My real-world experience working on Cons informed many of the design decisions in SCons, including the improved parallel build support, making Builder objects easily definable by users, and separating the build engine from the wrapping interface.
Greg Wilson was instrumental in getting SCons started as a real project when he initiated the Software Carpentry design competition in February 2000. Without that nudge, marrying the advantages of the Cons classic architecture with the readability of Python might have just stayed no more than a nice idea.
The entire SCons team have been absolutely wonderful to work with, and SCons would be nowhere near as useful a tool without the energy, enthusiasm and time people have contributed over the past few years. The "core team" of Chad Austin, Anthony Roach, Bill Deegan, Charles Crain, Steve Leblanc, Greg Noel, Gary Oberbrunner, Greg Spencer and Christoph Wiedemann have been great about reviewing my (and other) changes and catching problems before they get in the code base. Of particular technical note: Anthony's outstanding and innovative work on the tasking engine has given SCons a vastly superior parallel build model; Charles has been the master of the crucial Node infrastructure; Christoph's work on the Configure infrastructure has added crucial Autoconf-like functionality; and Greg has provided excellent support for Microsoft Visual Studio.
Special thanks to David Snopek for contributing his underlying "Autoscons" code that formed the basis of Christoph's work with the Configure functionality. David was extremely generous in making this code available to SCons, given that he initially released it under the GPL and SCons is released under a less-restrictive MIT-style license.
Thanks to Peter Miller for his splendid change management system, Aegis, which has provided the SCons project with a robust development methodology from day one, and which showed me how you could integrate incremental regression tests into a practical development cycle (years before eXtreme Programming arrived on the scene).
And last, thanks to Guido van Rossum for his elegant scripting language, which is the basis not only for the SCons implementation, but for the interface itself.
The best way to contact people involved with SCons, is through the SCons mailing lists.
If you want to ask general questions about how to use SCons
send email to <scons-users@scons.org>
.
If you want to contact the SCons development community directly,
send email to <scons-dev@scons.org>
.
For quicker, informal questions, discussion, etc. the project operated a Discord server at https://discord.gg/bXVpWAy and a Libera.chat IRC channel at https://web.libera.chat/#scons (the former channel at irc.freenode.net is now unused). Certain discussions may also be moved by administrators from mailing list or chat to GitHub Discussions for greater permanence and easier finding.
This chapter will take you through the basic steps of installing SCons so you can use it for your projects. Before that, however, this chapter will also describe the basic steps involved in installing Python on your system, in case that is necessary. Fortunately, both SCons and Python are easy to install on almost any system, and Python already comes installed on many systems.
Because SCons is written in the Python programming language,
you need to have a Python interpreter available on your system
to use SCons.
Before you try to install Python,
check to see if Python is already
available on your system by typing
python -V
(capital 'V')
or
python --version
at your system's command-line prompt.
For Linux/Unix/MacOS/BSD type systems this looks like:
$ python -V
Python 3.9.15
If you get a version like 2.7.x, you may need to try using the name python3 - current SCons no longer works with Python 2.
Note to Windows users: there are a number of different ways Python can be installed or invoked on Windows, it is beyond the scope of this guide to unravel all of them. Some have an additional program called the Python launcher (described, somewhat technically, in PEP 397): try using the command name py instead of python, if that is not available drop back to trying python
C:\>py -V
Python 3.9.15
If Python is not installed on your system,
or is not findable in the current search path,
you will see an error message
stating something like "command not found"
(on UNIX or Linux)
or "'python' is not recognized as an internal
or external command, operable progam or batch file"
(on Windows cmd).
In that case, you need to either install Python
or fix the search path
before you can install SCons.
The link for downloading Python installers (Windows and Mac) from the project's own website is: https://www.python.org/download. There are useful system-specific entries on setup and usage to be found at: https://docs.python.org/3/using
For Linux systems, Python is almost certainly available as a supported package, probably installed by default; this is often preferred over installing by other means as the system package will be built with carefully chosen optimizations, and will be kept up to date with bug fixes and security patches. In fact, the Python project itself does not build installers for Linux for this reason. Many such systems have separate packages for Python 2 and Python 3 - make sure the Python 3 package is installed, as the latest SCons requires it. Building from source may still be a useful option if you need a specific version that is not offered by the distribution you are using.
Recent versions of the Mac no longer come with Python pre-installed; older versions came with a rather out of date version (based on Python 2.7) which is insufficient to run current SCons. The python.org installer can be used on the Mac, but there are also other sources such as MacPorts and Homebrew. The Anaconda installation also comes with a bundled Python.
Windows has even more choices. The Python.org installer is
a traditional .exe
style;
the same software is also released as a Windows application through
the Microsoft Store. Several alternative builds also exist
such as Chocolatey and ActiveState, and, again,
a version of Python comes with Anaconda.
SCons will work with Python 3.6 or later. If you need to install Python and have a choice, we recommend using the most recent Python version available. Newer Python versions have significant improvements that help speed up the performance of SCons.
The recommended way to install SCons is from the Python Package Index (PyPI):
% python -m pip install scons
If you prefer not to install to the Python system location, or do not have privileges to do so, you can add a flag to install to a location specific to your own account and Python version:
% python -m pip install --user scons
For those users using Anaconda or Miniconda, use the conda installer instead, so the scons install location will match the version of Python that system will be using. For example:
% conda install -c conda-forge scons
If you need a specific
version of SCons that is different from the current version,
pip
has a version option
(e.g. python -m pip install scons==3.1.2
),
or you can follow the instructions in the following sections.
SCons does comes pre-packaged for installation on many Linux systems. Check your package installation system to see if there is an up-to-date SCons package available. Many people prefer to install distribution-native packages if available, as they provide a central point for management and updating; however not all distributions update in a timely fashion. During the still-ongoing Python 2 to 3 transition, some distributions may still have two SCons packages available, one which uses Python 2 and one which uses Python 3. Since the latest scons only runs on Python 3, to get the current version you should choose the Python 3 package.
You don't actually need to "install" SCons to use it.
Nor do you need to "build" it, unless you are interested in
producing the SCons documentation, which does use several
tools to produce HTML, PDF and other output formats from
files in the source tree.
All you need to do is
call the scons.py
driver script in a
location that contains an SCons tree, and it will figure out
the rest. You can test that like this:
$ python /path/to/unpacked
/scripts/scons.py --version
To make use of an uninstalled SCons,
the first step is to download either the
scons-4.8.1.tar.gz
or scons-4.8.1.zip
,
which are available from the SCons download page at
https://scons.org/pages/download.html.
There is also a scons-local
bundle you can make
use of. It is arranged a little bit differently, with the idea
that you can include it with your own project if you want people
to be able to do builds without having to download or install SCons.
Finally, you can also use a checkout of the git tree from GitHub
at a location to point to.
Unpack the archive you downloaded,
using a utility like tar
on Linux or UNIX,
or WinZip on Windows.
This will create a directory called
scons-4.8.1
,
usually in your local directory. The driver script
will be in a subdirectory named scripts
,
unless you are using scons-local
,
in which case it will be in the top directory.
Now you only need to call scons.py
by
giving a full or relative path to it in order to use that
SCons version.
Note that instructions for older versions may have suggested
running python setup.py install
to
"build and install" SCons. This is no longer recommended
(in fact, it is not recommended by the wider Python packaging
community for any end-user installations
of Python software). There is a setup.py
file,
but it is only tested and used for the automated procedure which
prepares an SCons bundle for making a release on PyPI,
and even that is not guaranteed to work in future.
In some cases you may need several versions of SCons present on a system at the same time - perhaps you have an older project to build that has not yet been "ported" to a newer SCons version, or maybe you want to test a new SCons release side-by-side with a previous one before switching over. The use of an "uninstalled" package as described in the previous section can be of use for this purpose.
Another approach to multiple versions is to create
Python virtualenvs, and install different SCons versions in each.
A Python virtual environment
is a directory with an isolated set of Python packages,
where packages you install/upgrade/remove inside the
environment do not affect anything outside it,
and those you install/upgrade/remove outside of it
do not affect anything inside it.
In other words, anything you do with pip
in the environment stays in that environment.
The Python standard library provides a module called
venv
for creating these
(https://docs.python.org/e/library/venv.html),
although there are also other tools which provide more precise
control of the setup.
Using a virtualenv can be useful even for a single version of SCons, to gain the advantages of having an isolated environment. It also gets around the problem of not having administrative privileges on a particular system to install a distribution package or use pip to install to a system location, as the virtualenv is completely under your control.
The following outline shows how this could be set up on a Linux/POSIX system (the syntax will be a bit different on Windows):
$ create virtualenv named scons3 $ create virtualenv named scons4 $source scons3/bin/activate
$pip install scons==3.1.2
$deactivate
$source scons4/bin/activate
$pip install scons
$deactivate
$ activate a virtualenv and run 'scons' to use that version
The single most important thing you do when writing a build system for your project is to describe the "what": what you want to build, and which files you want to build it from. And, in fact, simpler builds may need no more. In this chapter, you will see several examples of very simple build configurations using SCons, which will demonstrate how easy SCons makes it to build programs on different types of systems.
Here's the ubiquitous "Hello, World!" program in C:
#include <stdio.h> int main() { printf("Hello, world!\n"); }
And here's how to build it using SCons.
Save the code above into hello.c
,
and enter the following into a file named SConstruct
:
Program('hello.c')
This minimal build file gives
SCons three key pieces of information:
what you want to build (a program);
what you want to call that program (its
base name will be hello
),
and the source file you want it built from
(the hello.c
file).
Program
is a Builder,
an SCons function that you use to instruct
SCons about the "what" of your build.
That's it. Now run the scons command to build the program. On a POSIX-compliant system like Linux or UNIX, you'll see something like:
% scons
scons: Reading SConscript files ...
scons: done reading SConscript files.
scons: Building targets ...
cc -o hello.o -c hello.c
cc -o hello hello.o
scons: done building targets.
On a Windows system with the Microsoft Visual C++ compiler, you'll see something like:
C:\>scons
scons: Reading SConscript files ...
scons: done reading SConscript files.
scons: Building targets ...
cl /Fohello.obj /c hello.c /nologo
link /nologo /OUT:hello.exe hello.obj
embedManifestExeCheck(target, source, env)
scons: done building targets.
Notice that SCons deduced quite a bit here: it figured
out the name of the program to build, including operating
system specific suffixes (hello
or hello.exe
), based off
the basename of the source file; it knows an intermediate
object file should be built (hello.o
or hello.obj
);
and it knows how to build those things using the compiler
that is appropriate on the system you're using.
It was not necessary to instruct SCons about any of those
details.
This is an example of how SCons
makes it easy to write portable software builds.
For the programming languages SCons already knows about, it will mostly just figure it out. Here's the "Hello, World!" example in Fortran:
program hello print *, 'Hello, World!' end program hello
Program('hello', 'hello.f90')
$ scons
scons: Reading SConscript files ...
scons: done reading SConscript files.
scons: Building targets ...
gfortran -o hello.o -c hello.f90
gfortran -o hello hello.o
scons: done building targets.
The Program
builder is only one of
many builders (also called a builder method)
that SCons provides to build different types of files.
Another is the Object
builder method,
which tells SCons to build an object file
from the specified source file:
Object('hello.c')
Now when you run the scons command to build the program,
it will build just the hello.o
object file on a POSIX system:
% scons
scons: Reading SConscript files ...
scons: done reading SConscript files.
scons: Building targets ...
cc -o hello.o -c hello.c
scons: done building targets.
And just the hello.obj
object file
on a Windows system (with the Microsoft Visual C++ compiler):
C:\>scons
scons: Reading SConscript files ...
scons: done reading SConscript files.
scons: Building targets ...
cl /Fohello.obj /c hello.c /nologo
scons: done building targets.
(Note that this guide will not continue to provide duplicate side-by-side POSIX and Windows output for all of the examples. Just keep in mind that, unless otherwise specified, any of the examples should work equally well on both types of systems.)
SCons also makes building with Java extremely easy.
Unlike the Program
and Object
builder methods,
however, the Java
builder method
requires that you specify
the name of a destination directory in which
you want the class files placed,
followed by the source directory
in which the .java
files live:
Java('classes', 'src')
If the src
directory
contains a single hello.java
file,
then the output from running the scons command
would look something like this
(on a POSIX system):
% scons
scons: Reading SConscript files ...
scons: done reading SConscript files.
scons: Building targets ...
javac -d classes -sourcepath src src/hello.java
scons: done building targets.
Java builds will be covered in much more detail,
including building a Java archive (.jar
)
and other types of files,
in Chapter 24, Java Builds.
For cleaning up your build tree, SCons provides a
"clean" mode, selected by the
-c
or --clean
option when you invoke SCons.
SCons selects the same set of targets it would in build mode,
but instead of building, removes them.
That means you can control what is cleaned
in exactly the same way as you control what gets built.
If you build the C example above
and then invoke scons -c
afterwards, the output on POSIX looks like:
%scons
scons: Reading SConscript files ... scons: done reading SConscript files. scons: Building targets ... cc -o hello.o -c hello.c cc -o hello hello.o scons: done building targets. %scons -c
scons: Reading SConscript files ... scons: done reading SConscript files. scons: Cleaning targets ... Removed hello.o Removed hello scons: done cleaning targets.
And the output on Windows looks like:
C:\>scons
scons: Reading SConscript files ... scons: done reading SConscript files. scons: Building targets ... cl /Fohello.obj /c hello.c /nologo link /nologo /OUT:hello.exe hello.obj embedManifestExeCheck(target, source, env) scons: done building targets. C:\>scons -c
scons: Reading SConscript files ... scons: done reading SConscript files. scons: Cleaning targets ... Removed hello.obj Removed hello.exe scons: done cleaning targets.
Notice that SCons changes its output to tell you that it
is Cleaning targets ...
and
done cleaning targets.
If you're used to build systems like Make
you've already figured out that the SConstruct
file
is the SCons equivalent of a Makefile
.
That is, the SConstruct
file is the input file
that SCons reads to control the build.
There is, however, an important difference between
an SConstruct
file and a Makefile
:
the SConstruct
file is actually a Python script.
If you're not already familiar with Python, don't worry.
This User's Guide will introduce you step-by-step
to the relatively small amount of Python you'll
need to know to be able to use SCons effectively.
And Python is very easy to learn.
One aspect of using Python as the
scripting language is that you can put comments
in your SConstruct
file using Python's commenting convention:
everything between a #
character
and the end of the line will be ignored
(unless the character appears inside a string constant).
# Arrange to build the "hello" program. Program("hello.c") # "hello.c" is the source file. Program("#goodbye.c") # the # in "#goodbye" does not indicate a comment
You'll see throughout the remainder of this Guide that being able to use the power of a real scripting language can greatly simplify the solutions to complex requirements of real-world builds.
One important way in which the SConstruct
file is not exactly like a normal Python script,
and is more like a Makefile
,
is that the order in which
the SCons Builder functions are called in
the SConstruct
file
does not
affect the order in which SCons
actually builds the programs and object files
you want it to build.
[1].
In other words, when you call the Program
builder
(or any other builder method),
you're not telling SCons to build
the program at that moment.
Instead, you're telling SCons what you want accomplished,
and it's up to SCons to figure out how to do that, and to
take those steps if/when it's necessary.
you'll learn more about how
SCons decides when building or rebuilding a target
is necessary in Chapter 6, Dependencies, below.
SCons reflects this distinction between
calling a builder method like Program
and actually building the program
by printing the status messages that indicate
when it's "just reading" the SConstruct
file,
and when it's actually building the target files.
This is to make it clear when SCons is
executing the Python statements that make up the SConstruct
file,
and when SCons is actually executing the
commands or other actions to
build the necessary files.
Let's clarify this with an example.
Python has a print
function that
prints a string of characters to the screen.
If you put print
calls around
the calls to the Program
builder method:
print("Calling Program('hello.c')") Program('hello.c') print("Calling Program('goodbye.c')") Program('goodbye.c') print("Finished calling Program()")
Then when you execute SCons,
you will see the output from calling the print
function in between the messages about
reading the SConscript
files,
indicating that is when the
Python statements are being executed:
% scons
scons: Reading SConscript files ...
Calling Program('hello.c')
Calling Program('goodbye.c')
Finished calling Program()
scons: done reading SConscript files.
scons: Building targets ...
cc -o goodbye.o -c goodbye.c
cc -o goodbye goodbye.o
cc -o hello.o -c hello.c
cc -o hello hello.o
scons: done building targets.
Notice that SCons built the goodbye
program first,
even though the "reading SConscript
" output
shows that Program('hello.c')
was called
first in the SConstruct
file.
You've already seen how SCons prints some messages about what it's doing, surrounding the actual commands used to build the software:
C:\>scons
scons: Reading SConscript files ...
scons: done reading SConscript files.
scons: Building targets ...
cl /Fohello.obj /c hello.c /nologo
link /nologo /OUT:hello.exe hello.obj
embedManifestExeCheck(target, source, env)
scons: done building targets.
These messages emphasize the
order in which SCons does its work:
all of the configuration files
(generically referred to as SConscript
files)
are read and executed first,
and only then are the target files built.
Among other benefits, these messages help to distinguish between
errors that occur while the configuration files are read,
and errors that occur while targets are being built.
One drawback, of course, is that these messages clutter the output.
Fortunately, they're easily disabled by using
the -Q
option when invoking SCons:
C:\>scons -Q
cl /Fohello.obj /c hello.c /nologo
link /nologo /OUT:hello.exe hello.obj
embedManifestExeCheck(target, source, env)
So this User's Guide can focus
on what SCons is actually doing,
the -Q
option will be used
to remove these messages from the
output of all the remaining examples in this Guide.
[1] In programming parlance,
the SConstruct
file is
declarative,
meaning you tell SCons what you want done
and let it figure out the order in which to do it,
rather than strictly imperative,
where you specify explicitly the order in
which to do things.
Of course, most builds are more complicated than in the previous chapter. In this chapter, you will learn about builds that incorporate multiple source files, and then about building multiple targets that share some source files.
You've seen that when you call the Program
builder method,
it builds the resulting program with the same
base name as the source file.
That is, the following call to build an
executable program from the hello.c
source file
will build an executable program named hello
on POSIX systems,
and an executable program named hello.exe
on Windows systems:
Program('hello.c')
If you want to build a program with a different base name than the base of the source file name (or even the same name), you simply put the target file name to the left of the source file name:
Program('new_hello', 'hello.c')
SCons requires the target file name first,
followed by the source file name,
so that the order mimics that of an
assignment statement in most programming languages,
including Python:
"target = source files"
. For an
alternative way to supply this information, see
Section 3.6, “Keyword Arguments”.
Now SCons will build an executable program
named new_hello
when run on a POSIX system:
% scons -Q
cc -o hello.o -c hello.c
cc -o new_hello hello.o
And SCons will build an executable program
named new_hello.exe
when run on a Windows system:
C:\>scons -Q
cl /Fohello.obj /c hello.c /nologo
link /nologo /OUT:new_hello.exe hello.obj
embedManifestExeCheck(target, source, env)
You've just seen how to configure SCons to compile a program from a single source file. It's more common, of course, that you'll need to build a program from many input source files, not just one. To do this, you need to put the source files in a Python list (enclosed in square brackets), like so:
Program(['prog.c', 'file1.c', 'file2.c'])
A build of the above example would look like:
% scons -Q
cc -o file1.o -c file1.c
cc -o file2.o -c file2.c
cc -o prog.o -c prog.c
cc -o prog prog.o file1.o file2.o
Notice that SCons
deduces the output program name
from the first source file specified
in the list--that is,
because the first source file was prog.c
,
SCons will name the resulting program prog
(or prog.exe
on a Windows system).
If you want to specify a different program name,
then (as described in the previous section)
you slide the list of source files
over to the right
to make room for the output program file name.
Here is the updated example:
Program('program', ['prog.c', 'file1.c', 'file2.c'])
On Linux, a build of this example would look like:
% scons -Q
cc -o file1.o -c file1.c
cc -o file2.o -c file2.c
cc -o prog.o -c prog.c
cc -o program prog.o file1.o file2.o
Or on Windows:
C:\>scons -Q
cl /Fofile1.obj /c file1.c /nologo
cl /Fofile2.obj /c file2.c /nologo
cl /Foprog.obj /c prog.c /nologo
link /nologo /OUT:program.exe prog.obj file1.obj file2.obj
embedManifestExeCheck(target, source, env)
You can also use the Glob
function to find all files matching a
certain template, using the standard shell pattern matching
characters *
(to match everything),
?
(to match a single character)
and [abc]
to match any of
a
, b
or c
.
[!abc]
is also supported,
to match any character except
a
, b
or c
.
This makes many multi-source-file builds quite easy:
Program('program', Glob('*.c'))
Glob
has powerful capabilities - it matches even if the
file does not currently exist,
but SCons can determine that it would
exist after a build.
You will meet it again reading about
variant directories
(see Chapter 15, Separating Source and Build Trees: Variant Directories)
and repositories
(see Chapter 16, Building From Code Repositories).
You've now seen two ways to specify the source for a program, one with a list of files:
Program('hello', ['file1.c', 'file2.c'])
And one with a single file:
Program('hello', 'hello.c')
You can actually put a single file name in a list, too, which you might prefer just for the sake of consistency:
Program('hello', ['hello.c'])
SCons functions will accept a single file name in either form. In fact, internally, SCons treats all input as lists of files, but allows you to omit the square brackets to cut down a little on the typing when there's only a single file name.
Although SCons functions are forgiving about whether or not you use a string vs. a list for a single file name, Python itself is more strict about treating lists and strings differently. So where SCons allows either a string or list:
# The following two calls both work correctly: Program('program1', 'program1.c') Program('program2', ['program2.c'])
Trying to do "Python things" that mix strings and lists will cause errors or lead to incorrect results:
common_sources = ['file1.c', 'file2.c'] # THE FOLLOWING IS INCORRECT AND GENERATES A PYTHON ERROR # BECAUSE IT TRIES TO ADD A STRING TO A LIST: Program('program1', common_sources + 'program1.c') # The following works correctly, because it's adding two # lists together to make another list. Program('program2', common_sources + ['program2.c'])
One drawback to the use of a Python list
for source files is that
each file name must be enclosed in quotes
(either single quotes or double quotes).
This can get cumbersome and difficult to read
when the list of file names is long.
Fortunately, SCons and Python provide a number of ways
to make sure that
the SConstruct
file stays easy to read.
To make long lists of file names
easier to deal with, SCons provides a
Split
function
that takes a quoted list of file names,
with the names separated by spaces or other white-space characters,
and turns it into a list of separate file names.
Using the Split
function turns the
previous example into:
Program('program', Split('main.c file1.c file2.c'))
(If you're already familiar with Python,
you'll have realized that this is similar to the
split()
method
of Python string objects..
Unlike the split()
method,
however, the Split
function
does not require a string as input
and will wrap up a single non-string object in a list,
or return its argument untouched if it's already a list.
This comes in handy as a way to make sure
arbitrary values can be passed to SCons functions
without having to check the type of the variable by hand.)
Putting the call to the Split
function
inside the Program
call
can also be a little unwieldy.
A more readable alternative is to
assign the output from the Split
call
to a variable name,
and then use the variable when calling the
Program
function:
src_files = Split('main.c file1.c file2.c') Program('program', src_files)
Lastly, the Split
function
doesn't care how much white space separates
the file names in the quoted string.
This allows you to create lists of file
names that span multiple lines,
which often makes for easier editing:
src_files = Split(""" main.c file1.c file2.c """) Program('program', src_files)
(Note this example uses the Python "triple-quote" syntax, which allows a string to span multiple lines. The three quotes can be either single or double quotes as long as they match.)
SCons also allows you to identify
the output file and input source files
using Python keyword arguments
target
and
source
.
A keyword argument is an argument preceded by an identifier,
of the form name=value
, in a function call.
The usage looks like this example:
src_files = Split('main.c file1.c file2.c') Program(target='program', source=src_files)
Because the keywords explicitly identify what each argument is, the order does not matter and you can reverse it if you prefer:
src_files = Split('main.c file1.c file2.c') Program(source=src_files, target='program')
Whether or not you choose to use keyword arguments to identify the target and source files, and the order in which you specify them when using keywords, are purely personal choices; SCons functions the same regardless.
In order to compile multiple programs
within the same SConstruct
file,
simply call the Program
method
multiple times,
once for each program you need to build:
Program('foo.c') Program('bar', ['bar1.c', 'bar2.c'])
SCons would then build the programs as follows:
% scons -Q
cc -o bar1.o -c bar1.c
cc -o bar2.o -c bar2.c
cc -o bar bar1.o bar2.o
cc -o foo.o -c foo.c
cc -o foo foo.o
Notice that SCons does not necessarily build the
programs in the same order in which you specify
them in the SConstruct
file.
SCons does, however, recognize that
the individual object files must be built
before the resulting program can be built.
(This will be covered in greater detail in
Chapter 6, Dependencies, below.)
It's common to re-use code by sharing source files between multiple programs. One way to do this is to create a library from the common source files, which can then be linked into resulting programs. (Creating libraries is discussed in Chapter 4, Building and Linking with Libraries, below.)
A more straightforward, but perhaps less convenient, way to share source files between multiple programs is simply to include the common files in the lists of source files for each program:
Program(Split('foo.c common1.c common2.c')) Program('bar', Split('bar1.c bar2.c common1.c common2.c'))
SCons recognizes that the object files for
the common1.c
and common2.c
source files
each need to be built only once,
even though the resulting object files are
each linked in to both of the resulting executable programs:
% scons -Q
cc -o bar1.o -c bar1.c
cc -o bar2.o -c bar2.c
cc -o common1.o -c common1.c
cc -o common2.o -c common2.c
cc -o bar bar1.o bar2.o common1.o common2.o
cc -o foo.o -c foo.c
cc -o foo foo.o common1.o common2.o
If two or more programs
share a lot of common source files,
repeating the common files in the list for each program
can be a maintenance problem when you need to change the
list of common files.
You can simplify this by creating a separate Python list
to hold the common file names,
and concatenating it with other lists
using the Python +
operator:
common = ['common1.c', 'common2.c'] foo_files = ['foo.c'] + common bar_files = ['bar1.c', 'bar2.c'] + common Program('foo', foo_files) Program('bar', bar_files)
This is functionally equivalent to the previous example.
It's often useful to organize large software projects by collecting parts of the software into one or more libraries. SCons makes it easy to create libraries and to use them in the programs.
You build your own libraries by specifying Library
instead of Program
:
Library('foo', ['f1.c', 'f2.c', 'f3.c'])
SCons uses the appropriate library prefix and suffix for your system. So on POSIX or Linux systems, the above example would build as follows (although ranlib may not be called on all systems):
% scons -Q
cc -o f1.o -c f1.c
cc -o f2.o -c f2.c
cc -o f3.o -c f3.c
ar rc libfoo.a f1.o f2.o f3.o
ranlib libfoo.a
On a Windows system, a build of the above example would look like:
C:\>scons -Q
cl /Fof1.obj /c f1.c /nologo
cl /Fof2.obj /c f2.c /nologo
cl /Fof3.obj /c f3.c /nologo
lib /nologo /OUT:foo.lib f1.obj f2.obj f3.obj
The rules for the target name of the library are similar to those for programs: if you don't explicitly specify a target library name, SCons will deduce one from the name of the first source file specified, and SCons will add an appropriate file prefix and suffix if you leave them off.
The previous example shows building a library from a
list of source files.
You can, however, also give the Library
call
object files,
and it will correctly realize they are object files.
In fact, you can arbitrarily mix source code files
and object files in the source list:
Library('foo', ['f1.c', 'f2.o', 'f3.c', 'f4.o'])
And SCons realizes that only the source code files must be compiled into object files before creating the final library:
% scons -Q
cc -o f1.o -c f1.c
cc -o f3.o -c f3.c
ar rc libfoo.a f1.o f2.o f3.o f4.o
ranlib libfoo.a
Of course, in this example, the object files must already exist for the build to succeed. See Chapter 5, Node Objects, below, for information about how you can build object files explicitly and include the built files in a library.
The Library
function builds a traditional static library.
If you want to be explicit about the type of library being built,
you can use the synonym StaticLibrary
function
instead of Library
:
StaticLibrary('foo', ['f1.c', 'f2.c', 'f3.c'])
There is no functional difference between the
StaticLibrary
and Library
functions.
If you want to build a shared library (on POSIX systems)
or a DLL file (on Windows systems),
you use the SharedLibrary
function:
SharedLibrary('foo', ['f1.c', 'f2.c', 'f3.c'])
The output on POSIX:
% scons -Q
cc -o f1.os -c f1.c
cc -o f2.os -c f2.c
cc -o f3.os -c f3.c
cc -o libfoo.so -shared f1.os f2.os f3.os
And the output on Windows:
C:\>scons -Q
cl /Fof1.obj /c f1.c /nologo
cl /Fof2.obj /c f2.c /nologo
cl /Fof3.obj /c f3.c /nologo
link /nologo /dll /out:foo.dll /implib:foo.lib f1.obj f2.obj f3.obj
RegServerFunc(target, source, env)
embedManifestDllCheck(target, source, env)
Notice again that SCons takes care of
building the output file correctly,
adding the -shared
option
for a POSIX compilation,
and the /dll
option on Windows.
Usually, you build a library
because you want to link it with one or more programs.
You link libraries with a program by specifying
the libraries in the $LIBS
construction variable,
and by specifying the directory in which
the library will be found in the
$LIBPATH
construction variable:
Library('foo', ['f1.c', 'f2.c', 'f3.c']) Program('prog.c', LIBS=['foo', 'bar'], LIBPATH='.')
Notice, of course, that you don't need to specify a library
prefix (like lib
)
or suffix (like .a
or .lib
).
SCons uses the correct prefix or suffix for the current system.
On a POSIX or Linux system, a build of the above example would look like:
% scons -Q
cc -o f1.o -c f1.c
cc -o f2.o -c f2.c
cc -o f3.o -c f3.c
ar rc libfoo.a f1.o f2.o f3.o
ranlib libfoo.a
cc -o prog.o -c prog.c
cc -o prog prog.o -L. -lfoo -lbar
On a Windows system, a build of the above example would look like:
C:\>scons -Q
cl /Fof1.obj /c f1.c /nologo
cl /Fof2.obj /c f2.c /nologo
cl /Fof3.obj /c f3.c /nologo
lib /nologo /OUT:foo.lib f1.obj f2.obj f3.obj
cl /Foprog.obj /c prog.c /nologo
link /nologo /OUT:prog.exe /LIBPATH:. foo.lib bar.lib prog.obj
embedManifestExeCheck(target, source, env)
As usual, notice that SCons has taken care of constructing the correct command lines to link with the specified library on each system.
Note also that, if you only have a single library to link with, you can specify the library name in single string, instead of a Python list, so that:
Program('prog.c', LIBS='foo', LIBPATH='.')
is equivalent to:
Program('prog.c', LIBS=['foo'], LIBPATH='.')
This is similar to the way that SCons handles either a string or a list to specify a single source file.
By default, the linker will only look in
certain system-defined directories for libraries.
SCons knows how to look for libraries
in directories that you specify with the
$LIBPATH
construction variable.
$LIBPATH
consists of a list of
directory names, like so:
Program('prog.c', LIBS = 'm', LIBPATH = ['/usr/lib', '/usr/local/lib'])
Using a Python list is preferred because it's portable across systems. Alternatively, you could put all of the directory names in a single string, separated by the system-specific path separator character: a colon on POSIX systems:
LIBPATH = '/usr/lib:/usr/local/lib'
or a semi-colon on Windows systems:
LIBPATH = 'C:\\lib;D:\\lib'
(Note that Python requires that the backslash separators in a Windows path name be escaped within strings.)
When the linker is executed, SCons will create appropriate flags so that the linker will look for libraries in the same directories as SCons. So on a POSIX or Linux system, a build of the above example would look like:
% scons -Q
cc -o prog.o -c prog.c
cc -o prog prog.o -L/usr/lib -L/usr/local/lib -lm
On a Windows system, a build of the above example would look like:
C:\>scons -Q
cl /Foprog.obj /c prog.c /nologo
link /nologo /OUT:prog.exe /LIBPATH:\usr\lib /LIBPATH:\usr\local\lib m.lib prog.obj
embedManifestExeCheck(target, source, env)
Note again that SCons has taken care of the system-specific details of creating the right command-line options.
Internally, SCons represents all of the files
and directories it knows about as Nodes.
These internal objects
(not object files)
can be used in a variety of ways
to make your SConscript
files portable and easy to read.
All builder methods return a list of
Node
objects that identify the
target file or files that will be built.
These returned Nodes can be passed
as arguments to other builder methods.
For example, suppose that we want to build
the two object files that make up a program with different options.
This would mean calling the Object
builder once for each object file,
specifying the desired options:
Object('hello.c', CCFLAGS='-DHELLO') Object('goodbye.c', CCFLAGS='-DGOODBYE')
One way to combine these object files
into the resulting program
would be to call the Program
builder with the names of the object files
listed as sources:
Object('hello.c', CCFLAGS='-DHELLO') Object('goodbye.c', CCFLAGS='-DGOODBYE') Program(['hello.o', 'goodbye.o'])
The problem with specifying the names as strings
is that our SConstruct
file is no longer portable
across operating systems.
It won't, for example, work on Windows
because the object files there would be
named hello.obj
and goodbye.obj
,
not hello.o
and goodbye.o
.
A better solution is to assign the lists of targets
returned by the calls to the Object
builder to variables,
which we can then concatenate in our
call to the Program
builder:
hello_list = Object('hello.c', CCFLAGS='-DHELLO') goodbye_list = Object('goodbye.c', CCFLAGS='-DGOODBYE') Program(hello_list + goodbye_list)
This makes our SConstruct
file portable again,
the build output on Linux looking like:
% scons -Q
cc -o goodbye.o -c -DGOODBYE goodbye.c
cc -o hello.o -c -DHELLO hello.c
cc -o hello hello.o goodbye.o
And on Windows:
C:\>scons -Q
cl /Fogoodbye.obj /c goodbye.c -DGOODBYE
cl /Fohello.obj /c hello.c -DHELLO
link /nologo /OUT:hello.exe hello.obj goodbye.obj
embedManifestExeCheck(target, source, env)
We'll see examples of using the list of nodes returned by builder methods throughout the rest of this guide.
It's worth mentioning here that
SCons maintains a clear distinction
between Nodes that represent files
and Nodes that represent directories.
SCons supports File
and Dir
functions that, respectively,
return a file or directory Node:
hello_c = File('hello.c') Program(hello_c) classes = Dir('classes') Java(classes, 'src')
Normally, you don't need to call
File
or Dir
directly,
because calling a builder method automatically
treats strings as the names of files or directories,
and translates them into
the Node objects for you.
The File
and Dir
functions can come in handy
in situations where you need to explicitly
instruct SCons about the type of Node being
passed to a builder or other function,
or unambiguously refer to a specific
file in a directory tree.
There are also times when you may need to
refer to an entry in a file system
without knowing in advance
whether it's a file or a directory.
For those situations,
SCons also supports an Entry
function,
which returns a Node
that can represent either a file or a directory.
xyzzy = Entry('xyzzy')
The returned xyzzy
Node
will be turned into a file or directory Node
the first time it is used by a builder method
or other function that
requires one vs. the other.
One of the most common things you can do
with a Node is use it to print the
file name that the node represents.
Keep in mind, though, that because the object
returned by a builder call
is a list of Nodes,
you must use Python subscripts
to fetch individual Nodes from the list.
For example, the following SConstruct
file:
object_list = Object('hello.c') program_list = Program(object_list) print("The object file is: %s"%object_list[0]) print("The program file is: %s"%program_list[0])
Would print the following file names on a POSIX system:
% scons -Q
The object file is: hello.o
The program file is: hello
cc -o hello.o -c hello.c
cc -o hello hello.o
And the following file names on a Windows system:
C:\>scons -Q
The object file is: hello.obj
The program file is: hello.exe
cl /Fohello.obj /c hello.c /nologo
link /nologo /OUT:hello.exe hello.obj
embedManifestExeCheck(target, source, env)
Note that in the above example,
the object_list[0]
extracts an actual Node object
from the list,
and the Python print
function
converts the object to a string for printing.
Printing a Node
's name
as described in the previous section
works because the string representation of a Node
object
is the name of the file.
If you want to do something other than
print the name of the file,
you can fetch it by using the builtin Python
str
function.
For example, if you want to use the Python
os.path.exists
to figure out whether a file
exists while the SConstruct
file
is being read and executed,
you can fetch the string as follows:
import os.path program_list = Program('hello.c') program_name = str(program_list[0]) if not os.path.exists(program_name): print("%s does not exist!"%program_name)
Which executes as follows on a POSIX system:
% scons -Q
hello does not exist!
cc -o hello.o -c hello.c
cc -o hello hello.o
env.GetBuildPath(file_or_list)
returns the path of a Node
or a string representing a
path. It can also take a list of Node
s and/or strings, and
returns the list of paths. If passed a single Node
, the result
is the same as calling str(node)
(see above).
The string(s) can have embedded construction variables, which are
expanded as usual, using the calling environment's set of
variables. The paths can be files or directories, and do not have
to exist.
env=Environment(VAR="value") n=File("foo.c") print(env.GetBuildPath([n, "sub/dir/$VAR"]))
Would print the following file names:
% scons -Q
['foo.c', 'sub/dir/value']
scons: `.' is up to date.
There is also a function version of GetBuildPath
which can
be called without an Environment
; that uses the default SCons
Environment
to do substitution on any string arguments.
So far we've seen how SCons handles one-time builds.
But one of the main functions of a build tool like SCons
is to rebuild only what is necessary
when source files change--or, put another way,
SCons should not
waste time rebuilding things that don't need to be rebuilt.
You can see this at work simply by re-invoking SCons
after building our simple hello
example:
%scons -Q
cc -o hello.o -c hello.c cc -o hello hello.o %scons -Q
scons: `.' is up to date.
The second time it is executed,
SCons realizes that the hello
program
is up-to-date with respect to the current hello.c
source file,
and avoids rebuilding it.
You can see this more clearly by naming
the hello
program explicitly on the command line:
%scons -Q hello
cc -o hello.o -c hello.c cc -o hello hello.o %scons -Q hello
scons: `hello' is up to date.
Note that SCons reports "...is up to date"
only for target files named explicitly on the command line,
to avoid cluttering the output.
Another aspect of avoiding unnecessary rebuilds is the fundamental build tool behavior of rebuilding things when an input file changes, so that the built software is up to date. By default, SCons keeps track of this through a content signature, or hash, of the contents of each file, although you can easily configure SCons to use the modification times (or time stamps) instead. You can even write your own Python function for deciding if an input file should trigger a rebuild.
By default, SCons uses a cryptographic hash of the file's contents, not the file's modification time, to decide whether a file has changed. This means that you may be surprised by the default SCons behavior if you are used to the Make convention of forcing a rebuild by updating the file's modification time (using the touch command, for example):
%scons -Q hello
cc -o hello.o -c hello.c cc -o hello hello.o %touch hello.c
%scons -Q hello
scons: `hello' is up to date.
Even though the file's modification time has changed,
SCons realizes that the contents of the
hello.c
file have not changed,
and therefore that the hello
program
need not be rebuilt.
This avoids unnecessary rebuilds when,
for example, someone rewrites the
contents of a file without making a change.
But if the contents of the file really do change,
then SCons detects the change
and rebuilds the program as required:
%scons -Q hello
cc -o hello.o -c hello.c cc -o hello hello.o % [CHANGE THE CONTENTS OF hello.c] %scons -Q hello
cc -o hello.o -c hello.c cc -o hello hello.o
Note that you can, if you wish,
specify the default behavior of using
content signatures explicitly,
using the Decider
function as follows:
Program('hello.c') Decider('content')
You can also use the string 'MD5'
as a synonym for 'content'
when calling the Decider
function - this older
name is deprecated since SCons now supports a
choice of hash functions, not just the MD5 function.
Using content signatures to decide if an input file has changed has one surprising benefit: if a source file has been changed in such a way that the contents of the rebuilt target file(s) will be exactly the same as the last time the file was built, then any "downstream" target files that depend on the rebuilt-but-not-changed target file actually need not be rebuilt.
So if, for example,
a user were to only change a comment in a hello.c
file,
then the rebuilt hello.o
file
would be exactly the same as the one previously built
(assuming the compiler doesn't put any build-specific
information in the object file).
SCons would then realize that it would not
need to rebuild the hello
program as follows:
%scons -Q hello
cc -o hello.o -c hello.c cc -o hello hello.o % [CHANGE A COMMENT IN hello.c] %scons -Q hello
cc -o hello.o -c hello.c scons: `hello' is up to date.
In essence, SCons
"short-circuits" any dependent builds
when it realizes that a target file
has been rebuilt to exactly the same file as the last build.
This does take some extra processing time
to read the contents of the target (hello.o
) file,
but often saves time when the rebuild that was avoided
would have been time-consuming and expensive.
If you prefer, you can configure SCons to use the modification time of a file, not the file contents, when deciding if a target needs to be rebuilt. SCons gives you two ways to use time stamps to decide if an input file has changed since the last time a target has been built.
The most familiar way to use time stamps
is the way Make does:
that is, have SCons decide
that a target must be rebuilt
if a source file's modification time is
newer
than the target file.
To do this, call the Decider
function as follows:
Object('hello.c') Decider('timestamp-newer')
This makes SCons act like Make when a file's modification time is updated (using the touch command, for example):
%scons -Q hello.o
cc -o hello.o -c hello.c %touch hello.c
%scons -Q hello.o
cc -o hello.o -c hello.c
And, in fact, because this behavior is the same
as the behavior of Make,
you can also use the string 'make'
as a synonym for 'timestamp-newer'
when calling the Decider
function:
Object('hello.c') Decider('make')
One drawback to using times stamps exactly like Make is that if an input file's modification time suddenly becomes older than a target file, the target file will not be rebuilt. This can happen if an old copy of a source file is restored from a backup archive, for example. The contents of the restored file will likely be different than they were the last time a dependent target was built, but the target won't be rebuilt because the modification time of the source file is not newer than the target.
Because SCons actually stores information
about the source files' time stamps whenever a target is built,
it can handle this situation by checking for
an exact match of the source file time stamp,
instead of just whether or not the source file
is newer than the target file.
To do this, specify the argument
'timestamp-match'
when calling the Decider
function:
Object('hello.c') Decider('timestamp-match')
When configured this way,
SCons will rebuild a target whenever
a source file's modification time has changed.
So if we use the touch -t
option to change the modification time of
hello.c
to an old date (January 1, 1989),
SCons will still rebuild the target file:
%scons -Q hello.o
cc -o hello.o -c hello.c %touch -t 198901010000 hello.c
%scons -Q hello.o
cc -o hello.o -c hello.c
In general, the only reason to prefer
timestamp-newer
instead of
timestamp-match
,
would be if you have some specific reason
to require this Make-like behavior of
not rebuilding a target when an otherwise-modified
source file is older.
As a performance enhancement,
SCons provides a way to use
a file's content signature,
but to read those contents
only when the file's timestamp has changed.
To do this, call the Decider
function with 'content-timestamp'
argument as follows:
Program('hello.c') Decider('content-timestamp')
So configured, SCons will still behave like
it does when using Decider('content')
:
%scons -Q hello
cc -o hello.o -c hello.c cc -o hello hello.o %touch hello.c
%scons -Q hello
scons: `hello' is up to date. %edit hello.c
[CHANGE THE CONTENTS OF hello.c] %scons -Q hello
cc -o hello.o -c hello.c cc -o hello hello.o
However, the second call to SCons in the above output,
when the build is up-to-date,
will have been performed by simply looking at the
modification time of the hello.c
file,
not by opening it and performing
a signature calcuation on its contents.
This can significantly speed up many up-to-date builds.
The only drawback to using
Decider('content-timestamp')
is that SCons will not
rebuild a target file if a source file was modified
within one second of the last time SCons built the file.
While most developers are programming,
this isn't a problem in practice,
since it's unlikely that someone will have built
and then thought quickly enough to make a substantive
change to a source file within one second.
Certain build scripts or
continuous integration tools may, however,
rely on the ability to apply changes to files
automatically and then rebuild as quickly as possible,
in which case use of
Decider('content-timestamp')
may not be appropriate.
The different string values that we've passed to
the Decider
function are essentially used by SCons
to pick one of several specific internal functions
that implement various ways of deciding if a dependency
(usually a source file)
has changed since a target file has been built.
As it turns out,
you can also supply your own function
to decide if a dependency has changed.
For example, suppose we have an input file
that contains a lot of data,
in some specific regular format,
that is used to rebuild a lot of different target files,
but each target file really only depends on
one particular section of the input file.
We'd like to have each target file depend on
only its section of the input file.
However, since the input file may contain a lot of data,
we want to open the input file only if its timestamp has changed.
This could be done with a custom
Decider
function that might look something like this:
Program('hello.c') def decide_if_changed(dependency, target, prev_ni, repo_node=None): if dependency.get_timestamp() != prev_ni.timestamp: dep = str(dependency) tgt = str(target) if specific_part_of_file_has_changed(dep, tgt): return True return False Decider(decide_if_changed)
Note that in the function definition,
the dependency
(input file) is the first argument,
and then the target
.
Both of these are passed to the functions as
SCons Node
objects,
which we convert to strings using the Python
str()
.
The third argument, prev_ni
,
is an object that holds the
content signature and/or timestamp information
that was recorded about the dependency
the last time the target was built.
A prev_ni
object can hold
different information,
depending on the type of thing that the
dependency
argument represents.
For normal files,
the prev_ni
object
has the following attributes:
csig
The content signature:
a cryptgraphic hash, or checksum, of the file contents
of the dependency
file the last time the target
was built.
size
The size in bytes of the dependency
file the last time the target was built.
timestamp
The modification time of the dependency
file the last time the target
was built.
These attributes may not be present at the time of the
first run. Without any prior build, no targets have been
created and no .sconsign
DB file exists yet.
So you should always check whether the
prev_ni
attribute in question is available
(use the Python hasattr
method or a
try
-except
block).
The fourth argument repo_node
is the Node
to use if it is not None when comparing BuildInfo
.
This is typically only set when the target node only exists in a
Repository
Note that ignoring some of the arguments
in your custom Decider
function
is a perfectly normal thing to do,
if they don't impact the way you want to
decide if the dependency file has changed.
We finally present a small example for a
csig
-based decider function. Note how the
signature information for the dependency
file
has to get initialized via get_csig
during each function call (this is mandatory!).
env = Environment() def config_file_decider(dependency, target, prev_ni, repo_node=None): import os.path # We always have to init the .csig value... dep_csig = dependency.get_csig() # .csig may not exist, because no target was built yet... if not prev_ni.hasattr("csig"): return True # Target file may not exist yet if not os.path.exists(str(target.abspath)): return True if dep_csig != prev_ni.csig: # Some change on source file => update installed one return True return False def update_file(): with open("test.txt", "a") as f: f.write("some line\n") update_file() # Activate our own decider function env.Decider(config_file_decider) env.Install("install", "test.txt")
The previous examples have all demonstrated calling
the global Decider
function
to configure all dependency decisions that SCons makes.
Sometimes, however, you want to be able to configure
different decision-making for different targets.
When that's necessary, you can use the env.Decider
method to affect only the configuration
decisions for targets built with a
specific construction environment.
For example, if we arbitrarily want to build one program using content signatures and another using file modification times from the same source we might configure it this way:
env1 = Environment(CPPPATH = ['.']) env2 = env1.Clone() env2.Decider('timestamp-match') env1.Program('prog-content', 'program1.c') env2.Program('prog-timestamp', 'program2.c')
If both of the programs include the same
inc.h
file,
then updating the modification time of
inc.h
(using the touch command)
will cause only prog-timestamp
to be rebuilt:
%scons -Q
cc -o program1.o -c -I. program1.c cc -o prog-content program1.o cc -o program2.o -c -I. program2.c cc -o prog-timestamp program2.o %touch inc.h
%scons -Q
cc -o program2.o -c -I. program2.c cc -o prog-timestamp program2.o
Now suppose that our "Hello, World!" program
actually has an #include
line
to include the hello.h
file in the compilation:
#include <hello.h> int main() { printf("Hello, %s!\n", string); }
And, for completeness, the hello.h
file looks like this:
#define string "world"
In this case, we want SCons to recognize that,
if the contents of the hello.h
file change,
the hello
program must be recompiled.
To do this, we need to modify the
SConstruct
file like so:
Program('hello.c', CPPPATH='.')
The $CPPPATH
value
tells SCons to look in the current directory
('.'
)
for any files included by C source files
(.c
or .h
files).
With this assignment in the SConstruct
file:
%scons -Q hello
cc -o hello.o -c -I. hello.c cc -o hello hello.o %scons -Q hello
scons: `hello' is up to date. % [CHANGE THE CONTENTS OF hello.h] %scons -Q hello
cc -o hello.o -c -I. hello.c cc -o hello hello.o
First, notice that SCons
constructed the -I.
argument
from the '.'
in the $CPPPATH
variable
so that the compilation would find the
hello.h
file in the local directory.
Second, realize that SCons knows that the hello
program must be rebuilt
because it scans the contents of
the hello.c
file
for the #include
lines that indicate
another file is being included in the compilation.
SCons records these as
implicit dependencies
of the target file,
Consequently,
when the hello.h
file changes,
SCons realizes that the hello.c
file includes it,
and rebuilds the resulting hello
program
that depends on both the hello.c
and hello.h
files.
Like the $LIBPATH
variable,
the $CPPPATH
variable
may be a list of directories,
or a string separated by
the system-specific path separation character
(':' on POSIX/Linux, ';' on Windows).
Either way, SCons creates the
right command-line options
so that the following example:
Program('hello.c', CPPPATH = ['include', '/home/project/inc'])
Will look like this on POSIX or Linux:
% scons -Q hello
cc -o hello.o -c -Iinclude -I/home/project/inc hello.c
cc -o hello hello.o
And like this on Windows:
C:\>scons -Q hello.exe
cl /Fohello.obj /c hello.c /nologo /Iinclude /I\home\project\inc
link /nologo /OUT:hello.exe hello.obj
embedManifestExeCheck(target, source, env)
Scanning each file for #include
lines
does take some extra processing time.
When you're doing a full build of a large system,
the scanning time is usually a very small percentage
of the overall time spent on the build.
You're most likely to notice the scanning time,
however, when you rebuild
all or part of a large system:
SCons will likely take some extra time to "think about"
what must be built before it issues the
first build command
(or decides that everything is up to date
and nothing must be rebuilt).
In practice, having SCons scan files saves time
relative to the amount of potential time
lost to tracking down subtle problems
introduced by incorrect dependencies.
Nevertheless, the "waiting time"
while SCons scans files can annoy
individual developers waiting for their builds to finish.
Consequently, SCons lets you cache
the implicit dependencies
that its scanners find,
for use by later builds.
You can do this by specifying the
--implicit-cache
option on the command line:
%scons -Q --implicit-cache hello
cc -o hello.o -c hello.c cc -o hello hello.o %scons -Q hello
scons: `hello' is up to date.
If you don't want to specify --implicit-cache
on the command line each time,
you can make it the default behavior for your build
by setting the implicit_cache
option
in an SConscript
file:
SetOption('implicit_cache', 1)
SCons does not cache implicit dependencies like this by default
because the --implicit-cache
causes SCons to simply use the implicit
dependencies stored during the last run, without any checking
for whether or not those dependencies are still correct.
Specifically, this means --implicit-cache
instructs SCons
to not rebuild "correctly" in the
following cases:
When --implicit-cache
is used, SCons will ignore any changes that
may have been made to search paths
(like $CPPPATH
or $LIBPATH
,).
This can lead to SCons not rebuilding a file if a change to
$CPPPATH
would normally cause a different, same-named file from
a different directory to be used.
When --implicit-cache
is used, SCons will not detect if a
same-named file has been added to a directory that is earlier in
the search path than the directory in which the file was found
last time.
When using cached implicit dependencies,
sometimes you want to "start fresh"
and have SCons re-scan the files
for which it previously cached the dependencies.
For example,
if you have recently installed a new version of
external code that you use for compilation,
the external header files will have changed
and the previously-cached implicit dependencies
will be out of date.
You can update them by
running SCons with the --implicit-deps-changed
option:
%scons -Q --implicit-deps-changed hello
cc -o hello.o -c hello.c cc -o hello hello.o %scons -Q hello
scons: `hello' is up to date.
In this case, SCons will re-scan all of the implicit dependencies and cache updated copies of the information.
By default when caching dependencies,
SCons notices when a file has been modified
and re-scans the file for any updated
implicit dependency information.
Sometimes, however, you may want
to force SCons to use the cached implicit dependencies,
even if the source files changed.
This can speed up a build for example,
when you have changed your source files
but know that you haven't changed
any #include
lines.
In this case,
you can use the --implicit-deps-unchanged
option:
%scons -Q --implicit-deps-unchanged hello
cc -o hello.o -c hello.c cc -o hello hello.o %scons -Q hello
scons: `hello' is up to date.
In this case, SCons will assume that the cached implicit dependencies are correct and will not bother to re-scan changed files. For typical builds after small, incremental changes to source files, the savings may not be very big, but sometimes every bit of improved performance counts.
Sometimes a file depends on another file
that is not detected by an SCons scanner.
For this situation,
SCons allows you to specific explicitly that one file
depends on another file,
and must be rebuilt whenever that file changes.
This is specified using the Depends
method:
hello = Program('hello.c') Depends(hello, 'other_file')
%scons -Q hello
cc -c hello.c -o hello.o cc -o hello hello.o %scons -Q hello
scons: `hello' is up to date. %edit other_file
[CHANGE THE CONTENTS OF other_file] %scons -Q hello
cc -c hello.c -o hello.o cc -o hello hello.o
Note that the dependency
(the second argument to Depends
)
may also be a list of Node objects
(for example, as returned by a call to a Builder):
hello = Program('hello.c') goodbye = Program('goodbye.c') Depends(hello, goodbye)
in which case the dependency or dependencies will be built before the target(s):
% scons -Q hello
cc -c goodbye.c -o goodbye.o
cc -o goodbye goodbye.o
cc -c hello.c -o hello.o
cc -o hello hello.o
SCons has built-in scanners for a number of languages. Sometimes these scanners fail to extract certain implicit dependencies due to limitations of the scanner implementation.
The following example illustrates a case where the built-in C scanner is unable to extract the implicit dependency on a header file.
#define FOO_HEADER <foo.h> #include FOO_HEADER int main() { return FOO; }
%scons -Q
cc -o hello.o -c -I. hello.c cc -o hello hello.o % [CHANGE CONTENTS OF foo.h] %scons -Q
scons: `.' is up to date.
Apparently, the scanner does not know about the header dependency. Not being a full-fledged C preprocessor, the scanner does not expand the macro.
In these cases, you may also use the compiler to extract the
implicit dependencies. ParseDepends
can parse the contents of
the compiler output in the style of Make, and explicitly
establish all of the listed dependencies.
The following example uses ParseDepends
to process a compiler
generated dependency file which is generated as a side effect
during compilation of the object file:
obj = Object('hello.c', CCFLAGS='-MD -MF hello.d', CPPPATH='.') SideEffect('hello.d', obj) ParseDepends('hello.d') Program('hello', obj)
%scons -Q
cc -o hello.o -c -MD -MF hello.d -I. hello.c cc -o hello hello.o % [CHANGE CONTENTS OF foo.h] %scons -Q
cc -o hello.o -c -MD -MF hello.d -I. hello.c
Parsing dependencies from a compiler-generated
.d
file has a chicken-and-egg problem, that
causes unnecessary rebuilds:
%scons -Q
cc -o hello.o -c -MD -MF hello.d -I. hello.c cc -o hello hello.o %scons -Q --debug=explain
scons: rebuilding `hello.o' because `foo.h' is a new dependency cc -o hello.o -c -MD -MF hello.d -I. hello.c %scons -Q
scons: `.' is up to date.
In the first pass, the dependency file is generated while the
object file is compiled. At that time, SCons does not know about
the dependency on foo.h
. In the second pass,
the object file is regenerated because foo.h
is detected as a new dependency.
ParseDepends
immediately reads the specified file at invocation
time and just returns if the file does not exist. A dependency
file generated during the build process is not automatically
parsed again. Hence, the compiler-extracted dependencies are not
stored in the signature database during the same build pass. This
limitation of ParseDepends
leads to unnecessary recompilations.
Therefore, ParseDepends
should only be used if scanners are not
available for the employed language or not powerful enough for the
specific task.
Sometimes it makes sense
to not rebuild a program,
even if a dependency file changes.
In this case,
you would tell SCons specifically
to ignore a dependency using the
Ignore
function as follows:
hello_obj=Object('hello.c') hello = Program(hello_obj) Ignore(hello_obj, 'hello.h')
%scons -Q hello
cc -c -o hello.o hello.c cc -o hello hello.o %scons -Q hello
scons: `hello' is up to date. %edit hello.h
[CHANGE THE CONTENTS OF hello.h] %scons -Q hello
scons: `hello' is up to date.
Now, the above example is a little contrived,
because it's hard to imagine a real-world situation
where you wouldn't want to rebuild hello
if the hello.h
file changed.
A more realistic example
might be if the hello
program is being built in a
directory that is shared between multiple systems
that have different copies of the
stdio.h
include file.
In that case,
SCons would notice the differences between
the different systems' copies of stdio.h
and would rebuild hello
each time you change systems.
You could avoid these rebuilds as follows:
hello = Program('hello.c', CPPPATH=['/usr/include']) Ignore(hello, '/usr/include/stdio.h')
Ignore
can also be used to prevent a generated file from being built
by default. This is due to the fact that directories depend on
their contents. So to ignore a generated file from the default build,
you specify that the directory should ignore the generated file.
Note that the file will still be built if the user specifically
requests the target on scons command line, or if the file is
a dependency of another file which is requested and/or is built
by default.
hello_obj=Object('hello.c') hello = Program(hello_obj) Ignore('.',[hello,hello_obj])
%scons -Q
scons: `.' is up to date. %scons -Q hello
cc -o hello.o -c hello.c cc -o hello hello.o %scons -Q hello
scons: `hello' is up to date.
Occasionally, it may be useful to specify that a certain file or directory must, if necessary, be built or created before some other target is built, but that changes to that file or directory do not require that the target itself be rebuilt. Such a relationship is called an order-only dependency because it only affects the order in which things must be built--the dependency before the target--but it is not a strict dependency relationship because the target should not change in response to changes in the dependent file.
For example, suppose that you want to create a file
every time you run a build
that identifies the time the build was performed,
the version number, etc.,
and which is included in every program that you build.
The version file's contents will change every build.
If you specify a normal dependency relationship,
then every program that depends on
that file would be rebuilt every time you ran SCons.
For example, we could use some Python code in
a SConstruct
file to create a new version.c
file
with a string containing the current date every time
we run SCons,
and then link a program with the resulting object file
by listing version.c
in the sources:
import time version_c_text = """ char *date = "%s"; """ % time.ctime(time.time()) open('version.c', 'w').write(version_c_text) hello = Program(['hello.c', 'version.c'])
If we list version.c
as an actual source file,
though, then the version.o
file
will get rebuilt every time we run SCons
(because the SConstruct
file itself changes
the contents of version.c
)
and the hello
executable
will get re-linked every time
(because the version.o
file changes):
%scons -Q hello
cc -o hello.o -c hello.c cc -o version.o -c version.c cc -o hello hello.o version.o %sleep 1
%scons -Q hello
cc -o version.o -c version.c cc -o hello hello.o version.o %sleep 1
%scons -Q hello
cc -o version.o -c version.c cc -o hello hello.o version.o
(Note that for the above example to work,
we sleep for one second in between each run,
so that the SConstruct
file will create a
version.c
file with a time string
that's one second later than the previous run.)
One solution is to use the Requires
function
to specify that the version.o
must be rebuilt before it is used by the link step,
but that changes to version.o
should not actually cause the hello
executable to be re-linked:
import time version_c_text = """ char *date = "%s"; """ % time.ctime(time.time()) open('version.c', 'w').write(version_c_text) version_obj = Object('version.c') hello = Program('hello.c', LINKFLAGS = str(version_obj[0])) Requires(hello, version_obj)
Notice that because we can no longer list version.c
as one of the sources for the hello
program,
we have to find some other way to get it into the link command line.
For this example, we're cheating a bit and stuffing the
object file name (extracted from version_obj
list returned by the Object
builder call)
into the $LINKFLAGS
variable,
because $LINKFLAGS
is already included
in the $LINKCOM
command line.
With these changes,
we get the desired behavior of only
re-linking the hello
executable
when the hello.c
has changed,
even though the version.o
is rebuilt
(because the SConstruct
file still changes the
version.c
contents directly each run):
%scons -Q hello
cc -o version.o -c version.c cc -o hello.o -c hello.c cc -o hello version.o hello.o %sleep 1
%scons -Q hello
cc -o version.o -c version.c scons: `hello' is up to date. %sleep 1
% [CHANGE THE CONTENTS OF hello.c] %scons -Q hello
cc -o version.o -c version.c cc -o hello.o -c hello.c cc -o hello version.o hello.o %sleep 1
%scons -Q hello
cc -o version.o -c version.c scons: `hello' is up to date.
How SCons handles dependencies can also be affected
by the AlwaysBuild
method.
When a file is passed to the AlwaysBuild
method,
like so:
hello = Program('hello.c') AlwaysBuild(hello)
Then the specified target file (hello
in our example)
will always be considered out-of-date and
rebuilt whenever that target file is evaluated
while walking the dependency graph:
%scons -Q
cc -o hello.o -c hello.c cc -o hello hello.o %scons -Q
cc -o hello hello.o
The AlwaysBuild
function has a somewhat misleading name,
because it does not actually mean the target file will
be rebuilt every single time SCons is invoked.
Instead, it means that the target will, in fact,
be rebuilt whenever the target file is encountered
while evaluating the targets specified on
the command line (and their dependencies).
So specifying some other target on the command line,
a target that does not
itself depend on the AlwaysBuild
target,
will still be rebuilt only if it's out-of-date
with respect to its dependencies:
%scons -Q
cc -o hello.o -c hello.c cc -o hello hello.o %scons -Q hello.o
scons: `hello.o' is up to date.
An environment
is a collection of values that
can affect how a program executes.
SCons distinguishes between three
different types of environments
that can affect the behavior of SCons itself
(subject to the configuration in the SConscript
files),
as well as the compilers and other tools it executes:
The External Environment is the set of variables in the user's environment at the time the user runs SCons. These variables are not automatically part of an SCons build but are available to be examined if needed. See Section 7.1, “Using Values From the External Environment”, below.
A Construction Environment
is a distinct object created within
a SConscript
file and
which contains values that
affect how SCons decides
what action to use to build a target,
and even to define which targets
should be built from which sources.
One of the most powerful features of SCons
is the ability to create multiple construction environments,
including the ability to clone a new, customized
construction environment from an existing construction environment.
See Section 7.2, “Construction Environments”, below.
An Execution Environment is the values that SCons sets when executing an external command (such as a compiler or linker) to build one or more targets. Note that this is not the same as the external environment (see above). See Section 7.3, “Controlling the Execution Environment for Issued Commands”, below.
Unlike Make, SCons does not automatically copy or import values between different environments (with the exception of explicit clones of construction environments, which inherit the values from their parent). This is a deliberate design choice to make sure that builds are, by default, repeatable regardless of the values in the user's external environment. This avoids a whole class of problems with builds where a developer's local build works because a custom variable setting causes a different compiler or build option to be used, but the checked-in change breaks the official build because it uses different environment variable settings.
Note that the SConscript
writer can
easily arrange for variables to be
copied or imported between environments,
and this is often very useful
(or even downright necessary)
to make it easy for developers
to customize the build in appropriate ways.
The point is not
that copying variables between different environments
is evil and must always be avoided.
Instead, it should be up to the
implementer of the build system
to make conscious choices
about how and when to import
a variable from one environment to another,
making informed decisions about
striking the right balance
between making the build
repeatable on the one hand
and convenient to use on the other.
The external environment
variable settings that
the user has in force
when executing SCons
are available in the Python
os.environ
dictionary.
That syntax means the environ
attribute of the os
module.
In Python, to access the contents of a module you must first
import
it - so you would include the
import os
statement
to any SConscript
file
in which you want to use
values from the user's external environment.
import os print("Shell is", os.environ['SHELL'])
More usefully, you can use the
os.environ
dictionary in your SConscript
files to initialize construction environments
with values from the user's external environment.
Read on to the next section for information on how to do this.
It is rare that all of the software in a large, complicated system needs to be built exactly the same way. For example, different source files may need different options enabled on the command line, or different executable programs need to be linked with different libraries. SCons accommodates these different build requirements by allowing you to create and configure multiple construction environments that control how the software is built. A construction environment is an object that has a number of associated construction variables, each with a name and a value, just like a dictionary. (A construction environment also has an attached set of Builder methods, about which we'll learn more later.)
A construction environment is created by the Environment
method:
env = Environment()
By default, SCons initializes every new construction environment with a set of construction variables based on the tools that it finds on your system, plus the default set of builder methods necessary for using those tools. The construction variables are initialized with values describing the C compiler, the Fortran compiler, the linker, etc., as well as the command lines to invoke them.
When you initialize a construction environment you can set the values of the environment's construction variables to control how a program is built. For example:
env = Environment(CC='gcc', CCFLAGS='-O2') env.Program('foo.c')
The construction environment in this example
is still initialized with the same default
construction variable values,
except that the user has explicitly specified use of the
GNU C compiler gcc,
and that the -O2
(optimization level two)
flag should be used when compiling the object file.
In other words, the explicit initializations of
$CC
and $CCFLAGS
override the default values in the newly-created
construction environment.
So a run from this example would look like:
% scons -Q
gcc -o foo.o -c -O2 foo.c
gcc -o foo foo.o
You can fetch individual values, known as Construction Variables, using the same syntax used for accessing individual named items in a Python dictionary:
env = Environment() print("CC is: %s" % env['CC']) print("LATEX is: %s" % env.get('LATEX', None))
This example SConstruct
file doesn't contain instructions
for building any targets, but because it's still a valid
SConstruct
it will be evaluated and the Python
print
calls will output the values
of $CC
and $LATEX
for us (remember using the
.get()
method for fetching means
we get a default value back, rather than a failure,
if the variable is not set):
% scons -Q
CC is: cc
LATEX is: None
scons: `.' is up to date.
A construction environment
is actually an object with associated methods and attributes.
If you want to have direct access to only the
dictionary of construction variables
you can fetch this using the env.Dictionary
method
(although it's rarely necessary to use this method):
env = Environment(FOO='foo', BAR='bar') cvars = env.Dictionary() for key in ['OBJSUFFIX', 'LIBSUFFIX', 'PROGSUFFIX']: print("key = %s, value = %s" % (key, cvars[key]))
This SConstruct
file
will print the specified dictionary items for us on POSIX
systems as follows:
% scons -Q
key = OBJSUFFIX, value = .o
key = LIBSUFFIX, value = .a
key = PROGSUFFIX, value =
scons: `.' is up to date.
And on Windows:
C:\>scons -Q
key = OBJSUFFIX, value = .obj
key = LIBSUFFIX, value = .lib
key = PROGSUFFIX, value = .exe
scons: `.' is up to date.
If you want to loop and print the values of all of the construction variables in a construction environment, the Python code to do that in sorted order might look something like:
env = Environment() for item in sorted(env.Dictionary().items()): print("construction variable = '%s', value = '%s'" % item)
It should be noted that for the previous example, there is actually a construction environment method that does the same thing more simply, and tries to format the output nicely as well:
env = Environment() print(env.Dump())
Another way to get information from
a construction environment
is to use the subst
method
on a string containing $
expansions
of construction variable names.
As a simple example,
the example from the previous
section that used
env['CC']
to fetch the value of $CC
could also be written as:
env = Environment() print("CC is: %s" % env.subst('$CC'))
One advantage of using
subst
to expand strings is
that construction variables
in the result get re-expanded until
there are no expansions left in the string.
So a simple fetch of a value like
$CCCOM
:
env = Environment(CCFLAGS='-DFOO') print("CCCOM is: %s" % env['CCCOM'])
Will print the unexpanded value of $CCCOM
,
showing us the construction
variables that still need to be expanded:
% scons -Q
CCCOM is: $CC $CCFLAGS $CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS -c -o $TARGET $SOURCES
scons: `.' is up to date.
Calling the subst
method on $CCOM
,
however:
env = Environment(CCFLAGS='-DFOO') print("CCCOM is: %s" % env.subst('$CCCOM'))
Will recursively expand all of
the construction variables prefixed
with $
(dollar signs),
showing us the final output:
% scons -Q
CCCOM is: gcc -DFOO -c -o
scons: `.' is up to date.
Note that because we're not expanding this
in the context of building something
there are no target or source files
for $TARGET
and $SOURCES
to expand.
If a problem occurs when expanding a construction variable,
by default it is expanded to ''
(an empty string), and will not cause scons to fail.
env = Environment() print("value is: %s"%env.subst( '->$MISSING<-' ))
% scons -Q
value is: -><-
scons: `.' is up to date.
This default behaviour can be changed using the AllowSubstExceptions
function.
When a problem occurs with a variable expansion it generates
an exception, and the AllowSubstExceptions
function controls
which of these exceptions are actually fatal and which are
allowed to occur safely. By default, NameError
and IndexError
are the two exceptions that are allowed to occur: so instead of
causing scons to fail, these are caught, the variable expanded to
''
and scons execution continues.
To require that all construction variable names exist, and that
indexes out of range are not allowed, call AllowSubstExceptions
with no extra arguments.
AllowSubstExceptions() env = Environment() print("value is: %s"%env.subst( '->$MISSING<-' ))
% scons -Q
scons: *** NameError `name 'MISSING' is not defined' trying to evaluate `$MISSING'
File "/home/my/project/SConstruct", line 3, in <module>
This can also be used to allow other exceptions that might occur,
most usefully with the ${...}
construction
variable syntax. For example, this would allow zero-division to
occur in a variable expansion in addition to the default exceptions
allowed
AllowSubstExceptions(IndexError, NameError, ZeroDivisionError) env = Environment() print("value is: %s"%env.subst( '->${1 / 0}<-' ))
% scons -Q
value is: -><-
scons: `.' is up to date.
If AllowSubstExceptions
is called multiple times, each call
completely overwrites the previous list of allowed exceptions.
All of the Builder functions that we've introduced so far,
like Program
and Library
, use a construction environment
that contains settings for the various compilers
and other tools that SCons configures by default,
or otherwise knows about and has discovered on your system.
If not invoked as methods of a specific construction environment,
they use the default construction environment
The goal of the default construction environment
is to make many configurations "just work"
to build software using readily available tools
with a minimum of configuration changes.
If needed, you can control the default construction environment
by using the DefaultEnvironment
function
to initialize various settings by passing
them as keyword arguments:
DefaultEnvironment(CC='/usr/local/bin/gcc')
When configured as above,
all calls to the Program
or Object
Builder
will build object files with the
/usr/local/bin/gcc
compiler.
The DefaultEnvironment
function
returns the initialized default construction environment object,
which can then be manipulated like any other construction environment
(note that the default environment works like a singleton -
it can have only one instance - so the keyword arguments
are processed only on the first call. On any subsequent
call the existing object is returned).
So the following would be equivalent to the
previous example, setting the $CC
variable to /usr/local/bin/gcc
but as a separate step after
the default construction environment has been initialized:
def_env = DefaultEnvironment() def_env['CC'] = '/usr/local/bin/gcc'
One very common use of the DefaultEnvironment
function
is to speed up SCons initialization.
As part of trying to make most default
configurations "just work,"
SCons will actually
search the local system for installed
compilers and other utilities.
This search can take time,
especially on systems with
slow or networked file systems.
If you know which compiler(s) and/or
other utilities you want to configure,
you can control the search
that SCons performs
by specifying some specific
tool modules with which to
initialize the default construction environment:
def_env = DefaultEnvironment(tools=['gcc', 'gnulink'], CC='/usr/local/bin/gcc')
So the above example would tell SCons
to explicitly configure the default environment
to use its normal GNU Compiler and GNU Linker settings
(without having to search for them,
or any other utilities for that matter),
and specifically to use the compiler found at
/usr/local/bin/gcc
.
The real advantage of construction environments
is that you can create as many different ones as you need,
each tailored to a different way to build
some piece of software or other file.
If, for example, we need to build
one program with the -O2
flag
and another with the -g
(debug) flag,
we would do this like so:
opt = Environment(CCFLAGS='-O2') dbg = Environment(CCFLAGS='-g') opt.Program('foo', 'foo.c') dbg.Program('bar', 'bar.c')
% scons -Q
cc -o bar.o -c -g bar.c
cc -o bar bar.o
cc -o foo.o -c -O2 foo.c
cc -o foo foo.o
We can even use multiple construction environments to build
multiple versions of a single program.
If you do this by simply trying to use the
Program
builder with both environments, though,
like this:
opt = Environment(CCFLAGS='-O2') dbg = Environment(CCFLAGS='-g') opt.Program('foo', 'foo.c') dbg.Program('foo', 'foo.c')
Then SCons generates the following error:
% scons -Q
scons: *** Two environments with different actions were specified for the same target: foo.o
File "/home/my/project/SConstruct", line 6, in <module>
This is because the two Program
calls have
each implicitly told SCons to generate an object file named
foo.o
,
one with a $CCFLAGS
value of
-O2
and one with a $CCFLAGS
value of
-g
.
SCons can't just decide that one of them
should take precedence over the other,
so it generates the error.
To avoid this problem,
we must explicitly specify
that each environment compile
foo.c
to a separately-named object file
using the Object
builder, like so:
opt = Environment(CCFLAGS='-O2') dbg = Environment(CCFLAGS='-g') o = opt.Object('foo-opt', 'foo.c') opt.Program(o) d = dbg.Object('foo-dbg', 'foo.c') dbg.Program(d)
Notice that each call to the Object
builder
returns a value,
an internal SCons object that
represents the object file that will be built.
We then use that object
as input to the Program
builder.
This avoids having to specify explicitly
the object file name in multiple places,
and makes for a compact, readable
SConstruct
file.
Our SCons output then looks like:
% scons -Q
cc -o foo-dbg.o -c -g foo.c
cc -o foo-dbg foo-dbg.o
cc -o foo-opt.o -c -O2 foo.c
cc -o foo-opt foo-opt.o
Sometimes you want more than one construction environment
to share the same values for one or more variables.
Rather than always having to repeat all of the common
variables when you create each construction environment,
you can use the env.Clone
method
to create a copy of a construction environment.
Like the Environment
call that creates a construction environment,
the Clone
method takes construction variable assignments,
which will override the values in the copied construction environment.
For example, suppose we want to use gcc
to create three versions of a program,
one optimized, one debug, and one with neither.
We could do this by creating a "base" construction environment
that sets $CC
to gcc,
and then creating two copies,
one which sets $CCFLAGS
for optimization
and the other which sets $CCFLAGS
for debugging:
env = Environment(CC='gcc') opt = env.Clone(CCFLAGS='-O2') dbg = env.Clone(CCFLAGS='-g') env.Program('foo', 'foo.c') o = opt.Object('foo-opt', 'foo.c') opt.Program(o) d = dbg.Object('foo-dbg', 'foo.c') dbg.Program(d)
Then our output would look like:
% scons -Q
gcc -o foo.o -c foo.c
gcc -o foo foo.o
gcc -o foo-dbg.o -c -g foo.c
gcc -o foo-dbg foo-dbg.o
gcc -o foo-opt.o -c -O2 foo.c
gcc -o foo-opt foo-opt.o
You can replace existing construction variable values
using the env.Replace
method:
env = Environment(CCFLAGS='-DDEFINE1') env.Replace(CCFLAGS='-DDEFINE2') env.Program('foo.c')
The replacing value
(-DDEFINE2
in the above example)
completely replaces the value in the
construction environment:
% scons -Q
cc -o foo.o -c -DDEFINE2 foo.c
cc -o foo foo.o
You can safely call Replace
for construction variables that
don't exist in the construction environment:
env = Environment() env.Replace(NEW_VARIABLE='xyzzy') print("NEW_VARIABLE = %s" % env['NEW_VARIABLE'])
In this case, the construction variable simply gets added to the construction environment:
% scons -Q
NEW_VARIABLE = xyzzy
scons: `.' is up to date.
Because the variables aren't expanded until the construction environment is actually used to build the targets, and because SCons function and method calls are order-independent, the last replacement "wins" and is used to build all targets, regardless of the order in which the calls to Replace() are interspersed with calls to builder methods:
env = Environment(CCFLAGS='-DDEFINE1') print("CCFLAGS = %s" % env['CCFLAGS']) env.Program('foo.c') env.Replace(CCFLAGS='-DDEFINE2') print("CCFLAGS = %s" % env['CCFLAGS']) env.Program('bar.c')
The timing of when the replacement
actually occurs relative
to when the targets get built
becomes apparent
if we run scons without the -Q
option:
% scons
scons: Reading SConscript files ...
CCFLAGS = -DDEFINE1
CCFLAGS = -DDEFINE2
scons: done reading SConscript files.
scons: Building targets ...
cc -o bar.o -c -DDEFINE2 bar.c
cc -o bar bar.o
cc -o foo.o -c -DDEFINE2 foo.c
cc -o foo foo.o
scons: done building targets.
Because the replacement occurs while
the SConscript
files are being read,
the $CCFLAGS
variable has already been set to
-DDEFINE2
by the time the foo.o
target is built,
even though the call to the Replace
method does not occur until later in
the SConscript
file.
Sometimes it's useful to be able to specify
that a construction variable should be
set to a value only if the construction environment
does not already have that variable defined
You can do this with the env.SetDefault
method,
which behaves similarly to the setdefault
method of Python dictionary objects:
env.SetDefault(SPECIAL_FLAG='-extra-option')
This is especially useful
when writing your own Tool
modules
to apply variables to construction environments.
You can append a value to
an existing construction variable
using the env.Append
method:
env = Environment(CPPDEFINES=['MY_VALUE']) env.Append(CPPDEFINES=['LAST']) env.Program('foo.c')
Note $CPPDEFINES
is the preferred way to set preprocessor defines,
as SCons will generate the command line arguments using the correct
prefix/suffix for the platform, leaving the usage portable.
If you use $CCFLAGS
and $SHCCFLAGS
,
you need to include them in their final form, which is less portable.
% scons -Q
cc -o foo.o -c -DMY_VALUE -DLAST foo.c
cc -o foo foo.o
If the construction variable doesn't already exist,
the Append
method will create it:
env = Environment() env.Append(NEW_VARIABLE = 'added') print("NEW_VARIABLE = %s"%env['NEW_VARIABLE'])
Which yields:
% scons -Q
NEW_VARIABLE = added
scons: `.' is up to date.
Note that the Append
function tries to be "smart"
about how the new value is appended to the old value.
If both are strings, the previous and new strings
are simply concatenated.
Similarly, if both are lists,
the lists are concatenated.
If, however, one is a string and the other is a list,
the string is added as a new element to the list.
Sometimes it's useful to add a new value
only if the existing construction variable
doesn't already contain the value.
This can be done using the env.AppendUnique
method:
env.AppendUnique(CCFLAGS=['-g'])
In the above example,
the -g
would be added
only if the $CCFLAGS
variable
does not already contain a -g
value.
You can prepend a value to the beginning of
an existing construction variable
using the env.Prepend
method:
env = Environment(CPPDEFINES=['MY_VALUE']) env.Prepend(CPPDEFINES=['FIRST']) env.Program('foo.c')
SCons then generates the preprocessor define arguments from CPPDEFINES
values with the correct
prefix/suffix. For example on Linux or POSIX, the following arguments would be generated:
-DFIRST
and
-DMY_VALUE
% scons -Q
cc -o foo.o -c -DFIRST -DMY_VALUE foo.c
cc -o foo foo.o
If the construction variable doesn't already exist,
the Prepend
method will create it:
env = Environment() env.Prepend(NEW_VARIABLE='added') print("NEW_VARIABLE = %s" % env['NEW_VARIABLE'])
Which yields:
% scons -Q
NEW_VARIABLE = added
scons: `.' is up to date.
Like the Append
function,
the Prepend
function tries to be "smart"
about how the new value is appended to the old value.
If both are strings, the previous and new strings
are simply concatenated.
Similarly, if both are lists,
the lists are concatenated.
If, however, one is a string and the other is a list,
the string is added as a new element to the list.
Some times it's useful to add a new value
to the beginning of a construction variable
only if the existing value
doesn't already contain the to-be-added value.
This can be done using the env.PrependUnique
method:
env.PrependUnique(CCFLAGS=['-g'])
In the above example,
the -g
would be added
only if the $CCFLAGS
variable
does not already contain a -g
value.
Rather than creating a cloned construction environment for specific tasks, you can override or add construction variables when calling a builder method by passing them as keyword arguments. The values of these overridden or added variables will only be in effect when building that target, and will not affect other parts of the build. For example, if you want to add additional libraries for just one program:
env.Program('hello', 'hello.c', LIBS=['gl', 'glut'])
or generate a shared library with a non-standard suffix:
env.SharedLibrary( target='word', source='word.cpp', SHLIBSUFFIX='.ocx', LIBSUFFIXES=['.ocx'], )
When overriding this way, the Python keyword arguments in
the builder call mean "set to this value".
If you want your override to augment an existing value,
you have to take some extra steps.
Inside the builder call,
it is possible to substitute in the existing value by using
a string containing the variable name prefaced by a
dollar sign ($
).
env = Environment(CPPDEFINES="FOO") env.Object(target="foo1.o", source="foo.c") env.Object(target="foo2.o", source="foo.c", CPPDEFINES="BAR") env.Object(target="foo3.o", source="foo.c", CPPDEFINES=["BAR", "$CPPDEFINES"])
Which yields:
% scons -Q
cc -o foo1.o -c -DFOO foo.c
cc -o foo2.o -c -DBAR foo.c
cc -o foo3.o -c -DBAR -DFOO foo.c
It is also possible to use the parse_flags
keyword argument in an override to merge command-line
style arguments into the appropriate construction
variables. This works like the env.MergeFlags
method,
which will be fully described in the next chapter.
This example adds 'include' to $CPPPATH
,
'EBUG' to $CPPDEFINES
, and 'm' to $LIBS
:
env = Environment() env.Program('hello', 'hello.c', parse_flags='-Iinclude -DEBUG -lm')
So when executed:
% scons -Q
cc -o hello.o -c -DEBUG -Iinclude hello.c
cc -o hello hello.o -lm
Using temporary overrides this way is lighter weight than making
a full construction environment, so it can help performance in
large projects which have lots of special case values to set.
However, keep in mind that this only works well when the
targets are unique. Using builder overrides to try to build
the same target with different sets of flags or other construction
variables will lead to the
scons: *** Two environments with different actions...
error described in Section 7.2.6, “Multiple Construction Environments”
above. In this case you will actually want to create separate
environments.
When SCons builds a target file,
it does not execute the commands with
the external environment
that you used to execute SCons.
Instead, it builds an execution environment from the values
stored in the $ENV
construction variable
and uses that for executing commands.
The most important ramification of this behavior
is that the PATH
environment variable,
which controls where the operating system
will look for commands and utilities,
will almost certainly not be the same as in the external environment
from which you called SCons.
This means that SCons might not
necessarily find all of the tools
that you can successfully execute from the command line.
The default value of the PATH
environment variable
on a POSIX system
is /usr/local/bin:/opt/bin:/bin:/usr/bin:/snap/bin
.
The default value of the PATH
environment variable
on a Windows system comes from the Windows registry
value for the command interpreter.
If you want to execute any commands--compilers, linkers, etc.--that
are not in these default locations,
you need to set the PATH
value
in the $ENV
dictionary
in your construction environment.
The simplest way to do this is to initialize explicitly the value when you create the construction environment; this is one way to do that:
path = ['/usr/local/bin', '/bin', '/usr/bin'] env = Environment(ENV={'PATH': path})
Assigning a dictionary to the $ENV
construction variable in this way
completely resets the execution environment,
so that the only variable that will be
set when external commands are executed
will be the PATH
value.
If you want to use the rest of
the values in $ENV
and only
set the value of PATH
, you can assign a value only
to that variable:
env['ENV']['PATH'] = ['/usr/local/bin', '/bin', '/usr/bin']
Note that SCons does allow you to define
the directories in the PATH
in a string with paths
separated by the pathname-separator character
for your system (':'
on POSIX systems,
';'
on Windows).
env['ENV']['PATH'] = '/usr/local/bin:/bin:/usr/bin'
But doing so makes your SConscript
file less portable,
since it will be correct only for the system type that
matches the separator. You can use the Python
os.pathsep
for for greater portability -
don't worry too much if this Python syntax doesn't make sense
since there are other ways available:
import os env['ENV']['PATH'] = os.pathsep.join(['/usr/local/bin', '/bin', '/usr/bin'])
You may want to propagate the external environment PATH
to the execution environment for commands.
You do this by initializing the PATH
variable with the PATH
value from
the os.environ
dictionary,
which is Python's way of letting you
get at the external environment:
import os env = Environment(ENV={'PATH': os.environ['PATH']})
Alternatively, you may find it easier
to just propagate the entire external
environment to the execution environment
for commands.
This is simpler to code than explicity
selecting the PATH
value:
import os env = Environment(ENV=os.environ.copy())
Either of these will guarantee that
SCons will be able to execute
any command that you can execute from the command line.
The drawback is that the build can behave
differently if it's run by people with
different PATH
values in their environment--for example,
if both the /bin
and
/usr/local/bin
directories
have different cc commands,
then which one will be used to compile programs
will depend on which directory is listed
first in the user's PATH
variable.
One of the most common requirements
for manipulating a variable in the execution environment
is to add one or more custom directories to a path search variable
like PATH
on Linux or POSIX systems,
or %PATH%
on Windows,
so that a locally-installed compiler or other utility
can be found when SCons tries to execute it to update a target.
SCons provides env.PrependENVPath
and env.AppendENVPath
functions
to make adding things to execution variables convenient.
You call these functions by specifying the variable
to which you want the value added,
and then value itself.
So to add some /usr/local
directories
to the $PATH
and $LIB
variables,
you might:
env = Environment(ENV=os.environ.copy()) env.PrependENVPath('PATH', '/usr/local/bin') env.AppendENVPath('LIB', '/usr/local/lib')
Note that the added values are strings,
and if you want to add multiple directories to
a variable like $PATH
,
you must include the path separator character
in the string
(:
on Linux or POSIX,
;
on Windows, or use
os.pathsep
for portability).
Normally when using a tool from the construction environment,
several different search locations are checked by default.
This includes the SCons/Tools/
directory
that is part of the scons distribution
and the directory site_scons/site_tools
relative to the root SConstruct
file.
# Builtin tool or tool located within site_tools env = Environment(tools=['SomeTool']) env.SomeTool(targets, sources) # The search locations would include by default SCons/Tool/SomeTool.py SCons/Tool/SomeTool/__init__.py ./site_scons/site_tools/SomeTool.py ./site_scons/site_tools/SomeTool/__init__.py
In some cases you may want to specify a different location to search for tools.
The Environment
function contains an option for this called
toolpath
This can be used to add additional search directories.
# Tool located within the toolpath directory option env = Environment( tools=['SomeTool'], toolpath=['/opt/SomeToolPath', '/opt/SomeToolPath2'] ) env.SomeTool(targets, sources) # The search locations in this example would include: /opt/SomeToolPath/SomeTool.py /opt/SomeToolPath/SomeTool/__init__.py /opt/SomeToolPath2/SomeTool.py /opt/SomeToolPath2/SomeTool/__init__.py SCons/Tool/SomeTool.py SCons/Tool/SomeTool/__init__.py ./site_scons/site_tools/SomeTool.py ./site_scons/site_tools/SomeTool/__init__.py
Since SCons 3.0, a Builder may be located within a sub-directory / sub-package of the toolpath. This is similar to namespacing within Python. With nested or namespaced tools we can use the dot notation to specify a sub-directory that the tool is located under.
# namespaced target env = Environment( tools=['SubDir1.SubDir2.SomeTool'], toolpath=['/opt/SomeToolPath'] ) env.SomeTool(targets, sources) # With this example the search locations would include /opt/SomeToolPath/SubDir1/SubDir2/SomeTool.py /opt/SomeToolPath/SubDir1/SubDir2/SomeTool/__init__.py SCons/Tool/SubDir1/SubDir2/SomeTool.py SCons/Tool/SubDir1/SubDir2/SomeTool/__init__.py ./site_scons/site_tools/SubDir1/SubDir2/SomeTool.py ./site_scons/site_tools/SubDir1/SubDir2/SomeTool/__init__.py
If we want to access tools external to scons which are findable
via sys.path
(for example, tools installed via Python's pip package manager),
it is possible to use sys.path
with the toolpath.
One thing to watch out for with this approach is that
sys.path
can sometimes contains paths to .egg
files instead of directories.
So we need to filter those out with this approach.
# namespaced target using sys.path within toolpath searchpaths = [] for item in sys.path: if os.path.isdir(item): searchpaths.append(item) env = Environment( tools=['someinstalledpackage.SomeTool'], toolpath=searchpaths ) env.SomeTool(targets, sources)
By using sys.path
with the toolpath argument
and by using the nested syntax we can have scons search
packages installed via pip for Tools.
# For Windows based on the python version and install directory, this may be something like C:\Python35\Lib\site-packages\someinstalledpackage\SomeTool.py C:\Python35\Lib\site-packages\someinstalledpackage\SomeTool\__init__.py # For Linux this could be something like: /usr/lib/python3/dist-packages/someinstalledpackage/SomeTool.py /usr/lib/python3/dist-packages/someinstalledpackage/SomeTool/__init__.py
In some cases you may want to use a tool
located within a installed external pip package.
This is possible by the use of
sys.path
with the toolpath.
However in that situation you need to provide a prefix to the toolname
to indicate where it is located within sys.path
.
searchpaths = [] for item in sys.path: if os.path.isdir(item): searchpaths.append(item) env = Environment( tools=['tools_example.subdir1.subdir2.SomeTool'], toolpath=searchpaths ) env.SomeTool(targets, sources)
To avoid the use of a prefix within the name of the tool or filtering
sys.path
for directories,
we can use PyPackageDir
function to locate the directory of
the python package.
PyPackageDir
returns a Dir object which represents the path of the
directory
for the python package / module specified as a parameter.
# namespaced target using sys.path env = Environment( tools=['SomeTool'], toolpath=[PyPackageDir('tools_example.subdir1.subdir2')] ) env.SomeTool(targets, sources)
This chapter describes the MergeFlags
, ParseFlags
, and ParseConfig
methods of a construction environment, as well as the parse_flags
keyword argument to methods that construct environments.
SCons construction environments have a MergeFlags
method
that merges values from a passed-in argument into the construction environment.
If the argument is a dictionary,
MergeFlags
treats each value in the dictionary
as a list of options you would pass to a command
(such as a compiler or linker).
MergeFlags
will not duplicate an option
if it already exists in the construction variable.
If the argument is a string, MergeFlags
calls the
ParseFlags
method to burst it out into a
dictionary first, then acts on the result.
MergeFlags
tries to be intelligent about merging options,
knowing that different construction variables may have different needs.
When merging options to any variable
whose name ends in PATH
,
MergeFlags
keeps the leftmost occurrence of the option,
because in typical lists of directory paths,
the first occurrence "wins."
When merging options to any other variable name,
MergeFlags
keeps the rightmost occurrence of the option,
because in a list of typical command-line options,
the last occurrence "wins."
env = Environment() env.Append(CCFLAGS='-option -O3 -O1') flags = {'CCFLAGS': '-whatever -O3'} env.MergeFlags(flags) print("CCFLAGS:", env['CCFLAGS'])
% scons -Q
CCFLAGS: ['-option', '-O1', '-whatever', '-O3']
scons: `.' is up to date.
Note that the default value for $CCFLAGS
is an internal SCons object
which automatically converts
the options you specify as a string into a list.
env = Environment() env.Append(CPPPATH=['/include', '/usr/local/include', '/usr/include']) flags = {'CPPPATH': ['/usr/opt/include', '/usr/local/include']} env.MergeFlags(flags) print("CPPPATH:", env['CPPPATH'])
% scons -Q
CPPPATH: ['/include', '/usr/local/include', '/usr/include', '/usr/opt/include']
scons: `.' is up to date.
Note that the default value for $CPPPATH
is a normal Python list,
so you should give its values as a list
in the dictionary you pass to the MergeFlags
function.
If MergeFlags
is passed anything other than a dictionary,
it calls the ParseFlags
method to convert it into a dictionary.
env = Environment() env.Append(CCFLAGS='-option -O3 -O1') env.Append(CPPPATH=['/include', '/usr/local/include', '/usr/include']) env.MergeFlags('-whatever -I/usr/opt/include -O3 -I/usr/local/include') print("CCFLAGS:", env['CCFLAGS']) print("CPPPATH:", env['CPPPATH'])
% scons -Q
CCFLAGS: ['-option', '-O1', '-whatever', '-O3']
CPPPATH: ['/include', '/usr/local/include', '/usr/include', '/usr/opt/include']
scons: `.' is up to date.
In the combined example above,
ParseFlags
has sorted the options into their corresponding variables
and returned a dictionary for MergeFlags
to apply
to the construction variables
in the specified construction environment.
It is also possible to merge construction variable values from arguments
given to the Environment
call itself.
If the parse_flags
keyword argument
is given, its value is distributed to construction variables in the
new environment in the same way as
described for the MergeFlags
method.
This also works when calling env.Clone
,
as well as in overrides to builder methods
(see Section 7.2.14, “Overriding Construction Variable Settings”).
env = Environment(parse_flags="-I/opt/include -L/opt/lib -lfoo") for k in ('CPPPATH', 'LIBPATH', 'LIBS'): print("%s:" % k, env.get(k)) env.Program("f1.c")
% scons -Q
CPPPATH: ['/opt/include']
LIBPATH: ['/opt/lib']
LIBS: ['foo']
cc -o f1.o -c -I/opt/include f1.c
cc -o f1 f1.o -L/opt/lib -lfoo
SCons has a bewildering array of construction variables for different types of options when building programs. Sometimes you may not know exactly which variable should be used for a particular option.
SCons construction environments have a ParseFlags
method
that takes a set of typical command-line options
and distributes them into the appropriate construction variables
Historically, it was created to support the ParseConfig
method,
so it focuses on options used by the GNU Compiler Collection (GCC)
for the C and C++ toolchains.
ParseFlags
returns a dictionary containing the options
distributed into their respective construction variables.
Normally, this dictionary would then be passed to MergeFlags
to merge the options into a construction environment,
but the dictionary can be edited if desired to provide
additional functionality.
(Note that if the flags are not going to be edited,
calling MergeFlags
with the options directly
will avoid an additional step.)
env = Environment() d = env.ParseFlags("-I/opt/include -L/opt/lib -lfoo") for k, v in sorted(d.items()): if v: print(k, v) env.MergeFlags(d) env.Program("f1.c")
% scons -Q
CPPPATH ['/opt/include']
LIBPATH ['/opt/lib']
LIBS ['foo']
cc -o f1.o -c -I/opt/include f1.c
cc -o f1 f1.o -L/opt/lib -lfoo
Note that if the options are limited to generic types like those above, they will be correctly translated for other platform types:
C:\>scons -Q
CPPPATH ['/opt/include']
LIBPATH ['/opt/lib']
LIBS ['foo']
cl /Fof1.obj /c f1.c /nologo /I\opt\include
link /nologo /OUT:f1.exe /LIBPATH:\opt\lib foo.lib f1.obj
embedManifestExeCheck(target, source, env)
Since the assumption is that the flags are used for the GCC toolchain,
unrecognized flags are placed in $CCFLAGS
so they will be used for both C and C++ compiles:
env = Environment() d = env.ParseFlags("-whatever") for k, v in sorted(d.items()): if v: print(k, v) env.MergeFlags(d) env.Program("f1.c")
% scons -Q
CCFLAGS -whatever
cc -o f1.o -c -whatever f1.c
cc -o f1 f1.o
ParseFlags
will also accept a (recursive) list of strings as input;
the list is flattened before the strings are processed:
env = Environment() d = env.ParseFlags(["-I/opt/include", ["-L/opt/lib", "-lfoo"]]) for k, v in sorted(d.items()): if v: print(k, v) env.MergeFlags(d) env.Program("f1.c")
% scons -Q
CPPPATH ['/opt/include']
LIBPATH ['/opt/lib']
LIBS ['foo']
cc -o f1.o -c -I/opt/include f1.c
cc -o f1 f1.o -L/opt/lib -lfoo
If a string begins with a an exclamation mark (!
),
the string is passed to the shell for execution.
The output of the command is then parsed:
env = Environment() d = env.ParseFlags(["!echo -I/opt/include", "!echo -L/opt/lib", "-lfoo"]) for k, v in sorted(d.items()): if v: print(k, v) env.MergeFlags(d) env.Program("f1.c")
% scons -Q
CPPPATH ['/opt/include']
LIBPATH ['/opt/lib']
LIBS ['foo']
cc -o f1.o -c -I/opt/include f1.c
cc -o f1 f1.o -L/opt/lib -lfoo
ParseFlags
is regularly updated for new options;
consult the man page for details about those currently recognized.
Configuring the right options to build programs to work with
libraries--especially shared libraries--that are available
on POSIX systems can be complex.
To help this situation,
various utilies with names that end in config
return the command-line options for the GNU Compiler Collection (GCC)
that are needed to build and link against those libraries;
for example, the command-line options
to use a library named lib
could be found by calling a utility named lib-config.
A more recent convention is that these options are available through the generic pkg-config program, providing a common framework, error handling, and the like, so that all the package creator has to do is provide the set of strings for his particular package.
SCons construction variables have a ParseConfig
method that asks the host system to execute a command
and then configures the appropriate construction variables based on
the output of that command.
This lets you run a program like pkg-config
or a more specific utility to help set up your build.
env = Environment() env['CPPPATH'] = ['/lib/compat'] env.ParseConfig("pkg-config x11 --cflags --libs") print("CPPPATH:", env['CPPPATH'])
SCons will execute the specified command string, parse the resultant flags, and add the flags to the appropriate environment variables.
% scons -Q
CPPPATH: ['/lib/compat', '/usr/X11/include']
scons: `.' is up to date.
In the example above, SCons has added the include directory to
$CPPPATH
(Depending upon what other flags are emitted by the
pkg-config
command,
other variables may have been extended as well.)
Note that the options are merged with existing options using
the MergeFlags
method,
so that each option only occurs once in the construction variable.
env = Environment() env.ParseConfig("pkg-config x11 --cflags --libs") env.ParseConfig("pkg-config x11 --cflags --libs") print("CPPPATH:", "CPPPATH:", env['CPPPATH'])
% scons -Q
CPPPATH: ['/usr/X11/include']
scons: `.' is up to date.
A key aspect of creating a usable build configuration is providing useful output from the build so its users can readily understand what the build is doing and get information about how to control the build. SCons provides several ways of controlling output from the build configuration to help make the build more useful and understandable.
It's often very useful to be able to give
users some help that describes the
specific targets, build options, etc.,
that can be used for your build.
SCons provides the Help
function
to allow you to specify this help text:
Help(""" Type: 'scons program' to build the production program, 'scons debug' to build the debug version. """)
Optionally, you can specify the append
flag:
Help(""" Type: 'scons program' to build the production program, 'scons debug' to build the debug version. """, append=True)
(Note the above use of the Python triple-quote syntax, which comes in very handy for specifying multi-line strings like help text.)
When the SConstruct
or SConscript
files
contain a call to the Help
function,
the specified help text will be displayed in response to
the SCons -h
option:
% scons -h
scons: Reading SConscript files ...
scons: done reading SConscript files.
Type: 'scons program' to build the production program,
'scons debug' to build the debug version.
Use scons -H for help about SCons built-in command-line options.
The SConscript
files may contain
multiple calls to the Help
function,
in which case the specified text(s)
will be concatenated when displayed.
This allows you to define fragments of help text together with
the corresponding feature, even if spread
across multiple SConscript
files.
In this situation, the order in
which the SConscript
files are called
will determine the order in which the Help
functions are called,
which will determine the order in which
the various bits of text will get concatenated.
Calling Help("text")
overwrites
the help text that otherwise would be collected from any
command-line options defined in AddOption
calls.
To preserve the AddOption
help text,
add the append=True
keyword argument
when calling Help
.
This also preserves the option help for the scons command itself.
To preserve only the AddOption
help,
also add the local_only=True
keyword argument.
(This only matters the first time you call Append
,
on any subsequent calls the text you passed is added
to the existing help text).
Another use would be to make the help text conditional
on some variable.
For example, suppose you only want to display
a line about building a Windows-only
version of a program when actually
run on Windows.
The following SConstruct
file:
env = Environment() Help("\nType: 'scons program' to build the production program.\n") if env['PLATFORM'] == 'win32': Help("\nType: 'scons windebug' to build the Windows debug version.\n")
Will display the complete help text on Windows:
C:\>scons -h
scons: Reading SConscript files ...
scons: done reading SConscript files.
Type: 'scons program' to build the production program.
Type: 'scons windebug' to build the Windows debug version.
Use scons -H for help about SCons built-in command-line options.
But only show the relevant option on a Linux or UNIX system:
% scons -h
scons: Reading SConscript files ...
scons: done reading SConscript files.
Type: 'scons program' to build the production program.
Use scons -H for help about SCons built-in command-line options.
If there is no Help
text in the SConstruct
or
SConscript
files,
SCons will revert to displaying its
standard list that describes the SCons command-line
options.
This list is also always displayed whenever
the -H
option is used.
Sometimes the commands executed
to compile object files or link programs
(or build other targets)
can get very long,
long enough to make it difficult for users
to distinguish error messages or
other important build output
from the commands themselves.
All of the default $*COM
variables
that specify the command lines
used to build various types of target files
have a corresponding $*COMSTR
variable
that can be set to an alternative
string that will be displayed
when the target is built.
For example, suppose you want to
have SCons display a
"Compiling"
message whenever it's compiling an object file,
and a
"Linking"
when it's linking an executable.
You could write a SConstruct
file
that looks like:
env = Environment(CCCOMSTR = "Compiling $TARGET", LINKCOMSTR = "Linking $TARGET") env.Program('foo.c')
Which would then yield the output:
% scons -Q
Compiling foo.o
Linking foo
SCons performs complete variable substitution
on $*COMSTR
variables,
so they have access to all of the
standard variables like $TARGET
$SOURCES
, etc.,
as well as any construction variables
that happen to be configured in
the construction environment
used to build a specific target.
Of course, sometimes it's still important to be able to see the exact command that SCons will execute to build a target. For example, you may simply need to verify that SCons is configured to supply the right options to the compiler, or a developer may want to cut-and-paste a compile command to add a few options for a custom test.
One common way to give users
control over whether or not
SCons should print the actual command line
or a short, configured summary
is to add support for a
VERBOSE
command-line variable to your SConstruct
file.
A simple configuration for this might look like:
env = Environment() if ARGUMENTS.get('VERBOSE') != '1': env['CCCOMSTR'] = "Compiling $TARGET" env['LINKCOMSTR'] = "Linking $TARGET" env.Program('foo.c')
By only setting the appropriate
$*COMSTR
variables
if the user specifies
VERBOSE=1
on the command line,
the user has control
over how SCons
displays these particular command lines:
%scons -Q
Compiling foo.o Linking foo %scons -Q -c
Removed foo.o Removed foo %scons -Q VERBOSE=1
cc -o foo.o -c foo.c cc -o foo foo.o
A gentle reminder here: many of the commands for building come in
pairs, depending on whether the intent is to build an object for
use in a shared library or not. The command strings mirror this,
so it may be necessary to set, for example, both
CCCOMSTR
and SHCCCOMSTR
to get the desired results.
Another aspect of providing good build output is to give the user feedback about what SCons is doing even when nothing is being built at the moment. This can be especially true for large builds when most of the targets are already up-to-date. Because SCons can take a long time making absolutely sure that every target is, in fact, up-to-date with respect to a lot of dependency files, it can be easy for users to mistakenly conclude that SCons is hung or that there is some other problem with the build.
One way to deal with this perception
is to configure SCons to print something to
let the user know what it's "thinking about."
The Progress
function
allows you to specify a string
that will be printed for every file
that SCons is "considering"
while it is traversing the dependency graph
to decide what targets are or are not up-to-date.
Progress('Evaluating $TARGET\n') Program('f1.c') Program('f2.c')
Note that the Progress
function does not
arrange for a newline to be printed automatically
at the end of the string (as does the Python
print
function),
and we must specify the
\n
that we want printed at the end of the configured string.
This configuration, then,
will have SCons
print that it is Evaluating
each file that it encounters
in turn as it traverses the dependency graph:
% scons -Q
Evaluating SConstruct
Evaluating f1.c
Evaluating f1.o
cc -o f1.o -c f1.c
Evaluating f1
cc -o f1 f1.o
Evaluating f2.c
Evaluating f2.o
cc -o f2.o -c f2.c
Evaluating f2
cc -o f2 f2.o
Evaluating .
Of course, normally you don't want to add
all of these additional lines to your build output,
as that can make it difficult for the user
to find errors or other important messages.
A more useful way to display
this progress might be
to have the file names printed
directly to the user's screen,
not to the same standard output
stream where build output is printed,
and to use a carriage return character
(\r
)
so that each file name gets re-printed on the same line.
Such a configuration would look like:
Progress('$TARGET\r', file=open('/dev/tty', 'w'), overwrite=True) Program('f1.c') Program('f2.c')
Note that we also specified the
overwrite=True
argument
to the Progress
function,
which causes SCons to
"wipe out" the previous string with space characters
before printing the next Progress
string.
Without the
overwrite=True
argument,
a shorter file name would not overwrite
all of the charactes in a longer file name that
precedes it,
making it difficult to tell what the
actual file name is on the output.
Also note that we opened up the
/dev/tty
file
for direct access (on POSIX) to
the user's screen.
On Windows, the equivalent would be to open
the con:
file name.
Also, it's important to know that although you can use
$TARGET
to substitute the name of
the node in the string,
the Progress
function does not
perform general variable substitution
(because there's not necessarily a construction
environment involved in evaluating a node
like a source file, for example).
You can also specify a list of strings
to the Progress
function,
in which case SCons will
display each string in turn.
This can be used to implement a "spinner"
by having SCons cycle through a
sequence of strings:
Progress(['-\r', '\\\r', '|\r', '/\r'], interval=5) Program('f1.c') Program('f2.c')
Note that here we have also used the
interval=
keyword argument to have SCons
only print a new "spinner" string
once every five evaluated nodes.
Using an interval=
count,
even with strings that use $TARGET
like
our examples above,
can be a good way to lessen the
work that SCons expends printing Progress
strings,
while still giving the user feedback
that indicates SCons is still
working on evaluating the build.
Lastly, you can have direct control
over how to print each evaluated node
by passing a Python function
(or other Python callable)
to the Progress
function.
Your function will be called
for each evaluated node,
allowing you to
implement more sophisticated logic
like adding a counter:
screen = open('/dev/tty', 'w') count = 0 def progress_function(node) count += 1 screen.write('Node %4d: %s\r' % (count, node)) Progress(progress_function)
Of course, if you choose,
you could completely ignore the
node
argument to the function,
and just print a count,
or anything else you wish.
(Note that there's an obvious follow-on question here: how would you find the total number of nodes that will be evaluated so you can tell the user how close the build is to finishing? Unfortunately, in the general case, there isn't a good way to do that, short of having SCons evaluate its dependency graph twice, first to count the total and the second time to actually build the targets. This would be necessary because you can't know in advance which target(s) the user actually requested to be built. The entire build may consist of thousands of Nodes, for example, but maybe the user specifically requested that only a single object file be built.)
SCons, like most build tools, returns zero status to the shell on success and nonzero status on failure. Sometimes it's useful to give more information about the build status at the end of the run, for instance to print an informative message, send an email, or page the poor slob who broke the build.
SCons provides a GetBuildFailures
method that
you can use in a python atexit
function
to get a list of objects describing the actions that failed
while attempting to build targets. There can be more
than one if you're using -j
. Here's a
simple example:
import atexit def print_build_failures(): from SCons.Script import GetBuildFailures for bf in GetBuildFailures(): print("%s failed: %s" % (bf.node, bf.errstr)) atexit.register(print_build_failures)
The atexit.register
call
registers print_build_failures
as an atexit
callback, to be called
before SCons exits. When that function is called,
it calls GetBuildFailures
to fetch the list of failed objects.
See the man page
for the detailed contents of the returned objects;
some of the more useful attributes are
.node
,
.errstr
,
.filename
, and
.command
.
The filename
is not necessarily
the same file as the node
; the
node
is the target that was
being built when the error occurred, while the
filename
is the file or dir that
actually caused the error.
Note: only call GetBuildFailures
at the end of the
build; calling it at any other time is undefined.
Here is a more complete example showing how to
turn each element of GetBuildFailures
into a string:
# Make the build fail if we pass fail=1 on the command line if ARGUMENTS.get('fail', 0): Command('target', 'source', ['/bin/false']) def bf_to_str(bf): """Convert an element of GetBuildFailures() to a string in a useful way.""" import SCons.Errors if bf is None: # unknown targets product None in list return '(unknown tgt)' elif isinstance(bf, SCons.Errors.StopError): return str(bf) elif bf.node: return str(bf.node) + ': ' + bf.errstr elif bf.filename: return bf.filename + ': ' + bf.errstr return 'unknown failure: ' + bf.errstr import atexit def build_status(): """Convert the build status to a 2-tuple, (status, msg).""" from SCons.Script import GetBuildFailures bf = GetBuildFailures() if bf: # bf is normally a list of build failures; if an element is None, # it's because of a target that scons doesn't know anything about. status = 'failed' failures_message = "\n".join(["Failed building %s" % bf_to_str(x) for x in bf if x is not None]) else: # if bf is None, the build completed successfully. status = 'ok' failures_message = '' return (status, failures_message) def display_build_status(): """Display the build status. Called by atexit. Here you could do all kinds of complicated things.""" status, failures_message = build_status() if status == 'failed': print("FAILED!!!!") # could display alert, ring bell, etc. elif status == 'ok': print("Build succeeded.") print(failures_message) atexit.register(display_build_status)
When this runs, you'll see the appropriate output:
%scons -Q
scons: `.' is up to date. Build succeeded. %scons -Q fail=1
scons: *** [target] Source `source' not found, needed by target `target'. FAILED!!!! Failed building target: Source `source' not found, needed by target `target'.
Software builds are rarely completely static, so SCons gives you a number of ways to help control build execution via instructions on the command line. The arguments that can be specified on the command line are broken down into three types:
Command-line arguments that begin with a
-
(hyphen) characters
are called options.
SCons provides ways for you to examine
and act on options and their values,
as well as the ability to define custom options
for your project.
See Section 10.1, “Command-Line Options”, below.
Command-line arguments containing an =
(equal sign) character are called build variables
(or just variables).
SCons provides direct access to
all of the build variable settings from the command line,
as well as a higher-level interface that lets you
define known build variables,
including defining types, default values, help text,
and automatic validation,
as well as applying those to a construction environment.
See Section 10.2, “Command-Line variable
=value
Build Variables”, below.
Command-line arguments that are neither options
nor build variables
(that is, do not begin with a hyphen
and do not contain an equal sign)
are considered targets
that you are telling SCons to build.
SCons provides access to the list of specified targets,
as well as ways to set the default list of targets
from within the SConscript
files.
See Section 10.3, “Command-Line Targets”, below.
SCons has many command-line options that control its behavior.
A command-line option always begins with one
or two hyphen (-
) characters.
The SCons manual page contains the description of
the current options
(see https://scons.org/doc/production/HTML/scons-man.html).
You may find yourself using
certain command-line options every time
you run SCons.
For example, you might find it saves time
to specify -j 2
to have SCons run up to two build commands in parallel.
To avoid having to type -j 2
by hand
every time,
you can set the external environment variable
SCONSFLAGS
to a string containing
-j 2
, as well as any other
command-line options that you want SCons to always use.
SCONSFLAGS
is an exception to the usual rule that
SCons itself avoids looking at environment variables from the
shell you are running.
If, for example,
you are using a POSIX shell such as bash
or zsh
and you always want SCons to use the
-Q
option,
you can set the SCONSFLAGS
environment as follows:
%scons
scons: Reading SConscript files ... scons: done reading SConscript files. scons: Building targets ... ... [build output] ... scons: done building targets. %export SCONSFLAGS="-Q"
%scons
... [build output] ...
For csh-style shells on POSIX systems
you can set the SCONSFLAGS
environment variable as follows:
$ setenv SCONSFLAGS "-Q"
For the Windows command shell (cmd)
you can set the SCONSFLAGS
environment variable as follows:
C:\Users\foo> set SCONSFLAGS="-Q"
To set SCONSFLAGS
more permanently you can add the
setting to the shell's startup file on POSIX systems,
and on Windows you can use the
System Properties
control panel applet
to select Environment Variables
and set it there.
The GetOption
function
lets you query the values set by the various command-line options.
One use case for GetOption
is to check the operation
mode in order to bypass some steps,
for example, checking whether
the -h
(or --help
)
option was given.
Normally, SCons does not print its help text
until after it has read all of the SConscript files,
since any SConscript can make additions to the help text.
Of course, reading all of the SConscript files
takes extra time.
If you know that your configuration does not define
any additional help text in subsidiary SConscript files,
you can speed up displaying the command-line help
by using a GetOption
query as a guard for whether
to load the subsidiary SConscript files:
if not GetOption('help'): SConscript('src/SConscript', export='env')
The same technique can be used to special-case the
clean (GetOption('clean')
)
and no-execute (GetOption('no_exec')
)
modes.
In general, the string that you pass to the
GetOption
function to fetch the value of a command-line
option setting is the same as the "most common" long option name
(beginning with two hyphen characters),
although there are some exceptions.
The list of SCons command-line options
and the GetOption
strings for fetching them,
are available in the
Section 10.1.4, “Strings for Getting or Setting Values of SCons Command-Line Options” section,
below.
GetOption
can be used to retrieve the values of options
defined by calls to AddOption
. A GetOption
call
must appear after the AddOption
call for that option
(unlike the defining of build targets,
this is a case where "order matters" in SCons).
If the AddOption
call supplied a dest
keyword argument, a string with that name is what to pass
as the argument to GetOption
, otherwise it is a
(possibly modified) version of the first long option name -
see AddOption
.
You can also set the values of certain (but not all) SCons
command-line options from within the SConscript
files
by using the SetOption
function.
The strings that you use to set the values of SCons
command-line options are available in the
Section 10.1.4, “Strings for Getting or Setting Values of SCons Command-Line Options” section,
below.
One use of the SetOption
function is to
specify a value for the -j
or --jobs
option,
so that you get the improved performance
of a parallel build without having to specify the option by hand.
A complicating factor is that a good value
for the -j
option is
somewhat system-dependent.
One rough guideline is that the more processors
your system has,
the higher you want to set the
-j
value,
in order to take advantage of the number of CPUs.
For example, suppose the administrators
of your development systems
have standardized on setting a
NUM_CPU
environment variable
to the number of processors on each system.
A little bit of Python code
to access the environment variable
and the SetOption
function
provides the right level of flexibility:
import os num_cpu = int(os.environ.get('NUM_CPU', 2)) SetOption('num_jobs', num_cpu) print("running with -j %s" % GetOption('num_jobs'))
The above snippet of code
sets the value of the --jobs
option
to the value specified in the
NUM_CPU
environment variable.
(This is one of the exception cases
where the string is spelled differently from
the command-line option.
The string for fetching or setting the --jobs
value is num_jobs
for historical reasons.)
The code in this example prints the num_jobs
value for illustrative purposes.
It uses a default value of 2
to provide some minimal parallelism even on
single-processor systems:
% scons -Q
running with -j 2
scons: `.' is up to date.
But if the NUM_CPU
environment variable is set,
then use that for the default number of jobs:
%export NUM_CPU="4"
%scons -Q
running with -j 4 scons: `.' is up to date.
But any explicit
-j
or --jobs
value you specify on the command line is used first,
whether
the NUM_CPU
environment
variable is set or not:
%scons -Q -j 7
running with -j 7 scons: `.' is up to date. %export NUM_CPU="4"
%scons -Q -j 3
running with -j 3 scons: `.' is up to date.
The strings that you can pass to the GetOption
and SetOption
functions usually correspond to the
first long-form option name
(that is, name beginning with two hyphen characters: --
),
after replacing any remaining hyphen characters
with underscores.
SetOption
works for options added with AddOption
,
but only if they were created with
settable=True
in the call to AddOption
(only available in SCons 4.8.0 and later).
The full list of strings and the variables they correspond to is as follows:
String for GetOption and SetOption |
Command-Line Option(s) |
---|---|
cache_debug
|
--cache-debug
|
cache_disable
|
--cache-disable
|
cache_force
|
--cache-force
|
cache_show
|
--cache-show
|
clean
|
-c ,
--clean ,
--remove |
config
|
--config
|
directory
|
-C ,
--directory |
diskcheck
|
--diskcheck
|
duplicate
|
--duplicate
|
file
|
-f ,
--file ,
--makefile ,
--sconstruct |
help
|
-h ,
--help |
ignore_errors
|
--ignore-errors
|
implicit_cache
|
--implicit-cache
|
implicit_deps_changed
|
--implicit-deps-changed
|
implicit_deps_unchanged
|
--implicit-deps-unchanged
|
interactive
|
--interact ,
--interactive |
keep_going
|
-k ,
--keep-going |
max_drift
|
--max-drift
|
no_exec
|
-n ,
--no-exec ,
--just-print ,
--dry-run ,
--recon |
no_site_dir
|
--no-site-dir
|
num_jobs
|
-j ,
--jobs |
profile_file
|
--profile
|
question
|
-q ,
--question |
random
|
--random
|
repository
|
-Y ,
--repository ,
--srcdir |
silent
|
-s ,
--silent ,
--quiet |
site_dir
|
--site-dir
|
stack_size
|
--stack-size
|
taskmastertrace_file
|
--taskmastertrace
|
warn
|
--warn --warning |
You can also define your own command-line options
for the project with the AddOption
function.
The AddOption
function takes the same arguments
as the add_option
method
from the Python standard library module
optparse
[2]
(see https://docs.python.org/3/library/optparse.html).
Once you add a custom command-line option
with the AddOption
function,
the value of the option (if any) is immediately available
using the GetOption
function.
The argument to GetOption
must be the name of the
variable which holds the option.
If the dest
keyword argument to AddOption
is specified, the value is the
variable name.
given. If not given, it is the name
(without the leading hyphens) of the first long option name
given to AddOption
after replacing any remaining hyphen characters
with underscores, since hyphens are not legal in Python
identifier names.
SetOption
works for options added with AddOption
,
but only if they were created with
settable=True
in the call to AddOption
(only available in SCons 4.8.0 and later).
One useful example of using this functionality
is to provide a --prefix
to help describe
where to install files:
AddOption( '--prefix', dest='prefix', type='string', nargs=1, action='store', metavar='DIR', help='installation prefix', ) env = Environment(PREFIX=GetOption('prefix')) installed_foo = env.Install('$PREFIX/usr/bin', 'foo.in') Default(installed_foo)
The above code uses the GetOption
function
to set the $PREFIX
construction variable to a
value you specify with a command-line
option of --prefix
.
Because $PREFIX
expands to a null string if it's not initialized,
running SCons without the
option of --prefix
installs the file in the
/usr/bin/
directory:
% scons -Q -n
Install file: "foo.in" as "/usr/bin/foo.in"
But specifying --prefix=/tmp/install
on the command line causes the file to be installed in the
/tmp/install/usr/bin/
directory:
% scons -Q -n --prefix=/tmp/install
Install file: "foo.in" as "/tmp/install/usr/bin/foo.in"
The optparse
parser which SCons uses
allows option-arguments to follow their options after either
an =
or space separator,
however the latter form does not work well in SCons for
added options and should be avoided.
SCons does not place an ordering constraint on the
types of command-line arguments,
so while --input=ARG
is unambiguous,
for --input ARG
it is not possible to tell without instructions whether
ARG
is an argument belonging to the
input
option or a standalone word.
SCons considers words on the command line which do not
begin with hyphen as either command-line build variables
or command-line targets,
both of which are made available for use in an SConscript
(see the immediately following sections for details).
Thus, they must be collected before SConscript
processing
takes place. AddOption
calls do provide the
necessary instructions to resolve the ambiguity,
but as they appear in SConscript
files,
SCons does not have the information early enough,
and unexpected things may happen,
such as option-arguments appearing in the list of targets,
and processing exceptions due to missing option-arguments.
As a result,
this usage style should be avoided when invoking scons.
For single-argument options,
tell your users to use the --input=ARG
form on the command line.
For multiple-argument options
(nargs
value greater than one),
set nargs
to one in the
AddOption
call and either: combine the option-arguments into one word
with a separator, and parse the result in your own code
(see the built-in --debug
option, which
allows specifying multiple arguments as a single comma-separated
word, for an example of such usage); or allow the option to
be specified multiple times by setting
action='append'
. Both methods can be
supported at the same time.
You may want to control various aspects
of your build by allowing
variable
=value
values to be specified on the command line.
For example, suppose you want to be able to
build a debug version of a program
by running SCons as follows:
% scons -Q debug=1
SCons provides an ARGUMENTS
dictionary
that stores all of the
variable
=value
assignments from the command line.
This allows you to modify
aspects of your build in response
to specifications on the command line.
The following code sets the $CCFLAGS
construction variable
in response to the debug
flag being set in the ARGUMENTS
dictionary:
env = Environment() debug = ARGUMENTS.get('debug', 0) if int(debug): env.Append(CCFLAGS='-g') env.Program('prog.c')
This results in the -g
compiler option being used when
debug=1
is used on the command line:
%scons -Q debug=0
cc -o prog.o -c prog.c cc -o prog prog.o %scons -Q debug=0
scons: `.' is up to date. %scons -Q debug=1
cc -o prog.o -c -g prog.c cc -o prog prog.o %scons -Q debug=1
scons: `.' is up to date.
Two usage notes (both shown in the example above):
No matter how you intend to use them, the values read from a command line (i.e., external to the program) are always strings. You may need to do type conversion.
When you retrieve from the ARGUMENTS
dictionary,
it is useful to use the Python dictionary
get
method,
so you can supply a default value if the variable is
not given on the command line. Otherwise, the build
will fail with a KeyError
if the variable is not set.
SCons keeps track of the precise build command used to build each object file,
and as a result can determine that the object and executable files
need rebuilding when the value of the debug
argument has changed.
The ARGUMENTS
dictionary has two minor drawbacks.
First, because it is a dictionary,
it can only map each keyword to one value,
and thus only "remembers" the last setting
for each keyword on the command line.
This makes the ARGUMENTS
dictionary
less than ideal if you want to allow
specifying multiple values
on the command line for a given keyword.
Second, it does not preserve
the order in which the variable settings
were specified,
which is a problem if
you want the configuration to
behave differently in response
to the order in which the build
variable settings were specified on the command line
(Python versions since 3.6 now maintain dictionaries in
insertion order, so this problem is mitigated).
To accommodate these requirements,
SCons also provides an ARGLIST
variable
that gives you direct access to build variable
settings from the command line,
in the exact order they were specified,
and without removing any duplicate settings.
Each element in the ARGLIST
variable
is itself a two-element list
containing the keyword and the value
of the setting,
and you must loop through,
or otherwise select from,
the elements of ARGLIST
to
process the specific settings you want
in whatever way is appropriate for your configuration.
For example,
the following code lets you
add to the CPPDEFINES
construction variable
by specifying multiple
define=
settings on the command line:
cppdefines = [] for key, value in ARGLIST: if key == 'define': cppdefines.append(value) env = Environment(CPPDEFINES=cppdefines) env.Object('prog.c')
Yields the following output:
%scons -Q define=FOO
cc -o prog.o -c -DFOO prog.c %scons -Q define=FOO define=BAR
cc -o prog.o -c -DFOO -DBAR prog.c
Note that the ARGLIST
and ARGUMENTS
variables do not interfere with each other,
but rather provide slightly different views
into how you specified
variable
=value
settings on the command line.
You can use both variables in the same
SCons configuration.
In general, the ARGUMENTS
dictionary
is more convenient to use,
(since you can just fetch variable
settings through Python dictionary access),
and the ARGLIST
list
is more flexible
(since you can examine the
specific order in which
the command-line variable settings were given).
Being able to use a command-line build variable like
debug=1
is handy,
but it can be a chore to write specific Python code
to recognize each such variable,
check for errors and provide appropriate messages,
and apply the values to a construction variable.
To help with this,
SCons provides a Variables
container class to
hold definitions of such build variables,
and a mechanism to apply the
build variables to a construction environment.
This allows you to control how the build variables affect
construction environments.
For example, suppose that you want to set
a RELEASE
construction variable on the
command line whenever the time comes to build
a program for release,
and that the value of this variable
should be added to the build command
with the appropriate define
to pass the value to the C compiler.
Here's how you might do that by setting
the appropriate value in a dictionary for the
$CPPDEFINES
construction variable:
vars = Variables(None, ARGUMENTS) vars.Add('RELEASE', default=0) env = Environment(variables=vars, CPPDEFINES={'RELEASE_BUILD': '${RELEASE}'}) env.Program(['foo.c', 'bar.c'])
This SConstruct
snippet first creates a Variables
object which
uses the values from the command-line variables dictionary ARGUMENTS
.
It then uses the object's Add
method to indicate that the RELEASE
variable can be set on the command line, and that
if not set the default value is 0
.
The newly created Variables
object
is passed to the Environment
call
used to create the construction environment
using a variables
keyword argument.
This then allows you to set the
RELEASE
build variable on the command line
and have the variable show up in
the command line used to build each object from
a C source file:
% scons -Q RELEASE=1
cc -o bar.o -c -DRELEASE_BUILD=1 bar.c
cc -o foo.o -c -DRELEASE_BUILD=1 foo.c
cc -o foo foo.o bar.o
The Variables()
call in this example looks
a little awkward. The function takes two optional arguments:
a script name and a dictionary. In order to specify the
dictionary as the second argument, you must provide the
script argument as the first; since there's actually no script,
use None
as a sentinel value.
However, if you omit all the arguments,
the default behavior is to read from the ARGUMENTS
dictionary anyway,
which is what we want. The example shows it this way because the arguments
were introduced in this order, but you should feel free to just
leave off the arguments if the default behavior is what you want.
Historical note: In old SCons (prior to 0.98.1 from 2008),
these build variables were known as "command-line build options."
At that time, the class was named Options
and the predefined functions to construct options were named
BoolOption
, EnumOption
, ListOption
,
PathOption
, PackageOption
and AddOptions
(contrast
with the current names in
Section 10.2.4, “Pre-Defined Build Variable Functions”, below).
Because the Internet has a very long memory,
you may encounter these names in older
SConscript
files, wiki pages, blog entries, StackExchange
articles, etc.
These old names no longer work, but a mental substitution
of “Variable” for “Option”
allows the concepts to transfer to current usage models.
To make command-line build variables more useful,
you may want to provide
some help text to describe the available variables
when you ask for help (run scons -h
).
You can write this text by hand,
but SCons provides some assistance.
Variables objects provide a
GenerateHelpText
method to
generate text that describes
the various variables that
have been added to it. The default text includes
the help string itself plus other information
such as allowed values.
(The generated text can also be customized by
replacing the FormatVariableHelpText
method).
You then pass the output from this method to
the Help
function:
vars = Variables() vars.Add('RELEASE', help='Set to 1 to build for release', default=0) env = Environment(variables=vars) Help(vars.GenerateHelpText(env))
scons now displays some useful text
when the -h
option is used:
% scons -Q -h
RELEASE: Set to 1 to build for release
default: 0
actual: 0
Use scons -H for help about SCons built-in command-line options.
You can see the help output shows the default value as well as the current actual value of the build variable.
Being able to specify the
value of a build variable on the command line
is useful,
but can still become tedious
if you have to specify the variable
every time you run SCons.
To make this easier,
you can provide customized build variable settings
in a Python script by providing a file name when the
Variables
object is created:
vars = Variables('custom.py') vars.Add('RELEASE', help='Set to 1 to build for release', default=0) env = Environment(variables=vars, CPPDEFINES={'RELEASE_BUILD': '${RELEASE}'}) env.Program(['foo.c', 'bar.c']) Help(vars.GenerateHelpText(env))
This then allows you to control the RELEASE
variable by setting it in the custom.py
script:
RELEASE = 1
Note that this file is actually executed like a Python script. Now when you run SCons:
% scons -Q
cc -o bar.o -c -DRELEASE_BUILD=1 bar.c
cc -o foo.o -c -DRELEASE_BUILD=1 foo.c
cc -o foo foo.o bar.o
And if you change the contents of custom.py
to:
RELEASE = 0
The object files are rebuilt appropriately with the new variable:
% scons -Q
cc -o bar.o -c -DRELEASE_BUILD=0 bar.c
cc -o foo.o -c -DRELEASE_BUILD=0 foo.c
cc -o foo foo.o bar.o
Finally, you can combine both methods with:
vars = Variables('custom.py', ARGUMENTS)
If both a variables script and a dictionary are supplied, the dictionary is evaluated last, so values from the command line "win" if there are any duplicate keys. This rule allows you to move some common settings to a variables script, but still be able to override those for a given build without changing the script.
SCons provides a number of convenience functions
that provide behavior definitions
for various types of command-line build variables.
These functions all return a tuple which is ready
to be passed to the Add
or AddVariables
method call.
You are of course free to define your own behaviors
as well.
It is often handy to be able to specify a
variable that controls a simple Boolean variable
with a true
or false
value.
It would be even more handy to accommodate
different preferences for how to represent
true
or false
values.
The BoolVariable
function
makes it easy to accommodate these
common representations of
true
or false
.
The BoolVariable
function takes three arguments:
the name of the build variable,
the default value of the build variable,
and the help string for the variable.
It then returns appropriate information for
passing to the Add
method of a Variables
object, like so:
vars = Variables('custom.py') vars.Add(BoolVariable('RELEASE', help='Set to build for release', default=False)) env = Environment(variables=vars, CPPDEFINES={'RELEASE_BUILD': '${RELEASE}'}) env.Program('foo.c')
With this build variable in place,
the RELEASE
variable can now be enabled by
setting it to the value yes
or t
:
% scons -Q RELEASE=yes foo.o
cc -o foo.o -c -DRELEASE_BUILD=True foo.c
% scons -Q RELEASE=t foo.o
cc -o foo.o -c -DRELEASE_BUILD=True foo.c
Other values that equate to true
include
y
,
1
,
on
and
all
.
Conversely, RELEASE
may now be given a false
value by setting it to
no
or
f
:
% scons -Q RELEASE=no foo.o
cc -o foo.o -c -DRELEASE_BUILD=False foo.c
% scons -Q RELEASE=f foo.o
cc -o foo.o -c -DRELEASE_BUILD=False foo.c
Other values that equate to false
include
n
,
0
,
off
and
none
.
Lastly, if you try to specify any other value, SCons supplies an appropriate error message:
% scons -Q RELEASE=bad_value foo.o
scons: *** Error converting option: 'RELEASE'
Invalid value for boolean variable: 'bad_value'
File "/home/my/project/SConstruct", line 3, in <module>
Suppose that you want to allow
setting a COLOR
variable
that selects a background color to be
displayed by an application,
but that you want to restrict the
choices to a specific set of allowed colors.
You can set this up quite easily
using the EnumVariable
function,
which takes a list of allowed_values
in addition to the variable name,
default value,
and help text arguments:
vars = Variables('custom.py') vars.Add( EnumVariable( 'COLOR', help='Set background color', default='red', allowed_values=('red', 'green', 'blue'), ) ) env = Environment(variables=vars, CPPDEFINES={'COLOR': '"${COLOR}"'}) env.Program('foo.c') Help(vars.GenerateHelpText(env))
You can now explicitly set the COLOR
build variable
to any of the specified allowed values:
%scons -Q COLOR=red foo.o
cc -o foo.o -c -DCOLOR="red" foo.c %scons -Q COLOR=blue foo.o
cc -o foo.o -c -DCOLOR="blue" foo.c %scons -Q COLOR=green foo.o
cc -o foo.o -c -DCOLOR="green" foo.c
But, importantly,
an attempt to set COLOR
to a value that's not in the list
generates an error message:
% scons -Q COLOR=magenta foo.o
scons: *** Invalid value for enum variable 'COLOR': 'magenta'. Valid values are: ('red', 'green', 'blue')
File "/home/my/project/SConstruct", line 10, in <module>
This example can also serve to further illustrate help
generation: the help message here picks up not only the
help
text, but augments it with
information gathered from allowed_values
and default
:
% scons -Q -h
COLOR: Set background color (red|green|blue)
default: red
actual: red
Use scons -H for help about SCons built-in command-line options.
The EnumVariable
function also provides a way
to map alternate names to allowed values.
Suppose, for example, you want to allow
the word navy
to be used as a synonym for
blue
.
You do this by adding a map
dictionary
that maps its key values
to the desired allowed value:
vars = Variables('custom.py') vars.Add( EnumVariable( 'COLOR', help='Set background color', default='red', allowed_values=('red', 'green', 'blue'), map={'navy': 'blue'}, ) ) env = Environment(variables=vars, CPPDEFINES={'COLOR': '"${COLOR}"'}) env.Program('foo.c')
Now you can supply
navy
on the command line,
and SCons translates that into blue
when it comes time to use the COLOR
variable to build a target:
% scons -Q COLOR=navy foo.o
cc -o foo.o -c -DCOLOR="blue" foo.c
By default, when using the EnumVariable
function,
the allowed values are case-sensitive:
%scons -Q COLOR=Red foo.o
scons: *** Invalid value for enum variable 'COLOR': 'Red'. Valid values are: ('red', 'green', 'blue') File "/home/my/project/SConstruct", line 10, in <module> %scons -Q COLOR=BLUE foo.o
scons: *** Invalid value for enum variable 'COLOR': 'BLUE'. Valid values are: ('red', 'green', 'blue') File "/home/my/project/SConstruct", line 10, in <module> %scons -Q COLOR=nAvY foo.o
scons: *** Invalid value for enum variable 'COLOR': 'nAvY'. Valid values are: ('red', 'green', 'blue') File "/home/my/project/SConstruct", line 10, in <module>
The EnumVariable
function can take an additional
ignorecase
keyword argument that,
when set to 1
,
tells SCons to allow case differences
when the values are specified:
vars = Variables('custom.py') vars.Add( EnumVariable( 'COLOR', help='Set background color', default='red', allowed_values=('red', 'green', 'blue'), map={'navy': 'blue'}, ignorecase=1, ) ) env = Environment(variables=vars, CPPDEFINES={'COLOR': '"${COLOR}"'}) env.Program('foo.c')
Which yields the output:
%scons -Q COLOR=Red foo.o
cc -o foo.o -c -DCOLOR="Red" foo.c %scons -Q COLOR=BLUE foo.o
cc -o foo.o -c -DCOLOR="BLUE" foo.c %scons -Q COLOR=nAvY foo.o
cc -o foo.o -c -DCOLOR="blue" foo.c %scons -Q COLOR=green foo.o
cc -o foo.o -c -DCOLOR="green" foo.c
Notice that an ignorecase
value of 1
preserves the case-spelling supplied,
only ignoring the case for matching.
If you want SCons to translate the names
into lower-case,
regardless of the case used by the user,
specify an ignorecase
value of 2
:
vars = Variables('custom.py') vars.Add( EnumVariable( 'COLOR', help='Set background color', default='red', allowed_values=('red', 'green', 'blue'), map={'navy': 'blue'}, ignorecase=2, ) ) env = Environment(variables=vars, CPPDEFINES={'COLOR': '"${COLOR}"'}) env.Program('foo.c')
Now SCons uses values of
red
,
green
or
blue
regardless of how those values are spelled
on the command line:
%scons -Q COLOR=Red foo.o
cc -o foo.o -c -DCOLOR="red" foo.c %scons -Q COLOR=nAvY foo.o
cc -o foo.o -c -DCOLOR="blue" foo.c %scons -Q COLOR=GREEN foo.o
cc -o foo.o -c -DCOLOR="green" foo.c
Another way in which you might want to control a build variable is to
specify a list of allowed values, of which one or more can be chosen
(where EnumVariable
allows exactly one value to be chosen).
SCons provides this through the ListVariable
function.
If, for example, you want to be able to set a
COLORS
variable to one or more of the allowed values:
vars = Variables('custom.py') vars.Add( ListVariable( 'COLORS', help='List of colors', default=0, names=['red', 'green', 'blue'] ) ) env = Environment(variables=vars, CPPDEFINES={'COLORS': '"${COLORS}"'}) env.Program('foo.c')
You can now specify a comma-separated list of allowed values, which get translated into a space-separated list for passing to the build commands:
%scons -Q COLORS=red,blue foo.o
cc -o foo.o -c -DCOLORS="red -Dblue" foo.c %scons -Q COLORS=blue,green,red foo.o
cc -o foo.o -c -DCOLORS="blue -Dgreen -Dred" foo.c
In addition, the ListVariable
function
lets you specify explicit keywords of
all
or none
to select all of the allowed values,
or none of them, respectively:
%scons -Q COLORS=all foo.o
cc -o foo.o -c -DCOLORS="red -Dgreen -Dblue" foo.c %scons -Q COLORS=none foo.o
cc -o foo.o -c -DCOLORS="" foo.c
And, of course, an illegal value still generates an error message:
% scons -Q COLORS=magenta foo.o
scons: *** Invalid value(s) for variable 'COLORS': 'magenta'. Valid values are: blue,green,red,all,none
File "/home/my/project/SConstruct", line 7, in <module>
You can use this last characteristic as a way to enforce at least
one of your valid options being chosen by specifying the valid
values with the names
parameter and then
giving a value not in that list as the default
parameter - that way if no value is given on the command line,
the default is chosen, SCons errors out as this is invalid.
The example is, in fact, set up that way by using
0
as the default:
% scons -Q foo.o
scons: *** Invalid value(s) for variable 'COLORS': '0'. Valid values are: blue,green,red,all,none
File "/home/my/project/SConstruct", line 7, in <module>
This technique works for EnumVariable
as well.
SCons provides a PathVariable
function
to make it easy to create a build variable
to control an expected path name.
If, for example, you need to
define a preprocessor macro
that controls the location of a
configuration file:
vars = Variables('custom.py') vars.Add( PathVariable( 'CONFIG', help='Path to configuration file', default='/etc/my_config' ) ) env = Environment(variables=vars, CPPDEFINES={'CONFIG_FILE': '"$CONFIG"'}) env.Program('foo.c')
This allows you to
override the CONFIG
build variable
on the command line as necessary:
%scons -Q foo.o
cc -o foo.o -c -DCONFIG_FILE="/etc/my_config" foo.c %scons -Q CONFIG=/usr/local/etc/other_config foo.o
scons: `foo.o' is up to date.
By default, PathVariable
checks to make sure
that the specified path exists and generates an error if it
doesn't:
% scons -Q CONFIG=/does/not/exist foo.o
scons: *** Path for variable 'CONFIG' does not exist: /does/not/exist
File "/home/my/project/SConstruct", line 7, in <module>
PathVariable
provides a number of methods
that you can use to change this behavior.
If you want to ensure that any specified paths are,
in fact, files and not directories,
use the PathVariable.PathIsFile
method as the validation function:
vars = Variables('custom.py') vars.Add( PathVariable( 'CONFIG', help='Path to configuration file', default='/etc/my_config', validator=PathVariable.PathIsFile, ) ) env = Environment(variables=vars, CPPDEFINES={'CONFIG_FILE': '"$CONFIG"'}) env.Program('foo.c')
Conversely, to ensure that any specified paths are
directories and not files,
use the PathVariable.PathIsDir
method as the validation function:
vars = Variables('custom.py') vars.Add( PathVariable( 'DBDIR', help='Path to database directory', default='/var/my_dbdir', validator=PathVariable.PathIsDir, ) ) env = Environment(variables=vars, CPPDEFINES={'DBDIR': '"$DBDIR"'}) env.Program('foo.c')
If you want to make sure that any specified paths
are directories,
and you would like the directory created
if it doesn't already exist,
use the PathVariable.PathIsDirCreate
method as the validation function:
vars = Variables('custom.py') vars.Add( PathVariable( 'DBDIR', help='Path to database directory', default='/var/my_dbdir', validator=PathVariable.PathIsDirCreate, ) ) env = Environment(variables=vars, CPPDEFINES={'DBDIR': '"$DBDIR"'}) env.Program('foo.c')
Lastly, if you don't care whether the path exists,
is a file, or a directory,
use the PathVariable.PathAccept
method
to accept any path you supply:
vars = Variables('custom.py') vars.Add( PathVariable( 'OUTPUT', help='Path to output file or directory', default=None, validator=PathVariable.PathAccept, ) ) env = Environment(variables=vars, CPPDEFINES={'OUTPUT': '"$OUTPUT"'}) env.Program('foo.c')
Sometimes you want to give
even more control over a path name variable,
allowing them to be explicitly enabled or disabled
by using yes
or no
keywords,
in addition to allowing supplying an explicit path name.
SCons provides the PackageVariable
function to support this:
vars = Variables("custom.py") vars.Add( PackageVariable("PACKAGE", help="Location package", default="/opt/location") ) env = Environment(variables=vars, CPPDEFINES={"PACKAGE": '"$PACKAGE"'}) env.Program("foo.c")
When the SConscript
file uses the PackageVariable
function,
you can still use the default
or supply an overriding path name,
but you can now explicitly set the
specified variable to a value
that indicates the package should be enabled
(in which case the default should be used)
or disabled:
%scons -Q foo.o
cc -o foo.o -c -DPACKAGE="/opt/location" foo.c %scons -Q PACKAGE=/usr/local/location foo.o
cc -o foo.o -c -DPACKAGE="/usr/local/location" foo.c %scons -Q PACKAGE=yes foo.o
cc -o foo.o -c -DPACKAGE="True" foo.c %scons -Q PACKAGE=no foo.o
cc -o foo.o -c -DPACKAGE="False" foo.c
Lastly, SCons provides a way to add
multiple build variables to a Variables
object at once.
Instead of having to call the Add
method
multiple times, you can call the AddVariables
method with the build variables to be added to the object.
Each build variable is specified
as either a tuple of arguments,
or as a call to one of the pre-defined
functions for pre-packaged command-line build variables,
which returns such a tuple. Note that an individual tuple
cannot take keyword arguments in the way that a call to
Add
or one of the build variable functions can.
The order of variables given to AddVariables
does not
matter.
vars = Variables() vars.AddVariables( ('RELEASE', 'Set to 1 to build for release', 0), ('CONFIG', 'Configuration file', '/etc/my_config'), BoolVariable('warnings', help='compilation with -Wall and similar', default=True), EnumVariable( 'debug', help='debug output and symbols', default='no', allowed_values=('yes', 'no', 'full'), map={}, ignorecase=0, ), ListVariable( 'shared', help='libraries to build as shared libraries', default='all', names=list_of_libs, ), PackageVariable( 'x11', help='use X11 installed here (yes = search some places)', default='yes' ), PathVariable('qtdir', help='where the root of Qt is installed', default=qtdir), )
Humans, of course,
occasionally misspell variable names in their command-line settings.
SCons does not generate an error or warning
for any unknown variables specified on the command line,
because it can not reliably tell
whether a given "misspelled" variable is
really unknown and a potential problem or not.
After all, you might be processing arguments directly
using ARGUMENTS
or ARGLIST
with some Python
code in your SConscript
file.
If, however, you are using a Variables
object to
define a specific set of command-line build variables
that you expect to be able to set,
you may want to provide an error
message or warning of your own
if a variable setting is specified
that is not among
the defined list of variable names known to the Variables
object.
You can do this by calling the UnknownVariables
method of the Variables
object to get the
settings Variables
did not recognize:
vars = Variables(None) vars.Add('RELEASE', help='Set to 1 to build for release', default=0) env = Environment(variables=vars, CPPDEFINES={'RELEASE_BUILD': '${RELEASE}'}) unknown = vars.UnknownVariables() if unknown: print("Unknown variables: %s" % " ".join(unknown.keys())) Exit(1) env.Program('foo.c')
The UnknownVariables
method returns a dictionary
containing the keywords and values
of any variables specified on the command line
that are not
among the variables known to the Variables
object
(from having been specified using
the Variables
object's Add
method).
The example above,
checks whether the dictionary
returned by UnknownVariables
is non-empty,
and if so prints the Python list
containing the names of the unknown variables
and then calls the Exit
function
to terminate SCons:
% scons -Q NOT_KNOWN=foo
Unknown variables: NOT_KNOWN
Of course, you can process the items in the
dictionary returned by the UnknownVariables
function
in any way appropriate to your build configuration,
including just printing a warning message
but not exiting,
logging an error somewhere,
etc.
Note that you must delay the call of UnknownVariables
until after you have applied the Variables
object
to a construction environment
with the variables=
keyword argument of an Environment
call: the variables
in the object are not fully processed until this has happened.
SCons provides a COMMAND_LINE_TARGETS
variable
that lets you fetch the list of targets that were
specified on the command line.
You can use the targets to manipulate the
build in any way you wish.
As a simple example,
suppose that you want to print a reminder
whenever a specific program is built.
You can do this by checking for the
target in the COMMAND_LINE_TARGETS
list:
if 'bar' in COMMAND_LINE_TARGETS: print("Don't forget to copy `bar' to the archive!") Default(Program('foo.c')) Program('bar.c')
Now, running SCons with the default target
works as usual,
but explicitly specifying the bar
target
on the command line generates the warning message:
%scons -Q
cc -o foo.o -c foo.c cc -o foo foo.o %scons -Q bar
Don't forget to copy `bar' to the archive! cc -o bar.o -c bar.c cc -o bar bar.o
Another practical use for the COMMAND_LINE_TARGETS
variable
might be to speed up a build
by only reading certain subsidiary SConscript
files if a specific target is requested.
You can control
which targets SCons builds by default - that is,
when there are no targets specified on the command line.
As mentioned previously,
SCons normally builds every target
in or below the current directory unless you
explicitly specify one or more targets
on the command line.
Sometimes, however, you may want
to specify that only
certain programs, or programs in certain directories,
should be built by default.
You do this with the Default
function:
env = Environment() hello = env.Program('hello.c') env.Program('goodbye.c') Default(hello)
This SConstruct
file knows how to build two programs,
hello
and goodbye
,
but only builds the
hello
program by default:
%scons -Q
cc -o hello.o -c hello.c cc -o hello hello.o %scons -Q
scons: `hello' is up to date. %scons -Q goodbye
cc -o goodbye.o -c goodbye.c cc -o goodbye goodbye.o
Note that, even when you use the Default
function in your SConstruct
file,
you can still explicitly specify the current directory
(.
) on the command line
to tell SCons to build
everything in (or below) the current directory:
% scons -Q .
cc -o goodbye.o -c goodbye.c
cc -o goodbye goodbye.o
cc -o hello.o -c hello.c
cc -o hello hello.o
You can also call the Default
function more than once,
in which case each call
adds to the list of targets to be built by default:
env = Environment() prog1 = env.Program('prog1.c') Default(prog1) prog2 = env.Program('prog2.c') prog3 = env.Program('prog3.c') Default(prog3)
Or you can specify more than one target
in a single call to the Default
function:
env = Environment() prog1 = env.Program('prog1.c') prog2 = env.Program('prog2.c') prog3 = env.Program('prog3.c') Default(prog1, prog3)
Either of these last two examples build only the prog1 and prog3 programs by default:
%scons -Q
cc -o prog1.o -c prog1.c cc -o prog1 prog1.o cc -o prog3.o -c prog3.c cc -o prog3 prog3.o %scons -Q .
cc -o prog2.o -c prog2.c cc -o prog2 prog2.o
You can list a directory as
an argument to Default
:
env = Environment() env.Program(['prog1/main.c', 'prog1/foo.c']) env.Program(['prog2/main.c', 'prog2/bar.c']) Default('prog1')
In which case only the target(s) in that directory are built by default:
%scons -Q
cc -o prog1/foo.o -c prog1/foo.c cc -o prog1/main.o -c prog1/main.c cc -o prog1/main prog1/main.o prog1/foo.o %scons -Q
scons: `prog1' is up to date. %scons -Q .
cc -o prog2/bar.o -c prog2/bar.c cc -o prog2/main.o -c prog2/main.c cc -o prog2/main prog2/main.o prog2/bar.o
Lastly, if for some reason you don't want
any targets built by default,
you can use the Python None
variable:
env = Environment() prog1 = env.Program('prog1.c') prog2 = env.Program('prog2.c') Default(None)
Which would produce build output like:
%scons -Q
scons: *** No targets specified and no Default() targets found. Stop. Found nothing to build %scons -Q .
cc -o prog1.o -c prog1.c cc -o prog1 prog1.o cc -o prog2.o -c prog2.c cc -o prog2 prog2.o
SCons provides a DEFAULT_TARGETS
variable
that lets you get at the current list of default targets
specified by calls to the Default
function or method.
The DEFAULT_TARGETS
variable has
two important differences from the COMMAND_LINE_TARGETS
variable.
First, the DEFAULT_TARGETS
variable is a list of
internal SCons nodes,
so you need to convert the list elements to strings
if you want to print them or look for a specific target name.
You can do this easily by calling the str
on the elements in a list comprehension:
prog1 = Program('prog1.c') Default(prog1) print("DEFAULT_TARGETS is %s" % [str(t) for t in DEFAULT_TARGETS])
(Keep in mind that the manipulation of the
DEFAULT_TARGETS
list takes place during the
first phase when SCons is reading up the SConscript
files,
which is obvious if
you leave off the -Q
flag when you run SCons:)
% scons
scons: Reading SConscript files ...
DEFAULT_TARGETS is ['prog1']
scons: done reading SConscript files.
scons: Building targets ...
cc -o prog1.o -c prog1.c
cc -o prog1 prog1.o
scons: done building targets.
Second,
the contents of the DEFAULT_TARGETS
list changes
in response to calls to the Default
function,
as you can see from the following SConstruct
file:
prog1 = Program('prog1.c') Default(prog1) print("DEFAULT_TARGETS is now %s" % [str(t) for t in DEFAULT_TARGETS]) prog2 = Program('prog2.c') Default(prog2) print("DEFAULT_TARGETS is now %s" % [str(t) for t in DEFAULT_TARGETS])
Which yields the output:
% scons
scons: Reading SConscript files ...
DEFAULT_TARGETS is now ['prog1']
DEFAULT_TARGETS is now ['prog1', 'prog2']
scons: done reading SConscript files.
scons: Building targets ...
cc -o prog1.o -c prog1.c
cc -o prog1 prog1.o
cc -o prog2.o -c prog2.c
cc -o prog2 prog2.o
scons: done building targets.
In practice, this simply means that you
need to pay attention to the order in
which you call the Default
function
and refer to the DEFAULT_TARGETS
list,
to make sure that you don't examine the
list before you have added the default targets
you expect to find in it.
You have already seen the
COMMAND_LINE_TARGETS
variable,
which contains a list of targets specified on the command line,
and the DEFAULT_TARGETS
variable,
which contains a list of targets specified
via calls to the Default
method or function.
Sometimes, however,
you want a list of whatever targets
SCons tries to build,
regardless of whether the targets came from the
command line or a Default
call.
You could code this up by hand, as follows:
if COMMAND_LINE_TARGETS: targets = COMMAND_LINE_TARGETS else: targets = DEFAULT_TARGETS
SCons, however, provides a convenient
BUILD_TARGETS
variable
that eliminates the need for this by-hand manipulation.
Essentially, the BUILD_TARGETS
variable
contains a list of the command-line targets,
if any were specified,
and if no command-line targets were specified,
it contains a list of the targets specified
via the Default
method or function.
Because BUILD_TARGETS
may contain a list of SCons nodes,
you must convert the list elements to strings
if you want to print them or look for a specific target name,
just like the DEFAULT_TARGETS
list:
prog1 = Program('prog1.c') Program('prog2.c') Default(prog1) print("BUILD_TARGETS is %s" % [str(t) for t in BUILD_TARGETS])
Notice how the value of BUILD_TARGETS
changes depending on whether a target is
specified on the command line - BUILD_TARGETS
takes from DEFAULT_TARGETS
only if there are no COMMAND_LINE_TARGETS
:
%scons -Q
BUILD_TARGETS is ['prog1'] cc -o prog1.o -c prog1.c cc -o prog1 prog1.o %scons -Q prog2
BUILD_TARGETS is ['prog2'] cc -o prog2.o -c prog2.c cc -o prog2 prog2.o %scons -Q -c .
BUILD_TARGETS is ['.'] Removed prog1.o Removed prog1 Removed prog2.o Removed prog2
Once a program is built,
it is often appropriate to install it in another
directory for public use.
You use the Install
method
to arrange for a program, or any other file,
to be copied into a destination directory:
env = Environment() hello = env.Program('hello.c') env.Install('/usr/bin', hello)
Note, however, that installing a file is
still considered a type of file "build."
This is important when you remember that
the default behavior of SCons is
to build files in or below the current directory.
If, as in the example above,
you are installing files in a directory
outside of the top-level SConstruct
file's directory tree,
you must specify that directory
(or a higher directory, such as /
)
for it to install anything there:
%scons -Q
cc -o hello.o -c hello.c cc -o hello hello.o %scons -Q /usr/bin
Install file: "hello" as "/usr/bin/hello"
It can, however, be cumbersome to remember
(and type) the specific destination directory
in which the program (or other file)
should be installed. A call to Default
can be used to
add the directory to the list of default targets,
removing the need to type it,
but sometimes you don't want to install on every build.
This is an area where the Alias
function comes in handy,
allowing you, for example,
to create a pseudo-target named install
that can expand to the specified destination directory:
env = Environment() hello = env.Program('hello.c') env.Install('/usr/bin', hello) env.Alias('install', '/usr/bin')
This then yields the more natural ability to install the program in its destination as a separate invocation, as follows:
%scons -Q
cc -o hello.o -c hello.c cc -o hello hello.o %scons -Q install
Install file: "hello" as "/usr/bin/hello"
You can install multiple files into a directory
simply by calling the Install
function multiple times:
env = Environment() hello = env.Program('hello.c') goodbye = env.Program('goodbye.c') env.Install('/usr/bin', hello) env.Install('/usr/bin', goodbye) env.Alias('install', '/usr/bin')
Or, more succinctly, listing the multiple input files in a list (just like you can do with any other builder):
env = Environment() hello = env.Program('hello.c') goodbye = env.Program('goodbye.c') env.Install('/usr/bin', [hello, goodbye]) env.Alias('install', '/usr/bin')
Either of these two examples yields:
% scons -Q install
cc -o goodbye.o -c goodbye.c
cc -o goodbye goodbye.o
Install file: "goodbye" as "/usr/bin/goodbye"
cc -o hello.o -c hello.c
cc -o hello hello.o
Install file: "hello" as "/usr/bin/hello"
The Install
method preserves the name
of the file when it is copied into the
destination directory.
If you need to change the name of the file
when you copy it, use the InstallAs
function:
env = Environment() hello = env.Program('hello.c') env.InstallAs('/usr/bin/hello-new', hello) env.Alias('install', '/usr/bin')
This installs the hello
program with the name hello-new
as follows:
% scons -Q install
cc -o hello.o -c hello.c
cc -o hello hello.o
Install file: "hello" as "/usr/bin/hello-new"
If you have multiple files that all
need to be installed with different file names,
you can either call the InstallAs
function
multiple times, or as a shorthand,
you can supply same-length lists
for both the target and source arguments:
env = Environment() hello = env.Program('hello.c') goodbye = env.Program('goodbye.c') env.InstallAs(['/usr/bin/hello-new', '/usr/bin/goodbye-new'], [hello, goodbye]) env.Alias('install', '/usr/bin')
In this case, the InstallAs
function
loops through both lists simultaneously,
and copies each source file into its corresponding
target file name:
% scons -Q install
cc -o goodbye.o -c goodbye.c
cc -o goodbye goodbye.o
Install file: "goodbye" as "/usr/bin/goodbye-new"
cc -o hello.o -c hello.c
cc -o hello hello.o
Install file: "hello" as "/usr/bin/hello-new"
If a shared library is created with the
$SHLIBVERSION
variable set,
scons will create symbolic links as needed based on that
variable. To properly install such a library including the
symbolic links, use the InstallVersionedLib
function.
For example, on a Linux system, this instruction:
foo = env.SharedLibrary(target="foo", source="foo.c", SHLIBVERSION="1.2.3")
Will produce a shared library
libfoo.so.1.2.3
and symbolic links
libfoo.so
and
libfoo.so.1
which point to
libfoo.so.1.2.3
.
You can use the Node returned by the SharedLibrary
builder in order to install the library and its
symbolic links in one go without having to list
them individually:
env.InstallVersionedLib(target="lib", source=foo)
On systems which expect a shared library to be installed both with
a name that indicates the version, for run-time resolution,
and as a plain name, for link-time resolution, the
InstallVersionedLib
function can be used. Symbolic links
appropriate to the type of system will be generated based on
symlinks of the source library.
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 don't have a suitable pre-existing builder.
[3]
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 $TARGET
and $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 $TARGET
or $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", action=[ 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")
The Copy
factory has a third optional argument which controls
how symlinks are copied.
# Symbolic link shallow copied as a new symbolic link: Command("LinkIn", "LinkOut", Copy("$TARGET", "$SOURCE", symlinks=True)) # Symbolic link target copied as a file or directory: Command("LinkIn", "FileOrDirectoryOut", Copy("$TARGET", "$SOURCE", symlinks=False))
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", action=[ Delete("tempfile"), Copy("tempfile", "$SOURCE"), "modify tempfile", Copy("$TARGET", "tempfile"), ], )
Which 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
$TARGET
and $SOURCE
variables appropriately.
For example:
Command( "file.out", "file.in", action=[ 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.
One word of caution about using the Delete
factory:
it has the same variable expansions available
as any other factory, including the $SOURCE
variable.
Specifying Delete("$SOURCE")
is not something you usually want to do!
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 use:
Command( "file.out", "file.in", action=[ 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", action=[ Copy("$TARGET", "$SOURCE"), Touch("$TARGET"), ] )
Which executes as:
% scons -Q
Copy("file.out", "file.in")
Touch("file.out")
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 use:
Command( "file.out", "file.in", action=[ 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] tempdir/output_file: 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", action=[ Copy("$TARGET", "$SOURCE"), Chmod("$TARGET", 0o755), ] )
Which executes:
% scons -Q
Copy("file.out", "file.in")
Chmod("file.out", 0o755)
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 using 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.
The Execute
function returns the exit status
or return value of the underlying action being executed.
It will also print an error message if the action
fails and returns a non-zero value.
SCons will not, however,
actually stop the build if the action fails.
If you want the build to stop
in response to a failure in an action called by Execute
,
you must do so by explicitly
checking the return value
and calling the Exit
function
(or a Python equivalent):
if Execute(Mkdir('/tmp/my_temp_directory')): # A problem occurred while making the temp directory. Exit(1)
[3]
Unfortunately, in the early days of SCons design,
we used the name Copy
for the function that
returns a copy of the environment,
otherwise that would be the logical choice for
a Builder that copies a file or directory tree
to a target location.
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.
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)
Although the output doesn't look any different, SCons does not, in fact, delete the target library before rebuilding it:
% scons -Q
cc -o f1.o -c f1.c
cc -o f2.o -c f2.c
cc -o f3.o -c f3.c
ar rc libfoo.a f1.o f2.o f3.o
SCons will, however, still delete files marked as Precious
when the -c
option is used.
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)
Notice that the libfoo.a
is not listed as a removed file:
%scons -Q
cc -o f1.o -c f1.c cc -o f2.o -c f2.c cc -o f3.o -c f3.c ar rc libfoo.a f1.o f2.o f3.o %scons -c
scons: Reading SConscript files ... scons: done reading SConscript files. scons: Cleaning targets ... Removed f1.o Removed f2.o Removed f3.o scons: done cleaning targets.
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')
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
build -o foo.out foo.in %scons -Q -c
Removed foo.out Removed foo.log
The source code for large software projects
rarely stays in a single directory,
but is nearly always divided into a
hierarchy of directories.
Organizing a large software build using SCons
involves creating a hierarchy of build scripts
which are connected together using the SConscript
function.
As we've already seen,
the build script at the top of the tree is called SConstruct
.
The top-level SConstruct
file can
use the SConscript
function to
include other subsidiary scripts in the build.
These subsidiary scripts can, in turn,
use the SConscript
function
to include still other scripts in the build.
By convention, these subsidiary scripts are usually
named SConscript
.
For example, a top-level SConstruct
file might
arrange for four subsidiary scripts to be included
in the build as follows:
SConscript( [ 'drivers/display/SConscript', 'drivers/mouse/SConscript', 'parser/SConscript', 'utilities/SConscript', ] )
In this case, the SConstruct
file
lists all of the SConscript
files in the build explicitly.
(Note, however, that not every directory in the tree
necessarily has an SConscript
file.)
Alternatively, the drivers
subdirectory might contain an intermediate
SConscript
file,
in which case the SConscript
call in
the top-level SConstruct
file
would look like:
SConscript(['drivers/SConscript', 'parser/SConscript', 'utilities/SConscript'])
And the subsidiary SConscript
file in the
drivers
subdirectory
would look like:
SConscript(['display/SConscript', 'mouse/SConscript'])
Whether you list all of the SConscript
files in the
top-level SConstruct
file,
or place a subsidiary SConscript
file in
intervening directories,
or use some mix of the two schemes,
is up to you and the needs of your software.
Subsidiary SConscript
files make it easy to create a build
hierarchy because all of the file and directory names
in a subsidiary SConscript
files are interpreted
relative to the directory in which that SConscript
file lives.
Typically, this allows the SConscript
file containing the
instructions to build a target file
to live in the same directory as the source files
from which the target will be built,
making it easy to update how the software is built
whenever files are added or deleted
(or other changes are made).
It also tends to keep scripts more readable as they don't
need to be filled with complex paths.
For example, suppose we want to build two programs
prog1
and prog2
in two separate directories
with the same names as the programs.
One typical way to do this would be
with a top-level SConstruct
file like this:
SConscript(['prog1/SConscript', 'prog2/SConscript'])
And subsidiary SConscript
files that look like this:
env = Environment() env.Program('prog1', ['main.c', 'foo1.c', 'foo2.c'])
And this:
env = Environment() env.Program('prog2', ['main.c', 'bar1.c', 'bar2.c'])
Then, when we run SCons in the top-level directory, our build looks like:
% scons -Q
cc -o prog1/foo1.o -c prog1/foo1.c
cc -o prog1/foo2.o -c prog1/foo2.c
cc -o prog1/main.o -c prog1/main.c
cc -o prog1/prog1 prog1/main.o prog1/foo1.o prog1/foo2.o
cc -o prog2/bar1.o -c prog2/bar1.c
cc -o prog2/bar2.o -c prog2/bar2.c
cc -o prog2/main.o -c prog2/main.c
cc -o prog2/prog2 prog2/main.o prog2/bar1.o prog2/bar2.o
Notice the following:
First, you can have files with the same names
in multiple directories, like main.c
in the above example.
Second, when building,
SCons stays in the top-level directory
(where the SConstruct
file lives)
and issues commands that use the path names
from the top-level directory to the
target and source files within the hierarchy.
This works because SCons reads all the SConscript files
in one pass, interpreting each in its local context,
building up a tree of information, before starting to
execute the needed builds in a second pass.
This is quite different than some other build tools
which implement a heirarcical build by recursing.
If you need to use a file from another directory,
it's sometimes more convenient to specify
the path to a file in another directory
from the top-level SConstruct
directory,
even when you're using that file in
a subsidiary SConscript
file in a subdirectory.
You can tell SCons to interpret a path name
as relative to the top-level SConstruct
directory,
not the local directory of the SConscript
file,
by prepending a #
(hash mark) in front of the path name:
env = Environment() env.Program('prog', ['main.c', '#lib/foo1.c', 'foo2.c'])
In this example,
the lib
directory is
directly underneath the top-level SConstruct
directory.
If the above SConscript
file is in a subdirectory
named src/prog
,
the output would look like:
% scons -Q
cc -o lib/foo1.o -c lib/foo1.c
cc -o src/prog/foo2.o -c src/prog/foo2.c
cc -o src/prog/main.o -c src/prog/main.c
cc -o src/prog/prog src/prog/main.o lib/foo1.o src/prog/foo2.o
(Notice that the lib/foo1.o
object file
is built in the same directory as its source file.
See Chapter 15, Separating Source and Build Trees: Variant Directories, below,
for information about
how to build the object file in a different subdirectory.)
A couple of notes on top-relative paths:
SCons doesn't care whether you add a slash after the #
.
Some people consider '#/lib/foo1.c'
more readable than '#lib/foo1.c'
,
but they're functionally equivalent.
The top-relative syntax is only
evaluated by SCons, the Python language itself does not
understand about it. This becomes immediately obvious
if you like to use print
for debugging,
or write a Python function that wants to evaluate a path.
You can force SCons to evaluate a top-relative path
and produce a string that can be used by Python code by
creating a Node object from it:
path = "#/include" print("path =", path) print("force-interpreted path =", Entry(path))
Which shows:
% scons -Q
path = #/include
force-interpreted path = include
scons: `.' is up to date.
Of course, you can always specify an absolute path name for a file--for example:
env = Environment() env.Program('prog', ['main.c', '/usr/joe/lib/foo1.c', 'foo2.c'])
Which, when executed, would yield:
% scons -Q
cc -o src/prog/foo2.o -c src/prog/foo2.c
cc -o src/prog/main.o -c src/prog/main.c
cc -o /usr/joe/lib/foo1.o -c /usr/joe/lib/foo1.c
cc -o src/prog/prog src/prog/main.o /usr/joe/lib/foo1.o src/prog/foo2.o
(As was the case with top-relative path names,
notice that the /usr/joe/lib/foo1.o
object file
is built in the same directory as its source file.
See Chapter 15, Separating Source and Build Trees: Variant Directories, below,
for information about
how to build the object file in a different subdirectory.)
In the previous example,
each of the subsidiary SConscript
files
created its own construction environment
by calling Environment
separately.
This obviously works fine,
but if each program must be built
with the same construction variables,
it's cumbersome and error-prone to initialize
separate construction environments
in the same way over and over in each subsidiary
SConscript
file.
SCons supports the ability to export variables
from an SConscript
file
so they can be imported by other
SConscript
files, thus allowing you to share common initialized
values throughout your build hierarchy.
There are two ways to export a variable
from an SConscript
file.
The first way is to call the Export
function.
Export
is pretty flexible - in the simplest form,
you pass it a string that represents the name of
the variable, and Export
stores that with its value:
env = Environment() Export('env')
You may export more than one variable name at a time:
env = Environment() debug = ARGUMENTS['debug'] Export('env', 'debug')
Because a Python identifier cannot contain spaces,
Export
assumes a string containing spaces is is a
shortcut for multiple variable names to export and
splits it up for you:
env = Environment() debug = ARGUMENTS['debug'] Export('env debug')
You can also pass Export
a dictionary of values.
This form allows the opportunity to export a variable
from the current scope under a different name -
in this example, the value of foo
is exported under the name "bar"
:
env = Environment() foo = "FOO" args = {"env": env, "bar": foo} Export(args)
Export
will also accept arguments in keyword style.
This form adds the ability to create exported variables
that have not actually been set locally in the SConscript file.
When used this way, the key is the intended variable name,
not a string representation as with the other forms:
Export(MODE="DEBUG", TARGET="arm")
The styles can be mixed, though Python function calling syntax requires all non-keyword arguments to precede any keyword arguments in the call.
The Export
function adds the variables to a global
location from which other SConscript
files can import.
Calls to Export
are cumulative. When you call Export
you are actually updating a Python dictionary, so it
is fine to export a variable you have already exported,
but when doing so, the previous value is lost.
The other way to export is you can specify a list of
variables as a second argument
to the SConscript
function call:
SConscript('src/SConscript', 'env')
Or (preferably, for readability) using the exports
keyword argument:
SConscript('src/SConscript', exports='env')
These calls export the specified variables
to only the listed SConscript
file(s).
You may specify more than one
SConscript
file in a list:
SConscript(['src1/SConscript', 'src2/SConscript'], exports='env')
This is functionally equivalent to
calling the SConscript
function
multiple times with the same exports
argument,
one per SConscript
file.
Once a variable has been exported from a calling
SConscript
file,
it may be used in other SConscript
files
by calling the Import
function:
Import('env') env.Program('prog', ['prog.c'])
The Import
call makes the previously defined env
variable available to the SConscript
file.
Assuming env
is a construction environment,
after import it can be used to build programs, libraries, etc.
The use case of passing around a construction environment is extremely common
in larger scons builds.
Like the Export
function,
the Import
function can be called
with multiple variable names:
Import('env', 'debug') env = env.Clone(DEBUG=debug) env.Program('prog', ['prog.c'])
In this example, we pull in the common construction environment
env
, and
use the value of the debug
variable to make a modified copy by passing
that to a Clone
call.
The Import
function will (like Export
)
split a string containing white-space
into separate variable names:
Import('env debug') env = env.Clone(DEBUG=debug) env.Program('prog', ['prog.c'])
Import
prefers a local definition to a global one,
so that if there is a global export of foo
,
and the calling SConscript has
exported foo
to this SConscript,
the import will find the foo
exported to this SConscript.
Lastly, as a special case,
you may import all of the variables that
have been exported by supplying an asterisk
to the Import
function:
Import('*') env = env.Clone(DEBUG=debug) env.Program('prog', ['prog.c'])
If you're dealing with a lot of SConscript
files,
this can be a lot simpler than keeping
arbitrary lists of imported variables up to date in each file.
Sometimes, you would like to be able to
use information from a subsidiary
SConscript
file in some way.
For example,
suppose that you want to create one
library from object files built by
several subsidiary SConscript
files.
You can do this by using the Return
function to return values
from the subsidiary SConscript
files
to the calling file. Like Import
and Export
,
Return
takes a string representation of the variable
name, not the variable name itself.
If, for example, we have two subdirectories
foo
and bar
that should each contribute an object
file to a library,
what we'd like to be able to do is
collect the object files
from the subsidiary SConscript
calls
like this:
env = Environment() Export('env') objs = [] for subdir in ['foo', 'bar']: o = SConscript('%s/SConscript' % subdir) objs.append(o) env.Library('prog', objs)
We can do this by using the Return
function in the
foo/SConscript
file like this:
Import('env') obj = env.Object('foo.c') Return('obj')
(The corresponding
bar/SConscript
file should be pretty obvious.)
Then when we run SCons,
the object files from the subsidiary subdirectories
are all correctly archived in the desired library:
% scons -Q
cc -o bar/bar.o -c bar/bar.c
cc -o foo/foo.o -c foo/foo.c
ar rc libprog.a foo/foo.o bar/bar.o
ranlib libprog.a
It is often useful to keep built files completely separate from the source files. Two main benefits are the ability to have different configurations simultaneously without build conflicts, and being version-control friendly.
Consider if you have a project to build an embedded software system for a variety of different controller hardware. The system is able to share a lot of code, so it makes sense to use a common source tree, but certain build options in the source code and header files differ. For a regular in-place build, the build outputs go in the same place as the source code. If you build Controller A first, followed by Controller B, on the Controller B build everything that uses different build options has to be rebuilt since those objects will be different (the build lines, including preprocessor defines, are part of SCons's out-of-date calculation for this reason). If you go back and build for Controller A again, things have to be rebuilt again for the same reason. However, if you can separate the locations of the output files, so each controller has its own location for build outputs, this problem can be avoided.
Having a separated build tree also helps you keep your source tree clean - there is less chance of accidentally checking in build products to version control that were not intended to be checked in. You can add a separated build directory to your version control system's list of items not to track. You can even remove the whole build tree with a single command without risking removing any of the source code.
The key to making this separation work is the ability to
do out-of-tree builds: building under a separate root
than the sources being built.
You set up out of tree builds by establishing what SCons
calls a variant directory,
a place where you can build a single variant of your software
(of course you can define more than one of these if you need to).
Since SCons tracks targets by their path, it is able to distinguish
build products like build/A/network.obj
of the Controller A build
from build/B/network.obj
of the Controller B build,
thus avoiding conflicts.
SCons provides two ways to establish variant directories,
one through the SConscript
function that we have already seen,
and the second through a more flexible VariantDir
function.
The variant directory mechanism does support doing multiple builds in one invocation of SCons, but the remainder of this chapter will focus on setting up a single build. You can combine these techniques with ones from the previous chapter and elsewhere in this Guide to set up more complex scenarios.
The VariantDir
function used to be called BuildDir
,
a name which was changed because it turned out to be confusing:
the SCons functionality
differs from a familiar model of a "build directory"
implemented by certain other build systems like GNU Autotools.
You might still find references to the old name on
the Internet in postings about SCons, but it no longer works.
The most straightforward way to establish a variant directory tree
relies on the fact that the usual way to
set up a build hierarchy is to have an
SConscript
file in the source directory.
If you pass a variant_dir
argument to the
SConscript
function call:
SConscript('src/SConscript', variant_dir='build')
SCons will then build all of the files in
the build
directory:
%ls src
SConscript hello.c %scons -Q
cc -o build/hello.o -c build/hello.c cc -o build/hello build/hello.o %ls src
SConscript hello.c %ls build
SConscript hello hello.c hello.o
No files were built in src
:
the object file
build/hello.o
and the executable file
build/hello
were built in the build
directory, as expected.
But notice that even though our hello.c
file actually
lives in the src
directory, SCons has compiled a
build/hello.c
file
to create the object file,
and that file is now seen in build
.
You can ask SCons to show the dependency tree to illustrate a bit more:
% scons -Q --tree=prune
cc -o build/hello.o -c build/hello.c
cc -o build/hello build/hello.o
+-.
+-SConstruct
+-build
| +-build/SConscript
| +-build/hello
| | +-build/hello.o
| | +-build/hello.c
| +-build/hello.c
| +-[build/hello.o]
+-src
+-src/SConscript
+-src/hello.c
What's happened is that SCons has duplicated
the hello.c
file from the src
directory
to the build
directory,
and built the program from there (it also duplicated SConscript
).
The next section explains why SCons does this.
The nice thing about the SConscript
approach is it is almost
invisible to you:
this build looks just like an ordinary in-place build
except for the extra variant_dir
argument in the
SConscript
call.
SCons handles all the path adjustments for the
out of tree build
directory while it processes that SConscript file.
When you set up a variant directory SCons conceptually behaves as if you requested a build in that directory. As noted in the previous chapter, all builds actually happen from the top level directory, but as an aid to understanding how SCons operates, think of it as build in place in the variant directory, not build in source but send build artifacts to the variant directory. It turns out in place builds are easier to get right than out of tree builds - so by default SCons simulates an in place build by making the variant directory look just like the source directory. The most straightforward way to do that is by making copies of the files needed for the build.
The most direct reason to duplicate source files in variant directories is simply that some tools (mostly older versions) are written to only build their output files in the same directory as the source files - such tools often don't have any option to specify the output file, and the tool just uses a predefined output file name, or uses a derived variant of the source file name, dropping the result in the same directory. In this case, the choices are either to build the output file in the source directory and move it to the variant directory, or to duplicate the source files in the variant directory.
Additionally,
relative references between files
can cause problems which are resolved by
just duplicating the hierarchy of source files
into the variant directory.
You can see this at work in
use of the C preprocessor #include
mechanism with double quotes, not angle brackets:
#include "file.h"
The de facto standard behavior
for most C compilers in this case
is to first look in the same directory
as the source file that contains the #include
line,
then to look in the directories in the preprocessor search path.
Add to this that the SCons implementation of
support for code repositories
(described below)
means not all of the files
will be found in the same directory hierarchy,
and the simplest way to make sure
that the right include file is found
is to duplicate the source files into the variant directory,
which provides a correct build
regardless of the original location(s) of the source files.
Although source-file duplication guarantees a correct build even in these edge cases, it can usually be safely disabled. The next section describes how you can disable the duplication of source files in the variant directory.
In most cases and with most tool sets,
SCons can use sources directly from the source directory
without
duplicating them into the variant directory before building,
and everything will work just fine.
You can disable the default SCons duplication behavior
by specifying duplicate=False
when you call the SConscript
function:
SConscript('src/SConscript', variant_dir='build', duplicate=False)
When this flag is specified, the results of a build look more like the mental model people may have from other build systems - that is, the output files end up in the variant directory while the source files do not.
%ls src
SConscript hello.c %scons -Q
cc -c src/hello.c -o build/hello.o cc -o build/hello build/hello.o %ls build
hello hello.o
If disabling duplication causes any problems, just return to the more cautious approach by letting SCons go back to duplicating files.
You can also use the VariantDir
function to establish
that target files should be built in a separate directory tree
from the source files:
VariantDir('build', 'src') env = Environment() env.Program('build/hello.c')
When using this form, you have to tell SCons that sources and targets are in the variant directory, and those references will trigger the remapping, necessary file copying, etc. for an already established variant directory. Here is the same example in a more spelled out form to show this more clearly:
VariantDir('build', 'src') env = Environment() env.Program(target='build/hello', source=['build/hello.c'])
When using the VariantDir
function directly,
SCons still duplicates the source files
in the variant directory by default:
%ls src
hello.c %scons -Q
cc -o build/hello.o -c build/hello.c cc -o build/hello build/hello.o %ls build
hello hello.c hello.o
You can specify the same duplicate=False
argument
that you can specify for an SConscript
call:
VariantDir('build', 'src', duplicate=False) env = Environment() env.Program('build/hello.c')
In which case SCons will disable duplication of the source files:
%ls src
hello.c %scons -Q
cc -o build/hello.o -c src/hello.c cc -o build/hello build/hello.o %ls build
hello hello.o
Even when using the VariantDir
function,
it is more natural to use it with
a subsidiary SConscript
file,
because then you don't have to adjust your individual
build instructions to use the variant directory path.
For example, if the
src/SConscript
looks like this:
env = Environment() env.Program('hello.c')
Then our SConstruct
file could look like:
VariantDir('build', 'src') SConscript('build/SConscript')
Yielding the following output:
%ls src
SConscript hello.c %scons -Q
cc -o build/hello.o -c build/hello.c cc -o build/hello build/hello.o %ls build
SConscript hello hello.c hello.o
This is completely equivalent
to the use of SConscript
with the
variant_dir
argument
from earlier in this chapter,
but did require callng the SConscript using the already established
variant directory path to trigger that behavior.
If you call SConscript('src/SConscript')
you would get a normal in-place build in src
.
The Glob
file name pattern matching function
works just as usual when using VariantDir
.
For example, if the
src/SConscript
looks like this:
env = Environment() env.Program('hello', Glob('*.c'))
Then with the same SConstruct
file as in the previous section,
and source files f1.c
and f2.c
in src,
we would see the following output:
%ls src
SConscript f1.c f2.c f2.h %scons -Q
cc -o build/f1.o -c build/f1.c cc -o build/f2.o -c build/f2.c cc -o build/hello build/f1.o build/f2.o %ls build
SConscript f1.c f1.o f2.c f2.h f2.o hello
The Glob
function returns Nodes in the
build/
tree, as you'd expect.
The variant_dir
keyword argument of
the SConscript
function provides everything
we need to show how easy it is to create
variant builds using SCons.
Suppose, for example, that we want to
build a program for both Windows and Linux platforms,
but that we want to build it in directory on a network share
with separate side-by-side build directories
for the Windows and Linux versions of the program.
We have to do a little bit of work to construct paths,
to make sure unwanted location dependencies don't creep in.
The top-relative path reference can be useful here.
To avoid writing conditional code based on platform,
we can build the variant_dir
path dynamically:
platform = ARGUMENTS.get('OS', Platform()) include = "#export/$PLATFORM/include" lib = "#export/$PLATFORM/lib" bin = "#export/$PLATFORM/bin" env = Environment( PLATFORM=platform, BINDIR=bin, INCDIR=include, LIBDIR=lib, CPPPATH=[include], LIBPATH=[lib], LIBS='world', ) Export('env') env.SConscript('src/SConscript', variant_dir='build/$PLATFORM')
This SConstruct file, when run on a Linux system, yields:
% scons -Q OS=linux
Install file: "build/linux/world/world.h" as "export/linux/include/world.h"
cc -o build/linux/hello/hello.o -c -Iexport/linux/include build/linux/hello/hello.c
cc -o build/linux/world/world.o -c -Iexport/linux/include build/linux/world/world.c
ar rc build/linux/world/libworld.a build/linux/world/world.o
ranlib build/linux/world/libworld.a
Install file: "build/linux/world/libworld.a" as "export/linux/lib/libworld.a"
cc -o build/linux/hello/hello build/linux/hello/hello.o -Lexport/linux/lib -lworld
Install file: "build/linux/hello/hello" as "export/linux/bin/hello"
The same SConstruct file on Windows would build:
C:\>scons -Q OS=windows
Install file: "build/windows/world/world.h" as "export/windows/include/world.h"
cl /Fobuild\windows\hello\hello.obj /c build\windows\hello\hello.c /nologo /Iexport\windows\include
cl /Fobuild\windows\world\world.obj /c build\windows\world\world.c /nologo /Iexport\windows\include
lib /nologo /OUT:build\windows\world\world.lib build\windows\world\world.obj
Install file: "build/windows/world/world.lib" as "export/windows/lib/world.lib"
link /nologo /OUT:build\windows\hello\hello.exe /LIBPATH:export\windows\lib world.lib build\windows\hello\hello.obj
embedManifestExeCheck(target, source, env)
Install file: "build/windows/hello/hello.exe" as "export/windows/bin/hello.exe"
In order to build several variants at once when using the
variant_dir
argument to SConscript
,
you can call the function repeatedely - this example
does so in a loop. Note that the SConscript
trick of
passing a list of script files, or a list of source directories,
does not work with variant_dir
,
SCons allows only a single SConscript
to be given if
variant_dir
is used.
env = Environment(OS=ARGUMENTS.get('OS')) for os in ['newell', 'post']: SConscript('src/SConscript', variant_dir='build/' + os)
Often, a software project will have one or more central repositories, directory trees that contain source code, or derived files, or both. You can eliminate additional unnecessary rebuilds of files by having SCons use files from one or more code repositories to build files in your local build tree.
It's often useful to allow multiple programmers working
on a project to build software from
source files and/or derived files that
are stored in a centrally-accessible repository,
a directory copy of the source code tree.
(Note that this is not the sort of repository
maintained by a source code management system
like BitKeeper, CVS, or Subversion.)
You use the Repository
method
to tell SCons to search one or more
central code repositories (in order)
for any source files and derived files
that are not present in the local build tree:
env = Environment() env.Program('hello.c') Repository('/usr/repository1', '/usr/repository2')
Multiple calls to the Repository
method
will simply add repositories to the global list
that SCons maintains,
with the exception that SCons will automatically eliminate
the current directory and any non-existent
directories from the list.
The above example
specifies that SCons
will first search for files under
the /usr/repository1
tree
and next under the /usr/repository2
tree.
SCons expects that any files it searches
for will be found in the same position
relative to the top-level directory.
In the above example, if the hello.c
file is not
found in the local build tree,
SCons will search first for
a /usr/repository1/hello.c
file
and then for a /usr/repository2/hello.c
file
to use in its place.
So given the SConstruct
file above,
if the hello.c
file exists in the local
build directory,
SCons will rebuild the hello
program
as normal:
% scons -Q
cc -o hello.o -c hello.c
cc -o hello hello.o
If, however, there is no local hello.c
file,
but one exists in /usr/repository1
,
SCons will recompile the hello
program
from the source file it finds in the repository:
% scons -Q
cc -o hello.o -c /usr/repository1/hello.c
cc -o hello hello.o
And similarly, if there is no local hello.c
file
and no /usr/repository1/hello.c
,
but one exists in /usr/repository2
:
% scons -Q
cc -o hello.o -c /usr/repository2/hello.c
cc -o hello hello.o
The Glob
function understands about repositories,
and will use the same matching algorithm as described for
explicitly-listed sources.
We've already seen that SCons will scan the contents of
a source file for #include
file names
and realize that targets built from that source file
also depend on the #include
file(s).
For each directory in the $CPPPATH
list,
SCons will actually search the corresponding directories
in any repository trees and establish the
correct dependencies on any
#include
files that it finds
in repository directory.
Unless the C compiler also knows about these directories
in the repository trees, though,
it will be unable to find the #include
files.
If, for example, the hello.c
file in
our previous example includes the hello.h
in its current directory,
and the hello.h
only exists in the repository:
% scons -Q
cc -o hello.o -c hello.c
hello.c:1: hello.h: No such file or directory
In order to inform the C compiler about the repositories,
SCons will add appropriate
-I
flags to the compilation commands
for each directory in the $CPPPATH
list.
So if we add the current directory to the
construction environment $CPPPATH
like so:
env = Environment(CPPPATH = ['.']) env.Program('hello.c') Repository('/usr/repository1')
Then re-executing SCons yields:
% scons -Q
cc -o hello.o -c -I. -I/usr/repository1 hello.c
cc -o hello hello.o
The order of the -I
options replicates,
for the C preprocessor,
the same repository-directory search path
that SCons uses for its own dependency analysis.
If there are multiple repositories and multiple $CPPPATH
directories, SCons will add the repository directories
to the beginning of each $CPPPATH
directory,
rapidly multiplying the number of -I
flags.
If, for example, the $CPPPATH
contains three directories
(and shorter repository path names!):
env = Environment(CPPPATH = ['dir1', 'dir2', 'dir3']) env.Program('hello.c') Repository('/r1', '/r2')
Then we'll end up with nine -I
options
on the command line,
three (for each of the $CPPPATH
directories)
times three (for the local directory plus the two repositories):
% scons -Q
cc -o hello.o -c -Idir1 -I/r1/dir1 -I/r2/dir1 -Idir2 -I/r1/dir2 -I/r2/dir2 -Idir3 -I/r1/dir3 -I/r2/dir3 hello.c
cc -o hello hello.o
SCons relies on the C compiler's
-I
options to control the order in which
the preprocessor will search the repository directories
for #include
files.
This causes a problem, however, with how the C preprocessor
handles #include
lines with
the file name included in double-quotes.
As we've seen,
SCons will compile the hello.c
file from
the repository if it doesn't exist in
the local directory.
If, however, the hello.c
file in the repository contains
a #include
line with the file name in
double quotes:
#include "hello.h" int main(int argc, char *argv[]) { printf(HELLO_MESSAGE); return (0); }
Then the C preprocessor will always
use a hello.h
file from the repository directory first,
even if there is a hello.h
file in the local directory,
despite the fact that the command line specifies
-I
as the first option:
% scons -Q
cc -o hello.o -c -I. -I/usr/repository1 /usr/repository1/hello.c
cc -o hello hello.o
This behavior of the C preprocessor--always search
for a #include
file in double-quotes
first in the same directory as the source file,
and only then search the -I
--can
not, in general, be changed.
In other words, it's a limitation
that must be lived with if you want to use
code repositories in this way.
There are three ways you can possibly
work around this C preprocessor behavior:
Some modern versions of C compilers do have an option
to disable or control this behavior.
If so, add that option to $CFLAGS
(or $CXXFLAGS
or both) in your construction environment(s).
Make sure the option is used for all construction
environments that use C preprocessing!
Change all occurrences of #include "file.h"
to #include <file.h>
.
Use of #include
with angle brackets
does not have the same behavior--the -I
directories are searched first
for #include
files--which
gives SCons direct control over the list of
directories the C preprocessor will search.
Require that everyone working with compilation from repositories check out and work on entire directories of files, not individual files. (If you use local wrapper scripts around your source code control system's command, you could add logic to enforce this restriction there.
SCons will also search in repositories
for the SConstruct
file and any specified SConscript
files.
This poses a problem, though: how can SCons search a
repository tree for an SConstruct
file
if the SConstruct
file itself contains the information
about the pathname of the repository?
To solve this problem, SCons allows you
to specify repository directories
on the command line using the -Y
option:
% scons -Q -Y /usr/repository1 -Y /usr/repository2
When looking for source or derived files,
SCons will first search the repositories
specified on the command line,
and then search the repositories
specified in the SConstruct
or SConscript
files.
If a repository contains not only source files,
but also derived files (such as object files,
libraries, or executables), SCons will perform
its normal MD5 signature calculation to
decide if a derived file in a repository is up-to-date,
or the derived file must be rebuilt in the local build directory.
For the SCons signature calculation to work correctly,
a repository tree must contain the .sconsign
files
that SCons uses to keep track of signature information.
Usually, this would be done by a build integrator
who would run SCons in the repository
to create all of its derived files and .sconsign
files,
or who would run SCons in a separate build directory
and copy the resulting tree to the desired repository:
%cd /usr/repository1
%scons -Q
cc -o file1.o -c file1.c cc -o file2.o -c file2.c cc -o hello.o -c hello.c cc -o hello hello.o file1.o file2.o
(Note that this is safe even if the SConstruct
file
lists /usr/repository1
as a repository,
because SCons will remove the current build directory
from its repository list for that invocation.)
Now, with the repository populated,
we only need to create the one local source file
we're interested in working with at the moment,
and use the -Y
option to
tell SCons to fetch any other files it needs
from the repository:
%cd $HOME/build
%edit hello.c
%scons -Q -Y /usr/repository1
cc -c -o hello.o hello.c cc -o hello hello.o /usr/repository1/file1.o /usr/repository1/file2.o
Notice that SCons realizes that it does not need to
rebuild local copies file1.o
and file2.o
files,
but instead uses the already-compiled files
from the repository.
If the repository tree contains the complete results of a build, and we try to build from the repository without any files in our local tree, something moderately surprising happens:
%mkdir $HOME/build2
%cd $HOME/build2
%scons -Q -Y /usr/all/repository hello
scons: `hello' is up-to-date.
Why does SCons say that the hello
program
is up-to-date when there is no hello
program
in the local build directory?
Because the repository (not the local directory)
contains the up-to-date hello
program,
and SCons correctly determines that nothing
needs to be done to rebuild that
up-to-date copy of the file.
There are, however, many times when you want to ensure that a
local copy of a file always exists.
A packaging or testing script, for example,
may assume that certain generated files exist locally.
To tell SCons to make a copy of any up-to-date repository
file in the local build directory,
use the Local
function:
env = Environment() hello = env.Program('hello.c') Local(hello)
If we then run the same command, SCons will make a local copy of the program from the repository copy, and tell you that it is doing so:
% scons -Y /usr/all/repository hello
Local copy of hello from /usr/all/repository/hello
scons: `hello' is up-to-date.
(Notice that, because the act of making the local copy
is not considered a "build" of the hello
file,
SCons still reports that it is up-to-date.)
Although SCons provides many useful methods for building common software products (programs, libraries, documents, etc.), you frequently want to be able to build some other type of file not supported directly by SCons. Fortunately, SCons makes it very easy to define your own Builder objects for any custom file types you want to build. (In fact, the SCons interfaces for creating Builder objects are flexible enough and easy enough to use that all of the the SCons built-in Builder objects are created using the mechanisms described in this section.)
The simplest Builder to create is
one that executes an external command.
For example, if we want to build
an output file by running the contents
of the input file through a command named
foobuild
,
creating that Builder might look like:
bld = Builder(action='foobuild < $SOURCE > $TARGET')
All the above line does is create a free-standing Builder object. The next section will show how to actually use it.
A Builder object isn't useful
until it's attached to a construction environment
so that we can call it to arrange
for files to be built.
This is done through the $BUILDERS
construction variable in an environment.
The $BUILDERS
variable is a Python dictionary
that maps the names by which you want to call
various Builder objects to the objects themselves.
For example, if we want to call the
Builder we just defined by the name
Foo
,
our SConstruct
file might look like:
bld = Builder(action='foobuild < $SOURCE > $TARGET') env = Environment(BUILDERS={'Foo': bld})
With the Builder attached to our construction environment
with the name Foo
,
we can now actually call it like so:
env.Foo('file.foo', 'file.input')
Then when we run SCons it looks like:
% scons -Q
foobuild < file.input > file.foo
Note, however, that the default $BUILDERS
variable in a construction environment
comes with a default set of Builder objects
already defined:
Program
, Library
, etc.
And when we explicitly set the $BUILDERS
variable
when we create the construction environment,
the default Builders are no longer part of
the environment:
bld = Builder(action='foobuild < $SOURCE > $TARGET') env = Environment(BUILDERS={'Foo': bld}) env.Foo('file.foo', 'file.input') env.Program('hello.c')
% scons -Q
AttributeError: 'SConsEnvironment' object has no attribute 'Program':
File "/home/my/project/SConstruct", line 7:
env.Program('hello.c')
To be able to use both our own defined Builder objects
and the default Builder objects in the same construction environment,
you can either add to the $BUILDERS
variable
using the Append
function:
env = Environment() bld = Builder(action='foobuild < $SOURCE > $TARGET') env.Append(BUILDERS={'Foo': bld}) env.Foo('file.foo', 'file.input') env.Program('hello.c')
Or you can explicitly set the appropriately-named
key in the $BUILDERS
dictionary:
env = Environment() bld = Builder(action='foobuild < $SOURCE > $TARGET') env['BUILDERS']['Foo'] = bld env.Foo('file.foo', 'file.input') env.Program('hello.c')
Either way, the same construction environment
can then use both the newly-defined
Foo
Builder
and the default Program
Builder:
% scons -Q
foobuild < file.input > file.foo
cc -o hello.o -c hello.c
cc -o hello hello.o
By supplying additional information
when you create a Builder,
you can let SCons add appropriate file
suffixes to the target and/or the source file.
For example, rather than having to specify
explicitly that you want the Foo
Builder to build the file.foo
target file from the file.input
source file,
you can give the .foo
and .input
suffixes to the Builder,
making for more compact and readable calls to
the Foo
Builder:
bld = Builder( action='foobuild < $SOURCE > $TARGET', suffix='.foo', src_suffix='.input', ) env = Environment(BUILDERS={'Foo': bld}) env.Foo('file1') env.Foo('file2')
% scons -Q
foobuild < file1.input > file1.foo
foobuild < file2.input > file2.foo
You can also supply a prefix
keyword argument
if it's appropriate to have SCons append a prefix
to the beginning of target file names.
In SCons, you don't have to call an external command to build a file. You can, instead, define a Python function that a Builder object can invoke to build your target file (or files). Such a builder function definition looks like:
def build_function(target, source, env): # Code to build "target" from "source" return None
The arguments of a builder function are:
target
A list of Node objects representing
the target or targets to be
built by this function.
The file names of these target(s)
may be extracted using the Python str
function.
source
A list of Node objects representing
the sources to be
used by this function to build the targets.
The file names of these source(s)
may be extracted using the Python str
function.
env
The construction environment used for building the target(s). The function may use any of the environment's construction variables in any way to affect how it builds the targets.
The function will be constructed as a SCons FunctionAction and
must return a 0
or None
value if the target(s) are built successfully. The function may
raise an exception or return any non-zero value to indicate that
the build is unsuccessful.
For more information on Actions see the Action Objects section of
the man page.
Once you've defined the Python function
that will build your target file,
defining a Builder object for it is as
simple as specifying the name of the function,
instead of an external command,
as the Builder's
action
argument:
def build_function(target, source, env): # Code to build "target" from "source" return None bld = Builder( action=build_function, suffix='.foo', src_suffix='.input', ) env = Environment(BUILDERS={'Foo': bld}) env.Foo('file')
And notice that the output changes slightly, reflecting the fact that a Python function, not an external command, is now called to build the target file:
% scons -Q
build_function(["file.foo"], ["file.input"])
SCons Builder objects can create an action "on the fly" by using a function called a Generator. (Note: this is not the same thing as a Python generator function described in PEP 255) This provides a great deal of flexibility to construct just the right list of commands to build your target. A generator looks like:
def generate_actions(source, target, env, for_signature): return 'foobuild < %s > %s' % (target[0], source[0])
The arguments of a generator are:
source
A list of Node objects representing
the sources to be built
by the command or other action
generated by this function.
The file names of these source(s)
may be extracted using the Python str
function.
target
A list of Node objects representing
the target or targets to be built
by the command or other action
generated by this function.
The file names of these target(s)
may be extracted using the Python str
function.
env
The construction environment used for building the target(s). The generator may use any of the environment's construction variables in any way to determine what command or other action to return.
for_signature
A flag that specifies whether the generator is being called to contribute to a build signature, as opposed to actually executing the command.
The generator must return a command string or other action that will be used to build the specified target(s) from the specified source(s).
Once you've defined a generator,
you create a Builder to use it
by specifying the generator
keyword argument
instead of action
.
def generate_actions(source, target, env, for_signature): return 'foobuild < %s > %s' % (source[0], target[0]) bld = Builder( generator=generate_actions, suffix='.foo', src_suffix='.input', ) env = Environment(BUILDERS={'Foo': bld}) env.Foo('file')
% scons -Q
foobuild < file.input > file.foo
Note that it's illegal to specify both an
action
and a
generator
for a Builder.
SCons supports the ability for a Builder to modify the lists of target(s) from the specified source(s). You do this by defining an emitter function that takes as its arguments the list of the targets passed to the builder, the list of the sources passed to the builder, and the construction environment. The emitter function should return the modified lists of targets that should be built and sources from which the targets will be built.
For example, suppose you want to define a Builder
that always calls a foobuild program,
and you want to automatically add
a new target file named
new_target
and a new source file named
new_source
whenever it's called.
The SConstruct
file might look like this:
def modify_targets(target, source, env): target.append('new_target') source.append('new_source') return target, source bld = Builder( action='foobuild $TARGETS - $SOURCES', suffix='.foo', src_suffix='.input', emitter=modify_targets, ) env = Environment(BUILDERS={'Foo': bld}) env.Foo('file')
And would yield the following output:
% scons -Q
foobuild file.foo new_target - file.input new_source
One very flexible thing that you can do is
use a construction variable to specify
different emitter functions for different construction environments.
To do this, specify a string
containing a construction variable
expansion as the emitter when you call
the Builder
function,
and set that construction variable to
the desired emitter function
in different construction environments:
bld = Builder( action='./my_command $SOURCES > $TARGET', suffix='.foo', src_suffix='.input', emitter='$MY_EMITTER', ) def modify1(target, source, env): return target, source + ['modify1.in'] def modify2(target, source, env): return target, source + ['modify2.in'] env1 = Environment(BUILDERS={'Foo': bld}, MY_EMITTER=modify1) env2 = Environment(BUILDERS={'Foo': bld}, MY_EMITTER=modify2) env1.Foo('file1') env2.Foo('file2')
In this example, the modify1.in
and modify2.in
files
get added to the source lists
of the different commands:
% scons -Q
./my_command file1.input modify1.in > file1.foo
./my_command file2.input modify2.in > file2.foo
Defining an emitter to work with a custom Builder
is a powerful concept, but sometimes all you really want
is to be able to use an existing builder but change its
concept of what targets are created.
In this case,
trying to recreate the logic of an existing Builder to
supply a special emitter can be a lot of work.
The typical case for this is when you want to use a compiler flag
that causes additional files to be generated.
For example the GNU linker accepts an option
-Map
which outputs a link map
to the file specified by the option's argument.
If this option is just supplied to the build,
SCons will not consider the link map file a tracked target,
which has various undesirable efffects.
To help with this, SCons provides construction variables which correspond
to a few standard builders:
$PROGEMITTER
for Program
;
$LIBEMITTER
for Library
;
$SHLIBEMITTER
for SharedLibrary
and
$LDMODULEEMITTER
for LoadableModule
;.
Adding an emitter to one of these will cause it to be
invoked in addition to any existing emitter for the
corresponding builder.
This example adds map creation as a linker flag,
and modifies the standard Program
emitter to know that map generation is a side-effect:
env = Environment() map_filename = "${TARGET.name}.map" def map_emitter(target, source, env): target.append(map_filename) return target, source env.Append(LINKFLAGS="-Wl,-Map={},--cref".format(map_filename)) env.Append(PROGEMITTER=map_emitter) env.Program('hello.c')
If you run this example, adding an option to tell SCons to dump some information about the dependencies it knows, it shows the map file option in use, and that SCons indeed knows about the map file, it's not just a silent side effect of the compiler:
% scons -Q --tree=prune
cc -o hello.o -c hello.c
cc -o hello -Wl,-Map=hello.map,--cref hello.o
+-.
+-SConstruct
+-hello
| +-hello.o
| +-hello.c
+-hello.c
+-hello.map
| +-[hello.o]
+-[hello.o]
The site_scons
directories give you a place to
put Python modules and packages that you can import into your
SConscript
files (at the top level)
add-on tools that can integrate into SCons
(in a site_tools
subdirectory),
and a site_scons/site_init.py
file that
gets read before any SConstruct
or SConscript
file,
allowing you to change SCons's default behavior.
Each system type (Windows, Mac, Linux, etc.) searches a canonical
set of directories for site_scons
;
see the man page for details.
The top-level SConstruct's site_scons
dir
(that is, the one in the project) is always searched last,
and its dir is placed first in the tool path so it overrides all
others.
If you get a tool from somewhere (the SCons wiki or a third party,
for instance) and you'd like to use it in your project, a
site_scons
dir is the simplest place to put it.
Tools come in two flavors; either a Python function that operates on
an Environment
or a Python module or package containing two functions,
exists()
and generate()
.
A single-function Tool can just be included in your
site_scons/site_init.py
file where it will be
parsed and made available for use. For instance, you could have a
site_scons/site_init.py
file like this:
def TOOL_ADD_HEADER(env): """A Tool to add a header from $HEADER to the source file""" add_header = Builder( action=['echo "$HEADER" > $TARGET', 'cat $SOURCE >> $TARGET'] ) env.Append(BUILDERS={'AddHeader': add_header}) env['HEADER'] = '' # set default value
and a SConstruct
like this:
# Use TOOL_ADD_HEADER from site_scons/site_init.py env=Environment(tools=['default', TOOL_ADD_HEADER], HEADER="=====") env.AddHeader('tgt', 'src')
The TOOL_ADD_HEADER
tool method will be
called to add the AddHeader
tool to the
environment.
A more full-fledged tool with
exists()
and generate()
methods can be installed either as a module in the file
site_scons/site_tools/toolname.py
or as a
package in the
directory site_scons/site_tools/toolname
. In
the case of using a package, the exists()
and generate()
are in the
file site_scons/site_tools/toolname/__init__.py
.
(In all the above case toolname
is replaced
by the name of the tool.)
Since site_scons/site_tools
is automatically
added to the head of the tool search path, any tool found there
will be available to all environments. Furthermore, a tool found
there will override a built-in tool of the same name, so if you
need to change the behavior of a built-in
tool, site_scons
gives you the hook you need.
Many people have a collection of utility Python functions they'd like
to include in their SConscript
files: just put them in
site_scons/my_utils.py
or any valid Python module name of your
choice. For instance you can do something like this in
site_scons/my_utils.py
to add
build_id
and MakeWorkDir
functions:
from SCons.Script import * # for Execute and Mkdir def build_id(): """Return a build ID (stub version)""" return "100" def MakeWorkDir(workdir): """Create the specified dir immediately""" Execute(Mkdir(workdir))
And then in your SConscript
or any sub-SConscript
anywhere in
your build, you can import my_utils
and use it:
import my_utils print("build_id=" + my_utils.build_id()) my_utils.MakeWorkDir('/tmp/work')
You can put this collection in its own module in a
site_scons
and import it as in the example,
or you can include it in
site_scons/site_init.py
,
which is automatically imported (unless you disable site directories).
Note that in order to refer to objects in the SCons namespace
such as Environment
or Mkdir
or Execute
in any file other
than a SConstruct
or SConscript
you always need to do
from SCons.Script import *
This is true of modules in site_scons
such as
site_scons/site_init.py
as well.
You can use any of the user- or machine-wide site directories such as
~/.scons/site_scons
instead of
./site_scons
, or use the
--site-dir
option to point to your own directory.
site_init.py
and
site_tools
will be located under that directory.
To avoid using a site_scons
directory at all,
even if it exists, use the --no-site-dir
option.
Creating a Builder and attaching it to a construction environment
allows for a lot of flexibility when you
want to re-use actions
to build multiple files of the same type.
This can, however, be cumbersome
if you only need to execute one specific command
to build a single file (or group of files).
For these situations, SCons supports a
Command
builder that arranges
for a specific action to be executed
to build a specific file or files.
This looks a lot like the other builders
(like Program
, Object
, etc.),
but takes as an additional argument
the command to be executed to build the file:
env = Environment() env.Command('foo.out', 'foo.in', "sed 's/x/y/' < $SOURCE > $TARGET")
When executed,
SCons runs the specified command,
substituting $SOURCE
and $TARGET
as expected:
% scons -Q
sed 's/x/y/' < foo.in > foo.out
This is often more convenient than
creating a Builder object
and adding it to the $BUILDERS
variable
of a construction environment.
Note that the action you specify to the
Command
Builder can be any legal SCons Action,
such as a Python function:
env = Environment() def build(target, source, env): # Whatever it takes to build return None env.Command('foo.out', 'foo.in', build)
Which executes as follows:
% scons -Q
build(["foo.out"], ["foo.in"])
Note that $SOURCE
and $TARGET
are expanded
in the source and target as well, so you can write:
env.Command('${SOURCE.basename}.out', 'foo.in', build)
which does the same thing as the previous example, but allows you to avoid repeating yourself.
It may be helpful to use the action
keyword to specify the action, is this makes things more clear
to the reader:
env.Command('${SOURCE.basename}.out', 'foo.in', action=build)
The method described in
Section 9.2, “Controlling How SCons Prints Build Commands: the $*COMSTR
Variables” for controlling
build output works well when used with pre-defined builders which
have pre-defined *COMSTR
variables for that purpose,
but that is not the case when calling Command
,
where SCons has no specific knowledge of the action ahead of time.
If the action argument to Command
is not already an Action object,
it will construct one for you with suitable defaults,
which include a message based on the type of action.
However, you can also construct the Action object yourself
to pass to Command
, which gives you much more control.
Here's an evolution of the example from above showing this approach:
env = Environment() def build(target, source, env): # Whatever it takes to build return None act = Action(build, cmdstr="Building ${TARGET}") env.Command('foo.out', 'foo.in', action=act)
Which executes as follows:
% scons -Q
Building foo.out
The AddMethod
function is used to add a method
to an environment. It is typically used to add a "pseudo-builder,"
a function that looks like a Builder but
wraps up calls to multiple other Builders
or otherwise processes its arguments
before calling one or more Builders.
In the following example,
we want to install the program into the standard
/usr/bin
directory hierarchy,
but also copy it into a local install/bin
directory from which a package might be built:
def install_in_bin_dirs(env, source): """Install source in both bin dirs""" i1 = env.Install("$BIN", source) i2 = env.Install("$LOCALBIN", source) return [i1[0], i2[0]] # Return a list, like a normal builder env = Environment(BIN='/usr/bin', LOCALBIN='#install/bin') env.AddMethod(install_in_bin_dirs, "InstallInBinDirs") env.InstallInBinDirs(Program('hello.c')) # installs hello in both bin dirs
This produces the following:
% scons -Q /
cc -o hello.o -c hello.c
cc -o hello hello.o
Install file: "hello" as "/usr/bin/hello"
Install file: "hello" as "install/bin/hello"
A pseudo-builder is useful because it gives you more flexibility
parsing arguments than you can get with a standard Builder.
The next example shows a pseudo-builder with a
named argument that modifies the filename, and a separate optional
argument for a resource file (rather than having the builder figure it out
by file extension). This example also demonstrates using the global
AddMethod
function to add a method to the global Environment class,
so it will be available in all subsequently created environments.
def BuildTestProg(env, testfile, resourcefile="", testdir="tests"): """Build the test program. Prepends "test_" to src and target and puts the target into testdir. If the build is running on Windows, also make use of a resource file, if supplied. """ srcfile = f"test_{testfile}.c" target = f"{testdir}/test_{testfile}" if env['PLATFORM'] == 'win32' and resourcefile: resfile = env.RES(resourcefile) p = env.Program(target, [srcfile, resfile]) else: p = env.Program(target, srcfile) return p AddMethod(Environment, BuildTestProg) env = Environment() env.BuildTestProg('stuff', resourcefile='res.rc')
This produces the following on Linux:
% scons -Q
cc -o test_stuff.o -c test_stuff.c
cc -o tests/test_stuff test_stuff.o
And the following on Windows:
C:\>scons -Q
rc /nologo /fores.res res.rc
cl /Fotest_stuff.obj /c test_stuff.c /nologo
link /nologo /OUT:tests\test_stuff.exe test_stuff.obj res.res
embedManifestExeCheck(target, source, env)
Using AddMethod
is better than just adding an instance method
to a construction environment because it gets called as a proper method,
and because AddMethod
provides for copying the method
to any clones of the construction environment instance.
SCons has built-in Scanners that know how to look in
C/C++, Fortran, D, IDL, LaTeX, Python and SWIG source files
for information about
other files that targets built from those files depend on.
For example, if you have a file format which uses #include
to specify files which should be included into the source file
when it is processed, you can use an existing scanner already
included in SCons.
You can use the same mechanisms that SCons uses to create
its built-in Scanners to write Scanners of your own for file types
that SCons does not know how to scan "out of the box."
Suppose, for example, that we want to create a simple Scanner
for .k
files.
A .k
file contains some text that
will be processed,
and can include other files on lines that begin
with include
followed by a file name:
include filename.k
Scanning a file will be handled by a Python function
that you must supply.
Here is a function that will use the Python
re
module
to scan for the include
lines in our example:
import re include_re = re.compile(r'^include\s+(\S+)$', re.M) def kfile_scan(node, env, path, arg=None): contents = node.get_text_contents() return env.File(include_re.findall(contents))
It is important to note that you
have to return a list of File nodes from the scanner function, simple
strings for the file names won't do.
As in the examples we are showing here,
you can use the File
function of your current construction environment in order to create nodes
on the fly from a sequence of file names with relative paths.
The scanner function must accept the four specified arguments and return a list of implicit dependencies. Presumably, these would be dependencies found from examining the contents of the file, although the function can perform any manipulation at all to generate the list of dependencies.
node
An SCons node object representing the file being scanned.
The path name to the file can be
used by converting the node to a string
using the str
function,
or an internal SCons get_text_contents
object method can be used to fetch the contents.
env
The construction environment in effect for this scan. The scanner function may choose to use construction variables from this environment to affect its behavior.
path
A list of directories that form the search path for included files
for this Scanner.
This is how SCons handles the $CPPPATH
and $LIBPATH
variables.
arg
An optional argument that can be passed to this scanner function when it is called from a scanner instance. The argument is only supplied if it was given when the scanner instance is created (see the manpage section "Scanner Objects"). This can be useful, for example, to distinguish which scanner type called us, if the function might be bound to several scanner objects. Since the argument is only supplied in the function call if it was defined for that scanner, the function needs to be prepared to possibly be called in different ways if multiple scanners are expected to use this function - giving the parameter a default value as shown above is a good way to do this. If the function to scanner relationship will be 1:1, just make sure they match.
A scanner object is created using the Scanner
function,
which typically takes an skeys
argument
to associate a file suffix with this Scanner.
The scanner object must then be associated with the
$SCANNERS
construction variable in the current construction environment,
typically by using the Append
method:
kscan = Scanner(function=kfile_scan, skeys=['.k']) env.Append(SCANNERS=kscan)
Let's put this all together.
Our new file type, with the .k
suffix,
will be processed by a command named kprocess,
which lives in non-standard location
/usr/local/bin
,
so we add that path to the execution environment so SCons
can find it. Here's what it looks like:
import re include_re = re.compile(r'^include\s+(\S+)$', re.M) def kfile_scan(node, env, path): contents = node.get_text_contents() includes = include_re.findall(contents) return env.File(includes) kscan = Scanner(function=kfile_scan, skeys=['.k']) env = Environment() env.AppendENVPath('PATH', '/usr/local/bin') env.Append(SCANNERS=kscan) env.Command('foo', 'foo.k', 'kprocess < $SOURCES > $TARGET')
Assume a foo.k
file like this:
some initial text include other_file some other text
Now if we run scons we can see that the scanner works -
it identified the dependency
other_file
via the detected
include
line,
although we get an error message because we
forgot to create that file!
% scons -Q
scons: *** [foo] Implicit dependency `other_file' not found, needed by target `foo'.
If the build tool in question will use a path variable to search
for included files or other dependencies, then the Scanner will
need to take that path variable into account as well -
the same way $CPPPATH
is used for files processed
by the C Preprocessor (used for C, C++, Fortran and others).
Path variables may be lists of nodes or semicolon-separated strings
(SCons uses a semicolon here irrespective of
the pathlist separator used by the native operating system),
and may contain construction variables to be expanded.
A Scanner can take a path_function
to process such a path variable;
the function produces a tuple of paths that is passed to the
scanner function as its path
parameter.
To make this easy,
SCons provides the premade FindPathDirs
function which returns a callable to expand a given path variable
(given as an SCons construction variable name)
to a tuple of paths at the time the Scanner is called.
Deferring evaluation until that point allows, for instance,
the path to contain $TARGET
references which differ for
each file scanned.
Using FindPathDirs
is easy. Continuing the above example,
using $KPATH
as the construction variable to hold the paths
(analogous to $CPPPATH
), we just modify the call to
the Scanner
factory function to include a
path_function
keyword argument:
kscan = Scanner( function=kfile_scan, skeys=['.k'], path_function=FindPathDirs('KPATH'), )
FindPathDirs
is called when the Scanner is created,
and the callable object it returns is stored
as an attribute in the scanner.
When the scanner is invoked, it calls that object,
which processes the $KPATH
from the
current construction environment, doing necessary expansions and,
if necessary, adds related repository and variant directories,
producing a (possibly empty) tuple of paths
that is passed on to the scanner function.
The scanner function is then responsible for using that list
of paths to locate the include files identified by the scan.
The next section will show an example of that.
As a side note, the returned method stores the path in an efficient way so lookups are fast even when variable substitutions may be needed. This is important since many files get scanned in a typical build.
One approach for introducing a Scanner into the build is in
conjunction with a Builder. There are two relvant optional
parameters we can use when creating a Builder:
source_scanner
and
target_scanner
.
source_scanner
is used for scanning
source files, and target_scanner
is used for scanning the target once it is generated.
import os, re include_re = re.compile(r"^include\s+(\S+)$", re.M) def kfile_scan(node, env, path, arg=None): includes = include_re.findall(node.get_text_contents()) print(f"DEBUG: scan of {str(node)!r} found {includes}") deps = [] for inc in includes: for dir in path: file = str(dir) + os.sep + inc if os.path.exists(file): deps.append(file) break print(f"DEBUG: scanned dependencies found: {deps}") return env.File(deps) kscan = Scanner( function=kfile_scan, skeys=[".k"], path_function=FindPathDirs("KPATH"), ) def build_function(target, source, env): # Code to build "target" from "source" return None bld = Builder( action=build_function, suffix=".k", source_scanner=kscan, src_suffix=".input", ) env = Environment(BUILDERS={"KFile": bld}, KPATH="inc") env.KFile("file")
Running this example would only show that the stub
build_function
is getting called,
so some debug prints were added to the scaner function,
just to show the scanner is being invoked.
% scons -Q
DEBUG: scan of 'file.input' found ['other_file']
DEBUG: scanned dependencies found: ['inc/other_file']
build_function(["file.k"], ["file.input"])
The path-search implementation in
kfile_scan
works,
but is quite simple-minded - a production scanner
will probably do something more sophisticated.
An emitter function can modify the list of sources or targets passed to the action function when the Builder is triggered.
A scanner function will not affect the list of sources or targets seen by the Builder during the build action. The scanner function will, however, affect if the Builder should rebuild (if any of the files sourced by the Scanner have changed for example).
SCons has integrated support for build configuration similar in style to GNU Autoconf, but designed to be transparently multi-platform. The configuration system can help figure out if external build requirements such as system libraries or header files are available on the build system. This section describes how to use this SCons feature. (See also the SCons man page for additional information).
The basic framework for multi-platform build configuration
in SCons is to create a configure context inside a
construction environment by calling the Configure
function,
perform the desired checks for
libraries, functions, header files, etc.,
and then call the configure context's Finish
method
to finish off the configuration:
env = Environment() conf = Configure(env) # Checks for libraries, header files, etc. go here! env = conf.Finish()
The Finish
call is required; if a new context is
created while a context is active, even in a different
construction environment, scons will complain and exit.
SCons provides a number of pre-defined basic checks, as well as a mechanism for adding your own custom checks.
There are a few possible strategies for failing configure checks. Some checks may be for features without which you cannot proceed. The simple approach here is just to exit SCons at that point - a number of the examples in this chapter are coded that way. If there are multiple hard requirements, however, it may be friendlier to the user to set a flag in case of any fails of hard requirements and accumulate a record of them, so that on the completion of the configure context they can all be listed prior to failing the build - as it can be frustrating to have to iterate through the setup, fixing one new requirement each iteration. Other checks may be for features which you can do without, and here the strategy will usually be to set a construction variable which the rest of the build can examine for its absence/presence, or to set particular compiler flags, library lists, etc. as appropriate for the circumstances, so you can proceed with the build appropriately based on available features.
Note that SCons uses its own dependency mechanism to determine when a check needs to be run--that is, SCons does not run the checks every time it is invoked, but caches the values returned by previous checks and uses the cached values unless something has changed. This saves a tremendous amount of developer time while working on cross-platform build issues.
The next sections describe the basic checks that SCons supports, as well as how to add your own custom checks.
Testing the existence of a header file
requires knowing what language the header file is.
This information is supplied in the language
keyword parameter to the CheckHeader
method.
Since scons grew up in a world of C/C++ code,
a configure context also has a CheckCHeader
method
that specifically checks for the existence of a C header file:
env = Environment() conf = Configure(env) if not conf.CheckCHeader('math.h'): print('Math.h must be installed!') Exit(1) if conf.CheckCHeader('foo.h'): conf.env.Append(CPPDEFINES='HAS_FOO_H') env = conf.Finish()
As shown in the example, depending on the circumstances you can choose to terminate the build if a given header file doesn't exist, or you can modify the construction environment based on the presence or absence of a header file (the same applies to any other check). If there are a many elements to check for, it may be friendlier for the user if you do not terminate on the first failure, but track the problems found until the end and report on all of them, that way the user does not have to iterate multiple times, each time finding one new dependency that needs to be installed.
If you need to check for the existence
a C++ header file,
use the CheckCXXHeader
method:
env = Environment() conf = Configure(env) if not conf.CheckCXXHeader('vector.h'): print('vector.h must be installed!') Exit(1) env = conf.Finish()
Check for the availability of a specific function
using the CheckFunc
method:
env = Environment() conf = Configure(env) if not conf.CheckFunc('strcpy'): print('Did not find strcpy(), using local version') conf.env.Append(CPPDEFINES=('strcpy','my_local_strcpy')) env = conf.Finish()
Check for the availability of a library
using the CheckLib
method.
You only specify the base part of the library name,
you don't need to add a lib
prefix or a .a
or .lib
suffix:
env = Environment() conf = Configure(env) if not conf.CheckLib('m'): print('Did not find libm.a or m.lib, exiting!') Exit(1) env = conf.Finish()
Because the ability to use a library successfully
often depends on having access to a header file
that describes the library's interface,
you can check for a library
and a header file
at the same time by using the
CheckLibWithHeader
method:
env = Environment() conf = Configure(env) if not conf.CheckLibWithHeader('m', 'math.h', language='c'): print('Did not find libm.a or m.lib, exiting!') Exit(1) env = conf.Finish()
This is essentially shorthand for
separate calls to the CheckHeader
and CheckLib
functions.
Check for the availability of a typedef
by using the CheckType
method:
env = Environment() conf = Configure(env) if not conf.CheckType('off_t'): print('Did not find off_t typedef, assuming int') conf.env.Append(CPPDEFINES=('off_t','int')) env = conf.Finish()
You can also add a string that will be
placed at the beginning of the test file
that will be used to check for the typedef
.
This provide a way to specify
files that must be included to find the typedef
:
env = Environment() conf = Configure(env) if not conf.CheckType('off_t', '#include <sys/types.h>\n'): print('Did not find off_t typedef, assuming int') conf.env.Append(CPPDEFINES=('off_t','int')) env = conf.Finish()
Check the size of a datatype by using the CheckTypeSize
method:
env = Environment() conf = Configure(env) int_size = conf.CheckTypeSize('unsigned int') print('sizeof unsigned int is', int_size) env = conf.Finish()
% scons -Q
sizeof unsigned int is 4
scons: `.' is up to date.
Check for the presence of a program
by using the CheckProg
method:
env = Environment() conf = Configure(env) if not conf.CheckProg('foobar'): print('Unable to find the program foobar on the system') Exit(1) env = conf.Finish()
A custom check is a Python function that checks for a certain condition to exist on the running system, usually using methods that SCons supplies to take care of the details of checking whether a compilation succeeds, a link succeeds, a program is runnable, etc. A simple custom check for the existence of a specific library might look as follows:
mylib_test_source_file = """ #include <mylib.h> int main(int argc, char **argv) { MyLibrary mylib(argc, argv); return 0; } """ def CheckMyLibrary(context): context.Message('Checking for MyLibrary...') result = context.TryLink(mylib_test_source_file, '.c') context.Result(result) return result
The Message
and Result
methods
should typically begin and end a custom check to
let the user know what's going on:
the Message
call prints the
specified message (with no trailing newline)
and the Result
call prints
yes
if the check succeeds and
no
if it doesn't.
The TryLink
method
actually tests for whether the
specified program text
will successfully link.
(Note that a custom check can modify
its check based on any arguments you
choose to pass it,
or by using or modifying the configure context environment
in the context.env
attribute.)
This custom check function is
then attached to the configure context
by passing a dictionary
to the Configure
call
that maps a name of the check
to the underlying function:
env = Environment() conf = Configure(env, custom_tests={'CheckMyLibrary': CheckMyLibrary})
You'll typically want to make the check and the function name the same, as we've done here, to avoid potential confusion.
We can then put these pieces together
and actually call the CheckMyLibrary
check
as follows:
mylib_test_source_file = """ #include <mylib.h> int main(int argc, char **argv) { MyLibrary mylib(argc, argv); return 0; } """ def CheckMyLibrary(context): context.Message('Checking for MyLibrary... ') result = context.TryLink(mylib_test_source_file, '.c') context.Result(result) return result env = Environment() conf = Configure(env, custom_tests={'CheckMyLibrary': CheckMyLibrary}) if not conf.CheckMyLibrary(): print('MyLibrary is not installed!') Exit(1) env = conf.Finish() # We would then add actual calls like Program() to build # something using the "env" construction environment.
If MyLibrary is not installed on the system, the output will look like:
% scons
scons: Reading SConscript file ...
Checking for MyLibrary... no
MyLibrary is not installed!
If MyLibrary is installed, the output will look like:
% scons
scons: Reading SConscript file ...
Checking for MyLibrary... yes
scons: done reading SConscript
scons: Building targets ...
.
.
.
Using multi-platform configuration
as described in the previous sections
will run the configuration commands
even when invoking
scons -c
to clean targets:
% scons -Q -c
Checking for MyLibrary... yes
Removed foo.o
Removed foo
Although running the platform checks
when removing targets doesn't hurt anything,
it's usually unnecessary.
You can avoid this by using the
GetOption
method to
check whether the -c
(clean)
option has been invoked on the command line:
env = Environment() if not env.GetOption('clean'): conf = Configure(env, custom_tests={'CheckMyLibrary': CheckMyLibrary}) if not conf.CheckMyLibrary(): print('MyLibrary is not installed!') Exit(1) env = conf.Finish()
% scons -Q -c
Removed foo.o
Removed foo
On multi-developer software projects, you can sometimes speed up every developer's builds a lot by allowing them to share a cache of the derived files that they build. After all, it is relatively rare that any in-progress change affects more than a few derived files, most will be unchanged. Using a cache can also help an individual developer: for example if you wish to start work on a new feature in a clean tree, those build artifacts which could be reused can be retrieved from the cache to populate the tree and save a lot of initial build time. SCons makes this easy and reliable.
To enable caching of derived files,
use the CacheDir
function
in any SConscript
file:
CacheDir('/usr/local/build_cache')
The cache directory you specify must
have read and write access for all developers
who will be accessing the cached files
(if --cache-readonly
is used,
only read access is required).
It should also be in some central location
that all builds will be able to access.
In environments where developers are using separate systems
(like individual workstations) for builds,
this directory would typically be
on a shared or NFS-mounted file system.
While SCons will create the specified cache directory as needed,
in this multi user scenario it is usually best
to create it ahead of time so the access rights
can be set up correctly.
Here's what happens:
When a build has a CacheDir
specified,
every time a file is built,
it is stored in that cache directory
indexed by its build signature.
On subsequent builds,
before an action is invoked to build a file,
the build signature is computed and SCons checks
the derived-file cache directory
to see if a file with the exact same build signature
already exists.
[4]
If so, the derived file will not be built locally,
but will be copied into the local build directory
from the derived-file cache directory,
like this:
%scons -Q
cc -o hello.o -c hello.c cc -o hello hello.o %scons -Q -c
Removed hello.o Removed hello %scons -Q
Retrieved `hello.o' from cache Retrieved `hello' from cache
Note that the CacheDir
feature requires that the build signature
be calculated,
even if you configure SCons to use timestamps
to decide if files are up to date
(see the Chapter 6, Dependencies
chapter for information about the Decider
function),
since the build signature is used to determine if a target file
exists in the cache.
Consequently, using CacheDir
may reduce or negate any performance
improvements from using timestamps for up-to-date decisions.
One potential drawback to using a derived-file cache is that the output printed by SCons can be inconsistent from invocation to invocation, because any given file may be rebuilt one time and retrieved from the derived-file cache the next time. This can make analyzing build output more difficult, especially for automated scripts that expect consistent output each time.
If, however, you use the --cache-show
option,
SCons will print the command line that it
would have executed
to build the file,
even when it is retrieving the file from the derived-file cache.
This keeps the build output consistent across builds:
%scons -Q
cc -o hello.o -c hello.c cc -o hello hello.o %scons -Q -c
Removed hello.o Removed hello %scons -Q --cache-show
cc -o hello.o -c hello.c cc -o hello hello.o
The trade-off, of course, is that you no longer know whether or not SCons has retrieved a derived file from cache or has rebuilt it locally.
You may want to disable caching for certain
specific files in your configuration.
For example, if you only want to put
executable files in a central cache,
but not the intermediate object files,
you can use the NoCache
function to specify that the
object files should not be cached:
env = Environment() obj = env.Object('hello.c') env.Program('hello.c') CacheDir('cache') NoCache('hello.o')
Then when you run scons after cleaning the built targets, it will recompile the object file locally (since it doesn't exist in the derived-file cache directory), but still realize that the derived-file cache directory contains an up-to-date executable program that can be retrieved instead of re-linking:
%scons -Q
cc -o hello.o -c hello.c cc -o hello hello.o %scons -Q -c
Removed hello.o Removed hello %scons -Q
cc -o hello.o -c hello.c Retrieved `hello' from cache
Retrieving an already-built file from the derived-file cache is usually a significant time-savings over rebuilding the file, but how much of a savings (or even whether it saves time at all) can depend a great deal on your system or network configuration. For example, retrieving cached files from a busy server over a busy network might end up being slower than rebuilding the files locally.
In these cases, you can specify
the --cache-disable
command-line option to tell SCons
to not retrieve already-built files from the
derived-file cache directory:
%scons -Q
cc -o hello.o -c hello.c cc -o hello hello.o %scons -Q -c
Removed hello.o Removed hello %scons -Q
Retrieved `hello.o' from cache Retrieved `hello' from cache %scons -Q -c
Removed hello.o Removed hello %scons -Q --cache-disable
cc -o hello.o -c hello.c cc -o hello hello.o
Sometimes, you may have one or more derived files already built in your local build tree that you wish to make available to other people doing builds. For example, you may find it more effective to perform integration builds with the cache disabled (per the previous section) and only populate the derived-file cache directory with the built files after the integration build has completed successfully. This way, the cache will only get filled up with derived files that are part of a complete, successful build not with files that might be later overwritten while you debug integration problems.
In this case, you can use the
the --cache-force
option
to tell SCons to put all derived files in the cache,
even if the files already exist in your local tree
from having been built by a previous invocation:
%scons -Q --cache-disable
cc -o hello.o -c hello.c cc -o hello hello.o %scons -Q -c
Removed hello.o Removed hello %scons -Q --cache-disable
cc -o hello.o -c hello.c cc -o hello hello.o %scons -Q --cache-force
scons: `.' is up to date. %scons -Q
scons: `.' is up to date.
Notice how the above sample run
demonstrates that the --cache-disable
option avoids putting the built
hello.o
and
hello
files in the cache,
but after using the --cache-force
option,
the files have been put in the cache
for the next invocation to retrieve.
If you allow multiple builds to update the derived-file cache directory simultaneously, two builds that occur at the same time can sometimes start "racing" with one another to build the same files in the same order. If, for example, you are linking multiple files into an executable program:
Program('prog', ['f1.c', 'f2.c', 'f3.c', 'f4.c', 'f5.c'])
SCons will normally build the input object files on which the program depends in their normal, sorted order:
% scons -Q
cc -o f1.o -c f1.c
cc -o f4.o -c f4.c
cc -o f5.o -c f5.c
cc -o f2.o -c f2.c
cc -o f3.o -c f3.c
cc -o prog f1.o f2.o f3.o f4.o f5.o
But if two such builds take place simultaneously,
they may each look in the cache at nearly the same
time and both decide that f1.o
must be rebuilt and pushed into the derived-file cache directory,
then both decide that f2.o
must be rebuilt (and pushed into the derived-file cache directory),
then both decide that f3.o
must be rebuilt...
This won't cause any actual build problems--both
builds will succeed,
generate correct output files,
and populate the cache--but
it does represent wasted effort.
To alleviate such contention for the cache,
you can use the --random
command-line option
to tell SCons to build dependencies
in a random order:
% scons -Q --random
cc -o f3.o -c f3.c
cc -o f1.o -c f1.c
cc -o f5.o -c f5.c
cc -o f2.o -c f2.c
cc -o f4.o -c f4.c
cc -o prog f1.o f2.o f3.o f4.o f5.o
Multiple builds using the --random
option
will usually build their dependencies in different,
random orders,
which minimizes the chances for a lot of
contention for same-named files
in the derived-file cache directory.
Multiple simultaneous builds might still race to try to build
the same target file on occasion,
but long sequences of inefficient contention
should be rare.
Note, of course,
the --random
option
will cause the output that SCons prints
to be inconsistent from invocation to invocation,
which may be an issue when
trying to compare output from different build runs.
If you want to make sure dependencies will be built
in a random order without having to specify
the --random
on very command line,
you can use the SetOption
function to
set the random
option
within any SConscript
file:
SetOption('random', 1) Program('prog', ['f1.c', 'f2.c', 'f3.c', 'f4.c', 'f5.c'])
You can customize the behavior of derived-file caching to add your own features, for example to support compressed and/or encrypted cache files, modify cache file permissions to better support shared caches, gather additional statistics and data, etc.
To define custom cache behavior, subclass the
SCons.CacheDir.CacheDir
class,
specializing those methods you want to change.
You can pass this custom class as the custom_class
parameter when calling CacheDir
for global reach,
or when calling env.CacheDir
for a specific environment.
You can also set the construction variable
$CACHEDIR_CLASS
to the custom class - this needs to happen
before configuring the cache in that environment.
SCons will internally invoke and use your custom class when performing
cache operations.
The below example shows a simple use case of overriding the
copy_from_cache
method to record the total number of bytes pulled from the cache.
import os import SCons.CacheDir class CustomCacheDir(SCons.CacheDir.CacheDir): total_retrieved = 0 @classmethod def copy_from_cache(cls, env, src, dst): # record total bytes pulled from cache cls.total_retrieved += os.stat(src).st_size return super().copy_from_cache(env, src, dst) env = Environment() env.CacheDir('scons-cache', custom_class=CustomCacheDir) # ...
[4] A few inside details: SCons tracks two main kinds of cryptographic hashes: a content signature, which is a hash of the contents of a file participating in the build (dependencies as well as targets); and a build signature, which is a hash of the elements needed to build a target, such as the command line, the contents of the sources, and possibly information about tools used in the build. The hash function produces a unique signature from its inputs, no other set of inputs can produce that same signature. The build signature from building a target is used as the filename of the target file in the derived-file cache - that way lookups are efficient, just compute a build signature and see if a file exists with that as the name.
The use of the build signature provides protection from concflicts: if two developers have different setups, so they would produce built objects that are not identical, then because the difference in tools will show up in the build signature, which is used as the name of the cache entry, they will end up being stored as separate entries.
We've already seen how you can use the Alias
function to create a target named install
:
env = Environment() hello = env.Program('hello.c') env.Install('/usr/bin', hello) env.Alias('install', '/usr/bin')
You can then use this alias on the command line to tell SCons more naturally that you want to install files:
% scons -Q install
cc -o hello.o -c hello.c
cc -o hello hello.o
Install file: "hello" as "/usr/bin/hello"
Like other Builder methods, though,
the Alias
method returns an object
representing the alias being built.
You can then use this object as input to anothother Builder.
This is especially useful if you use such an object
as input to another call to the Alias
Builder,
allowing you to create a hierarchy
of nested aliases:
env = Environment() p = env.Program('foo.c') l = env.Library('bar.c') env.Install('/usr/bin', p) env.Install('/usr/lib', l) ib = env.Alias('install-bin', '/usr/bin') il = env.Alias('install-lib', '/usr/lib') env.Alias('install', [ib, il])
This example defines separate install
,
install-bin
,
and install-lib
aliases,
allowing you finer control over what gets installed:
%scons -Q install-bin
cc -o foo.o -c foo.c cc -o foo foo.o Install file: "foo" as "/usr/bin/foo" %scons -Q install-lib
cc -o bar.o -c bar.c ar rc libbar.a bar.o ranlib libbar.a Install file: "libbar.a" as "/usr/lib/libbar.a" %scons -Q -c /
Removed foo.o Removed foo Removed /usr/bin/foo Removed bar.o Removed libbar.a Removed /usr/lib/libbar.a %scons -Q install
cc -o foo.o -c foo.c cc -o foo foo.o Install file: "foo" as "/usr/bin/foo" cc -o bar.o -c bar.c ar rc libbar.a bar.o ranlib libbar.a Install file: "libbar.a" as "/usr/lib/libbar.a"
So far, we've been using examples of building C and C++ programs to demonstrate the features of SCons. SCons also supports building Java programs, but Java builds are handled slightly differently, which reflects the ways in which the Java compiler and tools build programs differently than other languages' tool chains.
The basic activity when programming in Java,
of course, is to take one or more .java
files
containing Java source code
and to call the Java compiler
to turn them into one or more
.class
files.
In SCons, you do this
by giving the Java
Builder
a target directory in which
to put the .class
files,
and a source directory that contains
the .java
files:
Java('classes', 'src')
If the src
directory contains
three .java
source files,
then running SCons might look like this:
% scons -Q
javac -d classes -sourcepath src src/Example1.java src/Example2.java src/Example3.java
SCons will actually search the src
directory tree for all of the .java
files.
The Java compiler will then create the
necessary class files in the classes
subdirectory,
based on the class names found in the .java
files.
In addition to searching the source directory for
.java
files,
SCons actually runs the .java
files
through a stripped-down Java parser that figures out
what classes are defined.
In other words, SCons knows,
without you having to tell it,
what .class
files
will be produced by the javac call.
So our one-liner example from the preceding section:
Java('classes', 'src')
Will not only tell you reliably
that the .class
files
in the classes
subdirectory
are up-to-date:
%scons -Q
javac -d classes -sourcepath src src/Example1.java src/Example2.java src/Example3.java %scons -Q classes
scons: `classes' is up to date.
But it will also remove all of the generated
.class
files,
even for inner classes,
without you having to specify them manually.
For example, if our
Example1.java
and
Example3.java
files both define additional classes,
and the class defined in Example2.java
has an inner class,
running scons -c
will clean up all of those .class
files
as well:
%scons -Q
javac -d classes -sourcepath src src/Example1.java src/Example2.java src/Example3.java %scons -Q -c classes
Removed classes/Example1.class Removed classes/AdditionalClass1.class Removed classes/Example2$Inner2.class Removed classes/Example2.class Removed classes/Example3.class Removed classes/AdditionalClass3.class
To ensure correct handling of .class
dependencies in all cases, you need to tell SCons which Java
version is being used. This is needed because Java 1.5 changed
the .class
file names for nested anonymous
inner classes. Use the JAVAVERSION
construction
variable to specify the version in use. With Java 1.6, the
one-liner example can then be defined like this:
Java('classes', 'src', JAVAVERSION='1.6')
See JAVAVERSION
in the man page for more information.
After building the class files,
it's common to collect them into
a Java archive (.jar
) file,
which you do by calling the Jar
Builder.
If you want to just collect all of the
class files within a subdirectory,
you can just specify that subdirectory
as the Jar
source:
Java(target='classes', source='src') Jar(target='test.jar', source='classes')
SCons will then pass that directory
to the jar command,
which will collect all of the underlying
.class
files:
% scons -Q
javac -d classes -sourcepath src src/Example1.java src/Example2.java src/Example3.java
jar cf test.jar classes
If you want to keep all of the
.class
files
for multiple programs in one location,
and only archive some of them in
each .jar
file,
you can pass the Jar
builder a
list of files as its source.
It's extremely simple to create multiple
.jar
files this way,
using the lists of target class files created
by calls to the Java
builder
as sources to the various Jar
calls:
prog1_class_files = Java(target='classes', source='prog1') prog2_class_files = Java(target='classes', source='prog2') Jar(target='prog1.jar', source=prog1_class_files) Jar(target='prog2.jar', source=prog2_class_files)
This will then create
prog1.jar
and prog2.jar
next to the subdirectories
that contain their .java
files:
% scons -Q
javac -d classes -sourcepath prog1 prog1/Example1.java prog1/Example2.java
javac -d classes -sourcepath prog2 prog2/Example3.java prog2/Example4.java
jar cf prog1.jar -C classes Example1.class -C classes Example2.class
jar cf prog2.jar -C classes Example3.class -C classes Example4.class
You can generate C header and source files
for implementing native methods,
by using the JavaH
Builder.
There are several ways of using the JavaH
Builder.
One typical invocation might look like:
classes = Java(target='classes', source='src/pkg/sub') JavaH(target='native', source=classes)
The source is a list of class files generated by the
call to the Java
Builder,
and the target is the output directory in
which we want the C header files placed.
The target
gets converted into the -d
when SCons runs javah:
% scons -Q
javac -d classes -sourcepath src/pkg/sub src/pkg/sub/Example1.java src/pkg/sub/Example2.java src/pkg/sub/Example3.java
javah -d native -classpath classes pkg.sub.Example1 pkg.sub.Example2 pkg.sub.Example3
In this case,
the call to javah
will generate the header files
native/pkg_sub_Example1.h
,
native/pkg_sub_Example2.h
and
native/pkg_sub_Example3.h
.
Notice that SCons remembered that the class
files were generated with a target directory of
classes
,
and that it then specified that target directory
as the -classpath
option
to the call to javah.
Although it's more convenient to use
the list of class files returned by
the Java
Builder
as the source of a call to the JavaH
Builder,
you can
specify the list of class files
by hand, if you prefer.
If you do,
you need to set the
$JAVACLASSDIR
construction variable
when calling JavaH
:
Java(target='classes', source='src/pkg/sub') class_file_list = [ 'classes/pkg/sub/Example1.class', 'classes/pkg/sub/Example2.class', 'classes/pkg/sub/Example3.class', ] JavaH(target='native', source=class_file_list, JAVACLASSDIR='classes')
The $JAVACLASSDIR
value then
gets converted into the -classpath
when SCons runs javah:
% scons -Q
javac -d classes -sourcepath src/pkg/sub src/pkg/sub/Example1.java src/pkg/sub/Example2.java src/pkg/sub/Example3.java
javah -d native -classpath classes pkg.sub.Example1 pkg.sub.Example2 pkg.sub.Example3
Lastly, if you don't want a separate header file
generated for each source file,
you can specify an explicit File Node
as the target of the JavaH
Builder:
classes = Java(target='classes', source='src/pkg/sub') JavaH(target=File('native.h'), source=classes)
Because SCons assumes by default
that the target of the JavaH
builder is a directory,
you need to use the File
function
to make sure that SCons doesn't
create a directory named native.h
.
When a file is used, though,
SCons correctly converts the file name
into the javah -o
option:
% scons -Q
javac -d classes -sourcepath src/pkg/sub src/pkg/sub/Example1.java src/pkg/sub/Example2.java src/pkg/sub/Example3.java
javah -o native.h -classpath classes pkg.sub.Example1 pkg.sub.Example2 pkg.sub.Example3
Note that the the javah command was
removed from the JDK as of JDK 10, and the approved method
(available since JDK 8) is to use javac
to generate native headers at the same time as the Java source
code is compiled.. As such the JavaH
builder
is of limited utility in later Java versions.
You can generate Remote Method Invocation stubs
by using the RMIC
Builder.
The source is a list of directories,
typically returned by a call to the Java
Builder,
and the target is an output directory
where the _Stub.class
and _Skel.class
files will
be placed:
classes = Java(target='classes', source='src/pkg/sub') RMIC(target='outdir', source=classes)
As it did with the JavaH
Builder,
SCons remembers the class directory
and passes it as the -classpath
option
to rmic:
% scons -Q
javac -d classes -sourcepath src/pkg/sub src/pkg/sub/Example1.java src/pkg/sub/Example2.java
rmic -d outdir -classpath classes pkg.sub.Example1 pkg.sub.Example2
This example would generate the files
outdir/pkg/sub/Example1_Skel.class
,
outdir/pkg/sub/Example1_Stub.class
,
outdir/pkg/sub/Example2_Skel.class
and
outdir/pkg/sub/Example2_Stub.class
.
The gettext
toolset supports internationalization and localization
of SCons-based projects. Builders provided by gettext
automatize
generation and updates of translation files. You can manage translations and
translation templates similarly to how it's done with autotools.
To follow examples provided in this chapter set up your operating system to
support two or more languages. In following examples we use locales
en_US
, de_DE
, and
pl_PL
.
Ensure, that you have GNU gettext utilities installed on your system.
To edit translation files you may wish to install poedit editor.
Let's start with a very simple project, the "Hello world" program for example
/* hello.c */ #include <stdio.h> int main(int argc, char* argv[]) { printf("Hello world\n"); return 0; }
Prepare a SConstruct
to compile the program
as usual.
# SConstruct env = Environment() hello = Program(["hello.c"])
Now we'll convert the project to a multi-lingual one. If you don't
already have GNU gettext
utilities installed, install them from your preffered
package repository, or download from
http://ftp.gnu.org/gnu/gettext/. For the purpose of this example,
you should have following three locales installed on your system:
en_US
, de_DE
and
pl_PL
. On debian, for example, you may enable certain
locales through dpkg-reconfigure locales.
First prepare the hello.c
program for
internationalization. Change the previous code so it reads as follows:
/* hello.c */ #include <stdio.h> #include <libintl.h> #include <locale.h> int main(int argc, char* argv[]) { bindtextdomain("hello", "locale"); setlocale(LC_ALL, ""); textdomain("hello"); printf(gettext("Hello world\n")); return 0; }
Detailed recipes for such conversion can
be found at
http://www.gnu.org/software/gettext/manual/gettext.html#Sources.
The gettext("...")
has two purposes.
First, it marks messages for the xgettext(1) program, which
we will use to extract from the sources the messages for localization.
Second, it calls the gettext
library internals to
translate the message at runtime.
Now we shall instruct SCons how to generate and maintain translation files.
For that, use the Translate
builder and MOFiles
builder.
The first one takes source files, extracts internationalized
messages from them, creates so-called POT
file
(translation template), and then creates PO
translation
files, one for each requested language. Later, during the development
lifecycle, the builder keeps all these files up-to date. The
MOFiles
builder compiles the PO
files to binary
form. Then install the MO
files under directory
called locale
.
The completed
SConstruct
is as follows:
# SConstruct env = Environment( tools = ['default', 'gettext'] ) hello = env.Program(["hello.c"]) env['XGETTEXTFLAGS'] = [ '--package-name=%s' % 'hello', '--package-version=%s' % '1.0', ] po = env.Translate(["pl","en", "de"], ["hello.c"], POAUTOINIT = 1) mo = env.MOFiles(po) InstallAs(["locale/en/LC_MESSAGES/hello.mo"], ["en.mo"]) InstallAs(["locale/pl/LC_MESSAGES/hello.mo"], ["pl.mo"]) InstallAs(["locale/de/LC_MESSAGES/hello.mo"], ["de.mo"])
Generate the translation files with scons po-update. You should see the output from SCons simillar to this:
user@host:$ scons po-update scons: Reading SConscript files ... scons: done reading SConscript files. scons: Building targets ... Entering '/home/ptomulik/projects/tmp' xgettext --package-name=hello --package-version=1.0 -o - hello.c Leaving '/home/ptomulik/projects/tmp' Writting 'messages.pot' (new file) msginit --no-translator -l pl -i messages.pot -o pl.po Created pl.po. msginit --no-translator -l en -i messages.pot -o en.po Created en.po. msginit --no-translator -l de -i messages.pot -o de.po Created de.po. scons: done building targets.
If everything is right, you should see following new files.
user@host:$ ls *.po* de.po en.po messages.pot pl.po
Open en.po
in poedit and provide
the English translation to message "Hello world\n"
. Do the
same for de.po
(deutsch) and
pl.po
(polish). Let the translations be, for example:
en: "Welcome to beautiful world!\n"
de: "Hallo Welt!\n"
pl: "Witaj swiecie!\n"
Now compile the project by executing scons. The output should be similar to this:
user@host:$ scons scons: Reading SConscript files ... scons: done reading SConscript files. scons: Building targets ... msgfmt -c -o de.mo de.po msgfmt -c -o en.mo en.po gcc -o hello.o -c hello.c gcc -o hello hello.o Install file: "de.mo" as "locale/de/LC_MESSAGES/hello.mo" Install file: "en.mo" as "locale/en/LC_MESSAGES/hello.mo" msgfmt -c -o pl.mo pl.po Install file: "pl.mo" as "locale/pl/LC_MESSAGES/hello.mo" scons: done building targets.
SCons automatically compiled the PO
files to binary format
MO
, and the InstallAs
lines installed
these files under locale
folder.
Your program should be now ready. You may try it as follows (linux):
user@host:$ LANG=en_US.UTF-8 ./hello Welcome to beautiful world
user@host:$ LANG=de_DE.UTF-8 ./hello Hallo Welt
user@host:$ LANG=pl_PL.UTF-8 ./hello Witaj swiecie
To demonstrate the further life of translation files, let's change Polish
translation (poedit pl.po) to "Witaj drogi
swiecie\n"
. Run scons to see how scons
reacts to this
user@host:$scons scons: Reading SConscript files ... scons: done reading SConscript files. scons: Building targets ... msgfmt -c -o pl.mo pl.po Install file: "pl.mo" as "locale/pl/LC_MESSAGES/hello.mo" scons: done building targets.
Now, open hello.c
and add another one
printf
line with new message.
/* hello.c */ #include <stdio.h> #include <libintl.h> #include <locale.h> int main(int argc, char* argv[]) { bindtextdomain("hello", "locale"); setlocale(LC_ALL, ""); textdomain("hello"); printf(gettext("Hello world\n")); printf(gettext("and good bye\n")); return 0; }
Compile project with scons. This time, the
msgmerge(1) program is used by SCons to update
PO
file. The output from compilation is like:
user@host:$scons scons: Reading SConscript files ... scons: done reading SConscript files. scons: Building targets ... Entering '/home/ptomulik/projects/tmp' xgettext --package-name=hello --package-version=1.0 -o - hello.c Leaving '/home/ptomulik/projects/tmp' Writting 'messages.pot' (messages in file were outdated) msgmerge --update de.po messages.pot ... done. msgfmt -c -o de.mo de.po msgmerge --update en.po messages.pot ... done. msgfmt -c -o en.mo en.po gcc -o hello.o -c hello.c gcc -o hello hello.o Install file: "de.mo" as "locale/de/LC_MESSAGES/hello.mo" Install file: "en.mo" as "locale/en/LC_MESSAGES/hello.mo" msgmerge --update pl.po messages.pot ... done. msgfmt -c -o pl.mo pl.po Install file: "pl.mo" as "locale/pl/LC_MESSAGES/hello.mo" scons: done building targets.
The next example demonstrates what happens if we change the source code
in such way that the internationalized messages do not change. The answer
is that none of translation files (POT
,
PO
) are touched (i.e. no content changes, no
creation/modification time changed and so on). Let's append another
line to the program (after the last printf), so its code becomes:
/* hello.c */ #include <stdio.h> #include <libintl.h> #include <locale.h> int main(int argc, char* argv[]) { bindtextdomain("hello", "locale"); setlocale(LC_ALL, ""); textdomain("hello"); printf(gettext("Hello world\n")); printf(gettext("and good bye\n")); printf("----------------\n"); return a; }
Compile the project. You'll see on your screen
user@host:$scons scons: Reading SConscript files ... scons: done reading SConscript files. scons: Building targets ... Entering '/home/ptomulik/projects/tmp' xgettext --package-name=hello --package-version=1.0 -o - hello.c Leaving '/home/ptomulik/projects/tmp' Not writting 'messages.pot' (messages in file found to be up-to-date) gcc -o hello.o -c hello.c gcc -o hello hello.o scons: done building targets.
As you see, the internationalized messages ditn't change, so the
POT
and the rest of translation files have not
even been touched.
SCons supports a lot of additional functionality that doesn't readily fit into the other chapters.
Although the SCons code itself will run
on any 2.x Python version 2.7 or later,
you are perfectly free to make use of
Python syntax and modules from later versions
when writing your SConscript
files
or your own local modules.
If you do this, it's usually helpful to
configure SCons to exit gracefully with an error message
if it's being run with a version of Python
that simply won't work with your code.
This is especially true if you're going to use SCons
to build source code that you plan to distribute publicly,
where you can't be sure of the Python version
that an anonymous remote user might use
to try to build your software.
SCons provides an EnsurePythonVersion
function for this.
You simply pass it the major and minor versions
numbers of the version of Python you require:
EnsurePythonVersion(2, 5)
And then SCons will exit with the following error message when a user runs it with an unsupported earlier version of Python:
% scons -Q
Python 2.5 or greater required, but you have Python 2.3.6
You may, of course, write your SConscript
files
to use features that were only added in
recent versions of SCons.
When you publicly distribute software that is built using SCons,
it's helpful to have SCons
verify the version being used and
exit gracefully with an error message
if the user's version of SCons won't work
with your SConscript
files.
SCons provides an EnsureSConsVersion
function
that verifies the version of SCons
in the same
the EnsurePythonVersion
function
verifies the version of Python,
by passing in the major and minor versions
numbers of the version of SCons you require:
EnsureSConsVersion(1, 0)
And then SCons will exit with the following error message when a user runs it with an unsupported earlier version of SCons:
% scons -Q
SCons 1.0 or greater required, but you have SCons 0.98.5
While EnsureSConsVersion
is acceptable for most cases, there
are times where the user will want to support multiple SCons versions
simultaneously. In this scenario, it's beneficial to retrieve version
information of the currently executing SCons directly. This was previously
only possible by accessing SCons internals. From SCons4.8 onwards, it's now possible
to instead call GetSConsVersion
to recieve a tuple containing the
major, minor, and revision values of the current version.
if GetSConsVersion() >= (4, 9): # Some function got a new argument in 4.9 that we want to take advantage of SomeFunc(arg1, arg2, arg3) else: # Can't use the extended syntax, but it doesn't warrant exiting prematurely SomeFunc(arg1, arg2)
SCons supports an Exit
function
which can be used to terminate SCons
while reading the SConscript
files,
usually because you've detected a condition
under which it doesn't make sense to proceed:
if ARGUMENTS.get('FUTURE'): print("The FUTURE option is not supported yet!") Exit(2) env = Environment() env.Program('hello.c')
%scons -Q FUTURE=1
The FUTURE option is not supported yet! %scons -Q
cc -o hello.o -c hello.c cc -o hello hello.o
The Exit
function takes as an argument
the (numeric) exit status that you want SCons to exit with.
If you don't specify a value,
the default is to exit with 0
,
which indicates successful execution.
Note that the Exit
function
is equivalent to calling the Python
sys.exit
function
(which the it actually calls),
but because Exit
is a SCons function,
you don't have to import the Python
sys
module to use it.
The FindFile
function searches for a file in a list of directories.
If there is only one directory, it can be given as a simple string.
The function returns a File node if a matching file exists,
or None if no file is found.
(See the documentation for the Glob
function for an alternative way
of searching for entries in a directory.)
# one directory print("%s"%FindFile('missing', '.')) t = FindFile('exists', '.') print("%s %s"%(t.__class__, t))
% scons -Q
None
<class 'SCons.Node.FS.File'> exists
scons: `.' is up to date.
# several directories includes = [ '.', 'include', 'src/include'] headers = [ 'nonesuch.h', 'config.h', 'private.h', 'dist.h'] for hdr in headers: print('%-12s: %s'%(hdr, FindFile(hdr, includes)))
% scons -Q
nonesuch.h : None
config.h : config.h
private.h : src/include/private.h
dist.h : include/dist.h
scons: `.' is up to date.
If the file exists in more than one directory, only the first occurrence is returned.
print(FindFile('multiple', ['sub1', 'sub2', 'sub3'])) print(FindFile('multiple', ['sub2', 'sub3', 'sub1'])) print(FindFile('multiple', ['sub3', 'sub1', 'sub2']))
% scons -Q
sub1/multiple
sub2/multiple
sub3/multiple
scons: `.' is up to date.
In addition to existing files, FindFile
will also find derived files
(that is, non-leaf files) that haven't been built yet.
(Leaf files should already exist, or the build will fail!)
# Neither file exists, so build will fail Command('derived', 'leaf', 'cat >$TARGET $SOURCE') print(FindFile('leaf', '.')) print(FindFile('derived', '.'))
% scons -Q
leaf
derived
cat > derived leaf
# Only 'leaf' exists Command('derived', 'leaf', 'cat >$TARGET $SOURCE') print(FindFile('leaf', '.')) print(FindFile('derived', '.'))
% scons -Q
leaf
derived
cat > derived leaf
If a source file exists, FindFile
will correctly return the name
in the build directory.
# Only 'src/leaf' exists VariantDir('build', 'src') print(FindFile('leaf', 'build'))
% scons -Q
build/leaf
scons: `.' is up to date.
SCons supports a Flatten
function
which takes an input Python sequence
(list or tuple)
and returns a flattened list
containing just the individual elements of
the sequence.
This can be handy when trying to examine
a list composed of the lists
returned by calls to various Builders.
For example, you might collect
object files built in different ways
into one call to the Program
Builder
by just enclosing them in a list, as follows:
objects = [ Object('prog1.c'), Object('prog2.c', CCFLAGS='-DFOO'), ] Program(objects)
Because the Builder calls in SCons flatten their input lists, this works just fine to build the program:
% scons -Q
cc -o prog1.o -c prog1.c
cc -o prog2.o -c -DFOO prog2.c
cc -o prog1 prog1.o prog2.o
But if you were debugging your build
and wanted to print the absolute path
of each object file in the
objects
list,
you might try the following simple approach,
trying to print each Node's
abspath
attribute:
objects = [ Object('prog1.c'), Object('prog2.c', CCFLAGS='-DFOO'), ] Program(objects) for object_file in objects: print(object_file.abspath)
This does not work as expected
because each call to str
is operating an embedded list returned by
each Object
call,
not on the underlying Nodes within those lists:
% scons -Q
AttributeError: 'NodeList' object has no attribute 'abspath':
File "/home/my/project/SConstruct", line 8:
print(object_file.abspath)
The solution is to use the Flatten
function
so that you can pass each Node to
the str
separately:
objects = [ Object('prog1.c'), Object('prog2.c', CCFLAGS='-DFOO'), ] Program(objects) for object_file in Flatten(objects): print(object_file.abspath)
% scons -Q
/home/me/project/prog1.o
/home/me/project/prog2.o
cc -o prog1.o -c prog1.c
cc -o prog2.o -c -DFOO prog2.c
cc -o prog1 prog1.o prog2.o
If you need to find the directory from
which the user invoked the scons command,
you can use the GetLaunchDir
function:
env = Environment( LAUNCHDIR = GetLaunchDir(), ) env.Command('directory_build_info', '$LAUNCHDIR/build_info' Copy('$TARGET', '$SOURCE'))
Because SCons is usually invoked from the top-level
directory in which the SConstruct
file lives,
the Python os.getcwd()
is often equivalent.
However, the SCons
-u
,
-U
and
-D
command-line options,
when invoked from a subdirectory,
will cause SCons to change to the directory
in which the SConstruct
file is found.
When those options are used,
GetLaunchDir
will still return the path to the
user's invoking subdirectory,
allowing the SConscript
configuration
to still get at configuration (or other) files
from the originating directory.
Sometimes the way an action is defined causes effects on files
that SCons does not recognize as targets. The SideEffect
method can be used to informs SCons about such files.
This can be used just to flag a dependency for use in subsequent
build steps, although there is usually a better way to do that.
The primary use for the SideEffect
method
is to prevent two build steps from simultaneously modifying
or accessing the same file in a way that could impact each other.
In this example, the rule to build file1
will also put data into log
, which is used
as a source for the command to generate file2
,
but log
is unknown to SCons on a clean
build: it neither exists, nor is it a target output by any builder.
The SConscript
uses
SideEffect
to inform SCons about the additional output file.
env = Environment() f2 = env.Command( target='file2', source='log', action=Copy('$TARGET', '$SOURCE') ) f1 = env.Command( target='file1', source=[], action='echo >$TARGET data1; echo >log updated file1' ) env.SideEffect('log', f1)
Without the SideEffect
, this build would fail with a message
Source `log' not found, needed by target `file2'
,
but now it can proceed:
% scons -Q
echo > file1 data1; echo >log updated file1
Copy("file2", "log")
However, it is better to actually identify
log
as a target, since in this
case that's what it is:
env = Environment() f2 = env.Command( target='file2', source='log', action=Copy('$TARGET', '$SOURCE') ) f1 = env.Command( target=['file1', 'log'], source=[], action='echo >$TARGET data1; echo >log updated file1' )
% scons -Q
echo > file1 data1; echo >log updated file1
Copy("file2", "log")
In general, SideEffect
is not intended for the case when
a command produces extra target files (that is, files which
will be used as sources to other build steps). For example, the
the Microsoft Visual C++ compiler is capable of performing
incremental linking, for which it uses a status file - such that
linking foo.exe
also produces
a foo.ilk
, or uses it if it was already present,
if the /INCREMENTAL
option was supplied.
Specifying foo.ilk
as a
side-effect of foo.exe
is not a recommended use of SideEffect
since foo.ilk
is used by the link.
SCons handles side-effect files
slightly differently in its analysis of the dependency graph.
When a command produces multiple output files,
they should be specified as multiple targets of
the call to the relevant builder function.
The SideEffect
function itself should really only be used
when it's important to ensure that commands are not executed in parallel,
such as when a "peripheral" file (such as a log file)
may actually be updated by more than one command invocation.
Unfortunately, the tool which sets up the Program
builder
for the Microsoft Visual C++ compiler chain does not come prebuilt
with an understanding of the details of the .ilk
example - that the target list would need to change
in the presence of that specific option flag. Unlike the trivial
example above where we could simply tell the Command
builder
there were two targets of the action, modifying the
chain of events for a builder like Program
,
though not inherently complex, is definitely an
advanced SCons topic. It's okay to use SideEffect
here
to get started, as long as it comes with an understanding
that it's "not quite right". Perhaps leave a comment in
the file as a reminder, if it does turn out to cause problems later.
So if the main use is to prevent parallelism problems,
here is an example to illustrate.
Say a program that you need to call to build a target file
will also update a log file describing what the program
does while building the target.
The following configuration
would have SCons invoke a hypothetical
script named build
(in the local directory)
with command-line arguments telling it to write
log information to a common
logfile.txt
file:
env = Environment() env.Command( target='file1.out', source='file1.in', action='./build --log logfile.txt $SOURCE $TARGET' ) env.Command( target='file2.out', source='file2.in', action='./build --log logfile.txt $SOURCE $TARGET' )
This can cause problems when running the build in parallel if SCons decides to update both targets by running both program invocations at the same time. The multiple program invocations may interfere with each other writing to the common log file, leading at best to intermixed output in the log file, and at worst to an actual failed build (on a system like Windows, for example, where only one process at a time can open the log file for writing).
We can make sure that SCons does not
run these build
commands at the same time
by using the SideEffect
function
to specify that updating
the logfile.txt
file
is a side effect of building the specified
file1
and
file2
target files:
env = Environment() f1 = env.Command( target='file1.out', source='file1.in', action='./build --log logfile.txt $SOURCE $TARGET' ) f2 = env.Command( target='file2.out', source='file2.in', action='./build --log logfile.txt $SOURCE $TARGET' ) env.SideEffect('logfile.txt', f1 + f2)
This makes sure the the two
./build steps are run sequentially,
even with the --jobs=2
in the command line:
% scons -Q --jobs=2
./build --log logfile.txt file1.in file1.out
./build --log logfile.txt file2.in file2.out
The SideEffect
function can be called multiple
times for the same side-effect file.
In fact, the name used as a SideEffect
does not
even need to actually exist as a file on disk -
SCons will still make sure
that the relevant targets
will be executed sequentially, not in parallel.
The side effect is actually a pseudo-target, and SCons
mainly cares whether nodes are listed as depending on it,
not about its contents.
env = Environment() f1 = env.Command('file1.out', [], action='echo >$TARGET data1') env.SideEffect('not_really_updated', f1) f2 = env.Command('file2.out', [], action='echo >$TARGET data2') env.SideEffect('not_really_updated', f2)
% scons -Q --jobs=2
echo > file1.out data1
echo > file2.out data2
Virtualenv is a tool to create isolated Python environments. A python application (such as SCons) may be executed within an activated virtualenv. The activation of virtualenv modifies current environment by defining some virtualenv-specific variables and modifying search PATH, such that executables installed within virtualenv's home directory are preferred over the ones installed outside of it.
Normally, SCons uses hard-coded PATH when searching for external executables, so it always picks-up executables from these pre-defined locations. This applies also to python interpreter, which is invoked by some custom SCons tools or test suites. This means, when running SCons in a virtualenv, an eventual invocation of python interpreter from SCons script will most probably jump out of virtualenv and execute python executable found in hard-coded SCons PATH, not the one which is executing SCons. Some users may consider this as an inconsistency.
This issue may be overcome by using the
--enable-virtualenv
option. The option automatically imports virtualenv-related environment
variables to all created construction environment env['ENV']
,
and modifies SCons PATH appropriately to prefer virtualenv's executables.
Setting environment variable SCONS_ENABLE_VIRTUALENV=1
will have same effect. If virtualenv support is enabled system-vide
by the environment variable, it may be suppressed with the
--ignore-virtualenv
option.
Inside of SConscript
, a global function Virtualenv
is
available. It returns a path to virtualenv's home directory, or
None
if scons is not running from virtualenv. Note
that this function returns a path even if scons is run from an
unactivated virtualenv.
Sometimes a project needs to interact with other projects in various ways. For example, many open source projects make use of components from other open source projects, and want to use those in their released form, not recode their builds into SCons. As another example, sometimes the flexibility and power of SCons is useful for managing the overall project, but developers might like faster incremental builds when making small changes by using a different tool.
This chapter shows some techniques for interacting with other projects and tools effectively from within SCons.
Tooling to perform analysis and modification of source code often needs to know not only the source code itself, but also how it will be compiled, as the compilation line affects the behavior of macros, includes, etc. SCons has a record of this information once it has run, in the form of Actions associated with the sources, and can emit this information so tools can use it.
The Clang project has defined a JSON Compilation Database.
This database is in common use as input into Clang tools
and many IDEs and editors as well.
See
JSON Compilation Database Format Specification
for complete information. SCons can emit a
compilation database in this format
by enabling the compilation_db
tool
and calling the CompilationDatabase
builder
(available since scons 4.0).
The compilation database can be populated with
source and output files either with paths relative
to the top of the build, or using absolute paths.
This is controlled by
COMPILATIONDB_USE_ABSPATH=(True|False)
which defaults to False
.
The entries in this file can be filtered by using
COMPILATIONDB_PATH_FILTER='pattern'
where the filter pattern is a string following the Python
fnmatch
syntax.
This filtering can be used for outputting different
build variants to different compilation database files.
The following example illustrates generating a compilation database containing absolute paths:
env = Environment(COMPILATIONDB_USE_ABSPATH=True) env.Tool('compilation_db') env.CompilationDatabase() env.Program('hello.c')
% scons -Q
Building compilation database compile_commands.json
cc -o hello.o -c hello.c
cc -o hello hello.o
compile_commands.json
contains:
[ { "command": "gcc -o hello.o -c hello.c", "directory": "/home/user/sandbox", "file": "/home/user/sandbox/hello.c", "output": "/home/user/sandbox/hello.o" } ]
Notice that the generated database contains only an entry for
the hello.c/hello.o
pairing,
and nothing for the generation of the final executable
hello
- the transformation of
hello.o
to
hello
does not have any information that affects interpretation
of the source code,
so it is not interesting to the compilation database.
Although it can be a little surprising at first glance, a compilation database target is, like any other target, subject to scons target selection rules. This means if you set a default target (that does not include the compilation database), or use command-line targets, it might not be selected for building. This can actually be an advantage, since you don't necessarily want to regenerate the compilation database every build. The following example shows selecting relative paths (the default) for output and source, and also giving a non-default name to the database. In order to be able to generate the database separately from building, an alias is set referring to the database, which can then be used as a target - here we are only building the compilation database target, not the code.
env = Environment() env.Tool('compilation_db') cdb = env.CompilationDatabase('compile_database.json') Alias('cdb', cdb) env.Program('test_main.c')
% scons -Q cdb
Building compilation database compile_database.json
compile_database.json
contains:
[ { "command": "gcc -o test_main.o -c test_main.c", "directory": "/home/user/sandbox", "file": "test_main.c", "output": "test_main.o" } ]
The following (incomplete) example shows using filtering to separate build variants. In the case of using variants, you want different compilation databases for each, since the build parameters differ, so the code analysis needs to see the correct build lines for the 32-bit build and 64-bit build hinted at here. For simplicity of presentation, the example omits the setup details of the variant directories:
env = Environment() env.Tool("compilation_db") env1 = env.Clone() env1["COMPILATIONDB_PATH_FILTER"] = "build/linux32/*" env1.CompilationDatabase("compile_commands-linux32.json") env2 = env.Clone() env2["COMPILATIONDB_PATH_FILTER"] = "build/linux64/*" env2.CompilationDatabase('compile_commands-linux64.json')
compile_commands-linux32.json
contains:
[ { "command": "gcc -o hello.o -c hello.c", "directory": "/home/mats/github/scons/exp/compdb", "file": "hello.c", "output": "hello.o" } ]
compile_commands-linux64.json
contains:
[ { "command": "gcc -m64 -o build/linux64/test_main.o -c test_main.c", "directory": "/home/user/sandbox", "file": "test_main.c", "output": "build/linux64/test_main.o" } ]
This is an experimental new feature. It is subject to change and/or removal without a depreciation cycle.
Loading the ninja
tool into SCons will make significant changes
in SCons' normal functioning.
SCons will no longer execute any commands directly and will only create the build.ninja
and
run ninja.
Any targets specified on the command line will be passed along to ninja
To enable this feature you'll need to use one of the following:
# On the command line --experimental=ninja # Or in your SConstruct SetOption('experimental', 'ninja')
Ninja is a small build system that tries to be fast
by not making decisions. SCons can at times be slow
because it makes lots of decisions to carry out its goal
of "correctness". The two tools can be paired to benefit
some build scenarios: by using the ninja
tool,
SCons can generate the build file ninja uses (basically
doing the decision-making ahead of time and recording that
for ninja), and can invoke ninja to perform a build.
For situations where relationships are not changing, such
as edit/build/debug iterations, this works fine and should
provide considerable speedups for more complex builds.
The implication is if there are larger changes taking place,
ninja is not as appropriate - but you can always use SCons
to regenerate the build file. You are NOT advised to use
this for production builds.
To use the ninja
tool you'll need to first install the
Python ninja package, as the tool depends on being able to do an
import
of the package.
This can be done via:
# In a virtualenv, or "python" is the native executable: python -m pip install ninja # Windows using Python launcher: py -m pip install ninja # Anaconda: conda install -c conda-forge ninja
Reminder that like any non-default tool, you need to initialize it before use
(e.g. env.Tool('ninja')
).
It is not expected that the Ninja
builder will work for all builds at this point. It is still under active
development. If you find that your build doesn't work with ninja please bring this to the users mailing list
or
#scons-help
channel on our Discord server.
Specifically if your build has many (or even any) Python function actions you may find that the ninja build will be slower as it will run ninja, which will then run SCons for each target created by a Python action. To alleviate some of these, especially those Python based actions built into SCons there is special logic to implement those actions via shell commands in the ninja build file.
When ninja runs the generated ninja build file, ninja will launch scons as a daemon and feed commands
to that scons process which ninja is unable to build directly. This daemon will stay alive until
explicitly killed, or it times out. The timeout is set by $NINJA_SCONS_DAEMON_KEEP_ALIVE
.
The daemon will be restarted if any SConscript
file(s) change or the build changes in a way that ninja determines
it needs to regenerate the build.ninja file
See:
Ninja Build System |
Ninja File Format Specification |
The experience of configuring any software build tool to build a large code base usually, at some point, involves trying to figure out why the tool is behaving a certain way, and how to get it to behave the way you want. SCons is no different. This appendix contains a number of different ways in which you can get some additional insight into SCons' behavior.
Note that we're always interested in trying to improve how you can troubleshoot configuration problems. If you run into a problem that has you scratching your head, and which there just doesn't seem to be a good way to debug, odds are pretty good that someone else will run into the same problem, too. If so, please let the SCons development team know using the contact information at https://scons.org/contact.html so that we can use your feedback to try to come up with a better way to help you, and others, get the necessary insight into SCons behavior to help identify and fix configuration issues.
Let's look at a simple example of a misconfigured build that causes a target to be rebuilt every time SCons is run:
# Intentionally misspell the output file name in the # command used to create the file: Command('file.out', 'file.in', 'cp $SOURCE file.oout')
(Note to Windows users: The POSIX cp command
copies the first file named on the command line
to the second file.
In our example, it copies the file.in
file
to the file.out
file.)
Now if we run SCons multiple times on this example, we see that it re-runs the cp command every time:
%scons -Q
cp file.in file.oout %scons -Q
cp file.in file.oout %scons -Q
cp file.in file.oout
In this example,
the underlying cause is obvious:
we've intentionally misspelled the output file name
in the cp command,
so the command doesn't actually
build the file.out
file that we've told SCons to expect.
But if the problem weren't obvious,
it would be helpful
to specify the --debug=explain
option
on the command line
to have SCons tell us very specifically
why it's decided to rebuild the target:
% scons -Q --debug=explain
scons: building `file.out' because it doesn't exist
cp file.in file.oout
If this had been a more complicated example involving a lot of build output, having SCons tell us that it's trying to rebuild the target file because it doesn't exist would be an important clue that something was wrong with the command that we invoked to build it.
Note that you can also use
--warn=target-not-built
which checks
whether or not expected targets exist after a build rule is
executed.
% scons -Q --warn=target-not-built
cp file.in file.oout
scons: warning: Cannot find target file.out after building
File "/Users/bdbaddog/devel/scons/git/as_scons/scripts/scons.py", line 97, in <module>
The --debug=explain
option also comes in handy
to help figure out what input file changed.
Given a simple configuration that builds
a program from three source files,
changing one of the source files
and rebuilding with the --debug=explain
option shows very specifically
why SCons rebuilds the files that it does:
%scons -Q
cc -o file1.o -c file1.c cc -o file2.o -c file2.c cc -o file3.o -c file3.c cc -o prog file1.o file2.o file3.o % [CHANGE THE CONTENTS OF file2.c] %scons -Q --debug=explain
scons: rebuilding `file2.o' because `file2.c' changed cc -o file2.o -c file2.c scons: rebuilding `prog' because `file2.o' changed cc -o prog file1.o file2.o file3.o
This becomes even more helpful
in identifying when a file is rebuilt
due to a change in an implicit dependency,
such as an incuded .h
file.
If the file1.c
and file3.c
files
in our example
both included a hello.h
file,
then changing that included file
and re-running SCons with the --debug=explain
option
will pinpoint that it's the change to the included file
that starts the chain of rebuilds:
%scons -Q
cc -o file1.o -c -I. file1.c cc -o file2.o -c -I. file2.c cc -o file3.o -c -I. file3.c cc -o prog file1.o file2.o file3.o % [CHANGE THE CONTENTS OF hello.h] %scons -Q --debug=explain
scons: rebuilding `file1.o' because `hello.h' changed cc -o file1.o -c -I. file1.c scons: rebuilding `file3.o' because `hello.h' changed cc -o file3.o -c -I. file3.c scons: rebuilding `prog' because: `file1.o' changed `file3.o' changed cc -o prog file1.o file2.o file3.o
(Note that the --debug=explain
option will only tell you
why SCons decided to rebuild necessary targets.
It does not tell you what files it examined
when deciding not
to rebuild a target file,
which is often a more valuable question to answer.)
When you create a construction environment,
SCons populates it
with construction variables that are set up
for various compilers, linkers and utilities
that it finds on your system.
Although this is usually helpful and what you want,
it might be frustrating if SCons
doesn't set certain variables that you
expect to be set.
In situations like this,
it's sometimes helpful to use the
construction environment Dump
method
to print all or some of
the construction variables.
Note that the Dump
method
returns
the representation of the variables
in the environment
for you to print (or otherwise manipulate):
env = Environment() print(env.Dump())
On a POSIX system with gcc installed, this might generate:
% scons
scons: Reading SConscript files ...
{ 'BUILDERS': { '_InternalInstall': <function InstallBuilderWrapper at 0x700000>,
'_InternalInstallAs': <function InstallAsBuilderWrapper at 0x700000>,
'_InternalInstallVersionedLib': <function InstallVersionedBuilderWrapper at 0x700000>},
'CONFIGUREDIR': '#/.sconf_temp',
'CONFIGURELOG': '#/config.log',
'CPPSUFFIXES': [ '.c',
'.C',
'.cxx',
'.cpp',
'.c++',
'.cc',
'.h',
'.H',
'.hxx',
'.hpp',
'.hh',
'.F',
'.fpp',
'.FPP',
'.m',
'.mm',
'.S',
'.spp',
'.SPP',
'.sx'],
'DSUFFIXES': ['.d'],
'Dir': <SCons.Defaults.Variable_Method_Caller object at 0x700000>,
'Dirs': <SCons.Defaults.Variable_Method_Caller object at 0x700000>,
'ENV': {'PATH': '/usr/local/bin:/opt/bin:/bin:/usr/bin:/snap/bin'},
'ESCAPE': <function escape at 0x700000>,
'File': <SCons.Defaults.Variable_Method_Caller object at 0x700000>,
'HOST_ARCH': 'arm64',
'HOST_OS': 'posix',
'IDLSUFFIXES': ['.idl', '.IDL'],
'INSTALL': <function copyFunc at 0x700000>,
'INSTALLVERSIONEDLIB': <function copyFuncVersionedLib at 0x700000>,
'LIBLITERALPREFIX': '',
'LIBPREFIX': 'lib',
'LIBPREFIXES': ['$LIBPREFIX'],
'LIBSUFFIX': '.a',
'LIBSUFFIXES': ['$LIBSUFFIX', '$SHLIBSUFFIX'],
'MAXLINELENGTH': 128072,
'OBJPREFIX': '',
'OBJSUFFIX': '.o',
'PLATFORM': 'posix',
'PROGPREFIX': '',
'PROGSUFFIX': '',
'PSPAWN': <function piped_env_spawn at 0x700000>,
'RDirs': <SCons.Defaults.Variable_Method_Caller object at 0x700000>,
'SCANNERS': [<SCons.Scanner.ScannerBase object at 0x700000>],
'SHELL': 'sh',
'SHLIBPREFIX': '$LIBPREFIX',
'SHLIBSUFFIX': '.so',
'SHOBJPREFIX': '$OBJPREFIX',
'SHOBJSUFFIX': '$OBJSUFFIX',
'SPAWN': <function subprocess_spawn at 0x700000>,
'TARGET_ARCH': None,
'TARGET_OS': None,
'TEMPFILE': <class 'SCons.Platform.TempFileMunge'>,
'TEMPFILEARGESCFUNC': <function quote_spaces at 0x700000>,
'TEMPFILEARGJOIN': ' ',
'TEMPFILEPREFIX': '@',
'TOOLS': ['install'],
'_CPPDEFFLAGS': '${_defines(CPPDEFPREFIX, CPPDEFINES, CPPDEFSUFFIX, __env__, '
'TARGET, SOURCE)}',
'_CPPINCFLAGS': '${_concat(INCPREFIX, CPPPATH, INCSUFFIX, __env__, RDirs, '
'TARGET, SOURCE, affect_signature=False)}',
'_LIBDIRFLAGS': '${_concat(LIBDIRPREFIX, LIBPATH, LIBDIRSUFFIX, __env__, '
'RDirs, TARGET, SOURCE, affect_signature=False)}',
'_LIBFLAGS': '${_concat(LIBLINKPREFIX, LIBS, LIBLINKSUFFIX, __env__)}',
'__DRPATH': '$_DRPATH',
'__DSHLIBVERSIONFLAGS': '${__libversionflags(__env__,"DSHLIBVERSION","_DSHLIBVERSIONFLAGS")}',
'__LDMODULEVERSIONFLAGS': '${__libversionflags(__env__,"LDMODULEVERSION","_LDMODULEVERSIONFLAGS")}',
'__RPATH': '$_RPATH',
'__SHLIBVERSIONFLAGS': '${__libversionflags(__env__,"SHLIBVERSION","_SHLIBVERSIONFLAGS")}',
'__lib_either_version_flag': <function __lib_either_version_flag at 0x700000>,
'__libversionflags': <function __libversionflags at 0x700000>,
'_concat': <function _concat at 0x700000>,
'_defines': <function _defines at 0x700000>,
'_stripixes': <function _stripixes at 0x700000>}
scons: done reading SConscript files.
scons: Building targets ...
scons: `.' is up to date.
scons: done building targets.
On a Windows system with Microsoft Visual C++ the output might look like:
C:\>scons
scons: Reading SConscript files ...
{ 'BUILDERS': { 'Object': <SCons.Builder.CompositeBuilder object at 0x700000>,
'PCH': <SCons.Builder.BuilderBase object at 0x700000>,
'RES': <SCons.Builder.BuilderBase object at 0x700000>,
'SharedObject': <SCons.Builder.CompositeBuilder object at 0x700000>,
'StaticObject': <SCons.Builder.CompositeBuilder object at 0x700000>,
'_InternalInstall': <function InstallBuilderWrapper at 0x700000>,
'_InternalInstallAs': <function InstallAsBuilderWrapper at 0x700000>,
'_InternalInstallVersionedLib': <function InstallVersionedBuilderWrapper at 0x700000>},
'CC': 'cl',
'CCCOM': <SCons.Action.FunctionAction object at 0x700000>,
'CCDEPFLAGS': '/showIncludes',
'CCFLAGS': ['/nologo'],
'CCPCHFLAGS': <function gen_ccpchflags at 0x700000>,
'CCPDBFLAGS': ['${(PDB and "/Z7") or ""}'],
'CFILESUFFIX': '.c',
'CFLAGS': [],
'CONFIGUREDIR': '#/.sconf_temp',
'CONFIGURELOG': '#/config.log',
'CPPDEFPREFIX': '/D',
'CPPDEFSUFFIX': '',
'CPPSUFFIXES': [ '.c',
'.C',
'.cxx',
'.cpp',
'.c++',
'.cc',
'.h',
'.H',
'.hxx',
'.hpp',
'.hh',
'.F',
'.fpp',
'.FPP',
'.m',
'.mm',
'.S',
'.spp',
'.SPP',
'.sx'],
'CXX': '$CC',
'CXXCOM': '${TEMPFILE("$CXX $_MSVC_OUTPUT_FLAG /c $CHANGED_SOURCES $CXXFLAGS '
'$CCFLAGS $_CCCOMCOM","$CXXCOMSTR")}',
'CXXFILESUFFIX': '.cc',
'CXXFLAGS': ['$(', '/TP', '$)'],
'DSUFFIXES': ['.d'],
'Dir': <SCons.Defaults.Variable_Method_Caller object at 0x700000>,
'Dirs': <SCons.Defaults.Variable_Method_Caller object at 0x700000>,
'ENV': { 'PATH': 'C:\\WINDOWS\\System32',
'PATHEXT': '.COM;.EXE;.BAT;.CMD',
'SystemRoot': 'C:\\WINDOWS'},
'ESCAPE': <function escape at 0x700000>,
'File': <SCons.Defaults.Variable_Method_Caller object at 0x700000>,
'HOST_ARCH': 'arm64',
'HOST_OS': 'win32',
'IDLSUFFIXES': ['.idl', '.IDL'],
'INCPREFIX': '/I',
'INCSUFFIX': '',
'INSTALL': <function copyFunc at 0x700000>,
'INSTALLVERSIONEDLIB': <function copyFuncVersionedLib at 0x700000>,
'LEXUNISTD': ['--nounistd'],
'LIBLITERALPREFIX': '',
'LIBPREFIX': '',
'LIBPREFIXES': ['$LIBPREFIX'],
'LIBSUFFIX': '.lib',
'LIBSUFFIXES': ['$LIBSUFFIX'],
'MAXLINELENGTH': 2048,
'MSVC_SETUP_RUN': True,
'NINJA_DEPFILE_PARSE_FORMAT': 'msvc',
'OBJPREFIX': '',
'OBJSUFFIX': '.obj',
'PCHCOM': '$CXX /Fo${TARGETS[1]} $CXXFLAGS $CCFLAGS $CPPFLAGS $_CPPDEFFLAGS '
'$_CPPINCFLAGS /c $SOURCES /Yc$PCHSTOP /Fp${TARGETS[0]} '
'$CCPDBFLAGS $PCHPDBFLAGS',
'PCHPDBFLAGS': ['${(PDB and "/Yd") or ""}'],
'PLATFORM': 'win32',
'PROGPREFIX': '',
'PROGSUFFIX': '.exe',
'PSPAWN': <function piped_spawn at 0x700000>,
'RC': 'rc',
'RCCOM': <SCons.Action.FunctionAction object at 0x700000>,
'RCFLAGS': ['/nologo'],
'RCSUFFIXES': ['.rc', '.rc2'],
'RDirs': <SCons.Defaults.Variable_Method_Caller object at 0x700000>,
'SCANNERS': [<SCons.Scanner.ScannerBase object at 0x700000>],
'SHCC': '$CC',
'SHCCCOM': <SCons.Action.FunctionAction object at 0x700000>,
'SHCCFLAGS': ['$CCFLAGS'],
'SHCFLAGS': ['$CFLAGS'],
'SHCXX': '$CXX',
'SHCXXCOM': '${TEMPFILE("$SHCXX $_MSVC_OUTPUT_FLAG /c $CHANGED_SOURCES '
'$SHCXXFLAGS $SHCCFLAGS $_CCCOMCOM","$SHCXXCOMSTR")}',
'SHCXXFLAGS': ['$CXXFLAGS'],
'SHELL': 'command',
'SHLIBPREFIX': '',
'SHLIBSUFFIX': '.dll',
'SHOBJPREFIX': '$OBJPREFIX',
'SHOBJSUFFIX': '$OBJSUFFIX',
'SPAWN': <function spawn at 0x700000>,
'STATIC_AND_SHARED_OBJECTS_ARE_THE_SAME': 1,
'TARGET_ARCH': None,
'TARGET_OS': None,
'TEMPFILE': <class 'SCons.Platform.TempFileMunge'>,
'TEMPFILEARGESCFUNC': <function quote_spaces at 0x700000>,
'TEMPFILEARGJOIN': '\n',
'TEMPFILEPREFIX': '@',
'TOOLS': ['msvc', 'install'],
'_CCCOMCOM': '$CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS $CCPCHFLAGS $CCPDBFLAGS',
'_CPPDEFFLAGS': '${_defines(CPPDEFPREFIX, CPPDEFINES, CPPDEFSUFFIX, __env__, '
'TARGET, SOURCE)}',
'_CPPINCFLAGS': '${_concat(INCPREFIX, CPPPATH, INCSUFFIX, __env__, RDirs, '
'TARGET, SOURCE, affect_signature=False)}',
'_LIBDIRFLAGS': '${_concat(LIBDIRPREFIX, LIBPATH, LIBDIRSUFFIX, __env__, '
'RDirs, TARGET, SOURCE, affect_signature=False)}',
'_LIBFLAGS': '${_concat(LIBLINKPREFIX, LIBS, LIBLINKSUFFIX, __env__)}',
'_MSVC_OUTPUT_FLAG': <function msvc_output_flag at 0x700000>,
'__DSHLIBVERSIONFLAGS': '${__libversionflags(__env__,"DSHLIBVERSION","_DSHLIBVERSIONFLAGS")}',
'__LDMODULEVERSIONFLAGS': '${__libversionflags(__env__,"LDMODULEVERSION","_LDMODULEVERSIONFLAGS")}',
'__SHLIBVERSIONFLAGS': '${__libversionflags(__env__,"SHLIBVERSION","_SHLIBVERSIONFLAGS")}',
'__lib_either_version_flag': <function __lib_either_version_flag at 0x700000>,
'__libversionflags': <function __libversionflags at 0x700000>,
'_concat': <function _concat at 0x700000>,
'_defines': <function _defines at 0x700000>,
'_stripixes': <function _stripixes at 0x700000>}
scons: done reading SConscript files.
scons: Building targets ...
scons: `.' is up to date.
scons: done building targets.
The construction environments in these examples have actually been restricted to just gcc and Microsoft Visual C++ respectively. In a real-life situation, the construction environments will likely contain a great many more variables. Also note that we've massaged the example output above to make the memory address of all objects a constant 0x700000. In reality, you would see a different hexadecimal number for each object.
To make it easier to see just what you're
interested in,
the Dump
method allows you to
specify a specific construction variable
that you want to disply.
For example,
it's not unusual to want to verify
the external environment used to execute build commands,
to make sure that the PATH and other
environment variables are set up the way they should be.
You can do this as follows:
env = Environment() print(env.Dump('ENV'))
Which might display the following when executed on a POSIX system:
% scons
scons: Reading SConscript files ...
{'ENV': {'PATH': '/usr/local/bin:/opt/bin:/bin:/usr/bin:/snap/bin'}}
scons: done reading SConscript files.
scons: Building targets ...
scons: `.' is up to date.
scons: done building targets.
And the following when executed on a Windows system:
C:\>scons
scons: Reading SConscript files ...
{ 'ENV': { 'PATH': 'C:\\WINDOWS\\System32:/usr/bin',
'PATHEXT': '.COM;.EXE;.BAT;.CMD',
'SystemRoot': 'C:\\WINDOWS'}}
scons: done reading SConscript files.
scons: Building targets ...
scons: `.' is up to date.
scons: done building targets.
Sometimes the best way to try to figure out what
SCons is doing is simply to take a look at the
dependency graph that it constructs
based on your SConscript
files.
The --tree
option
will display all or part of the
SCons dependency graph in an
"ASCII art" graphical format
that shows the dependency hierarchy.
For example, given the following input SConstruct
file:
env = Environment(CPPPATH = ['.']) env.Program('prog', ['f1.c', 'f2.c', 'f3.c'])
Running SCons with the --tree=all
option yields:
% scons -Q --tree=all
cc -o f1.o -c -I. f1.c
cc -o f2.o -c -I. f2.c
cc -o f3.o -c -I. f3.c
cc -o prog f1.o f2.o f3.o
+-.
+-SConstruct
+-f1.c
+-f1.o
| +-f1.c
| +-inc.h
+-f2.c
+-f2.o
| +-f2.c
| +-inc.h
+-f3.c
+-f3.o
| +-f3.c
| +-inc.h
+-inc.h
+-prog
+-f1.o
| +-f1.c
| +-inc.h
+-f2.o
| +-f2.c
| +-inc.h
+-f3.o
+-f3.c
+-inc.h
The tree will also be printed when the
-n
(no execute) option is used,
which allows you to examine the dependency graph
for a configuration without actually
rebuilding anything in the tree.
By default SCons uses "ASCII art" to draw the tree. It is
possible to use line-drawing characters (Unicode calls these
Box Drawing) to make a nicer display. To do this, add the
linedraw
qualifier:
% scons -Q --tree=all,linedraw
cc -o f1.o -c -I. f1.c
cc -o f2.o -c -I. f2.c
cc -o f3.o -c -I. f3.c
cc -o prog f1.o f2.o f3.o
└─┬.
├─SConstruct
├─f1.c
├─┬f1.o
│ ├─f1.c
│ └─inc.h
├─f2.c
├─┬f2.o
│ ├─f2.c
│ └─inc.h
├─f3.c
├─┬f3.o
│ ├─f3.c
│ └─inc.h
├─inc.h
└─┬prog
├─┬f1.o
│ ├─f1.c
│ └─inc.h
├─┬f2.o
│ ├─f2.c
│ └─inc.h
└─┬f3.o
├─f3.c
└─inc.h
The --tree
option only prints
the dependency graph for the specified targets
(or the default target(s) if none are specified on the command line).
So if you specify a target like f2.o
on the command line,
the --tree
option will only
print the dependency graph for that file:
% scons -Q --tree=all f2.o
cc -o f2.o -c -I. f2.c
+-f2.o
+-f2.c
+-inc.h
This is, of course, useful for restricting the output from a very large build configuration to just a portion in which you're interested. Multiple targets are fine, in which case a tree will be printed for each specified target:
% scons -Q --tree=all f1.o f3.o
cc -o f1.o -c -I. f1.c
+-f1.o
+-f1.c
+-inc.h
cc -o f3.o -c -I. f3.c
+-f3.o
+-f3.c
+-inc.h
The status
argument may be used
to tell SCons to print status information about
each file in the dependency graph:
% scons -Q --tree=status
cc -o f1.o -c -I. f1.c
cc -o f2.o -c -I. f2.c
cc -o f3.o -c -I. f3.c
cc -o prog f1.o f2.o f3.o
E = exists
R = exists in repository only
b = implicit builder
B = explicit builder
S = side effect
P = precious
A = always build
C = current
N = no clean
H = no cache
[E b ]+-.
[E C ] +-SConstruct
[E C ] +-f1.c
[E B C ] +-f1.o
[E C ] | +-f1.c
[E C ] | +-inc.h
[E C ] +-f2.c
[E B C ] +-f2.o
[E C ] | +-f2.c
[E C ] | +-inc.h
[E C ] +-f3.c
[E B C ] +-f3.o
[E C ] | +-f3.c
[E C ] | +-inc.h
[E C ] +-inc.h
[E B C ] +-prog
[E B C ] +-f1.o
[E C ] | +-f1.c
[E C ] | +-inc.h
[E B C ] +-f2.o
[E C ] | +-f2.c
[E C ] | +-inc.h
[E B C ] +-f3.o
[E C ] +-f3.c
[E C ] +-inc.h
Note that --tree=all,status
is equivalent;
the all
is assumed if only status
is present.
As an alternative to all
,
you can specify --tree=derived
to have SCons only print derived targets
in the tree output,
skipping source files
(like .c
and .h
files):
% scons -Q --tree=derived
cc -o f1.o -c -I. f1.c
cc -o f2.o -c -I. f2.c
cc -o f3.o -c -I. f3.c
cc -o prog f1.o f2.o f3.o
+-.
+-f1.o
+-f2.o
+-f3.o
+-prog
+-f1.o
+-f2.o
+-f3.o
You can use the status
modifier with derived
as well:
% scons -Q --tree=derived,status
cc -o f1.o -c -I. f1.c
cc -o f2.o -c -I. f2.c
cc -o f3.o -c -I. f3.c
cc -o prog f1.o f2.o f3.o
E = exists
R = exists in repository only
b = implicit builder
B = explicit builder
S = side effect
P = precious
A = always build
C = current
N = no clean
H = no cache
[E b ]+-.
[E B C ] +-f1.o
[E B C ] +-f2.o
[E B C ] +-f3.o
[E B C ] +-prog
[E B C ] +-f1.o
[E B C ] +-f2.o
[E B C ] +-f3.o
Note that the order of the --tree=
arguments doesn't matter;
--tree=status,derived
is
completely equivalent.
The default behavior of the --tree
option
is to repeat all of the dependencies each time the library dependency
(or any other dependency file) is encountered in the tree.
If certain target files share other target files,
such as two programs that use the same library:
env = Environment(CPPPATH = ['.'], LIBS = ['foo'], LIBPATH = ['.']) env.Library('foo', ['f1.c', 'f2.c', 'f3.c']) env.Program('prog1.c') env.Program('prog2.c')
Then there can be a lot of repetition in the
--tree=
output:
% scons -Q --tree=all
cc -o f1.o -c -I. f1.c
cc -o f2.o -c -I. f2.c
cc -o f3.o -c -I. f3.c
ar rc libfoo.a f1.o f2.o f3.o
ranlib libfoo.a
cc -o prog1.o -c -I. prog1.c
cc -o prog1 prog1.o -L. -lfoo
cc -o prog2.o -c -I. prog2.c
cc -o prog2 prog2.o -L. -lfoo
+-.
+-SConstruct
+-f1.c
+-f1.o
| +-f1.c
| +-inc.h
+-f2.c
+-f2.o
| +-f2.c
| +-inc.h
+-f3.c
+-f3.o
| +-f3.c
| +-inc.h
+-inc.h
+-libfoo.a
| +-f1.o
| | +-f1.c
| | +-inc.h
| +-f2.o
| | +-f2.c
| | +-inc.h
| +-f3.o
| +-f3.c
| +-inc.h
+-prog1
| +-prog1.o
| | +-prog1.c
| | +-inc.h
| +-libfoo.a
| +-f1.o
| | +-f1.c
| | +-inc.h
| +-f2.o
| | +-f2.c
| | +-inc.h
| +-f3.o
| +-f3.c
| +-inc.h
+-prog1.c
+-prog1.o
| +-prog1.c
| +-inc.h
+-prog2
| +-prog2.o
| | +-prog2.c
| | +-inc.h
| +-libfoo.a
| +-f1.o
| | +-f1.c
| | +-inc.h
| +-f2.o
| | +-f2.c
| | +-inc.h
| +-f3.o
| +-f3.c
| +-inc.h
+-prog2.c
+-prog2.o
+-prog2.c
+-inc.h
In a large configuration with many internal libraries
and include files,
this can very quickly lead to huge output trees.
To help make this more manageable,
a prune
modifier may
be added to the option list,
in which case SCons
will print the name of a target that has
already been visited during the tree-printing
in square brackets ([]
)
as an indication that the dependencies
of the target file may be found
by looking farther up the tree:
% scons -Q --tree=prune
cc -o f1.o -c -I. f1.c
cc -o f2.o -c -I. f2.c
cc -o f3.o -c -I. f3.c
ar rc libfoo.a f1.o f2.o f3.o
ranlib libfoo.a
cc -o prog1.o -c -I. prog1.c
cc -o prog1 prog1.o -L. -lfoo
cc -o prog2.o -c -I. prog2.c
cc -o prog2 prog2.o -L. -lfoo
+-.
+-SConstruct
+-f1.c
+-f1.o
| +-f1.c
| +-inc.h
+-f2.c
+-f2.o
| +-f2.c
| +-inc.h
+-f3.c
+-f3.o
| +-f3.c
| +-inc.h
+-inc.h
+-libfoo.a
| +-[f1.o]
| +-[f2.o]
| +-[f3.o]
+-prog1
| +-prog1.o
| | +-prog1.c
| | +-inc.h
| +-[libfoo.a]
+-prog1.c
+-[prog1.o]
+-prog2
| +-prog2.o
| | +-prog2.c
| | +-inc.h
| +-[libfoo.a]
+-prog2.c
+-[prog2.o]
Like the status
keyword,
the prune
argument by itself
is equivalent to --tree=all,prune
.
Sometimes the command lines that SCons executes don't
come out looking as you expect. In this case it may be
useful to look at the strings before SCons performs
substitution on them.
This can be done with the --debug=presub
option:
% scons -Q --debug=presub
Building prog.o with action:
$CC -o $TARGET -c $CFLAGS $CCFLAGS $_CCOMCOM $SOURCES
cc -o prog.o -c -I. prog.c
Building prog with action:
$SMART_LINKCOM
cc -o prog prog.o
To get some insight into what library names
SCons is searching for,
and in which directories it is searching,
Use the --debug=findlibs
option.
Given the following input SConstruct
file:
env = Environment(LIBPATH = ['libs1', 'libs2']) env.Program('prog.c', LIBS=['foo', 'bar'])
And the libraries libfoo.a
and libbar.a
in libs1
and libs2
,
respectively,
use of the --debug=findlibs
option yields:
% scons -Q --debug=findlibs
findlibs: looking for 'libfoo.a' in 'libs1' ...
findlibs: ... FOUND 'libfoo.a' in 'libs1'
findlibs: looking for 'libfoo.so' in 'libs1' ...
findlibs: looking for 'libfoo.so' in 'libs2' ...
findlibs: looking for 'libbar.a' in 'libs1' ...
findlibs: looking for 'libbar.a' in 'libs2' ...
findlibs: ... FOUND 'libbar.a' in 'libs2'
findlibs: looking for 'libbar.so' in 'libs1' ...
findlibs: looking for 'libbar.so' in 'libs2' ...
cc -o prog.o -c prog.c
cc -o prog prog.o -Llibs1 -Llibs2 -lfoo -lbar
In general, SCons tries to keep its error messages short and informative. That means we usually try to avoid showing the stack traces that are familiar to experienced Python programmers, since they usually contain much more information than is useful to most people.
For example, the following SConstruct
file:
Program('prog.c')
Generates the following error if the
prog.c
file
does not exist:
% scons -Q
scons: *** [prog.o] Source `prog.c' not found, needed by target `prog.o'.
In this case,
the error is pretty obvious.
But if it weren't,
and you wanted to try to get more information
about the error,
the --debug=stacktrace
option
would show you exactly where in the SCons source code
the problem occurs:
% scons -Q --debug=stacktrace
scons: *** [prog.o] Source `prog.c' not found, needed by target `prog.o'.
scons: internal stack trace:
File "SCons/Taskmaster/Job.py", line 670, in _work
task.prepare()
File "SCons/Script/Main.py", line 208, in prepare
return SCons.Taskmaster.OutOfDateTask.prepare(self)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "SCons/Taskmaster/__init__.py", line 195, in prepare
executor.prepare()
File "SCons/Executor.py", line 420, in prepare
raise SCons.Errors.StopError(msg % (s, self.batches[0].targets[0]))
Of course, if you do need to dive into the SCons source code, we'd like to know if, or how, the error messages or troubleshooting options could have been improved to avoid that. Not everyone has the necessary time or Python skill to dive into the source code, and we'd like to improve SCons for those people as well...
The internal SCons subsystem that handles walking
the dependency graph
and controls the decision-making about what to rebuild
is the Taskmaster.
SCons supports a --taskmastertrace
option that tells the Taskmaster to print
information about the children (dependencies)
of the various Nodes on its walk down the graph,
which specific dependent Nodes are being evaluated,
and in what order.
The --taskmastertrace
option
takes as an argument the name of a file in
which to put the trace output,
with -
(a single hyphen)
indicating that the trace messages
should be printed to the standard output:
env = Environment(CPPPATH = ['.']) env.Program('prog.c')
% scons -Q --taskmastertrace=- prog
Job.NewParallel._work(): [Thread:8682049344] Gained exclusive access
Job.NewParallel._work(): [Thread:8682049344] Starting search
Job.NewParallel._work(): [Thread:8682049344] Found 0 completed tasks to process
Job.NewParallel._work(): [Thread:8682049344] Searching for new tasks
Taskmaster: Looking for a node to evaluate
Taskmaster: Considering node <no_state 0 'prog'> and its children:
Taskmaster: <no_state 0 'prog.o'>
Taskmaster: adjusted ref count: <pending 1 'prog'>, child 'prog.o'
Taskmaster: Considering node <no_state 0 'prog.o'> and its children:
Taskmaster: <no_state 0 'prog.c'>
Taskmaster: <no_state 0 'inc.h'>
Taskmaster: adjusted ref count: <pending 1 'prog.o'>, child 'prog.c'
Taskmaster: adjusted ref count: <pending 2 'prog.o'>, child 'inc.h'
Taskmaster: Considering node <no_state 0 'prog.c'> and its children:
Taskmaster: Evaluating <pending 0 'prog.c'>
Task.make_ready_current(): node <pending 0 'prog.c'>
Task.prepare(): node <up_to_date 0 'prog.c'>
Job.NewParallel._work(): [Thread:8682049344] Found internal task
Task.executed_with_callbacks(): node <up_to_date 0 'prog.c'>
Task.postprocess(): node <up_to_date 0 'prog.c'>
Task.postprocess(): removing <up_to_date 0 'prog.c'>
Task.postprocess(): adjusted parent ref count <pending 1 'prog.o'>
Job.NewParallel._work(): [Thread:8682049344] Searching for new tasks
Taskmaster: Looking for a node to evaluate
Taskmaster: Considering node <no_state 0 'inc.h'> and its children:
Taskmaster: Evaluating <pending 0 'inc.h'>
Task.make_ready_current(): node <pending 0 'inc.h'>
Task.prepare(): node <up_to_date 0 'inc.h'>
Job.NewParallel._work(): [Thread:8682049344] Found internal task
Task.executed_with_callbacks(): node <up_to_date 0 'inc.h'>
Task.postprocess(): node <up_to_date 0 'inc.h'>
Task.postprocess(): removing <up_to_date 0 'inc.h'>
Task.postprocess(): adjusted parent ref count <pending 0 'prog.o'>
Job.NewParallel._work(): [Thread:8682049344] Searching for new tasks
Taskmaster: Looking for a node to evaluate
Taskmaster: Considering node <pending 0 'prog.o'> and its children:
Taskmaster: <up_to_date 0 'prog.c'>
Taskmaster: <up_to_date 0 'inc.h'>
Taskmaster: Evaluating <pending 0 'prog.o'>
Task.make_ready_current(): node <pending 0 'prog.o'>
Task.prepare(): node <executing 0 'prog.o'>
Job.NewParallel._work(): [Thread:8682049344] Found task requiring execution
Job.NewParallel._work(): [Thread:8682049344] Executing task
Task.execute(): node <executing 0 'prog.o'>
cc -o prog.o -c -I. prog.c
Job.NewParallel._work(): [Thread:8682049344] Enqueueing executed task results
Job.NewParallel._work(): [Thread:8682049344] Gained exclusive access
Job.NewParallel._work(): [Thread:8682049344] Starting search
Job.NewParallel._work(): [Thread:8682049344] Found 1 completed tasks to process
Task.executed_with_callbacks(): node <executing 0 'prog.o'>
Task.postprocess(): node <executed 0 'prog.o'>
Task.postprocess(): removing <executed 0 'prog.o'>
Task.postprocess(): adjusted parent ref count <pending 0 'prog'>
Job.NewParallel._work(): [Thread:8682049344] Searching for new tasks
Taskmaster: Looking for a node to evaluate
Taskmaster: Considering node <pending 0 'prog'> and its children:
Taskmaster: <executed 0 'prog.o'>
Taskmaster: Evaluating <pending 0 'prog'>
Task.make_ready_current(): node <pending 0 'prog'>
Task.prepare(): node <executing 0 'prog'>
Job.NewParallel._work(): [Thread:8682049344] Found task requiring execution
Job.NewParallel._work(): [Thread:8682049344] Executing task
Task.execute(): node <executing 0 'prog'>
cc -o prog prog.o
Job.NewParallel._work(): [Thread:8682049344] Enqueueing executed task results
Job.NewParallel._work(): [Thread:8682049344] Gained exclusive access
Job.NewParallel._work(): [Thread:8682049344] Starting search
Job.NewParallel._work(): [Thread:8682049344] Found 1 completed tasks to process
Task.executed_with_callbacks(): node <executing 0 'prog'>
Task.postprocess(): node <executed 0 'prog'>
Job.NewParallel._work(): [Thread:8682049344] Searching for new tasks
Taskmaster: Looking for a node to evaluate
Taskmaster: No candidate anymore.
Job.NewParallel._work(): [Thread:8682049344] Found no task requiring execution, and have no jobs: marking complete
Job.NewParallel._work(): [Thread:8682049344] Gained exclusive access
Job.NewParallel._work(): [Thread:8682049344] Completion detected, breaking from main loop
The --taskmastertrace
option
doesn't provide information about the actual
calculations involved in deciding if a file is up-to-date,
but it does show all of the dependencies
it knows about for each Node,
and the order in which those dependencies are evaluated.
This can be useful as an alternate way to determine
whether or not your SCons configuration,
or the implicit dependency scan,
has actually identified all the correct dependencies
you want it to.
Sometimes SCons doesn't build the target you want
and it's difficult to figure out why. You can use
the --debug=prepare
option
to see all the targets SCons is considering, and whether
they are already up-to-date or not. The message is
printed before SCons decides whether to build the target.
When using the Duplicate
option to create variant dirs,
sometimes you may find files not getting linked or copied to where you
expect (or not at all), or files mysteriously disappearing.
These are usually because of a misconfiguration of some kind in the
SConscript files, but they can be tricky to debug. The
--debug=duplicate
option shows each time a variant file is
unlinked and relinked from its source (or copied, depending on
settings), and also shows a message for removing "stale"
variant-dir files that no longer have a corresponding source file.
It also prints a line for each target that's removed just before
building, since that can also be mistaken for the same thing.
Over the years, many developers have chosen to dive in and make vastly complicated build systems out of SCons, which sometimes don't work quite as expected. As a general rule, make sure you need to reach for a complex solution before you do so. SCons is mature software and has evolved over time to meet a lot of feature requests, so there is often an easier way to do something if you can just find it. The SCons community can be helpful here - the discussion lists and chat channels can be a way to find out if something can be done an easier way before embarking on an implementation.
When something does misbehave, trying to isolate the problem to a simple test case can really help. The work to create a reproducer often helps you spot the issue yourself, and a simple example is much easier for others to look over and possibly spot logical flaws, misuse of the API, or other ways something could have been done. In addition, if it turns out there's actually a real SCons bug (we believe it's a high quality piece of software, but all software has some bugs), it's very likely the bug filing will result in a request for a simple reproducer anyway.
This appendix contains descriptions of all of the construction variables that are potentially available "out of the box" in this version of SCons. Whether or not setting a construction variable in a construction environment will actually have an effect depends on whether any of the Tools and/or Builders that use the variable have been included in the construction environment.
In this appendix, we have
appended the initial $
(dollar sign) to the beginning of each
variable name when it appears in the text,
but left off the dollar sign
in the left-hand column
where the name appears for each entry.
__LDMODULEVERSIONFLAGS
This construction variable automatically introduces $_LDMODULEVERSIONFLAGS
if $LDMODULEVERSION
is set. Othervise it evaluates to an empty string.
__SHLIBVERSIONFLAGS
This construction variable automatically introduces $_SHLIBVERSIONFLAGS
if $SHLIBVERSION
is set. Othervise it evaluates to an empty string.
APPLELINK_COMPATIBILITY_VERSION
On Mac OS X this is used to set the linker flag: -compatibility_version
The value is specified as X[.Y[.Z]] where X is between 1 and 65535, Y can be omitted or between 1 and
255, Z can be omitted or between 1 and 255. This value will be derived from $SHLIBVERSION
if
not
specified. The lowest digit will be dropped and replaced by a 0.
If the $APPLELINK_NO_COMPATIBILITY_VERSION
is set then no -compatibility_version will be
output.
See MacOS's ld manpage for more details
_APPLELINK_COMPATIBILITY_VERSION
A macro (by default a generator function) used to create the linker flags to specify
apple's linker's -compatibility_version flag.
The default generator uses $APPLELINK_COMPATIBILITY_VERSION
and $APPLELINK_NO_COMPATIBILITY_VERSION
and $SHLIBVERSION
to determine the correct flag.
APPLELINK_CURRENT_VERSION
On Mac OS X this is used to set the linker flag: -current_version
The value is specified as X[.Y[.Z]] where X is between 1 and 65535, Y can be omitted or between 1 and
255, Z can be omitted or between 1 and 255. This value will be set to $SHLIBVERSION
if not
specified.
If the $APPLELINK_NO_CURRENT_VERSION
is set then no -current_version will be
output.
See MacOS's ld manpage for more details
_APPLELINK_CURRENT_VERSION
A macro (by default a generator function) used to create the linker flags to specify apple's linker's
-current_version flag. The default generator uses $APPLELINK_CURRENT_VERSION
and
$APPLELINK_NO_CURRENT_VERSION
and $SHLIBVERSION
to determine the correct flag.
APPLELINK_NO_COMPATIBILITY_VERSION
Set this to any True (1|True|non-empty string) value to disable adding -compatibility_version flag when generating versioned shared libraries.
This overrides $APPLELINK_COMPATIBILITY_VERSION
.
APPLELINK_NO_CURRENT_VERSION
Set this to any True (1|True|non-empty string) value to disable adding -current_version flag when generating versioned shared libraries.
This overrides $APPLELINK_CURRENT_VERSION
.
AR
The static library archiver.
ARCHITECTURE
Specifies the system architecture for which
the package is being built.
The default is the system architecture
of the machine on which SCons is running.
This is used to fill in the
Architecture:
field in an Ipkg
control
file,
and the BuildArch:
field
in the RPM .spec
file,
as well as forming part of the name of a generated RPM package file.
See the Package
builder.
ARCOM
The command line used to generate a static library from object files.
ARCOMSTR
The string displayed when a static library is
generated from object files.
If this is not set, then $ARCOM
(the command line) is displayed.
env = Environment(ARCOMSTR = "Archiving $TARGET")
ARFLAGS
General options passed to the static library archiver.
AS
The assembler.
ASCOM
The command line used to generate an object file from an assembly-language source file.
ASCOMSTR
The string displayed when an object file
is generated from an assembly-language source file.
If this is not set, then $ASCOM
(the command line) is displayed.
env = Environment(ASCOMSTR = "Assembling $TARGET")
ASFLAGS
General options passed to the assembler.
ASPPCOM
The command line used to assemble an assembly-language
source file into an object file
after first running the file through the C preprocessor.
Any options specified
in the $ASFLAGS
and $CPPFLAGS
construction variables
are included on this command line.
ASPPCOMSTR
The string displayed when an object file
is generated from an assembly-language source file
after first running the file through the C preprocessor.
If this is not set, then $ASPPCOM
(the command line) is displayed.
env = Environment(ASPPCOMSTR = "Assembling $TARGET")
ASPPFLAGS
General options when an assembling an assembly-language
source file into an object file
after first running the file through the C preprocessor.
The default is to use the value of $ASFLAGS
.
BIBTEX
The bibliography generator for the TeX formatter and typesetter and the LaTeX structured formatter and typesetter.
BIBTEXCOM
The command line used to call the bibliography generator for the TeX formatter and typesetter and the LaTeX structured formatter and typesetter.
BIBTEXCOMSTR
The string displayed when generating a bibliography
for TeX or LaTeX.
If this is not set, then $BIBTEXCOM
(the command line) is displayed.
env = Environment(BIBTEXCOMSTR = "Generating bibliography $TARGET")
BIBTEXFLAGS
General options passed to the bibliography generator for the TeX formatter and typesetter and the LaTeX structured formatter and typesetter.
BUILDERS
A dictionary mapping the names of the builders available through the construction environment to underlying Builder objects. Custom builders need to be added to this to make them available.
A platform-dependent default list of builders such as
Program
, Library
etc. is used to
populate this construction variable when the construction environment is initialized
via the presence/absence of the tools those builders depend on.
$BUILDERS
can be examined to learn which builders will
actually be available at run-time.
Note that if you initialize this construction variable through
assignment when the construction environment is created,
that value for $BUILDERS
will override any defaults:
bld = Builder(action='foobuild < $SOURCE > $TARGET') env = Environment(BUILDERS={'NewBuilder': bld})
To instead use a new Builder object in addition to the default Builders, add your new Builder object like this:
env = Environment() env.Append(BUILDERS={'NewBuilder': bld})
or this:
env = Environment() env['BUILDERS']['NewBuilder'] = bld
CACHEDIR_CLASS
The class type that SCons should use when instantiating a
new CacheDir
in this construction environment. Must be
a subclass of the SCons.CacheDir.CacheDir
class.
CC
The C compiler.
CCCOM
The command line used to compile a C source file to a (static) object
file. Any options specified in the $CFLAGS
, $CCFLAGS
and
$CPPFLAGS
construction variables are included on this command line.
See also $SHCCCOM
for compiling to shared objects.
CCCOMSTR
If set, the string displayed when a C source file
is compiled to a (static) object file.
If not set, then $CCCOM
(the command line) is displayed.
See also $SHCCCOMSTR
for compiling to shared objects.
env = Environment(CCCOMSTR = "Compiling static object $TARGET")
CCDEPFLAGS
Options to pass to C or C++ compiler to generate list of dependency files.
This is set only by compilers which support this functionality. (gcc
, clang
, and msvc
currently)
CCFLAGS
General options that are passed to the C and C++ compilers.
See also $SHCCFLAGS
for compiling to shared objects.
CCPCHFLAGS
Options added to the compiler command line
to support building with precompiled headers.
The default value expands expands to the appropriate
Microsoft Visual C++ command-line options
when the $PCH
construction variable is set.
CCPDBFLAGS
Options added to the compiler command line
to support storing debugging information in a
Microsoft Visual C++ PDB file.
The default value expands expands to appropriate
Microsoft Visual C++ command-line options
when the $PDB
construction variable is set.
The Microsoft Visual C++ compiler option that SCons uses by default
to generate PDB information is /Z7
.
This works correctly with parallel (-j
) builds
because it embeds the debug information in the intermediate object files,
as opposed to sharing a single PDB file between multiple object files.
This is also the only way to get debug information
embedded into a static library.
Using the /Zi
instead may yield improved
link-time performance,
although parallel builds will no longer work.
You can generate PDB files with the /Zi
switch by overriding the default $CCPDBFLAGS
variable as follows:
env['CCPDBFLAGS'] = ['${(PDB and "/Zi /Fd%s" % File(PDB)) or ""}']
An alternative would be to use the /Zi
to put the debugging information in a separate .pdb
file for each object file by overriding
the $CCPDBFLAGS
variable as follows:
env['CCPDBFLAGS'] = '/Zi /Fd${TARGET}.pdb'
CCVERSION
The version number of the C compiler. This may or may not be set, depending on the specific C compiler being used.
CFILESUFFIX
The suffix for C source files.
This is used by the internal CFile builder
when generating C files from Lex (.l) or YACC (.y) input files.
The default suffix, of course, is
.c
(lower case).
On case-insensitive systems (like Windows),
SCons also treats
.C
(upper case) files
as C files.
CFLAGS
General options that are passed to the C compiler (C only; not C++).
See also $SHCFLAGS
for compiling to shared objects.
CHANGE_SPECFILE
A hook for modifying the file that controls the packaging build
(the .spec
for RPM,
the control
for Ipkg,
the .wxs
for MSI).
If set, the function will be called
after the SCons template for the file has been written.
See the Package
builder.
CHANGED_SOURCES
A reserved variable name that may not be set or used in a construction environment. (See the manpage section "Variable Substitution" for more information).
CHANGED_TARGETS
A reserved variable name that may not be set or used in a construction environment. (See the manpage section "Variable Substitution" for more information).
CHANGELOG
The name of a file containing the change log text
to be included in the package.
This is included as the
%changelog
section of the RPM
.spec
file.
See the Package
builder.
COMPILATIONDB_COMSTR
The string displayed when the CompilationDatabase
builder's action is run.
COMPILATIONDB_PATH_FILTER
A string which instructs CompilationDatabase
to
only include entries where the output
member
matches the pattern in the filter string using fnmatch, which
uses glob style wildcards.
The default value is an empty string '', which disables filtering.
COMPILATIONDB_USE_ABSPATH
A boolean flag to instruct CompilationDatabase
whether to write the file
and
output
members
in the compilation database using absolute or relative paths.
The default value is False (use relative paths)
_concat
A function used to produce variables like $_CPPINCFLAGS
. It takes
four mandatory arguments, and up to 4 additional optional arguments:
1) a prefix to concatenate onto each element,
2) a list of elements,
3) a suffix to concatenate onto each element,
4) an environment for variable interpolation,
5) an optional function that will be called to transform the list before concatenation,
6) an optionally specified target (Can use TARGET),
7) an optionally specified source (Can use SOURCE),
8) optional affect_signature
flag which will wrap non-empty returned value with $( and $) to indicate the contents
should not affect the signature of the generated command line.
env['_CPPINCFLAGS'] = '${_concat(INCPREFIX, CPPPATH, INCSUFFIX, __env__, RDirs, TARGET, SOURCE, affect_signature=False)}'
CONFIGUREDIR
The name of the directory in which
Configure context test files are written.
The default is
.sconf_temp
in the top-level directory
containing the
SConstruct
file.
If variant directories are in use,
and the configure check results should not be
shared between variants,
you can set $CONFIGUREDIR
and $CONFIGURELOG
so they are
unique per variant directory.
CONFIGURELOG
The name of the Configure
context log file.
The default is
config.log
in the top-level directory
containing the
SConstruct
file.
If variant directories are in use,
and the configure check results should not be
shared between variants,
you can set $CONFIGUREDIR
and $CONFIGURELOG
so they are
unique per variant directory.
_CPPDEFFLAGS
An automatically-generated construction variable
containing the C preprocessor command-line options
to define values.
The value of $_CPPDEFFLAGS
is created
by respectively prepending and appending
$CPPDEFPREFIX
and $CPPDEFSUFFIX
to each definition in $CPPDEFINES
.
CPPDEFINES
A platform independent specification of C preprocessor macro definitions.
The definitions are added to command lines
through the automatically-generated
$_CPPDEFFLAGS
construction variable,
which is constructed according to
the contents of $CPPDEFINES
:
If $CPPDEFINES
is a string,
the values of the
$CPPDEFPREFIX
and $CPPDEFSUFFIX
construction variables
are respectively prepended and appended to
each definition in $CPPDEFINES
,
split on whitespace.
# Adds -Dxyz to POSIX compiler command lines, # and /Dxyz to Microsoft Visual C++ command lines. env = Environment(CPPDEFINES='xyz')
If $CPPDEFINES
is a list,
the values of the
$CPPDEFPREFIX
and $CPPDEFSUFFIX
construction variables
are respectively prepended and appended to
each element in the list.
If any element is a tuple (or list)
then the first item of the tuple is the macro name
and the second is the macro definition.
If the definition is not omitted or None
,
the name and definition are combined into a single
name=definition
item
before the preending/appending.
# Adds -DB=2 -DA to POSIX compiler command lines, # and /DB=2 /DA to Microsoft Visual C++ command lines. env = Environment(CPPDEFINES=[('B', 2), 'A'])
If $CPPDEFINES
is a dictionary,
the values of the
$CPPDEFPREFIX
and $CPPDEFSUFFIX
construction variables
are respectively prepended and appended to
each key from the dictionary.
If the value for a key is not None
,
then the key (macro name) and the value
(macros definition) are combined into a single
name=definition
item
before the prepending/appending.
# Adds -DA -DB=2 to POSIX compiler command lines, # or /DA /DB=2 to Microsoft Visual C++ command lines. env = Environment(CPPDEFINES={'B':2, 'A':None})
Depending on how contents are added to $CPPDEFINES
,
it may be transformed into a compound type,
for example a list containing strings, tuples and/or dictionaries.
SCons can correctly expand such a compound type.
Note that SCons may call the compiler via a shell. If a macro definition contains characters such as spaces that have meaning to the shell, or is intended to be a string value, you may need to use the shell's quoting syntax to avoid interpretation by the shell before the preprocessor sees it. Function-like macros are not supported via this mechanism (and some compilers do not even implement that functionality via the command lines). When quoting, note that one set of quote characters are used to define a Python string, then quotes embedded inside that would be consumed by the shell unless escaped. These examples may help illustrate:
env = Environment(CPPDEFINES=['USE_ALT_HEADER=\\"foo_alt.h\\"']) env = Environment(CPPDEFINES=[('USE_ALT_HEADER', '\\"foo_alt.h\\"')])
:Changed in version 4.5:
SCons no longer sorts $CPPDEFINES
values entered
in dictionary form. Python now preserves dictionary
keys in the order they are entered, so it is no longer
necessary to sort them to ensure a stable command line.
CPPDEFPREFIX
The prefix used to specify preprocessor macro definitions
on the C compiler command line.
This will be prepended to each definition
in the $CPPDEFINES
construction variable
when the $_CPPDEFFLAGS
variable is automatically generated.
CPPDEFSUFFIX
The suffix used to specify preprocessor macro definitions
on the C compiler command line.
This will be appended to each definition
in the $CPPDEFINES
construction variable
when the $_CPPDEFFLAGS
variable is automatically generated.
CPPFLAGS
User-specified C preprocessor options.
These will be included in any command that uses the C preprocessor,
including not just compilation of C and C++ source files
via the $CCCOM
,
$SHCCCOM
,
$CXXCOM
and
$SHCXXCOM
command lines,
but also the $FORTRANPPCOM
,
$SHFORTRANPPCOM
,
$F77PPCOM
and
$SHF77PPCOM
command lines
used to compile a Fortran source file,
and the $ASPPCOM
command line
used to assemble an assembly language source file,
after first running each file through the C preprocessor.
Note that this variable does
not
contain
-I
(or similar) include search path options
that scons generates automatically from $CPPPATH
.
See $_CPPINCFLAGS
, below,
for the variable that expands to those options.
_CPPINCFLAGS
An automatically-generated construction variable
containing the C preprocessor command-line options
for specifying directories to be searched for include files.
The value of $_CPPINCFLAGS
is created
by respectively prepending and appending
$INCPREFIX
and $INCSUFFIX
to each directory in $CPPPATH
.
CPPPATH
The list of directories that the C preprocessor will search for include
directories. The C/C++ implicit dependency scanner will search these
directories for include files.
In general it's not advised to put include directory directives
directly into $CCFLAGS
or $CXXFLAGS
as the result will be non-portable
and the directories will not be searched by the dependency scanner.
$CPPPATH
should be a list of path strings,
or a single string, not a pathname list joined by
Python's os.pathsep
.
Note:
directory names in $CPPPATH
will be looked-up relative to the directory of the SConscript file
when they are used in a command.
To force scons
to look-up a directory relative to the root of the source tree use
the #
prefix:
env = Environment(CPPPATH='#/include')
The directory look-up can also be forced using the
Dir
function:
include = Dir('include') env = Environment(CPPPATH=include)
The directory list will be added to command lines
through the automatically-generated
$_CPPINCFLAGS
construction variable,
which is constructed by
respectively prepending and appending the values of the
$INCPREFIX
and $INCSUFFIX
construction variables
to each directory in $CPPPATH
.
Any command lines you define that need
the $CPPPATH
directory list should
include $_CPPINCFLAGS
:
env = Environment(CCCOM="my_compiler $_CPPINCFLAGS -c -o $TARGET $SOURCE")
CPPSUFFIXES
The list of suffixes of files that will be scanned for C preprocessor implicit dependencies (#include lines). The default list is:
[".c", ".C", ".cxx", ".cpp", ".c++", ".cc", ".h", ".H", ".hxx", ".hpp", ".hh", ".F", ".fpp", ".FPP", ".m", ".mm", ".S", ".spp", ".SPP"]
CXX
The C++ compiler.
See also $SHCXX
for compiling to shared objects..
CXXCOM
The command line used to compile a C++ source file to an object file.
Any options specified in the $CXXFLAGS
and
$CPPFLAGS
construction variables
are included on this command line.
See also $SHCXXCOM
for compiling to shared objects..
CXXCOMSTR
If set, the string displayed when a C++ source file
is compiled to a (static) object file.
If not set, then $CXXCOM
(the command line) is displayed.
See also $SHCXXCOMSTR
for compiling to shared objects..
env = Environment(CXXCOMSTR = "Compiling static object $TARGET")
CXXFILESUFFIX
The suffix for C++ source files.
This is used by the internal CXXFile builder
when generating C++ files from Lex (.ll) or YACC (.yy) input files.
The default suffix is
.cc
.
SCons also treats files with the suffixes
.cpp
,
.cxx
,
.c++
,
and
.C++
as C++ files,
and files with
.mm
suffixes as Objective C++ files.
On case-sensitive systems (Linux, UNIX, and other POSIX-alikes),
SCons also treats
.C
(upper case) files
as C++ files.
CXXFLAGS
General options that are passed to the C++ compiler.
By default, this includes the value of $CCFLAGS
,
so that setting $CCFLAGS
affects both C and C++ compilation.
If you want to add C++-specific flags,
you must set or override the value of $CXXFLAGS
.
See also $SHCXXFLAGS
for compiling to shared objects..
CXXVERSION
The version number of the C++ compiler. This may or may not be set, depending on the specific C++ compiler being used.
DC
The D compiler to use.
See also $SHDC
for compiling to shared objects.
DCOM
The command line used to compile a D file to an object file.
Any options specified in the $DFLAGS
construction variable
is included on this command line.
See also $SHDCOM
for compiling to shared objects.
DCOMSTR
If set, the string displayed when a D source file
is compiled to a (static) object file.
If not set, then $DCOM
(the command line) is displayed.
See also $SHDCOMSTR
for compiling to shared objects.
DDEBUG
List of debug tags to enable when compiling.
DDEBUGPREFIX
DDEBUGPREFIX.
DDEBUGSUFFIX
DDEBUGSUFFIX.
DESCRIPTION
A long description of the project being packaged. This is included in the relevant section of the file that controls the packaging build.
See the Package
builder.
DESCRIPTION_lang
A language-specific long description for
the specified lang
.
This is used to populate a
%description -l
section of an RPM
.spec
file.
See the Package
builder.
DFILESUFFIX
DFILESUFFIX.
DFLAGPREFIX
DFLAGPREFIX.
DFLAGS
General options that are passed to the D compiler.
DFLAGSUFFIX
DFLAGSUFFIX.
DI_FILE_DIR
Path where .di files will be generated
DI_FILE_DIR_PREFIX
Prefix to send the di path argument to compiler
DI_FILE_DIR_SUFFFIX
Suffix to send the di path argument to compiler
DI_FILE_SUFFIX
Suffix of d include files default is .di
DINCPREFIX
DINCPREFIX.
DINCSUFFIX
DLIBFLAGSUFFIX.
Dir
A function that converts a string into a Dir instance relative to the target being built.
Dirs
A function that converts a list of strings into a list of Dir instances relative to the target being built.
DLIB
Name of the lib tool to use for D codes.
DLIBCOM
The command line to use when creating libraries.
DLIBDIRPREFIX
DLIBLINKPREFIX.
DLIBDIRSUFFIX
DLIBLINKSUFFIX.
DLIBFLAGPREFIX
DLIBFLAGPREFIX.
DLIBFLAGSUFFIX
DLIBFLAGSUFFIX.
DLIBLINKPREFIX
DLIBLINKPREFIX.
DLIBLINKSUFFIX
DLIBLINKSUFFIX.
DLINK
Name of the linker to use for linking systems including D sources.
See also $SHDLINK
for linking shared objects.
DLINKCOM
The command line to use when linking systems including D sources.
See also $SHDLINKCOM
for linking shared objects.
DLINKFLAGPREFIX
DLINKFLAGPREFIX.
DLINKFLAGS
List of linker flags.
See also $SHDLINKFLAGS
for linking shared objects.
DLINKFLAGSUFFIX
DLINKFLAGSUFFIX.
DOCBOOK_DEFAULT_XSL_EPUB
The default XSLT file for the DocbookEpub
builder within the
current environment, if no other XSLT gets specified via keyword.
DOCBOOK_DEFAULT_XSL_HTML
The default XSLT file for the DocbookHtml
builder within the
current environment, if no other XSLT gets specified via keyword.
DOCBOOK_DEFAULT_XSL_HTMLCHUNKED
The default XSLT file for the DocbookHtmlChunked
builder within the
current environment, if no other XSLT gets specified via keyword.
DOCBOOK_DEFAULT_XSL_HTMLHELP
The default XSLT file for the DocbookHtmlhelp
builder within the
current environment, if no other XSLT gets specified via keyword.
DOCBOOK_DEFAULT_XSL_MAN
The default XSLT file for the DocbookMan
builder within the
current environment, if no other XSLT gets specified via keyword.
DOCBOOK_DEFAULT_XSL_PDF
The default XSLT file for the DocbookPdf
builder within the
current environment, if no other XSLT gets specified via keyword.
DOCBOOK_DEFAULT_XSL_SLIDESHTML
The default XSLT file for the DocbookSlidesHtml
builder within the
current environment, if no other XSLT gets specified via keyword.
DOCBOOK_DEFAULT_XSL_SLIDESPDF
The default XSLT file for the DocbookSlidesPdf
builder within the
current environment, if no other XSLT gets specified via keyword.
DOCBOOK_FOP
The path to the PDF renderer fop
or xep
,
if one of them is installed (fop
gets checked first).
DOCBOOK_FOPCOM
The full command-line for the
PDF renderer fop
or xep
.
DOCBOOK_FOPCOMSTR
The string displayed when a renderer like fop
or
xep
is used to create PDF output from an XML file.
DOCBOOK_FOPFLAGS
Additonal command-line flags for the
PDF renderer fop
or xep
.
DOCBOOK_XMLLINT
The path to the external executable xmllint
, if it's installed.
Note, that this is only used as last fallback for resolving
XIncludes, if no lxml Python binding can be imported
in the current system.
DOCBOOK_XMLLINTCOM
The full command-line for the external executable
xmllint
.
DOCBOOK_XMLLINTCOMSTR
The string displayed when xmllint
is used to resolve
XIncludes for a given XML file.
DOCBOOK_XMLLINTFLAGS
Additonal command-line flags for the external executable
xmllint
.
DOCBOOK_XSLTPROC
The path to the external executable xsltproc
(or saxon
, xalan
), if one of them
is installed.
Note, that this is only used as last fallback for XSL transformations, if
no lxml Python binding can be imported in the current system.
DOCBOOK_XSLTPROCCOM
The full command-line for the external executable
xsltproc
(or saxon
,
xalan
).
DOCBOOK_XSLTPROCCOMSTR
The string displayed when xsltproc
is used to transform
an XML file via a given XSLT stylesheet.
DOCBOOK_XSLTPROCFLAGS
Additonal command-line flags for the external executable
xsltproc
(or saxon
,
xalan
).
DOCBOOK_XSLTPROCPARAMS
Additonal parameters that are not intended for the XSLT processor executable, but
the XSL processing itself. By default, they get appended at the end of the command line
for saxon
and saxon-xslt
, respectively.
DPATH
List of paths to search for import modules.
DRPATHPREFIX
DRPATHPREFIX.
DRPATHSUFFIX
DRPATHSUFFIX.
DSUFFIXES
The list of suffixes of files that will be scanned
for imported D package files.
The default list is ['.d']
.
DVERPREFIX
DVERPREFIX.
DVERSIONS
List of version tags to enable when compiling.
DVERSUFFIX
DVERSUFFIX.
DVIPDF
The TeX DVI file to PDF file converter.
DVIPDFCOM
The command line used to convert TeX DVI files into a PDF file.
DVIPDFCOMSTR
The string displayed when a TeX DVI file
is converted into a PDF file.
If this is not set, then $DVIPDFCOM
(the command line) is displayed.
DVIPDFFLAGS
General options passed to the TeX DVI file to PDF file converter.
DVIPS
The TeX DVI file to PostScript converter.
DVIPSFLAGS
General options passed to the TeX DVI file to PostScript converter.
ENV
The execution environment -
a dictionary of environment variables
used when SCons invokes external commands
to build targets defined in this construction environment.
When $ENV
is passed to a command,
all list values are assumed to be path lists and
are joined using the search path separator.
Any other non-string values are coerced to a string.
Note that by default
SCons
does
not
propagate the environment in effect when you execute
scons (the "shell environment")
to the execution environment.
This is so that builds will be guaranteed
repeatable regardless of the environment
variables set at the time
scons
is invoked.
If you want to propagate a
shell environment variable
to the commands executed
to build target files,
you must do so explicitly.
A common example is
the system PATH
environment variable,
so that
scons
will find utilities the same way
as the invoking shell (or other process):
import os env = Environment(ENV={'PATH': os.environ['PATH']})
Although it is usually not recommended, you can propagate the entire shell environment in one go:
import os env = Environment(ENV=os.environ.copy())
ESCAPE
A function that will be called to escape shell special characters in command lines. The function should take one argument: the command line string to escape; and should return the escaped command line.
F03
The Fortran 03 compiler.
You should normally set the $FORTRAN
variable,
which specifies the default Fortran compiler
for all Fortran versions.
You only need to set $F03
if you need to use a specific compiler
or compiler version for Fortran 03 files.
F03COM
The command line used to compile a Fortran 03 source file to an object file.
You only need to set $F03COM
if you need to use a specific
command line for Fortran 03 files.
You should normally set the $FORTRANCOM
variable,
which specifies the default command line
for all Fortran versions.
F03COMSTR
If set, the string displayed when a Fortran 03 source file
is compiled to an object file.
If not set, then $F03COM
or $FORTRANCOM
(the command line) is displayed.
F03FILESUFFIXES
The list of file extensions for which the F03 dialect will be used. By
default, this is ['.f03']
F03FLAGS
General user-specified options that are passed to the Fortran 03 compiler.
Note that this variable does
not
contain
-I
(or similar) include search path options
that scons generates automatically from $F03PATH
.
See
$_F03INCFLAGS
below,
for the variable that expands to those options.
You only need to set $F03FLAGS
if you need to define specific
user options for Fortran 03 files.
You should normally set the $FORTRANFLAGS
variable,
which specifies the user-specified options
passed to the default Fortran compiler
for all Fortran versions.
_F03INCFLAGS
An automatically-generated construction variable
containing the Fortran 03 compiler command-line options
for specifying directories to be searched for include files.
The value of $_F03INCFLAGS
is created
by appending $INCPREFIX
and $INCSUFFIX
to the beginning and end
of each directory in $F03PATH
.
F03PATH
The list of directories that the Fortran 03 compiler will search for include
directories. The implicit dependency scanner will search these
directories for include files. Don't explicitly put include directory
arguments in $F03FLAGS
because the result will be non-portable
and the directories will not be searched by the dependency scanner. Note:
directory names in $F03PATH
will be looked-up relative to the SConscript
directory when they are used in a command. To force
scons
to look-up a directory relative to the root of the source tree use #:
You only need to set $F03PATH
if you need to define a specific
include path for Fortran 03 files.
You should normally set the $FORTRANPATH
variable,
which specifies the include path
for the default Fortran compiler
for all Fortran versions.
env = Environment(F03PATH='#/include')
The directory look-up can also be forced using the
Dir
()
function:
include = Dir('include') env = Environment(F03PATH=include)
The directory list will be added to command lines
through the automatically-generated
$_F03INCFLAGS
construction variable,
which is constructed by
appending the values of the
$INCPREFIX
and $INCSUFFIX
construction variables
to the beginning and end
of each directory in $F03PATH
.
Any command lines you define that need
the F03PATH directory list should
include $_F03INCFLAGS
:
env = Environment(F03COM="my_compiler $_F03INCFLAGS -c -o $TARGET $SOURCE")
F03PPCOM
The command line used to compile a Fortran 03 source file to an object file
after first running the file through the C preprocessor.
Any options specified in the $F03FLAGS
and $CPPFLAGS
construction variables
are included on this command line.
You only need to set $F03PPCOM
if you need to use a specific
C-preprocessor command line for Fortran 03 files.
You should normally set the $FORTRANPPCOM
variable,
which specifies the default C-preprocessor command line
for all Fortran versions.
F03PPCOMSTR
If set, the string displayed when a Fortran 03 source file
is compiled to an object file
after first running the file through the C preprocessor.
If not set, then $F03PPCOM
or $FORTRANPPCOM
(the command line) is displayed.
F03PPFILESUFFIXES
The list of file extensions for which the compilation + preprocessor pass for F03 dialect will be used. By default, this is empty.
F08
The Fortran 08 compiler.
You should normally set the $FORTRAN
variable,
which specifies the default Fortran compiler
for all Fortran versions.
You only need to set $F08
if you need to use a specific compiler
or compiler version for Fortran 08 files.
F08COM
The command line used to compile a Fortran 08 source file to an object file.
You only need to set $F08COM
if you need to use a specific
command line for Fortran 08 files.
You should normally set the $FORTRANCOM
variable,
which specifies the default command line
for all Fortran versions.
F08COMSTR
If set, the string displayed when a Fortran 08 source file
is compiled to an object file.
If not set, then $F08COM
or $FORTRANCOM
(the command line) is displayed.
F08FILESUFFIXES
The list of file extensions for which the F08 dialect will be used. By
default, this is ['.f08']
F08FLAGS
General user-specified options that are passed to the Fortran 08 compiler.
Note that this variable does
not
contain
-I
(or similar) include search path options
that scons generates automatically from $F08PATH
.
See
$_F08INCFLAGS
below,
for the variable that expands to those options.
You only need to set $F08FLAGS
if you need to define specific
user options for Fortran 08 files.
You should normally set the $FORTRANFLAGS
variable,
which specifies the user-specified options
passed to the default Fortran compiler
for all Fortran versions.
_F08INCFLAGS
An automatically-generated construction variable
containing the Fortran 08 compiler command-line options
for specifying directories to be searched for include files.
The value of $_F08INCFLAGS
is created
by appending $INCPREFIX
and $INCSUFFIX
to the beginning and end
of each directory in $F08PATH
.
F08PATH
The list of directories that the Fortran 08 compiler will search for include
directories. The implicit dependency scanner will search these
directories for include files. Don't explicitly put include directory
arguments in $F08FLAGS
because the result will be non-portable
and the directories will not be searched by the dependency scanner. Note:
directory names in $F08PATH
will be looked-up relative to the SConscript
directory when they are used in a command. To force
scons
to look-up a directory relative to the root of the source tree use #:
You only need to set $F08PATH
if you need to define a specific
include path for Fortran 08 files.
You should normally set the $FORTRANPATH
variable,
which specifies the include path
for the default Fortran compiler
for all Fortran versions.
env = Environment(F08PATH='#/include')
The directory look-up can also be forced using the
Dir
()
function:
include = Dir('include') env = Environment(F08PATH=include)
The directory list will be added to command lines
through the automatically-generated
$_F08INCFLAGS
construction variable,
which is constructed by
appending the values of the
$INCPREFIX
and $INCSUFFIX
construction variables
to the beginning and end
of each directory in $F08PATH
.
Any command lines you define that need
the F08PATH directory list should
include $_F08INCFLAGS
:
env = Environment(F08COM="my_compiler $_F08INCFLAGS -c -o $TARGET $SOURCE")
F08PPCOM
The command line used to compile a Fortran 08 source file to an object file
after first running the file through the C preprocessor.
Any options specified in the $F08FLAGS
and $CPPFLAGS
construction variables
are included on this command line.
You only need to set $F08PPCOM
if you need to use a specific
C-preprocessor command line for Fortran 08 files.
You should normally set the $FORTRANPPCOM
variable,
which specifies the default C-preprocessor command line
for all Fortran versions.
F08PPCOMSTR
If set, the string displayed when a Fortran 08 source file
is compiled to an object file
after first running the file through the C preprocessor.
If not set, then $F08PPCOM
or $FORTRANPPCOM
(the command line) is displayed.
F08PPFILESUFFIXES
The list of file extensions for which the compilation + preprocessor pass for F08 dialect will be used. By default, this is empty.
F77
The Fortran 77 compiler.
You should normally set the $FORTRAN
variable,
which specifies the default Fortran compiler
for all Fortran versions.
You only need to set $F77
if you need to use a specific compiler
or compiler version for Fortran 77 files.
F77COM
The command line used to compile a Fortran 77 source file to an object file.
You only need to set $F77COM
if you need to use a specific
command line for Fortran 77 files.
You should normally set the $FORTRANCOM
variable,
which specifies the default command line
for all Fortran versions.
F77COMSTR
If set, the string displayed when a Fortran 77 source file
is compiled to an object file.
If not set, then $F77COM
or $FORTRANCOM
(the command line) is displayed.
F77FILESUFFIXES
The list of file extensions for which the F77 dialect will be used. By
default, this is ['.f77']
F77FLAGS
General user-specified options that are passed to the Fortran 77 compiler.
Note that this variable does
not
contain
-I
(or similar) include search path options
that scons generates automatically from $F77PATH
.
See
$_F77INCFLAGS
below,
for the variable that expands to those options.
You only need to set $F77FLAGS
if you need to define specific
user options for Fortran 77 files.
You should normally set the $FORTRANFLAGS
variable,
which specifies the user-specified options
passed to the default Fortran compiler
for all Fortran versions.
_F77INCFLAGS
An automatically-generated construction variable
containing the Fortran 77 compiler command-line options
for specifying directories to be searched for include files.
The value of $_F77INCFLAGS
is created
by appending $INCPREFIX
and $INCSUFFIX
to the beginning and end
of each directory in $F77PATH
.
F77PATH
The list of directories that the Fortran 77 compiler will search for include
directories. The implicit dependency scanner will search these
directories for include files. Don't explicitly put include directory
arguments in $F77FLAGS
because the result will be non-portable
and the directories will not be searched by the dependency scanner. Note:
directory names in $F77PATH
will be looked-up relative to the SConscript
directory when they are used in a command. To force
scons
to look-up a directory relative to the root of the source tree use #:
You only need to set $F77PATH
if you need to define a specific
include path for Fortran 77 files.
You should normally set the $FORTRANPATH
variable,
which specifies the include path
for the default Fortran compiler
for all Fortran versions.
env = Environment(F77PATH='#/include')
The directory look-up can also be forced using the
Dir
()
function:
include = Dir('include') env = Environment(F77PATH=include)
The directory list will be added to command lines
through the automatically-generated
$_F77INCFLAGS
construction variable,
which is constructed by
appending the values of the
$INCPREFIX
and $INCSUFFIX
construction variables
to the beginning and end
of each directory in $F77PATH
.
Any command lines you define that need
the F77PATH directory list should
include $_F77INCFLAGS
:
env = Environment(F77COM="my_compiler $_F77INCFLAGS -c -o $TARGET $SOURCE")
F77PPCOM
The command line used to compile a Fortran 77 source file to an object file
after first running the file through the C preprocessor.
Any options specified in the $F77FLAGS
and $CPPFLAGS
construction variables
are included on this command line.
You only need to set $F77PPCOM
if you need to use a specific
C-preprocessor command line for Fortran 77 files.
You should normally set the $FORTRANPPCOM
variable,
which specifies the default C-preprocessor command line
for all Fortran versions.
F77PPCOMSTR
If set, the string displayed when a Fortran 77 source file
is compiled to an object file
after first running the file through the C preprocessor.
If not set, then $F77PPCOM
or $FORTRANPPCOM
(the command line) is displayed.
F77PPFILESUFFIXES
The list of file extensions for which the compilation + preprocessor pass for F77 dialect will be used. By default, this is empty.
F90
The Fortran 90 compiler.
You should normally set the $FORTRAN
variable,
which specifies the default Fortran compiler
for all Fortran versions.
You only need to set $F90
if you need to use a specific compiler
or compiler version for Fortran 90 files.
F90COM
The command line used to compile a Fortran 90 source file to an object file.
You only need to set $F90COM
if you need to use a specific
command line for Fortran 90 files.
You should normally set the $FORTRANCOM
variable,
which specifies the default command line
for all Fortran versions.
F90COMSTR
If set, the string displayed when a Fortran 90 source file
is compiled to an object file.
If not set, then $F90COM
or $FORTRANCOM
(the command line) is displayed.
F90FILESUFFIXES
The list of file extensions for which the F90 dialect will be used. By
default, this is ['.f90']
F90FLAGS
General user-specified options that are passed to the Fortran 90 compiler.
Note that this variable does
not
contain
-I
(or similar) include search path options
that scons generates automatically from $F90PATH
.
See
$_F90INCFLAGS
below,
for the variable that expands to those options.
You only need to set $F90FLAGS
if you need to define specific
user options for Fortran 90 files.
You should normally set the $FORTRANFLAGS
variable,
which specifies the user-specified options
passed to the default Fortran compiler
for all Fortran versions.
_F90INCFLAGS
An automatically-generated construction variable
containing the Fortran 90 compiler command-line options
for specifying directories to be searched for include files.
The value of $_F90INCFLAGS
is created
by appending $INCPREFIX
and $INCSUFFIX
to the beginning and end
of each directory in $F90PATH
.
F90PATH
The list of directories that the Fortran 90 compiler will search for include
directories. The implicit dependency scanner will search these
directories for include files. Don't explicitly put include directory
arguments in $F90FLAGS
because the result will be non-portable
and the directories will not be searched by the dependency scanner. Note:
directory names in $F90PATH
will be looked-up relative to the SConscript
directory when they are used in a command. To force
scons
to look-up a directory relative to the root of the source tree use #:
You only need to set $F90PATH
if you need to define a specific
include path for Fortran 90 files.
You should normally set the $FORTRANPATH
variable,
which specifies the include path
for the default Fortran compiler
for all Fortran versions.
env = Environment(F90PATH='#/include')
The directory look-up can also be forced using the
Dir
()
function:
include = Dir('include') env = Environment(F90PATH=include)
The directory list will be added to command lines
through the automatically-generated
$_F90INCFLAGS
construction variable,
which is constructed by
appending the values of the
$INCPREFIX
and $INCSUFFIX
construction variables
to the beginning and end
of each directory in $F90PATH
.
Any command lines you define that need
the F90PATH directory list should
include $_F90INCFLAGS
:
env = Environment(F90COM="my_compiler $_F90INCFLAGS -c -o $TARGET $SOURCE")
F90PPCOM
The command line used to compile a Fortran 90 source file to an object file
after first running the file through the C preprocessor.
Any options specified in the $F90FLAGS
and $CPPFLAGS
construction variables
are included on this command line.
You only need to set $F90PPCOM
if you need to use a specific
C-preprocessor command line for Fortran 90 files.
You should normally set the $FORTRANPPCOM
variable,
which specifies the default C-preprocessor command line
for all Fortran versions.
F90PPCOMSTR
If set, the string displayed when a Fortran 90 source file
is compiled after first running the file through the C preprocessor.
If not set, then $F90PPCOM
or $FORTRANPPCOM
(the command line) is displayed.
F90PPFILESUFFIXES
The list of file extensions for which the compilation + preprocessor pass for F90 dialect will be used. By default, this is empty.
F95
The Fortran 95 compiler.
You should normally set the $FORTRAN
variable,
which specifies the default Fortran compiler
for all Fortran versions.
You only need to set $F95
if you need to use a specific compiler
or compiler version for Fortran 95 files.
F95COM
The command line used to compile a Fortran 95 source file to an object file.
You only need to set $F95COM
if you need to use a specific
command line for Fortran 95 files.
You should normally set the $FORTRANCOM
variable,
which specifies the default command line
for all Fortran versions.
F95COMSTR
If set, the string displayed when a Fortran 95 source file
is compiled to an object file.
If not set, then $F95COM
or $FORTRANCOM
(the command line) is displayed.
F95FILESUFFIXES
The list of file extensions for which the F95 dialect will be used. By
default, this is ['.f95']
F95FLAGS
General user-specified options that are passed to the Fortran 95 compiler.
Note that this variable does
not
contain
-I
(or similar) include search path options
that scons generates automatically from $F95PATH
.
See
$_F95INCFLAGS
below,
for the variable that expands to those options.
You only need to set $F95FLAGS
if you need to define specific
user options for Fortran 95 files.
You should normally set the $FORTRANFLAGS
variable,
which specifies the user-specified options
passed to the default Fortran compiler
for all Fortran versions.
_F95INCFLAGS
An automatically-generated construction variable
containing the Fortran 95 compiler command-line options
for specifying directories to be searched for include files.
The value of $_F95INCFLAGS
is created
by appending $INCPREFIX
and $INCSUFFIX
to the beginning and end
of each directory in $F95PATH
.
F95PATH
The list of directories that the Fortran 95 compiler will search for include
directories. The implicit dependency scanner will search these
directories for include files. Don't explicitly put include directory
arguments in $F95FLAGS
because the result will be non-portable
and the directories will not be searched by the dependency scanner. Note:
directory names in $F95PATH
will be looked-up relative to the SConscript
directory when they are used in a command. To force
scons
to look-up a directory relative to the root of the source tree use #:
You only need to set $F95PATH
if you need to define a specific
include path for Fortran 95 files.
You should normally set the $FORTRANPATH
variable,
which specifies the include path
for the default Fortran compiler
for all Fortran versions.
env = Environment(F95PATH='#/include')
The directory look-up can also be forced using the
Dir
()
function:
include = Dir('include') env = Environment(F95PATH=include)
The directory list will be added to command lines
through the automatically-generated
$_F95INCFLAGS
construction variable,
which is constructed by
appending the values of the
$INCPREFIX
and $INCSUFFIX
construction variables
to the beginning and end
of each directory in $F95PATH
.
Any command lines you define that need
the F95PATH directory list should
include $_F95INCFLAGS
:
env = Environment(F95COM="my_compiler $_F95INCFLAGS -c -o $TARGET $SOURCE")
F95PPCOM
The command line used to compile a Fortran 95 source file to an object file
after first running the file through the C preprocessor.
Any options specified in the $F95FLAGS
and $CPPFLAGS
construction variables
are included on this command line.
You only need to set $F95PPCOM
if you need to use a specific
C-preprocessor command line for Fortran 95 files.
You should normally set the $FORTRANPPCOM
variable,
which specifies the default C-preprocessor command line
for all Fortran versions.
F95PPCOMSTR
If set, the string displayed when a Fortran 95 source file
is compiled to an object file
after first running the file through the C preprocessor.
If not set, then $F95PPCOM
or $FORTRANPPCOM
(the command line) is displayed.
F95PPFILESUFFIXES
The list of file extensions for which the compilation + preprocessor pass for F95 dialect will be used. By default, this is empty.
File
A function that converts a string into a File instance relative to the target being built.
FILE_ENCODING
File encoding used for files written by Textfile
and Substfile
.
Set to "utf-8" by default.
New in version 4.5.0.
FORTRAN
The default Fortran compiler for all versions of Fortran.
FORTRANCOM
The command line used to compile a Fortran source file to an object file.
By default, any options specified
in the $FORTRANFLAGS
,
$_FORTRANMODFLAG
, and
$_FORTRANINCFLAGS
construction variables are included on this command line.
FORTRANCOMMONFLAGS
General user-specified options that are passed to the Fortran compiler.
Similar to $FORTRANFLAGS
,
but this construction variable is applied to all dialects.
New in version 4.4.
FORTRANCOMSTR
If set, the string displayed when a Fortran source file
is compiled to an object file.
If not set, then $FORTRANCOM
(the command line) is displayed.
FORTRANFILESUFFIXES
The list of file extensions for which the FORTRAN dialect will be used. By
default, this is ['.f', '.for', '.ftn']
FORTRANFLAGS
General user-specified options for the FORTRAN dialect
that are passed to the Fortran compiler.
Note that this variable does
not
contain
-I
(or similar) include or module search path options
that scons generates automatically from $FORTRANPATH
.
See
$_FORTRANINCFLAGS
and $_FORTRANMODFLAG
for the construction variables that expand those options.
_FORTRANINCFLAGS
An automatically-generated construction variable
containing the Fortran compiler command-line options
for specifying directories to be searched for include
files and module files.
The value of $_FORTRANINCFLAGS
is created
by respectively prepending and appending
$INCPREFIX
and $INCSUFFIX
to the beginning and end
of each directory in $FORTRANPATH
.
FORTRANMODDIR
Directory location where the Fortran compiler should place any module files it generates. This variable is empty, by default. Some Fortran compilers will internally append this directory in the search path for module files, as well.
FORTRANMODDIRPREFIX
The prefix used to specify a module directory on the Fortran compiler command
line.
This will be prepended to the beginning of the directory
in the $FORTRANMODDIR
construction variables
when the $_FORTRANMODFLAG
variables is automatically generated.
FORTRANMODDIRSUFFIX
The suffix used to specify a module directory on the Fortran compiler command
line.
This will be appended to the end of the directory
in the $FORTRANMODDIR
construction variables
when the $_FORTRANMODFLAG
variables is automatically generated.
_FORTRANMODFLAG
An automatically-generated construction variable
containing the Fortran compiler command-line option
for specifying the directory location where the Fortran
compiler should place any module files that happen to get
generated during compilation.
The value of $_FORTRANMODFLAG
is created
by respectively prepending and appending
$FORTRANMODDIRPREFIX
and $FORTRANMODDIRSUFFIX
to the beginning and end of the directory in $FORTRANMODDIR
.
FORTRANMODPREFIX
The module file prefix used by the Fortran compiler. SCons assumes that
the Fortran compiler follows the quasi-standard naming convention for
module files of
module_name.mod
.
As a result, this variable is left empty, by default. For situations in
which the compiler does not necessarily follow the normal convention,
the user may use this variable. Its value will be appended to every
module file name as scons attempts to resolve dependencies.
FORTRANMODSUFFIX
The module file suffix used by the Fortran compiler. SCons assumes that
the Fortran compiler follows the quasi-standard naming convention for
module files of
module_name.mod
.
As a result, this variable is set to ".mod", by default. For situations
in which the compiler does not necessarily follow the normal convention,
the user may use this variable. Its value will be appended to every
module file name as scons attempts to resolve dependencies.
FORTRANPATH
The list of directories that the Fortran compiler will search for include files and (for some compilers) module files. The Fortran implicit dependency scanner will search these directories for include files (but not module files since they are autogenerated and, as such, may not actually exist at the time the scan takes place). Don't explicitly put include directory arguments in FORTRANFLAGS because the result will be non-portable and the directories will not be searched by the dependency scanner. Note: directory names in FORTRANPATH will be looked-up relative to the SConscript directory when they are used in a command. To force scons to look-up a directory relative to the root of the source tree use #:
env = Environment(FORTRANPATH='#/include')
The directory look-up can also be forced using the
Dir
()
function:
include = Dir('include') env = Environment(FORTRANPATH=include)
The directory list will be added to command lines
through the automatically-generated
$_FORTRANINCFLAGS
construction variable,
which is constructed by
respectively prepending and appending the values of the
$INCPREFIX
and $INCSUFFIX
construction variables
to the beginning and end
of each directory in $FORTRANPATH
.
Any command lines you define that need
the FORTRANPATH directory list should
include $_FORTRANINCFLAGS
:
env = Environment(FORTRANCOM="my_compiler $_FORTRANINCFLAGS -c -o $TARGET $SOURCE")
FORTRANPPCOM
The command line used to compile a Fortran source file to an object file
after first running the file through the C preprocessor.
By default, any options specified in the $FORTRANFLAGS
,
$CPPFLAGS
,
$_CPPDEFFLAGS
,
$_FORTRANMODFLAG
, and
$_FORTRANINCFLAGS
construction variables are included on this command line.
FORTRANPPCOMSTR
If set, the string displayed when a Fortran source file
is compiled to an object file
after first running the file through the C preprocessor.
If not set, then $FORTRANPPCOM
(the command line) is displayed.
FORTRANPPFILESUFFIXES
The list of file extensions for which the compilation + preprocessor pass for
FORTRAN dialect will be used. By default, this is ['.fpp', '.FPP']
FORTRANSUFFIXES
The list of suffixes of files that will be scanned for Fortran implicit dependencies (INCLUDE lines and USE statements). The default list is:
[".f", ".F", ".for", ".FOR", ".ftn", ".FTN", ".fpp", ".FPP", ".f77", ".F77", ".f90", ".F90", ".f95", ".F95"]
FRAMEWORKPATH
On Mac OS X with gcc,
a list containing the paths to search for frameworks.
Used by the compiler to find framework-style includes like
#include <Fmwk/Header.h>.
Used by the linker to find user-specified frameworks when linking (see
$FRAMEWORKS
).
For example:
env.AppendUnique(FRAMEWORKPATH='#myframeworkdir')
will add
... -Fmyframeworkdir
to the compiler and linker command lines.
_FRAMEWORKPATH
On Mac OS X with gcc, an automatically-generated construction variable
containing the linker command-line options corresponding to
$FRAMEWORKPATH
.
FRAMEWORKPATHPREFIX
On Mac OS X with gcc, the prefix to be used for the FRAMEWORKPATH entries.
(see $FRAMEWORKPATH
).
The default value is
-F
.
FRAMEWORKPREFIX
On Mac OS X with gcc,
the prefix to be used for linking in frameworks
(see $FRAMEWORKS
).
The default value is
-framework
.
FRAMEWORKS
On Mac OS X with gcc, a list of the framework names to be linked into a program or shared library or bundle. The default value is the empty list. For example:
env.AppendUnique(FRAMEWORKS=Split('System Cocoa SystemConfiguration'))
_FRAMEWORKS
On Mac OS X with gcc, an automatically-generated construction variable containing the linker command-line options for linking with FRAMEWORKS.
FRAMEWORKSFLAGS
On Mac OS X with gcc,
general user-supplied frameworks options to be added at
the end of a command
line building a loadable module.
(This has been largely superseded by
the $FRAMEWORKPATH
, $FRAMEWORKPATHPREFIX
,
$FRAMEWORKPREFIX
and $FRAMEWORKS
variables
described above.)
GS
The Ghostscript program used to, for example, convert PostScript to PDF files.
GSCOM
The full Ghostscript command line used for the conversion process. Its default
value is “$GS $GSFLAGS -sOutputFile=$TARGET $SOURCES
”.
GSCOMSTR
The string displayed when
Ghostscript is called for the conversion process.
If this is not set (the default), then $GSCOM
(the command line) is displayed.
GSFLAGS
General options passed to the Ghostscript program,
when converting PostScript to PDF files for example. Its default value
is “-dNOPAUSE -dBATCH -sDEVICE=pdfwrite
”
HOST_ARCH
The name of the host hardware architecture
used to create this construction environment.
The platform code sets this when initializing
(see $PLATFORM
and the
platform
argument to Environment
).
Note the detected name of the architecture may not be identical to
that returned by the Python
platform.machine
method.
On the win32
platform,
if the Microsoft Visual C++ compiler is available,
msvc
tool setup is done using
$HOST_ARCH
and $TARGET_ARCH
.
Changing the values at any later time will not cause
the tool to be reinitialized.
Valid host arch values are
x86
and arm
for 32-bit hosts and
amd64
, arm64
,
and x86_64
for 64-bit hosts.
Should be considered immutable.
$HOST_ARCH
is not currently used by other platforms,
but the option is reserved to do so in future
HOST_OS
The name of the host operating system for the platform
used to create this construction environment.
The platform code sets this when initializing
(see $PLATFORM
and the
platform
argument to Environment
).
Should be considered immutable.
$HOST_OS
is not currently used by SCons,
but the option is reserved to do so in future
IDLSUFFIXES
The list of suffixes of files that will be scanned for IDL implicit dependencies (#include or import lines). The default list is:
[".idl", ".IDL"]
IMPLIBNOVERSIONSYMLINKS
Used to override $SHLIBNOVERSIONSYMLINKS
/$LDMODULENOVERSIONSYMLINKS
when
creating versioned import library for a shared library/loadable module. If not defined,
then $SHLIBNOVERSIONSYMLINKS
/$LDMODULENOVERSIONSYMLINKS
is used to determine
whether to disable symlink generation or not.
IMPLIBPREFIX
The prefix used for import library names. For example, cygwin uses import
libraries (libfoo.dll.a
) in pair with dynamic libraries
(cygfoo.dll
). The cyglink
linker sets
$IMPLIBPREFIX
to 'lib'
and $SHLIBPREFIX
to 'cyg'
.
IMPLIBSUFFIX
The suffix used for import library names. For example, cygwin uses import
libraries (libfoo.dll.a
) in pair with dynamic libraries
(cygfoo.dll
). The cyglink
linker sets
$IMPLIBSUFFIX
to '.dll.a'
and $SHLIBSUFFIX
to '.dll'
.
IMPLIBVERSION
Used to override $SHLIBVERSION
/$LDMODULEVERSION
when
generating versioned import library for a shared library/loadable module. If
undefined, the $SHLIBVERSION
/$LDMODULEVERSION
is used to
determine the version of versioned import library.
IMPLICIT_COMMAND_DEPENDENCIES
Controls whether or not SCons will add implicit dependencies for the commands executed to build targets.
By default, SCons will add to each target
an implicit dependency on the command
represented by the first argument of any
command line it executes (which is typically
the command itself). By setting such
a dependency, SCons can determine that
a target should be rebuilt if the command changes,
such as when a compiler is upgraded to a new version.
The specific file for the dependency is
found by searching the
PATH
variable in the
ENV
dictionary
in the construction environment used to execute the command.
The default is the same as
setting the construction variable
$IMPLICIT_COMMAND_DEPENDENCIES
to a True-like value (“true”,
“yes”,
or “1” - but not a number
greater than one, as that has a different meaning).
Action strings can be segmented by the
use of an AND operator, &&
.
In a segemented string, each segment is a separate
“command line”, these are run
sequentially until one fails or the entire
sequence has been executed. If an
action string is segmented, then the selected
behavior of $IMPLICIT_COMMAND_DEPENDENCIES
is applied to each segment.
If $IMPLICIT_COMMAND_DEPENDENCIES
is set to a False-like value
(“none”,
“false”,
“no”,
“0”,
etc.),
then the implicit dependency will
not be added to the targets
built with that construction environment.
If $IMPLICIT_COMMAND_DEPENDENCIES
is set to “2” or higher,
then that number of arguments in the command line
will be scanned for relative or absolute paths.
If any are present, they will be added as
implicit dependencies to the targets built
with that construction environment.
The first argument in the command line will be
searched for using the PATH
variable in the ENV
dictionary
in the construction environment used to execute the command.
The other arguments will only be found if they
are absolute paths or valid paths relative
to the working directory.
If $IMPLICIT_COMMAND_DEPENDENCIES
is set to “all”,
then all arguments in the command line will be
scanned for relative or absolute paths.
If any are present, they will be added as
implicit dependencies to the targets built
with that construction environment.
The first argument in the command line will be
searched for using the PATH
variable in the ENV
dictionary
in the construction environment used to execute the command.
The other arguments will only be found if they
are absolute paths or valid paths relative
to the working directory.
env = Environment(IMPLICIT_COMMAND_DEPENDENCIES=False)
INCPREFIX
The prefix used to specify an include directory on the C compiler command
line.
This will be prepended to each directory
in the $CPPPATH
and $FORTRANPATH
construction variables
when the $_CPPINCFLAGS
and $_FORTRANINCFLAGS
variables are automatically generated.
INCSUFFIX
The suffix used to specify an include directory on the C compiler command
line.
This will be appended to each directory
in the $CPPPATH
and $FORTRANPATH
construction variables
when the $_CPPINCFLAGS
and $_FORTRANINCFLAGS
variables are automatically generated.
INSTALL
A function to be called to install a file into a destination file name. The default function copies the file into the destination (and sets the destination file's mode and permission bits to match the source file's). The function takes the following arguments:
def install(dest, source, env):
dest
is the path name of the destination file.
source
is the path name of the source file.
env
is the construction environment
(a dictionary of construction values)
in force for this file installation.
INSTALLSTR
The string displayed when a file is installed into a destination file name. The default is:
Install file: "$SOURCE" as "$TARGET"
INTEL_C_COMPILER_VERSION
Set by the intelc
Tool
to the major version number of the Intel C compiler
selected for use.
JAR
The Java archive tool.
JARCHDIR
The directory to which the Java archive tool should change
(using the
-C
option).
JARCOM
The command line used to call the Java archive tool.
JARCOMSTR
The string displayed when the Java archive tool
is called
If this is not set, then $JARCOM
(the command line) is displayed.
env = Environment(JARCOMSTR="JARchiving $SOURCES into $TARGET")
JARFLAGS
General options passed to the Java archive tool.
By default this is set to
cf
to create the necessary
jar
file.
JARSUFFIX
The suffix for Java archives:
.jar
by default.
JAVABOOTCLASSPATH
Specifies the location of the bootstrap class files. Can be specified as a string or Node object, or as a list of strings or Node objects.
The value will be added to the JDK command lines
via the -bootclasspath
option,
which requires a system-specific search path separator.
This will be supplied by SCons as needed when it
constructs the command line if $JAVABOOTCLASSPATH
is
provided in list form.
If $JAVABOOTCLASSPATH
is a single string containing
search path separator characters
(:
for POSIX systems or
;
for Windows), it will not be modified;
and so is inherently system-specific;
to supply the path in a system-independent manner,
give $JAVABOOTCLASSPATH
as a list of paths instead.
Can only be used when compiling for releases prior to JDK 9.
JAVAC
The Java compiler.
JAVACCOM
The command line used to compile a directory tree containing
Java source files to
corresponding Java class files.
Any options specified in the $JAVACFLAGS
construction variable
are included on this command line.
JAVACCOMSTR
The string displayed when compiling
a directory tree of Java source files to
corresponding Java class files.
If this is not set, then $JAVACCOM
(the command line) is displayed.
env = Environment(JAVACCOMSTR="Compiling class files $TARGETS from $SOURCES")
JAVACFLAGS
General options that are passed to the Java compiler.
JAVACLASSDIR
The directory in which Java class files may be found.
This is stripped from the beginning of any Java
.class
file names supplied to the JavaH
builder.
JAVACLASSPATH
Specifies the class search path for the JDK tools.
Can be specified as a string or Node object,
or as a list of strings or Node objects.
Class path entries may be directory names to search
for class files or packages, pathnames to archives
(.jar
or .zip
)
containing classes, or paths ending in a "base name wildcard"
character (*
), which matches files
in that directory with a .jar
suffix.
See the Java documentation for more details.
The value will be added to the JDK command lines
via the -classpath
option,
which requires a system-specific search path separator.
This will be supplied by SCons as needed when it
constructs the command line if $JAVACLASSPATH
is
provided in list form.
If $JAVACLASSPATH
is a single string containing
search path separator characters
(:
for POSIX systems or
;
for Windows),
it will be split on the separator into a list of individual
paths for dependency scanning purposes.
It will not be modified for JDK command-line usage,
so such a string is inherently system-specific;
to supply the path in a system-independent manner,
give $JAVACLASSPATH
as a list of paths instead.
SCons always
supplies a -sourcepath
when invoking the Java compiler javac,
regardless of the setting of $JAVASOURCEPATH
,
as it passes the path(s) to the source(s) supplied
in the call to the Java
builder via
-sourcepath
.
From the documentation of the standard Java toolkit for javac:
“If not compiling code for modules, if the
--source-path
or -sourcepath
option is not specified, then the user class path is also
searched for source files.”
Since -sourcepath
is always supplied,
javac will not use the contents of the value of
$JAVACLASSPATH
when searching for sources.
JAVACLASSSUFFIX
The suffix for Java class files;
.class
by default.
JAVAH
The Java generator for C header and stub files.
JAVAHCOM
The command line used to generate C header and stub files
from Java classes.
Any options specified in the $JAVAHFLAGS
construction variable
are included on this command line.
JAVAHCOMSTR
The string displayed when C header and stub files
are generated from Java classes.
If this is not set, then $JAVAHCOM
(the command line) is displayed.
env = Environment(JAVAHCOMSTR="Generating header/stub file(s) $TARGETS from $SOURCES")
JAVAHFLAGS
General options passed to the C header and stub file generator for Java classes.
JAVAINCLUDES
Include path for Java header files
(such as jni.h
).
JAVAPROCESSORPATH
Specifies the location of the annotation processor class files. Can be specified as a string or Node object, or as a list of strings or Node objects.
The value will be added to the JDK command lines
via the -processorpath
option,
which requires a system-specific search path separator.
This will be supplied by SCons as needed when it
constructs the command line if $JAVAPROCESSORPATH
is
provided in list form.
If $JAVAPROCESSORPATH
is a single string containing
search path separator characters
(:
for POSIX systems or
;
for Windows), it will not be modified;
and so is inherently system-specific;
to supply the path in a system-independent manner,
give $JAVAPROCESSORPATH
as a list of paths instead.
New in version 4.5.0
JAVASOURCEPATH
Specifies the list of directories that
will be searched for input (source)
.java
files.
Can be specified as a string or Node object,
or as a list of strings or Node objects.
The value will be added to the JDK command lines
via the -sourcepath
option,
which requires a system-specific search path separator,
This will be supplied by SCons as needed when it
constructs the command line if $JAVASOURCEPATH
is
provided in list form.
If $JAVASOURCEPATH
is a single string containing
search path separator characters
(:
for POSIX systems or
;
for Windows), it will not be modified,
and so is inherently system-specific;
to supply the path in a system-independent manner,
give $JAVASOURCEPATH
as a list of paths instead.
Note that the specified directories are only added to
the command line via the -sourcepath
option.
SCons does not currently search the
$JAVASOURCEPATH
directories for dependent
.java
files.
JAVASUFFIX
The suffix for Java files;
.java
by default.
JAVAVERSION
Specifies the Java version being used by the Java
builder. Set this to specify the version of Java targeted
by the javac compiler.
This is sometimes necessary because
Java 1.5 changed the file names that are created
for nested anonymous inner classes,
which can cause a mismatch with the files
that SCons expects will be generated by the javac compiler.
Setting $JAVAVERSION
to a version greater than
1.4
makes SCons realize that a build
with such a compiler is actually up to date.
The default is 1.4
.
While this is not primarily intended for
selecting one version of the Java compiler vs. another,
it does have that effect on the Windows platform. A
more precise approach is to set $JAVAC
(and related
construction variables for related utilities) to the path to the specific
Java compiler you want, if that is not the default compiler.
On non-Windows platforms, the
alternatives
system may provide a
way to adjust the default Java compiler without
having to specify explicit paths.
LATEX
The LaTeX structured formatter and typesetter.
LATEXCOM
The command line used to call the LaTeX structured formatter and typesetter.
LATEXCOMSTR
The string displayed when calling
the LaTeX structured formatter and typesetter.
If this is not set, then $LATEXCOM
(the command line) is displayed.
env = Environment(LATEXCOMSTR = "Building $TARGET from LaTeX input $SOURCES")
LATEXFLAGS
General options passed to the LaTeX structured formatter and typesetter.
LATEXRETRIES
The maximum number of times that LaTeX
will be re-run if the
.log
generated by the $LATEXCOM
command
indicates that there are undefined references.
The default is to try to resolve undefined references
by re-running LaTeX up to three times.
LATEXSUFFIXES
The list of suffixes of files that will be scanned
for LaTeX implicit dependencies
(\include
or \import
files).
The default list is:
[".tex", ".ltx", ".latex"]
LDMODULE
The linker for building loadable modules.
By default, this is the same as $SHLINK
.
LDMODULECOM
The command line for building loadable modules.
On Mac OS X, this uses the $LDMODULE
,
$LDMODULEFLAGS
and
$FRAMEWORKSFLAGS
variables.
On other systems, this is the same as $SHLINK
.
LDMODULECOMSTR
If set, the string displayed when building loadable modules.
If not set, then $LDMODULECOM
(the command line) is displayed.
LDMODULEEMITTER
Contains the emitter specification for the
LoadableModule
builder.
The manpage section "Builder Objects" contains
general information on specifying emitters.
LDMODULEFLAGS
General user options passed to the linker for building loadable modules.
LDMODULENOVERSIONSYMLINKS
Instructs the LoadableModule
builder to not automatically create symlinks
for versioned modules. Defaults to $SHLIBNOVERSIONSYMLINKS
LDMODULEPREFIX
The prefix used for loadable module file names.
On Mac OS X, this is null;
on other systems, this is
the same as $SHLIBPREFIX
.
_LDMODULESONAME
A macro that automatically generates loadable module's SONAME based on $TARGET,
$LDMODULEVERSION and $LDMODULESUFFIX. Used by LoadableModule
builder
when the linker tool supports SONAME (e.g. gnulink
).
LDMODULESUFFIX
The suffix used for loadable module file names. On Mac OS X, this is null; on other systems, this is the same as $SHLIBSUFFIX.
LDMODULEVERSION
When this construction variable is defined, a versioned loadable module
is created by LoadableModule
builder. This activates the
$_LDMODULEVERSIONFLAGS
and thus modifies the $LDMODULECOM
as
required, adds the version number to the library name, and creates the symlinks
that are needed. $LDMODULEVERSION
versions should exist in the same
format as $SHLIBVERSION
.
_LDMODULEVERSIONFLAGS
This macro automatically introduces extra flags to $LDMODULECOM
when
building versioned LoadableModule
(that is when
$LDMODULEVERSION
is set). _LDMODULEVERSIONFLAGS
usually adds $SHLIBVERSIONFLAGS
and some extra dynamically generated
options (such as -Wl,-soname=$_LDMODULESONAME
). It is unused
by plain (unversioned) loadable modules.
LDMODULEVERSIONFLAGS
Extra flags added to $LDMODULECOM
when building versioned
LoadableModule
. These flags are only used when $LDMODULEVERSION
is
set.
LEX
The lexical analyzer generator.
LEX_HEADER_FILE
If supplied, generate a C header file with the name taken from this variable.
Will be emitted as a --header-file=
command-line option. Use this in preference to including
--header-file=
in $LEXFLAGS
directly.
LEX_TABLES_FILE
If supplied, write the lex tables to a file with the name
taken from this variable.
Will be emitted as a --tables-file=
command-line option. Use this in preference to including
--tables-file=
in $LEXFLAGS
directly.
LEXCOM
The command line used to call the lexical analyzer generator to generate a source file.
LEXCOMSTR
The string displayed when generating a source file
using the lexical analyzer generator.
If this is not set, then $LEXCOM
(the command line) is displayed.
env = Environment(LEXCOMSTR="Lex'ing $TARGET from $SOURCES")
LEXFLAGS
General options passed to the lexical analyzer generator.
In addition to passing the value on during invocation,
the lex
tool also examines this construction variable for options
which cause additional output files to be generated,
and adds those to the target list.
Recognized for this purpose are GNU flex options
--header-file=
and
--tables-file=
;
the output file is named by the option argument.
Note that files specified by --header-file=
and
--tables-file=
may not be properly handled
by SCons in all situations. Consider using
$LEX_HEADER_FILE
and $LEX_TABLES_FILE
instead.
LEXUNISTD
Used only on windows environments to set a lex flag to prevent 'unistd.h' from being included. The default value is '--nounistd'.
_LIBDIRFLAGS
An automatically-generated construction variable
containing the linker command-line options
for specifying directories to be searched for library.
The value of $_LIBDIRFLAGS
is created
by respectively prepending and appending $LIBDIRPREFIX
and $LIBDIRSUFFIX
to each directory in $LIBPATH
.
LIBDIRPREFIX
The prefix used to specify a library directory on the linker command line.
This will be prepended to each directory
in the $LIBPATH
construction variable
when the $_LIBDIRFLAGS
variable is automatically generated.
LIBDIRSUFFIX
The suffix used to specify a library directory on the linker command line.
This will be appended to each directory
in the $LIBPATH
construction variable
when the $_LIBDIRFLAGS
variable is automatically generated.
LIBEMITTER
Contains the emitter specification for the
StaticLibrary
builder.
The manpage section "Builder Objects" contains
general information on specifying emitters.
_LIBFLAGS
An automatically-generated construction variable
containing the linker command-line options
for specifying libraries to be linked with the resulting target.
The value of $_LIBFLAGS
is created
by respectively prepending and appending $LIBLINKPREFIX
and $LIBLINKSUFFIX
to each filename in $LIBS
.
LIBLINKPREFIX
The prefix used to specify a library to link on the linker command line.
This will be prepended to each library
in the $LIBS
construction variable
when the $_LIBFLAGS
variable is automatically generated.
LIBLINKSUFFIX
The suffix used to specify a library to link on the linker command line.
This will be appended to each library
in the $LIBS
construction variable
when the $_LIBFLAGS
variable is automatically generated.
LIBLITERALPREFIX
If the linker supports command line syntax directing
that the argument specifying a library should be
searched for literally (without modification),
$LIBLITERALPREFIX
can be set to that indicator.
For example, the GNU linker follows this rule:
“
-l:foo
searches the library path
for a filename called foo
,
without converting it to
libfoo.so
or
libfoo.a
.
”
If $LIBLITERALPREFIX
is set,
SCons will not transform a string-valued entry in
$LIBS
that starts with that string.
The entry will still be surrounded with
$LIBLINKPREFIX
and $LIBLINKSUFFIX
on the command line.
This is useful, for example,
in directing that a static library
be used when both a static and dynamic library are available
and linker policy is to prefer dynamic libraries.
Compared to the example in $LIBS
,
env.Append(LIBS=":libmylib.a")
will let the linker select that specific (static)
library name if found in the library search path.
This differs from using a
File
object
to specify the static library,
as the latter bypasses the library search path entirely.
LIBPATH
The list of directories that will be searched for libraries
specified by the $LIBS
construction variable.
$LIBPATH
should be a list of path strings,
or a single string, not a pathname list joined by
Python's os.pathsep
.
Do not put library search directives directly
into $LINKFLAGS
or $SHLINKFLAGS
as the result will be non-portable.
Note:
directory names in $LIBPATH
will be looked-up relative to the
directory of the SConscript file
when they are used in a command.
To force scons
to look-up a directory relative to the root of the source tree use
the #
prefix:
env = Environment(LIBPATH='#/libs')
The directory look-up can also be forced using the
Dir
function:
libs = Dir('libs') env = Environment(LIBPATH=libs)
The directory list will be added to command lines
through the automatically-generated
$_LIBDIRFLAGS
construction variable,
which is constructed by
respectively prepending and appending the values of the
$LIBDIRPREFIX
and $LIBDIRSUFFIX
construction variables
to each directory in $LIBPATH
.
Any command lines you define that need
the $LIBPATH
directory list should
include $_LIBDIRFLAGS
:
env = Environment(LINKCOM="my_linker $_LIBDIRFLAGS $_LIBFLAGS -o $TARGET $SOURCE")
LIBPREFIX
The prefix used for (static) library file names. A default value is set for each platform (posix, win32, os2, etc.), but the value is overridden by individual tools (ar, mslib, sgiar, sunar, tlib, etc.) to reflect the names of the libraries they create.
LIBPREFIXES
A list of all legal prefixes for library file names
on the current platform.
When searching for library dependencies,
SCons will look for files with these prefixes,
the base library name,
and suffixes from the $LIBSUFFIXES
list.
LIBS
The list of libraries that will be added to the link line for linking with any executable program, shared library, or loadable module created by the construction environment or override.
For portability,
a string-valued library name should include
only the base library name,
without prefixes such as lib
or suffixes such as .so
or .dll
.
SCons will attempt to
strip prefixes from the $LIBPREFIXES
list
and suffixes from the $LIBSUFFIXES
list,
but depending on that behavior will make the build
less portable:
for example, on a POSIX system,
no attempt will be made to strip a suffix like
.dll
.
Library name strings in $LIBS
should not include a path component:
instead use $LIBPATH
to direct the compiler
to look for libraries in those paths,
plus any default paths the linker searches in.
If $LIBLITERALPREFIX
is set to a non-empty string,
then a string-valued $LIBS
entry
that starts with $LIBLITERALPREFIX
will cause the rest of the entry
to be searched for for unmodified,
but respecting normal library search paths
(this is an exception to the guideline above
about leaving off the prefix/suffix from the library name).
If a $LIBS
entry is a Node object
(either as returned by a previous Builder call,
or as the result of an explicit call to File
),
the pathname from that Node will be added to
$_LIBFLAGS
,
and thus to the link line,
unmodified - without adding
$LIBLINKPREFIX
or
$LIBLINKSUFFIX
.
Such entries are searched for literally
(including any path component);
the library search paths are not used.
For example:
env.Append(LIBS=File('/tmp/mylib.so'))
For each Builder call that causes linking with libraries,
SCons will add the libraries in the setting of $LIBS
in effect at that moment to the dependecy graph
as dependencies of the target being generated.
The library list will transformed to command line
arguments through the automatically-generated
$_LIBFLAGS
construction variable
which is constructed by
respectively prepending and appending the values of the
$LIBLINKPREFIX
and $LIBLINKSUFFIX
construction variables
to each library name.
Any command lines you define yourself that need
the libraries from $LIBS
should include $_LIBFLAGS
(as well as $_LIBDIRFLAGS
)
rather than $LIBS
.
For example:
env = Environment(LINKCOM="my_linker $_LIBDIRFLAGS $_LIBFLAGS -o $TARGET $SOURCE")
LIBSUFFIX
The suffix used for (static) library file names. A default value is set for each platform (posix, win32, os2, etc.), but the value is overridden by individual tools (ar, mslib, sgiar, sunar, tlib, etc.) to reflect the names of the libraries they create.
LIBSUFFIXES
A list of all legal suffixes for library file names.
on the current platform.
When searching for library dependencies,
SCons will look for files with prefixes from the $LIBPREFIXES
list,
the base library name,
and these suffixes.
LICENSE
The abbreviated name, preferably the SPDX code, of the license under which this project is released (GPL-3.0, LGPL-2.1, BSD-2-Clause etc.). See http://www.opensource.org/licenses/alphabetical for a list of license names and SPDX codes.
See the Package
builder.
LINESEPARATOR
The separator used by the Substfile
and Textfile
builders.
This value is used between sources when constructing the target.
It defaults to the current system line separator.
LINGUAS_FILE
The $LINGUAS_FILE
defines file(s) containing list of additional linguas
to be processed by POInit
, POUpdate
or MOFiles
builders. It also affects Translate
builder. If the variable contains
a string, it defines name of the list file. The $LINGUAS_FILE
may be a
list of file names as well. If $LINGUAS_FILE
is set to
True
(or non-zero numeric value), the list will be read from
default file named
LINGUAS
.
LINK
The linker.
See also $SHLINK
for linking shared objects.
On POSIX systems (those using the link
tool),
you should normally not change this value as it defaults
to a "smart" linker tool which selects a compiler
driver matching the type of source files in use.
So for example, if you set $CXX
to a specific
compiler name, and are compiling C++ sources,
the smartlink function will automatically select the same compiler
for linking.
LINKCOM
The command line used to link object files into an executable.
See also $SHLINKCOM
for linking shared objects.
LINKCOMSTR
If set, the string displayed when object files
are linked into an executable.
If not set, then $LINKCOM
(the command line) is displayed.
See also $SHLINKCOMSTR
. for linking shared objects.
env = Environment(LINKCOMSTR = "Linking $TARGET")
LINKFLAGS
General user options passed to the linker.
Note that this variable should
not
contain
-l
(or similar) options for linking with the libraries listed in $LIBS
,
nor
-L
(or similar) library search path options
that scons generates automatically from $LIBPATH
.
See
$_LIBFLAGS
above,
for the variable that expands to library-link options,
and
$_LIBDIRFLAGS
above,
for the variable that expands to library search path options.
See also $SHLINKFLAGS
. for linking shared objects.
M4
The M4 macro preprocessor.
M4COM
The command line used to pass files through the M4 macro preprocessor.
M4COMSTR
The string displayed when
a file is passed through the M4 macro preprocessor.
If this is not set, then $M4COM
(the command line) is displayed.
M4FLAGS
General options passed to the M4 macro preprocessor.
MAKEINDEX
The makeindex generator for the TeX formatter and typesetter and the LaTeX structured formatter and typesetter.
MAKEINDEXCOM
The command line used to call the makeindex generator for the TeX formatter and typesetter and the LaTeX structured formatter and typesetter.
MAKEINDEXCOMSTR
The string displayed when calling the makeindex generator for the
TeX formatter and typesetter
and the LaTeX structured formatter and typesetter.
If this is not set, then $MAKEINDEXCOM
(the command line) is displayed.
MAKEINDEXFLAGS
General options passed to the makeindex generator for the TeX formatter and typesetter and the LaTeX structured formatter and typesetter.
MAXLINELENGTH
The maximum number of characters allowed on an external command line. On Win32 systems, link lines longer than this many characters are linked via a temporary file name.
MIDL
The Microsoft IDL compiler.
MIDLCOM
The command line used to pass files to the Microsoft IDL compiler.
MIDLCOMSTR
The string displayed when
the Microsoft IDL compiler is called.
If this is not set, then $MIDLCOM
(the command line) is displayed.
MIDLFLAGS
General options passed to the Microsoft IDL compiler.
MOSUFFIX
Suffix used for MO
files (default: '.mo'
).
See msgfmt
tool and MOFiles
builder.
MSGFMT
Absolute path to msgfmt(1) binary, found by
Detect()
.
See msgfmt
tool and MOFiles
builder.
MSGFMTCOM
Complete command line to run msgfmt(1) program.
See msgfmt
tool and MOFiles
builder.
MSGFMTCOMSTR
String to display when msgfmt(1) is invoked
(default: ''
, which means ``print $MSGFMTCOM
'').
See msgfmt
tool and MOFiles
builder.
MSGFMTFLAGS
Additional flags to msgfmt(1).
See msgfmt
tool and MOFiles
builder.
MSGINIT
Path to msginit(1) program (found via
Detect()
).
See msginit
tool and POInit
builder.
MSGINITCOM
Complete command line to run msginit(1) program.
See msginit
tool and POInit
builder.
MSGINITCOMSTR
String to display when msginit(1) is invoked
(default: ''
, which means ``print $MSGINITCOM
'').
See msginit
tool and POInit
builder.
MSGINITFLAGS
List of additional flags to msginit(1) (default:
[]
).
See msginit
tool and POInit
builder.
_MSGINITLOCALE
Internal ``macro''. Computes locale (language) name based on target filename
(default: '${TARGET.filebase}'
).
MSGMERGE
Absolute path to msgmerge(1) binary as found by
Detect()
.
See msgmerge
tool and POUpdate
builder.
MSGMERGECOM
Complete command line to run msgmerge(1) command.
See msgmerge
tool and POUpdate
builder.
MSGMERGECOMSTR
String to be displayed when msgmerge(1) is invoked
(default: ''
, which means ``print $MSGMERGECOM
'').
See msgmerge
tool and POUpdate
builder.
MSGMERGEFLAGS
Additional flags to msgmerge(1) command.
See msgmerge
tool and POUpdate
builder.
MSSDK_DIR
The directory containing the Microsoft SDK (either Platform SDK or Windows SDK) to be used for compilation.
MSSDK_VERSION
The version string of the Microsoft SDK
(either Platform SDK or Windows SDK)
to be used for compilation.
Supported versions include
6.1
,
6.0A
,
6.0
,
2003R2
and
2003R1
.
MSVC_BATCH
When set to any true value,
specifies that SCons should batch
compilation of object files
when calling the Microsoft Visual C++ compiler.
All compilations of source files from the same source directory
that generate target files in a same output directory
and were configured in SCons using the same construction environment
will be built in a single call to the compiler.
Only source files that have changed since their
object files were built will be passed to each compiler invocation
(via the $CHANGED_SOURCES
construction variable).
Any compilations where the object (target) file base name
(minus the .obj
)
does not match the source file base name
will be compiled separately.
MSVC_NOTFOUND_POLICY
Specify the scons behavior when the Microsoft Visual C++ compiler is not detected.
The $MSVC_NOTFOUND_POLICY
specifies the scons behavior when no msvc versions are detected or
when the requested msvc version is not detected.
The valid values for $MSVC_NOTFOUND_POLICY
and the corresponding scons behavior are:
'Error' or 'Exception'
Raise an exception when no msvc versions are detected or when the requested msvc version is not detected.
'Warning' or 'Warn'
Issue a warning and continue when no msvc versions are detected or when the requested msvc version is not detected. Depending on usage, this could result in build failure(s).
'Ignore' or 'Suppress'
Take no action and continue when no msvc versions are detected or when the requested msvc version is not detected. Depending on usage, this could result in build failure(s).
Note: in addition to the camel case values shown above, lower case and upper case values are accepted as well.
The $MSVC_NOTFOUND_POLICY
is applied when any of the following conditions are satisfied:
$MSVC_VERSION
is specified, the default tools list is implicitly defined (i.e., the tools list is not specified),
and the default tools list contains one or more of the msvc tools.
$MSVC_VERSION
is specified, the default tools list is explicitly specified (e.g., tools=['default']
),
and the default tools list contains one or more of the msvc tools.
A non-default tools list is specified that contains one or more of the msvc tools (e.g., tools=['msvc', 'mslink']
).
The $MSVC_NOTFOUND_POLICY
is ignored when any of the following conditions are satisfied:
$MSVC_VERSION
is not specified and the default tools list is implicitly defined (i.e., the tools list is not specified).
$MSVC_VERSION
is not specified and the default tools list is explicitly specified (e.g., tools=['default']
).
A non-default tool list is specified that does not contain any of the msvc tools (e.g., tools=['mingw']
).
Important usage details:
$MSVC_NOTFOUND_POLICY
must be passed as an argument to the Environment
constructor when an msvc tool (e.g., msvc
, msvs
, etc.) is
loaded via the default tools list or via a tools list passed to the
Environment
constructor.
Otherwise, $MSVC_NOTFOUND_POLICY
must be set before the first msvc tool is
loaded into the environment.
When $MSVC_NOTFOUND_POLICY
is not specified, the default scons behavior is to issue a warning and continue
subject to the conditions listed above. The default scons behavior may change in the future.
New in version 4.4
MSVC_SCRIPT_ARGS
Pass user-defined arguments to the Microsoft Visual C++ batch file determined via autodetection.
$MSVC_SCRIPT_ARGS
is available for msvc batch file arguments that do not have first-class support
via construction variables or when there is an issue with the appropriate construction variable validation.
When available, it is recommended to use the appropriate construction variables (e.g., $MSVC_TOOLSET_VERSION
)
rather than $MSVC_SCRIPT_ARGS
arguments.
The valid values for $MSVC_SCRIPT_ARGS
are: None
, a string,
or a list of strings.
The $MSVC_SCRIPT_ARGS
value is converted to a scalar string (i.e., "flattened").
The resulting scalar string, if not empty, is passed as an argument to the msvc batch file determined
via autodetection subject to the validation conditions listed below.
$MSVC_SCRIPT_ARGS
is ignored when the value is None
and when the
result from argument conversion is an empty string. The validation conditions below do not apply.
An exception is raised when any of the following conditions are satisfied:
$MSVC_SCRIPT_ARGS
is specified for Visual Studio 2013 and earlier.
Multiple SDK version arguments (e.g., '10.0.20348.0'
) are specified
in $MSVC_SCRIPT_ARGS
.
$MSVC_SDK_VERSION
is specified and an SDK version argument
(e.g., '10.0.20348.0'
) is specified in $MSVC_SCRIPT_ARGS
.
Multiple SDK version declarations via $MSVC_SDK_VERSION
and $MSVC_SCRIPT_ARGS
are not allowed.
Multiple toolset version arguments (e.g., '-vcvars_ver=14.29'
)
are specified in $MSVC_SCRIPT_ARGS
.
$MSVC_TOOLSET_VERSION
is specified and a toolset version argument
(e.g., '-vcvars_ver=14.29'
) is specified in $MSVC_SCRIPT_ARGS
.
Multiple toolset version declarations via $MSVC_TOOLSET_VERSION
and
$MSVC_SCRIPT_ARGS
are not allowed.
Multiple spectre library arguments (e.g., '-vcvars_spectre_libs=spectre'
)
are specified in $MSVC_SCRIPT_ARGS
.
$MSVC_SPECTRE_LIBS
is enabled and a spectre library argument
(e.g., '-vcvars_spectre_libs=spectre'
) is specified in
$MSVC_SCRIPT_ARGS
. Multiple spectre library declarations via $MSVC_SPECTRE_LIBS
and $MSVC_SCRIPT_ARGS
are not allowed.
Multiple UWP arguments (e.g., uwp
or store
) are specified
in $MSVC_SCRIPT_ARGS
.
$MSVC_UWP_APP
is enabled and a UWP argument (e.g., uwp
or
store
) is specified in $MSVC_SCRIPT_ARGS
. Multiple UWP declarations
via $MSVC_UWP_APP
and $MSVC_SCRIPT_ARGS
are not allowed.
Example 1 - A Visual Studio 2022 build with an SDK version and a toolset version specified with a string argument:
env = Environment(MSVC_VERSION='14.3', MSVC_SCRIPT_ARGS='10.0.20348.0 -vcvars_ver=14.29.30133')
Example 2 - A Visual Studio 2022 build with an SDK version and a toolset version specified with a list argument:
env = Environment(MSVC_VERSION='14.3', MSVC_SCRIPT_ARGS=['10.0.20348.0', '-vcvars_ver=14.29.30133'])
Important usage details:
$MSVC_SCRIPT_ARGS
must be passed as an argument to the Environment
constructor when an msvc tool (e.g., msvc
, msvs
, etc.) is
loaded via the default tools list or via a tools list passed to the
Environment
constructor.
Otherwise, $MSVC_SCRIPT_ARGS
must be set before the first msvc tool is
loaded into the environment.
Other than checking for multiple declarations as described above, $MSVC_SCRIPT_ARGS
arguments
are not validated.
Erroneous, inconsistent, and/or version incompatible $MSVC_SCRIPT_ARGS
arguments are likely
to result in build failures for reasons that are not readily apparent and may be difficult to diagnose.
The burden is on the user to ensure that the arguments provided to the msvc batch file are valid, consistent
and compatible with the version of msvc selected.
New in version 4.4
MSVC_SCRIPTERROR_POLICY
Specify the scons behavior when Microsoft Visual C++ batch file errors are detected.
The $MSVC_SCRIPTERROR_POLICY
specifies the scons behavior when msvc batch file errors are
detected.
When $MSVC_SCRIPTERROR_POLICY
is not specified, the default scons behavior is to suppress
msvc batch file error messages.
The root cause of msvc build failures may be difficult to diagnose. In these situations, setting the scons behavior to issue a warning when msvc batch file errors are detected may produce additional diagnostic information.
The valid values for $MSVC_SCRIPTERROR_POLICY
and the corresponding scons behavior are:
'Error' or 'Exception'
Raise an exception when msvc batch file errors are detected.
'Warning' or 'Warn'
Issue a warning when msvc batch file errors are detected.
'Ignore' or 'Suppress'
Suppress msvc batch file error messages.
New in version 4.4
Note: in addition to the camel case values shown above, lower case and upper case values are accepted as well.
Example 1 - A Visual Studio 2022 build with user-defined script arguments:
env = environment(MSVC_VERSION='14.3', MSVC_SCRIPT_ARGS=['8.1', 'store', '-vcvars_ver=14.1']) env.Program('hello', ['hello.c'], CCFLAGS='/MD', LIBS=['kernel32', 'user32', 'runtimeobject'])
Example 1 - Output fragment:
... link /nologo /OUT:_build001\hello.exe kernel32.lib user32.lib runtimeobject.lib _build001\hello.obj LINK : fatal error LNK1104: cannot open file 'MSVCRT.lib' ...
Example 2 - A Visual Studio 2022 build with user-defined script arguments and the script error policy set to issue a warning when msvc batch file errors are detected:
env = environment(MSVC_VERSION='14.3', MSVC_SCRIPT_ARGS=['8.1', 'store', '-vcvars_ver=14.1'], MSVC_SCRIPTERROR_POLICY='warn') env.Program('hello', ['hello.c'], CCFLAGS='/MD', LIBS=['kernel32', 'user32', 'runtimeobject'])
Example 2 - Output fragment:
... scons: warning: vc script errors detected: [ERROR:vcvars.bat] The UWP Application Platform requires a Windows 10 SDK. [ERROR:vcvars.bat] WindowsSdkDir = "C:\Program Files (x86)\Windows Kits\8.1\" [ERROR:vcvars.bat] host/target architecture is not supported : { x64 , x64 } ... link /nologo /OUT:_build001\hello.exe kernel32.lib user32.lib runtimeobject.lib _build001\hello.obj LINK : fatal error LNK1104: cannot open file 'MSVCRT.lib'
Important usage details:
$MSVC_SCRIPTERROR_POLICY
must be passed as an argument to the Environment
constructor when an msvc tool (e.g., msvc
, msvs
, etc.) is
loaded via the default tools list or via a tools list passed to the
Environment
constructor.
Otherwise, $MSVC_SCRIPTERROR_POLICY
must be set before the first msvc tool is
loaded into the environment.
Due to scons implementation details, not all Windows system environment variables are propagated
to the environment in which the msvc batch file is executed. Depending on Visual Studio version
and installation options, non-fatal msvc batch file error messages may be generated for ancillary
tools which may not affect builds with the msvc compiler. For this reason, caution is recommended
when setting the script error policy to raise an exception (e.g., 'Error'
).
New in version 4.4
MSVC_SDK_VERSION
Build with a specific version of the Microsoft Software Development Kit (SDK).
The valid values for $MSVC_SDK_VERSION
are: None
or a string containing the requested SDK version (e.g., '10.0.20348.0'
).
$MSVC_SDK_VERSION
is ignored when the value is None
and when
the value is an empty string. The validation conditions below do not apply.
An exception is raised when any of the following conditions are satisfied:
$MSVC_SDK_VERSION
is specified for Visual Studio 2013 and earlier.
$MSVC_SDK_VERSION
is specified and an SDK version argument is specified in
$MSVC_SCRIPT_ARGS
. Multiple SDK version declarations via $MSVC_SDK_VERSION
and $MSVC_SCRIPT_ARGS
are not allowed.
The $MSVC_SDK_VERSION
specified does not match any of the supported formats:
'10.0.XXXXX.Y'
[SDK 10.0]
'8.1'
[SDK 8.1]
The system folder for the corresponding $MSVC_SDK_VERSION
version is not found.
The requested SDK version does not appear to be installed.
The $MSVC_SDK_VERSION
version does not appear to support the requested platform
type (i.e., UWP
or Desktop
). The requested SDK version
platform type components do not appear to be installed.
The $MSVC_SDK_VERSION
version is 8.1
, the platform type is
UWP
, and the build tools selected are from Visual Studio 2017
and later (i.e., $MSVC_VERSION
must be '14.0' or $MSVC_TOOLSET_VERSION
must be '14.0').
Example 1 - A Visual Studio 2022 build with a specific Windows SDK version:
env = Environment(MSVC_VERSION='14.3', MSVC_SDK_VERSION='10.0.20348.0')
Example 2 - A Visual Studio 2022 build with a specific SDK version for the Universal Windows Platform:
env = Environment(MSVC_VERSION='14.3', MSVC_SDK_VERSION='10.0.20348.0', MSVC_UWP_APP=True)
Important usage details:
$MSVC_SDK_VERSION
must be passed as an argument to the Environment
constructor when an msvc tool (e.g., msvc
, msvs
, etc.) is
loaded via the default tools list or via a tools list passed to the
Environment
constructor.
Otherwise, $MSVC_SDK_VERSION
must be set before the first msvc tool is
loaded into the environment.
Should a SDK 10.0 version be installed that does not follow the naming scheme above, the
SDK version will need to be specified via $MSVC_SCRIPT_ARGS
until the version number
validation format can be extended.
Should an exception be raised indicating that the SDK version is not found, verify that the requested SDK version is installed with the necessary platform type components.
There is a known issue with the Microsoft libraries when the target architecture is
ARM64
and a Windows 11 SDK (version '10.0.22000.0'
and later) is used
with the v141
build tools and older v142
toolsets
(versions '14.28.29333'
and earlier). Should build failures arise with these combinations
of settings due to unresolved symbols in the Microsoft libraries, $MSVC_SDK_VERSION
may be employed to
specify a Windows 10 SDK (e.g., '10.0.20348.0'
) for the build.
New in version 4.4
MSVC_SPECTRE_LIBS
Build with the spectre-mitigated Microsoft Visual C++ libraries.
The valid values for $MSVC_SPECTRE_LIBS
are: True
,
False
, or None
.
When $MSVC_SPECTRE_LIBS
is enabled (i.e., True
),
the Microsoft Visual C++ environment will include the paths to the spectre-mitigated implementations
of the Microsoft Visual C++ libraries.
An exception is raised when any of the following conditions are satisfied:
$MSVC_SPECTRE_LIBS
is enabled for Visual Studio 2015 and earlier.
$MSVC_SPECTRE_LIBS
is enabled and a spectre library argument is specified in
$MSVC_SCRIPT_ARGS
. Multiple spectre library declarations via $MSVC_SPECTRE_LIBS
and $MSVC_SCRIPT_ARGS
are not allowed.
$MSVC_SPECTRE_LIBS
is enabled and the platform type is UWP
. There
are no spectre-mitigated libraries for Universal Windows Platform (UWP) applications or
components.
Example - A Visual Studio 2022 build with spectre mitigated Microsoft Visual C++ libraries:
env = Environment(MSVC_VERSION='14.3', MSVC_SPECTRE_LIBS=True)
Important usage details:
$MSVC_SPECTRE_LIBS
must be passed as an argument to the Environment
constructor when an msvc tool (e.g., msvc
, msvs
, etc.) is
loaded via the default tools list or via a tools list passed to the
Environment
constructor.
Otherwise, $MSVC_SPECTRE_LIBS
must be set before the first msvc tool is
loaded into the environment.
Additional compiler switches (e.g., /Qspectre
) are necessary for including
spectre mitigations when building user artifacts. Refer to the Visual Studio documentation for
details.
The existence of the spectre libraries host architecture and target architecture folders are not
verified when $MSVC_SPECTRE_LIBS
is enabled which could result in build failures.
The burden is on the user to ensure the requisite libraries with spectre mitigations are installed.
New in version 4.4
MSVC_TOOLSET_VERSION
Build with a specific Microsoft Visual C++ toolset version.
Specifying $MSVC_TOOLSET_VERSION
does not affect the autodetection and selection
of msvc instances. The $MSVC_TOOLSET_VERSION
is applied after
an msvc instance is selected. This could be the default version of msvc if $MSVC_VERSION
is not specified.
The valid values for $MSVC_TOOLSET_VERSION
are: None
or a string containing the requested toolset version (e.g., '14.29'
).
$MSVC_TOOLSET_VERSION
is ignored when the value is None
and when
the value is an empty string. The validation conditions below do not apply.
An exception is raised when any of the following conditions are satisfied:
$MSVC_TOOLSET_VERSION
is specified for Visual Studio 2015 and earlier.
$MSVC_TOOLSET_VERSION
is specified and a toolset version argument is specified in
$MSVC_SCRIPT_ARGS
. Multiple toolset version declarations via $MSVC_TOOLSET_VERSION
and $MSVC_SCRIPT_ARGS
are not allowed.
The $MSVC_TOOLSET_VERSION
specified does not match any of the supported formats:
'XX.Y'
'XX.YY'
'XX.YY.ZZZZZ'
'XX.YY.Z'
to 'XX.YY.ZZZZ'
[scons extension not directly supported by the msvc batch files and may be removed in the future]
'XX.YY.ZZ.N'
[SxS format]
'XX.YY.ZZ.NN'
[SxS format]
The major msvc version prefix (i.e., 'XX.Y'
) of the $MSVC_TOOLSET_VERSION
specified
is for Visual Studio 2013 and earlier (e.g., '12.0'
).
The major msvc version prefix (i.e., 'XX.Y'
) of the $MSVC_TOOLSET_VERSION
specified
is greater than the msvc version selected (e.g., '99.0'
).
A system folder for the corresponding $MSVC_TOOLSET_VERSION
version is not found.
The requested toolset version does not appear to be installed.
Toolset selection details:
When $MSVC_TOOLSET_VERSION
is not an SxS version number or a full toolset version number:
the first toolset version, ranked in descending order, that matches the $MSVC_TOOLSET_VERSION
prefix is selected.
When $MSVC_TOOLSET_VERSION
is specified using the major msvc version prefix
(i.e., 'XX.Y'
) and the major msvc version is that of the latest release of
Visual Studio, the selected toolset version may not be the same as the default Microsoft Visual C++ toolset version.
In the latest release of Visual Studio, the default Microsoft Visual C++ toolset version is not necessarily the toolset with the largest version number.
Example 1 - A default Visual Studio build with a partial toolset version specified:
env = Environment(MSVC_TOOLSET_VERSION='14.2')
Example 2 - A default Visual Studio build with a partial toolset version specified:
env = Environment(MSVC_TOOLSET_VERSION='14.29')
Example 3 - A Visual Studio 2022 build with a full toolset version specified:
env = Environment(MSVC_VERSION='14.3', MSVC_TOOLSET_VERSION='14.29.30133')
Example 4 - A Visual Studio 2022 build with an SxS toolset version specified:
env = Environment(MSVC_VERSION='14.3', MSVC_TOOLSET_VERSION='14.29.16.11')
Important usage details:
$MSVC_TOOLSET_VERSION
must be passed as an argument to the Environment
constructor when an msvc tool (e.g., msvc
, msvs
, etc.) is
loaded via the default tools list or via a tools list passed to the
Environment
constructor.
Otherwise, $MSVC_TOOLSET_VERSION
must be set before the first msvc tool is
loaded into the environment.
The existence of the toolset host architecture and target architecture folders are not verified
when $MSVC_TOOLSET_VERSION
is specified which could result in build failures.
The burden is on the user to ensure the requisite toolset target architecture build tools are installed.
New in version 4.4
MSVC_USE_SCRIPT
Use a batch script to set up the Microsoft Visual C++ compiler.
If set to the name of a Visual Studio .bat
file
(e.g. vcvars.bat
),
SCons will run that batch file instead of the auto-detected one,
and extract the relevant variables from the result (typically
%INCLUDE%
,
%LIB%
, and
%PATH%
) for supplying to the build.
This can be useful to force the use of a compiler version that
SCons does not detect.
$MSVC_USE_SCRIPT_ARGS
provides arguments passed to this script.
Setting
$MSVC_USE_SCRIPT
to None
bypasses the
Visual Studio autodetection entirely;
use this if you are running SCons in a Visual Studio cmd
window and importing the shell's environment variables - that
is, if you are sure everything is set correctly already and
you don't want SCons to change anything.
$MSVC_USE_SCRIPT
ignores $MSVC_VERSION
and $TARGET_ARCH
.
Changed in version 4.4:
new $MSVC_USE_SCRIPT_ARGS
provides a
way to pass arguments.
MSVC_USE_SCRIPT_ARGS
Provides arguments passed to the script $MSVC_USE_SCRIPT
.
New in version 4.4
MSVC_USE_SETTINGS
Use a dictionary to set up the Microsoft Visual C++ compiler.
$MSVC_USE_SETTINGS
is ignored when $MSVC_USE_SCRIPT
is defined
and/or when $MSVC_USE_SETTINGS
is set to None
.
The dictionary is used to populate the environment with the relevant variables
(typically %INCLUDE%
, %LIB%
, and %PATH%
)
for supplying to the build. This can be useful to force the use of a compiler environment
that SCons does not configure correctly. This is an alternative to manually configuring
the environment when bypassing Visual Studio autodetection entirely by setting
$MSVC_USE_SCRIPT
to None
.
Here is an example of configuring a build environment using the Microsoft Visual C++ compiler included in the Microsoft SDK on a 64-bit host and building for a 64-bit architecture:
# Microsoft SDK 6.0 (MSVC 8.0): 64-bit host and 64-bit target msvc_use_settings = { "PATH": [ "C:\\Program Files\\Microsoft SDKs\\Windows\\v6.0\\VC\\Bin\\x64", "C:\\Program Files\\Microsoft SDKs\\Windows\\v6.0\\Bin\\x64", "C:\\Program Files\\Microsoft SDKs\\Windows\\v6.0\\Bin", "C:\\Windows\\Microsoft.NET\\Framework\\v2.0.50727", "C:\\Windows\\system32", "C:\\Windows", "C:\\Windows\\System32\\Wbem", "C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\" ], "INCLUDE": [ "C:\\Program Files\\Microsoft SDKs\\Windows\\v6.0\\VC\\Include", "C:\\Program Files\\Microsoft SDKs\\Windows\\v6.0\\VC\\Include\\Sys", "C:\\Program Files\\Microsoft SDKs\\Windows\\v6.0\\Include", "C:\\Program Files\\Microsoft SDKs\\Windows\\v6.0\\Include\\gl", ], "LIB": [ "C:\\Program Files\\Microsoft SDKs\\Windows\\v6.0\\VC\\Lib\\x64", "C:\\Program Files\\Microsoft SDKs\\Windows\\v6.0\\Lib\\x64", ], "LIBPATH": [], "VSCMD_ARG_app_plat": [], "VCINSTALLDIR": [], "VCToolsInstallDir": [] } # Specifying MSVC_VERSION is recommended env = Environment(MSVC_VERSION='8.0', MSVC_USE_SETTINGS=msvc_use_settings)
Important usage details:
$MSVC_USE_SETTINGS
must be passed as an argument to the Environment
constructor when an msvc tool (e.g., msvc
, msvs
, etc.) is
loaded via the default tools list or via a tools list passed to the
Environment
constructor.
Otherwise, $MSVC_USE_SETTINGS
must be set before the first msvc tool is
loaded into the environment.
The dictionary content requirements are based on the internal msvc implementation and therefore may change at any time. The burden is on the user to ensure the dictionary contents are minimally sufficient to ensure successful builds.
New in version 4.4
MSVC_UWP_APP
Build with the Universal Windows Platform (UWP) application Microsoft Visual C++ libraries.
The valid values for $MSVC_UWP_APP
are: True
,
'1'
, False
, '0'
,
or None
.
When $MSVC_UWP_APP
is enabled (i.e., True
or
'1'
), the Microsoft Visual C++ environment will be set up to point
to the Windows Store compatible libraries and Microsoft Visual C++ runtimes. In doing so,
any libraries that are built will be able to be used in a UWP App and published
to the Windows Store.
An exception is raised when any of the following conditions are satisfied:
$MSVC_UWP_APP
is enabled for Visual Studio 2013 and earlier.
$MSVC_UWP_APP
is enabled and a UWP argument is specified in
$MSVC_SCRIPT_ARGS
. Multiple UWP declarations via $MSVC_UWP_APP
and $MSVC_SCRIPT_ARGS
are not allowed.
Example - A Visual Studio 2022 build for the Universal Windows Platform:
env = Environment(MSVC_VERSION='14.3', MSVC_UWP_APP=True)
Important usage details:
$MSVC_UWP_APP
must be passed as an argument to the Environment
constructor when an msvc tool (e.g., msvc
, msvs
, etc.) is
loaded via the default tools list or via a tools list passed to the
Environment
constructor.
Otherwise, $MSVC_UWP_APP
must be set before the first msvc tool is
loaded into the environment.
The existence of the UWP libraries is not verified when $MSVC_UWP_APP
is enabled
which could result in build failures.
The burden is on the user to ensure the requisite UWP libraries are installed.
MSVC_VERSION
A string to select the preferred version of Microsoft Visual C++.
If the specified version is unavailable and/or unknown to SCons,
a warning is issued showing the versions actually discovered,
and the build will eventually fail indicating a missing compiler binary.
If $MSVC_VERSION
is not set, SCons will (by default) select the
latest version of Microsoft Visual C++ installed on your system
(excluding any preview versions).
In order to take effect, $MSVC_VERSION
must be set before
the initial Microsoft Visual C++ compiler discovery takes place.
Discovery happens, at the latest, during the first call to the
Environment
function, unless a tools
list is specified which excludes the entire Microsoft Visual C++ toolchain -
that is, omits "defaults"
and any specific tool module that refers to parts of the toolchain
(msvc
, mslink
, masm
, midl
and msvs
). In this case, detection is deferred until
any one of those tool modules is invoked manually.
The following two examples illustrate this:
# MSVC_VERSION set as Environment is created env = Environment(MSVC_VERSION='14.2') # Initialization deferred with empty tools, triggered manually env = Environment(tools=[]) env['MSVC_VERSION'] = '14.2 env.Tool('msvc') env.Tool('mslink') env.Tool('msvs')
The valid values for $MSVC_VERSION
represent major versions
of the compiler, except that versions ending in Exp
refer to "Express" or "Express for Desktop" Visual Studio editions.
Values that do not look like a valid compiler version
string are not supported.
The following table shows the correspondence
of $MSVC_VERSION
values to various version indicators
('x' is used as a placeholder for
a single digit that can vary).
SCons Key |
|
_MSVC_VER |
Visual Studio Product |
|
---|---|---|---|---|
"14.3" |
14.3x | 193x | Visual Studio 2022 | 17.x, 17.1x |
"14.2" |
14.2x | 192x | Visual Studio 2019 | 16.x, 16.1x |
"14.1" |
14.1 or 14.1x | 191x | Visual Studio 2017 | 15.x |
"14.1Exp" |
14.1 or 14.1x | 191x | Visual Studio 2017 Express | 15.x |
"14.0" |
14.0 | 1900 | Visual Studio 2015 | 14.0 |
"14.0Exp" |
14.0 | 1900 | Visual Studio 2015 Express | 14.0 |
"12.0" |
12.0 | 1800 | Visual Studio 2013 | 12.0 |
"12.0Exp" |
12.0 | 1800 | Visual Studio 2013 Express | 12.0 |
"11.0" |
11.0 | 1700 | Visual Studio 2012 | 11.0 |
"11.0Exp" |
11.0 | 1700 | Visual Studio 2012 Express | 11.0 |
"10.0" |
10.0 | 1600 | Visual Studio 2010 | 10.0 |
"10.0Exp" |
10.0 | 1600 | Visual C++ Express 2010 | 10.0 |
"9.0" |
9.0 | 1500 | Visual Studio 2008 | 9.0 |
"9.0Exp" |
9.0 | 1500 | Visual C++ Express 2008 | 9.0 |
"8.0" |
8.0 | 1400 | Visual Studio 2005 | 8.0 |
"8.0Exp" |
8.0 | 1400 | Visual C++ Express 2005 | 8.0 |
"7.1" |
7.1 | 1300 | Visual Studio .NET 2003 | 7.1 |
"7.0" |
7.0 | 1200 | Visual Studio .NET 2002 | 7.0 |
"6.0" |
6.0 | 1100 | Visual Studio 6.0 | 6.0 |
It is not necessary to install a Visual Studio IDE
to build with SCons (for example, you can install only
Build Tools), but when a Visual Studio IDE is installed,
additional builders such as MSVSSolution
and
MSVSProject
become available and correspond to
the specified versions.
Versions ending in Exp
refer to historical
"Express" or "Express for Desktop" Visual Studio editions,
which had feature limitations compared to the full editions.
It is only necessary to specify the Exp
suffix to select the express edition when both express and
non-express editions of the same product are installed
simulaneously. The Exp
suffix is unnecessary,
but accepted, when only the express edition is installed.
The compilation environment can be further or more precisely specified through the
use of several other construction variables: see the descriptions of
$MSVC_TOOLSET_VERSION
,
$MSVC_SDK_VERSION
,
$MSVC_USE_SCRIPT
,
$MSVC_USE_SCRIPT_ARGS
,
and $MSVC_USE_SETTINGS
.
MSVS
When the Microsoft Visual Studio tools are initialized, they set up this dictionary with the following keys:
the version of MSVS being used (can be set via
$MSVC_VERSION
)
the available versions of MSVS installed
installed directory of Microsoft Visual C++
installed directory of Visual Studio
installed directory of the .NET framework
list of installed versions of the .NET framework, sorted latest to oldest.
latest installed version of the .NET framework
installed location of the .NET SDK.
installed location of the Platform SDK.
dictionary of installed Platform SDK modules, where the dictionary keys are keywords for the various modules, and the values are 2-tuples where the first is the release date, and the second is the version number.
If a value is not set, it was not available in the registry.
Visual Studio 2017 and later do not use the registry for
primary storage of this information, so typically for these
versions only PROJECTSUFFIX
and
SOLUTIONSUFFIX
will be set.
MSVS_ARCH
Sets the architecture for which the generated project(s) should build.
The default value is x86
.
amd64
is also supported by SCons for
most Visual Studio versions. Since Visual Studio 2015
arm
is supported, and since Visual Studio
2017 arm64
is supported.
Trying to set $MSVS_ARCH
to an architecture that's not supported for a given Visual
Studio version will generate an error.
MSVS_PROJECT_GUID
The string placed in a generated
Microsoft Visual C++ project file as the value of the
ProjectGUID
attribute. There is no default
value. If not defined, a new GUID is generated.
MSVS_SCC_AUX_PATH
The path name placed in a generated
Microsoft Visual C++ project file as the value of the
SccAuxPath
attribute if the
MSVS_SCC_PROVIDER
construction variable is
also set. There is no default value.
MSVS_SCC_CONNECTION_ROOT
The root path of projects in your SCC workspace, i.e the
path under which all project and solution files will be
generated. It is used as a reference path from which the
relative paths of the generated Microsoft Visual C++ project
and solution files are computed. The relative project file path
is placed as the value of the SccLocalPath
attribute of the project file and as the values of the
SccProjectFilePathRelativizedFromConnection[i]
(where [i] ranges from 0 to the number of projects in the solution)
attributes of the GlobalSection(SourceCodeControl)
section of the Microsoft Visual Studio solution file. Similarly
the relative solution file path is placed as the values of the
SccLocalPath[i]
(where [i] ranges from 0
to the number of projects in the solution) attributes of the
GlobalSection(SourceCodeControl)
section of
the Microsoft Visual Studio solution file. This is used only if
the MSVS_SCC_PROVIDER
construction variable is
also set. The default value is the current working directory.
MSVS_SCC_PROJECT_NAME
The project name placed in a generated Microsoft Visual C++
project file as the value of the
SccProjectName
attribute if the
MSVS_SCC_PROVIDER
construction variable
is also set. In this case the string is also placed in
the SccProjectName0
attribute of the
GlobalSection(SourceCodeControl)
section
of the Microsoft Visual Studio solution file. There is no
default value.
MSVS_SCC_PROVIDER
The string placed in a generated Microsoft Visual C++
project file as the value of the
SccProvider
attribute. The string is
also placed in the SccProvider0
attribute
of the GlobalSection(SourceCodeControl)
section of the Microsoft Visual Studio solution file. There
is no default value.
MSVS_VERSION
Set the preferred version of Microsoft Visual Studio to use.
If $MSVS_VERSION
is not set, SCons will (by default)
select the latest version of Visual Studio installed on your
system. So, if you have version 6 and version 7 (MSVS .NET)
installed, it will prefer version 7. You can override this by
specifying the $MSVS_VERSION
variable when
initializing the Environment, setting it to the appropriate
version ('6.0' or '7.0', for example). If the specified
version isn't installed, tool initialization will fail.
Deprecated since 1.3.0:
$MSVS_VERSION
is deprecated in favor of $MSVC_VERSION
.
As a transitional aid, if $MSVS_VERSION
is set
and $MSVC_VERSION
is not,
$MSVC_VERSION
will be initialized to the value
of $MSVS_VERSION
.
An error is raised if If both are set and have different values,
MSVSBUILDCOM
The build command line placed in a generated Microsoft Visual C++ project file. The default is to have Visual Studio invoke SCons with any specified build targets.
MSVSCLEANCOM
The clean command line placed in a generated Microsoft Visual C++
project file. The default is to have Visual Studio
invoke SCons with the -c
option to remove
any specified targets.
MSVSENCODING
The encoding string placed in a generated Microsoft Visual C++
project file. The default is encoding
Windows-1252
.
MSVSPROJECTCOM
The action used to generate Microsoft Visual C++ project files.
MSVSPROJECTSUFFIX
The suffix used for Microsoft Visual C++ project (DSP)
files. The default value is
.vcxproj
when using Visual Studio 2010
and later, .vcproj
when using Visual Studio versions between 2002 and 2008,
and .dsp
when using Visual Studio 6.0.
MSVSREBUILDCOM
The rebuild command line placed in a generated Microsoft Visual C++ project file. The default is to have Visual Studio invoke SCons with any specified rebuild targets.
MSVSSCONS
The SCons used in generated Microsoft Visual C++ project files. The default is the version of SCons being used to generate the project file.
MSVSSCONSCOM
The default SCons command used in generated Microsoft Visual C++ project files.
MSVSSCONSCRIPT
The sconscript file (that is, SConstruct
or SConscript
file) that will be invoked by Microsoft Visual C++ project files
(through the $MSVSSCONSCOM
variable). The default
is the same sconscript file that contains the call to
MSVSProject
to build the project file.
MSVSSCONSFLAGS
The SCons flags used in generated Microsoft Visual C++ project files.
MSVSSOLUTIONCOM
The action used to generate Microsoft Visual Studio solution files.
MSVSSOLUTIONSUFFIX
The suffix used for Microsoft Visual Studio solution (DSW)
files. The default value is .sln
when using Visual Studio version 7.x (.NET 2002) and later,
and .dsw
when using Visual Studio 6.0.
MT
The program used on Windows systems to embed manifests into DLLs and EXEs.
See also $WINDOWS_EMBED_MANIFEST
.
MTEXECOM
The Windows command line used to embed manifests into executables.
See also $MTSHLIBCOM
.
MTFLAGS
Flags passed to the $MT
manifest embedding program (Windows only).
MTSHLIBCOM
The Windows command line used to embed manifests into shared libraries (DLLs).
See also $MTEXECOM
.
MWCW_VERSION
The version number of the MetroWerks CodeWarrior C compiler to be used.
MWCW_VERSIONS
A list of installed versions of the MetroWerks CodeWarrior C compiler on this system.
NAME
Specfies the name of the project to package.
See the Package
builder.
NINJA_ALIAS_NAME
The name of the alias target which will cause SCons to create the ninja build file,
and then (optionally) run ninja.
The default value is generate-ninja
.
NINJA_CMD_ARGS
A string which will pass arguments through SCons to the ninja command when scons executes ninja.
Has no effect if $NINJA_DISABLE_AUTO_RUN
is set.
This value can also be passed on the command line:
scons NINJA_CMD_ARGS=-v or scons NINJA_CMD_ARGS="-v -j 3"
NINJA_COMPDB_EXPAND
Boolean value to instruct ninja to expand the command line arguments normally put into
response files.
If true, prevents unexpanded lines in the compilation database like
“gcc @rsp_file
” and instead yields expanded lines like
“gcc -c -o myfile.o myfile.c -Ia -DXYZ
”.
Ninja's compdb tool added the -x
flag in Ninja V1.9.0
NINJA_DEPFILE_PARSE_FORMAT
Determines the type of format ninja should expect when parsing header
include depfiles. Can be msvc
, gcc
, or clang
.
The msvc
option corresponds to /showIncludes
format, and
gcc
or clang
correspond to -MMD -MF
.
NINJA_DIR
The builddir
value.
Propagates directly into the generated ninja build file.
From Ninja's docs:
“
A directory for some Ninja output files. ... (You can also store other build output in this
directory.)
”
The default value is .ninja
.
NINJA_DISABLE_AUTO_RUN
Boolean. Default: False
.
If true, SCons will not run ninja automatically after creating the ninja build file.
If not explicitly set, this will be set to True
if --disable_execute_ninja
or
SetOption('disable_execute_ninja', True)
is seen.
NINJA_ENV_VAR_CACHE
A string that sets the environment for any environment variables that differ between the OS environment and the SCons execution environment.
It will be compatible with the default shell of the operating system.
If not explicitly set, SCons will generate this dynamically from the
execution environment stored in the current construction environment
(e.g. env['ENV']
)
where those values differ from the existing shell..
NINJA_FILE_NAME
The filename for the generated Ninja build file.
The default is ninja.build
.
NINJA_FORCE_SCONS_BUILD
If true, causes the build nodes to callback to scons instead of using ninja to build them. This is intended to be passed to the environment on the builder invocation. It is useful if you have a build node which does something which is not easily translated into ninja.
NINJA_GENERATED_SOURCE_ALIAS_NAME
A string matching the name of a user defined alias which represents a list of all generated sources.
This will prevent the auto-detection of generated sources from $NINJA_GENERATED_SOURCE_SUFFIXES
.
Then all other source files will be made to depend on this in the ninja build file, forcing the
generated sources to be built first.
NINJA_GENERATED_SOURCE_SUFFIXES
The list of source file suffixes which are generated by SCons build steps. All source files which match these suffixes will be added to the _generated_sources alias in the output ninja build file. Then all other source files will be made to depend on this in the ninja build file, forcing the generated sources to be built first.
NINJA_MSVC_DEPS_PREFIX
The msvc_deps_prefix
string.
Propagates directly into the generated ninja build file.
From Ninja's docs:
“defines the string which should be stripped from msvc's /showIncludes
output”
NINJA_POOL
Set the ninja_pool
for this or all targets in scope for this env var.
NINJA_REGENERATE_DEPS
A generator function used to create a ninja depfile which includes all the files which would require SCons to be invoked if they change. Or a list of said files.
_NINJA_REGENERATE_DEPS_FUNC
Internal value used to specify the function to call with argument env to generate the list of files which if changed would require the ninja build file to be regenerated.
NINJA_SCONS_DAEMON_KEEP_ALIVE
The number of seconds for the SCons deamon launched by ninja to stay alive. (Default: 180000)
NINJA_SCONS_DAEMON_PORT
The TCP/IP port for the SCons daemon to listen on. NOTE: You cannot use a port already being listened to on your build machine. (Default: random number between 10000,60000)
NINJA_SYNTAX
The path to a custom ninja_syntax.py
file which is used in generation.
The tool currently assumes you have ninja installed as a Python module and grabs the syntax file from that
installation if $NINJA_SYNTAX
is not explicitly set.
no_import_lib
When set to non-zero,
suppresses creation of a corresponding Windows static import lib by the
SharedLibrary
builder when used with
MinGW, Microsoft Visual Studio or Metrowerks.
This also suppresses creation
of an export (.exp
) file
when using Microsoft Visual Studio.
OBJPREFIX
The prefix used for (static) object file names.
OBJSUFFIX
The suffix used for (static) object file names.
PACKAGEROOT
Specifies the directory where all files in resulting archive will be
placed if applicable. The default value is “$NAME
-$VERSION
”.
See the Package
builder.
PACKAGETYPE
Selects the package type to build when using the Package
builder. May be a string or list of strings. See the docuentation
for the builder for the currently supported types.
$PACKAGETYPE
may be overridden with the --package-type
command line option.
See the Package
builder.
PACKAGEVERSION
The version of the package (not the underlying project). This is currently only used by the rpm packager and should reflect changes in the packaging, not the underlying project code itself.
See the Package
builder.
PCH
A node for the Microsoft Visual C++ precompiled header that will be used when compiling object files. This variable is ignored by tools other than Microsoft Visual C++. When this variable is defined, SCons will add options to the compiler command line to cause it to use the precompiled header, and will also set up the dependencies for the PCH file. Examples:
env['PCH'] = File('StdAfx.pch') env['PCH'] = env.PCH('pch.cc')[0]
PCHCOM
The command line used by the
PCH
builder to generated a precompiled header.
PCHCOMSTR
The string displayed when generating a precompiled header.
If not set, then $PCHCOM
(the command line) is displayed.
PCHPDBFLAGS
A construction variable that, when expanded,
adds the /yD
flag to the command line
only if the $PDB
construction variable is set.
PCHSTOP
This variable specifies how much of a source file is precompiled. This variable is ignored by tools other than Microsoft Visual C++, or when the PCH variable is not being used. When this variable is define it must be a string that is the name of the header that is included at the end of the precompiled portion of the source files, or the empty string if the "#pragma hrdstop" construct is being used:
env['PCHSTOP'] = 'StdAfx.h'
PDB
The Microsoft Visual C++ PDB file that will store debugging information for object files, shared libraries, and programs. This variable is ignored by tools other than Microsoft Visual C++. When this variable is defined SCons will add options to the compiler and linker command line to cause them to generate external debugging information, and will also set up the dependencies for the PDB file. Example:
env['PDB'] = 'hello.pdb'
The Microsoft Visual C++ compiler switch that SCons uses by default
to generate PDB information is /Z7
.
This works correctly with parallel (-j
) builds
because it embeds the debug information in the intermediate object files,
as opposed to sharing a single PDB file between multiple object files.
This is also the only way to get debug information
embedded into a static library.
Using the /Zi
instead may yield improved
link-time performance,
although parallel builds will no longer work.
You can generate PDB files with the /Zi
switch by overriding the default $CCPDBFLAGS
variable;
see the entry for that variable for specific examples.
PDFLATEX
The pdflatex utility.
PDFLATEXCOM
The command line used to call the pdflatex utility.
PDFLATEXCOMSTR
The string displayed when calling the pdflatex utility.
If this is not set, then $PDFLATEXCOM
(the command line) is displayed.
env = Environment(PDFLATEX;COMSTR = "Building $TARGET from LaTeX input $SOURCES")