ANN: SCons.0.96 adds Fortran 90/95 support, better Qt support,platform-independent file system actio


Steven Knight

SCons is a software construction tool (build tool, or make tool) written
in Python. It is based on the design which won the Software Carpentry
build tool competition in August 2000.

Version 0.96 of SCons has been released and is available for download
from the SCons web site:

Or through the download link at the SCons project page at SourceForge:

RPM and Debian packages and a Win32 installer are all available, in
addition to the traditional .tar.gz and .zip files.


IMPORTANT: Release 0.96 contains the following interface changes:

- All Builder calls now return a *list* of Nodes, even when the Builder
only builds one file. This may require SConscript file changes if
you were manipulating the return values from Builders.
- The SConsignFile() function now uses a different internal database
format by default. This will cause a rebuild when you upgrade to
0.96 unless you modify your SConsignFile() call.
- The internal format of .sconsign files has been changed. The change
was coded to be backwards-compatible, but there might be corner
cases that cause warnings about "ignoring corrupt .sconsign files"
and rebuilds when you use SCons 0.96 for the first time in an
already-built tree.
- The scan_check function that can be supplied to a custom Scanner now
must take two arguments, the Node to be checked and a construction
environment. It previously only used the Node as an argument.
- The internal "node_factory" and "scanner" keyword arguments have
been removed from the Builder() function, in favor of separate
"target_factory," "source_factory," "target_scanner" and
"source"scanner" keywords, which are now documented.
- The Scanner add_skey() function has been dropped in favor of using
construction variables for the lists of file suffixes known to
a Scanner.
- File name extensions that contain all digits are now assumed to
be version numbers and treated as part of the file basename.
- The env.Append() and env.Prepend() methods have been changed to
behave like the rest of Python when either argument is a UserList.

See the release notes for more information about these changes.

This release adds the following new features:

- A new --debug=explain option tells SCons to report the reason(s)
why it thinks it must rebuild something.
- New Moc() and Uic() Builders provide more explicit control over
Qt builds, plus new construction variables to control them:
- Support for Fortran 90 and Fortran 95 has been added.
- The newer "ifort" versions of the Intel Fortran Compiler for Linux
are now supported.
- New functions have been added to return platform-independent Actions
that Chmod(), Copy(), Delete(), Mkdir(), Move() and Touch() files
and/or directories.
- A new Execute() function can now execute Actions directly at
SConscript-read time.
- A new $RPATH variable has been added that specifies a list of
directories for the GNU and IRIX linkers to search for shared
variables have been added that make it easier to arrange for
additional file suffixes to be scanned by the default Scanners.
- A new Flatten() function can be used to turn nested lists of Nodes
(or other arguments) into a flat list.
- A new --debug=presub option prints the commands to be executed before
their construction variables are expanded.
- A new .win32 Node attribute will expand file names with Windows
backslash path separators on any system.
- A new ARGLIST variable makes it possible to fetch keyword=value
arguments in the order specified on the command line.
- Support has been added for the .dylib shared library suffix
and -dynamiclib linker option on Mac OS X (darwin).

This release enhances the following existing features:

- Environment override keywords can now be passed to the Command()
- An emitter argument to a Builder() can now be a list of emitters
that will be called in sequence.
- The Java() Builder can now take more than one source directory.
- Scanners can now use suffix lists from construction variable
- ParseConfig() now recognizes the -Wa, -Wl, -Wp and -pthread flags
and adds them to the appropriate variable(s).
- Dir (directory) Nodes can now be be created with user-specified
Builder objects.
- The SConf.CheckLib() method can now search a list of libraries.
- The env.WhereIs() method now takes a "reject" argument to weed out
specific path names.
- When calling Builders, SCons now issues a warning upon use of
the keywords "targets" and "sources", which are virtually always
typographic errors that otherwise silently (and confusingly) turn
into construction variable overrides.
$YACCCOM variables all have wrapper Actions by default. This makes
it easier to replace the default print behavior with a custom
- Individual tools that create libraries now override the default
$LIBPREFIX and $LIBSUFFIX values set by the platform. This makes
it easier to use Microsoft Visual Studio tools on a CygWin platform.
- If Visual Studio is installed, SCons now assumes its C/C++ compiler,
its linker and its MIDL compiler are available, too.
- SCons now searches for the ICL license file path name in the external
environment and the registry before resorting to the hard-coded
path name.
- When using Visual Studio, SCons now generates the PDB files at link
time, not compile time.
- Dependency tracking has been modified to eliminate spurious circular
dependencies in certain corner cases involving generated header
files, and to avoid rebuilding generated .h files when a #included
.h file changes.
- The internal Task.make_ready() method now creates a list of the
out-of-date Nodes for the task for use by the wrapping interface.
- A new single_source keyword argument when creating a Builder enforces
a single source file on calls to that Builder.

The following fixes have been added:

- The CacheDir() directory is now created if it doesn't exist.
- Construction variables can now be substituted in $LIBS expansions,
and $LIBS expansions now properly ignore null library values.
- Construction variables that can be searched for libraries now remove
.dll files from the list before feeding the list to Win32 compilers.
- All *PATH variables can now expand to include Nodes.
- The name of a Scanner.Classic instance is now initialized correctly.
- SCons now handles dangling symlinks without generating a stack trace.
- env.SourceCode() now works properly when called with an individual
file name or Node, not just with a directory name or Node.
- SCons now handles the lack of an external PATH environment variable.
- Use of $MSVS_IGNORE_IDE_PATHS was broken in 0.95 and is now fixed.
- The Command() global function now works properly with string actions;
this was broken in 0.95.
- A bug introduced in 0.95 in building shared libraries under MinGW
has been fixed.
- SCons now handles null entries (None or '') in tool lists or CPPPATH.
- SCons now handles exceptions in thread-safe ways, according to
Pythonic standards.
- Error messages have been improved when the evaluation of a
construction variable expansion yields a Python syntax error.
- File names on command lines are now escaped properly when the
expansion is concatenated with another string.

Performance has been improved as follows:

- Node creation has been sped up when calling a Builder by comparing
whether environments are the same object, not whether they have
equivalent construction variables.
- File system Nodes now cache their generated string values after
we've finished reading the SConscript() files.
- Node lookup has been made slightly more efficient.
- Deleting parents' implicit dependencies after a Node has been built
has been made more efficient.

The documentation has been improved:

- The User's Guide has had the following chapters and sections added:
A chapter describing how to install Python and SCons; a section
describing the declarative nature of SCons functions in SConscript
files; a chapter describing File and Directory Nodes and the return
values from Builders; a chapter describing the SConf (Autoconf-like)
functionality; a chapter describing Java builds.
- The early chapters of the User's Guide have been reorganized to
better explain concepts for new users (based on input from Robert
P. J. Day, many thanks).
- User's Guide fixes: the signatures of the various example *Options()
calls; triple-quote properly a multi-line Split() example.
- Man page additions: an example and explanation of how to use "tools =
['default', ..." when creating a construction environment; a section
describing File and Directory Nodes and some of their attributes
and methods; a section describing use of the target_factory and
source_factory keyword arguments when creating Builder objects.
- Man page fixes: formatting typos, misspellings, fix a bad example.


Distinctive features of SCons include:

- a global view of all dependencies; no multiple passes to get
everything built properly
- configuration files are Python scripts, allowing the full use of a
real scripting language to solve difficult build problems
- a modular architecture allows the SCons Build Engine to be
embedded in other Python software
- the ability to scan files for implicit dependencies (#include files);
- improved parallel build (-j) support that provides consistent
build speedup regardless of source tree layout
- use of MD5 signatures to decide if a file has really changed; no
need to "touch" files to fool make that something is up-to-date
- easily extensible through user-defined Builder and Scanner objects
- build actions can be Python code, as well as external commands

An scons-users mailing list is available for those interested in getting
started using SCons. You can subscribe at:

Alternatively, we invite you to subscribe to the low-volume
scons-announce mailing list to receive notification when new versions of
SCons become available:


Special thanks to Chad Austin, Charles Crain, Tom Epperly, Ralf
W. Grosse-Kunstleve, Jonathan Gurley, Bob Halley, Chris Hoeppler, James
Juhasz, Chris Murray, Gary Oberbrunner, Simon Perkins, Kevin Quick,
Anthony Roach, sam th and Christoph Wiedemann for their contributions
to this release.

On behalf of the SCons team,



Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question