summaryrefslogtreecommitdiff
path: root/src/engine/SCons/Tool/__init__.py
diff options
context:
space:
mode:
Diffstat (limited to 'src/engine/SCons/Tool/__init__.py')
-rw-r--r--src/engine/SCons/Tool/__init__.py564
1 files changed, 426 insertions, 138 deletions
diff --git a/src/engine/SCons/Tool/__init__.py b/src/engine/SCons/Tool/__init__.py
index bb9729a..ac24134 100644
--- a/src/engine/SCons/Tool/__init__.py
+++ b/src/engine/SCons/Tool/__init__.py
@@ -35,7 +35,7 @@ tool definition.
# 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__ = "src/engine/SCons/Tool/__init__.py rel_2.4.0:3365:9259ea1c13d7 2015/09/21 14:03:43 bdbaddog"
+__revision__ = "src/engine/SCons/Tool/__init__.py rel_2.4.1:3453:73fefd3ea0b0 2015/11/09 03:25:05 bdbaddog"
import imp
import sys
@@ -236,150 +236,436 @@ def createStaticLibBuilder(env):
return static_lib
-def VersionShLibLinkNames(version, libname, env):
- """Generate names of symlinks to the versioned shared library"""
+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 met, 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
- platform = env.subst('$PLATFORM')
- shlib_suffix = env.subst('$SHLIBSUFFIX')
- shlink_flags = SCons.Util.CLVar(env.subst('$SHLINKFLAGS'))
-
- linknames = []
- if version.count(".") != 2:
- # We need a version string of the form x.y.z to proceed
- # Several changes need to be made to support versions like x.y
- raise ValueError
-
- if platform == 'darwin':
- # For libfoo.x.y.z.dylib, linknames libfoo.so
- suffix_re = re.escape('.' + version + shlib_suffix)
- linkname = re.sub(suffix_re, shlib_suffix, libname)
+
+ if Verbose:
+ print '_call_linker_cb: args=%r' % args
+ print '_call_linker_cb: callback=%r' % callback
+
+ try:
+ cbfun = env['LINKCALLBACKS'][callback]
+ except (KeyError, TypeError):
if Verbose:
- print "VersionShLibLinkNames: linkname = ",linkname
- linknames.append(linkname)
- elif platform == 'posix' or platform == 'sunos':
- if sys.platform.startswith('openbsd'):
- # OpenBSD uses x.y shared library versioning numbering convention
- # and doesn't use symlinks to backwards-compatible libraries
- return []
- # For libfoo.so.x.y.z, linknames libfoo.so libfoo.so.x.y libfoo.so.x
- suffix_re = re.escape(shlib_suffix + '.' + version)
- # First linkname has no version number
- linkname = re.sub(suffix_re, shlib_suffix, libname)
+ print '_call_linker_cb: env["LINKCALLBACKS"][%r] not found or can not be used' % callback
+ pass
+ else:
if Verbose:
- print "VersionShLibLinkNames: linkname = ",linkname
- linknames.append(linkname)
- versionparts = version.split('.')
- major_name = linkname + "." + versionparts[0]
- minor_name = major_name + "." + versionparts[1]
- #Only add link for major_name
- #for linkname in [major_name, minor_name]:
- for linkname in [major_name, ]:
+ print '_call_linker_cb: env["LINKCALLBACKS"][%r] found' % callback
+ print '_call_linker_cb: env["LINKCALLBACKS"][%r]=%r' % (callback, cbfun)
+ if(callable(cbfun)):
if Verbose:
- print "VersionShLibLinkNames: linkname ",linkname, ", target ",libname
- linknames.append(linkname)
- # note: no Windows case here (win32 or cygwin);
- # MSVC doesn't support this type of versioned shared libs.
- # (could probably do something for MinGW though)
- return linknames
-
-def VersionedSharedLibrary(target = None, source= None, env=None):
- """Build a shared library. If the environment has SHLIBVERSION
-defined make a versioned shared library and create the appropriate
-symlinks for the platform we are on"""
- Verbose = False
- try:
- version = env.subst('$SHLIBVERSION')
- except KeyError:
- version = None
+ print '_call_linker_cb: env["LINKCALLBACKS"][%r] is callable' % callback
+ result = cbfun(env, *args)
+ return result
- # libname includes the version number if one was given
- libname = getattr(target[0].attributes, 'shlibname', target[0].name)
- platform = env.subst('$PLATFORM')
- shlib_suffix = env.subst('$SHLIBSUFFIX')
- shlink_flags = SCons.Util.CLVar(env.subst('$SHLINKFLAGS'))
- if Verbose:
- print "VersionShLib: libname = ",libname
- print "VersionShLib: platform = ",platform
- print "VersionShLib: shlib_suffix = ",shlib_suffix
- print "VersionShLib: target = ",str(target[0])
-
- if version:
- # set the shared library link flags
- if platform == 'posix':
- shlink_flags += [ '-Wl,-Bsymbolic' ]
- # OpenBSD doesn't usually use SONAME for libraries
- if not sys.platform.startswith('openbsd'):
- # continue setup of shlink flags for all other POSIX systems
- suffix_re = re.escape(shlib_suffix + '.' + version)
- (major, age, revision) = version.split(".")
- # soname will have only the major version number in it
- soname = re.sub(suffix_re, shlib_suffix, libname) + '.' + major
- shlink_flags += [ '-Wl,-soname=%s' % soname ]
- if Verbose:
- print " soname ",soname,", shlink_flags ",shlink_flags
- elif platform == 'sunos':
- suffix_re = re.escape(shlib_suffix + '.' + version)
- (major, age, revision) = version.split(".")
- soname = re.sub(suffix_re, shlib_suffix, libname) + '.' + major
- shlink_flags += [ '-h', soname ]
- elif platform == 'cygwin':
- shlink_flags += [ '-Wl,-Bsymbolic',
- '-Wl,--out-implib,${TARGET.base}.a' ]
- elif platform == 'darwin':
- shlink_flags += [ '-current_version', '%s' % version,
- '-compatibility_version', '%s' % version,
- '-undefined', 'dynamic_lookup' ]
+def _call_env_subst(env, string, *args, **kw):
+ kw2 = {}
+ for k in ('raw', 'target', 'source', 'conv', 'executor'):
+ try: kw2[k] = kw[k]
+ except KeyError: pass
+ return env.subst(string, *args, **kw2)
+
+class _ShLibInfoSupport(object):
+ def get_libtype(self):
+ return 'ShLib'
+ def get_lib_prefix(self, env, *args, **kw):
+ return _call_env_subst(env,'$SHLIBPREFIX', *args, **kw)
+ def get_lib_suffix(self, env, *args, **kw):
+ return _call_env_subst(env,'$SHLIBSUFFIX', *args, **kw)
+ def get_lib_version(self, env, *args, **kw):
+ return _call_env_subst(env,'$SHLIBVERSION', *args, **kw)
+ def get_lib_noversionsymlinks(self, env, *args, **kw):
+ return _call_env_subst(env,'$SHLIBNOVERSIONSYMLINKS', *args, **kw)
+
+class _LdModInfoSupport(object):
+ def get_libtype(self):
+ return 'LdMod'
+ def get_lib_prefix(self, env, *args, **kw):
+ return _call_env_subst(env,'$LDMODULEPREFIX', *args, **kw)
+ def get_lib_suffix(self, env, *args, **kw):
+ return _call_env_subst(env,'$LDMODULESUFFIX', *args, **kw)
+ def get_lib_version(self, env, *args, **kw):
+ return _call_env_subst(env,'$LDMODULEVERSION', *args, **kw)
+ def get_lib_noversionsymlinks(self, env, *args, **kw):
+ return _call_env_subst(env,'$LDMODULENOVERSIONSYMLINKS', *args, **kw)
+
+class _ImpLibInfoSupport(object):
+ def get_libtype(self):
+ return 'ImpLib'
+ def get_lib_prefix(self, env, *args, **kw):
+ return _call_env_subst(env,'$IMPLIBPREFIX', *args, **kw)
+ def get_lib_suffix(self, env, *args, **kw):
+ return _call_env_subst(env,'$IMPLIBSUFFIX', *args, **kw)
+ def get_lib_version(self, env, *args, **kw):
+ version = _call_env_subst(env,'$IMPLIBVERSION', *args, **kw)
+ if not version:
+ try: lt = kw['implib_libtype']
+ except KeyError: pass
+ else:
+ if lt == 'ShLib':
+ version = _call_env_subst(env,'$SHLIBVERSION', *args, **kw)
+ elif lt == 'LdMod':
+ version = _call_env_subst(env,'$LDMODULEVERSION', *args, **kw)
+ return version
+ def get_lib_noversionsymlinks(self, env, *args, **kw):
+ disable = None
+ try: env['IMPLIBNOVERSIONSYMLINKS']
+ except KeyError:
+ try: lt = kw['implib_libtype']
+ except KeyError: pass
+ else:
+ if lt == 'ShLib':
+ disable = _call_env_subst(env,'$SHLIBNOVERSIONSYMLINKS', *args, **kw)
+ elif lt == 'LdMod':
+ disable = _call_env_subst(env,'$LDMODULENOVERSIONSYMLINKS', *args, **kw)
+ else:
+ disable = _call_env_subst(env,'$IMPLIBNOVERSIONSYMLINKS', *args, **kw)
+ return disable
+
+class _LibInfoGeneratorBase(object):
+ """Generator base class for library-related info such as suffixes for
+ versioned libraries, symlink maps, sonames etc. It handles commonities
+ of SharedLibrary and LoadableModule
+ """
+ _support_classes = { 'ShLib' : _ShLibInfoSupport,
+ 'LdMod' : _LdModInfoSupport,
+ 'ImpLib' : _ImpLibInfoSupport }
+ def __init__(self, libtype, infoname):
+ self.set_libtype(libtype)
+ self.set_infoname(infoname)
+
+ def set_libtype(self, libtype):
+ try:
+ support_class = self._support_classes[libtype]
+ except KeyError:
+ raise ValueError('unsupported libtype %r' % libtype)
+ self._support = support_class()
+
+ def get_libtype(self):
+ return self._support.get_libtype()
+
+ def set_infoname(self, infoname):
+ self.infoname = infoname
+
+ def get_infoname(self):
+ return self.infoname
+
+ def get_lib_prefix(self, env, *args, **kw):
+ return self._support.get_lib_prefix(env,*args,**kw)
+
+ def get_lib_suffix(self, env, *args, **kw):
+ return self._support.get_lib_suffix(env,*args,**kw)
+
+ def get_lib_version(self, env, *args, **kw):
+ return self._support.get_lib_version(env,*args,**kw)
+
+ def get_lib_noversionsymlinks(self, env, *args, **kw):
+ return self._support.get_lib_noversionsymlinks(env,*args,**kw)
+
+ # Returns name of generator linker callback that shall be used to generate
+ # our info for a versioned library. For example, if our libtype is 'ShLib'
+ # and infoname is 'Prefix', it would return 'VersionedShLibPrefix'.
+ def get_versioned_lib_info_generator(self, **kw):
+ try: libtype = kw['generator_libtype']
+ except KeyError: libtype = self.get_libtype()
+ infoname = self.get_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_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
+
+ if sources and 'source' not in kw:
+ kw2 = kw.copy()
+ kw2['source'] = sources
+ else:
+ kw2 = kw
+
+ prefix = self.get_lib_prefix(env,**kw2)
if Verbose:
- print "VersionShLib: shlink_flags = ",shlink_flags
- envlink = env.Clone()
- envlink['SHLINKFLAGS'] = shlink_flags
- else:
- envlink = env
+ print "_LibPrefixGenerator: input prefix=%r" % prefix
+
+ version = self.get_lib_version(env, **kw2)
+ if Verbose:
+ print "_LibPrefixGenerator: version=%r" % version
- result = SCons.Defaults.ShLinkAction(target, source, envlink)
+ if version:
+ prefix = self.generate_versioned_lib_info(env, [prefix, version], prefix, **kw2)
- if version:
- # here we need the full pathname so the links end up in the right directory
- libname = getattr(target[0].attributes, 'shlibpath', target[0].get_internal_path())
if Verbose:
- print "VerShLib: target lib is = ", libname
- print "VerShLib: name is = ", target[0].name
- print "VerShLib: dir is = ", target[0].dir.path
- linknames = VersionShLibLinkNames(version, libname, env)
+ 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
+ LoadableModule builders"""
+ def __init__(self, libtype):
+ super(_LibSuffixGenerator, self).__init__(libtype, 'Suffix')
+
+ def __call__(self, env, sources = None, **kw):
+ Verbose = False
+
+ if sources and 'source' not in kw:
+ kw2 = kw.copy()
+ kw2['source'] = sources
+ else:
+ kw2 = kw
+
+ suffix = self.get_lib_suffix(env, **kw2)
if Verbose:
- print "VerShLib: linknames ",linknames
- # Here we just need the file name w/o path as the target of the link
- lib_ver = getattr(target[0].attributes, 'shlibname', target[0].name)
- # make symlink of adjacent names in linknames
- for count in range(len(linknames)):
- linkname = linknames[count]
- if count > 0:
- try:
- os.remove(lastlinkname)
- except:
- pass
- os.symlink(os.path.basename(linkname),lastlinkname)
- if Verbose:
- print "VerShLib: made sym link of %s -> %s" % (lastlinkname,linkname)
- lastlinkname = linkname
- # finish chain of sym links with link to the actual library
- if len(linknames)>0:
+ print "_LibSuffixGenerator: input suffix=%r" % suffix
+
+ version = self.get_lib_version(env, **kw2)
+ if Verbose:
+ print "_LibSuffixGenerator: version=%r" % version
+
+ if version:
+ suffix = self.generate_versioned_lib_info(env, [suffix, version], suffix, **kw2)
+
+ if Verbose:
+ print "_LibSuffixGenerator: return suffix=%r" % suffix
+ return suffix
+
+ShLibSuffixGenerator = _LibSuffixGenerator('ShLib')
+LdModSuffixGenerator = _LibSuffixGenerator('LdMod')
+ImpLibSuffixGenerator = _LibSuffixGenerator('ImpLib')
+
+class _LibSymlinkGenerator(_LibInfoGeneratorBase):
+ """Library symlink map generator. It generates a list of symlinks that
+ should be created by SharedLibrary or LoadableModule builders"""
+ def __init__(self, libtype):
+ super(_LibSymlinkGenerator, self).__init__(libtype, 'Symlinks')
+
+ def __call__(self, env, libnode, **kw):
+ Verbose = False
+
+ if libnode and 'target' not in kw:
+ kw2 = kw.copy()
+ kw2['target'] = libnode
+ else:
+ kw2 = kw
+
+ if Verbose:
+ print "_LibSymLinkGenerator: libnode=%r" % libnode.get_path()
+
+ symlinks = None
+
+ version = self.get_lib_version(env, **kw2)
+ disable = self.get_lib_noversionsymlinks(env, **kw2)
+ if Verbose:
+ print '_LibSymlinkGenerator: version=%r' % version
+ print '_LibSymlinkGenerator: disable=%r' % disable
+
+ if version and not disable:
+ prefix = self.get_lib_prefix(env,**kw2)
+ suffix = self.get_lib_suffix(env,**kw2)
+ symlinks = self.generate_versioned_lib_info(env, [libnode, version, prefix, suffix], **kw2)
+
+ if Verbose:
+ print '_LibSymlinkGenerator: return symlinks=%r' % StringizeLibSymlinks(symlinks)
+ return symlinks
+
+ShLibSymlinkGenerator = _LibSymlinkGenerator('ShLib')
+LdModSymlinkGenerator = _LibSymlinkGenerator('LdMod')
+ImpLibSymlinkGenerator = _LibSymlinkGenerator('ImpLib')
+
+class _LibNameGenerator(_LibInfoGeneratorBase):
+ """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')
+
+ def __call__(self, env, libnode, **kw):
+ """Returns "demangled" library name"""
+ Verbose = False
+
+ if libnode and 'target' not in kw:
+ kw2 = kw.copy()
+ kw2['target'] = libnode
+ else:
+ kw2 = kw
+
+ if Verbose:
+ print "_LibNameGenerator: libnode=%r" % libnode.get_path()
+
+ version = self.get_lib_version(env, **kw2)
+ if Verbose:
+ print '_LibNameGenerator: version=%r' % version
+
+ name = None
+ if version:
+ prefix = self.get_lib_prefix(env,**kw2)
+ suffix = self.get_lib_suffix(env,**kw2)
+ name = self.generate_versioned_lib_info(env, [libnode, version, prefix, suffix], **kw2)
+
+ if not name:
+ name = os.path.basename(libnode.get_path())
+
+ if Verbose:
+ print '_LibNameGenerator: return name=%r' % name
+
+ return name
+
+ShLibNameGenerator = _LibNameGenerator('ShLib')
+LdModNameGenerator = _LibNameGenerator('LdMod')
+ImpLibNameGenerator = _LibNameGenerator('ImpLib')
+
+class _LibSonameGenerator(_LibInfoGeneratorBase):
+ """Library soname generator. Returns library soname (e.g. libfoo.so.0) for
+ a given node (e.g. /foo/bar/libfoo.so.0.1.2)"""
+ def __init__(self, libtype):
+ super(_LibSonameGenerator, self).__init__(libtype, 'Soname')
+
+ def __call__(self, env, libnode, **kw):
+ """Returns a SONAME based on a shared library's node path"""
+ Verbose = False
+
+ if libnode and 'target' not in kw:
+ kw2 = kw.copy()
+ kw2['target'] = libnode
+ else:
+ kw2 = kw
+
+ if Verbose:
+ print "_LibSonameGenerator: libnode=%r" % libnode.get_path()
+
+ soname = _call_env_subst(env, '$SONAME', **kw2)
+ if not soname:
+ version = self.get_lib_version(env,**kw2)
+ if Verbose:
+ print "_LibSonameGenerator: version=%r" % version
+ if version:
+ prefix = self.get_lib_prefix(env,**kw2)
+ suffix = self.get_lib_suffix(env,**kw2)
+ soname = self.generate_versioned_lib_info(env, [libnode, version, prefix, suffix], **kw2)
+
+ if not soname:
+ # fallback to library name (as returned by appropriate _LibNameGenerator)
+ soname = _LibNameGenerator(self.get_libtype())(env, libnode)
+ if Verbose:
+ print "_LibSonameGenerator: FALLBACK: soname=%r" % soname
+
+ if Verbose:
+ print "_LibSonameGenerator: return soname=%r" % soname
+
+ return soname
+
+ShLibSonameGenerator = _LibSonameGenerator('ShLib')
+LdModSonameGenerator = _LibSonameGenerator('LdMod')
+
+def StringizeLibSymlinks(symlinks):
+ """Converts list with pairs of nodes to list with pairs of node paths
+ (strings). Used mainly for debugging."""
+ if SCons.Util.is_List(symlinks):
+ try:
+ return [ (k.get_path(), v.get_path()) for k,v in symlinks ]
+ except (TypeError, ValueError):
+ return symlinks
+ else:
+ return symlinks
+
+def EmitLibSymlinks(env, symlinks, libnode, **kw):
+ """Used by emitters to handle (shared/versioned) library symlinks"""
+ Verbose = False
+
+ # nodes involved in process... all symlinks + library
+ nodes = list(set([ x for x,y in symlinks ] + [libnode]))
+
+ clean_targets = kw.get('clean_targets', [])
+ if not SCons.Util.is_List(clean_targets):
+ clean_targets = [ clean_targets ]
+
+ for link, linktgt in symlinks:
+ env.SideEffect(link, linktgt)
+ if(Verbose):
+ print "EmitLibSymlinks: SideEffect(%r,%r)" % (link.get_path(), linktgt.get_path())
+ clean_list = filter(lambda x : x != linktgt, nodes)
+ env.Clean(list(set([linktgt] + clean_targets)), clean_list)
+ if(Verbose):
+ print "EmitLibSymlinks: Clean(%r,%r)" % (linktgt.get_path(), map(lambda x : x.get_path(), clean_list))
+
+def CreateLibSymlinks(env, symlinks):
+ """Physically creates symlinks. The symlinks argument must be a list in
+ form [ (link, linktarget), ... ], where link and linktarget are SCons
+ nodes.
+ """
+
+ Verbose = False
+ for link, linktgt in symlinks:
+ linktgt = link.get_dir().rel_path(linktgt)
+ link = link.get_path()
+ if(Verbose):
+ print "CreateLibSymlinks: preparing to add symlink %r -> %r" % (link, linktgt)
+ # Delete the (previously created) symlink if exists. Let only symlinks
+ # to be deleted to prevent accidental deletion of source files...
+ if env.fs.islink(link):
+ env.fs.unlink(link)
+ if(Verbose):
+ print "CreateLibSymlinks: removed old symlink %r" % link
+ # If a file or directory exists with the same name as link, an OSError
+ # will be thrown, which should be enough, I think.
+ env.fs.symlink(linktgt, link)
+ if(Verbose):
+ print "CreateLibSymlinks: add symlink %r -> %r" % (link, linktgt)
+ return 0
+
+def LibSymlinksActionFunction(target, source, env):
+ for tgt in target:
+ symlinks = getattr(getattr(tgt,'attributes', None), 'shliblinks', None)
+ if symlinks:
+ CreateLibSymlinks(env, symlinks)
+ return 0
+
+def LibSymlinksStrFun(target, source, env, *args):
+ cmd = None
+ for tgt in target:
+ symlinks = getattr(getattr(tgt,'attributes', None), 'shliblinks', None)
+ if symlinks:
+ if cmd is None: cmd = ""
+ if cmd: cmd += "\n"
+ cmd += "Create symlinks for: %r" % tgt.get_path()
try:
- os.remove(lastlinkname)
- except:
+ linkstr = ', '.join([ "%r->%r" %(k,v) for k,v in StringizeLibSymlinks(symlinks)])
+ except (KeyError, ValueError):
pass
- os.symlink(lib_ver,lastlinkname)
- if Verbose:
- print "VerShLib: made sym link of %s -> %s" % (linkname, lib_ver)
- return result
+ else:
+ cmd += ": %s" % linkstr
+ return cmd
+
-# Fix http://scons.tigris.org/issues/show_bug.cgi?id=2903 :
-# Ensure we still depend on SCons.Defaults.ShLinkAction command line which is $SHLINKCOM.
-# This was tricky because we don't want changing LIBPATH to cause a rebuild, but
-# changing other link args should. LIBPATH has $( ... $) around it but until this
-# fix, when the varlist was added to the build sig those ignored parts weren't getting
-# ignored.
-ShLibAction = SCons.Action.Action(VersionedSharedLibrary, None, varlist=['SHLINKCOM'])
+LibSymlinksAction = SCons.Action.Action(LibSymlinksActionFunction, LibSymlinksStrFun)
def createSharedLibBuilder(env):
"""This is a utility function that creates the SharedLibrary
@@ -393,11 +679,12 @@ def createSharedLibBuilder(env):
except KeyError:
import SCons.Defaults
action_list = [ SCons.Defaults.SharedCheck,
- ShLibAction ]
+ SCons.Defaults.ShLinkAction,
+ LibSymlinksAction ]
shared_lib = SCons.Builder.Builder(action = action_list,
emitter = "$SHLIBEMITTER",
- prefix = '$SHLIBPREFIX',
- suffix = '$SHLIBSUFFIX',
+ prefix = ShLibPrefixGenerator,
+ suffix = ShLibSuffixGenerator,
target_scanner = ProgramScanner,
src_suffix = '$SHOBJSUFFIX',
src_builder = 'SharedObject')
@@ -417,11 +704,12 @@ def createLoadableModuleBuilder(env):
except KeyError:
import SCons.Defaults
action_list = [ SCons.Defaults.SharedCheck,
- SCons.Defaults.LdModuleLinkAction ]
+ SCons.Defaults.LdModuleLinkAction,
+ LibSymlinksAction ]
ld_module = SCons.Builder.Builder(action = action_list,
emitter = "$LDMODULEEMITTER",
- prefix = '$LDMODULEPREFIX',
- suffix = '$LDMODULESUFFIX',
+ prefix = LdModPrefixGenerator,
+ suffix = LdModSuffixGenerator,
target_scanner = ProgramScanner,
src_suffix = '$SHOBJSUFFIX',
src_builder = 'SharedObject')