Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

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

@@ -0,0 +1,212 @@
+"""SCons.Tool.cyglink
+
+Customization of gnulink for Cygwin (http://www.cygwin.com/)
+
+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.
+
+"""
+
+from SCons.Tool.linkCommon import StringizeLibSymlinks, EmitLibSymlinks
+from SCons.Util import CLVar, is_String
+from . import gnulink
+
+
+def cyglink_lib_emitter(target, source, env, **kw):
+    verbose = True
+
+    if 'variable_prefix' in kw:
+        var_prefix = kw['variable_prefix']
+    else:
+        var_prefix = 'SHLIB'
+
+    no_import_lib = env.get('no_import_lib', False)
+
+    if verbose:
+        print("cyglink_lib_emitter: target[0]={!r}".format(target[0].get_path()))
+
+    if not no_import_lib:
+        # Specify import lib and add to targets
+
+        import_lib = env.subst('$%s_IMPLIBNAME' % var_prefix, target=target, source=source)
+        import_lib_target = env.fs.File(import_lib)
+        import_lib_target.attributes.shared = 1
+        target.append(import_lib_target)
+
+        if verbose:
+            print("cyglink_lib_emitter: import_lib={}".format(import_lib))
+            print("cyglink_lib_emitter: target=%s" % target)
+
+    for tgt in target:
+        if is_String(tgt):
+            tgt = env.File(tgt)
+        tgt.attributes.shared = 1
+
+    return target, source
+
+
+def cyglink_ldmodule_emitter(target, source, env, **kw):
+    return cyglink_lib_emitter(target, source, env, variable_prefix='LDMODULE')
+
+
+def cyglink_shlib_symlink_emitter(target, source, env, **kw):
+    """
+    On cygwin, we only create a symlink from the non-versioned implib to the versioned implib.
+    We don't version the shared library itself.
+    :param target:
+    :param source:
+    :param env:
+    :param kw:
+    :return:
+    """
+    verbose = True
+
+    if 'variable_prefix' in kw:
+        var_prefix = kw['variable_prefix']
+    else:
+        var_prefix = 'SHLIB'
+
+    no_import_lib = env.get('no_import_lib', False)
+    if no_import_lib in ['1', 'True', 'true', True]:
+        if verbose:
+            print("cyglink_shlib_symlink_emitter: no_import_lib=%s" % no_import_lib)
+        return target, source
+
+    no_symlinks = env.subst('$%sNOVERSIONSYMLINKS' % var_prefix)
+    if no_symlinks in ['1', 'True', 'true', True]:
+        return target, source
+
+    shlibversion = env.subst('$%sVERSION' % var_prefix)
+    if shlibversion:
+        if verbose:
+            print("cyglink_shlib_symlink_emitter: %sVERSION=%s" % (var_prefix, shlibversion))
+
+        # The implib (added by the cyglink_lib_emitter)
+        imp_lib_node = target[1]
+        shlib_noversion_symlink = env.subst('$%s_NOVERSION_SYMLINK' % var_prefix, target=target[0], source=source)
+
+        if verbose:
+            print("cyglink_shlib_symlink_emitter: shlib_noversion_symlink :%s" % shlib_noversion_symlink)
+            print("cyglink_shlib_symlink_emitter: imp_lib_node            :%s" % imp_lib_node)
+
+        symlinks = [(env.File(shlib_noversion_symlink), imp_lib_node)]
+
+        if verbose:
+            print("cyglink_shlib_symlink_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 cyglink_ldmod_symlink_emitter(target, source, env, **kw):
+    return cyglink_shlib_symlink_emitter(target, source, env, variable_prefix='LDMODULE')
+
+
+def cyglink_shlibversion(target, source, env, for_signature):
+    var_prefix = 'SHLIB'
+    var = '%sVERSION' % var_prefix
+    if var not in env:
+        return ''
+
+    version = env.subst("$%s" % var, target=target, source=source)
+    version = version.replace('.', '-')
+    return "." + version
+
+
+def cyglink_ldmodule_version(target, source, env, for_signature):
+    var_prefix = 'LDMODULE'
+    var = '%sVERSION' % var_prefix
+    if var not in env:
+        return ''
+
+    version = env.subst("$%s" % var, target=target, source=source)
+    version = version.replace('.', '-')
+    return "." + version
+
+
+def _implib_pre_flags(target, source, env, for_signature):
+    no_import_lib = env.get('no_import_lib', False)
+    if no_import_lib in ['1', 'True', 'true', True]:
+        return ''
+    else:
+        return '-Wl,--out-implib=${TARGETS[1]} -Wl,--export-all-symbols -Wl,--enable-auto-import -Wl,--whole-archive'
+
+
+def _implib_post_flags(target, source, env, for_signature):
+    no_import_lib = env.get('no_import_lib', False)
+    if no_import_lib in ['1', 'True', 'true', True]:
+        return ''
+    else:
+        return '-Wl,--no-whole-archive'
+
+
+def generate(env):
+    """Add Builders and construction variables for cyglink to an Environment."""
+    gnulink.generate(env)
+
+    env['LINKFLAGS'] = CLVar('-Wl,-no-undefined')
+
+    env['SHLIBPREFIX'] = 'cyg'
+    env['SHLIBSUFFIX'] = '.dll'
+
+    env['IMPLIBPREFIX'] = 'lib'
+    env['IMPLIBSUFFIX'] = '.dll.a'
+
+    # Variables used by versioned shared libraries
+    # SHLIBVERSIONFLAGS and LDMODULEVERSIONFLAGS are same as in gnulink...
+    env['_SHLIBVERSIONFLAGS'] = '$SHLIBVERSIONFLAGS'
+    env['_LDMODULEVERSIONFLAGS'] = '$LDMODULEVERSIONFLAGS'
+
+    env['_IMPLIB_PRE_SOURCES'] = _implib_pre_flags
+    env['_IMPLIB_POST_SOURCES'] = _implib_post_flags
+    env['SHLINKCOM'] = '$SHLINK -o $TARGET $SHLINKFLAGS $__SHLIBVERSIONFLAGS $__RPATH ' \
+                       '$_IMPLIB_PRE_SOURCES $SOURCES  $_IMPLIB_POST_SOURCES $_LIBDIRFLAGS $_LIBFLAGS'
+    env['LDMODULECOM'] = '$LDMODULE -o $TARGET $SHLINKFLAGS $__LDMODULEVERSIONFLAGS $__RPATH ' \
+                         '$_IMPLIB_PRE_SOURCES $SOURCES $_IMPLIB_POST_SOURCES $_LIBDIRFLAGS  $_LIBFLAGS'
+
+    # Overwrite emitters. Cyglink does things differently when creating symlinks
+    env['SHLIBEMITTER'] = [cyglink_lib_emitter, cyglink_shlib_symlink_emitter]
+    env['LDMODULEEMITTER'] = [cyglink_ldmodule_emitter, cyglink_ldmod_symlink_emitter]
+
+    # This is the non versioned shlib filename
+    # If SHLIBVERSION is defined then this will symlink to $SHLIBNAME
+    env['SHLIB_NOVERSION_SYMLINK'] = '${IMPLIBPREFIX}$_get_shlib_stem${IMPLIBSUFFIX}'
+    env['LDMODULE_NOVERSION_SYMLINK'] = '${IMPLIBPREFIX}$_get_ldmodule_stem${IMPLIBSUFFIX}'
+
+    env['SHLIB_IMPLIBNAME'] = '${IMPLIBPREFIX}$_get_shlib_stem${_SHLIB_IMPLIBSUFFIX}'
+    env['LDMODULE_IMPLIBNAME'] = '${IMPLIBPREFIX}$_get_ldmodule_stem${_LDMODULE_IMPLIBSUFFIX}'
+
+    env['_cyglink_shlibversion'] = cyglink_shlibversion
+    env['_SHLIB_IMPLIBSUFFIX'] = '${_cyglink_shlibversion}${IMPLIBSUFFIX}'
+    env['_SHLIBSUFFIX'] = '${_cyglink_shlibversion}${SHLIBSUFFIX}'
+
+    env['_cyglink_ldmodule_version'] = cyglink_ldmodule_version
+
+    env['_LDMODULESUFFIX'] = '${_cyglink_ldmodule_version}${LDMODULESUFFIX}'
+    env['_LDMODULE_IMPLIBSUFFIX'] = '${_cyglink_ldmodule_version}${IMPLIBSUFFIX}'
+
+    # Remove variables set by default initialization which aren't needed/used by cyglink
+    # these variables were set by gnulink but are not used in cyglink
+    for rv in ['_SHLIBSONAME', '_LDMODULESONAME']:
+        if rv in env:
+            del env[rv]
+
+
+def exists(env):
+    return gnulink.exists(env)
+
+# 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/default.py

@@ -0,0 +1,50 @@
+"""SCons.Tool.default
+
+Initialization with a default tool list.
+
+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.Tool
+
+def generate(env):
+    """Add default tools."""
+    for t in SCons.Tool.tool_list(env['PLATFORM'], env):
+        SCons.Tool.Tool(t)(env)
+
+def exists(env):
+    return 1
+
+# 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/filesystem.py

@@ -0,0 +1,98 @@
+"""SCons.Tool.filesystem
+
+Tool-specific initialization for the filesystem tools.
+
+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
+from SCons.Tool.install import copyFunc
+
+copyToBuilder, copyAsBuilder = None, None
+
+def copyto_emitter(target, source, env):
+    """ changes the path of the source to be under the target (which
+    are assumed to be directories.
+    """
+    n_target = []
+
+    for t in target:
+        n_target = n_target + [t.File( str( s ) ) for s in source]
+
+    return (n_target, source)
+
+def copy_action_func(target, source, env):
+    assert( len(target) == len(source) ), "\ntarget: %s\nsource: %s" %(list(map(str, target)),list(map(str, source)))
+
+    for t, s in zip(target, source):
+        if copyFunc(t.get_path(), s.get_path(), env):
+            return 1
+
+    return 0
+
+def copy_action_str(target, source, env):
+    return env.subst_target_source(env['COPYSTR'], 0, target, source)
+
+copy_action = SCons.Action.Action( copy_action_func, copy_action_str )
+
+def generate(env):
+    try:
+        env['BUILDERS']['CopyTo']
+        env['BUILDERS']['CopyAs']
+    except KeyError as e:
+        global copyToBuilder
+        if copyToBuilder is None:
+            copyToBuilder = SCons.Builder.Builder(
+                             action         = copy_action,
+                             target_factory = env.fs.Dir,
+                             source_factory = env.fs.Entry,
+                             multi          = 1,
+                             emitter        = [ copyto_emitter, ] )
+
+        global copyAsBuilder
+        if copyAsBuilder is None:
+            copyAsBuilder = SCons.Builder.Builder(
+                             action         = copy_action,
+                             target_factory = env.fs.Entry,
+                             source_factory = env.fs.Entry )
+
+        env['BUILDERS']['CopyTo'] = copyToBuilder
+        env['BUILDERS']['CopyAs'] = copyAsBuilder
+
+        env['COPYSTR'] = 'Copy file(s): "$SOURCES" to "$TARGETS"'
+
+def exists(env):
+    return 1
+
+# 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/g++.py

@@ -0,0 +1,45 @@
+"""SCons.Tool.g++
+
+Tool-specific initialization for g++.
+
+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__"
+
+
+#forward proxy to the preffered cxx version
+from SCons.Tool.gxx import *
+
+
+# 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/gas.py

@@ -0,0 +1,56 @@
+"""SCons.Tool.gas
+
+Tool-specific initialization for as, the Gnu assembler.
+
+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__"
+
+try:
+    as_module = __import__('as', globals(), locals(), [])
+except:
+    as_module = __import__(__package__+'.as', globals(), locals(), ['*'])
+
+assemblers = ['as', 'gas']
+
+def generate(env):
+    """Add Builders and construction variables for as to an Environment."""
+    as_module.generate(env)
+
+    env['AS']        = env.Detect(assemblers) or 'as'
+
+def exists(env):
+    return env.Detect(assemblers)
+
+# 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/gcc.py

@@ -0,0 +1,110 @@
+# 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.
+
+"""SCons.Tool.gcc
+
+Tool-specific initialization for gcc.
+
+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.
+
+"""
+
+from . import cc
+import re
+import subprocess
+
+import SCons.Util
+
+compilers = ['gcc', 'cc']
+
+
+def generate(env):
+    """Add Builders and construction variables for gcc to an Environment."""
+
+    if 'CC' not in env:
+        env['CC'] = env.Detect(compilers) or compilers[0]
+
+    cc.generate(env)
+
+    if env['PLATFORM'] in ['cygwin', 'win32']:
+        env['SHCCFLAGS'] = SCons.Util.CLVar('$CCFLAGS')
+    else:
+        env['SHCCFLAGS'] = SCons.Util.CLVar('$CCFLAGS -fPIC')
+    # determine compiler version
+    version = detect_version(env, env['CC'])
+    if version:
+        env['CCVERSION'] = version
+
+
+def exists(env):
+    # is executable, and is a GNU compiler (or accepts '--version' at least)
+    return detect_version(env, env.Detect(env.get('CC', compilers)))
+
+
+def detect_version(env, cc):
+    """Return the version of the GNU compiler, or None if it is not a GNU compiler."""
+    version = None
+    cc = env.subst(cc)
+    if not cc:
+        return version
+
+    # -dumpversion was added in GCC 3.0.  As long as we're supporting
+    # GCC versions older than that, we should use --version and a
+    # regular expression.
+    # pipe = SCons.Action._subproc(env, SCons.Util.CLVar(cc) + ['-dumpversion'],
+    pipe=SCons.Action._subproc(env, SCons.Util.CLVar(cc) + ['--version'],
+                                 stdin='devnull',
+                                 stderr='devnull',
+                                 stdout=subprocess.PIPE)
+    if pipe.wait() != 0:
+        return version
+
+    with pipe.stdout:
+        # -dumpversion variant:
+        # line = pipe.stdout.read().strip()
+        # --version variant:
+        line = SCons.Util.to_str(pipe.stdout.readline())
+        # Non-GNU compiler's output (like AIX xlc's) may exceed the stdout buffer:
+        # So continue with reading to let the child process actually terminate.
+        # We don't need to know the rest of the data, so don't bother decoding.
+        while pipe.stdout.readline():
+            pass
+
+
+    # -dumpversion variant:
+    # if line:
+    #     version = line
+    # --version variant:
+    match = re.search(r'[0-9]+(\.[0-9]+)+', line)
+    if match:
+        version = match.group(0)
+
+    return version
+
+# 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/gettext_tool.py

@@ -0,0 +1,69 @@
+# 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.
+
+"""gettext tool"""
+
+import sys
+import os
+
+import SCons.Tool
+import SCons.Warnings
+from SCons.Errors import StopError
+from SCons.Platform.mingw import MINGW_DEFAULT_PATHS
+from SCons.Platform.cygwin import CYGWIN_DEFAULT_PATHS
+from SCons.Tool.GettextCommon import (
+    _msgfmt_exists,
+    _msginit_exists,
+    _msgmerge_exists,
+    tool_list,
+    _translate,
+    _xgettext_exists,
+)
+
+def generate(env, **kw):
+    for t in tool_list(env['PLATFORM'], env):
+        if sys.platform == 'win32':
+            tool = SCons.Tool.find_program_path(
+                env, t, default_paths=MINGW_DEFAULT_PATHS + CYGWIN_DEFAULT_PATHS
+            )
+            if tool:
+                tool_bin_dir = os.path.dirname(tool)
+                env.AppendENVPath('PATH', tool_bin_dir)
+            else:
+                SCons.Warnings.warn(
+                    SCons.Warnings.SConsWarning,
+                    t + ' tool requested, but binary not found in ENV PATH',
+                )
+        env.Tool(t)
+    env.AddMethod(_translate, 'Translate')
+
+def exists(env):
+    try:
+        return (
+            _xgettext_exists(env)
+            and _msginit_exists(env)
+            and _msgmerge_exists(env)
+            and _msgfmt_exists(env)
+        )
+    except StopError:
+        return False