Alien-SVN
view release on metacpan or search on metacpan
src/subversion/build/generator/gen_win.py view on Meta::CPAN
#
#
#
# gen_win.py -- base class for generating windows projects
#
import os
try:
# Python >=2.5
from hashlib import md5 as hashlib_md5
except ImportError:
# Python <2.5
from md5 import md5 as hashlib_md5
import sys
import fnmatch
import re
import subprocess
import glob
import string
import generator.swig.header_wrappers
import generator.swig.checkout_swig_header
import generator.swig.external_runtime
if sys.version_info[0] >= 3:
# Python >=3.0
from io import StringIO
else:
# Python <3.0
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
import gen_base
import ezt
class GeneratorBase(gen_base.GeneratorBase):
"""This intermediate base class exists to be instantiated by win-tests.py,
in order to obtain information from build.conf and library paths without
actually doing any generation."""
_extension_map = {
('exe', 'target'): '.exe',
('exe', 'object'): '.obj',
('lib', 'target'): '.dll',
('lib', 'object'): '.obj',
('pyd', 'target'): '.pyd',
('pyd', 'object'): '.obj',
}
def parse_options(self, options):
self.apr_path = 'apr'
self.apr_util_path = 'apr-util'
self.apr_iconv_path = 'apr-iconv'
self.serf_path = None
self.serf_lib = None
self.bdb_path = 'db4-win32'
self.httpd_path = None
self.libintl_path = None
self.zlib_path = 'zlib'
self.openssl_path = None
self.jdk_path = None
self.junit_path = None
self.swig_path = None
self.vs_version = '2002'
self.sln_version = '7.00'
self.vcproj_version = '7.00'
self.vcproj_extension = '.vcproj'
self.sqlite_path = 'sqlite-amalgamation'
self.skip_sections = { 'mod_dav_svn': None,
'mod_authz_svn': None,
'mod_dontdothat' : None,
'libsvn_auth_kwallet': None,
'libsvn_auth_gnome_keyring': None }
# Instrumentation options
self.disable_shared = None
self.static_apr = None
self.static_openssl = None
self.instrument_apr_pools = None
self.instrument_purify_quantify = None
self.configure_apr_util = None
self.sasl_path = None
# NLS options
self.enable_nls = None
# ML (assembler) is disabled by default; use --enable-ml to detect
self.enable_ml = None
for opt, val in options:
if opt == '--with-berkeley-db':
self.bdb_path = val
elif opt == '--with-apr':
self.apr_path = val
elif opt == '--with-apr-util':
self.apr_util_path = val
elif opt == '--with-apr-iconv':
self.apr_iconv_path = val
elif opt == '--with-serf':
self.serf_path = val
elif opt == '--with-httpd':
self.httpd_path = val
del self.skip_sections['mod_dav_svn']
del self.skip_sections['mod_authz_svn']
del self.skip_sections['mod_dontdothat']
elif opt == '--with-libintl':
self.libintl_path = val
self.enable_nls = 1
elif opt == '--with-jdk':
self.jdk_path = val
elif opt == '--with-junit':
self.junit_path = val
elif opt == '--with-zlib':
self.zlib_path = val
elif opt == '--with-swig':
self.swig_path = val
elif opt == '--with-sqlite':
self.sqlite_path = val
elif opt == '--with-sasl':
self.sasl_path = val
elif opt == '--with-openssl':
self.openssl_path = val
elif opt == '--enable-purify':
self.instrument_purify_quantify = 1
self.instrument_apr_pools = 1
elif opt == '--enable-quantify':
self.instrument_purify_quantify = 1
elif opt == '--enable-pool-debug':
self.instrument_apr_pools = 1
elif opt == '--enable-nls':
self.enable_nls = 1
elif opt == '--enable-bdb-in-apr-util':
self.configure_apr_util = 1
elif opt == '--enable-ml':
self.enable_ml = 1
elif opt == '--disable-shared':
self.disable_shared = 1
elif opt == '--with-static-apr':
self.static_apr = 1
elif opt == '--with-static-openssl':
self.static_openssl = 1
elif opt == '--vsnet-version':
if val == '2002' or re.match('7(\.\d+)?$', val):
self.vs_version = '2002'
self.sln_version = '7.00'
self.vcproj_version = '7.00'
self.vcproj_extension = '.vcproj'
elif val == '2003' or re.match('8(\.\d+)?$', val):
self.vs_version = '2003'
self.sln_version = '8.00'
self.vcproj_version = '7.10'
self.vcproj_extension = '.vcproj'
elif val == '2005' or re.match('9(\.\d+)?$', val):
self.vs_version = '2005'
self.sln_version = '9.00'
self.vcproj_version = '8.00'
self.vcproj_extension = '.vcproj'
elif val == '2008' or re.match('10(\.\d+)?$', val):
self.vs_version = '2008'
self.sln_version = '10.00'
self.vcproj_version = '9.00'
self.vcproj_extension = '.vcproj'
elif val == '2010':
self.vs_version = '2010'
self.sln_version = '11.00'
self.vcproj_version = '10.0'
self.vcproj_extension = '.vcxproj'
elif val == '2012' or val == '11':
self.vs_version = '2012'
self.sln_version = '12.00'
self.vcproj_version = '11.0'
self.vcproj_extension = '.vcxproj'
elif val == '2013' or val == '12':
self.vs_version = '2013'
self.sln_version = '12.00'
self.vcproj_version = '12.0'
self.vcproj_extension = '.vcxproj'
elif re.match('^1\d+$', val):
self.vs_version = val
self.sln_version = '12.00'
self.vcproj_version = val + '.0'
self.vcproj_extension = '.vcxproj'
else:
print('WARNING: Unknown VS.NET version "%s",'
' assuming "%s"\n' % (val, '7.00'))
def __init__(self, fname, verfname, options):
# parse (and save) the options that were passed to us
self.parse_options(options)
# Initialize parent
gen_base.GeneratorBase.__init__(self, fname, verfname, options)
# Find Berkeley DB
self._find_bdb()
def _find_bdb(self):
"Find the Berkeley DB library and version"
# Before adding "60" to this list, see build/ac-macros/berkeley-db.m4.
src/subversion/build/generator/gen_win.py view on Meta::CPAN
# Generate SWIG header wrappers and external runtime
for swig in (generator.swig.header_wrappers,
generator.swig.checkout_swig_header,
generator.swig.external_runtime):
swig.Generator(self.conf, self.swig_exe).write()
else:
print("%s not found; skipping SWIG file generation..." % self.swig_exe)
def find_rootpath(self):
"Gets the root path as understand by the project system"
return os.path.relpath('.', self.projfilesdir) + "\\"
def makeguid(self, data):
"Generate a windows style GUID"
### blah. this function can generate invalid GUIDs. leave it for now,
### but we need to fix it. we can wrap the apr UUID functions, or
### implement this from scratch using the algorithms described in
### http://www.webdav.org/specs/draft-leach-uuids-guids-01.txt
myhash = hashlib_md5(data).hexdigest()
guid = ("{%s-%s-%s-%s-%s}" % (myhash[0:8], myhash[8:12],
myhash[12:16], myhash[16:20],
myhash[20:32])).upper()
return guid
def path(self, *paths):
"""Convert build path to msvc path and prepend root"""
return self.rootpath + msvc_path_join(*list(map(msvc_path, paths)))
def apath(self, path, *paths):
"""Convert build path to msvc path and prepend root if not absolute"""
### On Unix, os.path.isabs won't do the right thing if "item"
### contains backslashes or drive letters
if os.path.isabs(path):
return msvc_path_join(msvc_path(path), *list(map(msvc_path, paths)))
else:
return self.rootpath + msvc_path_join(msvc_path(path),
*list(map(msvc_path, paths)))
def get_install_targets(self):
"Generate the list of targets"
# Get list of targets to generate project files for
install_targets = self.graph.get_all_sources(gen_base.DT_INSTALL) \
+ self.projects
# Don't create projects for scripts
install_targets = [x for x in install_targets if not isinstance(x, gen_base.TargetScript)]
# Drop the libsvn_fs_base target and tests if we don't have BDB
if not self.bdb_lib:
install_targets = [x for x in install_targets if x.name != 'libsvn_fs_base']
install_targets = [x for x in install_targets if not (isinstance(x, gen_base.TargetExe)
and x.install == 'bdb-test')]
# Don't build serf when we don't have it or for 1.3+
if not self.serf_lib or (self.serf_ver_maj, self.serf_ver_min) >= (1, 3):
install_targets = [x for x in install_targets if x.name != 'serf']
# Drop the serf target if we don't have both serf and openssl
if not self.serf_lib:
install_targets = [x for x in install_targets if x.name != 'libsvn_ra_serf']
# Don't build zlib if we have an already compiled serf
if self.serf_lib and (self.serf_ver_maj, self.serf_ver_min) >= (1, 3):
install_targets = [x for x in install_targets if x.name != 'zlib']
# Drop the swig targets if we don't have swig
if not self.swig_path and not self.swig_libdir:
install_targets = [x for x in install_targets
if not (isinstance(x, gen_base.TargetSWIG)
or isinstance(x, gen_base.TargetSWIGLib)
or isinstance(x, gen_base.TargetSWIGProject))]
# Drop the Java targets if we don't have a JDK
if not self.jdk_path:
install_targets = [x for x in install_targets
if not (isinstance(x, gen_base.TargetJava)
or isinstance(x, gen_base.TargetJavaHeaders)
or x.name == '__JAVAHL__'
or x.name == '__JAVAHL_TESTS__'
or x.name == 'libsvnjavahl')]
dll_targets = []
for target in install_targets:
if isinstance(target, gen_base.TargetLib):
if target.msvc_fake:
install_targets.append(self.create_fake_target(target))
if target.msvc_export:
if self.disable_shared:
target.msvc_static = True
else:
dll_targets.append(self.create_dll_target(target))
install_targets.extend(dll_targets)
for target in install_targets:
target.project_guid = self.makeguid(target.name)
# sort these for output stability, to watch out for regressions.
install_targets.sort(key = lambda t: t.name)
return install_targets
def create_fake_target(self, dep):
"Return a new target which depends on another target but builds nothing"
section = gen_base.TargetProject.Section(gen_base.TargetProject,
dep.name + "_fake",
{'path': 'build/win32'}, self)
section.create_targets()
section.target.msvc_name = dep.msvc_name and dep.msvc_name + "_fake"
self.graph.add(gen_base.DT_LINK, section.target.name, dep)
dep.msvc_fake = section.target
return section.target
def create_dll_target(self, dep):
"Return a dynamic library that depends on a static library"
target = gen_base.TargetLib(dep.name,
{ 'path' : dep.path,
'msvc-name' : dep.name + "_dll" },
self)
target.msvc_export = dep.msvc_export
src/subversion/build/generator/gen_win.py view on Meta::CPAN
# XXX: This is a hack until the apr build system is improved to
# XXX: know these things for itself.
if self.bdb_lib:
fakedefines.append("APU_HAVE_DB=1")
fakedefines.append("SVN_LIBSVN_FS_LINKS_FS_BASE=1")
# check if they wanted nls
if self.enable_nls:
fakedefines.append("ENABLE_NLS")
if self.serf_lib:
fakedefines.append("SVN_HAVE_SERF")
fakedefines.append("SVN_LIBSVN_CLIENT_LINKS_RA_SERF")
# check we have sasl
if self.sasl_path:
fakedefines.append("SVN_HAVE_SASL")
if target.name.endswith('svn_subr'):
fakedefines.append("SVN_USE_WIN32_CRASHHANDLER")
# use static linking to Expat
fakedefines.append("XML_STATIC")
return fakedefines
def get_win_includes(self, target):
"Return the list of include directories for target"
fakeincludes = [ self.path("subversion/include"),
self.path("subversion"),
self.apath(self.apr_path, "include"),
self.apath(self.apr_util_path, "include") ]
if target.name == 'mod_authz_svn':
fakeincludes.extend([ self.apath(self.httpd_path, "modules/aaa") ])
if isinstance(target, gen_base.TargetApacheMod):
fakeincludes.extend([ self.apath(self.apr_util_path, "xml/expat/lib"),
self.apath(self.httpd_path, "include"),
self.apath(self.bdb_path, "include") ])
elif isinstance(target, gen_base.TargetSWIG):
util_includes = "subversion/bindings/swig/%s/libsvn_swig_%s" \
% (target.lang,
gen_base.lang_utillib_suffix[target.lang])
fakeincludes.extend([ self.path("subversion/bindings/swig"),
self.path("subversion/bindings/swig/proxy"),
self.path("subversion/bindings/swig/include"),
self.path(util_includes) ])
else:
fakeincludes.extend([ self.apath(self.apr_util_path, "xml/expat/lib"),
self.path("subversion/bindings/swig/proxy"),
self.apath(self.bdb_path, "include") ])
if self.libintl_path:
fakeincludes.append(self.apath(self.libintl_path, 'inc'))
if self.serf_lib:
fakeincludes.append(self.apath(self.serf_path))
if self.openssl_path and self.openssl_inc_dir:
fakeincludes.append(self.apath(self.openssl_inc_dir))
if self.swig_libdir \
and (isinstance(target, gen_base.TargetSWIG)
or isinstance(target, gen_base.TargetSWIGLib)):
if self.swig_vernum >= 103028:
fakeincludes.append(self.apath(self.swig_libdir, target.lang))
if target.lang == 'perl':
# At least swigwin 1.3.38+ uses perl5 as directory name. Just add it
# to the list to make sure we don't break old versions
fakeincludes.append(self.apath(self.swig_libdir, 'perl5'))
else:
fakeincludes.append(self.swig_libdir)
if target.lang == "perl":
fakeincludes.extend(self.perl_includes)
if target.lang == "python":
fakeincludes.extend(self.python_includes)
if target.lang == "ruby":
fakeincludes.extend(self.ruby_includes)
fakeincludes.append(self.apath(self.zlib_path))
if self.sqlite_inline:
fakeincludes.append(self.apath(self.sqlite_path))
else:
fakeincludes.append(self.apath(self.sqlite_path, 'inc'))
if self.sasl_path:
fakeincludes.append(self.apath(self.sasl_path, 'include'))
if target.name == "libsvnjavahl" and self.jdk_path:
fakeincludes.append(os.path.join(self.jdk_path, 'include'))
fakeincludes.append(os.path.join(self.jdk_path, 'include', 'win32'))
if target.name.find('cxxhl') != -1:
fakeincludes.append(self.path("subversion/bindings/cxxhl/include"))
return fakeincludes
def get_win_lib_dirs(self, target, cfg):
"Return the list of library directories for target"
expatlibcfg = cfg.replace("Debug", "LibD").replace("Release", "LibR")
if self.static_apr:
libcfg = expatlibcfg
else:
libcfg = cfg
fakelibdirs = [ self.apath(self.bdb_path, "lib"),
self.apath(self.zlib_path),
]
if not self.sqlite_inline:
fakelibdirs.append(self.apath(self.sqlite_path, "lib"))
if self.sasl_path:
fakelibdirs.append(self.apath(self.sasl_path, "lib"))
if self.serf_lib:
if (self.serf_ver_maj, self.serf_ver_min) >= (1, 3):
fakelibdirs.append(self.apath(self.serf_path))
if self.openssl_path and self.openssl_lib_dir:
fakelibdirs.append(self.apath(self.openssl_lib_dir))
else:
fakelibdirs.append(self.apath(msvc_path_join(self.serf_path, cfg)))
fakelibdirs.append(self.apath(self.apr_path, libcfg))
fakelibdirs.append(self.apath(self.apr_util_path, libcfg))
fakelibdirs.append(self.apath(self.apr_util_path, 'xml', 'expat',
'lib', expatlibcfg))
if isinstance(target, gen_base.TargetApacheMod):
fakelibdirs.append(self.apath(self.httpd_path, cfg))
if target.name == 'mod_dav_svn':
fakelibdirs.append(self.apath(self.httpd_path, "modules/dav/main",
cfg))
if self.swig_libdir \
and (isinstance(target, gen_base.TargetSWIG)
or isinstance(target, gen_base.TargetSWIGLib)):
if target.lang == "perl" and self.perl_libdir:
fakelibdirs.append(self.perl_libdir)
if target.lang == "python" and self.python_libdir:
fakelibdirs.append(self.python_libdir)
if target.lang == "ruby" and self.ruby_libdir:
fakelibdirs.append(self.ruby_libdir)
return fakelibdirs
def get_win_libs(self, target, cfg):
"Return the list of external libraries needed for target"
dblib = None
if self.bdb_lib:
dblib = self.bdb_lib+(cfg == 'Debug' and 'd.lib' or '.lib')
if self.serf_lib:
if self.serf_ver_maj != 0:
serflib = 'serf-%d.lib' % self.serf_ver_maj
else:
serflib = 'serf.lib'
if self.serf_lib and (self.serf_ver_maj, self.serf_ver_min) >= (1, 3):
# We don't build zlib ourselves, so use the standard name
# (zdll.lib would link to zlib.dll)
zlib = 'zlib.lib'
else:
# We compile zlib ourselves to these explicit (non-standard) names
zlib = (cfg == 'Debug' and 'zlibstatD.lib' or 'zlibstat.lib')
sasllib = None
if self.sasl_path:
sasllib = 'libsasl.lib'
if not isinstance(target, gen_base.TargetLinked):
return []
if isinstance(target, gen_base.TargetLib) and target.msvc_static:
return []
nondeplibs = target.msvc_libs[:]
nondeplibs.append(zlib)
if self.enable_nls:
if self.libintl_path:
nondeplibs.append(self.apath(self.libintl_path,
'lib', 'intl3_svn.lib'))
else:
nondeplibs.append('intl3_svn.lib')
if isinstance(target, gen_base.TargetExe):
nondeplibs.append('setargv.obj')
if ((isinstance(target, gen_base.TargetSWIG)
or isinstance(target, gen_base.TargetSWIGLib))
and target.lang == 'perl'):
nondeplibs.append(self.perl_lib)
if ((isinstance(target, gen_base.TargetSWIG)
or isinstance(target, gen_base.TargetSWIGLib))
and target.lang == 'ruby'):
nondeplibs.append(self.ruby_lib)
for dep in self.get_win_depends(target, FILTER_LIBS):
nondeplibs.extend(dep.msvc_libs)
if dep.external_lib == '$(SVN_DB_LIBS)':
nondeplibs.append(dblib)
if dep.external_lib == '$(SVN_SQLITE_LIBS)' and not self.sqlite_inline:
nondeplibs.append('sqlite3.lib')
if self.serf_lib and dep.external_lib == '$(SVN_SERF_LIBS)':
nondeplibs.append(serflib)
if (self.serf_ver_maj, self.serf_ver_min) >= (1, 3):
nondeplibs.append('ssleay32.lib')
nondeplibs.append('libeay32.lib')
if dep.external_lib == '$(SVN_SASL_LIBS)':
nondeplibs.append(sasllib)
if dep.external_lib == '$(SVN_APR_LIBS)':
nondeplibs.append(self.apr_lib)
if dep.external_lib == '$(SVN_APRUTIL_LIBS)':
nondeplibs.append(self.aprutil_lib)
if dep.external_lib == '$(SVN_XML_LIBS)':
nondeplibs.append('xml.lib')
return gen_base.unique(nondeplibs)
def get_win_sources(self, target, reldir_prefix=''):
"Return the list of source files that need to be compliled for target"
sources = { }
for obj in self.graph.get_sources(gen_base.DT_LINK, target.name):
if isinstance(obj, gen_base.Target):
continue
for src in self.graph.get_sources(gen_base.DT_OBJECT, obj):
if isinstance(src, gen_base.SourceFile):
if reldir_prefix:
if src.reldir:
reldir = reldir_prefix + '\\' + src.reldir
else:
reldir = reldir_prefix
else:
reldir = src.reldir
else:
reldir = ''
sources[src] = src, obj, reldir
return list(sources.values())
def write_file_if_changed(self, fname, new_contents):
"""Rewrite the file if new_contents are different than its current content.
If you have your windows projects open and generate the projects
it's not a small thing for windows to re-read all projects so
only update those that have changed.
"""
try:
old_contents = open(fname, 'rb').read()
except IOError:
old_contents = None
if old_contents != new_contents:
open(fname, 'wb').write(new_contents)
print("Wrote: %s" % fname)
def write_with_template(self, fname, tname, data):
fout = StringIO()
template = ezt.Template(compress_whitespace = 0)
template.parse_file(os.path.join('build', 'generator', tname))
template.generate(fout, data)
self.write_file_if_changed(fname, fout.getvalue())
def write_zlib_project_file(self, name):
if not self.zlib_path:
return
zlib_path = os.path.abspath(self.zlib_path)
zlib_sources = map(lambda x : os.path.relpath(x, self.projfilesdir),
glob.glob(os.path.join(zlib_path, '*.c')) +
glob.glob(os.path.join(zlib_path,
'contrib/masmx86/*.c')) +
glob.glob(os.path.join(zlib_path,
'contrib/masmx86/*.asm')))
zlib_headers = map(lambda x : os.path.relpath(x, self.projfilesdir),
glob.glob(os.path.join(zlib_path, '*.h')))
self.move_proj_file(self.projfilesdir, name,
(('zlib_path', os.path.relpath(zlib_path,
self.projfilesdir)),
('zlib_sources', zlib_sources),
('zlib_headers', zlib_headers),
('zlib_version', self.zlib_version),
('project_guid', self.makeguid('zlib')),
('use_ml', self.have_ml and 1 or None),
))
def write_serf_project_file(self, name):
if not self.serf_lib:
return
serf_path = os.path.abspath(self.serf_path)
serf_sources = map(lambda x : os.path.relpath(x, self.serf_path),
glob.glob(os.path.join(serf_path, '*.c'))
+ glob.glob(os.path.join(serf_path, 'auth', '*.c'))
+ glob.glob(os.path.join(serf_path, 'buckets',
'*.c')))
serf_headers = map(lambda x : os.path.relpath(x, self.serf_path),
glob.glob(os.path.join(serf_path, '*.h'))
+ glob.glob(os.path.join(serf_path, 'auth', '*.h'))
+ glob.glob(os.path.join(serf_path, 'buckets', '*.h')))
if self.serf_ver_maj != 0:
serflib = 'serf-%d.lib' % self.serf_ver_maj
else:
serflib = 'serf.lib'
apr_static = self.static_apr and 'APR_STATIC=1' or ''
openssl_static = self.static_openssl and 'OPENSSL_STATIC=1' or ''
self.move_proj_file(self.serf_path, name,
(('serf_sources', serf_sources),
('serf_headers', serf_headers),
('zlib_path', os.path.relpath(self.zlib_path,
self.serf_path)),
('openssl_path', os.path.relpath(self.openssl_path,
self.serf_path)),
('apr_path', os.path.relpath(self.apr_path,
self.serf_path)),
('apr_util_path', os.path.relpath(self.apr_util_path,
self.serf_path)),
('project_guid', self.makeguid('serf')),
('apr_static', apr_static),
('openssl_static', openssl_static),
('serf_lib', serflib),
))
def move_proj_file(self, path, name, params=()):
### Move our slightly templatized pre-built project files into place --
### these projects include zlib, serf, locale, config, etc.
dest_file = os.path.join(path, name)
source_template = os.path.join('templates', name + '.ezt')
data = {
'version' : self.vcproj_version,
'configs' : self.configs,
'platforms' : self.platforms,
'toolset_version' : 'v' + self.vcproj_version.replace('.',''),
}
for key, val in params:
data[key] = val
self.write_with_template(dest_file, source_template, data)
def write(self):
"Override me when creating a new project type"
raise NotImplementedError
def _find_perl(self):
"Find the right perl library name to link swig bindings with"
self.perl_includes = []
self.perl_libdir = None
fp = os.popen('perl -MConfig -e ' + escape_shell_arg(
'print "$Config{PERL_REVISION}$Config{PERL_VERSION}"'), 'r')
try:
line = fp.readline()
if line:
msg = 'Found installed perl version number.'
self.perl_lib = 'perl' + line.rstrip() + '.lib'
else:
msg = 'Could not detect perl version.'
self.perl_lib = 'perl56.lib'
print('%s\n Perl bindings will be linked with %s\n'
% (msg, self.perl_lib))
finally:
fp.close()
fp = os.popen('perl -MConfig -e ' + escape_shell_arg(
'print $Config{archlib}'), 'r')
try:
line = fp.readline()
if line:
self.perl_libdir = os.path.join(line, 'CORE')
self.perl_includes = [os.path.join(line, 'CORE')]
finally:
fp.close()
def _find_ruby(self):
"Find the right Ruby library name to link swig bindings with"
self.ruby_includes = []
self.ruby_libdir = None
self.ruby_version = None
self.ruby_major_version = None
self.ruby_minor_version = None
src/subversion/build/generator/gen_win.py view on Meta::CPAN
if libdir:
print('Using SWIG library directory %s\n' % libdir)
return libdir
else:
print('WARNING: could not find SWIG library directory\n')
finally:
fp.close()
return ''
def _find_ml(self):
"Check if the ML assembler is in the path"
if not self.enable_ml:
self.have_ml = 0
return
fp = os.popen('ml /help', 'r')
try:
line = fp.readline()
if line:
msg = 'Found ML, ZLib build will use ASM sources'
self.have_ml = 1
else:
msg = 'Could not find ML, ZLib build will not use ASM sources'
self.have_ml = 0
print('%s\n' % (msg,))
finally:
fp.close()
def _get_serf_version(self):
"Retrieves the serf version from serf.h"
# shouldn't be called unless serf is there
assert self.serf_path and os.path.exists(self.serf_path)
self.serf_ver_maj = None
self.serf_ver_min = None
self.serf_ver_patch = None
# serf.h should be present
if not os.path.exists(os.path.join(self.serf_path, 'serf.h')):
return None, None, None
txt = open(os.path.join(self.serf_path, 'serf.h')).read()
maj_match = re.search(r'SERF_MAJOR_VERSION\s+(\d+)', txt)
min_match = re.search(r'SERF_MINOR_VERSION\s+(\d+)', txt)
patch_match = re.search(r'SERF_PATCH_VERSION\s+(\d+)', txt)
if maj_match:
self.serf_ver_maj = int(maj_match.group(1))
if min_match:
self.serf_ver_min = int(min_match.group(1))
if patch_match:
self.serf_ver_patch = int(patch_match.group(1))
return self.serf_ver_maj, self.serf_ver_min, self.serf_ver_patch
def _find_serf(self):
"Check if serf and its dependencies are available"
minimal_serf_version = (1, 2, 1)
if self.openssl_path and os.path.exists(self.openssl_path):
version_path = os.path.join(self.openssl_path, 'inc32/openssl/opensslv.h')
if os.path.isfile(version_path):
# We have an OpenSSL Source location (legacy handling)
self.openssl_inc_dir = os.path.join(self.openssl_path, 'inc32')
if self.static_openssl:
self.openssl_lib_dir = os.path.join(self.openssl_path, 'out32')
else:
self.openssl_lib_dir = os.path.join(self.openssl_path, 'out32dll')
elif os.path.isfile(os.path.join(self.openssl_path,
'include/openssl/opensslv.h')):
self.openssl_inc_dir = os.path.join(self.openssl_path, 'include')
self.openssl_lib_dir = os.path.join(self.openssl_path, 'lib')
else:
print('WARNING: \'opensslv.h\' not found')
self.openssl_path = None
self.serf_lib = None
if self.serf_path and os.path.exists(self.serf_path):
if self.openssl_path and os.path.exists(self.openssl_path):
self.serf_lib = 'serf'
version = self._get_serf_version()
if None in version:
msg = 'Unknown serf version found; but, will try to build ' \
'ra_serf.'
else:
self.serf_ver = '.'.join(str(v) for v in version)
if version < minimal_serf_version:
self.serf_lib = None
msg = 'Found serf %s, but >= %s is required. ra_serf will not be built.\n' % \
(self.serf_ver, '.'.join(str(v) for v in minimal_serf_version))
else:
msg = 'Found serf %s' % self.serf_ver
print(msg)
else:
print('openssl not found, ra_serf will not be built\n')
else:
print('serf not found, ra_serf will not be built\n')
def _find_apr(self):
"Find the APR library and version"
minimal_apr_version = (0, 9, 0)
version_file_path = os.path.join(self.apr_path, 'include',
'apr_version.h')
if not os.path.exists(version_file_path):
sys.stderr.write("ERROR: '%s' not found.\n" % version_file_path);
sys.stderr.write("Use '--with-apr' option to configure APR location.\n");
sys.exit(1)
fp = open(version_file_path)
txt = fp.read()
fp.close()
vermatch = re.search(r'^\s*#define\s+APR_MAJOR_VERSION\s+(\d+)', txt, re.M)
major = int(vermatch.group(1))
vermatch = re.search(r'^\s*#define\s+APR_MINOR_VERSION\s+(\d+)', txt, re.M)
minor = int(vermatch.group(1))
vermatch = re.search(r'^\s*#define\s+APR_PATCH_VERSION\s+(\d+)', txt, re.M)
patch = int(vermatch.group(1))
version = (major, minor, patch)
self.apr_version = '%d.%d.%d' % version
suffix = ''
if major > 0:
suffix = '-%d' % major
if self.static_apr:
self.apr_lib = 'apr%s.lib' % suffix
else:
self.apr_lib = 'libapr%s.lib' % suffix
if version < minimal_apr_version:
sys.stderr.write("ERROR: apr %s or higher is required "
"(%s found)\n" % (
'.'.join(str(v) for v in minimal_apr_version),
self.apr_version))
sys.exit(1)
else:
print('Found apr %s' % self.apr_version)
def _find_apr_util(self):
"Find the APR-util library and version"
minimal_aprutil_version = (0, 9, 0)
version_file_path = os.path.join(self.apr_util_path, 'include',
'apu_version.h')
if not os.path.exists(version_file_path):
sys.stderr.write("ERROR: '%s' not found.\n" % version_file_path);
sys.stderr.write("Use '--with-apr-util' option to configure APR-Util location.\n");
( run in 1.869 second using v1.01-cache-2.11-cpan-acf6aa7dc9e )