ANN: SCons 0.95 supports Visual Studio 2003, Borland tools, "D" programming language

Steven Knight knight at
Fri Mar 12 04:50:36 CET 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.95 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.95 contains the following interface changes:

  - The default behavior of the Zip() Builder is now to create a
    compressed file.
  - The "overrides" keyword argument when creating a Builder() has been
    deprecated in favor of specifying the values directly with keyword
  - The meaning of the "mode" keyword argument values to the
    SCons.Util.scons_subst() and SCons.Util.scons_subst_list() functions
    have been changed.  (These are internal functions and should have
    no external effect, but we list them here for completeness.)

  See the release notes for more information about these changes.

This release adds the following features:

  - Microsoft Visual Studio 2003 (version 7.1) is now supported.
  - The bcc32, ilink32 and tlib Borland tools are now supported.
  - The Digital Mars "D" programming language is now supported.
  - A new $MSVS_USE_MFC_DIRS construction variable controls whether the
    Microsoft Visual Studio ATL and MFC directories are included in the
    default INCLUDE and LIB paths.
  - New AppendUnique() and PrependUnique() Environment methods add values
    (flags) to construction variables only if they're not already present.
  - New "rsrcpath" and "rsrcdir" attributes to the $TARGET, $TARGETS,
    $SOURCE and $SOURCES construction variables allow Builder commands
    to access Repository source directories when using a Builder.
  - A new --debug=count option displays the numbers of various types
    of internal objects created, when run under Python 2.1 or later.
  - A new --debug=objects option dumps information about SCons internal
    objects when run under Python 2.1 or later.
  - A new --debug=memory option displays memory usage statistics when
    run under Linux systems.
  - A new ZIPCOMPRESSION construction variable controls whether the
    internal Python action for the Zip Builder compresses the file
    or not.  The default value is zipfile.ZIP_DEFLATED, which generates
    a compressed file.
  - A new "toolpath" Tool() and Environment keyword allows Tool modules
    to be searched for in specified local directories.

The following bug fixes have been added:

  - SCons now gracefully handles non-string construction variables in
    all known situations.
  - Construction variables may now be recursively expanded (e.g. CCFLAGS =
    "$CCFLAGS -g") without going into an infinite loop.
  - Compile the moc_*.cc Qt files using the correct environment flags,
    not those from the environment that first had Qt Builders attached.
  - Expansions like ${TARGET.dir} now work properly in *PATH construction
    variables (like CPPPATH, F77PATH, etc.).
  - Qt support now works from a copied construction environment.
  - The M4 Builder now changes correctly to a Repository directory when
    the source file is in the source directory of a BuildDir.
  - Automatic checkout of implicit dependency files from SCCS and RCS
    has been fixed.
  - Builder-specific override values are now always used in substitutions,
    not just when there isn't a target-specific environment.
  - SCons now properly checks for whether all of the objects going into
    a SharedLibrary() are shared, even if the object was already built.
  - SCons now correctly looks up a Win32 drive letter with no path ('C:')
    as a directory.
  - Specifying .class files as input to JavaH with the .class suffix
    when they weren't generated using the Java Builder has been fixed.
  - The env.Action() method now returns the correct type of
    Action for its argument(s).
  - The Configure() function now works when called from nested subsidiary
    SConscript files more than one level deep.
  - Error message spellings have been corrected from "non-existant" to
  - The EnsureSConsVersion() function now checks against the SCons
    version, not the Python version, for all Python version.
  - SCons now properly handles command-line arguments with multiple =
    in them.
  - SCons now correctly retrieves all files from cache when multiple
    files would ordinarily be built by in a single Action.
  - Use of a custom _concat() function in the construction environment
    when calling _stripixes() has been fixed.
  - The Fortran scanner is now case-insensitive for the INCLUDE string
    (per the Fortan spec).
  - Side-effect targets are now properly removed before building their
    corresponding target.
  - BuildDir() can, once again, be called multiple times with the same
    target and source directory arguments.
  - Output lines now stay (more nearly) together when -j is used.
  - A bug in saving and restoring PackageOptions to a file has been fixed.
  - Microsoft Visual Studio type libraries are now built in the target
    directory, not the source directory.
  - Generated Microsoft Visual Studio project files now re-invoke SCons
    correctly regardless of whether the file was built via scons.bat
    is invoked, not when the tool is initialized.
  - A typo has been fixed in the Microsoft Visual C registry lookup
    ("VCComponents.dat", not "VSComponents.dat").
  - When using Microsoft Visual C++, SCons now uses independently
    configured "include," "lib" or "path" from the registry.  Previously,
    SCons would only use the values if all three were set in the registry.
  - SCons now ignore any "6.1" version of Microsoft Visual C++ found in
    the registry; this is apparently a phony version number (created by
    later service packs?) that throws off the logic if the user had any
    non-default paths configured.
  - SCons now uses the Microsoft Visual C++ 6.0 paths by default if the
    "msvc" Tool is specified but no version of MSVC is detected on disk.

The following miscellaneous improvements have been added:

  - All *FLAGS variables now "do the right thing" (as much as possible)
    when appending flags with either strings or lists of flags.
  - The -H help text now lists the legal --debug values.
  - SCons now supplies an error message if you try to configure a BuildDir
    for a directory that already has one.
  - The error message when a source file can't be found has been reworded
    to make it more clear.
  - SCons now supplies a useful error message, not a stack trace, if a
    construction variable expansion contains a syntax error.
  - SCons now supplies meaningful error messages, not stack traces, if
    a non-Node is added as a source, dependency, or ignored dependency
    of a Node.
  - The $LIBS construction variable can now contain File nodes, and
    can now be a single string or File node, not a list, when only one
    library is needed.
  - When scanning for libraries to link with, SCons no longer appends
    $LIBPREFIXES or $LIBSUFFIXES values to the $LIBS values if they're
    already present.
  - SCons now allows a target that can have its Builder called multiple
    times to be called through multiple environments without error,
    so long as the Builder calls all use the same action.
  - The message about ignoring a missing SConscript file is now a
    suppressable Warning, not a hard-coded sys.stderr.write().
  - On POSIX systems with the "env" command, spawn commands with the
    more portable "env -" idiom, instead of "env -i".
  - Improve Cygwin support by accomodating Cygwin Python's delusion that
    it's running on a case-sensitive file system.
  - Microsoft Visual Studio .NET and Visual C 6.0/7.0 path detection
    has been updated and made more robust.

Memory utilization has been improved as follows:

  - "Build" construction environments with overrides are now only
    generated as needed, not for every target.
  - Nodes now delete their build environments after they've been built.

The documentation has been improved:

  - The User's Guide now has an appendix describing how to accomplish
    various common tasks in Python.
  - Mention of the still-unimplemented -e option has been removed.
  - A man page typo of "JAVACHDIR" instead of "JARCHDIR" has been fixed.
  - An undocumented "for_signature" argument in the __call__() example
    of the "Variable Substitution" section has now been documented.
  - An odd double-quote escape sequence in the man page has been fixed.
  - The dbm_module argument to the SConsignFile() function has been


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, Kerim Borchaev, Chris Burghart, Steve
Christensen, David M. Cooke, Charles Crain, Andy Friesen, Scott Lystig
Fritchie, Bob Halley, Zephaniah Hull, Vincent Risi, Anthony Roach, Greg
Spencer and Christoph Wiedemann for their contributions to this release.

On behalf of the SCons team,


More information about the Python-list mailing list