Raise an error if a builder is called multiple times for a given target, unless the builder is marked as multicall safe. (Anthony Roach)

4 files changed, 86 insertions, 36 deletions

diff --git a/src/engine/SCons/Builder.py b/src/engine/SCons/Builder.py
index a28a31d..d73917c 100644
--- a/src/engine/SCons/Builder.py
+++ b/src/engine/SCons/Builder.py
@@ -99,18 +99,37 @@ def Builder(**kw):
     else:
         return apply(BuilderBase, (), kw)
 
-def _init_nodes(builder, env, tlist, slist):
+def _init_nodes(builder, env, args, tlist, slist):
     """Initialize lists of target and source nodes with all of
     the proper Builder information.
     """
+
     for s in slist:
         src_key = s.scanner_key()        # the file suffix
         scanner = env.get_scanner(src_key)
         if scanner:
             s.source_scanner = scanner
-            
+
     for t in tlist:
-        t.cwd = SCons.Node.FS.default_fs.getcwd()       # XXX
+        if t.builder is not None:
+            if t.env != env: 
+                raise UserError, "Two different environments were specified for the same target: %s"%str(t)
+            elif t.build_args != args:
+                raise UserError, "Two different sets of build arguments were specified for the same target: %s"%str(t)
+            elif builder.scanner and builder.scanner != t.target_scanner:
+                raise UserError, "Two different scanners were specified for the same target: %s"%str(t)
+
+            if builder.multi:
+                if t.builder != builder:
+                    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))
+            elif t.sources != slist:
+                raise UserError, "Multiple ways to build the same target were specified for: %s" % str(t)
+
+        t.build_args = args
+        t.cwd = SCons.Node.FS.default_fs.getcwd()
         t.builder_set(builder)
         t.env_set(env)
         t.add_source(slist)
@@ -181,11 +200,13 @@ class BuilderBase:
                         target_factory = None,
                         source_factory = None,
                         scanner = None,
-                        emitter = 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
 
         if callable(prefix):
             self.prefix = prefix
@@ -262,18 +283,16 @@ class BuilderBase:
                                                     src_suf),
                                          self.source_factory)
             
-        for t in tlist:
-            t.build_args = args
-        return tlist, slist
+	return tlist, slist
 
     def __call__(self, env, target = None, source = None, **kw):
         tlist, slist = self._create_nodes(env, kw, target, source)
 
         if len(tlist) == 1:
-            _init_nodes(self, env, tlist, slist)
+            _init_nodes(self, env, kw, tlist, slist)
             tlist = tlist[0]
         else:
-            _init_nodes(ListBuilder(self, env, tlist), env, tlist, slist)
+            _init_nodes(ListBuilder(self, env, tlist), env, kw, tlist, slist)
 
         return tlist
 
@@ -330,7 +349,9 @@ class ListBuilder:
         self.builder = builder
         self.scanner = builder.scanner
         self.env = env
-        self.tlist = tlist
+	self.tlist = tlist
+        self.multi = builder.multi
+        self.name = "ListBuilder(%s)"%builder.name
 
     def execute(self, **kw):
         if hasattr(self, 'status'):
@@ -360,6 +381,9 @@ class ListBuilder:
         """
         return self.tlist
 
+    def __cmp__(self, other):
+	return cmp(self.__dict__, other.__dict__)
+
 class MultiStepBuilder(BuilderBase):
     """This is a builder subclass that can build targets in
     multiple steps.  The src_builder parameter to the constructor
diff --git a/src/engine/SCons/BuilderTests.py b/src/engine/SCons/BuilderTests.py
index 12178ed..d7fd92d 100644
--- a/src/engine/SCons/BuilderTests.py
+++ b/src/engine/SCons/BuilderTests.py
@@ -38,6 +38,7 @@ import unittest
 import TestCmd
 import SCons.Builder
 import SCons.Errors
+import SCons.Node.FS
 
 # Initial setup of the common environment for all tests,
 # a temporary working directory containing a
@@ -680,7 +681,7 @@ class BuilderTestCase(unittest.TestCase):
             pass
         scn = TestScanner()
         builder = SCons.Builder.Builder(name = "builder", scanner=scn)
-        tgt = builder(env, target='foo', source='bar')
+        tgt = builder(env, target='foo2', source='bar')
         assert tgt.target_scanner == scn, tgt.target_scanner
 
         builder1 = SCons.Builder.Builder(name = "builder1",
@@ -691,7 +692,7 @@ class BuilderTestCase(unittest.TestCase):
                                          action='foo',
                                          src_builder = builder1,
                                          scanner = scn)
-        tgt = builder2(env, target='baz', source='test.bar test2.foo test3.txt')
+        tgt = builder2(env, target='baz2', source='test.bar test2.foo test3.txt')
         assert tgt.target_scanner == scn, tgt.target_scanner
 
     def test_src_scanner(slf):
@@ -725,45 +726,45 @@ class BuilderTestCase(unittest.TestCase):
         """Test emitter functions."""
         def emit(target, source, env, foo=0, bar=0):
             if foo:
-                target.append("bar")
+                target.append("bar%d"%foo)
             if bar:
-                source.append("foo")
+                source.append("baz")
             return ( target, source )
 
         builder = SCons.Builder.Builder(name="builder", action='foo',
                                         emitter=emit)
-        tgt = builder(env, target='foo', source='bar')
-        assert str(tgt) == 'foo', str(tgt)
+        tgt = builder(env, target='foo2', source='bar')
+        assert str(tgt) == 'foo2', str(tgt)
         assert str(tgt.sources[0]) == 'bar', str(tgt.sources[0])
 
-        tgt = builder(env, target='foo', source='bar', foo=1)
+        tgt = builder(env, target='foo3', source='bar', foo=1)
         assert len(tgt) == 2, len(tgt)
-        assert 'foo' in map(str, tgt), map(str, tgt)
-        assert 'bar' in map(str, tgt), map(str, tgt)
+        assert 'foo3' in map(str, tgt), map(str, tgt)
+        assert 'bar1' in map(str, tgt), map(str, tgt)
 
-        tgt = builder(env, target='foo', source='bar', bar=1)
-        assert str(tgt) == 'foo', str(tgt)
+        tgt = builder(env, target='foo4', source='bar', bar=1)
+        assert str(tgt) == 'foo4', str(tgt)
         assert len(tgt.sources) == 2, len(tgt.sources)
-        assert 'foo' in map(str, tgt.sources), map(str, tgt.sources)
+        assert 'baz' in map(str, tgt.sources), map(str, tgt.sources)
         assert 'bar' in map(str, tgt.sources), map(str, tgt.sources)
 
         env2=Environment(FOO=emit)
         builder2=SCons.Builder.Builder(name="builder2", action='foo',
                                        emitter="$FOO")
 
-        tgt = builder2(env2, target='foo', source='bar')
-        assert str(tgt) == 'foo', str(tgt)
+        tgt = builder2(env2, target='foo5', source='bar')
+        assert str(tgt) == 'foo5', str(tgt)
         assert str(tgt.sources[0]) == 'bar', str(tgt.sources[0])
 
-        tgt = builder2(env2, target='foo', source='bar', foo=1)
+        tgt = builder2(env2, target='foo6', source='bar', foo=2)
         assert len(tgt) == 2, len(tgt)
-        assert 'foo' in map(str, tgt), map(str, tgt)
-        assert 'bar' in map(str, tgt), map(str, tgt)
+        assert 'foo6' in map(str, tgt), map(str, tgt)
+        assert 'bar2' in map(str, tgt), map(str, tgt)
 
-        tgt = builder2(env2, target='foo', source='bar', bar=1)
-        assert str(tgt) == 'foo', str(tgt)
+        tgt = builder2(env2, target='foo7', source='bar', bar=1)
+        assert str(tgt) == 'foo7', str(tgt)
         assert len(tgt.sources) == 2, len(tgt.sources)
-        assert 'foo' in map(str, tgt.sources), map(str, tgt.sources)
+        assert 'baz' in map(str, tgt.sources), map(str, tgt.sources)
         assert 'bar' in map(str, tgt.sources), map(str, tgt.sources)
 
 if __name__ == "__main__":
diff --git a/src/engine/SCons/Defaults.py b/src/engine/SCons/Defaults.py
index cb21d81..7597169 100644
--- a/src/engine/SCons/Defaults.py
+++ b/src/engine/SCons/Defaults.py
@@ -318,7 +318,8 @@ def alias_builder(env, target, source):
 Alias = SCons.Builder.Builder(name = 'Alias',
                               action = alias_builder,
                               target_factory = SCons.Node.Alias.default_ans.Alias,
-                              source_factory = SCons.Node.FS.default_fs.Entry)
+                              source_factory = SCons.Node.FS.default_fs.Entry,
+                              multi = 1)
 
 def get_devstudio_versions ():
     """
diff --git a/src/engine/SCons/Script/__init__.py b/src/engine/SCons/Script/__init__.py
index 105c28f..d0b17d4 100644
--- a/src/engine/SCons/Script/__init__.py
+++ b/src/engine/SCons/Script/__init__.py
@@ -179,13 +179,36 @@ def _scons_syntax_error(e):
         sys.stderr.write(line+'\n')
     sys.exit(2)
 
+def find_deepest_user_frame(tb):
+    """
+    Find the deepest stack frame that is not part of SCons.
+    """
+    
+    stack = [tb]
+    while tb.tb_next is not None:
+        tb = tb.tb_next
+        stack.append(tb)
+
+    stack.reverse()
+
+    # find the deepest traceback frame that is not part
+    # of SCons:
+    for frame in stack:
+        filename = frame.tb_frame.f_code.co_filename
+        if string.find(filename, os.sep+'SCons'+os.sep) == -1:
+            tb = frame
+            break
+        
+    return tb
+
 def _scons_user_error(e):
     """Handle user errors. Print out a message and a description of the
-    error, along with the line number and routine where it occured.
+    error, along with the line number and routine where it occured. 
+    The file and line number will be the deepest stack frame that is
+    not part of SCons itself.
     """
     etype, value, tb = sys.exc_info()
-    while tb.tb_next is not None:
-        tb = tb.tb_next
+    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
@@ -196,10 +219,11 @@ def _scons_user_error(e):
 def _scons_user_warning(e):
     """Handle user warnings. Print out a message and a description of
     the warning, along with the line number and routine where it occured.
+    The file and line number will be the deepest stack frame that is
+    not part of SCons itself.
     """
     etype, value, tb = sys.exc_info()
-    while tb.tb_next is not None:
-        tb = tb.tb_next
+    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