Velocity Reviews - Computer Hardware Reviews

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

Reply
Thread Tools

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

 
 
Steven Knight
Guest
Posts: n/a
 
      08-18-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:

http://www.scons.org/

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

http://sourceforge.net/projects/scons/

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


WHAT'S NEW IN THIS RELEASE?

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:
$QT_AUTOSCAN, $QT_DEBUG, $QT_MOCCXXPREFIX, $QT_MOCCXXSUFFIX,
$QT_MOCHPREFIX, $QT_MOCHSUFFIX, $QT_UICDECLPREFIX, $QT_UICDECLSUFFIX,
$QT_UICIMPLPREFIX, $QT_UICIMPLSUFFIX and $QT_UISUFFIX.
- 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
libraries.
- New $CPPSUFFIXES, $DSUFFIXES, $FORTRANSUFFIXES and $IDLSUFFIXES
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()
Builder.
- 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
expansions.
- 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.
- The $ASCOM, $ASPPCOM, $LINKCOM, $SHLINKCOM, $ARCOM, $LEXCOM and
$YACCCOM variables all have wrapper Actions by default. This makes
it easier to replace the default print behavior with a custom
strfunction().
- 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.


ABOUT SCONS

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:

http://lists.sourceforge.net/lists/listinfo/scons-users

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

http://lists.sourceforge.net/lists/l...scons-announce


ACKNOWLEDGEMENTS

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,

--SK

 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Passing an array from FORTRAN to C then passing it within C andReturning it to FORTRAN deadpickle C Programming 1 11-07-2010 02:38 PM
Looking for lots of words in lots of files brad Python 9 06-19-2008 07:59 AM
Many Fortran code! How to call Fortran code from C/C++? Luna Moon C++ 9 09-04-2007 03:49 PM
Downloading lots and lots and lots of files coolneo Perl Misc 9 01-30-2007 02:34 PM
Build a Better Blair (like Build a Better Bush, only better) Kenny Computer Support 0 05-06-2005 04:50 AM



Advertisments