# This is the mercurial setup script.

import ctypes

import logging

import os

import re

import shutil

import ssl

import stat

import subprocess

import sys

import sysconfig

import tempfile

if not ssl.HAS_TLSv1_2:

    error = """

The `ssl` module does not advertise support for TLS 1.2.

Please make sure that your Python installation was compiled against an OpenSSL

version enabling these features (likely this requires the OpenSSL version to

be at least 1.0.1).

"""

    print(error, file=sys.stderr)

    sys.exit(1)

DYLIB_SUFFIX = sysconfig.get_config_vars()['EXT_SUFFIX']

# Solaris Python packaging brain damage

try:

    import hashlib

    sha = hashlib.sha1()

except ImportError:

    try:

        import sha

        del sha  # silence unused import warning

    except ImportError:

        raise SystemExit(

            "Couldn't import standard hashlib (incomplete Python install)."

        )

try:

    import zlib

    del zlib  # silence unused import warning

except ImportError:

    raise SystemExit(

        "Couldn't import standard zlib (incomplete Python install)."

    )

try:

    import bz2

    del bz2  # silence unused import warning

except ImportError:

    raise SystemExit(

        "Couldn't import standard bz2 (incomplete Python install)."

    )

from setuptools import setup, Command, Extension, Distribution

from setuptools.command.build import build

from setuptools.command.build_ext import build_ext

from setuptools.command.build_py import build_py

from setuptools.command.install import install

from setuptools.command.install_lib import install_lib

from setuptools.command.install_scripts import install_scripts

from setuptools.errors import (

    CCompilerError,

    BaseError as DistutilsError,

    ExecError as DistutilsExecError,

)

# no setuptools.command.build_scripts

from distutils.command.build_scripts import build_scripts

from distutils.spawn import spawn

from distutils import file_util

from distutils.sysconfig import get_python_inc

from distutils.ccompiler import new_compiler

# raise an explicit error if setuptools_scm is not importable

try:

    import setuptools_scm

except ImportError:

    raise SystemExit(

        "Couldn't import setuptools_scm (direct call of setup.py?)."

    )

else:

    del setuptools_scm

ispypy = "PyPy" in sys.version

def sysstr(s):

    return s.decode('latin-1')

def eprint(*args, **kwargs):

    kwargs['file'] = sys.stderr

    print(*args, **kwargs)

def write_if_changed(path, content):

    """Write content to a file iff the content hasn't changed."""

    if os.path.exists(path):

        with open(path, 'rb') as fh:

            current = fh.read()

    else:

        current = b''

    if current != content:

        with open(path, 'wb') as fh:

            fh.write(content)

scripts = ['hg']

if os.name == 'nt':

    # We remove hg.bat if we are able to build hg.exe.

    scripts.append('contrib/win32/hg.bat')

def cancompile(cc, code):

    tmpdir = tempfile.mkdtemp(prefix='hg-install-')

    oldstderr = None

    try:

        fname = os.path.join(tmpdir, 'testcomp.c')

        with open(fname, 'w') as file:

            file.write(code)

        oldstderr = os.dup(sys.stderr.fileno())

        # Redirect stderr to /dev/null to hide any error messages

        # from the compiler.

        # This will have to be changed if we ever have to check

        # for a function on Windows.

        with open('/dev/null', 'w') as devnull:

            os.dup2(devnull.fileno(), sys.stderr.fileno())

        objects = cc.compile([fname], output_dir=tmpdir)

        cc.link_executable(objects, os.path.join(tmpdir, "a.out"))

        return True

    except Exception:

        return False

    finally:

        if oldstderr is not None:

            os.dup2(oldstderr, sys.stderr.fileno())

        shutil.rmtree(tmpdir)

# simplified version of distutils.ccompiler.CCompiler.has_function

# that actually removes its temporary files.

def hasfunction(cc, funcname):

    code = 'int main(void) { %s(); }\n' % funcname

    return cancompile(cc, code)

def hasheader(cc, headername):

    code = '#include <%s>\nint main(void) { return 0; }\n' % headername

    return cancompile(cc, code)

# py2exe needs to be installed to work

try:

    import py2exe

    py2exe.patch_distutils()

    py2exeloaded = True

    # import py2exe's patched Distribution class

    from distutils.core import Distribution

except ImportError:

    py2exeloaded = False

def runcmd(cmd, env, cwd=None):

    p = subprocess.Popen(

        cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env, cwd=cwd

    )

    out, err = p.communicate()

    return p.returncode, out, err

class hgcommand:

    def __init__(self, cmd, env):

        self.cmd = cmd

        self.env = env

    def __repr__(self):

        return f"<hgcommand cmd={self.cmd} env={self.env}>"

    def run(self, args):

        cmd = self.cmd + args

        returncode, out, err = runcmd(cmd, self.env)

        err = filterhgerr(err)

        if err:

            print("stderr from '%s':" % (' '.join(cmd)), file=sys.stderr)

            print(err, file=sys.stderr)

        if returncode != 0:

            print(

                "non zero-return '%s': %d" % (' '.join(cmd), returncode),

                file=sys.stderr,

            )

            return b''

        return out

def filterhgerr(err):

    # If root is executing setup.py, but the repository is owned by

    # another user (as in "sudo python setup.py install") we will get

    # trust warnings since the .hg/hgrc file is untrusted. That is

    # fine, we don't want to load it anyway.  Python may warn about

    # a missing __init__.py in mercurial/locale, we also ignore that.

    err = [

        e

        for e in err.splitlines()

        if (

            not e.startswith(b'not trusting file')

            and not e.startswith(b'warning: Not importing')

            and not (

                e.startswith(b'obsolete feature not enabled')

                or e.startswith(b'"obsolete" feature not enabled')

            )

            and not e.startswith(b'*** failed to import extension')

            and not e.startswith(b'devel-warn:')

            and not (

                e.startswith(b'(third party extension')

                and e.endswith(b'or newer of Mercurial; disabling)')

            )

        )

    ]

    return b'\n'.join(b'  ' + e for e in err)

def localhgenv(pure_python=True):

    """Get an environment dictionary to use for invoking or importing

    mercurial from the local repository."""

    # Execute hg out of this directory with a custom environment which takes

    # care to not use any hgrc files and do no localization.

    env = {

        'HGRCPATH': '',

        'LANGUAGE': 'C',

        'PATH': '',

    }  # make pypi modules that use os.environ['PATH'] happy

    if pure_python:

        env['HGMODULEPOLICY'] = 'py'

    if 'LD_LIBRARY_PATH' in os.environ:

        env['LD_LIBRARY_PATH'] = os.environ['LD_LIBRARY_PATH']

    if 'SystemRoot' in os.environ:

        # SystemRoot is required by Windows to load various DLLs.  See:

        # https://bugs.python.org/issue13524#msg148850

        env['SystemRoot'] = os.environ['SystemRoot']

    return env

version = ''

class hgbuild(build):

    # Insert hgbuildmo first so that files in mercurial/locale/ are found

    # when build_py is run next.

    sub_commands = [('build_mo', None)] + build.sub_commands

class hgbuildmo(build):

    description = "build translations (.mo files)"

    def run(self):

        result = self._run()

        if (

            not result

            and os.environ.get('MERCURIAL_SETUP_FORCE_TRANSLATIONS') == '1'

        ):

            raise DistutilsExecError("failed to build translations")

    def _run(self):

        try:

            from shutil import which as find_executable

        except ImportError:

            # Deprecated in py3.12

            from distutils.spawn import find_executable

        if not find_executable('msgfmt'):

            logging.warning(

                "could not find msgfmt executable, no translations "

                "will be built"

            )

            return False

        podir = 'i18n'

        if not os.path.isdir(podir):

            logging.warning("could not find %s/ directory", podir)

            return False

        join = os.path.join

        for po in os.listdir(podir):

            if not po.endswith('.po'):

                continue

            pofile = join(podir, po)

            modir = join('locale', po[:-3], 'LC_MESSAGES')

            mofile = join(modir, 'hg.mo')

            mobuildfile = join('mercurial', mofile)

            cmd = ['msgfmt', '-v', '-o', mobuildfile, pofile]

            if sys.platform != 'sunos5':

                # msgfmt on Solaris does not know about -c

                cmd.append('-c')

            self.mkpath(join('mercurial', modir))

            self.make_file([pofile], mobuildfile, spawn, (cmd,))

        return True

class hgdist(Distribution):

    pure = False

    rust = False

    no_rust = False

    cffi = ispypy

    global_options = Distribution.global_options + [

        ('pure', None, "use pure (slow) Python code instead of C extensions"),

        ('rust', None, "use Rust extensions additionally to C extensions"),

        (

            'no-rust',

            None,

            "do not use Rust extensions additionally to C extensions",

        ),

    ]

    negative_opt = Distribution.negative_opt.copy()

    boolean_options = ['pure', 'rust', 'no-rust']

    negative_opt['no-rust'] = 'rust'

    def _set_command_options(self, command_obj, option_dict=None):

        # Not all distutils versions in the wild have boolean_options.

        # This should be cleaned up when we're Python 3 only.

        command_obj.boolean_options = (

            getattr(command_obj, 'boolean_options', []) + self.boolean_options

        )

        return Distribution._set_command_options(

            self, command_obj, option_dict=option_dict

        )

    def parse_command_line(self):

        ret = Distribution.parse_command_line(self)

        if not (self.rust or self.no_rust):

            hgrustext = os.environ.get('HGWITHRUSTEXT')

            # TODO record it for proper rebuild upon changes

            # (see mercurial/__modulepolicy__.py)

            if hgrustext != 'cpython' and hgrustext is not None:

                if hgrustext:

                    msg = 'unknown HGWITHRUSTEXT value: %s' % hgrustext

                    print(msg, file=sys.stderr)

                hgrustext = None

            self.rust = hgrustext is not None

            self.no_rust = not self.rust

        return ret

    def has_ext_modules(self):

        # self.ext_modules is emptied in hgbuildpy.finalize_options which is

        # too late for some cases

        return not self.pure and Distribution.has_ext_modules(self)

# This is ugly as a one-liner. So use a variable.

buildextnegops = dict(getattr(build_ext, 'negative_options', {}))

buildextnegops['no-zstd'] = 'zstd'

buildextnegops['no-rust'] = 'rust'

class hgbuildext(build_ext):

    user_options = build_ext.user_options + [

        ('zstd', None, 'compile zstd bindings [default]'),

        ('no-zstd', None, 'do not compile zstd bindings'),

        (

            'rust',

            None,

            'compile Rust extensions if they are in use '

            '(requires Cargo) [default]',

        ),

        ('no-rust', None, 'do not compile Rust extensions'),

    ]

    boolean_options = build_ext.boolean_options + ['zstd', 'rust']

    negative_opt = buildextnegops

    def initialize_options(self):

        self.zstd = True

        self.rust = True

        return build_ext.initialize_options(self)

    def finalize_options(self):

        # Unless overridden by the end user, build extensions in parallel.

        # Only influences behavior on Python 3.5+.

        if getattr(self, 'parallel', None) is None:

            self.parallel = True

        return build_ext.finalize_options(self)

    def build_extensions(self):

        ruststandalones = [

            e for e in self.extensions if isinstance(e, RustStandaloneExtension)

        ]

        self.extensions = [

            e for e in self.extensions if e not in ruststandalones

        ]

        # Filter out zstd if disabled via argument.

        if not self.zstd:

            self.extensions = [

                e for e in self.extensions if e.name != 'mercurial.zstd'

            ]

        # Build Rust standalone extensions if it'll be used

        # and its build is not explicitly disabled (for external build

        # as Linux distributions would do)

        if self.distribution.rust and self.rust:

            if not sys.platform.startswith('linux'):

                logging.warning(

                    "rust extensions have only been tested on Linux "

                    "and may not behave correctly on other platforms"

                )

            for rustext in ruststandalones:

                rustext.build('' if self.editable_mode else self.build_lib)

        return build_ext.build_extensions(self)

    def build_extension(self, ext):

        if (

            self.distribution.rust

            and self.rust

            and isinstance(ext, RustExtension)

        ):

            ext.rustbuild()

        try:

            build_ext.build_extension(self, ext)

        except CCompilerError:

            if not getattr(ext, 'optional', False):

                raise

            logging.warning(

                "Failed to build optional extension '%s' (skipping)", ext.name

            )

class hgbuildscripts(build_scripts):

    def run(self):

        if os.name != 'nt' or self.distribution.pure:

            return build_scripts.run(self)

        exebuilt = False

        try:

            self.run_command('build_hgexe')

            exebuilt = True

        except (DistutilsError, CCompilerError):

            logging.warning('failed to build optional hg.exe')

        if exebuilt:

            # Copying hg.exe to the scripts build directory ensures it is

            # installed by the install_scripts command.

            hgexecommand = self.get_finalized_command('build_hgexe')

            dest = os.path.join(self.build_dir, 'hg.exe')

            self.mkpath(self.build_dir)

            self.copy_file(hgexecommand.hgexepath, dest)

            # Remove hg.bat because it is redundant with hg.exe.

            self.scripts.remove('contrib/win32/hg.bat')

        return build_scripts.run(self)

class hgbuildpy(build_py):

    def finalize_options(self):

        build_py.finalize_options(self)

        if self.distribution.pure:

            self.distribution.ext_modules = []

        elif self.distribution.cffi:

            from mercurial.cffi import (

                bdiffbuild,

                mpatchbuild,

            )

            exts = [

                mpatchbuild.ffi.distutils_extension(),

                bdiffbuild.ffi.distutils_extension(),