refactored the versioned lib code a little

4 files changed, 148 insertions, 89 deletions

diff --git a/src/engine/SCons/Tool/__init__.py b/src/engine/SCons/Tool/__init__.py
index 0e6e7d8..0b09a13 100644
--- a/src/engine/SCons/Tool/__init__.py
+++ b/src/engine/SCons/Tool/__init__.py
@@ -236,31 +236,31 @@ def createStaticLibBuilder(env):
 
     return static_lib
 
-def _call_env_cb(env, callback, args, result = None):
-    """Returns the result of env[callback](*args) call if env[callback] is
-    callable. If env[callback] does not exist or is not callable, return the
-    value provided as the *result* argument. This function is mainly used for
-    generating library info such as versioned suffixes, symlink maps, sonames
-    etc. by delegating the core job to callbacks configured by current linker
-    tool"""
+def _call_linker_cb(env, callback, args, result = None):
+    """Returns the result of env['LINKCALLBACKS'][callback](*args)
+    if env['LINKCALLBACKS'] is a dictionary and env['LINKCALLBACKS'][callback]
+    is callable. If these conditions are not meet, return the value provided as
+    the *result* argument. This function is mainly used for generating library
+    info such as versioned suffixes, symlink maps, sonames etc. by delegating
+    the core job to callbacks configured by current linker tool"""
 
     Verbose = False
 
     if Verbose:
-        print '_call_env_cb: args=%r' % args
-        print '_call_env_cb: callback=%r' % callback
-
+        print '_call_linker_cb: args=%r' % args
+        print '_call_linker_cb: callback=%r' % callback
+    
     try:
-        cbfun = env[callback]
-    except KeyError:
+        cbfun = env['LINKCALLBACKS'][callback]
+    except (KeyError, TypeError):
         pass
     else:
         if Verbose:
-            print '_call_env_cb: env[%r] found' % callback
-            print '_call_env_cb: env[%r]=%r' % (callback, cbfun)
+            print '_call_linker_cb: env[%r] found' % callback
+            print '_call_linker_cb: env[%r]=%r' % (callback, cbfun)
         if(callable(cbfun)):
             if Verbose:
-                print '_call_env_cb: env[%r] is callable' % callback
+                print '_call_linker_cb: env[%r] is callable' % callback
             result = cbfun(env, *args)
     return result
 
@@ -298,6 +298,17 @@ class _LibInfoGeneratorBase(object):
             prefix = env.subst('$IMPLIBPREFIX')
         return prefix
 
+    def get_lib_prefix(self, env):
+        prefix = None
+        libtype = self.get_libtype()
+        if libtype == 'ShLib':
+            prefix = env.subst('$SHLIBPREFIX')
+        elif libtype == 'LdMod':
+            prefix = env.subst('$LDMODULEPREFIX')
+        elif libtype == 'ImpLib':
+            prefix = env.subst('$IMPLIBPREFIX')
+        return prefix
+
     def get_lib_suffix(self, env):
         suffix = None
         libtype = self.get_libtype()
@@ -332,11 +343,39 @@ class _LibInfoGeneratorBase(object):
         try: libtype = kw['generator_libtype']
         except KeyError: libtype = self.get_libtype()
         infoname = self.get_infoname()
-        return 'GenerateVersioned%s%s' % (libtype, infoname)
+        return 'Versioned%s%s' % (libtype, infoname)
 
     def generate_versioned_lib_info(self, env, args, result = None, **kw):
         callback = self.get_versioned_lib_info_generator(**kw)
-        return _call_env_cb(env, callback, args, result) 
+        return _call_linker_cb(env, callback, args, result) 
+
+class _LibPrefixGenerator(_LibInfoGeneratorBase):
+    """Library prefix generator, used as target_prefix in SharedLibrary and
+    LoadableModule builders"""
+    def __init__(self, libtype):
+        super(_LibPrefixGenerator, self).__init__(libtype, 'Prefix')
+
+    def __call__(self, env, sources = None, **kw):
+        Verbose = False
+
+        prefix = self.get_lib_prefix(env)
+        if Verbose:
+            print "_LibPrefixGenerator: input prefix=%r" % prefix
+
+        version = self.get_lib_version(env, **kw)
+        if Verbose:
+            print "_LibPrefixGenerator: version=%r" % version
+
+        if version:
+            prefix = self.generate_versioned_lib_info(env, [prefix, version], prefix, **kw)
+
+        if Verbose:
+            print "_LibPrefixGenerator: return prefix=%r" % prefix
+        return prefix
+
+ShLibPrefixGenerator  = _LibPrefixGenerator('ShLib')
+LdModPrefixGenerator  = _LibPrefixGenerator('LdMod')
+ImpLibPrefixGenerator = _LibPrefixGenerator('ImpLib')
 
 class _LibSuffixGenerator(_LibInfoGeneratorBase):
     """Library suffix generator, used as target_suffix in SharedLibrary and
@@ -408,8 +447,9 @@ class _LibSymlinkGenerator(_LibInfoGeneratorBase):
             print '_LibSymlinkGenerator: disable=%r' % disable
 
         if version and not disable:
+            prefix = self.get_lib_prefix(env)
             suffix = self.get_lib_suffix(env)
-            symlinks = self.generate_versioned_lib_info(env, [libnode, version, suffix], **kw)
+            symlinks = self.generate_versioned_lib_info(env, [libnode, version, prefix, suffix], **kw)
 
         if Verbose:
             print '_LibSymlinkGenerator: return symlinks=%r' % StringizeLibSymlinks(symlinks)
@@ -420,8 +460,19 @@ LdModSymlinkGenerator =  _LibSymlinkGenerator('LdMod')
 ImpLibSymlinkGenerator = _LibSymlinkGenerator('ImpLib')
 
 class _LibNameGenerator(_LibInfoGeneratorBase):
-    """Library name generator. Returns library name (e.g. libfoo.so) for 
-    a given node (e.g. /foo/bar/libfoo.so.0.1.2)"""
+    """Generates "unmangled" library name from a library file node.
+    
+    Generally, it's thought to revert modifications done by prefix/suffix
+    generators (_LibPrefixGenerator/_LibSuffixGenerator) used by a library
+    builder. For example, on gnulink the suffix generator used by SharedLibrary
+    builder appends $SHLIBVERSION to $SHLIBSUFFIX producing node name which
+    ends with "$SHLIBSUFFIX.$SHLIBVERSION". Correspondingly, the implementation
+    of _LibNameGenerator replaces "$SHLIBSUFFIX.$SHLIBVERSION" with
+    "$SHLIBSUFFIX" in the node's basename. So that, if $SHLIBSUFFIX is ".so",
+    $SHLIBVERSION is "0.1.2" and the node path is "/foo/bar/libfoo.so.0.1.2",
+    the _LibNameGenerator shall return "libfoo.so". Other link tools may
+    implement it's own way of library name unmangling. 
+    """
     def __init__(self, libtype):
         super(_LibNameGenerator, self).__init__(libtype, 'Name')
 
@@ -438,8 +489,9 @@ class _LibNameGenerator(_LibInfoGeneratorBase):
 
         name = None
         if version:
+            prefix = self.get_lib_prefix(env)
             suffix = self.get_lib_suffix(env)
-            name = self.generate_versioned_lib_info(env, [libnode, version, suffix], **kw)
+            name = self.generate_versioned_lib_info(env, [libnode, version, prefix, suffix], **kw)
 
         if not name:
             name = os.path.basename(libnode.get_path())
@@ -566,7 +618,7 @@ def createSharedLibBuilder(env):
                         LibSymlinksAction ]
         shared_lib = SCons.Builder.Builder(action = action_list,
                                            emitter = "$SHLIBEMITTER",
-                                           prefix = '$SHLIBPREFIX',
+                                           prefix = ShLibPrefixGenerator,
                                            suffix = ShLibSuffixGenerator,
                                            target_scanner = ProgramScanner,
                                            src_suffix = '$SHOBJSUFFIX',
@@ -591,7 +643,7 @@ def createLoadableModuleBuilder(env):
                         LibSymlinksAction ]
         ld_module = SCons.Builder.Builder(action = action_list,
                                           emitter = "$LDMODULEEMITTER",
-                                          prefix = '$LDMODULEPREFIX',
+                                          prefix = ShLibPrefixGenerator,
                                           suffix = LdModSuffixGenerator,
                                           target_scanner = ProgramScanner,
                                           src_suffix = '$SHOBJSUFFIX',
diff --git a/src/engine/SCons/Tool/cyglink.py b/src/engine/SCons/Tool/cyglink.py
index 59258b2..e05e85f 100644
--- a/src/engine/SCons/Tool/cyglink.py
+++ b/src/engine/SCons/Tool/cyglink.py
@@ -15,6 +15,7 @@ import SCons.Util
 import SCons.Tool
 
 import gnulink
+import link
 
 def _lib_generator(target, source, env, for_signature, **kw):
     try: cmd = kw['cmd']
@@ -135,13 +136,13 @@ def _versioned_lib_suffix(env, suffix, version):
         print "_versioned_lib_suffix: return suffix= ", suffix
     return suffix
 
-def _versioned_implib_name(env, libnode, version, suffix, **kw):
-    import link
-    generator = SCons.Tool.ImpLibSuffixGenerator
-    libtype = kw['libtype']
-    return link._versioned_lib_name(env, libnode, version, suffix, generator, implib_libtype=libtype)
+def _versioned_implib_name(env, libnode, version, prefix, suffix, **kw):
+    return link._versioned_lib_name(env, libnode, version, prefix, suffix,
+                                    SCons.Tool.ImpLibPrefixGenerator,
+                                    SCons.Tool.ImpLibSuffixGenerator,
+                                    implib_libtype=kw['libtype'])
 
-def _versioned_implib_symlinks(env, libnode, version, suffix, **kw):
+def _versioned_implib_symlinks(env, libnode, version, prefix, suffix, **kw):
     """Generate link names that should be created for a versioned shared lirbrary.
        Returns a list in the form [ (link, linktarget), ... ]
     """
@@ -201,27 +202,24 @@ def generate(env):
 
     # SHLIBVERSIONFLAGS and LDMODULEVERSIONFLAGS are same as in gnulink...
 
-    env['GenerateVersionedShLibSuffix']          = _versioned_lib_suffix
-    env['GenerateVersionedLdModSuffix']          = _versioned_lib_suffix
-    env['GenerateVersionedImpLibSuffix']         = _versioned_lib_suffix
-    env['GenerateVersionedShLibImpLibName']      = lambda *args: _versioned_implib_name(*args, libtype='ShLib')
-    env['GenerateVersionedLdModImpLibName']      = lambda *args: _versioned_implib_name(*args, libtype='LdMod')
-    env['GenerateVersionedShLibImpLibSymlinks']  = lambda *args: _versioned_implib_symlinks(*args, libtype='ShLib')
-    env['GenerateVersionedLdModImpLibSymlinks']  = lambda *args: _versioned_implib_symlinks(*args, libtype='LdMod')
-
-    def trydel(env, key):
-        try: del env[key]
-        except KeyError: pass
+    # LINKCALLBACKS are NOT inherited from gnulink
+    env['LINKCALLBACKS'] = {
+        'VersionedShLibSuffix'          : _versioned_lib_suffix,
+        'VersionedLdModSuffix'          : _versioned_lib_suffix,
+        'VersionedImpLibSuffix'         : _versioned_lib_suffix,
+        'VersionedShLibName'            : link._versioned_shlib_name,
+        'VersionedLdModName'            : link._versioned_ldmod_name,
+        'VersionedShLibImpLibName'      : lambda *args: _versioned_implib_name(*args, libtype='ShLib'),
+        'VersionedLdModImpLibName'      : lambda *args: _versioned_implib_name(*args, libtype='LdMod'),
+        'VersionedShLibImpLibSymlinks'  : lambda *args: _versioned_implib_symlinks(*args, libtype='ShLib'),
+        'VersionedLdModImpLibSymlinks'  : lambda *args: _versioned_implib_symlinks(*args, libtype='LdMod'),
+    }
 
     # these variables were set by gnulink but are not used in cyglink
-    trydel(env,'_SHLINKSONAME')
-    trydel(env,'_LDMODULESONAME')
-    trydel(env,'ShLibSonameGenerator')
-    trydel(env,'LdModSonameGenerator')
-    trydel(env,'GenerateVersionedShLibSymlinks')
-    trydel(env,'GenerateVersionedLdModSymlinks')
-    trydel(env,'GenerateVersionedShLibSoname')
-    trydel(env,'GenerateVersionedLdModSoname')
+    try: del env['_SHLINKSONAME']
+    except KeyError: pass
+    try: del env['_LDMODULESONAME']
+    except KeyError: pass
 
 def exists(env):
     return gnulink.exists(env)
diff --git a/src/engine/SCons/Tool/gnulink.py b/src/engine/SCons/Tool/gnulink.py
index 14007af..e5e8818 100644
--- a/src/engine/SCons/Tool/gnulink.py
+++ b/src/engine/SCons/Tool/gnulink.py
@@ -53,12 +53,12 @@ def _versioned_lib_suffix(env, suffix, version):
         print "_versioned_lib_suffix: return suffix=%r" % suffix
     return suffix
 
-def _versioned_lib_soname(env, libnode, version, suffix, name_generator):
+def _versioned_lib_soname(env, libnode, version, prefix, suffix, name_func):
     """For libnode='/optional/dir/libfoo.so.X.Y.Z' it returns 'libfoo.so.X'"""
     Verbose = False
     if Verbose:
         print "_versioned_lib_soname: version=%r" % version
-    name = name_generator(env, libnode)
+    name = name_func(env, libnode, version, prefix, suffix)
     if Verbose:
         print "_versioned_lib_soname: name=%r" % name
     major = version.split('.')[0]
@@ -67,22 +67,20 @@ def _versioned_lib_soname(env, libnode, version, suffix, name_generator):
         print "_versioned_lib_soname: soname=%r" % soname
     return soname
 
-def _versioned_shlib_soname(env, libnode, version, suffix):
-    generator = SCons.Tool.ShLibNameGenerator
-    return _versioned_lib_soname(env, libnode, version, suffix, generator) 
+def _versioned_shlib_soname(env, libnode, version, prefix, suffix):
+    return _versioned_lib_soname(env, libnode, version, prefix, suffix, link._versioned_shlib_name) 
 
-def _versioned_ldmod_soname(env, libnode, version, suffix):
-    generator = SCons.Tool.LdModNameGenerator
-    return _versioned_lib_soname(env, libnode, version, suffix, generator) 
+def _versioned_ldmod_soname(env, libnode, version, prefix, suffix):
+    return _versioned_lib_soname(env, libnode, version, prefix, suffix, link._versioned_ldmod_name) 
 
-def _versioned_lib_symlinks(env, libnode, version, suffix, name_generator, soname_generator):
+def _versioned_lib_symlinks(env, libnode, version, prefix, suffix, name_func, soname_func):
     """Generate link names that should be created for a versioned shared lirbrary.
        Returns a dictionary in the form { linkname : linktarget }
     """
     Verbose = False
 
     if Verbose:
-        print "_versioned_lib_symlinks: str(libnode)=%r" % str(libnode)
+        print "_versioned_lib_symlinks: libnode=%r" % libnode.get_path()
         print "_versioned_lib_symlinks: version=%r" % version
 
     if sys.platform.startswith('openbsd'):
@@ -96,11 +94,11 @@ def _versioned_lib_symlinks(env, libnode, version, suffix, name_generator, sonam
     if Verbose:
         print "_versioned_lib_symlinks: linkdir=%r" % linkdir.get_path()
 
-    name = name_generator(env, libnode)
+    name = name_func(env, libnode, version, prefix, suffix)
     if Verbose:
         print "_versioned_lib_symlinks: name=%r" % name
 
-    soname = soname_generator(env, libnode)
+    soname = soname_func(env, libnode, version, prefix, suffix)
 
     link0 = env.fs.File(soname, linkdir)
     link1 = env.fs.File(name, linkdir)
@@ -112,15 +110,15 @@ def _versioned_lib_symlinks(env, libnode, version, suffix, name_generator, sonam
 
     return symlinks
 
-def _versioned_shlib_symlinks(env, libnode, version, suffix):
-    name_generator = SCons.Tool.ShLibNameGenerator
-    soname_generator = SCons.Tool.ShLibSonameGenerator
-    return _versioned_lib_symlinks(env, libnode, version, suffix, name_generator, soname_generator)
+def _versioned_shlib_symlinks(env, libnode, version, prefix, suffix):
+    nf = link._versioned_shlib_name
+    sf = _versioned_shlib_soname
+    return _versioned_lib_symlinks(env, libnode, version, prefix, suffix, nf, sf)
 
-def _versioned_ldmod_symlinks(env, libnode, version, suffix):
-    name_generator = SCons.Tool.LdModNameGenerator
-    soname_generator = SCons.Tool.LdModSonameGenerator
-    return _versioned_lib_symlinks(env, libnode, version, suffix, name_generator, soname_generator)
+def _versioned_ldmod_symlinks(env, libnode, version, prefix, suffix):
+    nf = link._versioned_ldmod_name
+    sf = _versioned_ldmod_soname
+    return _versioned_lib_symlinks(env, libnode, version, prefix, suffix, nf, sf)
 
 def generate(env):
     """Add Builders and construction variables for gnulink to an Environment."""
@@ -155,14 +153,16 @@ def generate(env):
     env['ShLibSonameGenerator'] = SCons.Tool.ShLibSonameGenerator
     env['LdModSonameGenerator'] = SCons.Tool.LdModSonameGenerator
 
-    env['GenerateVersionedShLibSuffix']   = _versioned_lib_suffix
-    env['GenerateVersionedLdModSuffix']   = _versioned_lib_suffix
-    env['GenerateVersionedShLibSymlinks'] = _versioned_shlib_symlinks
-    env['GenerateVersionedLdModSymlinks'] = _versioned_ldmod_symlinks
-    env['GenerateVersionedShLibName']     = link._versioned_shlib_name
-    env['GenerateVersionedLdModName']     = link._versioned_ldmod_name
-    env['GenerateVersionedShLibSoname']   = _versioned_shlib_soname
-    env['GenerateVersionedLdModSoname']   = _versioned_shlib_soname
+    env['LINKCALLBACKS'] = {
+        'VersionedShLibSuffix'   : _versioned_lib_suffix,
+        'VersionedLdModSuffix'   : _versioned_lib_suffix,
+        'VersionedShLibSymlinks' : _versioned_shlib_symlinks,
+        'VersionedLdModSymlinks' : _versioned_ldmod_symlinks,
+        'VersionedShLibName'     : link._versioned_shlib_name,
+        'VersionedLdModName'     : link._versioned_ldmod_name,
+        'VersionedShLibSoname'   : _versioned_shlib_soname,
+        'VersionedLdModSoname'   : _versioned_shlib_soname,
+    }
     
 def exists(env):
     # TODO: sync with link.smart_link() to choose a linker
diff --git a/src/engine/SCons/Tool/link.py b/src/engine/SCons/Tool/link.py
index 33e50d9..d52a9e5 100644
--- a/src/engine/SCons/Tool/link.py
+++ b/src/engine/SCons/Tool/link.py
@@ -76,7 +76,7 @@ def smart_link(source, target, env, for_signature):
 def _lib_emitter(target, source, env, **kw):
     Verbose = False
     if Verbose:
-        print "_lib_emitter: str(target[0])=%r" % str(target[0])
+        print "_lib_emitter: target[0]=%r" % target[0].get_path()
     for tgt in target:
         tgt.attributes.shared = 1
     
@@ -103,35 +103,44 @@ def ldmod_emitter(target, source, env):
     return _lib_emitter(target, source, env, symlink_generator = SCons.Tool.LdModSymlinkGenerator)
 
 # This is generic enough to be included here...
-def _versioned_lib_name(env, libnode, version, suffix, suffix_generator, **kw):
+def _versioned_lib_name(env, libnode, version, prefix, suffix, prefix_generator, suffix_generator, **kw):
     """For libnode='/optional/dir/libfoo.so.X.Y.Z' it returns 'libfoo.so'"""
     Verbose = False
 
     if Verbose:
+        print "_versioned_lib_name: libnode=%r" % libnode.get_path()
         print "_versioned_lib_name: version=%r" % version
+        print "_versioned_lib_name: prefix=%r" % prefix
+        print "_versioned_lib_name: suffix=%r" % suffix
+        print "_versioned_lib_name: suffix_generator=%r" % suffix_generator
 
-    versioned_name = os.path.basename(str(libnode))
+    versioned_name = os.path.basename(libnode.get_path())
     if Verbose:
         print "_versioned_lib_name: versioned_name=%r" % versioned_name
 
-    if Verbose:
-        print "_versioned_lib_name: suffix=%r" % suffix
-
+    versioned_prefix = prefix_generator(env, **kw)
     versioned_suffix = suffix_generator(env, **kw)
+    if Verbose:
+        print "_versioned_lib_name: versioned_prefix=%r" % versioned_prefix
+        print "_versioned_lib_name: versioned_suffix=%r" % versioned_suffix
 
+    versioned_prefix_re = '^' + re.escape(versioned_prefix)
     versioned_suffix_re = re.escape(versioned_suffix) + '$'
-    name = re.sub(versioned_suffix_re, suffix, versioned_name)
+    name = re.sub(versioned_prefix_re, prefix, versioned_name)
+    name = re.sub(versioned_suffix_re, suffix, name)
     if Verbose:
         print "_versioned_lib_name: name=%r" % name
     return name
 
-def _versioned_shlib_name(env, libnode, version, suffix, **kw):
-    generator = SCons.Tool.ShLibSuffixGenerator
-    return _versioned_lib_name(env, libnode, version, suffix, generator, **kw)
+def _versioned_shlib_name(env, libnode, version, prefix, suffix, **kw):
+    pg = SCons.Tool.ShLibPrefixGenerator
+    sg = SCons.Tool.ShLibSuffixGenerator
+    return _versioned_lib_name(env, libnode, version, prefix, suffix, pg, sg, **kw)
 
-def _versioned_ldmod_name(env, libnode, version, suffix, **kw):
-    generator = SCons.Tool.LdModSuffixGenerator
-    return _versioned_lib_name(env, libnode, version, suffix, generator, **kw)
+def _versioned_ldmod_name(env, libnode, version, prefix, suffix, **kw):
+    pg = SCons.Tool.LdModPrefixGenerator
+    sg = SCons.Tool.LdModSuffixGenerator
+    return _versioned_lib_name(env, libnode, version, prefix, suffix, pg, sg, **kw)
 
 
 def generate(env):