ANN: SCons.0.96 adds Fortran 90/95 support, better Qt support, platform-independent file system actions, improved debugging, lots more

Steven Knight knight at
Wed Aug 18 17:55:26 CEST 2004

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,


More information about the Python-announce-list mailing list