Skip to content
Back to top

# Source code for xonsh.platform

    """Module for platform-specific constants and implementations, as well as
    compatibility layers to make use of the 'best' implementation available
    on a platform.
    """

    import collections.abc as cabc
    import ctypes  # noqa
    import functools
    import importlib.util
    import os
    import pathlib
    import platform
    import shutil
    import signal
    import subprocess
    import sys
    from pathlib import Path

    from xonsh.lib.lazyasd import LazyBool, lazybool, lazyobject

    # do not import any xonsh-modules here to avoid circular dependencies

    FD_STDIN = 0
    FD_STDOUT = 1
    FD_STDERR = 2

    @lazyobject
    def distro():
        try:
            import distro as d
        except ImportError:
            d = None
        except Exception:
            raise
        return d

    #
    # OS
    #
    ON_DARWIN = LazyBool(lambda: platform.system() == "Darwin", globals(), "ON_DARWIN")
    """``True`` if executed on a Darwin platform, else ``False``. """
    ON_LINUX = LazyBool(lambda: platform.system() == "Linux", globals(), "ON_LINUX")
    """``True`` if executed on a Linux platform, else ``False``. """
    ON_WINDOWS = LazyBool(lambda: platform.system() == "Windows", globals(), "ON_WINDOWS")
    """``True`` if executed on a native Windows platform, else ``False``. """
    ON_CYGWIN = LazyBool(lambda: sys.platform == "cygwin", globals(), "ON_CYGWIN")
    """``True`` if executed on a Cygwin Windows platform, else ``False``. """
    ON_MSYS = LazyBool(lambda: sys.platform == "msys", globals(), "ON_MSYS")
    """``True`` if executed on a MSYS Windows platform, else ``False``. """
    ON_POSIX = LazyBool(lambda: os.name == "posix", globals(), "ON_POSIX")
    """``True`` if executed on a POSIX-compliant platform, else ``False``. """
    ON_FREEBSD = LazyBool(
        lambda: sys.platform.startswith("freebsd"), globals(), "ON_FREEBSD"
    )
    """``True`` if on a FreeBSD operating system, else ``False``."""
    ON_DRAGONFLY = LazyBool(
        lambda: sys.platform.startswith("dragonfly"), globals(), "ON_DRAGONFLY"
    )
    """``True`` if on a DragonFly BSD operating system, else ``False``."""
    ON_NETBSD = LazyBool(lambda: sys.platform.startswith("netbsd"), globals(), "ON_NETBSD")
    """``True`` if on a NetBSD operating system, else ``False``."""
    ON_OPENBSD = LazyBool(
        lambda: sys.platform.startswith("openbsd"), globals(), "ON_OPENBSD"
    )
    """``True`` if on a OpenBSD operating system, else ``False``."""
    IN_APPIMAGE = LazyBool(
        lambda: "APPIMAGE" in os.environ and "APPDIR" in os.environ,
        globals(),
        "IN_APPIMAGE",
    )
    """``True`` if in AppImage, else ``False``."""
    ON_ANDROID = LazyBool(
        lambda: (
            sys.platform == "android"
            or platform.system() == "Android"
            or "ANDROID_ROOT" in os.environ
            or os.path.isfile("/system/build.prop")
        ),
        globals(),
        "ON_ANDROID",
    )
    """``True`` on any Android userland — Termux, UserLAnd, proot-distro,
    Linux Deploy chroot, etc.

    Detection is layered: PEP 738 sets ``sys.platform == "android"`` and
    ``platform.system() == "Android"`` on Python 3.13+; for older Python
    versions and proot/chroot setups where those checks miss, we fall back
    to the presence of the ``ANDROID_ROOT`` environment variable (always
    exported by the Android init) and finally to ``/system/build.prop``.

    Implies the Android app sandbox: ``/`` is typically unlistable,
    ``os.tcsetpgrp`` and ``os.link`` are restricted, the filesystem is
    non-FHS. Code that needs Android-wide behaviour (e.g. ``skipif`` on
    tests that walk the FS root) should key off this flag rather than
    ``ON_TERMUX`` so non-Termux Android shells (UserLAnd, …) are covered.
    """
    ON_TERMUX = LazyBool(
        lambda: "TERMUX_VERSION" in os.environ,
        globals(),
        "ON_TERMUX",
    )
    """``True`` specifically inside the Termux app (and forks that keep its
    ``TERMUX_VERSION`` env var).

    Detected via ``TERMUX_VERSION`` which Termux exports in every shell it
    spawns. Implies :data:`ON_ANDROID`, plus the Termux userland layout
    under ``$PREFIX = /data/data/com.termux/files/usr``. Use this flag for
    Termux-specific path defaults (``$PREFIX/bin``, completion script
    locations, etc.); use :data:`ON_ANDROID` for sandbox/bionic concerns
    that apply to any Android userland.
    """
    IN_FLATPAK = LazyBool(
        lambda: "FLATPAK_ID" in os.environ,
        globals(),
        "IN_FLATPAK",
    )
    """``True`` if in Flastpak, else ``False``."""

    def path_bshell():
        """Absolute path to the system Bourne shell, like libc ``_PATH_BSHELL``.

        ``/bin/sh`` everywhere except Android: Termux ships ``sh`` under
        ``$PREFIX/bin`` and stock Android under ``/system/bin`` (bionic's
        ``_PATH_BSHELL``); plain ``/bin/sh`` may not exist on either.
        Candidates are checked for existence, so FHS userlands running on top
        of Android (proot-distro, UserLAnd, ...) keep their own ``/bin/sh``.
        NixOS needs no special casing — ``/bin/sh`` is its single ``/bin``
        FHS concession. If no candidate exists, fall back to ``sh`` from
        ``$PATH`` (POSIX mandates the *utility*, not a fixed path).
        """
        candidates = []
        if ON_TERMUX:
            prefix = os.environ.get("PREFIX", "/data/data/com.termux/files/usr")
            candidates.append(os.path.join(prefix, "bin", "sh"))
        candidates.append("/bin/sh")
        if ON_ANDROID:
            candidates.append("/system/bin/sh")
        for sh in candidates:
            if os.access(sh, os.X_OK):
                return sh
        return shutil.which("sh") or "/bin/sh"

    @lazybool
    def ON_BSD():
        """``True`` if on a BSD operating system, else ``False``."""
        return bool(ON_FREEBSD) or bool(ON_NETBSD) or bool(ON_OPENBSD) or bool(ON_DRAGONFLY)

    @lazybool
    def ON_BEOS():
        """True if we are on BeOS or Haiku."""
        return sys.platform == "beos5" or sys.platform == "haiku1"

    @lazybool
    def ON_WSL():
        """True if we are on Windows Subsystem for Linux (WSL)"""
        return "microsoft" in platform.release()

    @lazybool
    def ON_WSL1():
        return bool(ON_WSL) and not bool(ON_WSL2)

    @lazybool
    def ON_WSL2():
        return bool(ON_WSL) and "WSL2" in platform.release()

    #
    # Python & packages
    #

    PYTHON_VERSION_INFO = sys.version_info[:3]
    """ Version of Python interpreter as three-value tuple. """

    @lazyobject
    def PYTHON_VERSION_INFO_BYTES():
        """The python version info tuple in a canonical bytes form."""
        return ".".join(map(str, sys.version_info)).encode()

    ON_ANACONDA = LazyBool(
        lambda: pathlib.Path(sys.prefix).joinpath("conda-meta").exists(),
        globals(),
        "ON_ANACONDA",
    )
    """ ``True`` if executed in an Anaconda instance, else ``False``. """
    CAN_RESIZE_WINDOW = LazyBool(
        lambda: hasattr(signal, "SIGWINCH"), globals(), "CAN_RESIZE_WINDOW"
    )
    """``True`` if we can resize terminal window, as provided by the presense of
    signal.SIGWINCH, else ``False``.
    """

    @lazybool
    def HAS_PYGMENTS():
        """``True`` if `pygments` is available, else ``False``."""
        spec = importlib.util.find_spec("pygments")
        return spec is not None

    @functools.lru_cache(1)
    def pygments_version():
        """pygments.__version__ version if available, else None."""
        if HAS_PYGMENTS:
            import pygments

            v = pygments.__version__
        else:
            v = None
        return v

    @functools.lru_cache(1)
    def pygments_version_info():
        """Returns `pygments`'s version as tuple of integers."""
        if HAS_PYGMENTS:
            return tuple(int(x) for x in pygments_version().strip("<>+-=.").split("."))
        else:
            return None

    @functools.lru_cache(1)
    def has_prompt_toolkit():
        """Tests if the `prompt_toolkit` is available."""
        spec = importlib.util.find_spec("prompt_toolkit")
        return spec is not None

    @functools.lru_cache(1)
    def ptk_version():
        """Returns `prompt_toolkit.__version__` if available, else ``None``."""
        if has_prompt_toolkit():
            import prompt_toolkit

            return getattr(prompt_toolkit, "__version__", "<0.57")
        else:
            return None

    @functools.lru_cache(1)
    def ptk_version_info():
        """Returns `prompt_toolkit`'s version as tuple of integers."""
        if has_prompt_toolkit():
            return tuple(int(x) for x in ptk_version().strip("<>+-=.").split("."))
        else:
            return None

    minimum_required_ptk_version = (2, 0, 0)
    """Minimum version of prompt-toolkit supported by Xonsh"""

    @functools.lru_cache(1)
    def ptk_above_min_supported():
        return ptk_version_info() and ptk_version_info() >= minimum_required_ptk_version

    @functools.lru_cache(1)
    def win_ansi_support():
        if ON_WINDOWS:
            try:
                from prompt_toolkit.utils import is_conemu_ansi, is_windows_vt100_supported
            except ImportError:
                return False
            return is_conemu_ansi() or is_windows_vt100_supported()
        else:
            return False

    @functools.lru_cache(1)
    def ptk_below_max_supported():
        ptk_max_version_cutoff = (99999, 0)  # currently, no limit.
        return ptk_version_info()[:2] < ptk_max_version_cutoff

    @functools.lru_cache(1)
    def best_shell_type():
        from xonsh.built_ins import XSH

        if XSH.env.get("TERM", "") == "dumb":
            return "dumb"
        if has_prompt_toolkit():
            return "prompt_toolkit"
        return "readline"

    @functools.lru_cache(1)
    def is_readline_available():
        """Checks if readline is available to import."""
        spec = importlib.util.find_spec("readline")
        return spec is not None

    @lazyobject
    def seps():
        """String of all path separators."""
        s = os.path.sep
        if os.path.altsep is not None:
            s += os.path.altsep
        return s

    def pathsplit(p):
        """This is a safe version of os.path.split(), which does not work on input
        without a drive.
        """
        n = len(p)
        if n == 0:
            # lazy object seps does not get initialized when n is zero
            return "", ""
        while n and p[n - 1] not in seps:
            n -= 1
        pre = p[:n]
        pre = pre.rstrip(seps) or pre
        post = p[n:]
        return pre, post

    def pathbasename(p):
        """This is a safe version of os.path.basename(), which does not work on
        input without a drive.  This version does.
        """
        return pathsplit(p)[-1]

    @lazyobject
    def expanduser():
        """Dispatches to the correct platform-dependent expanduser() function."""
        if ON_WINDOWS:
            return windows_expanduser
        else:
            return os.path.expanduser

    def windows_expanduser(path):
        """A Windows-specific expanduser() function for xonsh. This is needed
        since os.path.expanduser() does not check on Windows if the user actually
        exists. This restricts expanding the '~' if it is not followed by a
        separator. That is only '~/' and '~\' are expanded.
        """
        path = str(path)
        if not path.startswith("~"):
            return path
        elif len(path) < 2 or path[1] in seps:
            return os.path.expanduser(path)
        else:
            return path

    # termios tc(get|set)attr indexes.
    IFLAG = 0
    OFLAG = 1
    CFLAG = 2
    LFLAG = 3
    ISPEED = 4
    OSPEED = 5
    CC = 6

    #
    # Dev release info
    #

    @functools.lru_cache(1)
    def githash():
        """Returns a tuple contains two strings: the hash and the date."""
        install_base = os.path.dirname(__file__)
        githash_file = f"{install_base}/dev.githash"
        if not os.path.exists(githash_file):
            return None, None
        sha = None
        date_ = None
        try:
            with open(githash_file) as f:
                sha, date_ = f.read().strip().split("|")
        except ValueError:
            pass
        return sha, date_

    #
    # Encoding
    #

    DEFAULT_ENCODING = sys.getdefaultencoding()
    """ Default string encoding. """

    #
    # Linux distro
    #

    @functools.lru_cache(1)
    def linux_distro():
        """The id of the Linux distribution running on, possibly 'unknown'.
        None on non-Linux platforms.
        """
        if ON_LINUX:
            if distro:
                ld = distro.id()
            elif "-ARCH-" in platform.platform():
                ld = "arch"  # that's the only one we need to know for now
            else:
                ld = "unknown"
        else:
            ld = None
        return ld

    #
    # Windows
    #

    @functools.lru_cache(1)
    def git_for_windows_path():
        """Returns the path to git for windows, if available and None otherwise."""
        import winreg

        try:
            key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, "SOFTWARE\\GitForWindows")
            gfwp, _ = winreg.QueryValueEx(key, "InstallPath")
        except FileNotFoundError:
            gfwp = None
        return gfwp

    @functools.lru_cache(1)
    def windows_bash_command():
        """Determines the command for Bash on windows."""
        # Check that bash is on path otherwise try the default directory
        # used by Git for windows
        from xonsh.built_ins import XSH

        wbc = "bash"
        cmd_cache = XSH.commands_cache
        bash_on_path = cmd_cache.lazy_locate_binary("bash", ignore_alias=True)
        if bash_on_path:
            try:
                out = subprocess.check_output(
                    [bash_on_path, "--version"],
                    stderr=subprocess.PIPE,
                    text=True,
                )
            except subprocess.CalledProcessError:
                bash_works = False
            else:
                # Check if Bash is from the "Windows Subsystem for Linux" (WSL)
                # which can't be used by xonsh foreign-shell/completer
                bash_works = out and "pc-linux-gnu" not in out.splitlines()[0]

            if bash_works:
                wbc = bash_on_path
            else:
                gfwp = git_for_windows_path()
                if gfwp:
                    bashcmd = os.path.join(gfwp, "bin\\bash.exe")
                    if os.path.isfile(bashcmd):
                        wbc = bashcmd
        return wbc

    #
    # Environment variables defaults
    #

    if ON_WINDOWS:

        class OSEnvironCasePreserving(cabc.MutableMapping):
            """Case-preserving wrapper for os.environ on Windows.
            It uses nt.environ to get the correct cased keys on
            initialization. It also preserves the case of any variables
            add after initialization.
            """

            def __init__(self):
                import nt

                self._upperkeys = {k.upper(): k for k in nt.environ}

            def _sync(self):
                """Ensure that the case sensitive map of the keys are
                in sync with os.environ
                """
                envkeys = {k.upper(): k for k in os.environ.keys()}
                for ukey in set(envkeys).difference(self._upperkeys):
                    self._upperkeys[ukey] = envkeys[ukey]
                for ukey in set(self._upperkeys).difference(envkeys):
                    del self._upperkeys[ukey]

            def __contains__(self, k):
                self._sync()
                return k.upper() in self._upperkeys

            def __len__(self):
                self._sync()
                return len(self._upperkeys)

            def __iter__(self):
                self._sync()
                return iter(self._upperkeys.values())

            def __getitem__(self, k):
                self._sync()
                return os.environ[k]

            def __setitem__(self, k, v):
                self._sync()
                self._upperkeys[k.upper()] = k
                os.environ[k] = v

            def __delitem__(self, k):
                self._sync()
                if k.upper() in self._upperkeys:
                    del self._upperkeys[k.upper()]
                    del os.environ[k]

            def getkey_actual_case(self, k):
                self._sync()
                return self._upperkeys.get(k.upper())

    @lazyobject
    def os_environ():
        """This dispatches to the correct, case-sensitive version of os.environ.
        This is mainly a problem for Windows. See #2024 for more details.
        This can probably go away once support for Python v3.5 or v3.6 is
        dropped.
        """
        if ON_WINDOWS:
            return OSEnvironCasePreserving()
        else:
            return os.environ

    def bash_command():
        """Determines the command for Bash on the current platform."""
        if (bc := os.getenv("XONSH_BASH_PATH_OVERRIDE", None)) is not None:
            bc = str(bc)  # for pathlib Paths
        elif ON_WINDOWS:
            bc = windows_bash_command()
        else:
            bc = "bash"
        return bc

    @lazyobject
    def BASH_COMPLETIONS_DEFAULT():
        """A possibly empty tuple with default paths to Bash completions known for
        the current platform.

        The bridge picks the first existing framework file from this list,
        then sources supplemental user scripts from non-framework file and
        directory entries. Order only affects which framework gets sourced
        when several are installed side by side. Distro/package-manager
        prefixes are listed alongside the standard FHS path so users don't
        have to extend ``$BASH_COMPLETIONS`` manually after installing
        bash-completion via Homebrew, MacPorts, Linuxbrew, Nix, etc.
        """
        if ON_LINUX or ON_CYGWIN or ON_MSYS or ON_TERMUX:
            bcd = (
                "/usr/share/bash-completion/bash_completion",  # FHS, all major distros
                "/home/linuxbrew/.linuxbrew/share/bash-completion/bash_completion",  # Linuxbrew
                "/run/current-system/sw/share/bash-completion/bash_completion",  # NixOS
                os.path.expanduser(  # nix-env single-user profile
                    "~/.nix-profile/share/bash-completion/bash_completion"
                ),
            )
            # Non-FHS userland prefix: Termux on Android sets $PREFIX to its
            # sandboxed /usr-equivalent (/data/data/com.termux/files/usr);
            # custom ./configure --prefix builds may also set it. Pick up
            # bash-completion under that prefix when present.
            _prefix = os.environ.get("PREFIX")
            if _prefix:
                bcd = bcd + (
                    os.path.join(_prefix, "share/bash-completion/bash_completion"),
                )
            bcd = bcd + (
                # User-defined
                os.path.expanduser("~/.bash_completions"),
            )
        elif ON_DARWIN:
            bcd = (
                # Homebrew, Intel
                "/usr/local/share/bash-completion/bash_completion",  # v2.x
                "/usr/local/etc/bash_completion",  # v1.x
                # Homebrew, Apple Silicon
                "/opt/homebrew/share/bash-completion/bash_completion",  # v2.x
                "/opt/homebrew/etc/bash_completion",  # v1.x
                # MacPorts
                "/opt/local/share/bash-completion/bash_completion",  # v2.x
                "/opt/local/etc/bash_completion",  # v1.x
                # User-defined
                os.path.expanduser("~/.bash_completions"),
                # Nix (nix-darwin shared and per-user profiles)
                "/run/current-system/sw/share/bash-completion/bash_completion",
                os.path.expanduser("~/.nix-profile/share/bash-completion/bash_completion"),
            )
        elif ON_WINDOWS and git_for_windows_path():
            bcd = (
                os.path.join(
                    git_for_windows_path(), "usr\\share\\bash-completion\\bash_completion"
                ),
                os.path.join(
                    git_for_windows_path(),
                    "mingw64\\share\\git\\completion\\git-completion.bash",
                ),
            )
        elif ON_BSD:
            # FreeBSD/DragonFly install bash-completion via ports/pkg under
            # /usr/local; NetBSD/OpenBSD use the same prefix via pkgsrc, plus
            # NetBSD's /usr/pkg fallback.
            # Note: bash-completion 2.17 (FreeBSD 16+) also ships a
            # ``bash_completion.sh`` wrapper next to the library. We do not
            # list it because it bails out in non-interactive bash
            # (``[[ "$-" =~ i ]] || return 0``) — and xonsh's bridge runs
            # bash with ``-c``, i.e. non-interactively. The wrapper would
            # silently no-op and produce empty completions; the library
            # file below works in either mode.
            bcd = (
                "/usr/local/share/bash-completion/bash_completion",  # v2.x library
                "/usr/local/etc/bash_completion",  # v1.x
                "/usr/pkg/share/bash-completion/bash_completion",  # pkgsrc
                # User-defined
                os.path.expanduser("~/.bash_completions"),
            )
        else:
            bcd = ()
        return bcd

    @lazyobject
    def PATH_DEFAULT():
        if ON_TERMUX:
            # Android sandbox: there is no /usr; everything userland-installed
            # lives under $PREFIX (= /data/data/com.termux/files/usr by default).
            # Without this branch ON_LINUX is False on Termux (Python 3.13+ has
            # ``platform.system() == "Android"`` per PEP 738) so the generic
            # else-branch returns an empty tuple, leaving completers and the
            # syntax highlighter unable to recognize any external command.
            prefix = os.environ.get("PREFIX", "/data/data/com.termux/files/usr")
            return (
                os.path.expanduser("~/bin"),
                os.path.join(prefix, "bin"),
                os.path.join(prefix, "sbin"),
            )
        if ON_LINUX or ON_CYGWIN or ON_MSYS:
            if linux_distro() == "arch":
                pd = (
                    "/usr/local/sbin",
                    "/usr/local/bin",
                    "/usr/bin",
                    "/usr/bin/site_perl",
                    "/usr/bin/vendor_perl",
                    "/usr/bin/core_perl",
                )
            else:
                pd = (
                    os.path.expanduser("~/bin"),
                    "/usr/local/sbin",
                    "/usr/local/bin",
                    "/usr/sbin",
                    "/usr/bin",
                    "/sbin",
                    "/bin",
                    "/usr/games",
                    "/usr/local/games",
                )

                """
                On NixOS the coreutils bin path is versioned in /nix/store,
                so we need to locate something like: `/nix/store/<hash>-<coreutils>-<version>/bin`.
                """
                if Path("/nix").exists() and "PATH" in os.environ:
                    path_list = os.environ["PATH"].split(os.pathsep)
                    pd += tuple(
                        path
                        for path in path_list
                        if path.startswith("/nix") and path.endswith("/bin")
                    )

        elif ON_DARWIN:
            pd = ("/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin")
        elif ON_BSD:
            # FreeBSD's /etc/login.conf default; also matches the layout NetBSD,
            # OpenBSD and DragonFly use, with /usr/local/{s,}bin coming from
            # ports / pkgsrc.
            pd = (
                "/sbin",
                "/bin",
                "/usr/sbin",
                "/usr/bin",
                "/usr/local/sbin",
                "/usr/local/bin",
                os.path.expanduser("~/bin"),
            )
        elif ON_WINDOWS:
            import winreg

            key = winreg.OpenKey(
                winreg.HKEY_LOCAL_MACHINE,
                r"SYSTEM\CurrentControlSet\Control\Session Manager\Environment",
            )
            pd = tuple(winreg.QueryValueEx(key, "Path")[0].split(os.pathsep))
        else:
            pd = ()
        return pd

    #
    # libc
    #
    @lazyobject
    def LIBC():
        """The platform dependent libc implementation."""
        global ctypes
        if ON_DARWIN:
            import ctypes.util

            libc = ctypes.CDLL(ctypes.util.find_library("c"))
        elif ON_CYGWIN or ON_MSYS:
            # In MSYS2, sys.platform may report "cygwin" even though the
            # runtime library is msys-2.0.dll (not cygwin1.dll).  Try both.
            for _dll in ("msys-2.0.dll", "cygwin1.dll"):
                try:
                    libc = ctypes.CDLL(_dll)
                    break
                except OSError:
                    continue
            else:
                libc = None
        elif ON_FREEBSD:
            try:
                libc = ctypes.CDLL("libc.so.7")
            except OSError:
                libc = None
        elif ON_BSD:
            try:
                libc = ctypes.CDLL("libc.so")
            except AttributeError:
                libc = None
            except OSError:
                # macOS; can't use ctypes.util.find_library because that creates
                # a new process on Linux, which is undesirable.
                try:
                    libc = ctypes.CDLL("libc.dylib")
                except OSError:
                    libc = None
        elif ON_POSIX:
            try:
                libc = ctypes.CDLL("libc.so")
            except AttributeError:
                libc = None
            except OSError:
                # Debian and derivatives do the wrong thing because /usr/lib/libc.so
                # is a GNU ld script rather than an ELF object. To get around this, we
                # have to be more specific.
                # We don't want to use ctypes.util.find_library because that creates a
                # new process on Linux. We also don't want to try too hard because at
                # this point we're already pretty sure this isn't Linux.
                try:
                    libc = ctypes.CDLL("libc.so.6")
                except OSError:
                    libc = None
            if not hasattr(libc, "sysinfo"):
                # Not Linux.
                libc = None
        elif ON_WINDOWS:
            if hasattr(ctypes, "windll") and hasattr(ctypes.windll, "kernel32"):
                libc = ctypes.windll.kernel32
            else:
                try:
                    # Windows CE uses the cdecl calling convention.
                    libc = ctypes.CDLL("coredll.lib")
                except (AttributeError, OSError):
                    libc = None
        elif ON_BEOS:
            libc = ctypes.CDLL("libroot.so")
        else:
            libc = None
        return libc