Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/build/inline_copy/lib/scons-4.3.0/SCons/Tool/linkCommon/LoadableModule.py

@@ -0,0 +1,131 @@
+# MIT License
+#
+# Copyright The SCons Foundation
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+from SCons.Tool import createLoadableModuleBuilder
+from .SharedLibrary import shlib_symlink_emitter
+from . import lib_emitter
+
+
+def ldmod_symlink_emitter(target, source, env, **kw):
+    return shlib_symlink_emitter(target, source, env, variable_prefix='LDMODULE')
+
+
+def _get_ldmodule_stem(target, source, env, for_signature):
+    """
+    Get the basename for a library (so for libxyz.so, return xyz)
+    :param target:
+    :param source:
+    :param env:
+    :param for_signature:
+    :return:
+    """
+    target_name = str(target)
+    ldmodule_prefix = env.subst('$LDMODULEPREFIX')
+    ldmodule_suffix = env.subst("$_LDMODULESUFFIX")
+
+    if target_name.startswith(ldmodule_prefix):
+        target_name = target_name[len(ldmodule_prefix):]
+
+    if target_name.endswith(ldmodule_suffix):
+        target_name = target_name[:-len(ldmodule_suffix)]
+
+    return target_name
+
+
+def _ldmodule_soversion(target, source, env, for_signature):
+    """Function to determine what to use for SOVERSION"""
+
+    if 'SOVERSION' in env:
+        return '.$SOVERSION'
+    elif 'LDMODULEVERSION' in env:
+        ldmod_version = env.subst('$LDMODULEVERSION')
+        # We use only the most significant digit of LDMODULEVERSION
+        return '.' + ldmod_version.split('.')[0]
+    else:
+        return ''
+
+
+def _ldmodule_soname(target, source, env, for_signature):
+    if 'SONAME' in env:
+        return '$SONAME'
+    else:
+        return "$LDMODULEPREFIX$_get_ldmodule_stem${LDMODULESUFFIX}$_LDMODULESOVERSION"
+
+def _LDMODULEVERSION(target, source, env, for_signature):
+    """
+    Return "." + version if it's set, otherwise just a blank
+    """
+    value = env.subst('$LDMODULEVERSION', target=target, source=source)
+    # print("_has_LDMODULEVERSION:%s"%value)
+    if value:
+        return "."+value
+    else:
+        return ""
+
+def setup_loadable_module_logic(env):
+    """
+    Just the logic for loadable modules
+
+    For most platforms, a loadable module is the same as a shared
+    library.  Platforms which are different can override these, but
+    setting them the same means that LoadableModule works everywhere.
+
+    :param env:
+    :return:
+    """
+
+    createLoadableModuleBuilder(env)
+
+    env['_get_ldmodule_stem'] = _get_ldmodule_stem
+    env['_LDMODULESOVERSION'] = _ldmodule_soversion
+    env['_LDMODULESONAME'] = _ldmodule_soname
+
+    env['LDMODULENAME'] = '${LDMODULEPREFIX}$_get_ldmodule_stem${_LDMODULESUFFIX}'
+
+    # This is the non versioned LDMODULE filename
+    # If LDMODULEVERSION is defined then this will symlink to $LDMODULENAME
+    env['LDMODULE_NOVERSION_SYMLINK'] = '$_get_shlib_dir${LDMODULEPREFIX}$_get_ldmodule_stem${LDMODULESUFFIX}'
+
+    # This is the sonamed file name
+    # If LDMODULEVERSION is defined then this will symlink to $LDMODULENAME
+    env['LDMODULE_SONAME_SYMLINK'] = '$_get_shlib_dir$_LDMODULESONAME'
+
+    env['_LDMODULEVERSION'] =  _LDMODULEVERSION
+
+    env['_LDMODULEVERSIONFLAGS'] = '$LDMODULEVERSIONFLAGS -Wl,-soname=$_LDMODULESONAME'
+
+    env['LDMODULEEMITTER'] = [lib_emitter, ldmod_symlink_emitter]
+
+    env['LDMODULEPREFIX'] = '$SHLIBPREFIX'
+    env['_LDMODULESUFFIX'] = '${LDMODULESUFFIX}${_LDMODULEVERSION}'
+    env['LDMODULESUFFIX'] = '$SHLIBSUFFIX'
+
+    env['LDMODULE'] = '$SHLINK'
+
+    env['LDMODULEFLAGS'] = '$SHLINKFLAGS'
+
+    env['LDMODULECOM'] = '$LDMODULE -o $TARGET $LDMODULEFLAGS $__LDMODULEVERSIONFLAGS $__RPATH $SOURCES ' \
+                         '$_LIBDIRFLAGS $_LIBFLAGS '
+
+    env['LDMODULEVERSION'] = '$SHLIBVERSION'
+    env['LDMODULENOVERSIONSYMLINKS'] = '$SHLIBNOVERSIONSYMLINKS'

nuitka/build/inline_copy/lib/scons-4.3.0/SCons/Tool/linkCommon/SharedLibrary.py

@@ -0,0 +1,218 @@
+# MIT License
+#
+# Copyright The SCons Foundation
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+from SCons.Errors import UserError
+from SCons.Tool import createSharedLibBuilder
+from SCons.Util import CLVar
+from . import lib_emitter, EmitLibSymlinks, StringizeLibSymlinks
+
+
+def shlib_symlink_emitter(target, source, env, **kw):
+    verbose = False
+
+    if "variable_prefix" in kw:
+        var_prefix = kw["variable_prefix"]
+    else:
+        var_prefix = "SHLIB"
+
+    do_symlinks = env.subst("$%sNOVERSIONSYMLINKS" % var_prefix)
+    if do_symlinks in ["1", "True", "true", True]:
+        return target, source
+
+    shlibversion = env.subst("$%sVERSION" % var_prefix)
+    if shlibversion:
+        if verbose:
+            print("shlib_symlink_emitter: %sVERSION=%s" % (var_prefix, shlibversion))
+
+        libnode = target[0]
+        shlib_soname_symlink = env.subst(
+            "$%s_SONAME_SYMLINK" % var_prefix, target=target, source=source
+        )
+        shlib_noversion_symlink = env.subst(
+            "$%s_NOVERSION_SYMLINK" % var_prefix, target=target, source=source
+        )
+
+        if verbose:
+            print("shlib_soname_symlink    :%s" % shlib_soname_symlink)
+            print("shlib_noversion_symlink :%s" % shlib_noversion_symlink)
+            print("libnode                 :%s" % libnode)
+
+        shlib_soname_symlink = env.File(shlib_soname_symlink)
+        shlib_noversion_symlink = env.File(shlib_noversion_symlink)
+
+        symlinks = []
+        if shlib_soname_symlink != libnode:
+            # If soname and library name machine, don't symlink them together
+            symlinks.append((env.File(shlib_soname_symlink), libnode))
+
+        symlinks.append((env.File(shlib_noversion_symlink), libnode))
+
+        if verbose:
+            print(
+                "_lib_emitter: symlinks={!r}".format(
+                    ", ".join(
+                        ["%r->%r" % (k, v) for k, v in StringizeLibSymlinks(symlinks)]
+                    )
+                )
+            )
+
+        if symlinks:
+            # This does the actual symlinking
+            EmitLibSymlinks(env, symlinks, target[0])
+
+            # This saves the information so if the versioned shared library is installed
+            # it can faithfully reproduce the correct symlinks
+            target[0].attributes.shliblinks = symlinks
+
+    return target, source
+
+
+def _soversion(target, source, env, for_signature):
+    """Function to determine what to use for SOVERSION"""
+
+    if "SOVERSION" in env:
+        return ".$SOVERSION"
+    elif "SHLIBVERSION" in env:
+        shlibversion = env.subst("$SHLIBVERSION")
+        # We use only the most significant digit of SHLIBVERSION
+        return "." + shlibversion.split(".")[0]
+    else:
+        return ""
+
+
+def _soname(target, source, env, for_signature):
+    if "SONAME" in env:
+        # Now verify that SOVERSION is not also set as that is not allowed
+        if "SOVERSION" in env:
+            raise UserError(
+                "Ambiguous library .so naming, both SONAME: %s and SOVERSION: %s are defined. "
+                "Only one can be defined for a target library."
+                % (env["SONAME"], env["SOVERSION"])
+            )
+        return "$SONAME"
+    else:
+        return "$SHLIBPREFIX$_get_shlib_stem${SHLIBSUFFIX}$_SHLIBSOVERSION"
+
+
+def _get_shlib_stem(target, source, env, for_signature: bool) -> str:
+    """Get the base name of a shared library.
+
+    Args:
+        target: target node containing the lib name
+        source: source node, not used
+        env: environment context for running subst
+        for_signature: whether this is being done for signature generation
+
+    Returns:
+        the library name without prefix/suffix
+    """
+    verbose = False
+
+    target_name = str(target.name)
+    shlibprefix = env.subst("$SHLIBPREFIX")
+    shlibsuffix = env.subst("$_SHLIBSUFFIX")
+
+    if verbose and not for_signature:
+        print(
+            "_get_shlib_stem: target_name:%s shlibprefix:%s shlibsuffix:%s"
+            % (target_name, shlibprefix, shlibsuffix)
+        )
+
+
+    if shlibsuffix and target_name.endswith(shlibsuffix):
+        target_name = target_name[: -len(shlibsuffix)]
+
+    if shlibprefix and target_name.startswith(shlibprefix):
+        # skip pathological case were target _is_ the prefix
+        if target_name != shlibprefix:
+            target_name = target_name[len(shlibprefix) :]
+
+
+    if verbose and not for_signature:
+        print("_get_shlib_stem: target_name:%s AFTER" % (target_name,))
+
+    return target_name
+
+
+def _get_shlib_dir(target, source, env, for_signature: bool) -> str:
+    """Get the directory the shared library is in.
+
+    Args:
+        target: target node
+        source: source node, not used
+        env: environment context, not used
+        for_signature: whether this is being done for signature generation
+
+    Returns:
+        the directory the library will be in (empty string if '.')
+    """
+    verbose = False
+
+    if target.dir and str(target.dir) != ".":
+        if verbose:
+            print("_get_shlib_dir: target.dir:%s" % target.dir)
+
+        return "%s/" % str(target.dir)
+    else:
+        return ""
+
+
+def setup_shared_lib_logic(env):
+    """Initialize an environment for shared library building.
+
+    Args:
+        env: environment to set up
+    """
+    createSharedLibBuilder(env)
+
+    env["_get_shlib_stem"] = _get_shlib_stem
+    env["_get_shlib_dir"] = _get_shlib_dir
+    env["_SHLIBSOVERSION"] = _soversion
+    env["_SHLIBSONAME"] = _soname
+
+    env["SHLIBNAME"] = "${_get_shlib_dir}${SHLIBPREFIX}$_get_shlib_stem${_SHLIBSUFFIX}"
+
+    # This is the non versioned shlib filename
+    # If SHLIBVERSION is defined then this will symlink to $SHLIBNAME
+    env["SHLIB_NOVERSION_SYMLINK"] = "${_get_shlib_dir}${SHLIBPREFIX}$_get_shlib_stem${SHLIBSUFFIX}"
+
+    # This is the sonamed file name
+    # If SHLIBVERSION is defined then this will symlink to $SHLIBNAME
+    env["SHLIB_SONAME_SYMLINK"] = "${_get_shlib_dir}$_SHLIBSONAME"
+
+    # Note this is gnu style
+    env["SHLIBSONAMEFLAGS"] = "-Wl,-soname=$_SHLIBSONAME"
+    env["_SHLIBVERSION"] = "${SHLIBVERSION and '.'+SHLIBVERSION or ''}"
+    env["_SHLIBVERSIONFLAGS"] = "$SHLIBVERSIONFLAGS -Wl,-soname=$_SHLIBSONAME"
+
+    env["SHLIBEMITTER"] = [lib_emitter, shlib_symlink_emitter]
+
+    # If it's already set, then don't overwrite.
+    env["SHLIBPREFIX"] = env.get('SHLIBPREFIX', "lib")
+    env["_SHLIBSUFFIX"] = "${SHLIBSUFFIX}${_SHLIBVERSION}"
+
+    env["SHLINKFLAGS"] = CLVar("$LINKFLAGS -shared")
+
+    env["SHLINKCOM"] = "$SHLINK -o $TARGET $SHLINKFLAGS $__SHLIBVERSIONFLAGS $__RPATH $SOURCES $_LIBDIRFLAGS $_LIBFLAGS"
+
+    env["SHLINK"] = "$LINK"

nuitka/build/inline_copy/lib/scons-4.3.0/SCons/Tool/linkCommon/__init__.py

@@ -0,0 +1,171 @@
+# MIT License
+#
+# Copyright The SCons Foundation
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+Common link/shared library logic
+"""
+
+import SCons.Util
+import SCons.Warnings
+# Nuitka: Disable unused tools
+# from SCons.Tool.DCommon import isD
+def isD(env,source): return False
+
+from SCons.Util import is_List
+
+issued_mixed_link_warning = False
+
+
+def StringizeLibSymlinks(symlinks):
+    """Converts list with pairs of nodes to list with pairs of node paths
+    (strings). Used mainly for debugging."""
+    if 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 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 = [x for x in nodes if x != linktgt]
+        env.Clean(list(set([linktgt] + clean_targets)), clean_list)
+        if Verbose:
+            print("EmitLibSymlinks: Clean(%r,%r)" % (linktgt.get_path(), [x.get_path() for x in 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\n    " % tgt.get_path()
+            try:
+                linkstr = '\n    '.join(["%r->%r" % (k, v) for k, v in StringizeLibSymlinks(symlinks)])
+            except (KeyError, ValueError):
+                pass
+            else:
+                cmd += "%s" % linkstr
+    return cmd
+
+
+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)
+
+
+def smart_link(source, target, env, for_signature):
+    import SCons.Tool.cxx
+    # Nuitka: Avoid ununused tools
+    # import SCons.Tool.FortranCommon
+
+    has_cplusplus = SCons.Tool.cxx.iscplusplus(source)
+    has_fortran = False
+    has_d = isD(env, source)
+    if has_cplusplus and has_fortran and not has_d:
+        global issued_mixed_link_warning
+        if not issued_mixed_link_warning:
+            msg = "Using $CXX to link Fortran and C++ code together.\n\t" + \
+                  "This may generate a buggy executable if the '%s'\n\t" + \
+                  "compiler does not know how to deal with Fortran runtimes."
+            SCons.Warnings.warn(SCons.Warnings.FortranCxxMixWarning,
+                                msg % env.subst('$CXX'))
+            issued_mixed_link_warning = True
+        return '$CXX'
+    elif has_d:
+        env['LINKCOM'] = env['DLINKCOM']
+        env['SHLINKCOM'] = env['SHDLINKCOM']
+        return '$DC'
+    elif has_fortran:
+        return '$FORTRAN'
+    elif has_cplusplus:
+        return '$CXX'
+    return '$CC'
+
+
+def lib_emitter(target, source, env, **kw):
+    verbose = False
+    if verbose:
+        print("_lib_emitter: target[0]={!r}".format(target[0].get_path()))
+    for tgt in target:
+        if SCons.Util.is_String(tgt):
+            tgt = env.File(tgt)
+        tgt.attributes.shared = 1
+
+    return target, source

nuitka/build/inline_copy/lib/scons-4.3.0/SCons/Tool/linkloc.py

@@ -0,0 +1,112 @@
+"""SCons.Tool.linkloc
+
+Tool specification for the LinkLoc linker for the Phar Lap ETS embedded
+operating system.
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+"""
+
+#
+# __COPYRIGHT__
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# 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__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+
+import re
+
+import SCons.Action
+import SCons.Defaults
+import SCons.Errors
+import SCons.Tool
+import SCons.Util
+
+from SCons.Tool.MSCommon import msvs_exists, merge_default_version
+from SCons.Tool.PharLapCommon import addPharLapPaths
+
+_re_linker_command = re.compile(r'(\s)@\s*([^\s]+)')
+
+def repl_linker_command(m):
+    # Replaces any linker command file directives (e.g. "@foo.lnk") with
+    # the actual contents of the file.
+    try:
+        with open(m.group(2), "r") as f:
+            return m.group(1) + f.read()
+    except IOError:
+        # the linker should return an error if it can't
+        # find the linker command file so we will remain quiet.
+        # However, we will replace the @ with a # so we will not continue
+        # to find it with recursive substitution
+        return m.group(1) + '#' + m.group(2)
+
+class LinklocGenerator:
+    def __init__(self, cmdline):
+        self.cmdline = cmdline
+
+    def __call__(self, env, target, source, for_signature):
+        if for_signature:
+            # Expand the contents of any linker command files recursively
+            subs = 1
+            strsub = env.subst(self.cmdline, target=target, source=source)
+            while subs:
+                strsub, subs = _re_linker_command.subn(repl_linker_command, strsub)
+            return strsub
+        else:
+            return "${TEMPFILE('" + self.cmdline + "')}"
+
+def generate(env):
+    """Add Builders and construction variables for ar to an Environment."""
+    SCons.Tool.createSharedLibBuilder(env)
+    SCons.Tool.createProgBuilder(env)
+
+    env['SUBST_CMD_FILE'] = LinklocGenerator
+    env['SHLINK']      = '$LINK'
+    env['SHLINKFLAGS'] = SCons.Util.CLVar('$LINKFLAGS')
+    env['SHLINKCOM']   = '${SUBST_CMD_FILE("$SHLINK $SHLINKFLAGS $_LIBDIRFLAGS $_LIBFLAGS -dll $TARGET $SOURCES")}'
+    env['SHLIBEMITTER']= None
+    env['LDMODULEEMITTER']= None
+    env['LINK']        = "linkloc"
+    env['LINKFLAGS']   = SCons.Util.CLVar('')
+    env['LINKCOM']     = '${SUBST_CMD_FILE("$LINK $LINKFLAGS $_LIBDIRFLAGS $_LIBFLAGS -exe $TARGET $SOURCES")}'
+    env['LIBDIRPREFIX']='-libpath '
+    env['LIBDIRSUFFIX']=''
+    env['LIBLINKPREFIX']='-lib '
+    env['LIBLINKSUFFIX']='$LIBSUFFIX'
+
+    # Set-up ms tools paths for default version
+    merge_default_version(env)
+
+    addPharLapPaths(env)
+
+def exists(env):
+    if msvs_exists(env):
+        return env.Detect('linkloc')
+    else:
+        return 0
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:

nuitka/build/inline_copy/lib/scons-4.3.0/SCons/Tool/m4.py

@@ -0,0 +1,63 @@
+"""SCons.Tool.m4
+
+Tool-specific initialization for m4.
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+"""
+
+#
+# __COPYRIGHT__
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# 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__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+
+import SCons.Action
+import SCons.Builder
+import SCons.Util
+
+def generate(env):
+    """Add Builders and construction variables for m4 to an Environment."""
+    M4Action = SCons.Action.Action('$M4COM', '$M4COMSTR')
+    bld = SCons.Builder.Builder(action = M4Action, src_suffix = '.m4')
+
+    env['BUILDERS']['M4'] = bld
+
+    # .m4 files might include other files, and it would be pretty hard
+    # to write a scanner for it, so let's just cd to the dir of the m4
+    # file and run from there.
+    # The src_suffix setup is like so: file.c.m4 -> file.c,
+    # file.cpp.m4 -> file.cpp etc.
+    env['M4']      = 'm4'
+    env['M4FLAGS'] = SCons.Util.CLVar('-E')
+    env['M4COM']   = 'cd ${SOURCE.rsrcdir} && $M4 $M4FLAGS < ${SOURCE.file} > ${TARGET.abspath}'
+
+def exists(env):
+    return env.Detect('m4')
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4: