2005-07-03 01:40:15 +04:00
|
|
|
#
|
|
|
|
# This is the mercurial setup script.
|
2005-05-04 01:16:10 +04:00
|
|
|
#
|
2007-06-28 04:11:54 +04:00
|
|
|
# 'python setup.py install', or
|
|
|
|
# 'python setup.py --help' for more options
|
2005-05-04 01:16:10 +04:00
|
|
|
|
2018-01-09 01:35:01 +03:00
|
|
|
from distutils.version import LooseVersion
|
2018-01-10 23:08:50 +03:00
|
|
|
import glob
|
2017-07-26 20:21:34 +03:00
|
|
|
import os
|
|
|
|
|
2017-07-21 17:39:52 +03:00
|
|
|
supportedpy = '~= 2.7'
|
2017-07-26 20:21:34 +03:00
|
|
|
if os.environ.get('HGALLOWPYTHON3', ''):
|
2017-07-21 17:39:52 +03:00
|
|
|
# Mercurial will never work on Python 3 before 3.5 due to a lack
|
|
|
|
# of % formatting on bytestrings, and can't work on 3.6.0 or 3.6.1
|
|
|
|
# due to a bug in % formatting in bytestrings.
|
|
|
|
#
|
|
|
|
# TODO: when we actually work on Python 3, use this string as the
|
|
|
|
# actual supportedpy string.
|
|
|
|
supportedpy = ','.join([
|
|
|
|
'>=2.7',
|
|
|
|
'!=3.0.*',
|
|
|
|
'!=3.1.*',
|
|
|
|
'!=3.2.*',
|
|
|
|
'!=3.3.*',
|
|
|
|
'!=3.4.*',
|
|
|
|
'!=3.6.0',
|
|
|
|
'!=3.6.1',
|
|
|
|
])
|
|
|
|
|
2011-05-09 23:16:56 +04:00
|
|
|
import sys, platform
|
2010-07-02 23:21:34 +04:00
|
|
|
if sys.version_info[0] >= 3:
|
2013-09-19 23:38:42 +04:00
|
|
|
printf = eval('print')
|
|
|
|
libdir_escape = 'unicode_escape'
|
2017-12-05 15:31:01 +03:00
|
|
|
def sysstr(s):
|
|
|
|
return s.decode('latin-1')
|
2010-07-02 23:21:34 +04:00
|
|
|
else:
|
2013-09-19 23:38:42 +04:00
|
|
|
libdir_escape = 'string_escape'
|
|
|
|
def printf(*args, **kwargs):
|
|
|
|
f = kwargs.get('file', sys.stdout)
|
|
|
|
end = kwargs.get('end', '\n')
|
2015-12-13 20:40:53 +03:00
|
|
|
f.write(b' '.join(args) + end)
|
2017-12-05 15:31:01 +03:00
|
|
|
def sysstr(s):
|
|
|
|
return s
|
2010-07-02 23:21:34 +04:00
|
|
|
|
2018-01-09 01:35:01 +03:00
|
|
|
try:
|
|
|
|
import Cython
|
|
|
|
except ImportError:
|
|
|
|
havecython = False
|
|
|
|
else:
|
|
|
|
havecython = (LooseVersion(Cython.__version__) >= LooseVersion('0.22'))
|
|
|
|
|
|
|
|
if not havecython:
|
|
|
|
raise RuntimeError('Cython >= 0.22 is required')
|
|
|
|
|
|
|
|
from Cython.Build import cythonize
|
|
|
|
|
2017-07-21 17:46:31 +03:00
|
|
|
# Attempt to guide users to a modern pip - this means that 2.6 users
|
|
|
|
# should have a chance of getting a 4.2 release, and when we ratchet
|
|
|
|
# the version requirement forward again hopefully everyone will get
|
|
|
|
# something that works for them.
|
|
|
|
if sys.version_info < (2, 7, 0, 'final'):
|
|
|
|
pip_message = ('This may be due to an out of date pip. '
|
|
|
|
'Make sure you have pip >= 9.0.1.')
|
|
|
|
try:
|
|
|
|
import pip
|
|
|
|
pip_version = tuple([int(x) for x in pip.__version__.split('.')[:3]])
|
|
|
|
if pip_version < (9, 0, 1) :
|
|
|
|
pip_message = (
|
|
|
|
'Your pip version is out of date, please install '
|
|
|
|
'pip >= 9.0.1. pip {} detected.'.format(pip.__version__))
|
|
|
|
else:
|
|
|
|
# pip is new enough - it must be something else
|
|
|
|
pip_message = ''
|
|
|
|
except Exception:
|
|
|
|
pass
|
|
|
|
error = """
|
|
|
|
Mercurial does not support Python older than 2.7.
|
|
|
|
Python {py} detected.
|
|
|
|
{pip}
|
|
|
|
""".format(py=sys.version_info, pip=pip_message)
|
|
|
|
printf(error, file=sys.stderr)
|
|
|
|
sys.exit(1)
|
|
|
|
|
2009-01-01 02:59:58 +03:00
|
|
|
# Solaris Python packaging brain damage
|
|
|
|
try:
|
|
|
|
import hashlib
|
|
|
|
sha = hashlib.sha1()
|
2012-05-12 18:02:45 +04:00
|
|
|
except ImportError:
|
2009-01-01 02:59:58 +03:00
|
|
|
try:
|
|
|
|
import sha
|
2014-08-15 06:37:45 +04:00
|
|
|
sha.sha # silence unused import warning
|
2012-05-12 18:02:45 +04:00
|
|
|
except ImportError:
|
2009-01-01 02:59:58 +03:00
|
|
|
raise SystemExit(
|
|
|
|
"Couldn't import standard hashlib (incomplete Python install).")
|
|
|
|
|
|
|
|
try:
|
|
|
|
import zlib
|
2014-08-15 06:37:45 +04:00
|
|
|
zlib.compressobj # silence unused import warning
|
2012-05-12 18:02:45 +04:00
|
|
|
except ImportError:
|
2009-01-01 02:59:58 +03:00
|
|
|
raise SystemExit(
|
|
|
|
"Couldn't import standard zlib (incomplete Python install).")
|
|
|
|
|
2011-05-09 23:16:56 +04:00
|
|
|
# The base IronPython distribution (as of 2.7.1) doesn't support bz2
|
|
|
|
isironpython = False
|
2010-03-23 22:01:30 +03:00
|
|
|
try:
|
2012-05-12 17:54:54 +04:00
|
|
|
isironpython = (platform.python_implementation()
|
|
|
|
.lower().find("ironpython") != -1)
|
2012-05-12 18:02:45 +04:00
|
|
|
except AttributeError:
|
2011-05-09 23:16:56 +04:00
|
|
|
pass
|
|
|
|
|
|
|
|
if isironpython:
|
2011-11-12 05:07:55 +04:00
|
|
|
sys.stderr.write("warning: IronPython detected (no bz2 support)\n")
|
2011-05-09 23:16:56 +04:00
|
|
|
else:
|
|
|
|
try:
|
|
|
|
import bz2
|
2014-08-15 06:37:45 +04:00
|
|
|
bz2.BZ2Compressor # silence unused import warning
|
2012-05-12 18:02:45 +04:00
|
|
|
except ImportError:
|
2011-05-09 23:16:56 +04:00
|
|
|
raise SystemExit(
|
|
|
|
"Couldn't import standard bz2 (incomplete Python install).")
|
2010-03-23 22:01:30 +03:00
|
|
|
|
2015-02-22 17:40:36 +03:00
|
|
|
ispypy = "PyPy" in sys.version
|
|
|
|
|
2016-04-28 18:52:13 +03:00
|
|
|
import ctypes
|
2018-01-24 22:27:39 +03:00
|
|
|
import stat, subprocess
|
2014-04-16 00:27:12 +04:00
|
|
|
import re
|
2008-03-14 07:45:17 +03:00
|
|
|
import shutil
|
|
|
|
import tempfile
|
2010-06-23 15:44:07 +04:00
|
|
|
from distutils import log
|
2017-03-10 06:59:52 +03:00
|
|
|
# We have issues with setuptools on some platforms and builders. Until
|
|
|
|
# those are resolved, setuptools is opt-in except for platforms where
|
|
|
|
# we don't have issues.
|
2017-07-27 17:15:14 +03:00
|
|
|
issetuptools = (os.name == 'nt' or 'FORCE_SETUPTOOLS' in os.environ)
|
|
|
|
if issetuptools:
|
2015-10-09 20:25:51 +03:00
|
|
|
from setuptools import setup
|
|
|
|
else:
|
|
|
|
from distutils.core import setup
|
2016-11-11 23:45:40 +03:00
|
|
|
from distutils.ccompiler import new_compiler
|
2015-10-09 20:25:51 +03:00
|
|
|
from distutils.core import Command, Extension
|
2009-01-24 03:44:43 +03:00
|
|
|
from distutils.dist import Distribution
|
2009-01-15 02:11:54 +03:00
|
|
|
from distutils.command.build import build
|
2010-06-23 15:44:07 +04:00
|
|
|
from distutils.command.build_ext import build_ext
|
2009-01-24 03:44:43 +03:00
|
|
|
from distutils.command.build_py import build_py
|
2015-12-04 11:24:48 +03:00
|
|
|
from distutils.command.build_scripts import build_scripts
|
2017-05-08 06:29:03 +03:00
|
|
|
from distutils.command.install import install
|
2014-10-01 04:13:54 +04:00
|
|
|
from distutils.command.install_lib import install_lib
|
2010-08-17 17:44:38 +04:00
|
|
|
from distutils.command.install_scripts import install_scripts
|
2009-01-15 02:11:54 +03:00
|
|
|
from distutils.spawn import spawn, find_executable
|
2014-12-24 06:54:48 +03:00
|
|
|
from distutils import file_util
|
2015-12-04 11:24:48 +03:00
|
|
|
from distutils.errors import (
|
|
|
|
CCompilerError,
|
|
|
|
DistutilsError,
|
|
|
|
DistutilsExecError,
|
|
|
|
)
|
2014-04-16 00:27:12 +04:00
|
|
|
from distutils.sysconfig import get_python_inc, get_config_var
|
2018-01-09 02:26:24 +03:00
|
|
|
from distutils.version import (
|
|
|
|
StrictVersion,
|
|
|
|
LooseVersion,
|
|
|
|
)
|
|
|
|
from distutils_rust import (
|
|
|
|
RustExtension,
|
2018-01-10 04:48:32 +03:00
|
|
|
RustVendoredCrates,
|
2018-01-09 02:26:24 +03:00
|
|
|
BuildRustExt,
|
|
|
|
)
|
2018-01-09 04:55:53 +03:00
|
|
|
import distutils
|
2018-01-09 02:26:24 +03:00
|
|
|
|
2018-01-10 00:44:53 +03:00
|
|
|
haverust = False
|
|
|
|
try:
|
|
|
|
cargo_version = subprocess.check_output(
|
|
|
|
['cargo', '--version']).split()[1]
|
|
|
|
except Exception:
|
|
|
|
sys.stderr.write(
|
|
|
|
"not compiling Rust extensions: cargo is not available\n")
|
2018-01-09 02:26:24 +03:00
|
|
|
else:
|
2018-01-10 00:44:53 +03:00
|
|
|
required_cargo_version = '0.21'
|
|
|
|
if (LooseVersion(cargo_version) >= LooseVersion(required_cargo_version)):
|
|
|
|
haverust = True
|
2018-01-09 02:26:24 +03:00
|
|
|
else:
|
2018-01-10 00:44:53 +03:00
|
|
|
sys.stderr.write(
|
|
|
|
"not compiling Rust extensions: cargo is too old " +
|
|
|
|
"(found %s, need %s or higher)\n"
|
|
|
|
% (cargo_version, required_cargo_version))
|
|
|
|
|
|
|
|
if not haverust:
|
|
|
|
raise RuntimeError('Rust (and cargo >= 0.21) is required')
|
2005-05-26 04:21:06 +04:00
|
|
|
|
2018-01-08 23:54:57 +03:00
|
|
|
iswindows = os.name == 'nt'
|
|
|
|
NOOPTIMIZATION = "/Od" if iswindows else "-O0"
|
|
|
|
PRODUCEDEBUGSYMBOLS = "/DEBUG:FULL" if iswindows else "-g"
|
|
|
|
SHA1_LIBRARY = "sha1detectcoll"
|
|
|
|
SHA1LIB_DEFINE = "/DSHA1_USE_SHA1DC" if iswindows else "-DSHA1_USE_SHA1DC"
|
|
|
|
STDC99 = "" if iswindows else "-std=c99"
|
2018-01-09 04:55:53 +03:00
|
|
|
STDCPP0X = "" if iswindows else "-std=c++0x"
|
2018-01-09 04:45:51 +03:00
|
|
|
STDCPP11 = "" if iswindows else "-std=c++11"
|
2018-01-08 23:54:57 +03:00
|
|
|
WALL = "/Wall" if iswindows else "-Wall"
|
|
|
|
WSTRICTPROTOTYPES = None if iswindows else "-Werror=strict-prototypes"
|
|
|
|
|
|
|
|
cflags = [SHA1LIB_DEFINE]
|
|
|
|
|
|
|
|
# if this is set, compile all C extensions with -O0 -g for easy debugging. note
|
|
|
|
# that this is not manifested in any way in the Makefile dependencies.
|
|
|
|
# therefore, if you already have build products, they won't be rebuilt!
|
|
|
|
if os.getenv('FB_HGEXT_CDEBUG') is not None:
|
|
|
|
cflags.extend([NOOPTIMIZATION, PRODUCEDEBUGSYMBOLS])
|
|
|
|
|
2017-12-04 07:55:35 +03:00
|
|
|
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)
|
|
|
|
|
2008-04-11 01:07:54 +04:00
|
|
|
scripts = ['hg']
|
2018-01-10 23:06:26 +03:00
|
|
|
|
|
|
|
# Rename hg to $HGNAME. Useful when "hg" is a wrapper calling $HGNAME (or chg).
|
|
|
|
hgname = os.environ.get('HGNAME', 'hg')
|
|
|
|
if not re.match('\Ahg[.0-9a-z-]*\Z', hgname):
|
|
|
|
raise RuntimeError('Illegal HGNAME: %s' % hgname)
|
|
|
|
|
2008-04-11 01:07:54 +04:00
|
|
|
if os.name == 'nt':
|
2015-12-04 11:24:48 +03:00
|
|
|
# We remove hg.bat if we are able to build hg.exe.
|
2008-04-11 01:07:54 +04:00
|
|
|
scripts.append('contrib/win32/hg.bat')
|
2006-12-15 10:17:04 +03:00
|
|
|
|
2017-03-21 01:28:08 +03:00
|
|
|
def cancompile(cc, code):
|
2008-03-14 07:45:17 +03:00
|
|
|
tmpdir = tempfile.mkdtemp(prefix='hg-install-')
|
2008-03-24 03:35:57 +03:00
|
|
|
devnull = oldstderr = None
|
2008-03-14 07:45:17 +03:00
|
|
|
try:
|
2017-03-21 01:28:08 +03:00
|
|
|
fname = os.path.join(tmpdir, 'testcomp.c')
|
2015-05-15 18:00:46 +03:00
|
|
|
f = open(fname, 'w')
|
2017-03-21 01:28:08 +03:00
|
|
|
f.write(code)
|
2015-05-15 18:00:46 +03:00
|
|
|
f.close()
|
|
|
|
# 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.
|
|
|
|
devnull = open('/dev/null', 'w')
|
|
|
|
oldstderr = os.dup(sys.stderr.fileno())
|
|
|
|
os.dup2(devnull.fileno(), sys.stderr.fileno())
|
|
|
|
objects = cc.compile([fname], output_dir=tmpdir)
|
|
|
|
cc.link_executable(objects, os.path.join(tmpdir, "a.out"))
|
2008-03-14 07:45:17 +03:00
|
|
|
return True
|
2015-05-15 18:00:46 +03:00
|
|
|
except Exception:
|
|
|
|
return False
|
2008-03-14 07:45:17 +03:00
|
|
|
finally:
|
2008-03-24 03:35:57 +03:00
|
|
|
if oldstderr is not None:
|
|
|
|
os.dup2(oldstderr, sys.stderr.fileno())
|
|
|
|
if devnull is not None:
|
|
|
|
devnull.close()
|
2008-03-14 07:45:17 +03:00
|
|
|
shutil.rmtree(tmpdir)
|
|
|
|
|
2017-03-21 01:28:08 +03:00
|
|
|
# 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)
|
|
|
|
|
2017-03-21 01:31:21 +03:00
|
|
|
def hasheader(cc, headername):
|
|
|
|
code = '#include <%s>\nint main(void) { return 0; }\n' % headername
|
|
|
|
return cancompile(cc, code)
|
|
|
|
|
2005-09-21 06:25:14 +04:00
|
|
|
# py2exe needs to be installed to work
|
|
|
|
try:
|
2005-09-22 00:33:24 +04:00
|
|
|
import py2exe
|
2014-08-15 06:37:45 +04:00
|
|
|
py2exe.Distribution # silence unused import warning
|
2010-02-08 01:07:58 +03:00
|
|
|
py2exeloaded = True
|
2011-11-20 22:14:36 +04:00
|
|
|
# import py2exe's patched Distribution class
|
|
|
|
from distutils.core import Distribution
|
2005-09-21 08:29:07 +04:00
|
|
|
except ImportError:
|
2010-02-08 01:07:58 +03:00
|
|
|
py2exeloaded = False
|
2005-09-21 06:25:14 +04:00
|
|
|
|
2009-11-09 19:33:16 +03:00
|
|
|
def runcmd(cmd, env):
|
2017-06-17 01:42:03 +03:00
|
|
|
p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
|
|
|
|
stderr=subprocess.PIPE, env=env)
|
|
|
|
out, err = p.communicate()
|
2017-06-26 21:31:30 +03:00
|
|
|
return p.returncode, out, err
|
2011-03-14 01:39:33 +03:00
|
|
|
|
2017-06-28 02:15:32 +03:00
|
|
|
class hgcommand(object):
|
2017-06-28 02:15:32 +03:00
|
|
|
def __init__(self, cmd, env):
|
|
|
|
self.cmd = cmd
|
|
|
|
self.env = env
|
2017-06-28 02:15:32 +03:00
|
|
|
|
|
|
|
def run(self, args):
|
|
|
|
cmd = self.cmd + args
|
|
|
|
returncode, out, err = runcmd(cmd, self.env)
|
2017-07-20 16:32:37 +03:00
|
|
|
err = filterhgerr(err)
|
2017-06-28 02:15:32 +03:00
|
|
|
if err or returncode != 0:
|
|
|
|
printf("stderr from '%s':" % (' '.join(cmd)), file=sys.stderr)
|
2017-07-20 16:32:37 +03:00
|
|
|
printf(err, file=sys.stderr)
|
2017-06-28 02:15:32 +03:00
|
|
|
return ''
|
|
|
|
return out
|
2009-05-22 23:03:06 +04:00
|
|
|
|
2017-07-20 16:32:37 +03:00
|
|
|
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')
|
2017-10-24 06:13:59 +03:00
|
|
|
and not e.startswith(b'obsolete feature not enabled')
|
|
|
|
and not e.startswith(b'devel-warn:'))]
|
2017-07-20 16:32:37 +03:00
|
|
|
return b'\n'.join(b' ' + e for e in err)
|
|
|
|
|
2017-06-28 02:15:32 +03:00
|
|
|
def findhg():
|
|
|
|
"""Try to figure out how we should invoke hg for examining the local
|
|
|
|
repository contents.
|
|
|
|
|
|
|
|
Returns an hgcommand object."""
|
|
|
|
# By default, prefer the "hg" command in the user's path. This was
|
|
|
|
# presumably the hg command that the user used to create this repository.
|
|
|
|
#
|
|
|
|
# This repository may require extensions or other settings that would not
|
|
|
|
# be enabled by running the hg script directly from this local repository.
|
|
|
|
hgenv = os.environ.copy()
|
|
|
|
# Use HGPLAIN to disable hgrc settings that would change output formatting,
|
|
|
|
# and disable localization for the same reasons.
|
|
|
|
hgenv['HGPLAIN'] = '1'
|
|
|
|
hgenv['LANGUAGE'] = 'C'
|
|
|
|
hgcmd = ['hg']
|
|
|
|
# Run a simple "hg log" command just to see if using hg from the user's
|
|
|
|
# path works and can successfully interact with this repository.
|
|
|
|
check_cmd = ['log', '-r.', '-Ttest']
|
|
|
|
try:
|
|
|
|
retcode, out, err = runcmd(hgcmd + check_cmd, hgenv)
|
|
|
|
except EnvironmentError:
|
|
|
|
retcode = -1
|
2017-07-20 16:32:37 +03:00
|
|
|
if retcode == 0 and not filterhgerr(err):
|
2017-06-28 02:15:32 +03:00
|
|
|
return hgcommand(hgcmd, hgenv)
|
|
|
|
|
|
|
|
# Fall back to trying the local hg installation.
|
|
|
|
hgenv = localhgenv()
|
|
|
|
hgcmd = [sys.executable, 'hg']
|
|
|
|
try:
|
|
|
|
retcode, out, err = runcmd(hgcmd + check_cmd, hgenv)
|
|
|
|
except EnvironmentError:
|
|
|
|
retcode = -1
|
2017-07-20 16:32:37 +03:00
|
|
|
if retcode == 0 and not filterhgerr(err):
|
2017-06-28 02:15:32 +03:00
|
|
|
return hgcommand(hgcmd, hgenv)
|
|
|
|
|
|
|
|
raise SystemExit('Unable to find a working hg binary to extract the '
|
|
|
|
'version from the repository tags')
|
|
|
|
|
|
|
|
def localhgenv():
|
|
|
|
"""Get an environment dictionary to use for invoking or importing
|
|
|
|
mercurial from the local repository."""
|
2017-06-26 21:31:30 +03:00
|
|
|
# Execute hg out of this directory with a custom environment which takes
|
|
|
|
# care to not use any hgrc files and do no localization.
|
|
|
|
env = {'HGMODULEPOLICY': 'py',
|
|
|
|
'HGRCPATH': '',
|
|
|
|
'LANGUAGE': 'C',
|
|
|
|
'PATH': ''} # make pypi modules that use os.environ['PATH'] happy
|
|
|
|
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']
|
2017-06-28 16:49:01 +03:00
|
|
|
return env
|
2017-06-26 21:31:30 +03:00
|
|
|
|
2018-01-24 10:22:53 +03:00
|
|
|
def pickversion():
|
2017-06-28 02:15:32 +03:00
|
|
|
hg = findhg()
|
2018-01-24 10:22:53 +03:00
|
|
|
# New version system: YYMMDD_HHmmSS_hash
|
|
|
|
# This is duplicated a bit from build_rpm.py:auto_release_str()
|
|
|
|
template = '{sub("([:+-]|\d\d\d\d$)", "",date|isodatesec)} {node|short}'
|
|
|
|
out = sysstr(hg.run(['log', '-r.', '-T', template]))
|
2018-01-26 22:06:14 +03:00
|
|
|
# Some tools parse this number to figure out if they support this version of
|
|
|
|
# Mercurial, so prepend with 4.4.2.
|
|
|
|
# ex. 4.4.2_20180105_214829_58fda95a0202
|
|
|
|
return '4.4.2_' + '_'.join(out.split())
|
2018-01-24 10:22:53 +03:00
|
|
|
|
|
|
|
version = pickversion()
|
2009-05-22 23:03:06 +04:00
|
|
|
|
|
|
|
if version:
|
2017-12-04 07:55:35 +03:00
|
|
|
versionb = version
|
|
|
|
if not isinstance(versionb, bytes):
|
|
|
|
versionb = versionb.encode('ascii')
|
|
|
|
|
|
|
|
write_if_changed('mercurial/__version__.py', b''.join([
|
|
|
|
b'# this file is autogenerated by setup.py\n'
|
|
|
|
b'version = "%s"\n' % versionb,
|
|
|
|
]))
|
2009-04-03 04:18:43 +04:00
|
|
|
|
|
|
|
try:
|
2016-01-12 07:45:29 +03:00
|
|
|
oldpolicy = os.environ.get('HGMODULEPOLICY', None)
|
|
|
|
os.environ['HGMODULEPOLICY'] = 'py'
|
2009-04-03 04:18:43 +04:00
|
|
|
from mercurial import __version__
|
|
|
|
version = __version__.version
|
|
|
|
except ImportError:
|
|
|
|
version = 'unknown'
|
2016-01-12 07:45:29 +03:00
|
|
|
finally:
|
|
|
|
if oldpolicy is None:
|
|
|
|
del os.environ['HGMODULEPOLICY']
|
|
|
|
else:
|
|
|
|
os.environ['HGMODULEPOLICY'] = oldpolicy
|
2009-01-11 03:02:38 +03:00
|
|
|
|
2011-11-01 23:13:53 +04:00
|
|
|
class hgbuild(build):
|
|
|
|
# Insert hgbuildmo first so that files in mercurial/locale/ are found
|
|
|
|
# when build_py is run next.
|
2016-02-28 08:11:24 +03:00
|
|
|
sub_commands = [('build_mo', None)] + build.sub_commands
|
2011-11-01 23:13:53 +04:00
|
|
|
|
2011-11-18 09:01:58 +04:00
|
|
|
class hgbuildmo(build):
|
2009-01-15 02:11:54 +03:00
|
|
|
|
|
|
|
description = "build translations (.mo files)"
|
|
|
|
|
|
|
|
def run(self):
|
|
|
|
if not find_executable('msgfmt'):
|
|
|
|
self.warn("could not find msgfmt executable, no translations "
|
|
|
|
"will be built")
|
|
|
|
return
|
|
|
|
|
|
|
|
podir = 'i18n'
|
|
|
|
if not os.path.isdir(podir):
|
|
|
|
self.warn("could not find %s/ directory" % podir)
|
|
|
|
return
|
|
|
|
|
|
|
|
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')
|
2009-12-01 18:06:10 +03:00
|
|
|
mobuildfile = join('mercurial', mofile)
|
|
|
|
cmd = ['msgfmt', '-v', '-o', mobuildfile, pofile]
|
2009-01-28 12:32:15 +03:00
|
|
|
if sys.platform != 'sunos5':
|
|
|
|
# msgfmt on Solaris does not know about -c
|
|
|
|
cmd.append('-c')
|
2009-12-01 18:06:10 +03:00
|
|
|
self.mkpath(join('mercurial', modir))
|
|
|
|
self.make_file([pofile], mobuildfile, spawn, (cmd,))
|
2009-01-15 02:11:54 +03:00
|
|
|
|
2010-08-17 17:44:38 +04:00
|
|
|
|
2011-07-23 07:57:39 +04:00
|
|
|
class hgdist(Distribution):
|
2016-07-11 11:44:18 +03:00
|
|
|
pure = False
|
|
|
|
cffi = ispypy
|
2011-07-23 07:57:39 +04:00
|
|
|
|
|
|
|
global_options = Distribution.global_options + \
|
|
|
|
[('pure', None, "use pure (slow) Python "
|
|
|
|
"code instead of C extensions"),
|
|
|
|
]
|
2009-01-24 03:44:43 +03:00
|
|
|
|
2011-11-01 23:13:52 +04:00
|
|
|
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)
|
|
|
|
|
2016-11-18 07:09:10 +03:00
|
|
|
# This is ugly as a one-liner. So use a variable.
|
|
|
|
buildextnegops = dict(getattr(build_ext, 'negative_options', {}))
|
|
|
|
buildextnegops['no-zstd'] = 'zstd'
|
|
|
|
|
2010-06-23 15:44:07 +04:00
|
|
|
class hgbuildext(build_ext):
|
2016-11-18 07:09:10 +03:00
|
|
|
user_options = build_ext.user_options + [
|
|
|
|
('zstd', None, 'compile zstd bindings [default]'),
|
|
|
|
('no-zstd', None, 'do not compile zstd bindings'),
|
|
|
|
]
|
|
|
|
|
|
|
|
boolean_options = build_ext.boolean_options + ['zstd']
|
|
|
|
negative_opt = buildextnegops
|
|
|
|
|
|
|
|
def initialize_options(self):
|
|
|
|
self.zstd = True
|
|
|
|
return build_ext.initialize_options(self)
|
|
|
|
|
|
|
|
def build_extensions(self):
|
|
|
|
# Filter out zstd if disabled via argument.
|
|
|
|
if not self.zstd:
|
|
|
|
self.extensions = [e for e in self.extensions
|
|
|
|
if e.name != 'mercurial.zstd']
|
|
|
|
|
|
|
|
return build_ext.build_extensions(self)
|
2010-06-23 15:44:07 +04:00
|
|
|
|
|
|
|
def build_extension(self, ext):
|
|
|
|
try:
|
|
|
|
build_ext.build_extension(self, ext)
|
|
|
|
except CCompilerError:
|
2010-09-26 23:37:42 +04:00
|
|
|
if not getattr(ext, 'optional', False):
|
2010-06-23 15:44:07 +04:00
|
|
|
raise
|
|
|
|
log.warn("Failed to build optional extension '%s' (skipping)",
|
|
|
|
ext.name)
|
|
|
|
|
2015-12-04 11:24:48 +03:00
|
|
|
class hgbuildscripts(build_scripts):
|
|
|
|
def run(self):
|
2018-01-10 23:08:50 +03:00
|
|
|
# Build chg on non-Windows platform
|
|
|
|
if not iswindows:
|
|
|
|
cc = new_compiler()
|
|
|
|
chgcflags = ['-std=c99', '-D_GNU_SOURCE']
|
|
|
|
if hgname != 'hg':
|
|
|
|
chgcflags.append('-DHGPATH="%s"' % hgname)
|
|
|
|
objs = cc.compile(glob.glob('contrib/chg/*.c'), debug=True,
|
|
|
|
extra_preargs=chgcflags)
|
|
|
|
dest = os.path.join(self.build_dir, 'chg')
|
|
|
|
cc.link_executable(objs, dest)
|
|
|
|
|
|
|
|
# Potentially build hg.bat/exe
|
2016-02-08 15:12:13 +03:00
|
|
|
if os.name != 'nt' or self.distribution.pure:
|
2015-12-04 11:24:48 +03:00
|
|
|
return build_scripts.run(self)
|
|
|
|
|
|
|
|
exebuilt = False
|
|
|
|
try:
|
|
|
|
self.run_command('build_hgexe')
|
|
|
|
exebuilt = True
|
|
|
|
except (DistutilsError, CCompilerError):
|
|
|
|
log.warn('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)
|
|
|
|
|
2018-01-10 23:06:26 +03:00
|
|
|
def copy_scripts(self):
|
|
|
|
build_scripts.copy_scripts(self)
|
|
|
|
# Rename hg to hgname
|
|
|
|
if hgname != 'hg':
|
|
|
|
oldpath = os.path.join(self.build_dir, 'hg')
|
|
|
|
newpath = os.path.join(self.build_dir, hgname)
|
|
|
|
os.rename(oldpath, newpath)
|
|
|
|
|
2009-12-03 22:50:00 +03:00
|
|
|
class hgbuildpy(build_py):
|
2009-01-24 03:44:43 +03:00
|
|
|
def finalize_options(self):
|
|
|
|
build_py.finalize_options(self)
|
|
|
|
|
|
|
|
if self.distribution.pure:
|
|
|
|
self.distribution.ext_modules = []
|
2016-07-11 11:44:18 +03:00
|
|
|
elif self.distribution.cffi:
|
2016-11-10 01:08:30 +03:00
|
|
|
from mercurial.cffi import (
|
2017-05-02 15:04:40 +03:00
|
|
|
bdiffbuild,
|
|
|
|
mpatchbuild,
|
2016-11-10 01:08:30 +03:00
|
|
|
)
|
2017-05-02 15:04:40 +03:00
|
|
|
exts = [mpatchbuild.ffi.distutils_extension(),
|
|
|
|
bdiffbuild.ffi.distutils_extension()]
|
2016-07-11 11:44:18 +03:00
|
|
|
# cffi modules go here
|
2016-07-11 12:05:08 +03:00
|
|
|
if sys.platform == 'darwin':
|
2017-05-02 15:04:40 +03:00
|
|
|
from mercurial.cffi import osutilbuild
|
|
|
|
exts.append(osutilbuild.ffi.distutils_extension())
|
2016-07-11 11:44:18 +03:00
|
|
|
self.distribution.ext_modules = exts
|
2010-10-08 23:43:21 +04:00
|
|
|
else:
|
2013-04-13 00:55:34 +04:00
|
|
|
h = os.path.join(get_python_inc(), 'Python.h')
|
|
|
|
if not os.path.exists(h):
|
2012-05-12 17:54:54 +04:00
|
|
|
raise SystemExit('Python headers are required to build '
|
2013-04-13 00:55:34 +04:00
|
|
|
'Mercurial but weren\'t found in %s' % h)
|
2009-01-24 03:44:43 +03:00
|
|
|
|
2016-03-09 18:47:01 +03:00
|
|
|
def run(self):
|
2017-06-03 08:05:52 +03:00
|
|
|
basepath = os.path.join(self.build_lib, 'mercurial')
|
|
|
|
self.mkpath(basepath)
|
|
|
|
|
2016-03-09 18:47:01 +03:00
|
|
|
if self.distribution.pure:
|
|
|
|
modulepolicy = 'py'
|
2017-04-26 17:02:43 +03:00
|
|
|
elif self.build_lib == '.':
|
|
|
|
# in-place build should run without rebuilding C extensions
|
|
|
|
modulepolicy = 'allow'
|
2016-03-09 18:47:01 +03:00
|
|
|
else:
|
|
|
|
modulepolicy = 'c'
|
2017-12-04 07:55:35 +03:00
|
|
|
|
|
|
|
content = b''.join([
|
|
|
|
b'# this file is autogenerated by setup.py\n',
|
|
|
|
b'modulepolicy = b"%s"\n' % modulepolicy.encode('ascii'),
|
|
|
|
])
|
|
|
|
write_if_changed(os.path.join(basepath, '__modulepolicy__.py'),
|
|
|
|
content)
|
2016-03-09 18:47:01 +03:00
|
|
|
|
|
|
|
build_py.run(self)
|
2009-01-24 03:44:43 +03:00
|
|
|
|
2011-06-04 15:11:10 +04:00
|
|
|
class buildhgextindex(Command):
|
|
|
|
description = 'generate prebuilt index of hgext (for frozen package)'
|
|
|
|
user_options = []
|
|
|
|
_indexfilename = 'hgext/__index__.py'
|
|
|
|
|
|
|
|
def initialize_options(self):
|
|
|
|
pass
|
|
|
|
|
|
|
|
def finalize_options(self):
|
|
|
|
pass
|
|
|
|
|
|
|
|
def run(self):
|
|
|
|
if os.path.exists(self._indexfilename):
|
2016-03-09 18:35:57 +03:00
|
|
|
with open(self._indexfilename, 'w') as f:
|
|
|
|
f.write('# empty\n')
|
2011-06-04 15:11:10 +04:00
|
|
|
|
|
|
|
# here no extension enabled, disabled() lists up everything
|
|
|
|
code = ('import pprint; from mercurial import extensions; '
|
|
|
|
'pprint.pprint(extensions.disabled())')
|
2017-06-28 02:15:32 +03:00
|
|
|
returncode, out, err = runcmd([sys.executable, '-c', code],
|
|
|
|
localhgenv())
|
2017-06-26 21:31:30 +03:00
|
|
|
if err or returncode != 0:
|
2011-06-04 15:11:10 +04:00
|
|
|
raise DistutilsExecError(err)
|
|
|
|
|
2016-03-09 18:35:57 +03:00
|
|
|
with open(self._indexfilename, 'w') as f:
|
|
|
|
f.write('# this file is autogenerated by setup.py\n')
|
|
|
|
f.write('docs = ')
|
|
|
|
f.write(out)
|
2011-06-04 15:11:10 +04:00
|
|
|
|
2012-06-29 15:10:48 +04:00
|
|
|
class buildhgexe(build_ext):
|
|
|
|
description = 'compile hg.exe from mercurial/exewrapper.c'
|
2017-10-09 12:30:23 +03:00
|
|
|
user_options = build_ext.user_options + [
|
|
|
|
('long-paths-support', None, 'enable support for long paths on '
|
|
|
|
'Windows (off by default and '
|
|
|
|
'experimental)'),
|
|
|
|
]
|
|
|
|
|
|
|
|
LONG_PATHS_MANIFEST = """
|
|
|
|
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
|
|
|
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
|
|
|
|
<application>
|
|
|
|
<windowsSettings
|
|
|
|
xmlns:ws2="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
|
|
|
|
<ws2:longPathAware>true</ws2:longPathAware>
|
|
|
|
</windowsSettings>
|
|
|
|
</application>
|
|
|
|
</assembly>"""
|
|
|
|
|
|
|
|
def initialize_options(self):
|
|
|
|
build_ext.initialize_options(self)
|
|
|
|
self.long_paths_support = False
|
2012-06-29 15:10:48 +04:00
|
|
|
|
|
|
|
def build_extensions(self):
|
|
|
|
if os.name != 'nt':
|
|
|
|
return
|
2012-07-25 18:50:22 +04:00
|
|
|
if isinstance(self.compiler, HackedMingw32CCompiler):
|
|
|
|
self.compiler.compiler_so = self.compiler.compiler # no -mdll
|
|
|
|
self.compiler.dll_libraries = [] # no -lmsrvc90
|
2016-04-28 18:52:13 +03:00
|
|
|
|
|
|
|
# Different Python installs can have different Python library
|
|
|
|
# names. e.g. the official CPython distribution uses pythonXY.dll
|
|
|
|
# and MinGW uses libpythonX.Y.dll.
|
|
|
|
_kernel32 = ctypes.windll.kernel32
|
|
|
|
_kernel32.GetModuleFileNameA.argtypes = [ctypes.c_void_p,
|
|
|
|
ctypes.c_void_p,
|
|
|
|
ctypes.c_ulong]
|
|
|
|
_kernel32.GetModuleFileNameA.restype = ctypes.c_ulong
|
|
|
|
size = 1000
|
|
|
|
buf = ctypes.create_string_buffer(size + 1)
|
|
|
|
filelen = _kernel32.GetModuleFileNameA(sys.dllhandle, ctypes.byref(buf),
|
|
|
|
size)
|
|
|
|
|
|
|
|
if filelen > 0 and filelen != size:
|
|
|
|
dllbasename = os.path.basename(buf.value)
|
|
|
|
if not dllbasename.lower().endswith('.dll'):
|
|
|
|
raise SystemExit('Python DLL does not end with .dll: %s' %
|
|
|
|
dllbasename)
|
|
|
|
pythonlib = dllbasename[:-4]
|
|
|
|
else:
|
|
|
|
log.warn('could not determine Python DLL filename; '
|
|
|
|
'assuming pythonXY')
|
|
|
|
|
|
|
|
hv = sys.hexversion
|
|
|
|
pythonlib = 'python%d%d' % (hv >> 24, (hv >> 16) & 0xff)
|
|
|
|
|
|
|
|
log.info('using %s as Python library name' % pythonlib)
|
2016-03-09 18:35:57 +03:00
|
|
|
with open('mercurial/hgpythonlib.h', 'wb') as f:
|
|
|
|
f.write('/* this file is autogenerated by setup.py */\n')
|
|
|
|
f.write('#define HGPYTHONLIB "%s"\n' % pythonlib)
|
2012-06-29 15:10:48 +04:00
|
|
|
objects = self.compiler.compile(['mercurial/exewrapper.c'],
|
|
|
|
output_dir=self.build_temp)
|
|
|
|
dir = os.path.dirname(self.get_ext_fullpath('dummy'))
|
2017-10-09 12:30:23 +03:00
|
|
|
self.hgtarget = os.path.join(dir, 'hg')
|
|
|
|
self.compiler.link_executable(objects, self.hgtarget,
|
exewrapper: adapt for legacy HackableMercurial
We give up using CPython's PythonXX.lib import libraries (and Python.h), and
now "manually" call the LoadLibrary() / GetProcAddress() Windows API's instead.
If there is a "hg-python" subdirectory (the canonical directory name for
HackableMercurial's private Python copy) next to the hg.exe, we load the
pythonXX.dll from there (feeding an absolute path to LoadLibrary) and we set
Py_SetPythonHome() to that directory, so that the Python libraries are used
from there as well.
If there is no "hg-python" subdir found next to the hg.exe, we do not feed an
absolute path to LoadLibrary. This continues to allow to find a globally
installed Python DLL, as before this change - that is, without having to edit,
delete, rename, or configure anything.
Note that the hg.exe built is still bound to a *specific* major version of the
pythonXX.dll (e.g. python27.dll). What version it is, is inferred from the
version of the python interpreter that was used when calling setup.py. For
example
C:\python27_x86\python.exe setup.py build_hgexe -i --compiler=mingw32
builds a hg.exe (using the mingw32 tool chain) bound to (x86) Python 2.7. And
C:\python27_x86\python.exe setup.py build_hgexe -i
builds the same using the Microsoft C compiler/linker. (Note that the Microsoft
toolchain combined with x64 CPython can be used to build an x64 hg.exe.)
setup.py is changed to write the name of the pythonlib into the generated header
file "mercurial/hgpythonlib.h", which is #included by exewrapper.c. For a Python
2.7 build, it for example contains:
#define HGPYTHONLIB "python27"
exewrapper.c then uses HGPYTHONLIB for the name of the Python dll to load.
We don't want to track mercurial/hgpythonlib.h, so we add it to .hgignore.
2012-08-07 13:04:41 +04:00
|
|
|
libraries=[],
|
2012-06-29 15:10:48 +04:00
|
|
|
output_dir=self.build_temp)
|
2017-10-09 12:30:23 +03:00
|
|
|
if self.long_paths_support:
|
|
|
|
self.addlongpathsmanifest()
|
|
|
|
|
|
|
|
def addlongpathsmanifest(self):
|
|
|
|
"""Add manifest pieces so that hg.exe understands long paths
|
|
|
|
|
|
|
|
This is an EXPERIMENTAL feature, use with care.
|
|
|
|
To enable long paths support, one needs to do two things:
|
|
|
|
- build Mercurial with --long-paths-support option
|
|
|
|
- change HKLM\SYSTEM\CurrentControlSet\Control\FileSystem\
|
|
|
|
LongPathsEnabled to have value 1.
|
|
|
|
|
|
|
|
Please ignore 'warning 81010002: Unrecognized Element "longPathAware"';
|
|
|
|
it happens because Mercurial uses mt.exe circa 2008, which is not
|
|
|
|
yet aware of long paths support in the manifest (I think so at least).
|
|
|
|
This does not stop mt.exe from embedding/merging the XML properly.
|
|
|
|
|
|
|
|
Why resource #1 should be used for .exe manifests? I don't know and
|
|
|
|
wasn't able to find an explanation for mortals. But it seems to work.
|
|
|
|
"""
|
2018-01-23 23:09:14 +03:00
|
|
|
exefname = self.compiler.executable_filename(self.hgtarget,
|
|
|
|
output_dir=self.build_temp)
|
2017-10-09 12:30:23 +03:00
|
|
|
fdauto, manfname = tempfile.mkstemp(suffix='.hg.exe.manifest')
|
|
|
|
os.close(fdauto)
|
|
|
|
with open(manfname, 'w') as f:
|
|
|
|
f.write(self.LONG_PATHS_MANIFEST)
|
|
|
|
log.info("long paths manifest is written to '%s'" % manfname)
|
|
|
|
inputresource = '-inputresource:%s;#1' % exefname
|
|
|
|
outputresource = '-outputresource:%s;#1' % exefname
|
|
|
|
log.info("running mt.exe to update hg.exe's manifest in-place")
|
|
|
|
# supplying both -manifest and -inputresource to mt.exe makes
|
|
|
|
# it merge the embedded and supplied manifests in the -outputresource
|
|
|
|
self.spawn(['mt.exe', '-nologo', '-manifest', manfname,
|
|
|
|
inputresource, outputresource])
|
|
|
|
log.info("done updating hg.exe's manifest")
|
|
|
|
os.remove(manfname)
|
2012-06-29 15:10:48 +04:00
|
|
|
|
2015-12-04 11:24:48 +03:00
|
|
|
@property
|
|
|
|
def hgexepath(self):
|
|
|
|
dir = os.path.dirname(self.get_ext_fullpath('dummy'))
|
|
|
|
return os.path.join(self.build_temp, dir, 'hg.exe')
|
|
|
|
|
2017-05-08 06:29:03 +03:00
|
|
|
class hginstall(install):
|
2017-06-06 18:02:30 +03:00
|
|
|
|
|
|
|
user_options = install.user_options + [
|
|
|
|
('old-and-unmanageable', None,
|
|
|
|
'noop, present for eggless setuptools compat'),
|
|
|
|
('single-version-externally-managed', None,
|
|
|
|
'noop, present for eggless setuptools compat'),
|
|
|
|
]
|
|
|
|
|
|
|
|
# Also helps setuptools not be sad while we refuse to create eggs.
|
|
|
|
single_version_externally_managed = True
|
|
|
|
|
2017-05-08 06:29:03 +03:00
|
|
|
def get_sub_commands(self):
|
|
|
|
# Screen out egg related commands to prevent egg generation. But allow
|
|
|
|
# mercurial.egg-info generation, since that is part of modern
|
|
|
|
# packaging.
|
2017-07-26 17:39:42 +03:00
|
|
|
excl = set(['bdist_egg'])
|
2017-05-08 06:29:03 +03:00
|
|
|
return filter(lambda x: x not in excl, install.get_sub_commands(self))
|
|
|
|
|
2014-10-01 04:13:54 +04:00
|
|
|
class hginstalllib(install_lib):
|
|
|
|
'''
|
|
|
|
This is a specialization of install_lib that replaces the copy_file used
|
|
|
|
there so that it supports setting the mode of files after copying them,
|
|
|
|
instead of just preserving the mode that the files originally had. If your
|
|
|
|
system has a umask of something like 027, preserving the permissions when
|
|
|
|
copying will lead to a broken install.
|
|
|
|
|
|
|
|
Note that just passing keep_permissions=False to copy_file would be
|
|
|
|
insufficient, as it might still be applying a umask.
|
|
|
|
'''
|
|
|
|
|
|
|
|
def run(self):
|
|
|
|
realcopyfile = file_util.copy_file
|
|
|
|
def copyfileandsetmode(*args, **kwargs):
|
|
|
|
src, dst = args[0], args[1]
|
|
|
|
dst, copied = realcopyfile(*args, **kwargs)
|
|
|
|
if copied:
|
|
|
|
st = os.stat(src)
|
|
|
|
# Persist executable bit (apply it to group and other if user
|
|
|
|
# has it)
|
|
|
|
if st[stat.ST_MODE] & stat.S_IXUSR:
|
2015-04-12 22:36:10 +03:00
|
|
|
setmode = int('0755', 8)
|
2014-10-01 04:13:54 +04:00
|
|
|
else:
|
2015-04-12 22:36:10 +03:00
|
|
|
setmode = int('0644', 8)
|
|
|
|
m = stat.S_IMODE(st[stat.ST_MODE])
|
|
|
|
m = (m & ~int('0777', 8)) | setmode
|
|
|
|
os.chmod(dst, m)
|
2014-10-01 04:13:54 +04:00
|
|
|
file_util.copy_file = copyfileandsetmode
|
|
|
|
try:
|
|
|
|
install_lib.run(self)
|
|
|
|
finally:
|
|
|
|
file_util.copy_file = realcopyfile
|
|
|
|
|
2010-08-17 17:44:38 +04:00
|
|
|
class hginstallscripts(install_scripts):
|
|
|
|
'''
|
|
|
|
This is a specialization of install_scripts that replaces the @LIBDIR@ with
|
|
|
|
the configured directory for modules. If possible, the path is made relative
|
|
|
|
to the directory for scripts.
|
|
|
|
'''
|
|
|
|
|
|
|
|
def initialize_options(self):
|
|
|
|
install_scripts.initialize_options(self)
|
|
|
|
|
|
|
|
self.install_lib = None
|
|
|
|
|
|
|
|
def finalize_options(self):
|
|
|
|
install_scripts.finalize_options(self)
|
|
|
|
self.set_undefined_options('install',
|
|
|
|
('install_lib', 'install_lib'))
|
|
|
|
|
|
|
|
def run(self):
|
|
|
|
install_scripts.run(self)
|
|
|
|
|
2015-12-06 04:52:50 +03:00
|
|
|
# It only makes sense to replace @LIBDIR@ with the install path if
|
|
|
|
# the install path is known. For wheels, the logic below calculates
|
|
|
|
# the libdir to be "../..". This is because the internal layout of a
|
|
|
|
# wheel archive looks like:
|
|
|
|
#
|
|
|
|
# mercurial-3.6.1.data/scripts/hg
|
|
|
|
# mercurial/__init__.py
|
|
|
|
#
|
|
|
|
# When installing wheels, the subdirectories of the "<pkg>.data"
|
|
|
|
# directory are translated to system local paths and files therein
|
|
|
|
# are copied in place. The mercurial/* files are installed into the
|
|
|
|
# site-packages directory. However, the site-packages directory
|
|
|
|
# isn't known until wheel install time. This means we have no clue
|
|
|
|
# at wheel generation time what the installed site-packages directory
|
|
|
|
# will be. And, wheels don't appear to provide the ability to register
|
|
|
|
# custom code to run during wheel installation. This all means that
|
|
|
|
# we can't reliably set the libdir in wheels: the default behavior
|
|
|
|
# of looking in sys.path must do.
|
|
|
|
|
2010-08-17 17:44:38 +04:00
|
|
|
if (os.path.splitdrive(self.install_dir)[0] !=
|
|
|
|
os.path.splitdrive(self.install_lib)[0]):
|
|
|
|
# can't make relative paths from one drive to another, so use an
|
|
|
|
# absolute path instead
|
|
|
|
libdir = self.install_lib
|
|
|
|
else:
|
|
|
|
common = os.path.commonprefix((self.install_dir, self.install_lib))
|
|
|
|
rest = self.install_dir[len(common):]
|
|
|
|
uplevel = len([n for n in os.path.split(rest) if n])
|
|
|
|
|
2015-12-31 11:16:59 +03:00
|
|
|
libdir = uplevel * ('..' + os.sep) + self.install_lib[len(common):]
|
2010-08-17 17:44:38 +04:00
|
|
|
|
|
|
|
for outfile in self.outfiles:
|
2016-03-09 18:35:57 +03:00
|
|
|
with open(outfile, 'rb') as fp:
|
|
|
|
data = fp.read()
|
2010-08-17 17:44:38 +04:00
|
|
|
|
|
|
|
# skip binary files
|
2015-12-13 20:40:53 +03:00
|
|
|
if b'\0' in data:
|
2010-08-17 17:44:38 +04:00
|
|
|
continue
|
|
|
|
|
2015-12-06 04:52:50 +03:00
|
|
|
# During local installs, the shebang will be rewritten to the final
|
|
|
|
# install path. During wheel packaging, the shebang has a special
|
|
|
|
# value.
|
|
|
|
if data.startswith(b'#!python'):
|
|
|
|
log.info('not rewriting @LIBDIR@ in %s because install path '
|
|
|
|
'not known' % outfile)
|
|
|
|
continue
|
|
|
|
|
2015-12-13 20:40:53 +03:00
|
|
|
data = data.replace(b'@LIBDIR@', libdir.encode(libdir_escape))
|
2016-03-09 18:35:57 +03:00
|
|
|
with open(outfile, 'wb') as fp:
|
|
|
|
fp.write(data)
|
2010-08-17 17:44:38 +04:00
|
|
|
|
2011-11-01 23:13:53 +04:00
|
|
|
cmdclass = {'build': hgbuild,
|
|
|
|
'build_mo': hgbuildmo,
|
2010-06-23 15:44:07 +04:00
|
|
|
'build_ext': hgbuildext,
|
2010-08-17 17:44:38 +04:00
|
|
|
'build_py': hgbuildpy,
|
2015-12-04 11:24:48 +03:00
|
|
|
'build_scripts': hgbuildscripts,
|
2011-06-04 15:11:10 +04:00
|
|
|
'build_hgextindex': buildhgextindex,
|
2017-05-08 06:29:03 +03:00
|
|
|
'install': hginstall,
|
2014-10-01 04:13:54 +04:00
|
|
|
'install_lib': hginstalllib,
|
2012-06-29 15:10:48 +04:00
|
|
|
'install_scripts': hginstallscripts,
|
|
|
|
'build_hgexe': buildhgexe,
|
2018-01-09 02:26:24 +03:00
|
|
|
'build_rust_ext': BuildRustExt,
|
2012-06-29 15:10:48 +04:00
|
|
|
}
|
2006-10-03 13:30:59 +04:00
|
|
|
|
2016-08-12 05:06:14 +03:00
|
|
|
packages = ['mercurial',
|
|
|
|
'mercurial.cext',
|
2017-05-02 15:08:38 +03:00
|
|
|
'mercurial.cffi',
|
2016-08-12 05:06:14 +03:00
|
|
|
'mercurial.hgweb',
|
|
|
|
'mercurial.httpclient',
|
setup: refactor handling of modules with C/Python implementations
Previously, .py files under mercurial/pure/ were copied to mercurial/*
during installation if we were performing a pure Python installation.
Now that the new import hooks and module load policy are in place, this
hackery from the past is no longer necessary.
With this patch, we stop copying modules from mercurial/pure/* to
mercurial/*. Instead, we preserve the files at their original
hierarchy, mirroring the source repository structure.
In addition, we always install the pure modules. Before, we would only
include the pure modules in the distribution/installation if the
install-time settings requested a pure Python installation. The upside
of this change is that CPython and PyPy can run from the same Mercurial
installation, making packaging and distribution of Mercurial simpler.
The inclusion of pure Python modules in the installation sounds
risky, as it could lead to inadvertent loading of non-C modules.
This shouldn't be a problem. The default module load policy is "C
only" (or at least will be shortly) and the only way to load pure
modules from an installation is if a) pure installation was requested
b) the HGMODULELOADPOLICY overrides the requirement for C modules.
The default module load policy as defined in source is a special string
whose default value from the checkout is equivalent to the "C only"
policy (again, not exactly the state right now). For pure
installations, this default policy is not appropriate and will not
work. This patch adds support for rewriting __init__.py during
installation to reflect the module load policy that should be in
place accoding to the installation settings. For default CPython
installs, the value in the source file will change but there will
be no functional change. For pure installations, the default policy
will be set to "py," allowing them to work without having to set
environment variables.
2015-12-04 08:48:12 +03:00
|
|
|
'mercurial.pure',
|
2017-10-01 14:14:16 +03:00
|
|
|
'mercurial.thirdparty',
|
|
|
|
'mercurial.thirdparty.attr',
|
2018-01-09 00:57:01 +03:00
|
|
|
'hgext',
|
|
|
|
'hgext.absorb',
|
|
|
|
'hgext.convert',
|
2018-01-09 05:58:08 +03:00
|
|
|
'hgext.extlib',
|
2018-01-13 05:12:02 +03:00
|
|
|
'hgext.extlib.phabricator',
|
2018-01-09 23:38:05 +03:00
|
|
|
'hgext.fastannotate',
|
2018-01-09 23:58:51 +03:00
|
|
|
'hgext.fastmanifest',
|
2018-01-09 23:38:05 +03:00
|
|
|
'hgext.fbamend',
|
2018-01-09 00:57:01 +03:00
|
|
|
'hgext.fsmonitor',
|
2018-01-09 23:38:05 +03:00
|
|
|
'hgext.hggit',
|
2018-01-11 03:20:27 +03:00
|
|
|
'hgext.hgsubversion',
|
|
|
|
'hgext.hgsubversion.hooks',
|
|
|
|
'hgext.hgsubversion.layouts',
|
|
|
|
'hgext.hgsubversion.svnwrap',
|
2018-01-10 19:10:27 +03:00
|
|
|
'hgext.infinitepush',
|
2018-01-09 23:38:05 +03:00
|
|
|
'hgext.p4fastimport',
|
|
|
|
'hgext.remotefilelog',
|
|
|
|
'hgext.treemanifest',
|
2016-03-23 02:08:02 +03:00
|
|
|
'hgext.fsmonitor.pywatchman', 'hgext.highlight',
|
2018-01-17 22:50:44 +03:00
|
|
|
'hgext.lfs', 'hgext.zeroconf', 'hgext3rd',
|
2017-05-21 22:10:53 +03:00
|
|
|
'hgdemandimport']
|
2010-02-22 00:16:35 +03:00
|
|
|
|
2016-06-06 14:08:13 +03:00
|
|
|
common_depends = ['mercurial/bitmanipulation.h',
|
|
|
|
'mercurial/compat.h',
|
2017-05-21 07:35:19 +03:00
|
|
|
'mercurial/cext/util.h']
|
2018-01-26 07:45:12 +03:00
|
|
|
common_include_dirs = ['.']
|
2013-09-13 06:00:57 +04:00
|
|
|
|
2018-01-08 23:54:57 +03:00
|
|
|
def get_env_path_list(var_name, default=None):
|
|
|
|
'''Get a path list from an environment variable. The variable is parsed as
|
|
|
|
a colon-separated list.'''
|
|
|
|
value = os.environ.get(var_name)
|
|
|
|
if not value:
|
|
|
|
return default
|
|
|
|
return value.split(os.path.pathsep)
|
|
|
|
|
|
|
|
def filter_existing_dirs(dirs):
|
|
|
|
'''Filters the given list and keeps only existing directory names.'''
|
|
|
|
return [d for d in dirs if os.path.isdir(d)]
|
|
|
|
|
2018-01-09 04:55:53 +03:00
|
|
|
def distutils_dir_name(dname):
|
|
|
|
"""Returns the name of a distutils build directory"""
|
|
|
|
f = "{dirname}.{platform}-{version}"
|
|
|
|
return f.format(dirname=dname,
|
|
|
|
platform=distutils.util.get_platform(),
|
|
|
|
version=sys.version[:3])
|
|
|
|
|
2018-01-08 23:54:57 +03:00
|
|
|
# Historical default values.
|
|
|
|
# We should perhaps clean these up in the future after verifying that it
|
|
|
|
# doesn't break the build on any platforms.
|
|
|
|
#
|
|
|
|
# The /usr/local/* directories shouldn't actually be needed--the compiler
|
|
|
|
# should already use these directories when appropriate (e.g., if we are
|
|
|
|
# using the standard system compiler that has them in its default paths).
|
|
|
|
#
|
|
|
|
# The /opt/local paths may be necessary on Darwin builds.
|
|
|
|
include_dirs = get_env_path_list('INCLUDE_DIRS')
|
|
|
|
if include_dirs is None:
|
|
|
|
if iswindows:
|
|
|
|
include_dirs = []
|
|
|
|
else:
|
|
|
|
include_dirs = filter_existing_dirs([
|
|
|
|
'/usr/local/include',
|
|
|
|
'/opt/local/include',
|
|
|
|
'/opt/homebrew/include/',
|
|
|
|
])
|
|
|
|
|
2018-01-09 04:55:53 +03:00
|
|
|
library_dirs = get_env_path_list('LIBRARY_DIRS')
|
|
|
|
if library_dirs is None:
|
|
|
|
if iswindows:
|
|
|
|
library_dirs = []
|
|
|
|
else:
|
|
|
|
library_dirs = filter_existing_dirs([
|
|
|
|
'/usr/local/lib',
|
|
|
|
'/opt/local/lib',
|
|
|
|
'/opt/homebrew/lib/',
|
|
|
|
])
|
|
|
|
library_dirs.append('build/' + distutils_dir_name('lib'))
|
|
|
|
|
2016-11-11 23:45:40 +03:00
|
|
|
osutil_cflags = []
|
2015-05-14 12:04:35 +03:00
|
|
|
osutil_ldflags = []
|
|
|
|
|
2017-03-21 01:11:18 +03:00
|
|
|
# platform specific macros
|
2017-03-25 00:59:19 +03:00
|
|
|
for plat, func in [('bsd', 'setproctitle')]:
|
2017-03-21 01:11:18 +03:00
|
|
|
if re.search(plat, sys.platform) and hasfunction(new_compiler(), func):
|
2016-11-11 23:45:40 +03:00
|
|
|
osutil_cflags.append('-DHAVE_%s' % func.upper())
|
|
|
|
|
2017-03-24 08:15:36 +03:00
|
|
|
for plat, macro, code in [
|
|
|
|
('bsd|darwin', 'BSD_STATFS', '''
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/mount.h>
|
|
|
|
int main() { struct statfs s; return sizeof(s.f_fstypename); }
|
|
|
|
'''),
|
2017-03-25 00:59:19 +03:00
|
|
|
('linux', 'LINUX_STATFS', '''
|
|
|
|
#include <linux/magic.h>
|
|
|
|
#include <sys/vfs.h>
|
|
|
|
int main() { struct statfs s; return sizeof(s.f_type); }
|
|
|
|
'''),
|
2017-03-24 08:15:36 +03:00
|
|
|
]:
|
|
|
|
if re.search(plat, sys.platform) and cancompile(new_compiler(), code):
|
|
|
|
osutil_cflags.append('-DHAVE_%s' % macro)
|
|
|
|
|
2015-05-14 12:04:35 +03:00
|
|
|
if sys.platform == 'darwin':
|
|
|
|
osutil_ldflags += ['-framework', 'ApplicationServices']
|
|
|
|
|
2009-12-03 22:50:00 +03:00
|
|
|
extmodules = [
|
2016-08-13 06:08:23 +03:00
|
|
|
Extension('mercurial.cext.base85', ['mercurial/cext/base85.c'],
|
2016-08-12 05:06:14 +03:00
|
|
|
include_dirs=common_include_dirs,
|
2013-09-13 06:00:57 +04:00
|
|
|
depends=common_depends),
|
2016-08-13 06:12:50 +03:00
|
|
|
Extension('mercurial.cext.bdiff', ['mercurial/bdiff.c',
|
|
|
|
'mercurial/cext/bdiff.c'],
|
2016-08-12 05:06:14 +03:00
|
|
|
include_dirs=common_include_dirs,
|
2016-07-13 11:46:26 +03:00
|
|
|
depends=common_depends + ['mercurial/bdiff.h']),
|
2016-08-13 06:15:49 +03:00
|
|
|
Extension('mercurial.cext.diffhelpers', ['mercurial/cext/diffhelpers.c'],
|
2016-08-12 05:06:14 +03:00
|
|
|
include_dirs=common_include_dirs,
|
2013-09-13 06:00:57 +04:00
|
|
|
depends=common_depends),
|
2016-08-13 06:18:58 +03:00
|
|
|
Extension('mercurial.cext.mpatch', ['mercurial/mpatch.c',
|
|
|
|
'mercurial/cext/mpatch.c'],
|
2016-08-12 05:06:14 +03:00
|
|
|
include_dirs=common_include_dirs,
|
2013-09-13 06:00:57 +04:00
|
|
|
depends=common_depends),
|
2017-07-31 16:28:27 +03:00
|
|
|
Extension('mercurial.cext.parsers', ['mercurial/cext/charencode.c',
|
|
|
|
'mercurial/cext/dirs.c',
|
2016-08-13 06:23:56 +03:00
|
|
|
'mercurial/cext/manifest.c',
|
|
|
|
'mercurial/cext/parsers.c',
|
2017-05-21 00:01:05 +03:00
|
|
|
'mercurial/cext/pathencode.c',
|
|
|
|
'mercurial/cext/revlog.c'],
|
2016-08-12 05:06:14 +03:00
|
|
|
include_dirs=common_include_dirs,
|
2017-05-21 08:23:22 +03:00
|
|
|
depends=common_depends + ['mercurial/cext/charencode.h']),
|
2016-08-12 05:35:17 +03:00
|
|
|
Extension('mercurial.cext.osutil', ['mercurial/cext/osutil.c'],
|
2016-08-12 05:06:14 +03:00
|
|
|
include_dirs=common_include_dirs,
|
2016-11-11 23:45:40 +03:00
|
|
|
extra_compile_args=osutil_cflags,
|
2015-05-14 12:04:36 +03:00
|
|
|
extra_link_args=osutil_ldflags,
|
|
|
|
depends=common_depends),
|
2016-03-02 19:25:12 +03:00
|
|
|
Extension('hgext.fsmonitor.pywatchman.bser',
|
|
|
|
['hgext/fsmonitor/pywatchman/bser.c']),
|
2018-01-09 04:55:53 +03:00
|
|
|
]
|
2018-01-10 16:51:25 +03:00
|
|
|
if not iswindows:
|
|
|
|
extmodules += [
|
|
|
|
Extension('hgext.extlib.cstore',
|
|
|
|
sources=[
|
|
|
|
'hgext/extlib/cstore/datapackstore.cpp',
|
|
|
|
'hgext/extlib/cstore/deltachain.cpp',
|
|
|
|
'hgext/extlib/cstore/py-cstore.cpp',
|
|
|
|
'hgext/extlib/cstore/pythonutil.cpp',
|
|
|
|
'hgext/extlib/cstore/pythondatastore.cpp',
|
|
|
|
'hgext/extlib/cstore/uniondatapackstore.cpp',
|
|
|
|
'hgext/extlib/ctreemanifest/manifest.cpp',
|
|
|
|
'hgext/extlib/ctreemanifest/manifest_entry.cpp',
|
|
|
|
'hgext/extlib/ctreemanifest/manifest_fetcher.cpp',
|
|
|
|
'hgext/extlib/ctreemanifest/manifest_ptr.cpp',
|
|
|
|
'hgext/extlib/ctreemanifest/treemanifest.cpp',
|
|
|
|
],
|
|
|
|
include_dirs=[
|
|
|
|
'.',
|
|
|
|
] + include_dirs,
|
|
|
|
library_dirs=[
|
|
|
|
'build/' + distutils_dir_name('lib'),
|
|
|
|
] + library_dirs,
|
|
|
|
libraries=[
|
|
|
|
'datapack',
|
|
|
|
'lz4',
|
|
|
|
'mpatch',
|
|
|
|
SHA1_LIBRARY,
|
|
|
|
],
|
|
|
|
extra_compile_args=filter(None, [STDCPP0X, WALL] + cflags),
|
|
|
|
),
|
|
|
|
Extension('hgext.extlib.cfastmanifest',
|
|
|
|
sources=['hgext/extlib/cfastmanifest.c',
|
|
|
|
'hgext/extlib/cfastmanifest/bsearch.c',
|
|
|
|
'lib/clib/buffer.c',
|
|
|
|
'hgext/extlib/cfastmanifest/checksum.c',
|
|
|
|
'hgext/extlib/cfastmanifest/node.c',
|
|
|
|
'hgext/extlib/cfastmanifest/tree.c',
|
|
|
|
'hgext/extlib/cfastmanifest/tree_arena.c',
|
|
|
|
'hgext/extlib/cfastmanifest/tree_convert.c',
|
|
|
|
'hgext/extlib/cfastmanifest/tree_copy.c',
|
|
|
|
'hgext/extlib/cfastmanifest/tree_diff.c',
|
|
|
|
'hgext/extlib/cfastmanifest/tree_disk.c',
|
|
|
|
'hgext/extlib/cfastmanifest/tree_iterator.c',
|
|
|
|
'hgext/extlib/cfastmanifest/tree_path.c',
|
|
|
|
],
|
|
|
|
include_dirs=[
|
|
|
|
'.',
|
|
|
|
'hgext/extlib/cfastmanifest',
|
|
|
|
'lib/clib',
|
|
|
|
'lib/third-party',
|
|
|
|
] + include_dirs,
|
|
|
|
library_dirs=library_dirs,
|
|
|
|
libraries=[SHA1_LIBRARY],
|
|
|
|
extra_compile_args=filter(None, [
|
|
|
|
STDC99,
|
|
|
|
WALL,
|
|
|
|
WSTRICTPROTOTYPES,
|
|
|
|
] + cflags),
|
|
|
|
),
|
|
|
|
]
|
2007-10-06 02:01:06 +04:00
|
|
|
|
2018-01-09 01:35:01 +03:00
|
|
|
# Cython modules
|
|
|
|
# see http://cython.readthedocs.io/en/latest/src/reference/compilation.html
|
|
|
|
cythonopts = {
|
|
|
|
'unraisable_tracebacks': False,
|
|
|
|
'c_string_type': 'bytes',
|
|
|
|
}
|
|
|
|
|
2018-01-09 21:33:45 +03:00
|
|
|
extmodules += cythonize([
|
2018-01-09 21:50:46 +03:00
|
|
|
Extension('hgext.clindex',
|
|
|
|
sources=['hgext/clindex.pyx'],
|
2018-01-09 21:33:45 +03:00
|
|
|
extra_compile_args=filter(None, [STDC99, PRODUCEDEBUGSYMBOLS])),
|
2018-01-09 06:25:13 +03:00
|
|
|
Extension('hgext.patchrmdir',
|
|
|
|
sources=['hgext/patchrmdir.pyx'],
|
|
|
|
extra_compile_args=filter(None, [PRODUCEDEBUGSYMBOLS])),
|
2018-01-09 04:45:51 +03:00
|
|
|
Extension('hgext.traceprof',
|
|
|
|
sources=['hgext/traceprof.pyx'],
|
2018-01-26 07:45:12 +03:00
|
|
|
include_dirs=common_include_dirs,
|
2018-01-09 04:45:51 +03:00
|
|
|
extra_compile_args=filter(None, [STDCPP11, PRODUCEDEBUGSYMBOLS])),
|
2018-01-09 21:50:46 +03:00
|
|
|
Extension('hgext.extlib.linelog',
|
|
|
|
sources=['hgext/extlib/linelog.pyx'],
|
2018-01-26 07:45:12 +03:00
|
|
|
include_dirs=common_include_dirs,
|
2018-01-09 21:33:45 +03:00
|
|
|
extra_compile_args=filter(None, [STDC99, PRODUCEDEBUGSYMBOLS])),
|
|
|
|
], compiler_directives=cythonopts)
|
2018-01-09 01:35:01 +03:00
|
|
|
|
2018-01-10 16:51:25 +03:00
|
|
|
if iswindows:
|
|
|
|
libraries = []
|
|
|
|
else:
|
|
|
|
libraries = [
|
|
|
|
("datapack", {
|
|
|
|
"sources" : ["lib/cdatapack/cdatapack.c"],
|
|
|
|
"include_dirs" : ["."] + include_dirs,
|
|
|
|
"libraries" : ["lz4", SHA1_LIBRARY],
|
|
|
|
"extra_args" : filter(None,
|
2018-01-10 22:49:09 +03:00
|
|
|
[STDC99, WALL, WSTRICTPROTOTYPES] + cflags),
|
2018-01-10 16:51:25 +03:00
|
|
|
}),
|
|
|
|
('mpatch', {
|
|
|
|
"sources": ["hgext/extlib/cstore/mpatch.c"],
|
|
|
|
"include_dirs" : ["."] + include_dirs,
|
|
|
|
}),
|
|
|
|
("sha1detectcoll", {
|
|
|
|
"sources" : [
|
|
|
|
"lib/third-party/sha1dc/sha1.c",
|
|
|
|
"lib/third-party/sha1dc/ubc_check.c",
|
|
|
|
],
|
|
|
|
"include_dirs" : ["lib/third-party"] + include_dirs,
|
|
|
|
"extra_args" : filter(None,
|
2018-01-10 22:49:09 +03:00
|
|
|
[STDC99, WALL, WSTRICTPROTOTYPES] + cflags),
|
2018-01-10 16:51:25 +03:00
|
|
|
}),
|
|
|
|
]
|
2018-01-08 23:54:57 +03:00
|
|
|
|
2016-11-11 09:26:35 +03:00
|
|
|
sys.path.insert(0, 'contrib/python-zstandard')
|
|
|
|
import setup_zstd
|
2017-01-05 06:17:44 +03:00
|
|
|
extmodules.append(setup_zstd.get_c_extension(name='mercurial.zstd'))
|
2016-11-11 09:26:35 +03:00
|
|
|
|
2014-12-24 06:54:48 +03:00
|
|
|
try:
|
|
|
|
from distutils import cygwinccompiler
|
|
|
|
|
|
|
|
# the -mno-cygwin option has been deprecated for years
|
2017-08-11 04:16:00 +03:00
|
|
|
mingw32compilerclass = cygwinccompiler.Mingw32CCompiler
|
2012-07-07 07:19:55 +04:00
|
|
|
|
2014-12-24 06:54:48 +03:00
|
|
|
class HackedMingw32CCompiler(cygwinccompiler.Mingw32CCompiler):
|
|
|
|
def __init__(self, *args, **kwargs):
|
2017-08-11 04:16:00 +03:00
|
|
|
mingw32compilerclass.__init__(self, *args, **kwargs)
|
2014-12-24 06:54:48 +03:00
|
|
|
for i in 'compiler compiler_so linker_exe linker_so'.split():
|
|
|
|
try:
|
|
|
|
getattr(self, i).remove('-mno-cygwin')
|
|
|
|
except ValueError:
|
|
|
|
pass
|
2012-07-07 07:19:55 +04:00
|
|
|
|
2014-12-24 06:54:48 +03:00
|
|
|
cygwinccompiler.Mingw32CCompiler = HackedMingw32CCompiler
|
|
|
|
except ImportError:
|
|
|
|
# the cygwinccompiler package is not available on some Python
|
|
|
|
# distributions like the ones from the optware project for Synology
|
|
|
|
# DiskStation boxes
|
|
|
|
class HackedMingw32CCompiler(object):
|
|
|
|
pass
|
2012-07-07 07:19:55 +04:00
|
|
|
|
2017-06-10 05:15:53 +03:00
|
|
|
if os.name == 'nt':
|
|
|
|
# Allow compiler/linker flags to be added to Visual Studio builds. Passing
|
|
|
|
# extra_link_args to distutils.extensions.Extension() doesn't have any
|
|
|
|
# effect.
|
|
|
|
from distutils import msvccompiler
|
|
|
|
|
2017-08-11 04:16:00 +03:00
|
|
|
msvccompilerclass = msvccompiler.MSVCCompiler
|
2017-06-10 05:15:53 +03:00
|
|
|
|
|
|
|
class HackedMSVCCompiler(msvccompiler.MSVCCompiler):
|
|
|
|
def initialize(self):
|
2017-08-11 04:16:00 +03:00
|
|
|
msvccompilerclass.initialize(self)
|
2017-06-10 05:15:53 +03:00
|
|
|
# "warning LNK4197: export 'func' specified multiple times"
|
|
|
|
self.ldflags_shared.append('/ignore:4197')
|
2018-01-03 16:35:56 +03:00
|
|
|
self.ldflags_shared.append('/DEBUG')
|
2017-06-10 05:15:53 +03:00
|
|
|
self.ldflags_shared_debug.append('/ignore:4197')
|
2018-01-03 16:35:56 +03:00
|
|
|
self.compile_options.append('/Z7')
|
2017-06-10 05:15:53 +03:00
|
|
|
|
|
|
|
msvccompiler.MSVCCompiler = HackedMSVCCompiler
|
|
|
|
|
2009-12-01 18:06:10 +03:00
|
|
|
packagedata = {'mercurial': ['locale/*/LC_MESSAGES/hg.mo',
|
2014-09-26 04:19:48 +04:00
|
|
|
'help/*.txt',
|
2015-12-13 22:34:04 +03:00
|
|
|
'help/internals/*.txt',
|
2014-09-04 23:36:35 +04:00
|
|
|
'default.d/*.rc',
|
2018-01-11 03:20:37 +03:00
|
|
|
'dummycert.pem'],
|
|
|
|
'hgext': ['hgsubversion/help/*.rst']}
|
2009-12-01 18:06:10 +03:00
|
|
|
|
|
|
|
def ordinarypath(p):
|
|
|
|
return p and p[0] != '.' and p[-1] != '~'
|
|
|
|
|
2010-01-25 09:05:27 +03:00
|
|
|
for root in ('templates',):
|
2009-12-01 18:06:10 +03:00
|
|
|
for curdir, dirs, files in os.walk(os.path.join('mercurial', root)):
|
|
|
|
curdir = curdir.split(os.sep, 1)[1]
|
|
|
|
dirs[:] = filter(ordinarypath, dirs)
|
|
|
|
for f in filter(ordinarypath, files):
|
|
|
|
f = os.path.join(curdir, f)
|
|
|
|
packagedata['mercurial'].append(f)
|
|
|
|
|
2009-12-11 00:26:09 +03:00
|
|
|
datafiles = []
|
2017-03-12 04:14:02 +03:00
|
|
|
|
|
|
|
# distutils expects version to be str/unicode. Converting it to
|
|
|
|
# unicode on Python 2 still works because it won't contain any
|
|
|
|
# non-ascii bytes and will be implicitly converted back to bytes
|
|
|
|
# when operated on.
|
|
|
|
assert isinstance(version, bytes)
|
|
|
|
setupversion = version.decode('ascii')
|
|
|
|
|
2010-02-08 01:07:58 +03:00
|
|
|
extra = {}
|
|
|
|
|
2017-07-27 17:15:14 +03:00
|
|
|
if issetuptools:
|
|
|
|
extra['python_requires'] = supportedpy
|
2010-02-08 01:07:58 +03:00
|
|
|
if py2exeloaded:
|
|
|
|
extra['console'] = [
|
|
|
|
{'script':'hg',
|
2017-02-11 20:23:33 +03:00
|
|
|
'copyright':'Copyright (C) 2005-2017 Matt Mackall and others',
|
2010-02-08 01:07:58 +03:00
|
|
|
'product_version':version}]
|
2011-06-04 15:11:10 +04:00
|
|
|
# sub command of 'build' because 'py2exe' does not handle sub_commands
|
|
|
|
build.sub_commands.insert(0, ('build_hgextindex', None))
|
2015-06-03 22:31:19 +03:00
|
|
|
# put dlls in sub directory so that they won't pollute PATH
|
|
|
|
extra['zipfile'] = 'lib/library.zip'
|
2010-02-08 01:07:58 +03:00
|
|
|
|
|
|
|
if os.name == 'nt':
|
|
|
|
# Windows binary file versions for exe/dll files must have the
|
|
|
|
# form W.X.Y.Z, where W,X,Y,Z are numbers in the range 0..65535
|
|
|
|
setupversion = version.split('+', 1)[0]
|
2009-01-15 02:10:54 +03:00
|
|
|
|
2011-03-12 14:42:20 +03:00
|
|
|
if sys.platform == 'darwin' and os.path.exists('/usr/bin/xcodebuild'):
|
2017-06-28 20:50:37 +03:00
|
|
|
version = runcmd(['/usr/bin/xcodebuild', '-version'], {})[1].splitlines()
|
2012-02-27 17:54:26 +04:00
|
|
|
if version:
|
2012-03-02 22:42:12 +04:00
|
|
|
version = version[0]
|
2015-04-12 23:13:38 +03:00
|
|
|
if sys.version_info[0] == 3:
|
|
|
|
version = version.decode('utf-8')
|
2012-02-27 17:54:26 +04:00
|
|
|
xcode4 = (version.startswith('Xcode') and
|
|
|
|
StrictVersion(version.split()[1]) >= StrictVersion('4.0'))
|
2014-05-27 21:31:59 +04:00
|
|
|
xcode51 = re.match(r'^Xcode\s+5\.1', version) is not None
|
2012-02-27 17:54:26 +04:00
|
|
|
else:
|
|
|
|
# xcodebuild returns empty on OS X Lion with XCode 4.3 not
|
|
|
|
# installed, but instead with only command-line tools. Assume
|
|
|
|
# that only happens on >= Lion, thus no PPC support.
|
|
|
|
xcode4 = True
|
2014-04-16 00:27:12 +04:00
|
|
|
xcode51 = False
|
2012-02-27 17:54:26 +04:00
|
|
|
|
2014-04-16 00:27:12 +04:00
|
|
|
# XCode 4.0 dropped support for ppc architecture, which is hardcoded in
|
|
|
|
# distutils.sysconfig
|
2012-02-27 17:54:26 +04:00
|
|
|
if xcode4:
|
2011-05-15 09:07:58 +04:00
|
|
|
os.environ['ARCHFLAGS'] = ''
|
2011-03-12 14:42:20 +03:00
|
|
|
|
2014-04-16 00:27:12 +04:00
|
|
|
# XCode 5.1 changes clang such that it now fails to compile if the
|
|
|
|
# -mno-fused-madd flag is passed, but the version of Python shipped with
|
|
|
|
# OS X 10.9 Mavericks includes this flag. This causes problems in all
|
|
|
|
# C extension modules, and a bug has been filed upstream at
|
|
|
|
# http://bugs.python.org/issue21244. We also need to patch this here
|
|
|
|
# so Mercurial can continue to compile in the meantime.
|
|
|
|
if xcode51:
|
|
|
|
cflags = get_config_var('CFLAGS')
|
2014-07-05 18:31:08 +04:00
|
|
|
if cflags and re.search(r'-mno-fused-madd\b', cflags) is not None:
|
2014-04-16 00:27:12 +04:00
|
|
|
os.environ['CFLAGS'] = (
|
|
|
|
os.environ.get('CFLAGS', '') + ' -Qunused-arguments')
|
|
|
|
|
2018-01-08 23:54:57 +03:00
|
|
|
import distutils.command.build_clib
|
|
|
|
from distutils.errors import DistutilsSetupError
|
|
|
|
def build_libraries(self, libraries):
|
|
|
|
for (lib_name, build_info) in libraries:
|
|
|
|
sources = build_info.get('sources')
|
|
|
|
if sources is None or not isinstance(sources, (list, tuple)):
|
|
|
|
raise DistutilsSetupError(
|
|
|
|
"in 'libraries' option (library '%s'), " +
|
|
|
|
"'sources' must be present and must be " +
|
|
|
|
"a list of source filenames") % lib_name
|
|
|
|
sources = list(sources)
|
|
|
|
|
|
|
|
# First, compile the source code to object files in the library
|
|
|
|
# directory. (This should probably change to putting object
|
|
|
|
# files in a temporary build directory.)
|
|
|
|
macros = build_info.get('macros')
|
|
|
|
include_dirs = build_info.get('include_dirs')
|
|
|
|
extra_args = build_info.get('extra_args')
|
|
|
|
objects = self.compiler.compile(sources,
|
|
|
|
output_dir=self.build_temp,
|
|
|
|
macros=macros,
|
|
|
|
include_dirs=include_dirs,
|
|
|
|
debug=self.debug,
|
|
|
|
extra_postargs=extra_args)
|
|
|
|
|
|
|
|
# Now "link" the object files together into a static library.
|
|
|
|
# (On Unix at least, this isn't really linking -- it just
|
|
|
|
# builds an archive. Whatever.)
|
|
|
|
libraries = build_info.get('libraries', [])
|
|
|
|
for lib in libraries:
|
|
|
|
self.compiler.add_library(lib)
|
|
|
|
self.compiler.create_static_lib(objects, lib_name,
|
|
|
|
output_dir=self.build_clib,
|
|
|
|
debug=self.debug)
|
|
|
|
distutils.command.build_clib.build_clib.build_libraries = build_libraries
|
|
|
|
|
2018-01-10 04:48:32 +03:00
|
|
|
rustvendoredcrates = [
|
2018-01-12 04:16:44 +03:00
|
|
|
RustVendoredCrates('hg-vendored-crates', dest='build'),
|
2018-01-10 04:48:32 +03:00
|
|
|
]
|
|
|
|
|
2018-01-09 02:26:24 +03:00
|
|
|
rustextmodules = [
|
|
|
|
RustExtension('indexes',
|
|
|
|
package='hgext.extlib',
|
|
|
|
manifest='hgext/extlib/indexes/Cargo.toml',
|
|
|
|
),
|
|
|
|
RustExtension('treedirstate',
|
|
|
|
package='hgext.extlib',
|
|
|
|
manifest='hgext/extlib/treedirstate/Cargo.toml',
|
|
|
|
),
|
|
|
|
]
|
|
|
|
|
2018-01-11 03:20:27 +03:00
|
|
|
# If the Subversion SWIG bindings aren't present, require Subvertpy
|
|
|
|
requires = []
|
|
|
|
try:
|
|
|
|
from hgext.hgsubversion.svnwrap import svn_swig_wrapper
|
|
|
|
except ImportError:
|
|
|
|
requires.append('subvertpy>=0.7.4')
|
|
|
|
|
2006-03-19 23:26:58 +03:00
|
|
|
setup(name='mercurial',
|
2010-02-08 01:07:58 +03:00
|
|
|
version=setupversion,
|
2013-03-04 13:13:28 +04:00
|
|
|
author='Matt Mackall and many others',
|
2017-02-10 18:23:53 +03:00
|
|
|
author_email='mercurial@mercurial-scm.org',
|
2015-09-30 23:43:49 +03:00
|
|
|
url='https://mercurial-scm.org/',
|
|
|
|
download_url='https://mercurial-scm.org/release/',
|
2013-03-04 13:13:28 +04:00
|
|
|
description=('Fast scalable distributed SCM (revision control, version '
|
|
|
|
'control) system'),
|
|
|
|
long_description=('Mercurial is a distributed SCM tool written in Python.'
|
|
|
|
' It is used by a number of large projects that require'
|
|
|
|
' fast, reliable distributed revision control, such as '
|
|
|
|
'Mozilla.'),
|
|
|
|
license='GNU GPLv2 or any later version',
|
|
|
|
classifiers=[
|
|
|
|
'Development Status :: 6 - Mature',
|
|
|
|
'Environment :: Console',
|
|
|
|
'Intended Audience :: Developers',
|
|
|
|
'Intended Audience :: System Administrators',
|
|
|
|
'License :: OSI Approved :: GNU General Public License (GPL)',
|
|
|
|
'Natural Language :: Danish',
|
|
|
|
'Natural Language :: English',
|
|
|
|
'Natural Language :: German',
|
|
|
|
'Natural Language :: Italian',
|
|
|
|
'Natural Language :: Japanese',
|
|
|
|
'Natural Language :: Portuguese (Brazilian)',
|
|
|
|
'Operating System :: Microsoft :: Windows',
|
|
|
|
'Operating System :: OS Independent',
|
|
|
|
'Operating System :: POSIX',
|
|
|
|
'Programming Language :: C',
|
|
|
|
'Programming Language :: Python',
|
|
|
|
'Topic :: Software Development :: Version Control',
|
|
|
|
],
|
2008-04-11 01:07:54 +04:00
|
|
|
scripts=scripts,
|
2008-03-13 01:30:11 +03:00
|
|
|
packages=packages,
|
2009-12-03 22:50:00 +03:00
|
|
|
ext_modules=extmodules,
|
2018-01-08 23:54:57 +03:00
|
|
|
libraries=libraries,
|
2018-01-10 04:48:32 +03:00
|
|
|
rust_vendored_crates=rustvendoredcrates,
|
2018-01-09 02:26:24 +03:00
|
|
|
rust_ext_modules=rustextmodules,
|
2009-01-15 02:10:54 +03:00
|
|
|
data_files=datafiles,
|
2009-12-01 18:06:10 +03:00
|
|
|
package_data=packagedata,
|
2006-10-03 13:30:59 +04:00
|
|
|
cmdclass=cmdclass,
|
2011-07-23 07:57:39 +04:00
|
|
|
distclass=hgdist,
|
2018-01-11 03:20:27 +03:00
|
|
|
install_requires=requires,
|
2017-07-20 16:47:40 +03:00
|
|
|
options={'py2exe': {'packages': ['hgdemandimport', 'hgext', 'email',
|
|
|
|
# implicitly imported per module policy
|
|
|
|
# (cffi wouldn't be used as a frozen exe)
|
|
|
|
'mercurial.cext',
|
|
|
|
#'mercurial.cffi',
|
|
|
|
'mercurial.pure']},
|
2014-08-31 12:24:25 +04:00
|
|
|
'bdist_mpkg': {'zipdist': False,
|
2014-03-12 21:29:29 +04:00
|
|
|
'license': 'COPYING',
|
|
|
|
'readme': 'contrib/macosx/Readme.html',
|
|
|
|
'welcome': 'contrib/macosx/Welcome.html',
|
|
|
|
},
|
|
|
|
},
|
2006-12-15 10:17:04 +03:00
|
|
|
**extra)
|