Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/build/inline_copy/lib/scons-4.3.0/SCons/PathList.py

@@ -0,0 +1,224 @@
+# 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.
+
+"""Handle lists of directory paths.
+
+These are the path lists that get set as CPPPATH, LIBPATH,
+etc.) with as much caching of data and efficiency as we can, while
+still keeping the evaluation delayed so that we Do the Right Thing
+(almost) regardless of how the variable is specified.
+"""
+
+import os
+
+import SCons.Memoize
+import SCons.Node
+import SCons.Util
+
+#
+# Variables to specify the different types of entries in a PathList object:
+#
+
+TYPE_STRING_NO_SUBST = 0        # string with no '$'
+TYPE_STRING_SUBST = 1           # string containing '$'
+TYPE_OBJECT = 2                 # other object
+
+def node_conv(obj):
+    """
+    This is the "string conversion" routine that we have our substitutions
+    use to return Nodes, not strings.  This relies on the fact that an
+    EntryProxy object has a get() method that returns the underlying
+    Node that it wraps, which is a bit of architectural dependence
+    that we might need to break or modify in the future in response to
+    additional requirements.
+    """
+    try:
+        get = obj.get
+    except AttributeError:
+        if isinstance(obj, SCons.Node.Node) or SCons.Util.is_Sequence( obj ):
+            result = obj
+        else:
+            result = str(obj)
+    else:
+        result = get()
+    return result
+
+class _PathList:
+    """
+    An actual PathList object.
+    """
+    def __init__(self, pathlist):
+        """
+        Initializes a PathList object, canonicalizing the input and
+        pre-processing it for quicker substitution later.
+
+        The stored representation of the PathList is a list of tuples
+        containing (type, value), where the "type" is one of the TYPE_*
+        variables defined above.  We distinguish between:
+
+            strings that contain no '$' and therefore need no
+            delayed-evaluation string substitution (we expect that there
+            will be many of these and that we therefore get a pretty
+            big win from avoiding string substitution)
+
+            strings that contain '$' and therefore need substitution
+            (the hard case is things like '${TARGET.dir}/include',
+            which require re-evaluation for every target + source)
+
+            other objects (which may be something like an EntryProxy
+            that needs a method called to return a Node)
+
+        Pre-identifying the type of each element in the PathList up-front
+        and storing the type in the list of tuples is intended to reduce
+        the amount of calculation when we actually do the substitution
+        over and over for each target.
+        """
+        if SCons.Util.is_String(pathlist):
+            pathlist = pathlist.split(os.pathsep)
+        elif not SCons.Util.is_Sequence(pathlist):
+            pathlist = [pathlist]
+
+        pl = []
+        for p in pathlist:
+            try:
+                found = '$' in p
+            except (AttributeError, TypeError):
+                type = TYPE_OBJECT
+            else:
+                if not found:
+                    type = TYPE_STRING_NO_SUBST
+                else:
+                    type = TYPE_STRING_SUBST
+            pl.append((type, p))
+
+        self.pathlist = tuple(pl)
+
+    def __len__(self): return len(self.pathlist)
+
+    def __getitem__(self, i): return self.pathlist[i]
+
+    def subst_path(self, env, target, source):
+        """
+        Performs construction variable substitution on a pre-digested
+        PathList for a specific target and source.
+        """
+        result = []
+        for type, value in self.pathlist:
+            if type == TYPE_STRING_SUBST:
+                value = env.subst(value, target=target, source=source,
+                                  conv=node_conv)
+                if SCons.Util.is_Sequence(value):
+                    result.extend(SCons.Util.flatten(value))
+                elif value:
+                    result.append(value)
+            elif type == TYPE_OBJECT:
+                value = node_conv(value)
+                if value:
+                    result.append(value)
+            elif value:
+                result.append(value)
+        return tuple(result)
+
+
+class PathListCache:
+    """
+    A class to handle caching of PathList lookups.
+
+    This class gets instantiated once and then deleted from the namespace,
+    so it's used as a Singleton (although we don't enforce that in the
+    usual Pythonic ways).  We could have just made the cache a dictionary
+    in the module namespace, but putting it in this class allows us to
+    use the same Memoizer pattern that we use elsewhere to count cache
+    hits and misses, which is very valuable.
+
+    Lookup keys in the cache are computed by the _PathList_key() method.
+    Cache lookup should be quick, so we don't spend cycles canonicalizing
+    all forms of the same lookup key.  For example, 'x:y' and ['x',
+    'y'] logically represent the same list, but we don't bother to
+    split string representations and treat those two equivalently.
+    (Note, however, that we do, treat lists and tuples the same.)
+
+    The main type of duplication we're trying to catch will come from
+    looking up the same path list from two different clones of the
+    same construction environment.  That is, given
+    
+        env2 = env1.Clone()
+
+    both env1 and env2 will have the same CPPPATH value, and we can
+    cheaply avoid re-parsing both values of CPPPATH by using the
+    common value from this cache.
+    """
+    def __init__(self):
+        self._memo = {}
+
+    def _PathList_key(self, pathlist):
+        """
+        Returns the key for memoization of PathLists.
+
+        Note that we want this to be pretty quick, so we don't completely
+        canonicalize all forms of the same list.  For example,
+        'dir1:$ROOT/dir2' and ['$ROOT/dir1', 'dir'] may logically
+        represent the same list if you're executing from $ROOT, but
+        we're not going to bother splitting strings into path elements,
+        or massaging strings into Nodes, to identify that equivalence.
+        We just want to eliminate obvious redundancy from the normal
+        case of re-using exactly the same cloned value for a path.
+        """
+        if SCons.Util.is_Sequence(pathlist):
+            pathlist = tuple(SCons.Util.flatten(pathlist))
+        return pathlist
+
+    @SCons.Memoize.CountDictCall(_PathList_key)
+    def PathList(self, pathlist):
+        """
+        Returns the cached _PathList object for the specified pathlist,
+        creating and caching a new object as necessary.
+        """
+        pathlist = self._PathList_key(pathlist)
+        try:
+            memo_dict = self._memo['PathList']
+        except KeyError:
+            memo_dict = {}
+            self._memo['PathList'] = memo_dict
+        else:
+            try:
+                return memo_dict[pathlist]
+            except KeyError:
+                pass
+
+        result = _PathList(pathlist)
+
+        memo_dict[pathlist] = result
+
+        return result
+
+PathList = PathListCache().PathList
+
+
+del PathListCache
+
+# 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/Platform/__init__.py

@@ -0,0 +1,341 @@
+# 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 platform selection.
+
+Looks for modules that define a callable object that can modify a
+construction environment as appropriate for a given platform.
+
+Note that we take a more simplistic view of "platform" than Python does.
+We're looking for a single string that determines a set of
+tool-independent variables with which to initialize a construction
+environment.  Consequently, we'll examine both sys.platform and os.name
+(and anything else that might come in to play) in order to return some
+specification which is unique enough for our purposes.
+
+Note that because this subsystem just *selects* a callable that can
+modify a construction environment, it's possible for people to define
+their own "platform specification" in an arbitrary callable function.
+No one needs to use or tie in to this subsystem in order to roll
+their own platform definition.
+"""
+
+import SCons.compat
+
+import importlib
+import os
+import sys
+import tempfile
+
+import SCons.Errors
+import SCons.Subst
+import SCons.Tool
+
+
+def platform_default():
+    r"""Return the platform string for our execution environment.
+
+    The returned value should map to one of the SCons/Platform/\*.py
+    files.  Since scons is architecture independent, though, we don't
+    care about the machine architecture.
+    """
+    osname = os.name
+    if osname == 'java':
+        osname = os._osType
+    if osname == 'posix':
+        if sys.platform == 'cygwin':
+            return 'cygwin'
+        elif sys.platform.find('irix') != -1:
+            return 'irix'
+        elif sys.platform.find('sunos') != -1:
+            return 'sunos'
+        elif sys.platform.find('hp-ux') != -1:
+            return 'hpux'
+        elif sys.platform.find('aix') != -1:
+            return 'aix'
+        elif sys.platform.find('darwin') != -1:
+            return 'darwin'
+        else:
+            return 'posix'
+    elif os.name == 'os2':
+        return 'os2'
+    else:
+        return sys.platform
+
+
+def platform_module(name = platform_default()):
+    """Return the imported module for the platform.
+
+    This looks for a module name that matches the specified argument.
+    If the name is unspecified, we fetch the appropriate default for
+    our execution environment.
+    """
+    full_name = 'SCons.Platform.' + name
+    if full_name not in sys.modules:
+        if os.name == 'java':
+            eval(full_name)
+        else:
+            try:
+                # the specific platform module is a relative import
+                mod = importlib.import_module("." + name, __name__)
+            except ImportError:
+                try:
+                    import zipimport
+                    importer = zipimport.zipimporter( sys.modules['SCons.Platform'].__path__[0] )
+                    mod = importer.load_module(full_name)
+                except ImportError:
+                    raise SCons.Errors.UserError("No platform named '%s'" % name)
+            setattr(SCons.Platform, name, mod)
+    return sys.modules[full_name]
+
+
+def DefaultToolList(platform, env):
+    """Select a default tool list for the specified platform.
+    """
+    return SCons.Tool.tool_list(platform, env)
+
+
+class PlatformSpec:
+    def __init__(self, name, generate):
+        self.name = name
+        self.generate = generate
+
+    def __call__(self, *args, **kw):
+        return self.generate(*args, **kw)
+
+    def __str__(self):
+        return self.name
+
+
+class TempFileMunge:
+    """Convert long command lines to use a temporary file.
+
+    You can set an Environment variable (usually ``TEMPFILE``) to this,
+    then call it with a string argument, and it will perform temporary
+    file substitution on it.  This is used to circumvent limitations on
+    the length of command lines. Example::
+
+        env["TEMPFILE"] = TempFileMunge
+        env["LINKCOM"] = "${TEMPFILE('$LINK $TARGET $SOURCES','$LINKCOMSTR')}"
+
+    By default, the name of the temporary file used begins with a
+    prefix of '@'.  This may be configured for other tool chains by
+    setting the ``TEMPFILEPREFIX`` variable. Example::
+
+        env["TEMPFILEPREFIX"] = '-@'        # diab compiler
+        env["TEMPFILEPREFIX"] = '-via'      # arm tool chain
+        env["TEMPFILEPREFIX"] = ''          # (the empty string) PC Lint
+
+    You can configure the extension of the temporary file through the
+    ``TEMPFILESUFFIX`` variable, which defaults to '.lnk' (see comments
+    in the code below). Example::
+
+        env["TEMPFILESUFFIX"] = '.lnt'   # PC Lint
+
+    Entries in the temporary file are separated by the value of the
+    ``TEMPFILEARGJOIN`` variable, which defaults to an OS-appropriate value.
+
+    A default argument escape function is ``SCons.Subst.quote_spaces``.
+    If you need to apply extra operations on a command argument before
+    writing to a temporary file(fix Windows slashes, normalize paths, etc.),
+    please set `TEMPFILEARGESCFUNC` variable to a custom function. Example::
+
+        import sys
+        import re
+        from SCons.Subst import quote_spaces
+
+        WINPATHSEP_RE = re.compile(r"\\([^\"'\\]|$)")
+
+
+        def tempfile_arg_esc_func(arg):
+            arg = quote_spaces(arg)
+            if sys.platform != "win32":
+                return arg
+            # GCC requires double Windows slashes, let's use UNIX separator
+            return WINPATHSEP_RE.sub(r"/\1", arg)
+
+
+        env["TEMPFILEARGESCFUNC"] = tempfile_arg_esc_func
+
+    """
+    def __init__(self, cmd, cmdstr = None):
+        self.cmd = cmd
+        self.cmdstr = cmdstr
+
+    def __call__(self, target, source, env, for_signature):
+        if for_signature:
+            # If we're being called for signature calculation, it's
+            # because we're being called by the string expansion in
+            # Subst.py, which has the logic to strip any $( $) that
+            # may be in the command line we squirreled away.  So we
+            # just return the raw command line and let the upper
+            # string substitution layers do their thing.
+            return self.cmd
+
+        # Now we're actually being called because someone is actually
+        # going to try to execute the command, so we have to do our
+        # own expansion.
+        cmd = env.subst_list(self.cmd, SCons.Subst.SUBST_CMD, target, source)[0]
+        try:
+            maxline = int(env.subst('$MAXLINELENGTH'))
+        except ValueError:
+            maxline = 2048
+
+        length = 0
+        for c in cmd:
+            length += len(c)
+        length += len(cmd) - 1
+        if length <= maxline:
+            return self.cmd
+
+        # Check if we already created the temporary file for this target
+        # It should have been previously done by Action.strfunction() call
+        if SCons.Util.is_List(target):
+            node = target[0]
+        else:
+            node = target
+
+        cmdlist = None
+
+        if SCons.Util.is_List(self.cmd):
+            cmdlist_key = tuple(self.cmd)
+        else:
+            cmdlist_key = self.cmd
+
+        if node and hasattr(node.attributes, 'tempfile_cmdlist'):
+            cmdlist = node.attributes.tempfile_cmdlist.get(cmdlist_key, None)
+        if cmdlist is not None:
+            return cmdlist
+
+        # Default to the .lnk suffix for the benefit of the Phar Lap
+        # linkloc linker, which likes to append an .lnk suffix if
+        # none is given.
+        if 'TEMPFILESUFFIX' in env:
+            suffix = env.subst('$TEMPFILESUFFIX')
+        else:
+            suffix = '.lnk'
+
+        if 'TEMPFILEDIR' in env:
+            tempfile_dir = env.subst('$TEMPFILEDIR')
+            os.makedirs(tempfile_dir, exist_ok=True)
+        else:
+            tempfile_dir = None
+
+        fd, tmp = tempfile.mkstemp(suffix, dir=tempfile_dir, text=True)
+        native_tmp = SCons.Util.get_native_path(tmp)
+
+        if env.get('SHELL', None) == 'sh':
+            # The sh shell will try to escape the backslashes in the
+            # path, so unescape them.
+            native_tmp = native_tmp.replace('\\', r'\\\\')
+            # In Cygwin, we want to use rm to delete the temporary
+            # file, because del does not exist in the sh shell.
+            rm = env.Detect('rm') or 'del'
+        else:
+            # Don't use 'rm' if the shell is not sh, because rm won't
+            # work with the Windows shells (cmd.exe or command.com) or
+            # Windows path names.
+            rm = 'del'
+
+        if 'TEMPFILEPREFIX' in env:
+            prefix = env.subst('$TEMPFILEPREFIX')
+        else:
+            prefix = '@'
+
+        tempfile_esc_func = env.get('TEMPFILEARGESCFUNC', SCons.Subst.quote_spaces)
+        args = [
+            tempfile_esc_func(arg)
+            for arg in cmd[1:]
+        ]
+        join_char = env.get('TEMPFILEARGJOIN', ' ')
+        os.write(fd, bytearray(join_char.join(args) + "\n", 'utf-8'))
+        os.close(fd)
+
+        # XXX Using the SCons.Action.print_actions value directly
+        # like this is bogus, but expedient.  This class should
+        # really be rewritten as an Action that defines the
+        # __call__() and strfunction() methods and lets the
+        # normal action-execution logic handle whether or not to
+        # print/execute the action.  The problem, though, is all
+        # of that is decided before we execute this method as
+        # part of expanding the $TEMPFILE construction variable.
+        # Consequently, refactoring this will have to wait until
+        # we get more flexible with allowing Actions to exist
+        # independently and get strung together arbitrarily like
+        # Ant tasks.  In the meantime, it's going to be more
+        # user-friendly to not let obsession with architectural
+        # purity get in the way of just being helpful, so we'll
+        # reach into SCons.Action directly.
+        if SCons.Action.print_actions:
+            cmdstr = env.subst(self.cmdstr, SCons.Subst.SUBST_RAW, target,
+                               source) if self.cmdstr is not None else ''
+            # Print our message only if XXXCOMSTR returns an empty string
+            if len(cmdstr) == 0 :
+                cmdstr = ("Using tempfile "+native_tmp+" for command line:\n"+
+                    str(cmd[0]) + " " + " ".join(args))
+                self._print_cmd_str(target, source, env, cmdstr)
+
+        cmdlist = [cmd[0], prefix + native_tmp + '\n' + rm, native_tmp]
+
+        # Store the temporary file command list into the target Node.attributes
+        # to avoid creating two temporary files one for print and one for execute.
+        if node is not None:
+            try:
+                # Storing in tempfile_cmdlist by self.cmd provided when intializing
+                # $TEMPFILE{} fixes issue raised in PR #3140 and #3553
+                node.attributes.tempfile_cmdlist[cmdlist_key] = cmdlist
+            except AttributeError:
+                node.attributes.tempfile_cmdlist = {cmdlist_key: cmdlist}
+
+        return cmdlist
+
+    def _print_cmd_str(self, target, source, env, cmdstr):
+        # check if the user has specified a cmd line print function
+        print_func = None
+        try:
+            get = env.get
+        except AttributeError:
+            pass
+        else:
+            print_func = get('PRINT_CMD_LINE_FUNC')
+
+        # use the default action cmd line print if user did not supply one
+        if not print_func:
+            action = SCons.Action._ActionAction()
+            action.print_cmd_line(cmdstr, target, source, env)
+        else:
+            print_func(cmdstr, target, source, env)
+
+
+def Platform(name = platform_default()):
+    """Select a canned Platform specification.
+    """
+    module = platform_module(name)
+    spec = PlatformSpec(name, module.generate)
+    return spec
+
+# 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/Platform/aix.py

@@ -0,0 +1,81 @@
+# 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.
+
+"""Platform-specific initialization for IBM AIX systems.
+
+There normally shouldn't be any need to import this module directly.  It
+will usually be imported through the generic SCons.Platform.Platform()
+selection method.
+"""
+
+import subprocess
+
+from . import posix
+
+import SCons.Util
+import SCons.Action
+
+def get_xlc(env, xlc=None, packages=[]):
+    # Use the AIX package installer tool lslpp to figure out where a
+    # given xl* compiler is installed and what version it is.
+    xlcPath = None
+    xlcVersion = None
+
+    if xlc is None:
+        xlc = env.get('CC', 'xlc')
+    if SCons.Util.is_List(xlc):
+        xlc = xlc[0]
+    for package in packages:
+        # find the installed filename, which may be a symlink as well
+        pipe = SCons.Action._subproc(env, ['lslpp', '-fc', package],
+                stdin = 'devnull',
+                stderr = 'devnull',
+                universal_newlines=True,
+                stdout = subprocess.PIPE)
+        # output of lslpp is something like this:
+        #     #Path:Fileset:File
+        #     /usr/lib/objrepos:vac.C 6.0.0.0:/usr/vac/exe/xlCcpp
+        #     /usr/lib/objrepos:vac.C 6.0.0.0:/usr/vac/bin/xlc_r -> /usr/vac/bin/xlc
+        for line in pipe.stdout:
+            if xlcPath:
+                continue # read everything to let lslpp terminate
+            fileset, filename = line.split(':')[1:3]
+            filename = filename.split()[0]
+            if ('/' in xlc and filename == xlc) \
+            or ('/' not in xlc and filename.endswith('/' + xlc)):
+                xlcVersion = fileset.split()[1]
+                xlcPath, sep, xlc = filename.rpartition('/')
+    return (xlcPath, xlc, xlcVersion)
+
+def generate(env):
+    posix.generate(env)
+    #Based on AIX 5.2: ARG_MAX=24576 - 3000 for environment expansion
+    env['MAXLINELENGTH']  = 21576
+    env['SHLIBSUFFIX'] = '.a'
+    env['HOST_OS'] = 'aix'
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4: