outf.close()
os.chmod(t, os.stat(s)[0])
-revbuilder = Builder(name = 'SCons_revision', action = SCons_revision)
+revbuilder = Builder(action = SCons_revision)
env = Environment(
ENV = ENV,
UNPACK_TAR_GZ_DIR = unpack_tar_gz_dir,
UNPACK_ZIP_DIR = unpack_zip_dir,
- BUILDERS = [ revbuilder ],
+ BUILDERS = { 'SCons_revision' : revbuilder },
)
#
Print a message containing the working directory before and
after other processing.
+.TP
+.RI --warn= type ", --warn=no-" type
+Enable or disable warnings.
+.I type
+specifies the type of warnings to be enabled or disabled:
+
+.TP
+.RI --warn=all ", " --warn=no-all
+Enables or disables all warnings.
+
+.TP
+.RI --warn=dependency ", " --warn=no-dependency
+Enables or disables warnings about dependencies.
+These warnings are disabled by default.
+
+.TP
+.RI --warn=deprecated ", " --warn=no-deprecated
+Enables or disables warnings about use of deprecated features.
+These warnings are enabled by default.
+
.TP
--no-print-directory
Turn off -w, even if it was turned on implicitly.
The command line used to generate a static library from object files.
.IP BUILDERS
-A list of the available builders.
-[Alias, CFile, CXXFile, DVI, Library, Object, PDF, PostScript, Program] by default.
+A dictionary mapping the names of the builders
+available through this environment
+to underlying Builder objects.
+Builders named
+Alias, CFile, CXXFile, DVI, Library, Object, PDF, PostScript, and Program
+are available by default.
.IP CC
The C compiler.
def e(target, source, env):
return (target + ['foo.foo'], source + ['foo.src'])
-b = Builder(name="Foo", emitter=e)
+b = Builder(emitter=e)
.EE
.IP generator
def g(source, target, env, for_signature):
return [["gcc", "-c", "-o"] + target + source]
-b = Builder(name="Object", generator=g)
+b = Builder(generator=g)
.EE
The
result of the call).
.ES
-b = Builder(name='MyBuild', action="build < $SOURCE > $TARGET")
-env = Environment(BUILDERS = [b])
+b = Builder(action="build < $SOURCE > $TARGET")
+env = Environment(BUILDERS = {'MyBuild' : b})
env.MyBuild('foo.out', 'foo.in', my_arg = 'xyzzy')
.EE
and the builder will add it automatically.
.ES
-bld = Builder(name = 'PDFBuilder',
- action = 'pdftex < $SOURCES > $TARGET'
+bld = Builder(action = 'pdftex < $SOURCES > $TARGET'
suffix = '.pdf',
src_suffix = '.tex')
-env = Environment(BUILDERS = [bld])
+env = Environment(BUILDERS = {'PDFBuilder' : bld})
env.PDFBuilder(target = 'foo.pdf', source = 'foo.tex')
# The following creates "bar.pdf" from "bar.tex"
/usr/lib/scons/SCons/Taskmaster.pyc
/usr/lib/scons/SCons/Util.py
/usr/lib/scons/SCons/Util.pyc
+/usr/lib/scons/SCons/Warnings.py
+/usr/lib/scons/SCons/Warnings.pyc
/usr/lib/scons/SCons/__init__.py
/usr/lib/scons/SCons/__init__.pyc
/usr/lib/scons/SCons/exitfuncs.py
- Fixed a bug with relative CPPPATH dirs when using BuildDir().
(Bug reported by Bob Summerwill.)
+ - Added a warnings framework and a --warn option to enable or
+ disable warnings.
+
+ - Make the C scanner warn users if files referenced by #include
+ directives cannot be found and --warn=dependency is specified.
+
+ - The BUILDERS construction variable should now be a dictionary
+ that maps builder names to actions. Existing uses of lists,
+ and the Builder name= keyword argument, generate warnings
+ about use of deprecated features.
+
From Steven Knight:
- Add a "platform=" keyword argument to Environment instantiation,
SCons/Sig/TimeStamp.py
SCons/Taskmaster.py
SCons/Util.py
+SCons/Warnings.py
import SCons.Node
import SCons.Node.FS
import SCons.Util
+import SCons.Warnings
class DictCmdGenerator:
"""This is a callable class that can be used as a
def Builder(**kw):
"""A factory for builder objects."""
+ if kw.has_key('name'):
+ SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning,
+ "The use of the 'name' parameter to Builder() is deprecated.")
if kw.has_key('generator'):
if kw.has_key('action'):
raise UserError, "You must not specify both an action and a generator."
if isinstance(t.builder, ListBuilder) and isinstance(builder, ListBuilder) and t.builder.builder == builder.builder:
raise UserError, "Two different target sets have a target in common: %s"%str(t)
else:
- raise UserError, "Two different builders (%s and %s) were specified for the same target: %s"%(t.builder.name, builder.name, str(t))
+ raise UserError, "Two different builders (%s and %s) were specified for the same target: %s"%(t.builder.get_name(env), builder.get_name(env), str(t))
elif t.sources != slist:
raise UserError, "Multiple ways to build the same target were specified for: %s" % str(t)
scanner = None,
emitter = None,
multi = 0):
- if name is None:
- raise UserError, "You must specify a name for the builder."
self.name = name
self.action = SCons.Action.Action(action)
self.multi = multi
self.emitter = emitter
+ def get_name(self, env):
+ """Attempts to get the name of the Builder.
+
+ If the Builder's name attribute is None, then we will look at
+ the BUILDERS variable of env, expecting it to be a dictionary
+ containing this Builder, and we will return the key of the
+ dictionary."""
+
+ if self.name:
+ return self.name
+ try:
+ index = env['BUILDERS'].values().index(self)
+ return env['BUILDERS'].keys()[index]
+ except (AttributeError, KeyError, ValueError):
+ return str(self.__class__)
+
def __cmp__(self, other):
return cmp(self.__dict__, other.__dict__)
def __init__(self, builder, env, tlist):
self.builder = builder
- self.tlist = tlist
- self.name = "ListBuilder(%s)"%builder.name
+ self.tlist = tlist
+ self.name = "ListBuilder(%s)"%builder.get_name(env)
+
+ def get_name(self, env):
+ return self.name
def execute(self, **kw):
if hasattr(self, 'status'):
import SCons.Builder
import SCons.Errors
import SCons.Node.FS
+import SCons.Warnings
# Initial setup of the common environment for all tests,
# a temporary working directory containing a
assert target.sources[1].name == uni('n19')
def test_noname(self):
- """Test error reporting for missing name
+ """Test deprecated warning for Builder name.
- Verify that the Builder constructor gives an error message if the
- name is missing.
+ Using the name argument for Builder() is deprectaed and the
+ user should receive a warning.
"""
+ SCons.Warnings.enableWarningClass(SCons.Warnings.DeprecatedWarning)
+ SCons.Warnings.warningAsException(1)
+
try:
- b = SCons.Builder.Builder()
- except SCons.Errors.UserError:
- pass
- else:
- assert 0
+ try:
+ b = SCons.Builder.Builder(name='foo')
+ except SCons.Warnings.DeprecatedWarning:
+ pass
+ else:
+ assert 0
+ finally:
+ SCons.Warnings.suppressWarningClass(SCons.Warnings.DeprecatedWarning)
+ SCons.Warnings.warningAsException(0)
def test_action(self):
"""Test Builder creation
def __call__(self, target, source, env, shared=0, **kw):
for src in source:
try:
- if src.attributes.shared != shared:
- raise SCons.Errors.UserError("Source file: %s must be built with shared=%s in order to be compatible with the selected target." % (src, str(shared)))
+ if (src.attributes.shared and not shared) or \
+ (shared and not src.attributes.shared):
+ raise SCons.Errors.UserError("Source file: %s must be built with shared=%s in order to be compatible with target: %s" % (src, str(shared), target[0]))
except AttributeError:
pass
for t in target:
'.h')
return (target, source)
-CFile = SCons.Builder.Builder(name = 'CFile',
- action = { '.l' : '$LEXCOM',
+CFile = SCons.Builder.Builder(action = { '.l' : '$LEXCOM',
'.y' : '$YACCCOM',
},
emitter = yaccEmitter,
suffix = '$CFILESUFFIX')
-CXXFile = SCons.Builder.Builder(name = 'CXXFile',
- action = { '.ll' : '$LEXCOM',
+CXXFile = SCons.Builder.Builder(action = { '.ll' : '$LEXCOM',
'.yy' : '$YACCCOM',
},
emitter = yaccEmitter,
".FOR" : F77Action,
".fpp" : F77PPAction,
".FPP" : F77PPAction })
-
-Object = SCons.Builder.Builder(name = 'Object',
- generator = \
+
+Object = SCons.Builder.Builder(generator = \
SharedCmdGenerator(static=SCons.Action.CommandGeneratorAction(static_obj),
shared=SCons.Action.CommandGeneratorAction(shared_obj)),
prefix = '$OBJPREFIX',
src_suffix = static_obj.src_suffixes(),
src_builder = [CFile, CXXFile])
-def win32TempFileMunge(env, cmd_list, for_signature):
+def win32TempFileMunge(env, cmd_list, for_signature):
"""Given a list of command line arguments, see if it is too
long to pass to the win32 command line interpreter. If so,
create a temp file, then pass "@tempfile" as the sole argument
args.extend(map(SCons.Util.to_String, source))
return win32TempFileMunge(env, args, for_signature)
-Program = SCons.Builder.Builder(name='Program',
- action='$LINKCOM',
+Program = SCons.Builder.Builder(action='$LINKCOM',
prefix='$PROGPREFIX',
suffix='$PROGSUFFIX',
src_suffix='$OBJSUFFIX',
env.subst("$LIBSUFFIX")))
return (target, source)
-Library = SCons.Builder.Builder(name = 'Library',
- generator = \
+Library = SCons.Builder.Builder(generator = \
SharedCmdGenerator(shared="$SHLINKCOM",
static="$ARCOM"),
emitter="$LIBEMITTER",
LaTeXAction = SCons.Action.Action('$LATEXCOM')
-DVI = SCons.Builder.Builder(name = 'DVI',
- action = { '.tex' : '$TEXCOM',
+DVI = SCons.Builder.Builder(action = { '.tex' : '$TEXCOM',
'.ltx' : LaTeXAction,
'.latex' : LaTeXAction,
},
PDFLaTeXAction = SCons.Action.Action('$PDFLATEXCOM')
-PDF = SCons.Builder.Builder(name = 'PDF',
- action = { '.dvi' : '$PDFCOM',
+PDF = SCons.Builder.Builder(action = { '.dvi' : '$PDFCOM',
'.tex' : '$PDFTEXCOM',
'.ltx' : PDFLaTeXAction,
'.latex' : PDFLaTeXAction,
prefix = '$PDFPREFIX',
suffix = '$PDFSUFFIX')
-PostScript = SCons.Builder.Builder(name = 'PostScript',
- action = '$PSCOM',
+PostScript = SCons.Builder.Builder(action = '$PSCOM',
prefix = '$PSPREFIX',
suffix = '$PSSUFFIX',
src_suffix = '.dvi',
def alias_builder(env, target, source):
pass
-Alias = SCons.Builder.Builder(name = 'Alias',
- action = alias_builder,
+Alias = SCons.Builder.Builder(action = alias_builder,
target_factory = SCons.Node.Alias.default_ans.Alias,
source_factory = SCons.Node.FS.default_fs.Entry,
multi = 1)
'PSCOM' : '$DVIPS $DVIPSFLAGS -o $TARGET $SOURCES',
'PSPREFIX' : '',
'PSSUFFIX' : '.ps',
- 'BUILDERS' : [Alias, CFile, CXXFile, DVI, Library, Object,
- PDF, PostScript, Program],
+ 'BUILDERS' : { 'Alias' : Alias,
+ 'CFile' : CFile,
+ 'CXXFile' : CXXFile,
+ 'DVI' : DVI,
+ 'Library' : Library,
+ 'Object' : Object,
+ 'PDF' : PDF,
+ 'PostScript' : PostScript,
+ 'Program' : Program },
'SCANNERS' : [CScan],
'LIBDIRPREFIX' : '/LIBPATH:',
'LIBDIRSUFFIX' : '',
'PSCOM' : '$DVIPS $DVIPSFLAGS -o $TARGET $SOURCES',
'PSPREFIX' : '',
'PSSUFFIX' : '.ps',
- 'BUILDERS' : [Alias, CFile, CXXFile, DVI, Library, Object,
- PDF, PostScript, Program],
+ 'BUILDERS' : { 'Alias' : Alias,
+ 'CFile' : CFile,
+ 'CXXFile' : CXXFile,
+ 'DVI' : DVI,
+ 'Library' : Library,
+ 'Object' : Object,
+ 'PDF' : PDF,
+ 'PostScript' : PostScript,
+ 'Program' : Program },
'SCANNERS' : [CScan],
'LIBDIRPREFIX' : '-L',
'LIBDIRSUFFIX' : '',
import SCons.Node
import SCons.Node.FS
import SCons.Util
+import SCons.Warnings
+from UserDict import UserDict
def installFunc(env, target, source):
try:
copy = x
return copy
+class BuilderDict(UserDict):
+ """This is a dictionary-like class used by Environment
+ to hold Builders. We need to do this, because every time
+ someone changes the Builders in the Environment's BUILDERS
+ dictionary, we need to update the Environment's attributes."""
+ def setEnvironment(self, env):
+ self.env = env
+
+ def __setitem__(self, item, val):
+ UserDict.__setitem__(self, item, val)
+ try:
+ self.env.Replace() # re-compute Builders
+ except AttributeError:
+ # Have to catch this because sometimes
+ # __setitem__ gets called out of __init__, when
+ # we don't have an env attribute yet, nor do
+ # we want one!
+ pass
+
+ def __delitem__(self, item):
+ UserDict.__delitem__(self, item)
+ self.env.Replace()
+
class Environment:
"""Base class for construction Environments. These are
the primary objects used to communicate dependency and
"""
apply(self.Replace, (), kw)
- def Replace(self, **kw):
- """Replace existing construction variables in an Environment
- with new construction variables and/or values.
- """
- self._dict.update(our_deepcopy(kw))
- if self._dict.has_key('BUILDERS') and \
- not SCons.Util.is_List(self._dict['BUILDERS']):
- self._dict['BUILDERS'] = [self._dict['BUILDERS']]
+ def __updateBuildersAndScanners(self):
+ """Update attributes for builders and scanners.
+
+ Have to be careful in this function...we can't
+ call functions like __setitem__() or Replace(), or
+ we will have infinite recursion."""
+
if self._dict.has_key('SCANNERS') and \
not SCons.Util.is_List(self._dict['SCANNERS']):
self._dict['SCANNERS'] = [self._dict['SCANNERS']]
kw['env'] = self.env
apply(self.builder.execute, (), kw)
- for b in self._dict['BUILDERS']:
- setattr(self, b.name, BuilderWrapper(self, b))
+ if self._dict.has_key('BUILDERS'):
+ if SCons.Util.is_Dict(self._dict['BUILDERS']):
+ bd = self._dict['BUILDERS']
+ if not isinstance(bd, BuilderDict):
+ # Convert it to a BuilderDict. This class
+ # Updates our builder attributes every time
+ # someone changes it.
+ bd = BuilderDict(bd)
+ bd.setEnvironment(self)
+ self._dict['BUILDERS'] = bd
+ for name, builder in bd.items():
+ setattr(self, name, BuilderWrapper(self, builder))
+ else:
+ SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning,
+ "The use of the BUILDERS Environment variable as a list or Builder instance is deprecated. BUILDERS should be a dictionary of name->Builder instead.")
+
+ if not SCons.Util.is_List(self._dict['BUILDERS']):
+ self._dict['BUILDERS'] = [self._dict['BUILDERS']]
+ for b in self._dict['BUILDERS']:
+ setattr(self, b.name, BuilderWrapper(self, b))
for s in self._dict['SCANNERS']:
setattr(self, s.name, s)
+
+
+ def Replace(self, **kw):
+ """Replace existing construction variables in an Environment
+ with new construction variables and/or values.
+ """
+ self._dict.update(our_deepcopy(kw))
+ self.__updateBuildersAndScanners()
def Append(self, **kw):
"""Append values to existing construction variables
self._dict[key] = [ self._dict[key] ] + kw[key]
else:
self._dict[key] = self._dict[key] + kw[key]
+ self.__updateBuildersAndScanners()
def Depends(self, target, dependency):
"""Explicity specify that 'target's depend on 'dependency'."""
def __setitem__(self, key, value):
self._dict[key] = value
+ self.__updateBuildersAndScanners()
def __getitem__(self, key):
return self._dict[key]
source files using the supplied action. Action may
be any type that the Builder constructor will accept
for an action."""
- bld = SCons.Builder.Builder(name="Command", action=action)
+ bld = SCons.Builder.Builder(action=action)
return bld(self, target, source)
def Install(self, dir, source):
import unittest
from SCons.Environment import *
-
+import SCons.Warnings
built_it = {}
b1 = Builder(name = 'builder1')
b2 = Builder(name = 'builder2')
+ # BUILDERS as a list or instance, now deprecated...
built_it = {}
env1 = Environment(BUILDERS = b1)
env1.builder1.execute(target = 'out1')
assert env4.builder1.env is env4
assert env4.builder2.env is env4
+ # Now test BUILDERS as a dictionary.
+ built_it = {}
+ env5 = Environment(BUILDERS={ 'foo' : b1 })
+ env5['BUILDERS']['bar'] = b2
+ env5.foo.execute(target='out1')
+ env5.bar.execute(target='out2')
+ assert built_it['out1']
+ assert built_it['out2']
+
+ built_it = {}
+ env6 = Environment()
+ env6['BUILDERS'] = { 'foo' : b1,
+ 'bar' : b2 }
+ env6.foo.execute(target='out1')
+ env6.bar.execute(target='out2')
+ assert built_it['out1']
+ assert built_it['out2']
+
+ # Now test deprecated warning for BUILDERS as a list
+ # or instance.
+
+ SCons.Warnings.enableWarningClass(SCons.Warnings.DeprecatedWarning)
+ SCons.Warnings.warningAsException(1)
+ try:
+ try:
+ env=Environment(BUILDERS=b1)
+ except SCons.Warnings.DeprecatedWarning:
+ pass
+ else:
+ assert 0
+
+ try:
+ env=Environment(BUILDERS=[b1, b2])
+ except SCons.Warnings.DeprecatedWarning:
+ pass
+ else:
+ assert 0
+ finally:
+ SCons.Warnings.suppressWarningClass(SCons.Warnings.DeprecatedWarning)
+ SCons.Warnings.warningAsException(0)
+
def test_Scanners(self):
"""Test Scanner execution through different environments
import SCons.Node.FS
import SCons.Scanner
import SCons.Util
+import SCons.Warnings
include_re = re.compile('^[ \t]*#[ \t]*include[ \t]+(<|")([\\w./\\\\]+)(>|")', re.M)
if not n is None:
nodes.append(n)
+ else:
+ SCons.Warnings.warn(SCons.Warnings.DependencyWarning,
+ "No dependency generated for file: %s (included from: %s) -- file not found" % (include[1], node))
node.found_includes[cpppath] = nodes
# Schwartzian transform from the Python FAQ Wizard
import os
import os.path
import SCons.Node.FS
+import SCons.Warnings
test = TestCmd.TestCmd(workdir = '')
class CScannerTestCase9(unittest.TestCase):
def runTest(self):
+ SCons.Warnings.enableWarningClass(SCons.Warnings.DependencyWarning)
+ class TestOut:
+ def __call__(self, x):
+ self.out = x
+
+ to = TestOut()
+ to.out = None
+ SCons.Warnings._warningOut = to
test.write('fa.h','\n')
fs = SCons.Node.FS.FS(test.workpath(''))
s = SCons.Scanner.C.CScan(fs=fs)
env = DummyEnvironment([])
deps = s.scan(fs.File('fa.cpp'), env, DummyTarget())
+
+ # Did we catch the warning associated with not finding fb.h?
+ assert to.out
+
deps_match(self, deps, [ 'fa.h' ])
test.unlink('fa.h')
from SCons.Taskmaster import Taskmaster
import SCons.Builder
import SCons.Script.SConscript
+import SCons.Warnings
#
def find_deepest_user_frame(tb):
"""
Find the deepest stack frame that is not part of SCons.
+
+ Input is a "pre-processed" stack trace in the form
+ returned by traceback.extract_tb() or traceback.extract_stack()
"""
- stack = [tb]
- while tb.tb_next is not None:
- tb = tb.tb_next
- stack.append(tb)
-
- stack.reverse()
+ tb.reverse()
# find the deepest traceback frame that is not part
# of SCons:
- for frame in stack:
- filename = frame.tb_frame.f_code.co_filename
+ for frame in tb:
+ filename = frame[0]
if string.find(filename, os.sep+'SCons'+os.sep) == -1:
- tb = frame
- break
-
- return tb
+ return frame
+ return tb[0]
def _scons_user_error(e):
"""Handle user errors. Print out a message and a description of the
not part of SCons itself.
"""
etype, value, tb = sys.exc_info()
- tb = find_deepest_user_frame(tb)
- lineno = traceback.tb_lineno(tb)
- filename = tb.tb_frame.f_code.co_filename
- routine = tb.tb_frame.f_code.co_name
+ filename, lineno, routine, dummy = find_deepest_user_frame(traceback.extract_tb(tb))
sys.stderr.write("\nSCons error: %s\n" % value)
sys.stderr.write('File "%s", line %d, in %s\n' % (filename, lineno, routine))
sys.exit(2)
not part of SCons itself.
"""
etype, value, tb = sys.exc_info()
- tb = find_deepest_user_frame(tb)
- lineno = traceback.tb_lineno(tb)
- filename = tb.tb_frame.f_code.co_filename
- routine = tb.tb_frame.f_code.co_name
+ filename, lineno, routine, dummy = find_deepest_user_frame(traceback.extract_tb(tb))
+ sys.stderr.write("\nSCons warning: %s\n" % e)
+ sys.stderr.write('File "%s", line %d, in %s\n' % (filename, lineno, routine))
+
+def _scons_internal_warning(e):
+ """Slightly different from _scons_user_warning in that we use the
+ *current call stack* rather than sys.exc_info() to get our stack trace.
+ This is used by the warnings framework to print warnings."""
+ filename, lineno, routine, dummy = find_deepest_user_frame(traceback.extract_stack())
sys.stderr.write("\nSCons warning: %s\n" % e)
sys.stderr.write('File "%s", line %d, in %s\n' % (filename, lineno, routine))
short = 'W', long = ['what-if', 'new-file', 'assume-new'], arg = 'FILE',
help = "Consider FILE to be changed.")
- Option(func = opt_not_yet, future = 1,
- long = ['warn-undefined-variables'],
- help = "Warn when an undefined variable is referenced.")
+ def opt_warn(opt, arg):
+ """The --warn option. An argument to this option
+ should be of the form <warning-class> or no-<warning-class>.
+ The warning class is munged in order to get an actual class
+ name from the SCons.Warnings module to enable or disable.
+ The supplied <warning-class> is split on hyphens, each element
+ is captialized, then smushed back together. Then the string
+ "SCons.Warnings." is added to the front and "Warning" is added
+ to the back to get the fully qualified class name.
+
+ For example, --warn=deprecated will enable the
+ SCons.Warnings.DeprecatedWarning class.
+
+ --warn=no-dependency will disable the
+ SCons.Warnings.DependencyWarning class.
+
+ As a special case, --warn=all and --warn=no-all
+ will enable or disable (respectively) the base
+ class of all warnings, which is SCons.Warning.Warning."""
+
+ elems = string.split(string.lower(arg), '-')
+ enable = 1
+ if elems[0] == 'no':
+ enable = 0
+ del elems[0]
+
+ if len(elems) == 1 and elems[0] == 'all':
+ class_name = "Warning"
+ else:
+ class_name = string.join(map(string.capitalize, elems), '') + \
+ "Warning"
+ try:
+ clazz = getattr(SCons.Warnings, class_name)
+ except AttributeError:
+ sys.stderr.write("No warning type: '%s'\n" % arg)
+ else:
+ if enable:
+ SCons.Warnings.enableWarningClass(clazz)
+ else:
+ SCons.Warnings.suppressWarningClass(clazz)
+
+ Option(func = opt_warn,
+ long = [ 'warn', 'warning' ], arg='WARNING-SPEC',
+ help = "Enable or disable warnings.")
+
+
+ # We want to preserve the --warn-undefined-variables option for
+ # compatibility with GNU Make. Unfortunately, this conflicts with
+ # the --warn=type option that we're using for our own warning
+ # control. The getopt module reports "--warn not a unique prefix"
+ # when both are defined. We may be able to support both in the
+ # future with a more robust getopt solution.
+ #
+ #Option(func = opt_not_yet, future = 1,
+ # long = ['warn-undefined-variables'],
+ # help = "Warn when an undefined variable is referenced.")
Option(func = opt_not_yet, future = 1,
short = 'Y', long = ['repository'], arg = 'REPOSITORY',
except:
getopt_err = getopt.error
+ # Enable deprecated warnings by default.
+ SCons.Warnings._warningOut = _scons_internal_warning
+ SCons.Warnings.enableWarningClass(SCons.Warnings.DeprecatedWarning)
+
try:
cmd_opts, t = getopt.getopt(string.split(os.environ['SCONSFLAGS']),
short_opts, long_opts)
--- /dev/null
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+"""SCons.Warnings
+
+This file implements the warnings framework for SCons.
+
+"""
+
+__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+
+import sys
+import copy
+import traceback
+
+import SCons.Errors
+
+class Warning(SCons.Errors.UserError):
+ pass
+
+class DeprecatedWarning(Warning):
+ pass
+
+class DependencyWarning(Warning):
+ pass
+
+_warningAsException = 0
+
+# The below is a list of 2-tuples. The first element is a class object.
+# The second element is true if that class is enabled, false if it is disabled.
+_enabled = []
+
+_warningOut = None
+
+def suppressWarningClass(clazz):
+ """Suppresses all warnings that are of type clazz or
+ derived from clazz."""
+ _enabled.insert(0, (clazz, 0))
+
+def enableWarningClass(clazz):
+ """Suppresses all warnings that are of type clazz or
+ derived from clazz."""
+ _enabled.insert(0, (clazz, 1))
+
+def warningAsException(flag=1):
+ global _warningAsException
+ _warningAsException = flag
+
+def warn(clazz, *args):
+ global _enabled, _warningAsException, _warningOut
+
+ warning = clazz(args)
+ for clazz, flag in _enabled:
+ if isinstance(warning, clazz):
+ if flag:
+ if _warningAsException:
+ raise warning
+
+ if _warningOut:
+ _warningOut(warning)
+ break
--- /dev/null
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+
+import sys
+import unittest
+import SCons.Warnings
+
+class TestOutput:
+ def __call__(self, x):
+ self.out = str(x)
+
+class WarningsTestCase(unittest.TestCase):
+ def test_Warning(self):
+ """Test warn function."""
+
+ # Reset global state
+ SCons.Warnings._enabled = []
+ SCons.Warnings._warningAsException = 0
+
+ to = TestOutput()
+ SCons.Warnings._warningOut=to
+ SCons.Warnings.enableWarningClass(SCons.Warnings.Warning)
+ SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning,
+ "Foo")
+ assert to.out == "Foo", to.out
+ SCons.Warnings.warn(SCons.Warnings.DependencyWarning,
+ "Foo", 1)
+ assert to.out == "('Foo', 1)", to.out
+
+ def test_WarningAsExc(self):
+ """Test warnings as exceptions."""
+
+ # Reset global state
+ SCons.Warnings._enabled = []
+ SCons.Warnings._warningAsException = 0
+
+ SCons.Warnings.enableWarningClass(SCons.Warnings.Warning)
+ SCons.Warnings.warningAsException()
+ try:
+ SCons.Warnings.warn(SCons.Warnings.Warning, "Foo")
+ except:
+ pass
+ else:
+ assert 0
+
+ SCons.Warnings.warningAsException(0)
+ SCons.Warnings.warn(SCons.Warnings.Warning, "Foo")
+
+ def test_Disable(self):
+ """Test disabling/enabling warnings."""
+
+ # Reset global state
+ SCons.Warnings._enabled = []
+ SCons.Warnings._warningAsException = 0
+
+ to = TestOutput()
+ SCons.Warnings._warningOut=to
+ to.out = None
+
+ # No warnings by default
+ SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning,
+ "Foo")
+ assert to.out is None, to.out
+
+ SCons.Warnings.enableWarningClass(SCons.Warnings.Warning)
+ SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning,
+ "Foo")
+ assert to.out == "Foo", to.out
+
+ to.out = None
+ SCons.Warnings.suppressWarningClass(SCons.Warnings.DeprecatedWarning)
+ SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning,
+ "Foo")
+ assert to.out is None, to.out
+
+ # Dependency warnings should still be enabled though
+ SCons.Warnings.enableWarningClass(SCons.Warnings.Warning)
+ SCons.Warnings.warn(SCons.Warnings.DependencyWarning,
+ "Foo")
+ assert to.out == "Foo", to.out
+
+ # Try reenabling all warnings...
+ SCons.Warnings.enableWarningClass(SCons.Warnings.Warning)
+
+ SCons.Warnings.enableWarningClass(SCons.Warnings.Warning)
+ SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning,
+ "Foo")
+ assert to.out == "Foo", to.out
+
+if __name__ == "__main__":
+ suite = unittest.makeSuite(WarningsTestCase, 'test_')
+ if not unittest.TextTestRunner().run(suite).wasSuccessful():
+ sys.exit(1)
""")
test.write('SConstruct', """
-B = Builder(name = "B", action = r"%s build.py $TARGET $SOURCES")
-builders = Environment().Dictionary('BUILDERS')
-env = Environment(BUILDERS = builders + [ B ])
+B = Builder(action = r"%s build.py $TARGET $SOURCES")
+env = Environment()
+env['BUILDERS']['B'] = B
env.B(target = 'f1.out', source = 'f1.in')
env.B(target = 'f2.out', source = 'f2.in')
env.B(target = 'f3.out', source = 'f3.in')
return [[python, "build.py", "$TEMPFILE"] + source,
[python, "build.py"] + target + ["$TEMPFILE"]]
-b = Builder(name = 'b', generator=g)
-env = Environment(BUILDERS = [b],
+b = Builder(generator=g)
+env = Environment(BUILDERS = { 'b' : b },
TEMPFILE=".temp")
env.b(target = 'foo1.out', source = 'foo1.in')
env.b(target = 'foo2.out', source = 'foo2.in')
""")
test.write(['one', 'SConstruct'], """
-B = Builder(name = 'B', action = r'%s ../build.py $TARGET $SOURCES')
-env = Environment(BUILDERS = [B])
+B = Builder(action = r'%s ../build.py $TARGET $SOURCES')
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'foo.out', source = 'foo.in')
env.B(target = 'bar.out', source = 'bar.in')
Default('foo.out')
""" % python)
test.write(['two', 'SConstruct'], """
-B = Builder(name = 'B', action = r'%s ../build.py $TARGET $SOURCES')
-env = Environment(BUILDERS = [B])
+B = Builder(action = r'%s ../build.py $TARGET $SOURCES')
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'foo.out', source = 'foo.in')
env.B(target = 'bar.out', source = 'bar.in')
Default('foo.out', 'bar.out')
""" % python)
test.write(['three', 'SConstruct'], """
-B = Builder(name = 'B', action = r'%s ../build.py $TARGET $SOURCES')
-env = Environment(BUILDERS = [B])
+B = Builder(action = r'%s ../build.py $TARGET $SOURCES')
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'foo.out', source = 'foo.in')
env.B(target = 'bar.out', source = 'bar.in')
Default('foo.out bar.out')
""" % python)
test.write(['four', 'SConstruct'], """
-B = Builder(name = 'B', action = r'%s ../build.py $TARGET $SOURCES')
-env = Environment(BUILDERS = [B])
+B = Builder(action = r'%s ../build.py $TARGET $SOURCES')
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = ['foo bar'], source = 'foo.in')
env.B(target = 'foo', source = 'foo.in')
env.B(target = 'bar', source = 'bar.in')
""" % python)
test.write(['five', 'SConstruct'], """
-B = Builder(name = 'B', action = r'%s ../build.py $TARGET $SOURCES')
-env = Environment(BUILDERS = [B])
+B = Builder(action = r'%s ../build.py $TARGET $SOURCES')
+env = Environment(BUILDERS = { 'B' : B })
Default(env.B(target = 'foo.out', source = 'foo.in'))
Default(env.B(target = 'bar.out', source = 'bar.in'))
""" % python)
test.subdir('sub1')
test.write('SConstruct', """
-B = Builder(name = 'B', action = r'%s build.py $TARGET $SOURCES')
-env = Environment(BUILDERS = [B])
+B = Builder(action = r'%s build.py $TARGET $SOURCES')
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'xxx.out', source = 'xxx.in')
SConscript('sub1/SConscript')
""" % python)
test.write('xxx.in', "xxx.in\n")
test.write(['sub1', 'SConscript'], """
-B = Builder(name = 'B', action = r'%s build.py $TARGET $SOURCES')
-env = Environment(BUILDERS = [B])
+B = Builder(action = r'%s build.py $TARGET $SOURCES')
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'xxx.out', source = 'xxx.in')
Default('xxx.out')
""" % python)
test.write('SConstruct', """
Default('sub2')
-B = Builder(name = 'B', action = r'%s build.py $TARGET $SOURCES')
-env = Environment(BUILDERS = [B])
+B = Builder(action = r'%s build.py $TARGET $SOURCES')
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'xxx.out', source = 'xxx.in')
SConscript('sub2/SConscript')
""" % python)
test.write('xxx.in', "xxx.in\n")
test.write(['sub2', 'SConscript'], """
-B = Builder(name = 'B', action = r'%s build.py $TARGET $SOURCES')
-env = Environment(BUILDERS = [B])
+B = Builder(action = r'%s build.py $TARGET $SOURCES')
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'xxx.out', source = 'xxx.in')
""" % python)
""")
test.write('SConstruct', """
-Foo = Builder(name = "Foo",
- action = r"%s build.py $TARGET $SOURCES subdir/foo.dep")
-Bar = Builder(name = "Bar",
- action = r"%s build.py $TARGET $SOURCES subdir/bar.dep")
-env = Environment(BUILDERS = [Foo, Bar])
+Foo = Builder(action = r"%s build.py $TARGET $SOURCES subdir/foo.dep")
+Bar = Builder(action = r"%s build.py $TARGET $SOURCES subdir/bar.dep")
+env = Environment(BUILDERS = { 'Foo' : Foo, 'Bar' : Bar })
env.Depends(target = ['f1.out', 'f2.out'], dependency = 'subdir/foo.dep')
env.Depends(target = 'f3.out', dependency = 'subdir/bar.dep')
env.Foo(target = 'f1.out', source = 'f1.in')
test.write('SConstruct', """
import os
-Bld = Builder(name = 'Bld', action = r"%s build.py $TARGET $SOURCES")
-env1 = Environment(ENV = {'X' : 'env1'}, BUILDERS = [Bld])
-env2 = Environment(ENV = {'X' : 'env2'}, BUILDERS = [Bld])
+Bld = Builder(action = r"%s build.py $TARGET $SOURCES")
+env1 = Environment(ENV = {'X' : 'env1'}, BUILDERS = { 'Bld' : Bld })
+env2 = Environment(ENV = {'X' : 'env2'}, BUILDERS = { 'Bld' : Bld })
env1.Bld(target = 'env1.out', source = 'input')
env2.Bld(target = 'env2.out', source = 'input')
""" % python)
""")
test.write('SConstruct', """
-Foo = Builder(name = "Foo",
- action = r"%s build.py $TARGET $SOURCES")
-Bar = Builder(name = "Bar",
- action = r"%s build.py $TARGET $SOURCES")
-env = Environment(BUILDERS = [Foo, Bar])
+Foo = Builder(action = r"%s build.py $TARGET $SOURCES")
+Bar = Builder(action = r"%s build.py $TARGET $SOURCES")
+env = Environment(BUILDERS = { 'Foo' : Foo, 'Bar' : Bar })
env.Foo(target = 'f1.out', source = ['f1a.in', 'f1b.in'])
env.Ignore(target = 'f1.out', dependency = 'f1b.in')
SConscript('subdir/SConscript', "env")
""")
test.write('SConstruct', """
-B = Builder(name = "B", action = r"%s build.py $TARGET $SOURCES")
-env = Environment(BUILDERS = [B])
+B = Builder(action = r"%s build.py $TARGET $SOURCES")
+env = Environment(BUILDERS = { 'B' : B })
f1 = env.B(target = 'f1.out', source = 'f1.in')
env.B(target = 'f2.out', source = 'f2.in')
env.B(target = 'f3.out', source = 'f3.in')
test.write('SConscript5', """
-B = Builder(name = 'B', action = 'B')
+B = Builder(action = 'B')
def scan():
pass
-S = Scanner(name = 'S', function = scan)
+S = Scanner(function = scan)
A = Action("A")
""")
stdout = "f1.c\nf2a.c\nf2b.c\nf2c.c\nf3a.c\nf3b.c\nf3c.c\nprog.c\n")
test.run(arguments = '-f SConstructFoo', status=2, stderr='''
-SCons error: Source file: foo\..* must be built with shared=1 in order to be compatible with the selected target.
+SCons error: Source file: foo\..* must be built with shared=1 in order to be compatible with target: .*
File ".*", line .*, in .*
'''
)
""")
test.write('SConstruct', """
-B = Builder(name = 'B', action = r'%s build.py $TARGET 1 $SOURCES')
-env = Environment(BUILDERS = [B])
+B = Builder(action = r'%s build.py $TARGET 1 $SOURCES')
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'foo.out', source = 'foo.in')
""" % python)
test.up_to_date(arguments = '.')
test.write('SConstruct', """
-B = Builder(name = 'B', action = r'%s build.py $TARGET 2 $SOURCES')
-env = Environment(BUILDERS = [B])
+B = Builder(action = r'%s build.py $TARGET 2 $SOURCES')
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'foo.out', source = 'foo.in')
""" % python)
string.join(map(str, source)))
print cmd
return os.system(cmd)
-B = Builder(name = 'B', action = func)
-env = Environment(BUILDERS = [B])
+B = Builder(action = func)
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'foo.out', source = 'foo.in')
""" % python)
def get_contents(self, env, target, source):
return self.cmd %% (string.join(map(str, target)),
string.join(map(str, source)))
-B = Builder(name = 'B', action = bld())
-env = Environment(BUILDERS = [B])
+B = Builder(action = bld())
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'foo.out', source = 'foo.in')
""" % python)
test.write("f3.in", "\n")
test.write('SConstruct1', r"""
-bld = Builder(name = 'bld', action = '%s $SOURCES $TARGET')
-env = Environment(BUILDERS = [bld])
+bld = Builder(action = '%s $SOURCES $TARGET')
+env = Environment(BUILDERS = { 'bld' : bld })
env.bld(target = 'f1', source = 'f1.in')
""" % string.replace(no_such_file, '\\', '\\\\'))
test.write('SConstruct2', r"""
-bld = Builder(name = 'bld', action = '%s $SOURCES $TARGET')
-env = Environment(BUILDERS = [bld])
+bld = Builder(action = '%s $SOURCES $TARGET')
+env = Environment(BUILDERS = { 'bld': bld })
env.bld(target = 'f2', source = 'f2.in')
""" % string.replace(not_executable, '\\', '\\\\'))
""" % not_executable)
test.write('SConstruct3', r"""
-bld = Builder(name = 'bld', action = '%s $SOURCES $TARGET')
-env = Environment(BUILDERS = [bld])
+bld = Builder(action = '%s $SOURCES $TARGET')
+env = Environment(BUILDERS = { 'bld' : bld })
env.bld(target = 'f3', source = 'f3.in')
""" % string.replace(test.workdir, '\\', '\\\\'))
""")
test.write(['one', 'SConstruct'], """
-B0 = Builder(name = 'B0', action = r'%s ../build.py 0 $TARGET $SOURCES')
-B1 = Builder(name = 'B1', action = r'%s ../build.py 1 $TARGET $SOURCES')
-env = Environment(BUILDERS = [B0, B1])
+B0 = Builder(action = r'%s ../build.py 0 $TARGET $SOURCES')
+B1 = Builder(action = r'%s ../build.py 1 $TARGET $SOURCES')
+env = Environment(BUILDERS = { 'B0' : B0, 'B1' : B1 })
env.B1(target = 'f1.out', source = 'f1.in')
env.B0(target = 'f2.out', source = 'f2.in')
env.B0(target = 'f3.out', source = 'f3.in')
test.fail_test(os.path.exists(test.workpath('f3.out')))
test.write(['two', 'SConstruct'], """
-B0 = Builder(name = 'B0', action = r'%s ../build.py 0 $TARGET $SOURCES')
-B1 = Builder(name = 'B1', action = r'%s ../build.py 1 $TARGET $SOURCES')
-env = Environment(BUILDERS = [B0, B1])
+B0 = Builder(action = r'%s ../build.py 0 $TARGET $SOURCES')
+B1 = Builder(action = r'%s ../build.py 1 $TARGET $SOURCES')
+env = Environment(BUILDERS = { 'B0': B0, 'B1' : B1 })
env.B0(target = 'f1.out', source = 'f1.in')
env.B1(target = 'f2.out', source = 'f2.in')
env.B0(target = 'f3.out', source = 'f3.in')
test.fail_test(os.path.exists(test.workpath('f3.out')))
test.write(['three', 'SConstruct'], """
-B0 = Builder(name = 'B0', action = r'%s ../build.py 0 $TARGET $SOURCES')
-B1 = Builder(name = 'B1', action = r'%s ../build.py 1 $TARGET $SOURCES')
-env = Environment(BUILDERS = [B0, B1])
+B0 = Builder(action = r'%s ../build.py 0 $TARGET $SOURCES')
+B1 = Builder(action = r'%s ../build.py 1 $TARGET $SOURCES')
+env = Environment(BUILDERS = { 'B0' : B0, 'B1': B1 })
env.B0(target = 'f1.out', source = 'f1.in')
env.B0(target = 'f2.out', source = 'f2.in')
env.B1(target = 'f3.out', source = 'f3.in')
open(str(target[0]), 'wt').write(open(str(source[0]), 'rt').read())
print "built %s"%target[0]
-env=Environment(BUILDERS=[Builder(name='B', action=build)])
+env=Environment(BUILDERS={'B' : Builder(action=build)})
env.B('foo.mid', 'foo.in')
""")
open(str(target[0]), 'wt').write(open(str(source[0]), 'rt').read())
print "built %s"%target[0]
-env=Environment(BUILDERS=[Builder(name='B', action=build)])
+env=Environment(BUILDERS={'B' : Builder(action=build)})
env.B('foo.out', 'foo.mid')
""")
target.append(str(target[0])+".foo")
return target,source
-b = Builder(name='foo', action=build, emitter=emitter)
+b = Builder(action=build, emitter=emitter)
-env=Environment(BUILDERS=[b])
+env=Environment(BUILDERS={ 'foo': b })
env.foo('f.out', 'f.in')
""")
def exit(env, target, source):
raise 'exit'
-env = Environment(BUILDERS = [Builder(name='foo', action=foo),
- Builder(name='exit', action=exit)])
+env = Environment(BUILDERS = { 'foo' : Builder(action=foo),
+ 'exit' : Builder(action=exit) })
env.foo('foo.out', 'foo.in')
env.exit('exit.out', 'exit.in')
test.write('SConstruct', """
def func(source = None, target = None, env = None):
raise "func exception"
-B = Builder(name = 'B', action = func)
-env = Environment(BUILDERS = [B])
+B = Builder(action = func)
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'foo.out', source = 'foo.in')
""")
for s in source:
file.write(open(str(s), 'rb').read())
-B = Builder(name='B', action=build, multi=1)
-env = Environment(BUILDERS = [B])
+B = Builder(action=build, multi=1)
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'foo.out', source = 'foo.in')
env.B(target = 'foo.out', source = 'bar.in')
""")
for s in source:
file.write(open(str(s), 'rb').read())
-B = Builder(name='B', action=build, multi=0)
-env = Environment(BUILDERS = [B])
+B = Builder(action=build, multi=0)
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'foo.out', source = 'foo.in')
env.B(target = 'foo.out', source = 'bar.in')
""")
for s in source:
file.write(open(str(s), 'rb').read())
-B = Builder(name='B', action=build, multi=1)
-env = Environment(BUILDERS = [B])
+B = Builder(action=build, multi=1)
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'foo.out', source = 'foo.in', foo=1)
env.B(target = 'foo.out', source = 'bar.in', foo=2)
""")
for s in source:
file.write(open(str(s), 'rb').read())
-B = Builder(name='B', action=build, multi=1)
-env = Environment(BUILDERS = [B])
+B = Builder(action=build, multi=1)
+env = Environment(BUILDERS = { 'B' : B })
env2 = env.Copy(CCFLAGS='foo')
env.B(target = 'foo.out', source = 'foo.in')
env2.B(target = 'foo.out', source = 'bar.in')
for s in source:
file.write(open(str(s), 'rb').read())
-B = Builder(name='B', action=build, multi=0)
-env = Environment(BUILDERS = [B])
+B = Builder(action=build, multi=0)
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'foo.out', source = 'foo.in')
env.B(target = 'foo.out', source = 'foo.in')
""")
for s in source:
file.write(open(str(s), 'rb').read())
-B = Builder(name='B', action=build, multi=1)
-C = Builder(name='C', action=build, multi=1)
-env = Environment(BUILDERS = [B,C])
+def build2(env, target, source):
+ build(env, target, source)
+
+B = Builder(action=build, multi=1)
+C = Builder(action=build2, multi=1)
+env = Environment(BUILDERS = { 'B' : B, 'C' : C })
env.B(target = 'foo.out', source = 'foo.in')
env.C(target = 'foo.out', source = 'bar.in')
""")
status=2,
stderr="""
SCons error: Two different builders (B and C) were specified for the same target: foo.out
-File "SConstruct", line 11, in ?
+File "SConstruct", line 14, in ?
""")
test.write('SConstruct', """
for s in source:
file.write(open(str(s), 'rb').read())
-B = Builder(name='B', action=build, multi=1)
-env = Environment(BUILDERS = [B])
+B = Builder(action=build, multi=1)
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = ['foo.out', 'bar.out'], source = 'foo.in')
env.B(target = ['foo.out', 'bar.out'], source = 'bar.in')
""")
for s in source:
file.write(open(str(s), 'rb').read())
-B = Builder(name='B', action=build, multi=1)
-env = Environment(BUILDERS = [B])
+B = Builder(action=build, multi=1)
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = ['foo.out', 'bar.out'], source = 'foo.in')
env.B(target = ['bar.out', 'foo.out'], source = 'bar.in')
""")
for s in source:
file.write(open(str(s), 'rb').read())
-B = Builder(name='B', action=build, multi=1)
-env = Environment(BUILDERS = [B])
+B = Builder(action=build, multi=1)
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = ['foo.out', 'bar.out'], source = 'foo.in')
env.B(target = ['bar.out', 'blat.out'], source = 'bar.in')
""")
for s in source:
file.write(open(str(s), 'rb').read())
-B = Builder(name='B', action=build, multi=1)
-env = Environment(BUILDERS = [B])
+B = Builder(action=build, multi=1)
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = ['foo.out', 'bar.out'], source = 'foo.in')
env.B(target = 'foo.out', source = 'bar.in')
""")
""")
test.write('SConstruct', """
-B1 = Builder(name = 'B1', action = [ [ r'%s', 'build.py', '.temp', '$SOURCES' ],
- [ r'%s', 'build.py', '$TARGETS', '.temp'] ])
-B2 = Builder(name = 'B2', action = r'%s' + " build.py .temp $SOURCES\\n" + r'%s' + " build.py $TARGETS .temp")
-env = Environment(BUILDERS = [B1, B2])
+B1 = Builder(action = [ [ r'%s', 'build.py', '.temp', '$SOURCES' ],
+ [ r'%s', 'build.py', '$TARGETS', '.temp'] ])
+B2 = Builder(action = r'%s' + " build.py .temp $SOURCES\\n" + r'%s' + " build.py $TARGETS .temp")
+env = Environment(BUILDERS = { 'B1' : B1, 'B2' : B2 })
env.B1(target = 'foo1.out', source = 'foo1.in')
env.B2(target = 'foo2.out', source = 'foo2.in')
env.B1(target = 'foo3.out', source = 'foo3.in')
""")
test.write('SConstruct', """
-MyBuild = Builder(name = "MyBuild",
- action = r'%s build.py $TARGETS')
-env = Environment(BUILDERS = [MyBuild])
+MyBuild = Builder(action = r'%s build.py $TARGETS')
+env = Environment(BUILDERS = { 'MyBuild' : MyBuild })
env.MyBuild(target = '-f1.out', source = 'f1.in')
env.MyBuild(target = '-f2.out', source = 'f2.in')
""" % python)
test.write('SConstruct', """
import SCons.Defaults
-B = Builder(name='B', action='%s build.py $TARGET $SOURCES')
-env = Environment(BUILDERS = [B, SCons.Defaults.Alias])
+B = Builder(action='%s build.py $TARGET $SOURCES')
+env = Environment()
+env['BUILDERS']['B'] = B
env.B(target = 'sub1/foo.out', source = 'sub1/foo.in')
Export('env')
SConscript('sub1/SConscript')
test.write('SConstruct', """
import SCons.Defaults
-B = Builder(name='B', action='%s build.py $TARGET $SOURCES', multi=1)
-env = Environment(BUILDERS = [B, SCons.Defaults.Alias])
+env = Environment()
+env['BUILDERS']['B'] = Builder(action='%s build.py $TARGET $SOURCES', multi=1)
Default(env.B(target = 'sub1/foo.out', source = 'sub1/foo.in'))
Export('env')
SConscript('sub2/SConscript')
""")
test.write('SConstruct', """
-B = Builder(name = "B", action = r'%s build.py $TARGETS $SOURCES')
-env = Environment(BUILDERS = [B])
+B = Builder(action = r'%s build.py $TARGETS $SOURCES')
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'f1.out', source = 'f1.in')
env.B(target = 'f2.out', source = 'f2.in')
""" % python)
--- /dev/null
+#!/usr/bin/env python
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+
+import os.path
+import sys
+
+import TestSCons
+import TestCmd
+
+test = TestSCons.TestSCons(match = TestCmd.match_re_dotall)
+
+test.write("SConstruct","""
+b=Builder(name='b', action='foo')
+""")
+
+test.run(arguments='', stderr=r"""
+SCons warning: The use of the 'name' parameter to Builder\(\) is deprecated\.
+File "SConstruct", line 2, in \?
+""")
+
+test.run(arguments='--warn=no-deprecated', stderr='')
+
+test.run(arguments='--warn=no-all', stderr='')
+
+test.run(arguments='--warn=no-all --warn=deprecated', stderr=r"""
+SCons warning: The use of the 'name' parameter to Builder\(\) is deprecated\.
+File "SConstruct", line 2, in \?
+""")
+
+test.write("SConstruct","""
+def build(target, source, env):
+ pass
+
+env=Environment()
+env['BUILDERS']['test'] = Builder(action=build)
+env.test(target='foo', source='foo.c')
+""")
+
+test.write("foo.c","""
+#include "not_there.h"
+""")
+
+test.run(arguments='--warn=dependency .', stderr=r"""
+SCons warning: No dependency generated for file: not_there\.h \(included from: foo\.c\) \-\- file not found
+File ".+", line \d+, in .+
+""")
+
+test.run(arguments='--warn=all .', stderr=r"""
+SCons warning: No dependency generated for file: not_there\.h \(included from: foo\.c\) \-\- file not found
+File ".+", line \d+, in .+
+""")
+
+test.run(arguments='--warn=all --warn=no-dependency .', stderr="")
+
+test.run(arguments='--warn=no-dependency --warn=all .', stderr=r"""
+SCons warning: No dependency generated for file: not_there\.h \(included from: foo\.c\) \-\- file not found
+File ".+", line \d+, in .+
+""")
+
+test.pass_test()
test = TestSCons.TestSCons()
+# We want to preserve the --warn-undefined-variables option for
+# compatibility with GNU Make. Unfortunately, this conflicts with
+# the --warn=type option that we're using for our own warning
+# control. The getopt module reports "--warn not a unique prefix"
+# when both are defined. We may be able to support both in the
+# future with a more robust getopt solution.
+test.pass_test() #XXX Short-circuit until then.
+
test.write('SConstruct', "")
test.run(arguments = '--warn-undefined-variables',
""")
test.write('SConstruct', """
-B = Builder(name = 'B', action = r'%s build.py $TARGETS $SOURCES')
-env = Environment(BUILDERS = [B])
+B = Builder(action = r'%s build.py $TARGETS $SOURCES')
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'foo1.out', source = 'foo1.in')
env.B(target = 'foo2.out', source = 'foo2.xxx')
env.B(target = 'foo2.xxx', source = 'foo2.in')
""")
test.write('SConstruct', """
-Succeed = Builder(name = "Succeed", action = r'%s succeed.py $TARGETS')
-Fail = Builder(name = "Fail", action = r'%s fail.py $TARGETS')
-env = Environment(BUILDERS = [Succeed, Fail])
+Succeed = Builder(action = r'%s succeed.py $TARGETS')
+Fail = Builder(action = r'%s fail.py $TARGETS')
+env = Environment(BUILDERS = { 'Succeed' : Succeed, 'Fail' : Fail })
env.Fail(target = 'aaa.1', source = 'aaa.in')
env.Succeed(target = 'aaa.out', source = 'aaa.1')
env.Fail(target = 'bbb.1', source = 'bbb.in')
""")
test.write('SConstruct', """
-MyBuild = Builder(name = "MyBuild",
- action = r'%s build.py $TARGETS')
-env = Environment(BUILDERS = [MyBuild])
+MyBuild = Builder(action = r'%s build.py $TARGETS')
+env = Environment(BUILDERS = { 'MyBuild' : MyBuild })
env.MyBuild(target = 'f1', source = 'f1.in')
env.MyBuild(target = 'f2', source = 'f2.in')
""" % python)
""")
test.write('SConstruct', """
-Succeed = Builder(name = "Succeed", action = r'%s succeed.py $TARGETS')
-Fail = Builder(name = "Fail", action = r'%s fail.py $TARGETS')
-env = Environment(BUILDERS = [Succeed, Fail])
+Succeed = Builder(action = r'%s succeed.py $TARGETS')
+Fail = Builder(action = r'%s fail.py $TARGETS')
+env = Environment(BUILDERS = { 'Succeed' : Succeed, 'Fail' : Fail })
env.Fail(target = 'aaa.1', source = 'aaa.in')
env.Succeed(target = 'aaa.out', source = 'aaa.1')
env.Succeed(target = 'bbb.out', source = 'bbb.in')
""")
test.write('SConstruct', """
-MyBuild = Builder(name = "MyBuild",
- action = r'%s build.py $TARGETS')
-env = Environment(BUILDERS = [MyBuild])
+MyBuild = Builder(action = r'%s build.py $TARGETS')
+env = Environment(BUILDERS = { 'MyBuild' : MyBuild })
env.MyBuild(target = 'f1.out', source = 'f1.in')
env.MyBuild(target = 'f2.out', source = 'f2.in')
""" % python)
""")
test.write('SConstruct', """
-B = Builder(name='B', action='%s build.py $TARGET $SOURCES')
-env = Environment(BUILDERS = [B])
+B = Builder(action='%s build.py $TARGET $SOURCES')
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'aaa.out', source = 'aaa.in')
env.B(target = 'bbb.out', source = 'bbb.in')
""" % python)
""")
test.write('SConstruct', """
-MyBuild = Builder(name = "MyBuild",
- action = r'%s build.py $TARGET')
-env = Environment(BUILDERS = [MyBuild])
+MyBuild = Builder(action = r'%s build.py $TARGET')
+env = Environment(BUILDERS = { 'MyBuild' : MyBuild })
env.MyBuild(target = 'f1.out', source = 'f1.in')
env.MyBuild(target = 'f2.out', source = 'f2.in')
""" % python)
test.write('SConstruct', """
import SCons.Defaults
-B = Builder(name='B', action='%s build.py $TARGET $SOURCES')
-env = Environment(BUILDERS = [B, SCons.Defaults.Alias])
+env = Environment()
+env['BUILDERS']['B'] = Builder(action='%s build.py $TARGET $SOURCES')
env.B(target = 'sub1/foo.out', source = 'sub1/foo.in')
Default('.')
Export('env')
os.chmod(dir, 0555)
return None
-B1 = Builder(name = "B1", action = build1)
-B2 = Builder(name = "B2", action = build2)
-env = Environment(BUILDERS = [B1, B2])
+B1 = Builder(action = build1)
+B2 = Builder(action = build2)
+env = Environment(BUILDERS = { 'B1' : B1, 'B2' : B2 })
env.B1(target = 'sub1/foo.out', source = 'foo.in')
env.B2(target = 'sub2/foo.out', source = 'foo.in')
env.B2(target = 'sub3/foo.out', source = 'foo.in')
""")
test.write('SConstruct', """
-B = Builder(name = "B", action = "python build.py $TARGETS $SOURCES")
-env = Environment(BUILDERS = [B])
+B = Builder(action = "python build.py $TARGETS $SOURCES")
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'subdir/f1.out', source = 'subdir/f1.in')
env.B(target = 'subdir/f2.out', source = 'subdir/f2.in')
env.B(target = 'subdir/f3.out', source = 'subdir/f3.in')
test.write('SConstruct', """
def build(env, target, source):
open(str(target[0]), 'wt').write(open(str(source[0]), 'rt').read())
-B = Builder(name = 'B', action = build)
-env = Environment(BUILDERS = [B])
+B = Builder(action = build)
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'f1.out', source = 'f1.in')
env.B(target = 'f2.out', source = 'f2.in')
env.B(target = 'f3.out', source = 'f3.in')
""")
test.write('SConstruct', """
-B = Builder(name = "B", action = r'%s build.py $TARGETS $SOURCES')
-env = Environment(BUILDERS = [B])
+B = Builder(action = r'%s build.py $TARGETS $SOURCES')
+env = Environment(BUILDERS = { 'B' : B })
env.B(target = 'f1.out', source = 'f1.in')
env.B(target = 'f2.out', source = 'f2.in')
env.B(target = 'f3.out', source = 'f3.in')
projects / scons.git / commitdiff