Add a script to print .sconsign file contents.

6 files changed, 99 insertions, 33 deletions

diff --git a/src/engine/SCons/SConfTests.py b/src/engine/SCons/SConfTests.py
index 65c84b9..3240aa4 100644
--- a/src/engine/SCons/SConfTests.py
+++ b/src/engine/SCons/SConfTests.py
@@ -76,17 +76,11 @@ class SConfTestCase(unittest.TestCase):
         #    - cygwin on win32 (using cmd.exe, not bash)
         #    - posix
         #    - msvc on win32 (hopefully)
-        if self.scons_env.subst('$CXX') == 'c++':
-            # better use g++ (which is normally no symbolic link
-            # --> the c++ call fails on cygwin
-            self.scons_env['CXX'] = 'g++'
-        if self.scons_env.subst('$LINK') == 'c++':
-            self.scons_env['LINK'] = 'g++'
         if (not self.scons_env.Detect( self.scons_env.subst('$CXX') ) or
             not self.scons_env.Detect( self.scons_env.subst('$CC') ) or
             not self.scons_env.Detect( self.scons_env.subst('$LINK') )):
             raise Exception, "This test needs an installed compiler!"
-        if self.scons_env['LINK'] == 'g++':
+        if self.scons_env['CXX'] == 'g++':
             global existing_lib
             existing_lib = 'm'
         
diff --git a/src/engine/SCons/Sig/SigTests.py b/src/engine/SCons/Sig/SigTests.py
index 3010396..af2ebab 100644
--- a/src/engine/SCons/Sig/SigTests.py
+++ b/src/engine/SCons/Sig/SigTests.py
@@ -400,6 +400,41 @@ class SConsignEntryTestCase(unittest.TestCase):
         assert e.bsig == None
         assert e.implicit == None
 
+class _SConsignTestCase(unittest.TestCase):
+
+    def runTest(self):
+        class DummyModule:
+            def to_string(self, sig):
+                return str(sig)
+
+            def from_string(self, sig):
+                return int(sig)
+            
+        class DummyNode:
+            path = 'not_a_valid_path'
+
+        f = SCons.Sig._SConsign()
+        f.set_bsig('foo', 1)
+        assert f.get('foo') == (None, 1, None)
+        f.set_csig('foo', 2)
+        assert f.get('foo') == (None, 1, 2)
+        f.set_timestamp('foo', 3)
+        assert f.get('foo') == (3, 1, 2)
+        f.set_implicit('foo', ['bar'])
+        assert f.get('foo') == (3, 1, 2)
+        assert f.get_implicit('foo') == ['bar']
+
+        f = SCons.Sig._SConsign(None, DummyModule())
+        f.set_bsig('foo', 1)
+        assert f.get('foo') == (None, 1, None)
+        f.set_csig('foo', 2)
+        assert f.get('foo') == (None, 1, 2)
+        f.set_timestamp('foo', 3)
+        assert f.get('foo') == (3, 1, 2)
+        f.set_implicit('foo', ['bar'])
+        assert f.get('foo') == (3, 1, 2)
+        assert f.get_implicit('foo') == ['bar']
+
 class SConsignFileTestCase(unittest.TestCase):
 
     def runTest(self):
@@ -431,6 +466,7 @@ def suite():
     suite.addTest(TimeStampTestCase())
     suite.addTest(CalcTestCase())
     suite.addTest(SConsignEntryTestCase())
+    suite.addTest(_SConsignTestCase())
     suite.addTest(SConsignFileTestCase())
     return suite
 
diff --git a/src/engine/SCons/Sig/__init__.py b/src/engine/SCons/Sig/__init__.py
index 65fe807..36145cb 100644
--- a/src/engine/SCons/Sig/__init__.py
+++ b/src/engine/SCons/Sig/__init__.py
@@ -76,34 +76,24 @@ class SConsignEntry:
     csig = None
     implicit = None
 
-class SConsignFile:
-    """
-    Encapsulates reading and writing a .sconsign file.
-    """
+class _SConsign:
 
-    def __init__(self, dir, module=None):
+    def __init__(self, fp=None, module=None):
         """
-        dir - the directory for the file
+        fp - file pointer to read entries from
         module - the signature module being used
         """
 
-        self.dir = dir
-
         if module is None:
             self.module = default_calc.module
         else:
             self.module = module
-        self.sconsign = os.path.join(dir.path, '.sconsign')
         self.entries = {}
         self.dirty = 0
 
-        try:
-            file = open(self.sconsign, 'rb')
-        except:
-            pass
-        else:
+        if fp:
             try:
-                self.entries = cPickle.load(file)
+                self.entries = cPickle.load(fp)
                 if type(self.entries) is not type({}):
                     self.entries = {}
                     raise TypeError
@@ -190,6 +180,27 @@ class SConsignFile:
         entry.implicit = implicit
         self.set_entry(filename, entry)
 
+class SConsignFile(_SConsign):
+    """
+    Encapsulates reading and writing a .sconsign file.
+    """
+
+    def __init__(self, dir, module=None):
+        """
+        dir - the directory for the file
+        module - the signature module being used
+        """
+
+        self.dir = dir
+        self.sconsign = os.path.join(dir.path, '.sconsign')
+
+        try:
+            fp = open(self.sconsign, 'rb')
+        except:
+            fp = None
+
+        _SConsign.__init__(self, fp, module)
+
     def write(self):
         """
         Write the .sconsign file to disk.
diff --git a/src/engine/SCons/Tool/g++.py b/src/engine/SCons/Tool/g++.py
index 6beca1c..6497fe2 100644
--- a/src/engine/SCons/Tool/g++.py
+++ b/src/engine/SCons/Tool/g++.py
@@ -35,25 +35,22 @@ __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
 
 import os.path
 
+import cc
 import SCons.Defaults
 import SCons.Tool
 import SCons.Util
 
-compilers = ['c++', 'g++']
-
-CXXSuffixes = ['.cc', '.cpp', '.cxx', '.c++', '.C++']
-if os.path.normcase('.c') != os.path.normcase('.C'):
-    CXXSuffixes.append('.C')
+compilers = ['g++', 'c++']
 
 def generate(env):
     """Add Builders and construction variables for g++ to an Environment."""
     static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
 
-    for suffix in CXXSuffixes:
+    for suffix in cc.CXXSuffixes:
         static_obj.add_action(suffix, SCons.Defaults.CXXAction)
         shared_obj.add_action(suffix, SCons.Defaults.ShCXXAction)
 
-    env['CXX']        = env.Detect(compilers) or 'c++'
+    env['CXX']        = env.Detect(compilers) or 'g++'
     env['CXXFLAGS']   = '$CCFLAGS'
     env['CXXCOM']     = '$CXX $CXXFLAGS $CPPFLAGS $_CPPINCFLAGS -c -o $TARGET $SOURCES'
     env['SHCXX']      = '$CXX'
diff --git a/src/engine/SCons/Tool/gcc.py b/src/engine/SCons/Tool/gcc.py
index bf81ba8..a9f8ee1 100644
--- a/src/engine/SCons/Tool/gcc.py
+++ b/src/engine/SCons/Tool/gcc.py
@@ -35,13 +35,13 @@ __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
 
 import cc
 
-compilers = ['cc', 'gcc']
+compilers = ['gcc', 'cc']
 
 def generate(env):
     """Add Builders and construction variables for gcc to an Environment."""
     cc.generate(env)
 
-    env['CC'] = env.Detect(compilers) or 'cc'
+    env['CC'] = env.Detect(compilers) or 'gcc'
     if env['PLATFORM'] == 'cygwin':
         env['SHCCFLAGS'] = '$CCFLAGS'
     else:
diff --git a/src/engine/SCons/Tool/gnulink.py b/src/engine/SCons/Tool/gnulink.py
index 1928b58..4c14383 100644
--- a/src/engine/SCons/Tool/gnulink.py
+++ b/src/engine/SCons/Tool/gnulink.py
@@ -33,13 +33,41 @@ selection method.
 
 __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
 
+import cc
 import link
+import os.path
+import SCons.Action
+import SCons.Builder
+import SCons.Errors
+import SCons.Util
 
-linkers = ['c++', 'cc', 'g++', 'gcc']
+linkers = ['g++', 'gcc', 'c++', 'cc']
 
+def cxxSource(sources):
+    for s in sources:
+        if os.path.splitext(str(s))[1] in cc.CXXSuffixes:
+            return 1
+        if cxxSource(s.sources):
+            return 1
+    return 0
+
+def smart_link(source, target, env, for_signature):
+    cppSource = 0
+    if source is None:
+        # may occur, when env.subst('$LINK') is called
+        return '$CXX'
+    if not SCons.Util.is_List(source):
+        source = [source]
+        
+    if cxxSource(source):
+        return '$CXX'
+    else:
+        return '$CC'
+        
 def generate(env):
     """Add Builders and construction variables for gnulink to an Environment."""
     link.generate(env)
-
+    env['LINK'] = smart_link
+    
 def exists(env):
     return env.Detect(linkers)