Add LIBS and LIBPATH dependencies for shared libraries. (Charles Crain)

8 files changed, 161 insertions, 165 deletions

diff --git a/src/engine/SCons/Action.py b/src/engine/SCons/Action.py
index f8d37ee..c222d26 100644
--- a/src/engine/SCons/Action.py
+++ b/src/engine/SCons/Action.py
@@ -491,7 +491,7 @@ class ListAction(ActionBase):
     def execute(self, **kw):
         for l in self.list:
             r = apply(l.execute, (), kw)
-            if r != 0:
+            if r:
                 return r
         return 0
 
@@ -501,4 +501,4 @@ class ListAction(ActionBase):
         Simple concatenation of the signatures of the elements.
         """
 
-        return reduce(lambda x, y: x + str(y.get_contents()), self.list, "")
+        return reduce(lambda x, y, kw=kw: x + str(apply(y.get_contents, (), kw)), self.list, "")
diff --git a/src/engine/SCons/ActionTests.py b/src/engine/SCons/ActionTests.py
index 1a0ec18..c1425ef 100644
--- a/src/engine/SCons/ActionTests.py
+++ b/src/engine/SCons/ActionTests.py
@@ -287,7 +287,6 @@ class ListActionTestCase(unittest.TestCase):
         self.inc = 0
         def f(s):
             s.inc = s.inc + 1
-            return 0
         a = SCons.Action.ListAction([f, f, f])
         a.execute(s = self)
         assert self.inc == 3, self.inc
@@ -295,8 +294,15 @@ class ListActionTestCase(unittest.TestCase):
     def test_get_contents(self):
         """Test fetching the contents of a list of subsidiary Actions
         """
-        a = SCons.Action.ListAction(["x", "y", "z"])
-        c = a.get_contents(target=[], source=[])
+        self.foo=0
+        def gen(target, source, s, for_signature):
+            s.foo=1
+            return "y"
+        a = SCons.Action.ListAction(["x",
+                                     SCons.Action.CommandGenerator(gen),
+                                     "z"])
+        c = a.get_contents(target=[], source=[], s=self)
+        assert self.foo==1, self.foo
         assert c == "xyz", c
 
 class LazyActionTestCase(unittest.TestCase):
diff --git a/src/engine/SCons/Builder.py b/src/engine/SCons/Builder.py
index aa71214..94a8946 100644
--- a/src/engine/SCons/Builder.py
+++ b/src/engine/SCons/Builder.py
@@ -209,24 +209,14 @@ class BuilderBase:
         self.name = name
         self.action = SCons.Action.Action(action)
         self.multi = multi
+        self.prefix = prefix
+        self.suffix = suffix
 
-        if callable(prefix):
-            self.prefix = prefix
+        if SCons.Util.is_String(src_suffix):
+            self.src_suffix = [ src_suffix ]
         else:
-            self.prefix = _callable_adaptor(str(prefix))
-
-        if callable(suffix):
-            self.suffix = suffix
-        else:
-            self.suffix = _callable_adaptor(str(suffix))
-
-        if callable(src_suffix):
             self.src_suffix = src_suffix
-        elif SCons.Util.is_String(src_suffix):
-            self.src_suffix = _callable_adaptor([ str(src_suffix) ])
-        else:
-            self.src_suffix = _callable_adaptor(src_suffix)
-            
+
         self.target_factory = target_factory or node_factory
         self.source_factory = source_factory or node_factory
         self.scanner = scanner
@@ -328,21 +318,20 @@ class BuilderBase:
 
     def src_suffixes(self, env, args):
         return map(lambda x, e=env: e.subst(_adjust_suffix(x)),
-                   apply(self.src_suffix, (), args))
+                   self.src_suffix)
 
     def get_src_suffix(self, env, args):
         """Get the first src_suffix in the list of src_suffixes."""
-        ret = self.src_suffixes(env, args)
-        if not ret:
+        if not self.src_suffix:
             return ''
         else:
-            return ret[0]
+            return self.src_suffix[0]
 
     def get_suffix(self, env, args):
-        return env.subst(_adjust_suffix(apply(self.suffix, (), args)))
+        return env.subst(_adjust_suffix(self.suffix))
 
     def get_prefix(self, env, args):
-        return env.subst(apply(self.prefix, (), args))
+        return env.subst(self.prefix)
 
     def targets(self, node):
         """Return the list of targets for this builder instance.
diff --git a/src/engine/SCons/BuilderTests.py b/src/engine/SCons/BuilderTests.py
index 4651688..e1fc8fc 100644
--- a/src/engine/SCons/BuilderTests.py
+++ b/src/engine/SCons/BuilderTests.py
@@ -601,8 +601,7 @@ class BuilderTestCase(unittest.TestCase):
         tgt = builder(env, target='test2', source=['test2.bar', 'test1.foo'])
         try:
             tgt.build()
-        except SCons.Errors.BuildError, e:
-            assert e.args[0] == SCons.Errors.UserError
+        except SCons.Errors.UserError:
             flag = 1
         assert flag, "UserError should be thrown when we build targets with files of different suffixes."
 
@@ -646,8 +645,7 @@ class BuilderTestCase(unittest.TestCase):
         tgt = builder(env, target='t5', source='test5a.foo test5b.inb')
         try:
             tgt.build()
-        except SCons.Errors.BuildError, e:
-            assert e.args[0] == SCons.Errors.UserError
+        except SCons.Errors.UserError:
             flag = 1
         assert flag, "UserError should be thrown when we build targets with files of different suffixes."
 
@@ -655,8 +653,7 @@ class BuilderTestCase(unittest.TestCase):
         tgt = builder(env, target='t6', source='test6a.bar test6b.ina')
         try:
             tgt.build()
-        except SCons.Errors.BuildError, e:
-            assert e.args[0] == SCons.Errors.UserError
+        except SCons.Errors.UserError:
             flag = 1
         assert flag, "UserError should be thrown when we build targets with files of different suffixes."
 
@@ -664,8 +661,7 @@ class BuilderTestCase(unittest.TestCase):
         tgt = builder(env, target='t4', source='test4a.ina test4b.inb')
         try:
             tgt.build()
-        except SCons.Errors.BuildError, e:
-            assert e.args[0] == SCons.Errors.UserError
+        except SCons.Errors.UserError:
             flag = 1
         assert flag, "UserError should be thrown when we build targets with files of different suffixes."
 
diff --git a/src/engine/SCons/Defaults.py b/src/engine/SCons/Defaults.py
index aa8a643..e7a49b8 100644
--- a/src/engine/SCons/Defaults.py
+++ b/src/engine/SCons/Defaults.py
@@ -53,34 +53,6 @@ import SCons.Scanner.Fortran
 import SCons.Scanner.Prog
 import SCons.Util
 
-class SharedCmdGenerator:
-    """A callable class that acts as a command generator.
-    It is designed to hold on to 2 actions, and return
-    one if the shared=1 keyword arg is supplied to the
-    Builder method, and the other if not.
-
-    Also, all target nodes will have the shared attribute
-    set to match the vaue of the shared keyword argument,
-    zero by default."""
-    def __init__(self, static, shared):
-        self.action_static = static
-        self.action_shared = shared
-        
-    def __call__(self, target, source, env, shared=0, **kw):
-        for src in source:
-            try:
-                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:
-            t.attributes.shared = shared
-        if shared:
-            return self.action_shared
-        else:
-            return self.action_static
-
 def yaccEmitter(target, source, env, **kw):
     # Yacc can be configured to emit a .h file as well
     # as a .c file, if -d is specified on the command line.
@@ -104,14 +76,41 @@ CXXFile = SCons.Builder.Builder(action = { '.ll' : '$LEXCOM',
                                 emitter = yaccEmitter,
                                 suffix = '$CXXFILESUFFIX')
 
-CAction = SCons.Action.Action("$CCCOM")
-ShCAction = SCons.Action.Action("$SHCCCOM")
-CXXAction = SCons.Action.Action("$CXXCOM")
-ShCXXAction = SCons.Action.Action("$SHCXXCOM")
-F77Action = SCons.Action.Action("$F77COM")
-ShF77Action = SCons.Action.Action("$SHF77COM")
-F77PPAction = SCons.Action.Action("$F77PPCOM")
-ShF77PPAction = SCons.Action.Action("$SHF77PPCOM")
+class SharedFlagChecker:
+    """This is a callable class that is used as
+    a build action for all objects, libraries, and programs.
+    Its job is to run before the "real" action that builds the
+    file, to make sure we aren't trying to link shared objects
+    into a static library/program, or static objects into a
+    shared library."""
+
+    def __init__(self, shared):
+        self.shared = shared
+
+    def __call__(self, source, target, env, **kw):
+        if kw.has_key('shared'):
+            raise SCons.Errors.UserError, "The shared= parameter to Library() or Object() no longer works.\nUse SharedObject() or SharedLibrary() instead."
+        for tgt in target:
+            tgt.attributes.shared = self.shared
+
+        for src in source:
+            if hasattr(src.attributes, 'shared'):
+                if self.shared and not src.attributes.shared:
+                    raise SCons.Errors.UserError, "Source file: %s is static and is not compatible with shared target: %s" % (src, target[0])
+                elif not self.shared and src.attributes.shared:
+                    raise SCons.Errors.UserError, "Source file: %s is shared and is not compatible with static target: %s" % (src, target[0])
+
+SharedCheck = SharedFlagChecker(1)
+StaticCheck = SharedFlagChecker(0)
+
+CAction = SCons.Action.Action([ StaticCheck, "$CCCOM" ])
+ShCAction = SCons.Action.Action([ SharedCheck, "$SHCCCOM" ])
+CXXAction = SCons.Action.Action([ StaticCheck, "$CXXCOM" ])
+ShCXXAction = SCons.Action.Action([ SharedCheck, "$SHCXXCOM" ])
+F77Action = SCons.Action.Action([ StaticCheck, "$F77COM" ])
+ShF77Action = SCons.Action.Action([ SharedCheck, "$SHF77COM" ])
+F77PPAction = SCons.Action.Action([ StaticCheck, "$F77PPCOM" ])
+ShF77PPAction = SCons.Action.Action([ SharedCheck, "$SHF77PPCOM" ])
 
 if os.path.normcase('.c') == os.path.normcase('.C'):
     # We're on a case-insensitive system, so .[CF] (upper case)
@@ -129,41 +128,39 @@ else:
     F_static = F77PPAction
     F_shared = ShF77PPAction
 
-shared_obj = SCons.Builder.DictCmdGenerator({ ".C"   : C_shared,
-                                              ".cc"  : ShCXXAction,
-                                              ".cpp" : ShCXXAction,
-                                              ".cxx" : ShCXXAction,
-                                              ".c++" : ShCXXAction,
-                                              ".C++" : ShCXXAction,
-                                              ".c"   : ShCAction,
-                                              ".f"   : ShF77Action,
-                                              ".for" : ShF77Action,
-                                              ".FOR" : ShF77Action,
-                                              ".F"   : F_shared,
-                                              ".fpp" : ShF77PPAction,
-                                              ".FPP" : ShF77PPAction })
-
-static_obj = SCons.Builder.DictCmdGenerator({ ".C"   : C_static,
-                                              ".cc"  : CXXAction,
-                                              ".cpp" : CXXAction,
-                                              ".cxx" : CXXAction,
-                                              ".c++" : CXXAction,
-                                              ".C++" : CXXAction,
-                                              ".c"   : CAction,
-                                              ".f"   : F77Action,
-                                              ".for" : F77Action,
-                                              ".F"   : F_static,
-                                              ".FOR" : F77Action,
-                                              ".fpp" : F77PPAction,
-                                              ".FPP" : F77PPAction })
-
-Object = SCons.Builder.Builder(generator = \
-                               SharedCmdGenerator(static=SCons.Action.CommandGeneratorAction(static_obj),
-                                                  shared=SCons.Action.CommandGeneratorAction(shared_obj)),
-                               prefix = '$OBJPREFIX',
-                               suffix = '$OBJSUFFIX',
-                               src_suffix = static_obj.src_suffixes(),
-                               src_builder = [CFile, CXXFile])
+StaticObject = SCons.Builder.Builder(action = { ".C"   : C_static,
+                                                ".cc"  : CXXAction,
+                                                ".cpp" : CXXAction,
+                                                ".cxx" : CXXAction,
+                                                ".c++" : CXXAction,
+                                                ".C++" : CXXAction,
+                                                ".c"   : CAction,
+                                                ".f"   : F77Action,
+                                                ".for" : F77Action,
+                                                ".F"   : F_static,
+                                                ".FOR" : F77Action,
+                                                ".fpp" : F77PPAction,
+                                                ".FPP" : F77PPAction },
+                                     prefix = '$OBJPREFIX',
+                                     suffix = '$OBJSUFFIX',
+                                     src_builder = [CFile, CXXFile])
+
+SharedObject = SCons.Builder.Builder(action = { ".C"   : C_shared,
+                                                ".cc"  : ShCXXAction,
+                                                ".cpp" : ShCXXAction,
+                                                ".cxx" : ShCXXAction,
+                                                ".c++" : ShCXXAction,
+                                                ".C++" : ShCXXAction,
+                                                ".c"   : ShCAction,
+                                                ".f"   : ShF77Action,
+                                                ".for" : ShF77Action,
+                                                ".FOR" : ShF77Action,
+                                                ".F"   : F_shared,
+                                                ".fpp" : ShF77PPAction,
+                                                ".FPP" : ShF77PPAction },
+                                     prefix = '$OBJPREFIX',
+                                     suffix = '$OBJSUFFIX',
+                                     src_builder = [CFile, CXXFile])
 
 def win32TempFileMunge(env, cmd_list, for_signature): 
     """Given a list of command line arguments, see if it is too
@@ -193,25 +190,16 @@ def win32LinkGenerator(env, target, source, for_signature, **kw):
     args.extend(map(SCons.Util.to_String, source))
     return win32TempFileMunge(env, args, for_signature)
 
-Program = SCons.Builder.Builder(action='$LINKCOM',
+ProgScan = SCons.Scanner.Prog.ProgScan()
+
+Program = SCons.Builder.Builder(action=[ StaticCheck, '$LINKCOM' ],
                                 prefix='$PROGPREFIX',
                                 suffix='$PROGSUFFIX',
                                 src_suffix='$OBJSUFFIX',
-                                src_builder=Object,
-                                scanner = SCons.Scanner.Prog.ProgScan())
-
-class LibAffixGenerator:
-    def __init__(self, static, shared):
-        self.static_affix = static
-        self.shared_affix = shared
-
-    def __call__(self, shared=0, **kw):
-        if shared:
-            return self.shared_affix
-        return self.static_affix
+                                src_builder=StaticObject,
+                                scanner = ProgScan)
 
-def win32LibGenerator(target, source, env, for_signature, shared=1,
-                      no_import_lib=0):
+def win32LibGenerator(target, source, env, for_signature, no_import_lib=0):
     listCmd = [ "$SHLINK", "$SHLINKFLAGS" ]
 
     for tgt in target:
@@ -235,47 +223,46 @@ def win32LibGenerator(target, source, env, for_signature, shared=1,
             listCmd.append(str(src))
     return win32TempFileMunge(env, listCmd, for_signature)
 
-def win32LibEmitter(target, source, env, shared=0,
-                    no_import_lib=0):
-    if shared:
-        dll = None
-        for tgt in target:
-            ext = os.path.splitext(str(tgt))[1]
-            if ext == env.subst("$SHLIBSUFFIX"):
-                dll = tgt
-                break
-        if not dll:
-            raise SCons.Errors.UserError("A shared library should have exactly one target with the suffix: %s" % env.subst("$SHLIBSUFFIX"))
+def win32LibEmitter(target, source, env, no_import_lib=0):
+    dll = None
+    for tgt in target:
+        ext = os.path.splitext(str(tgt))[1]
+        if ext == env.subst("$SHLIBSUFFIX"):
+            dll = tgt
+            break
+    if not dll:
+        raise SCons.Errors.UserError, "A shared library should have exactly one target with the suffix: %s" % env.subst("$SHLIBSUFFIX")
         
-        if env.has_key("WIN32_INSERT_DEF") and \
-           env["WIN32_INSERT_DEF"] and \
-           not '.def' in map(lambda x: os.path.split(str(x))[1],
-                             source):
-
-            # append a def file to the list of sources
-            source.append("%s%s" % (os.path.splitext(str(dll))[0],
-                                    env.subst("$WIN32DEFSUFFIX")))
-        if not no_import_lib and \
-           not env.subst("$LIBSUFFIX") in \
-           map(lambda x: os.path.split(str(x))[1], target):
-            # Append an import library to the list of targets.
-            target.append("%s%s%s" % (env.subst("$LIBPREFIX"),
-                                      os.path.splitext(str(dll))[0],
-                                      env.subst("$LIBSUFFIX")))
+    if env.has_key("WIN32_INSERT_DEF") and \
+       env["WIN32_INSERT_DEF"] and \
+       not '.def' in map(lambda x: os.path.split(str(x))[1],
+                         source):
+
+        # append a def file to the list of sources
+        source.append("%s%s" % (os.path.splitext(str(dll))[0],
+                                env.subst("$WIN32DEFSUFFIX")))
+    if not no_import_lib and \
+       not env.subst("$LIBSUFFIX") in \
+       map(lambda x: os.path.split(str(x))[1], target):
+        # Append an import library to the list of targets.
+        target.append("%s%s%s" % (env.subst("$LIBPREFIX"),
+                                  os.path.splitext(str(dll))[0],
+                                  env.subst("$LIBSUFFIX")))
     return (target, source)
 
-Library = SCons.Builder.Builder(generator = \
-                                SharedCmdGenerator(shared="$SHLINKCOM",
-                                                   static="$ARCOM"),
-                                emitter="$LIBEMITTER",
-                                prefix = \
-                                LibAffixGenerator(static='$LIBPREFIX',
-                                                  shared='$SHLIBPREFIX'),
-                                suffix = \
-                                LibAffixGenerator(static='$LIBSUFFIX',
-                                                  shared='$SHLIBSUFFIX'),
-                                src_suffix = '$OBJSUFFIX',
-                                src_builder = Object)
+StaticLibrary = SCons.Builder.Builder(action=[ StaticCheck, "$ARCOM" ],
+                                      prefix = '$LIBPREFIX',
+                                      suffix = '$LIBSUFFIX',
+                                      src_suffix = '$OBJSUFFIX',
+                                      src_builder = StaticObject)
+
+SharedLibrary = SCons.Builder.Builder(action=[ SharedCheck, "$SHLINKCOM" ],
+                                      emitter="$LIBEMITTER",
+                                      prefix = '$SHLIBPREFIX',
+                                      suffix = '$SHLIBSUFFIX',
+                                      scanner = ProgScan,
+                                      src_suffix = '$OBJSUFFIX',
+                                      src_builder = SharedObject)
 
 LaTeXAction = SCons.Action.Action('$LATEXCOM')
 
@@ -480,8 +467,12 @@ def make_win32_env_from_paths(include, lib, path):
                          'CFile'          : CFile,
                          'CXXFile'        : CXXFile,
                          'DVI'            : DVI,
-                         'Library'        : Library,
-                         'Object'         : Object,
+                         'Library'        : StaticLibrary,
+                         'StaticLibrary'  : StaticLibrary,
+                         'SharedLibrary'  : SharedLibrary,
+                         'Object'         : StaticObject,
+                         'StaticObject'   : StaticObject,
+                         'SharedObject'   : SharedObject,
                          'PDF'            : PDF,
                          'PostScript'     : PostScript,
                          'Program'        : Program },
@@ -589,8 +580,12 @@ if os.name == 'posix':
                          'CFile'          : CFile,
                          'CXXFile'        : CXXFile,
                          'DVI'            : DVI,
-                         'Library'        : Library,
-                         'Object'         : Object,
+                         'Library'        : StaticLibrary,
+                         'StaticLibrary'  : StaticLibrary,
+                         'SharedLibrary'  : SharedLibrary,
+                         'Object'         : StaticObject,
+                         'StaticObject'   : StaticObject,
+                         'SharedObject'   : SharedObject,
                          'PDF'            : PDF,
                          'PostScript'     : PostScript,
                          'Program'        : Program },
diff --git a/src/engine/SCons/Node/__init__.py b/src/engine/SCons/Node/__init__.py
index 483de10..22d6072 100644
--- a/src/engine/SCons/Node/__init__.py
+++ b/src/engine/SCons/Node/__init__.py
@@ -37,7 +37,7 @@ import copy
 import sys
 import SCons.Sig
 
-from SCons.Errors import BuildError
+from SCons.Errors import BuildError, UserError
 import SCons.Util
 
 # Node states
@@ -116,6 +116,8 @@ class Node:
                              self.generate_build_args())
             except KeyboardInterrupt:
                 raise
+            except UserError:
+                raise
             except:
                 raise BuildError(self, "Exception",
                                  sys.exc_type,
diff --git a/src/engine/SCons/Script/SConscript.py b/src/engine/SCons/Script/SConscript.py
index 44ec7ce..7fcdf77 100644
--- a/src/engine/SCons/Script/SConscript.py
+++ b/src/engine/SCons/Script/SConscript.py
@@ -259,8 +259,12 @@ def BuildDefaultGlobals():
     globals['GetCommandHandler'] = SCons.Action.GetCommandHandler
     globals['Help']              = Help
     globals['Import']            = Import
-    globals['Library']           = SCons.Defaults.Library
-    globals['Object']            = SCons.Defaults.Object
+    globals['Library']           = SCons.Defaults.StaticLibrary
+    globals['Object']            = SCons.Defaults.StaticObject
+    globals['StaticLibrary']     = SCons.Defaults.StaticLibrary
+    globals['StaticObject']      = SCons.Defaults.StaticObject
+    globals['SharedLibrary']     = SCons.Defaults.SharedLibrary
+    globals['SharedObject']      = SCons.Defaults.SharedObject
     globals['Platform']          = SCons.Platform.Platform
     globals['Program']           = SCons.Defaults.Program
     globals['Return']            = Return
diff --git a/src/engine/SCons/Script/__init__.py b/src/engine/SCons/Script/__init__.py
index 89d26b2..879f6d1 100644
--- a/src/engine/SCons/Script/__init__.py
+++ b/src/engine/SCons/Script/__init__.py
@@ -93,6 +93,10 @@ class BuildTask(SCons.Taskmaster.Task):
                     traceback.print_exception(e.args[0], e.args[1],
                                               e.args[2])
                 raise
+            except UserError, e:
+                # We aren't being called out of a user frame, so
+                # don't try to walk the stack, just print the error.
+                sys.stderr.write("\nSCons error: %s\n" % e)
 	    except:
 		sys.stderr.write("scons: *** %s\n" % sys.exc_value)
 		raise