1dnl *********************************************** 2dnl * Please run autoreconf to test your changes! * 3dnl *********************************************** 4 5# Set VERSION so we only need to edit in one place (i.e., here) 6m4_define(PYTHON_VERSION, 3.8) 7 8AC_PREREQ([2.69]) 9 10AC_INIT([python],[PYTHON_VERSION],[https://bugs.python.org/]) 11 12AC_CONFIG_MACRO_DIR(m4) 13 14AC_SUBST(BASECPPFLAGS) 15if test "$srcdir" != . -a "$srcdir" != "$(pwd)"; then 16 # If we're building out-of-tree, we need to make sure the following 17 # resources get picked up before their $srcdir counterparts. 18 # Objects/ -> typeslots.inc 19 # Include/ -> Python-ast.h, graminit.h 20 # Python/ -> importlib.h 21 # (A side effect of this is that these resources will automatically be 22 # regenerated when building out-of-tree, regardless of whether or not 23 # the $srcdir counterpart is up-to-date. This is an acceptable trade 24 # off.) 25 BASECPPFLAGS="-IObjects -IInclude -IPython" 26else 27 BASECPPFLAGS="" 28fi 29 30AC_SUBST(GITVERSION) 31AC_SUBST(GITTAG) 32AC_SUBST(GITBRANCH) 33 34if test -e $srcdir/.git 35then 36AC_CHECK_PROG(HAS_GIT, git, found, not-found) 37else 38HAS_GIT=no-repository 39fi 40if test $HAS_GIT = found 41then 42 GITVERSION="git --git-dir \$(srcdir)/.git rev-parse --short HEAD" 43 GITTAG="git --git-dir \$(srcdir)/.git describe --all --always --dirty" 44 GITBRANCH="git --git-dir \$(srcdir)/.git name-rev --name-only HEAD" 45else 46 GITVERSION="" 47 GITTAG="" 48 GITBRANCH="" 49fi 50 51AC_CONFIG_SRCDIR([Include/object.h]) 52AC_CONFIG_HEADER(pyconfig.h) 53 54AC_CANONICAL_HOST 55AC_SUBST(build) 56AC_SUBST(host) 57 58# pybuilddir.txt will be created by --generate-posix-vars in the Makefile 59rm -f pybuilddir.txt 60 61AC_CHECK_PROGS(PYTHON_FOR_REGEN, python$PACKAGE_VERSION python3 python, python3) 62AC_SUBST(PYTHON_FOR_REGEN) 63 64if test "$cross_compiling" = yes; then 65 AC_MSG_CHECKING([for python interpreter for cross build]) 66 if test -z "$PYTHON_FOR_BUILD"; then 67 for interp in python$PACKAGE_VERSION python3 python; do 68 which $interp >/dev/null 2>&1 || continue 69 if $interp -c "import sys;sys.exit(not '.'.join(str(n) for n in sys.version_info@<:@:2@:>@) == '$PACKAGE_VERSION')"; then 70 break 71 fi 72 interp= 73 done 74 if test x$interp = x; then 75 AC_MSG_ERROR([python$PACKAGE_VERSION interpreter not found]) 76 fi 77 AC_MSG_RESULT($interp) 78 PYTHON_FOR_BUILD='_PYTHON_PROJECT_BASE=$(abs_builddir) _PYTHON_HOST_PLATFORM=$(_PYTHON_HOST_PLATFORM) PYTHONPATH=$(shell test -f pybuilddir.txt && echo $(abs_builddir)/`cat pybuilddir.txt`:)$(srcdir)/Lib _PYTHON_SYSCONFIGDATA_NAME=_sysconfigdata_$(ABIFLAGS)_$(MACHDEP)_$(MULTIARCH) '$interp 79 fi 80elif test "$cross_compiling" = maybe; then 81 AC_MSG_ERROR([Cross compiling required --host=HOST-TUPLE and --build=ARCH]) 82else 83 PYTHON_FOR_BUILD='./$(BUILDPYTHON) -E' 84fi 85AC_SUBST(PYTHON_FOR_BUILD) 86 87dnl Ensure that if prefix is specified, it does not end in a slash. If 88dnl it does, we get path names containing '//' which is both ugly and 89dnl can cause trouble. 90 91dnl Last slash shouldn't be stripped if prefix=/ 92if test "$prefix" != "/"; then 93 prefix=`echo "$prefix" | sed -e 's/\/$//g'` 94fi 95 96dnl This is for stuff that absolutely must end up in pyconfig.h. 97dnl Please use pyport.h instead, if possible. 98AH_TOP([ 99#ifndef Py_PYCONFIG_H 100#define Py_PYCONFIG_H 101]) 102AH_BOTTOM([ 103/* Define the macros needed if on a UnixWare 7.x system. */ 104#if defined(__USLC__) && defined(__SCO_VERSION__) 105#define STRICT_SYSV_CURSES /* Don't use ncurses extensions */ 106#endif 107 108#endif /*Py_PYCONFIG_H*/ 109]) 110 111# We don't use PACKAGE_ variables, and they cause conflicts 112# with other autoconf-based packages that include Python.h 113grep -v 'define PACKAGE_' <confdefs.h >confdefs.h.new 114rm confdefs.h 115mv confdefs.h.new confdefs.h 116 117AC_SUBST(VERSION) 118VERSION=PYTHON_VERSION 119 120# Version number of Python's own shared library file. 121AC_SUBST(SOVERSION) 122SOVERSION=1.0 123 124# The later defininition of _XOPEN_SOURCE disables certain features 125# on Linux, so we need _GNU_SOURCE to re-enable them (makedev, tm_zone). 126AC_DEFINE(_GNU_SOURCE, 1, [Define on Linux to activate all library features]) 127 128# The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables 129# certain features on NetBSD, so we need _NETBSD_SOURCE to re-enable 130# them. 131AC_DEFINE(_NETBSD_SOURCE, 1, [Define on NetBSD to activate all library features]) 132 133# The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables 134# certain features on FreeBSD, so we need __BSD_VISIBLE to re-enable 135# them. 136AC_DEFINE(__BSD_VISIBLE, 1, [Define on FreeBSD to activate all library features]) 137 138# The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables 139# certain features on Mac OS X, so we need _DARWIN_C_SOURCE to re-enable 140# them. 141AC_DEFINE(_DARWIN_C_SOURCE, 1, [Define on Darwin to activate all library features]) 142 143 144define_xopen_source=yes 145 146# Arguments passed to configure. 147AC_SUBST(CONFIG_ARGS) 148CONFIG_ARGS="$ac_configure_args" 149 150AC_MSG_CHECKING([for --enable-universalsdk]) 151AC_ARG_ENABLE(universalsdk, 152 AS_HELP_STRING([--enable-universalsdk@<:@=SDKDIR@:>@], [Build fat binary against Mac OS X SDK]), 153[ 154 case $enableval in 155 yes) 156 # Locate the best usable SDK, see Mac/README for more 157 # information 158 enableval="`/usr/bin/xcodebuild -version -sdk macosx Path 2>/dev/null`" 159 if ! ( echo $enableval | grep -E '\.sdk' 1>/dev/null ) 160 then 161 enableval=/Developer/SDKs/MacOSX10.4u.sdk 162 if test ! -d "${enableval}" 163 then 164 enableval=/ 165 fi 166 fi 167 ;; 168 esac 169 case $enableval in 170 no) 171 UNIVERSALSDK= 172 enable_universalsdk= 173 ;; 174 *) 175 UNIVERSALSDK=$enableval 176 if test ! -d "${UNIVERSALSDK}" 177 then 178 AC_MSG_ERROR([--enable-universalsdk specifies non-existing SDK: ${UNIVERSALSDK}]) 179 fi 180 ;; 181 esac 182 183],[ 184 UNIVERSALSDK= 185 enable_universalsdk= 186]) 187if test -n "${UNIVERSALSDK}" 188then 189 AC_MSG_RESULT(${UNIVERSALSDK}) 190else 191 AC_MSG_RESULT(no) 192fi 193AC_SUBST(UNIVERSALSDK) 194 195AC_SUBST(ARCH_RUN_32BIT) 196ARCH_RUN_32BIT="" 197 198# For backward compatibility reasons we prefer to select '32-bit' if available, 199# otherwise use 'intel' 200UNIVERSAL_ARCHS="32-bit" 201if test "`uname -s`" = "Darwin" 202then 203 if test -n "${UNIVERSALSDK}" 204 then 205 if test -z "`/usr/bin/file -L "${UNIVERSALSDK}/usr/lib/libSystem.dylib" | grep ppc`" 206 then 207 UNIVERSAL_ARCHS="intel" 208 fi 209 fi 210fi 211 212AC_SUBST(LIPO_32BIT_FLAGS) 213AC_MSG_CHECKING(for --with-universal-archs) 214AC_ARG_WITH(universal-archs, 215 AS_HELP_STRING([--with-universal-archs=ARCH], [select architectures for universal build ("32-bit", "64-bit", "3-way", "intel", "intel-32", "intel-64", or "all")]), 216[ 217 UNIVERSAL_ARCHS="$withval" 218], 219[]) 220if test -n "${UNIVERSALSDK}" 221then 222 AC_MSG_RESULT(${UNIVERSAL_ARCHS}) 223else 224 AC_MSG_RESULT(no) 225fi 226 227AC_ARG_WITH(framework-name, 228 AS_HELP_STRING([--with-framework-name=FRAMEWORK], 229 [specify an alternate name of the framework built with --enable-framework]), 230[ 231 PYTHONFRAMEWORK=${withval} 232 PYTHONFRAMEWORKDIR=${withval}.framework 233 PYTHONFRAMEWORKIDENTIFIER=org.python.`echo $withval | tr '[A-Z]' '[a-z]'` 234 ],[ 235 PYTHONFRAMEWORK=Python 236 PYTHONFRAMEWORKDIR=Python.framework 237 PYTHONFRAMEWORKIDENTIFIER=org.python.python 238]) 239dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output 240AC_ARG_ENABLE(framework, 241 AS_HELP_STRING([--enable-framework@<:@=INSTALLDIR@:>@], [Build (MacOSX|Darwin) framework]), 242[ 243 case $enableval in 244 yes) 245 enableval=/Library/Frameworks 246 esac 247 case $enableval in 248 no) 249 PYTHONFRAMEWORK= 250 PYTHONFRAMEWORKDIR=no-framework 251 PYTHONFRAMEWORKPREFIX= 252 PYTHONFRAMEWORKINSTALLDIR= 253 FRAMEWORKINSTALLFIRST= 254 FRAMEWORKINSTALLLAST= 255 FRAMEWORKALTINSTALLFIRST= 256 FRAMEWORKALTINSTALLLAST= 257 FRAMEWORKPYTHONW= 258 if test "x${prefix}" = "xNONE"; then 259 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}" 260 else 261 FRAMEWORKUNIXTOOLSPREFIX="${prefix}" 262 fi 263 enable_framework= 264 ;; 265 *) 266 PYTHONFRAMEWORKPREFIX="${enableval}" 267 PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR 268 FRAMEWORKINSTALLFIRST="frameworkinstallstructure" 269 FRAMEWORKALTINSTALLFIRST="frameworkinstallstructure " 270 FRAMEWORKINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkinstallunixtools" 271 FRAMEWORKALTINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkaltinstallunixtools" 272 FRAMEWORKPYTHONW="frameworkpythonw" 273 FRAMEWORKINSTALLAPPSPREFIX="/Applications" 274 275 if test "x${prefix}" = "xNONE" ; then 276 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}" 277 278 else 279 FRAMEWORKUNIXTOOLSPREFIX="${prefix}" 280 fi 281 282 case "${enableval}" in 283 /System*) 284 FRAMEWORKINSTALLAPPSPREFIX="/Applications" 285 if test "${prefix}" = "NONE" ; then 286 # See below 287 FRAMEWORKUNIXTOOLSPREFIX="/usr" 288 fi 289 ;; 290 291 /Library*) 292 FRAMEWORKINSTALLAPPSPREFIX="/Applications" 293 ;; 294 295 */Library/Frameworks) 296 MDIR="`dirname "${enableval}"`" 297 MDIR="`dirname "${MDIR}"`" 298 FRAMEWORKINSTALLAPPSPREFIX="${MDIR}/Applications" 299 300 if test "${prefix}" = "NONE"; then 301 # User hasn't specified the 302 # --prefix option, but wants to install 303 # the framework in a non-default location, 304 # ensure that the compatibility links get 305 # installed relative to that prefix as well 306 # instead of in /usr/local. 307 FRAMEWORKUNIXTOOLSPREFIX="${MDIR}" 308 fi 309 ;; 310 311 *) 312 FRAMEWORKINSTALLAPPSPREFIX="/Applications" 313 ;; 314 esac 315 316 prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION 317 318 # Add files for Mac specific code to the list of output 319 # files: 320 AC_CONFIG_FILES(Mac/Makefile) 321 AC_CONFIG_FILES(Mac/PythonLauncher/Makefile) 322 AC_CONFIG_FILES(Mac/Resources/framework/Info.plist) 323 AC_CONFIG_FILES(Mac/Resources/app/Info.plist) 324 esac 325 ],[ 326 PYTHONFRAMEWORK= 327 PYTHONFRAMEWORKDIR=no-framework 328 PYTHONFRAMEWORKPREFIX= 329 PYTHONFRAMEWORKINSTALLDIR= 330 FRAMEWORKINSTALLFIRST= 331 FRAMEWORKINSTALLLAST= 332 FRAMEWORKALTINSTALLFIRST= 333 FRAMEWORKALTINSTALLLAST= 334 FRAMEWORKPYTHONW= 335 if test "x${prefix}" = "xNONE" ; then 336 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}" 337 else 338 FRAMEWORKUNIXTOOLSPREFIX="${prefix}" 339 fi 340 enable_framework= 341 342]) 343AC_SUBST(PYTHONFRAMEWORK) 344AC_SUBST(PYTHONFRAMEWORKIDENTIFIER) 345AC_SUBST(PYTHONFRAMEWORKDIR) 346AC_SUBST(PYTHONFRAMEWORKPREFIX) 347AC_SUBST(PYTHONFRAMEWORKINSTALLDIR) 348AC_SUBST(FRAMEWORKINSTALLFIRST) 349AC_SUBST(FRAMEWORKINSTALLLAST) 350AC_SUBST(FRAMEWORKALTINSTALLFIRST) 351AC_SUBST(FRAMEWORKALTINSTALLLAST) 352AC_SUBST(FRAMEWORKPYTHONW) 353AC_SUBST(FRAMEWORKUNIXTOOLSPREFIX) 354AC_SUBST(FRAMEWORKINSTALLAPPSPREFIX) 355 356AC_DEFINE_UNQUOTED(_PYTHONFRAMEWORK, "${PYTHONFRAMEWORK}", [framework name]) 357 358##AC_ARG_WITH(dyld, 359## AS_HELP_STRING([--with-dyld], 360## [Use (OpenStep|Rhapsody) dynamic linker])) 361## 362# Set name for machine-dependent library files 363AC_ARG_VAR([MACHDEP], [name for machine-dependent library files]) 364AC_MSG_CHECKING(MACHDEP) 365if test -z "$MACHDEP" 366then 367 # avoid using uname for cross builds 368 if test "$cross_compiling" = yes; then 369 # ac_sys_system and ac_sys_release are used for setting 370 # a lot of different things including 'define_xopen_source' 371 # in the case statement below. 372 case "$host" in 373 *-*-linux-android*) 374 ac_sys_system=Linux-android 375 ;; 376 *-*-linux*) 377 ac_sys_system=Linux 378 ;; 379 *-*-cygwin*) 380 ac_sys_system=Cygwin 381 ;; 382 *-*-vxworks*) 383 ac_sys_system=VxWorks 384 ;; 385 *) 386 # for now, limit cross builds to known configurations 387 MACHDEP="unknown" 388 AC_MSG_ERROR([cross build not supported for $host]) 389 esac 390 ac_sys_release= 391 else 392 ac_sys_system=`uname -s` 393 if test "$ac_sys_system" = "AIX" \ 394 -o "$ac_sys_system" = "UnixWare" -o "$ac_sys_system" = "OpenUNIX"; then 395 ac_sys_release=`uname -v` 396 else 397 ac_sys_release=`uname -r` 398 fi 399 fi 400 ac_md_system=`echo $ac_sys_system | 401 tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'` 402 ac_md_release=`echo $ac_sys_release | 403 tr -d '[/ ]' | sed 's/^[[A-Z]]\.//' | sed 's/\..*//'` 404 MACHDEP="$ac_md_system$ac_md_release" 405 406 case $MACHDEP in 407 aix*) MACHDEP="aix";; 408 linux*) MACHDEP="linux";; 409 cygwin*) MACHDEP="cygwin";; 410 darwin*) MACHDEP="darwin";; 411 '') MACHDEP="unknown";; 412 esac 413fi 414AC_MSG_RESULT("$MACHDEP") 415 416AC_SUBST(_PYTHON_HOST_PLATFORM) 417if test "$cross_compiling" = yes; then 418 case "$host" in 419 *-*-linux*) 420 case "$host_cpu" in 421 arm*) 422 _host_cpu=arm 423 ;; 424 *) 425 _host_cpu=$host_cpu 426 esac 427 ;; 428 *-*-cygwin*) 429 _host_cpu= 430 ;; 431 *-*-vxworks*) 432 _host_cpu=$host_cpu 433 ;; 434 *) 435 # for now, limit cross builds to known configurations 436 MACHDEP="unknown" 437 AC_MSG_ERROR([cross build not supported for $host]) 438 esac 439 _PYTHON_HOST_PLATFORM="$MACHDEP${_host_cpu:+-$_host_cpu}" 440fi 441 442# Some systems cannot stand _XOPEN_SOURCE being defined at all; they 443# disable features if it is defined, without any means to access these 444# features as extensions. For these systems, we skip the definition of 445# _XOPEN_SOURCE. Before adding a system to the list to gain access to 446# some feature, make sure there is no alternative way to access this 447# feature. Also, when using wildcards, make sure you have verified the 448# need for not defining _XOPEN_SOURCE on all systems matching the 449# wildcard, and that the wildcard does not include future systems 450# (which may remove their limitations). 451dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output 452case $ac_sys_system/$ac_sys_release in 453 # On OpenBSD, select(2) is not available if _XOPEN_SOURCE is defined, 454 # even though select is a POSIX function. Reported by J. Ribbens. 455 # Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish. 456 # In addition, Stefan Krah confirms that issue #1244610 exists through 457 # OpenBSD 4.6, but is fixed in 4.7. 458 OpenBSD/2.* | OpenBSD/3.* | OpenBSD/4.@<:@0123456@:>@) 459 define_xopen_source=no 460 # OpenBSD undoes our definition of __BSD_VISIBLE if _XOPEN_SOURCE is 461 # also defined. This can be overridden by defining _BSD_SOURCE 462 # As this has a different meaning on Linux, only define it on OpenBSD 463 AC_DEFINE(_BSD_SOURCE, 1, [Define on OpenBSD to activate all library features]) 464 ;; 465 OpenBSD/*) 466 # OpenBSD undoes our definition of __BSD_VISIBLE if _XOPEN_SOURCE is 467 # also defined. This can be overridden by defining _BSD_SOURCE 468 # As this has a different meaning on Linux, only define it on OpenBSD 469 AC_DEFINE(_BSD_SOURCE, 1, [Define on OpenBSD to activate all library features]) 470 ;; 471 # Defining _XOPEN_SOURCE on NetBSD version prior to the introduction of 472 # _NETBSD_SOURCE disables certain features (eg. setgroups). Reported by 473 # Marc Recht 474 NetBSD/1.5 | NetBSD/1.5.* | NetBSD/1.6 | NetBSD/1.6.* | NetBSD/1.6@<:@A-S@:>@) 475 define_xopen_source=no;; 476 # From the perspective of Solaris, _XOPEN_SOURCE is not so much a 477 # request to enable features supported by the standard as a request 478 # to disable features not supported by the standard. The best way 479 # for Python to use Solaris is simply to leave _XOPEN_SOURCE out 480 # entirely and define __EXTENSIONS__ instead. 481 SunOS/*) 482 define_xopen_source=no;; 483 # On UnixWare 7, u_long is never defined with _XOPEN_SOURCE, 484 # but used in /usr/include/netinet/tcp.h. Reported by Tim Rice. 485 # Reconfirmed for 7.1.4 by Martin v. Loewis. 486 OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@) 487 define_xopen_source=no;; 488 # On OpenServer 5, u_short is never defined with _XOPEN_SOURCE, 489 # but used in struct sockaddr.sa_family. Reported by Tim Rice. 490 SCO_SV/3.2) 491 define_xopen_source=no;; 492 # On MacOS X 10.2, a bug in ncurses.h means that it craps out if 493 # _XOPEN_EXTENDED_SOURCE is defined. Apparently, this is fixed in 10.3, which 494 # identifies itself as Darwin/7.* 495 # On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE 496 # disables platform specific features beyond repair. 497 # On Mac OS X 10.3, defining _POSIX_C_SOURCE or _XOPEN_SOURCE 498 # has no effect, don't bother defining them 499 Darwin/@<:@6789@:>@.*) 500 define_xopen_source=no;; 501 Darwin/1@<:@0-9@:>@.*) 502 define_xopen_source=no;; 503 # On AIX 4 and 5.1, mbstate_t is defined only when _XOPEN_SOURCE == 500 but 504 # used in wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined 505 # or has another value. By not (re)defining it, the defaults come in place. 506 AIX/4) 507 define_xopen_source=no;; 508 AIX/5) 509 if test `uname -r` -eq 1; then 510 define_xopen_source=no 511 fi 512 ;; 513 # On QNX 6.3.2, defining _XOPEN_SOURCE prevents netdb.h from 514 # defining NI_NUMERICHOST. 515 QNX/6.3.2) 516 define_xopen_source=no 517 ;; 518 # On VxWorks, defining _XOPEN_SOURCE causes compile failures 519 # in network headers still using system V types. 520 VxWorks/*) 521 define_xopen_source=no 522 ;; 523 524esac 525 526if test $define_xopen_source = yes 527then 528 # X/Open 7, incorporating POSIX.1-2008 529 AC_DEFINE(_XOPEN_SOURCE, 700, 530 Define to the level of X/Open that your system supports) 531 532 # On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires 533 # definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else 534 # several APIs are not declared. Since this is also needed in some 535 # cases for HP-UX, we define it globally. 536 AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1, 537 Define to activate Unix95-and-earlier features) 538 539 AC_DEFINE(_POSIX_C_SOURCE, 200809L, Define to activate features from IEEE Stds 1003.1-2008) 540fi 541 542# On HP-UX mbstate_t requires _INCLUDE__STDC_A1_SOURCE 543case $ac_sys_system in 544 hp*|HP*) 545 define_stdc_a1=yes;; 546 *) 547 define_stdc_a1=no;; 548esac 549 550if test $define_stdc_a1 = yes 551then 552 AC_DEFINE(_INCLUDE__STDC_A1_SOURCE, 1, Define to include mbstate_t for mbrtowc) 553fi 554 555# Record the configure-time value of MACOSX_DEPLOYMENT_TARGET, 556# it may influence the way we can build extensions, so distutils 557# needs to check it 558AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET) 559AC_SUBST(EXPORT_MACOSX_DEPLOYMENT_TARGET) 560CONFIGURE_MACOSX_DEPLOYMENT_TARGET= 561EXPORT_MACOSX_DEPLOYMENT_TARGET='#' 562 563# checks for alternative programs 564 565# compiler flags are generated in two sets, BASECFLAGS and OPT. OPT is just 566# for debug/optimization stuff. BASECFLAGS is for flags that are required 567# just to get things to compile and link. Users are free to override OPT 568# when running configure or make. The build should not break if they do. 569# BASECFLAGS should generally not be messed with, however. 570 571# If the user switches compilers, we can't believe the cache 572if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC" 573then 574 AC_MSG_ERROR([cached CC is different -- throw away $cache_file 575(it is also a good idea to do 'make clean' before compiling)]) 576fi 577 578# Don't let AC_PROG_CC set the default CFLAGS. It normally sets -g -O2 579# when the compiler supports them, but we don't always want -O2, and 580# we set -g later. 581if test -z "$CFLAGS"; then 582 CFLAGS= 583fi 584 585if test "$ac_sys_system" = "Darwin" 586then 587 # Compiler selection on MacOSX is more complicated than 588 # AC_PROG_CC can handle, see Mac/README for more 589 # information 590 if test -z "${CC}" 591 then 592 found_gcc= 593 found_clang= 594 as_save_IFS=$IFS; IFS=: 595 for as_dir in $PATH 596 do 597 IFS=$as_save_IFS 598 if test -x "${as_dir}/gcc"; then 599 if test -z "${found_gcc}"; then 600 found_gcc="${as_dir}/gcc" 601 fi 602 fi 603 if test -x "${as_dir}/clang"; then 604 if test -z "${found_clang}"; then 605 found_clang="${as_dir}/clang" 606 fi 607 fi 608 done 609 IFS=$as_save_IFS 610 611 if test -n "$found_gcc" -a -n "$found_clang" 612 then 613 if test -n "`"$found_gcc" --version | grep llvm-gcc`" 614 then 615 AC_MSG_NOTICE([Detected llvm-gcc, falling back to clang]) 616 CC="$found_clang" 617 CXX="$found_clang++" 618 fi 619 620 621 elif test -z "$found_gcc" -a -n "$found_clang" 622 then 623 AC_MSG_NOTICE([No GCC found, use CLANG]) 624 CC="$found_clang" 625 CXX="$found_clang++" 626 627 elif test -z "$found_gcc" -a -z "$found_clang" 628 then 629 found_clang=`/usr/bin/xcrun -find clang 2>/dev/null` 630 if test -n "${found_clang}" 631 then 632 AC_MSG_NOTICE([Using clang from Xcode.app]) 633 CC="${found_clang}" 634 CXX="`/usr/bin/xcrun -find clang++`" 635 636 # else: use default behaviour 637 fi 638 fi 639 fi 640fi 641AC_PROG_CC 642AC_PROG_CPP 643AC_PROG_GREP 644AC_PROG_SED 645 646AC_SUBST(CXX) 647AC_SUBST(MAINCC) 648AC_MSG_CHECKING(for --with-cxx-main=<compiler>) 649AC_ARG_WITH(cxx_main, 650 AS_HELP_STRING([--with-cxx-main=<compiler>], 651 [compile main() and link python executable with C++ compiler]), 652[ 653 654 case $withval in 655 no) with_cxx_main=no 656 MAINCC='$(CC)';; 657 yes) with_cxx_main=yes 658 MAINCC='$(CXX)';; 659 *) with_cxx_main=yes 660 MAINCC=$withval 661 if test -z "$CXX" 662 then 663 CXX=$withval 664 fi;; 665 esac], [ 666 with_cxx_main=no 667 MAINCC='$(CC)' 668]) 669AC_MSG_RESULT($with_cxx_main) 670 671preset_cxx="$CXX" 672if test -z "$CXX" 673then 674 case "$CC" in 675 gcc) AC_PATH_TOOL(CXX, [g++], [g++], [notfound]) ;; 676 cc) AC_PATH_TOOL(CXX, [c++], [c++], [notfound]) ;; 677 clang|*/clang) AC_PATH_TOOL(CXX, [clang++], [clang++], [notfound]) ;; 678 icc|*/icc) AC_PATH_TOOL(CXX, [icpc], [icpc], [notfound]) ;; 679 esac 680 if test "$CXX" = "notfound" 681 then 682 CXX="" 683 fi 684fi 685if test -z "$CXX" 686then 687 AC_CHECK_TOOLS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound) 688 if test "$CXX" = "notfound" 689 then 690 CXX="" 691 fi 692fi 693if test "$preset_cxx" != "$CXX" 694then 695 AC_MSG_NOTICE([ 696 697 By default, distutils will build C++ extension modules with "$CXX". 698 If this is not intended, then set CXX on the configure command line. 699 ]) 700fi 701 702 703MULTIARCH=$($CC --print-multiarch 2>/dev/null) 704AC_SUBST(MULTIARCH) 705 706AC_MSG_CHECKING([for the platform triplet based on compiler characteristics]) 707cat >> conftest.c <<EOF 708#undef bfin 709#undef cris 710#undef fr30 711#undef linux 712#undef hppa 713#undef hpux 714#undef i386 715#undef mips 716#undef powerpc 717#undef sparc 718#undef unix 719#if defined(__ANDROID__) 720 # Android is not a multiarch system. 721#elif defined(__linux__) 722# if defined(__x86_64__) && defined(__LP64__) 723 x86_64-linux-gnu 724# elif defined(__x86_64__) && defined(__ILP32__) 725 x86_64-linux-gnux32 726# elif defined(__i386__) 727 i386-linux-gnu 728# elif defined(__aarch64__) && defined(__AARCH64EL__) 729# if defined(__ILP32__) 730 aarch64_ilp32-linux-gnu 731# else 732 aarch64-linux-gnu 733# endif 734# elif defined(__aarch64__) && defined(__AARCH64EB__) 735# if defined(__ILP32__) 736 aarch64_be_ilp32-linux-gnu 737# else 738 aarch64_be-linux-gnu 739# endif 740# elif defined(__alpha__) 741 alpha-linux-gnu 742# elif defined(__ARM_EABI__) && defined(__ARM_PCS_VFP) 743# if defined(__ARMEL__) 744 arm-linux-gnueabihf 745# else 746 armeb-linux-gnueabihf 747# endif 748# elif defined(__ARM_EABI__) && !defined(__ARM_PCS_VFP) 749# if defined(__ARMEL__) 750 arm-linux-gnueabi 751# else 752 armeb-linux-gnueabi 753# endif 754# elif defined(__hppa__) 755 hppa-linux-gnu 756# elif defined(__ia64__) 757 ia64-linux-gnu 758# elif defined(__m68k__) && !defined(__mcoldfire__) 759 m68k-linux-gnu 760# elif defined(__mips_hard_float) && defined(__mips_isa_rev) && (__mips_isa_rev >=6) && defined(_MIPSEL) 761# if _MIPS_SIM == _ABIO32 762 mipsisa32r6el-linux-gnu 763# elif _MIPS_SIM == _ABIN32 764 mipsisa64r6el-linux-gnuabin32 765# elif _MIPS_SIM == _ABI64 766 mipsisa64r6el-linux-gnuabi64 767# else 768# error unknown platform triplet 769# endif 770# elif defined(__mips_hard_float) && defined(__mips_isa_rev) && (__mips_isa_rev >=6) 771# if _MIPS_SIM == _ABIO32 772 mipsisa32r6-linux-gnu 773# elif _MIPS_SIM == _ABIN32 774 mipsisa64r6-linux-gnuabin32 775# elif _MIPS_SIM == _ABI64 776 mipsisa64r6-linux-gnuabi64 777# else 778# error unknown platform triplet 779# endif 780# elif defined(__mips_hard_float) && defined(_MIPSEL) 781# if _MIPS_SIM == _ABIO32 782 mipsel-linux-gnu 783# elif _MIPS_SIM == _ABIN32 784 mips64el-linux-gnuabin32 785# elif _MIPS_SIM == _ABI64 786 mips64el-linux-gnuabi64 787# else 788# error unknown platform triplet 789# endif 790# elif defined(__mips_hard_float) 791# if _MIPS_SIM == _ABIO32 792 mips-linux-gnu 793# elif _MIPS_SIM == _ABIN32 794 mips64-linux-gnuabin32 795# elif _MIPS_SIM == _ABI64 796 mips64-linux-gnuabi64 797# else 798# error unknown platform triplet 799# endif 800# elif defined(__or1k__) 801 or1k-linux-gnu 802# elif defined(__powerpc__) && defined(__SPE__) 803 powerpc-linux-gnuspe 804# elif defined(__powerpc64__) 805# if defined(__LITTLE_ENDIAN__) 806 powerpc64le-linux-gnu 807# else 808 powerpc64-linux-gnu 809# endif 810# elif defined(__powerpc__) 811 powerpc-linux-gnu 812# elif defined(__s390x__) 813 s390x-linux-gnu 814# elif defined(__s390__) 815 s390-linux-gnu 816# elif defined(__sh__) && defined(__LITTLE_ENDIAN__) 817 sh4-linux-gnu 818# elif defined(__sparc__) && defined(__arch64__) 819 sparc64-linux-gnu 820# elif defined(__sparc__) 821 sparc-linux-gnu 822# elif defined(__riscv) 823# if __riscv_xlen == 32 824 riscv32-linux-gnu 825# elif __riscv_xlen == 64 826 riscv64-linux-gnu 827# else 828# error unknown platform triplet 829# endif 830# else 831# error unknown platform triplet 832# endif 833#elif defined(__FreeBSD_kernel__) 834# if defined(__LP64__) 835 x86_64-kfreebsd-gnu 836# elif defined(__i386__) 837 i386-kfreebsd-gnu 838# else 839# error unknown platform triplet 840# endif 841#elif defined(__gnu_hurd__) 842 i386-gnu 843#elif defined(__APPLE__) 844 darwin 845#elif defined(__VXWORKS__) 846 vxworks 847#else 848# error unknown platform triplet 849#endif 850 851EOF 852 853if $CPP $CPPFLAGS conftest.c >conftest.out 2>/dev/null; then 854 PLATFORM_TRIPLET=`grep -v '^#' conftest.out | grep -v '^ *$' | tr -d ' '` 855 AC_MSG_RESULT([$PLATFORM_TRIPLET]) 856else 857 AC_MSG_RESULT([none]) 858fi 859rm -f conftest.c conftest.out 860 861if test x$PLATFORM_TRIPLET != x && test x$MULTIARCH != x; then 862 if test x$PLATFORM_TRIPLET != x$MULTIARCH; then 863 AC_MSG_ERROR([internal configure error for the platform triplet, please file a bug report]) 864 fi 865elif test x$PLATFORM_TRIPLET != x && test x$MULTIARCH = x; then 866 MULTIARCH=$PLATFORM_TRIPLET 867fi 868AC_SUBST(PLATFORM_TRIPLET) 869if test x$MULTIARCH != x; then 870 MULTIARCH_CPPFLAGS="-DMULTIARCH=\\\"$MULTIARCH\\\"" 871fi 872AC_SUBST(MULTIARCH_CPPFLAGS) 873 874AC_MSG_CHECKING([for -Wl,--no-as-needed]) 875save_LDFLAGS="$LDFLAGS" 876LDFLAGS="$LDFLAGS -Wl,--no-as-needed" 877AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[]])], 878 [NO_AS_NEEDED="-Wl,--no-as-needed" 879 AC_MSG_RESULT([yes])], 880 [NO_AS_NEEDED="" 881 AC_MSG_RESULT([no])]) 882LDFLAGS="$save_LDFLAGS" 883AC_SUBST(NO_AS_NEEDED) 884 885 886# checks for UNIX variants that set C preprocessor variables 887AC_USE_SYSTEM_EXTENSIONS 888 889AC_MSG_CHECKING([for the Android API level]) 890cat >> conftest.c <<EOF 891#ifdef __ANDROID__ 892android_api = __ANDROID_API__ 893arm_arch = __ARM_ARCH 894#else 895#error not Android 896#endif 897EOF 898 899if $CPP $CPPFLAGS conftest.c >conftest.out 2>/dev/null; then 900 ANDROID_API_LEVEL=`sed -n -e '/__ANDROID_API__/d' -e 's/^android_api = //p' conftest.out` 901 _arm_arch=`sed -n -e '/__ARM_ARCH/d' -e 's/^arm_arch = //p' conftest.out` 902 AC_MSG_RESULT([$ANDROID_API_LEVEL]) 903 if test -z "$ANDROID_API_LEVEL"; then 904 echo 'Fatal: you must define __ANDROID_API__' 905 exit 1 906 fi 907 AC_DEFINE_UNQUOTED(ANDROID_API_LEVEL, $ANDROID_API_LEVEL, [The Android API level.]) 908 909 AC_MSG_CHECKING([for the Android arm ABI]) 910 AC_MSG_RESULT([$_arm_arch]) 911 if test "$_arm_arch" = 7; then 912 BASECFLAGS="${BASECFLAGS} -mfloat-abi=softfp -mfpu=vfpv3-d16" 913 LDFLAGS="${LDFLAGS} -march=armv7-a -Wl,--fix-cortex-a8" 914 fi 915else 916 AC_MSG_RESULT([not Android]) 917fi 918rm -f conftest.c conftest.out 919 920# Check for unsupported systems 921case $ac_sys_system/$ac_sys_release in 922atheos*|Linux*/1*) 923 echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported. 924 echo See README for details. 925 exit 1;; 926esac 927 928AC_EXEEXT 929AC_MSG_CHECKING(for --with-suffix) 930AC_ARG_WITH(suffix, 931 AS_HELP_STRING([--with-suffix=.exe], [set executable suffix]), 932[ 933 case $withval in 934 no) EXEEXT=;; 935 yes) EXEEXT=.exe;; 936 *) EXEEXT=$withval;; 937 esac]) 938AC_MSG_RESULT($EXEEXT) 939 940# Test whether we're running on a non-case-sensitive system, in which 941# case we give a warning if no ext is given 942AC_SUBST(BUILDEXEEXT) 943AC_MSG_CHECKING(for case-insensitive build directory) 944if test ! -d CaseSensitiveTestDir; then 945mkdir CaseSensitiveTestDir 946fi 947 948if test -d casesensitivetestdir 949then 950 AC_MSG_RESULT(yes) 951 BUILDEXEEXT=.exe 952else 953 AC_MSG_RESULT(no) 954 BUILDEXEEXT=$EXEEXT 955fi 956rmdir CaseSensitiveTestDir 957 958case $ac_sys_system in 959hp*|HP*) 960 case $CC in 961 cc|*/cc) CC="$CC -Ae";; 962 esac;; 963esac 964 965AC_SUBST(LIBRARY) 966AC_MSG_CHECKING(LIBRARY) 967if test -z "$LIBRARY" 968then 969 LIBRARY='libpython$(VERSION)$(ABIFLAGS).a' 970fi 971AC_MSG_RESULT($LIBRARY) 972 973# LDLIBRARY is the name of the library to link against (as opposed to the 974# name of the library into which to insert object files). BLDLIBRARY is also 975# the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY 976# is blank as the main program is not linked directly against LDLIBRARY. 977# LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On 978# systems without shared libraries, LDLIBRARY is the same as LIBRARY 979# (defined in the Makefiles). On Cygwin LDLIBRARY is the import library, 980# DLLLIBRARY is the shared (i.e., DLL) library. 981# 982# RUNSHARED is used to run shared python without installed libraries 983# 984# INSTSONAME is the name of the shared library that will be use to install 985# on the system - some systems like version suffix, others don't 986# 987# LDVERSION is the shared library version number, normally the Python version 988# with the ABI build flags appended. 989AC_SUBST(LDLIBRARY) 990AC_SUBST(DLLLIBRARY) 991AC_SUBST(BLDLIBRARY) 992AC_SUBST(PY3LIBRARY) 993AC_SUBST(LDLIBRARYDIR) 994AC_SUBST(INSTSONAME) 995AC_SUBST(RUNSHARED) 996AC_SUBST(LDVERSION) 997LDLIBRARY="$LIBRARY" 998BLDLIBRARY='$(LDLIBRARY)' 999INSTSONAME='$(LDLIBRARY)' 1000DLLLIBRARY='' 1001LDLIBRARYDIR='' 1002RUNSHARED='' 1003LDVERSION="$VERSION" 1004 1005# LINKCC is the command that links the python executable -- default is $(CC). 1006# If CXX is set, and if it is needed to link a main function that was 1007# compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable: 1008# python might then depend on the C++ runtime 1009# This is altered for AIX in order to build the export list before 1010# linking. 1011AC_SUBST(LINKCC) 1012AC_MSG_CHECKING(LINKCC) 1013if test -z "$LINKCC" 1014then 1015 LINKCC='$(PURIFY) $(MAINCC)' 1016 case $ac_sys_system in 1017 AIX*) 1018 exp_extra="\"\"" 1019 if test $ac_sys_release -ge 5 -o \ 1020 $ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then 1021 exp_extra="." 1022 fi 1023 LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";; 1024 QNX*) 1025 # qcc must be used because the other compilers do not 1026 # support -N. 1027 LINKCC=qcc;; 1028 esac 1029fi 1030AC_MSG_RESULT($LINKCC) 1031 1032# GNULD is set to "yes" if the GNU linker is used. If this goes wrong 1033# make sure we default having it set to "no": this is used by 1034# distutils.unixccompiler to know if it should add --enable-new-dtags 1035# to linker command lines, and failing to detect GNU ld simply results 1036# in the same bahaviour as before. 1037AC_SUBST(GNULD) 1038AC_MSG_CHECKING(for GNU ld) 1039ac_prog=ld 1040if test "$GCC" = yes; then 1041 ac_prog=`$CC -print-prog-name=ld` 1042fi 1043case `"$ac_prog" -V 2>&1 < /dev/null` in 1044 *GNU*) 1045 GNULD=yes;; 1046 *) 1047 GNULD=no;; 1048esac 1049AC_MSG_RESULT($GNULD) 1050 1051AC_MSG_CHECKING(for --enable-shared) 1052AC_ARG_ENABLE(shared, 1053 AS_HELP_STRING([--enable-shared], [disable/enable building shared python library])) 1054 1055if test -z "$enable_shared" 1056then 1057 case $ac_sys_system in 1058 CYGWIN*) 1059 enable_shared="yes";; 1060 *) 1061 enable_shared="no";; 1062 esac 1063fi 1064AC_MSG_RESULT($enable_shared) 1065 1066AC_MSG_CHECKING(for --enable-profiling) 1067AC_ARG_ENABLE(profiling, 1068 AS_HELP_STRING([--enable-profiling], [enable C-level code profiling])) 1069if test "x$enable_profiling" = xyes; then 1070 ac_save_cc="$CC" 1071 CC="$CC -pg" 1072 AC_LINK_IFELSE([AC_LANG_SOURCE([[int main() { return 0; }]])], 1073 [], 1074 [enable_profiling=no]) 1075 CC="$ac_save_cc" 1076else 1077 enable_profiling=no 1078fi 1079AC_MSG_RESULT($enable_profiling) 1080 1081if test "x$enable_profiling" = xyes; then 1082 BASECFLAGS="-pg $BASECFLAGS" 1083 LDFLAGS="-pg $LDFLAGS" 1084fi 1085 1086AC_MSG_CHECKING(LDLIBRARY) 1087 1088# MacOSX framework builds need more magic. LDLIBRARY is the dynamic 1089# library that we build, but we do not want to link against it (we 1090# will find it with a -framework option). For this reason there is an 1091# extra variable BLDLIBRARY against which Python and the extension 1092# modules are linked, BLDLIBRARY. This is normally the same as 1093# LDLIBRARY, but empty for MacOSX framework builds. 1094if test "$enable_framework" 1095then 1096 LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)' 1097 RUNSHARED=DYLD_FRAMEWORK_PATH=`pwd`${DYLD_FRAMEWORK_PATH:+:${DYLD_FRAMEWORK_PATH}} 1098 BLDLIBRARY='' 1099else 1100 BLDLIBRARY='$(LDLIBRARY)' 1101fi 1102 1103# Other platforms follow 1104if test $enable_shared = "yes"; then 1105 PY_ENABLE_SHARED=1 1106 AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.]) 1107 case $ac_sys_system in 1108 CYGWIN*) 1109 LDLIBRARY='libpython$(LDVERSION).dll.a' 1110 DLLLIBRARY='libpython$(LDVERSION).dll' 1111 ;; 1112 SunOS*) 1113 LDLIBRARY='libpython$(LDVERSION).so' 1114 BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(LDVERSION)' 1115 RUNSHARED=LD_LIBRARY_PATH=`pwd`${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}} 1116 INSTSONAME="$LDLIBRARY".$SOVERSION 1117 if test "$with_pydebug" != yes 1118 then 1119 PY3LIBRARY=libpython3.so 1120 fi 1121 ;; 1122 Linux*|GNU*|NetBSD*|FreeBSD*|DragonFly*|OpenBSD*) 1123 LDLIBRARY='libpython$(LDVERSION).so' 1124 BLDLIBRARY='-L. -lpython$(LDVERSION)' 1125 RUNSHARED=LD_LIBRARY_PATH=`pwd`${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}} 1126 INSTSONAME="$LDLIBRARY".$SOVERSION 1127 if test "$with_pydebug" != yes 1128 then 1129 PY3LIBRARY=libpython3.so 1130 fi 1131 ;; 1132 hp*|HP*) 1133 case `uname -m` in 1134 ia64) 1135 LDLIBRARY='libpython$(LDVERSION).so' 1136 ;; 1137 *) 1138 LDLIBRARY='libpython$(LDVERSION).sl' 1139 ;; 1140 esac 1141 BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(LDVERSION)' 1142 RUNSHARED=SHLIB_PATH=`pwd`${SHLIB_PATH:+:${SHLIB_PATH}} 1143 ;; 1144 Darwin*) 1145 LDLIBRARY='libpython$(LDVERSION).dylib' 1146 BLDLIBRARY='-L. -lpython$(LDVERSION)' 1147 RUNSHARED=DYLD_LIBRARY_PATH=`pwd`${DYLD_LIBRARY_PATH:+:${DYLD_LIBRARY_PATH}} 1148 ;; 1149 AIX*) 1150 LDLIBRARY='libpython$(LDVERSION).so' 1151 RUNSHARED=LIBPATH=`pwd`${LIBPATH:+:${LIBPATH}} 1152 ;; 1153 1154 esac 1155else # shared is disabled 1156 PY_ENABLE_SHARED=0 1157 case $ac_sys_system in 1158 CYGWIN*) 1159 BLDLIBRARY='$(LIBRARY)' 1160 LDLIBRARY='libpython$(LDVERSION).dll.a' 1161 ;; 1162 esac 1163fi 1164 1165if test "$cross_compiling" = yes; then 1166 RUNSHARED= 1167fi 1168 1169AC_MSG_RESULT($LDLIBRARY) 1170 1171AC_SUBST(AR) 1172AC_CHECK_TOOLS(AR, ar aal, ar) 1173 1174# tweak ARFLAGS only if the user didn't set it on the command line 1175AC_SUBST(ARFLAGS) 1176if test -z "$ARFLAGS" 1177then 1178 ARFLAGS="rcs" 1179fi 1180 1181AC_CHECK_TOOLS([READELF], [readelf], [:]) 1182if test "$cross_compiling" = yes; then 1183 case "$READELF" in 1184 readelf|:) 1185 AC_MSG_ERROR([readelf for the host is required for cross builds]) 1186 ;; 1187 esac 1188fi 1189AC_SUBST(READELF) 1190 1191 1192case $MACHDEP in 1193hp*|HP*) 1194 # install -d does not work on HP-UX 1195 if test -z "$INSTALL" 1196 then 1197 INSTALL="${srcdir}/install-sh -c" 1198 fi 1199esac 1200AC_PROG_INSTALL 1201AC_PROG_MKDIR_P 1202 1203# Not every filesystem supports hard links 1204AC_SUBST(LN) 1205if test -z "$LN" ; then 1206 case $ac_sys_system in 1207 CYGWIN*) LN="ln -s";; 1208 *) LN=ln;; 1209 esac 1210fi 1211 1212# For calculating the .so ABI tag. 1213AC_SUBST(ABIFLAGS) 1214ABIFLAGS="" 1215 1216# Check for --with-pydebug 1217AC_MSG_CHECKING(for --with-pydebug) 1218AC_ARG_WITH(pydebug, 1219 AS_HELP_STRING([--with-pydebug], [build with Py_DEBUG defined]), 1220[ 1221if test "$withval" != no 1222then 1223 AC_DEFINE(Py_DEBUG, 1, 1224 [Define if you want to build an interpreter with many run-time checks.]) 1225 AC_MSG_RESULT(yes); 1226 Py_DEBUG='true' 1227 ABIFLAGS="${ABIFLAGS}d" 1228else AC_MSG_RESULT(no); Py_DEBUG='false' 1229fi], 1230[AC_MSG_RESULT(no)]) 1231 1232# Check for --with-trace-refs 1233# --with-trace-refs 1234AC_MSG_CHECKING(for --with-trace-refs) 1235AC_ARG_WITH(trace-refs, 1236 AS_HELP_STRING([--with-trace-refs],[enable tracing references for debugging purpose]),, 1237 with_trace_refs=no) 1238AC_MSG_RESULT($with_trace_refs) 1239 1240if test "$with_trace_refs" = "yes" 1241then 1242 AC_DEFINE(Py_TRACE_REFS, 1, [Define if you want to enable tracing references for debugging purpose]) 1243fi 1244 1245# Check for --with-assertions. 1246# This allows enabling assertions without Py_DEBUG. 1247assertions='false' 1248AC_MSG_CHECKING(for --with-assertions) 1249AC_ARG_WITH(assertions, 1250 AS_HELP_STRING([--with-assertions],[build with C assertions enabled]), 1251[ 1252if test "$withval" != no 1253then 1254 assertions='true' 1255fi], 1256[]) 1257if test "$assertions" = 'true'; then 1258 AC_MSG_RESULT(yes) 1259elif test "$Py_DEBUG" = 'true'; then 1260 assertions='true' 1261 AC_MSG_RESULT(implied by --with-pydebug) 1262else 1263 AC_MSG_RESULT(no) 1264fi 1265 1266# Enable optimization flags 1267AC_SUBST(DEF_MAKE_ALL_RULE) 1268AC_SUBST(DEF_MAKE_RULE) 1269Py_OPT='false' 1270AC_MSG_CHECKING(for --enable-optimizations) 1271AC_ARG_ENABLE(optimizations, AS_HELP_STRING([--enable-optimizations], [Enable expensive, stable optimizations (PGO, etc). Disabled by default.]), 1272[ 1273if test "$enableval" != no 1274then 1275 Py_OPT='true' 1276 AC_MSG_RESULT(yes); 1277else 1278 Py_OPT='false' 1279 AC_MSG_RESULT(no); 1280fi], 1281[AC_MSG_RESULT(no)]) 1282if test "$Py_OPT" = 'true' ; then 1283 # Intentionally not forcing Py_LTO='true' here. Too many toolchains do not 1284 # compile working code using it and both test_distutils and test_gdb are 1285 # broken when you do manage to get a toolchain that works with it. People 1286 # who want LTO need to use --with-lto themselves. 1287 DEF_MAKE_ALL_RULE="profile-opt" 1288 REQUIRE_PGO="yes" 1289 DEF_MAKE_RULE="build_all" 1290else 1291 DEF_MAKE_ALL_RULE="build_all" 1292 REQUIRE_PGO="no" 1293 DEF_MAKE_RULE="all" 1294fi 1295 1296AC_ARG_VAR(PROFILE_TASK, Python args for PGO generation task) 1297AC_MSG_CHECKING(PROFILE_TASK) 1298if test -z "$PROFILE_TASK" 1299then 1300 PROFILE_TASK='-m test --pgo' 1301fi 1302AC_MSG_RESULT($PROFILE_TASK) 1303 1304# Make llvm-relatec checks work on systems where llvm tools are not installed with their 1305# normal names in the default $PATH (ie: Ubuntu). They exist under the 1306# non-suffixed name in their versioned llvm directory. 1307 1308llvm_bin_dir='' 1309llvm_path="${PATH}" 1310if test "${CC}" = "clang" 1311then 1312 clang_bin=`which clang` 1313 # Some systems install clang elsewhere as a symlink to the real path 1314 # which is where the related llvm tools are located. 1315 if test -L "${clang_bin}" 1316 then 1317 clang_dir=`dirname "${clang_bin}"` 1318 clang_bin=`readlink "${clang_bin}"` 1319 llvm_bin_dir="${clang_dir}/"`dirname "${clang_bin}"` 1320 llvm_path="${llvm_path}${PATH_SEPARATOR}${llvm_bin_dir}" 1321 fi 1322fi 1323 1324# Enable LTO flags 1325AC_MSG_CHECKING(for --with-lto) 1326AC_ARG_WITH(lto, AS_HELP_STRING([--with-lto], [Enable Link Time Optimization in any build. Disabled by default.]), 1327[ 1328if test "$withval" != no 1329then 1330 Py_LTO='true' 1331 AC_MSG_RESULT(yes); 1332else 1333 Py_LTO='false' 1334 AC_MSG_RESULT(no); 1335fi], 1336[AC_MSG_RESULT(no)]) 1337if test "$Py_LTO" = 'true' ; then 1338 case $CC in 1339 *clang*) 1340 AC_SUBST(LLVM_AR) 1341 AC_PATH_TOOL(LLVM_AR, llvm-ar, '', ${llvm_path}) 1342 AC_SUBST(LLVM_AR_FOUND) 1343 if test -n "${LLVM_AR}" -a -x "${LLVM_AR}" 1344 then 1345 LLVM_AR_FOUND="found" 1346 else 1347 LLVM_AR_FOUND="not-found" 1348 fi 1349 if test "$ac_sys_system" = "Darwin" -a "${LLVM_AR_FOUND}" = "not-found" 1350 then 1351 found_llvm_ar=`/usr/bin/xcrun -find llvm-ar 2>/dev/null` 1352 if test -n "${found_llvm_ar}" 1353 then 1354 LLVM_AR='/usr/bin/xcrun llvm-ar' 1355 LLVM_AR_FOUND=found 1356 AC_MSG_NOTICE([llvm-ar found via xcrun: ${LLVM_AR}]) 1357 fi 1358 fi 1359 if test $LLVM_AR_FOUND = not-found 1360 then 1361 LLVM_PROFR_ERR=yes 1362 AC_MSG_ERROR([llvm-ar is required for a --with-lto build with clang but could not be found.]) 1363 else 1364 LLVM_AR_ERR=no 1365 fi 1366 AR="${LLVM_AR}" 1367 case $ac_sys_system in 1368 Darwin*) 1369 # Any changes made here should be reflected in the GCC+Darwin case below 1370 LTOFLAGS="-flto -Wl,-export_dynamic" 1371 ;; 1372 *) 1373 LTOFLAGS="-flto" 1374 ;; 1375 esac 1376 ;; 1377 *gcc*) 1378 case $ac_sys_system in 1379 Darwin*) 1380 LTOFLAGS="-flto -Wl,-export_dynamic" 1381 ;; 1382 *) 1383 LTOFLAGS="-flto -fuse-linker-plugin -ffat-lto-objects -flto-partition=none" 1384 ;; 1385 esac 1386 ;; 1387 esac 1388 1389 if test "$ac_cv_prog_cc_g" = "yes" 1390 then 1391 # bpo-30345: Add -g to LDFLAGS when compiling with LTO 1392 # to get debug symbols. 1393 LTOFLAGS="$LTOFLAGS -g" 1394 fi 1395 1396 CFLAGS_NODIST="$CFLAGS_NODIST $LTOFLAGS" 1397 LDFLAGS_NODIST="$LDFLAGS_NODIST $LTOFLAGS" 1398fi 1399 1400# Enable PGO flags. 1401AC_SUBST(PGO_PROF_GEN_FLAG) 1402AC_SUBST(PGO_PROF_USE_FLAG) 1403AC_SUBST(LLVM_PROF_MERGER) 1404AC_SUBST(LLVM_PROF_FILE) 1405AC_SUBST(LLVM_PROF_ERR) 1406AC_SUBST(LLVM_PROFDATA) 1407AC_PATH_TOOL(LLVM_PROFDATA, llvm-profdata, '', ${llvm_path}) 1408AC_SUBST(LLVM_PROF_FOUND) 1409if test -n "${LLVM_PROFDATA}" -a -x "${LLVM_PROFDATA}" 1410then 1411 LLVM_PROF_FOUND="found" 1412else 1413 LLVM_PROF_FOUND="not-found" 1414fi 1415if test "$ac_sys_system" = "Darwin" -a "${LLVM_PROF_FOUND}" = "not-found" 1416then 1417 found_llvm_profdata=`/usr/bin/xcrun -find llvm-profdata 2>/dev/null` 1418 if test -n "${found_llvm_profdata}" 1419 then 1420 # llvm-profdata isn't directly in $PATH in some cases. 1421 # https://apple.stackexchange.com/questions/197053/ 1422 LLVM_PROFDATA='/usr/bin/xcrun llvm-profdata' 1423 LLVM_PROF_FOUND=found 1424 AC_MSG_NOTICE([llvm-profdata found via xcrun: ${LLVM_PROFDATA}]) 1425 fi 1426fi 1427LLVM_PROF_ERR=no 1428case $CC in 1429 *clang*) 1430 # Any changes made here should be reflected in the GCC+Darwin case below 1431 PGO_PROF_GEN_FLAG="-fprofile-instr-generate" 1432 PGO_PROF_USE_FLAG="-fprofile-instr-use=code.profclangd" 1433 LLVM_PROF_MERGER="${LLVM_PROFDATA} merge -output=code.profclangd *.profclangr" 1434 LLVM_PROF_FILE="LLVM_PROFILE_FILE=\"code-%p.profclangr\"" 1435 if test $LLVM_PROF_FOUND = not-found 1436 then 1437 LLVM_PROF_ERR=yes 1438 if test "${REQUIRE_PGO}" = "yes" 1439 then 1440 AC_MSG_ERROR([llvm-profdata is required for a --enable-optimizations build but could not be found.]) 1441 fi 1442 fi 1443 ;; 1444 *gcc*) 1445 case $ac_sys_system in 1446 Darwin*) 1447 PGO_PROF_GEN_FLAG="-fprofile-instr-generate" 1448 PGO_PROF_USE_FLAG="-fprofile-instr-use=code.profclangd" 1449 LLVM_PROF_MERGER="${LLVM_PROFDATA} merge -output=code.profclangd *.profclangr" 1450 LLVM_PROF_FILE="LLVM_PROFILE_FILE=\"code-%p.profclangr\"" 1451 if test "${LLVM_PROF_FOUND}" = "not-found" 1452 then 1453 LLVM_PROF_ERR=yes 1454 if test "${REQUIRE_PGO}" = "yes" 1455 then 1456 AC_MSG_ERROR([llvm-profdata is required for a --enable-optimizations build but could not be found.]) 1457 fi 1458 fi 1459 ;; 1460 *) 1461 PGO_PROF_GEN_FLAG="-fprofile-generate" 1462 PGO_PROF_USE_FLAG="-fprofile-use -fprofile-correction" 1463 LLVM_PROF_MERGER="true" 1464 LLVM_PROF_FILE="" 1465 ;; 1466 esac 1467 ;; 1468 *icc*) 1469 PGO_PROF_GEN_FLAG="-prof-gen" 1470 PGO_PROF_USE_FLAG="-prof-use" 1471 LLVM_PROF_MERGER="true" 1472 LLVM_PROF_FILE="" 1473 ;; 1474esac 1475 1476# XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be 1477# merged with this chunk of code? 1478 1479# Optimizer/debugger flags 1480# ------------------------ 1481# (The following bit of code is complicated enough - please keep things 1482# indented properly. Just pretend you're editing Python code. ;-) 1483 1484# There are two parallel sets of case statements below, one that checks to 1485# see if OPT was set and one that does BASECFLAGS setting based upon 1486# compiler and platform. BASECFLAGS tweaks need to be made even if the 1487# user set OPT. 1488 1489case $CC in 1490 *clang*) 1491 cc_is_clang=1 1492 ;; 1493 *) 1494 if $CC --version 2>&1 | grep -q clang 1495 then 1496 cc_is_clang=1 1497 else 1498 cc_is_clang= 1499 fi 1500esac 1501 1502# tweak OPT based on compiler and platform, only if the user didn't set 1503# it on the command line 1504AC_SUBST(OPT) 1505AC_SUBST(CFLAGS_ALIASING) 1506if test "${OPT-unset}" = "unset" 1507then 1508 case $GCC in 1509 yes) 1510 # For gcc 4.x we need to use -fwrapv so lets check if its supported 1511 if "$CC" -v --help 2>/dev/null |grep -- -fwrapv > /dev/null; then 1512 WRAP="-fwrapv" 1513 fi 1514 1515 if test -n "${cc_is_clang}" 1516 then 1517 # Clang also needs -fwrapv 1518 WRAP="-fwrapv" 1519 # bpo-30104: disable strict aliasing to compile correctly dtoa.c, 1520 # see Makefile.pre.in for more information 1521 CFLAGS_ALIASING="-fno-strict-aliasing" 1522 fi 1523 1524 case $ac_cv_prog_cc_g in 1525 yes) 1526 if test "$Py_DEBUG" = 'true' ; then 1527 # Optimization messes up debuggers, so turn it off for 1528 # debug builds. 1529 if "$CC" -v --help 2>/dev/null |grep -- -Og > /dev/null; then 1530 OPT="-g -Og -Wall" 1531 else 1532 OPT="-g -O0 -Wall" 1533 fi 1534 else 1535 OPT="-g $WRAP -O3 -Wall" 1536 fi 1537 ;; 1538 *) 1539 OPT="-O3 -Wall" 1540 ;; 1541 esac 1542 1543 case $ac_sys_system in 1544 SCO_SV*) OPT="$OPT -m486 -DSCO5" 1545 ;; 1546 esac 1547 ;; 1548 1549 *) 1550 OPT="-O" 1551 ;; 1552 esac 1553fi 1554 1555AC_SUBST(BASECFLAGS) 1556AC_SUBST(CFLAGS_NODIST) 1557AC_SUBST(LDFLAGS_NODIST) 1558 1559# The -arch flags for universal builds on OSX 1560UNIVERSAL_ARCH_FLAGS= 1561AC_SUBST(UNIVERSAL_ARCH_FLAGS) 1562 1563# tweak BASECFLAGS based on compiler and platform 1564case $GCC in 1565yes) 1566 CFLAGS_NODIST="$CFLAGS_NODIST -std=c99" 1567 1568 AC_MSG_CHECKING(for -Wextra) 1569 ac_save_cc="$CC" 1570 CC="$CC -Wextra -Werror" 1571 AC_CACHE_VAL(ac_cv_extra_warnings, 1572 AC_COMPILE_IFELSE( 1573 [ 1574 AC_LANG_PROGRAM([[]], [[]]) 1575 ],[ 1576 ac_cv_extra_warnings=yes 1577 ],[ 1578 ac_cv_extra_warnings=no 1579 ])) 1580 CC="$ac_save_cc" 1581 AC_MSG_RESULT($ac_cv_extra_warnings) 1582 1583 if test $ac_cv_extra_warnings = yes 1584 then 1585 CFLAGS_NODIST="$CFLAGS_NODIST -Wextra" 1586 fi 1587 1588 # Python doesn't violate C99 aliasing rules, but older versions of 1589 # GCC produce warnings for legal Python code. Enable 1590 # -fno-strict-aliasing on versions of GCC that support but produce 1591 # warnings. See Issue3326 1592 AC_MSG_CHECKING(whether $CC accepts and needs -fno-strict-aliasing) 1593 ac_save_cc="$CC" 1594 CC="$CC -fno-strict-aliasing" 1595 save_CFLAGS="$CFLAGS" 1596 AC_CACHE_VAL(ac_cv_no_strict_aliasing, 1597 AC_COMPILE_IFELSE( 1598 [ 1599 AC_LANG_PROGRAM([[]], [[]]) 1600 ],[ 1601 CC="$ac_save_cc -fstrict-aliasing" 1602 CFLAGS="$CFLAGS -Werror -Wstrict-aliasing" 1603 AC_COMPILE_IFELSE( 1604 [ 1605 AC_LANG_PROGRAM([[void f(int **x) {}]], 1606 [[double *x; f((int **) &x);]]) 1607 ],[ 1608 ac_cv_no_strict_aliasing=no 1609 ],[ 1610 ac_cv_no_strict_aliasing=yes 1611 ]) 1612 ],[ 1613 ac_cv_no_strict_aliasing=no 1614 ])) 1615 CFLAGS="$save_CFLAGS" 1616 CC="$ac_save_cc" 1617 AC_MSG_RESULT($ac_cv_no_strict_aliasing) 1618 if test $ac_cv_no_strict_aliasing = yes 1619 then 1620 BASECFLAGS="$BASECFLAGS -fno-strict-aliasing" 1621 fi 1622 1623 # ICC doesn't recognize the option, but only emits a warning 1624 ## XXX does it emit an unused result warning and can it be disabled? 1625 case "$CC" in 1626 *icc*) 1627 ac_cv_disable_unused_result_warning=no 1628 ;; 1629 *) 1630 AC_MSG_CHECKING(if we can turn off $CC unused result warning) 1631 ac_save_cc="$CC" 1632 CC="$CC -Wunused-result -Werror" 1633 save_CFLAGS="$CFLAGS" 1634 AC_CACHE_VAL(ac_cv_disable_unused_result_warning, 1635 AC_COMPILE_IFELSE( 1636 [ 1637 AC_LANG_PROGRAM([[]], [[]]) 1638 ],[ 1639 ac_cv_disable_unused_result_warning=yes 1640 ],[ 1641 ac_cv_disable_unused_result_warning=no 1642 ])) 1643 CFLAGS="$save_CFLAGS" 1644 CC="$ac_save_cc" 1645 AC_MSG_RESULT($ac_cv_disable_unused_result_warning) 1646 ;; 1647 esac 1648 1649 if test $ac_cv_disable_unused_result_warning = yes 1650 then 1651 BASECFLAGS="$BASECFLAGS -Wno-unused-result" 1652 CFLAGS_NODIST="$CFLAGS_NODIST -Wno-unused-result" 1653 fi 1654 1655 AC_MSG_CHECKING(if we can turn off $CC unused parameter warning) 1656 ac_save_cc="$CC" 1657 CC="$CC -Wunused-parameter -Werror" 1658 AC_CACHE_VAL(ac_cv_disable_unused_parameter_warning, 1659 AC_COMPILE_IFELSE( 1660 [ 1661 AC_LANG_PROGRAM([[]], [[]]) 1662 ],[ 1663 ac_cv_disable_unused_parameter_warning=yes 1664 ],[ 1665 ac_cv_disable_unused_parameter_warning=no 1666 ])) 1667 CC="$ac_save_cc" 1668 AC_MSG_RESULT($ac_cv_disable_unused_parameter_warning) 1669 1670 if test $ac_cv_disable_unused_parameter_warning = yes 1671 then 1672 CFLAGS_NODIST="$CFLAGS_NODIST -Wno-unused-parameter" 1673 fi 1674 1675 AC_MSG_CHECKING(if we can turn off $CC missing field initializers warning) 1676 ac_save_cc="$CC" 1677 CC="$CC -Wmissing-field-initializers -Werror" 1678 AC_CACHE_VAL(ac_cv_disable_missing_field_initializers, 1679 AC_COMPILE_IFELSE( 1680 [ 1681 AC_LANG_PROGRAM([[]], [[]]) 1682 ],[ 1683 ac_cv_disable_missing_field_initializers=yes 1684 ],[ 1685 ac_cv_disable_missing_field_initializers=no 1686 ])) 1687 CC="$ac_save_cc" 1688 AC_MSG_RESULT($ac_cv_disable_missing_field_initializers) 1689 1690 if test $ac_cv_disable_missing_field_initializers = yes 1691 then 1692 CFLAGS_NODIST="$CFLAGS_NODIST -Wno-missing-field-initializers" 1693 fi 1694 1695 AC_MSG_CHECKING(if we can turn on $CC mixed sign comparison warning) 1696 ac_save_cc="$CC" 1697 CC="$CC -Wsign-compare" 1698 save_CFLAGS="$CFLAGS" 1699 AC_CACHE_VAL(ac_cv_enable_sign_compare_warning, 1700 AC_COMPILE_IFELSE( 1701 [ 1702 AC_LANG_PROGRAM([[]], [[]]) 1703 ],[ 1704 ac_cv_enable_sign_compare_warning=yes 1705 ],[ 1706 ac_cv_enable_sign_compare_warning=no 1707 ])) 1708 CFLAGS="$save_CFLAGS" 1709 CC="$ac_save_cc" 1710 AC_MSG_RESULT($ac_cv_enable_sign_compare_warning) 1711 1712 if test $ac_cv_enable_sign_compare_warning = yes 1713 then 1714 BASECFLAGS="$BASECFLAGS -Wsign-compare" 1715 fi 1716 1717 AC_MSG_CHECKING(if we can turn on $CC unreachable code warning) 1718 ac_save_cc="$CC" 1719 CC="$CC -Wunreachable-code" 1720 save_CFLAGS="$CFLAGS" 1721 AC_CACHE_VAL(ac_cv_enable_unreachable_code_warning, 1722 AC_COMPILE_IFELSE( 1723 [ 1724 AC_LANG_PROGRAM([[]], [[]]) 1725 ],[ 1726 ac_cv_enable_unreachable_code_warning=yes 1727 ],[ 1728 ac_cv_enable_unreachable_code_warning=no 1729 ])) 1730 CFLAGS="$save_CFLAGS" 1731 CC="$ac_save_cc" 1732 1733 # Don't enable unreachable code warning in debug mode, since it usually 1734 # results in non-standard code paths. 1735 # Issue #24324: Unfortunately, the unreachable code warning does not work 1736 # correctly on gcc and has been silently removed from the compiler. 1737 # It is supported on clang but on OS X systems gcc may be an alias 1738 # for clang. Try to determine if the compiler is not really gcc and, 1739 # if so, only then enable the warning. 1740 if test $ac_cv_enable_unreachable_code_warning = yes && \ 1741 test "$Py_DEBUG" != "true" && \ 1742 test -z "`$CC --version 2>/dev/null | grep 'Free Software Foundation'`" 1743 then 1744 BASECFLAGS="$BASECFLAGS -Wunreachable-code" 1745 else 1746 ac_cv_enable_unreachable_code_warning=no 1747 fi 1748 AC_MSG_RESULT($ac_cv_enable_unreachable_code_warning) 1749 1750 AC_MSG_CHECKING(if we can turn on $CC strict-prototypes warning) 1751 ac_save_cc="$CC" 1752 CC="$CC -Werror -Wstrict-prototypes" 1753 AC_CACHE_VAL(ac_cv_enable_enable_strict_prototypes_warning, 1754 AC_COMPILE_IFELSE( 1755 [ 1756 AC_LANG_PROGRAM([[]], [[]]) 1757 ],[ 1758 ac_cv_enable_strict_prototypes_warning=yes 1759 ],[ 1760 ac_cv_enable_strict_prototypes_warning=no 1761 ])) 1762 CC="$ac_save_cc" 1763 AC_MSG_RESULT($ac_cv_enable_strict_prototypes_warning) 1764 1765 if test $ac_cv_enable_strict_prototypes_warning = yes 1766 then 1767 CFLAGS_NODIST="$CFLAGS_NODIST -Wstrict-prototypes" 1768 fi 1769 1770 AC_MSG_CHECKING(if we can make implicit function declaration an error in $CC) 1771 ac_save_cc="$CC" 1772 CC="$CC -Werror=implicit-function-declaration" 1773 AC_CACHE_VAL(ac_cv_enable_implicit_function_declaration_error, 1774 AC_COMPILE_IFELSE( 1775 [ 1776 AC_LANG_PROGRAM([[]], [[]]) 1777 ],[ 1778 ac_cv_enable_implicit_function_declaration_error=yes 1779 ],[ 1780 ac_cv_enable_implicit_function_declaration_error=no 1781 ])) 1782 CC="$ac_save_cc" 1783 AC_MSG_RESULT($ac_cv_enable_implicit_function_declaration_error) 1784 1785 if test $ac_cv_enable_implicit_function_declaration_error = yes 1786 then 1787 CFLAGS_NODIST="$CFLAGS_NODIST -Werror=implicit-function-declaration" 1788 fi 1789 1790 # if using gcc on alpha, use -mieee to get (near) full IEEE 754 1791 # support. Without this, treatment of subnormals doesn't follow 1792 # the standard. 1793 case $host in 1794 alpha*) 1795 BASECFLAGS="$BASECFLAGS -mieee" 1796 ;; 1797 esac 1798 1799 case $ac_sys_system in 1800 SCO_SV*) 1801 BASECFLAGS="$BASECFLAGS -m486 -DSCO5" 1802 ;; 1803 1804 Darwin*) 1805 # -Wno-long-double, -no-cpp-precomp, and -mno-fused-madd 1806 # used to be here, but non-Apple gcc doesn't accept them. 1807 if test "${CC}" = gcc 1808 then 1809 AC_MSG_CHECKING(which compiler should be used) 1810 case "${UNIVERSALSDK}" in 1811 */MacOSX10.4u.sdk) 1812 # Build using 10.4 SDK, force usage of gcc when the 1813 # compiler is gcc, otherwise the user will get very 1814 # confusing error messages when building on OSX 10.6 1815 CC=gcc-4.0 1816 CPP=cpp-4.0 1817 ;; 1818 esac 1819 AC_MSG_RESULT($CC) 1820 fi 1821 1822 if test "${enable_universalsdk}" 1823 then 1824 case "$UNIVERSAL_ARCHS" in 1825 32-bit) 1826 UNIVERSAL_ARCH_FLAGS="-arch ppc -arch i386" 1827 LIPO_32BIT_FLAGS="" 1828 ARCH_RUN_32BIT="" 1829 ;; 1830 64-bit) 1831 UNIVERSAL_ARCH_FLAGS="-arch ppc64 -arch x86_64" 1832 LIPO_32BIT_FLAGS="" 1833 ARCH_RUN_32BIT="true" 1834 ;; 1835 all) 1836 UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch ppc64 -arch x86_64" 1837 LIPO_32BIT_FLAGS="-extract ppc7400 -extract i386" 1838 ARCH_RUN_32BIT="/usr/bin/arch -i386 -ppc" 1839 ;; 1840 intel) 1841 UNIVERSAL_ARCH_FLAGS="-arch i386 -arch x86_64" 1842 LIPO_32BIT_FLAGS="-extract i386" 1843 ARCH_RUN_32BIT="/usr/bin/arch -i386" 1844 ;; 1845 intel-32) 1846 UNIVERSAL_ARCH_FLAGS="-arch i386" 1847 LIPO_32BIT_FLAGS="" 1848 ARCH_RUN_32BIT="" 1849 ;; 1850 intel-64) 1851 UNIVERSAL_ARCH_FLAGS="-arch x86_64" 1852 LIPO_32BIT_FLAGS="" 1853 ARCH_RUN_32BIT="true" 1854 ;; 1855 3-way) 1856 UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch x86_64" 1857 LIPO_32BIT_FLAGS="-extract ppc7400 -extract i386" 1858 ARCH_RUN_32BIT="/usr/bin/arch -i386 -ppc" 1859 ;; 1860 *) 1861 AC_MSG_ERROR([proper usage is --with-universal-arch=32-bit|64-bit|all|intel|3-way]) 1862 ;; 1863 esac 1864 1865 if test "${UNIVERSALSDK}" != "/" 1866 then 1867 CFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${CFLAGS}" 1868 LDFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${LDFLAGS}" 1869 CPPFLAGS="-isysroot ${UNIVERSALSDK} ${CPPFLAGS}" 1870 else 1871 CFLAGS="${UNIVERSAL_ARCH_FLAGS} ${CFLAGS}" 1872 LDFLAGS="${UNIVERSAL_ARCH_FLAGS} ${LDFLAGS}" 1873 fi 1874 fi 1875 1876 # Calculate an appropriate deployment target for this build: 1877 # The deployment target value is used explicitly to enable certain 1878 # features are enabled (such as builtin libedit support for readline) 1879 # through the use of Apple's Availability Macros and is used as a 1880 # component of the string returned by distutils.get_platform(). 1881 # 1882 # Use the value from: 1883 # 1. the MACOSX_DEPLOYMENT_TARGET environment variable if specified 1884 # 2. the operating system version of the build machine if >= 10.6 1885 # 3. If running on OS X 10.3 through 10.5, use the legacy tests 1886 # below to pick either 10.3, 10.4, or 10.5 as the target. 1887 # 4. If we are running on OS X 10.2 or earlier, good luck! 1888 1889 AC_MSG_CHECKING(which MACOSX_DEPLOYMENT_TARGET to use) 1890 cur_target_major=`sw_vers -productVersion | \ 1891 sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\1/'` 1892 cur_target_minor=`sw_vers -productVersion | \ 1893 sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\2/'` 1894 cur_target="${cur_target_major}.${cur_target_minor}" 1895 if test ${cur_target_major} -eq 10 && \ 1896 test ${cur_target_minor} -ge 3 && \ 1897 test ${cur_target_minor} -le 5 1898 then 1899 # OS X 10.3 through 10.5 1900 cur_target=10.3 1901 if test ${enable_universalsdk} 1902 then 1903 case "$UNIVERSAL_ARCHS" in 1904 all|3-way|intel|64-bit) 1905 # These configurations were first supported in 10.5 1906 cur_target='10.5' 1907 ;; 1908 esac 1909 else 1910 if test `/usr/bin/arch` = "i386" 1911 then 1912 # 10.4 was the first release to support Intel archs 1913 cur_target="10.4" 1914 fi 1915 fi 1916 fi 1917 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}} 1918 1919 # Make sure that MACOSX_DEPLOYMENT_TARGET is set in the 1920 # environment with a value that is the same as what we'll use 1921 # in the Makefile to ensure that we'll get the same compiler 1922 # environment during configure and build time. 1923 MACOSX_DEPLOYMENT_TARGET="$CONFIGURE_MACOSX_DEPLOYMENT_TARGET" 1924 export MACOSX_DEPLOYMENT_TARGET 1925 EXPORT_MACOSX_DEPLOYMENT_TARGET='' 1926 AC_MSG_RESULT($MACOSX_DEPLOYMENT_TARGET) 1927 1928 # end of Darwin* tests 1929 ;; 1930 esac 1931 ;; 1932 1933*) 1934 case $ac_sys_system in 1935 OpenUNIX*|UnixWare*) 1936 BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca " 1937 ;; 1938 SCO_SV*) 1939 BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5" 1940 ;; 1941 esac 1942 ;; 1943esac 1944 1945# ICC needs -fp-model strict or floats behave badly 1946case "$CC" in 1947*icc*) 1948 CFLAGS_NODIST="$CFLAGS_NODIST -fp-model strict" 1949 ;; 1950esac 1951 1952if test "$assertions" = 'true'; then 1953 : 1954else 1955 OPT="-DNDEBUG $OPT" 1956fi 1957 1958if test "$ac_arch_flags" 1959then 1960 BASECFLAGS="$BASECFLAGS $ac_arch_flags" 1961fi 1962 1963# On some compilers, pthreads are available without further options 1964# (e.g. MacOS X). On some of these systems, the compiler will not 1965# complain if unaccepted options are passed (e.g. gcc on Mac OS X). 1966# So we have to see first whether pthreads are available without 1967# options before we can check whether -Kpthread improves anything. 1968AC_MSG_CHECKING(whether pthreads are available without options) 1969AC_CACHE_VAL(ac_cv_pthread_is_default, 1970[AC_RUN_IFELSE([AC_LANG_SOURCE([[ 1971#include <stdio.h> 1972#include <pthread.h> 1973 1974void* routine(void* p){return NULL;} 1975 1976int main(){ 1977 pthread_t p; 1978 if(pthread_create(&p,NULL,routine,NULL)!=0) 1979 return 1; 1980 (void)pthread_detach(p); 1981 return 0; 1982} 1983]])],[ 1984 ac_cv_pthread_is_default=yes 1985 ac_cv_kthread=no 1986 ac_cv_pthread=no 1987],[ac_cv_pthread_is_default=no],[ac_cv_pthread_is_default=no]) 1988]) 1989AC_MSG_RESULT($ac_cv_pthread_is_default) 1990 1991 1992if test $ac_cv_pthread_is_default = yes 1993then 1994 ac_cv_kpthread=no 1995else 1996# -Kpthread, if available, provides the right #defines 1997# and linker options to make pthread_create available 1998# Some compilers won't report that they do not support -Kpthread, 1999# so we need to run a program to see whether it really made the 2000# function available. 2001AC_MSG_CHECKING(whether $CC accepts -Kpthread) 2002AC_CACHE_VAL(ac_cv_kpthread, 2003[ac_save_cc="$CC" 2004CC="$CC -Kpthread" 2005AC_RUN_IFELSE([AC_LANG_SOURCE([[ 2006#include <stdio.h> 2007#include <pthread.h> 2008 2009void* routine(void* p){return NULL;} 2010 2011int main(){ 2012 pthread_t p; 2013 if(pthread_create(&p,NULL,routine,NULL)!=0) 2014 return 1; 2015 (void)pthread_detach(p); 2016 return 0; 2017} 2018]])],[ac_cv_kpthread=yes],[ac_cv_kpthread=no],[ac_cv_kpthread=no]) 2019CC="$ac_save_cc"]) 2020AC_MSG_RESULT($ac_cv_kpthread) 2021fi 2022 2023if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no 2024then 2025# -Kthread, if available, provides the right #defines 2026# and linker options to make pthread_create available 2027# Some compilers won't report that they do not support -Kthread, 2028# so we need to run a program to see whether it really made the 2029# function available. 2030AC_MSG_CHECKING(whether $CC accepts -Kthread) 2031AC_CACHE_VAL(ac_cv_kthread, 2032[ac_save_cc="$CC" 2033CC="$CC -Kthread" 2034AC_RUN_IFELSE([AC_LANG_SOURCE([[ 2035#include <stdio.h> 2036#include <pthread.h> 2037 2038void* routine(void* p){return NULL;} 2039 2040int main(){ 2041 pthread_t p; 2042 if(pthread_create(&p,NULL,routine,NULL)!=0) 2043 return 1; 2044 (void)pthread_detach(p); 2045 return 0; 2046} 2047]])],[ac_cv_kthread=yes],[ac_cv_kthread=no],[ac_cv_kthread=no]) 2048CC="$ac_save_cc"]) 2049AC_MSG_RESULT($ac_cv_kthread) 2050fi 2051 2052if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no 2053then 2054# -pthread, if available, provides the right #defines 2055# and linker options to make pthread_create available 2056# Some compilers won't report that they do not support -pthread, 2057# so we need to run a program to see whether it really made the 2058# function available. 2059AC_MSG_CHECKING(whether $CC accepts -pthread) 2060AC_CACHE_VAL(ac_cv_pthread, 2061[ac_save_cc="$CC" 2062CC="$CC -pthread" 2063AC_RUN_IFELSE([AC_LANG_SOURCE([[ 2064#include <stdio.h> 2065#include <pthread.h> 2066 2067void* routine(void* p){return NULL;} 2068 2069int main(){ 2070 pthread_t p; 2071 if(pthread_create(&p,NULL,routine,NULL)!=0) 2072 return 1; 2073 (void)pthread_detach(p); 2074 return 0; 2075} 2076]])],[ac_cv_pthread=yes],[ac_cv_pthread=no],[ac_cv_pthread=no]) 2077CC="$ac_save_cc"]) 2078AC_MSG_RESULT($ac_cv_pthread) 2079fi 2080 2081# If we have set a CC compiler flag for thread support then 2082# check if it works for CXX, too. 2083ac_cv_cxx_thread=no 2084if test ! -z "$CXX" 2085then 2086AC_MSG_CHECKING(whether $CXX also accepts flags for thread support) 2087ac_save_cxx="$CXX" 2088 2089if test "$ac_cv_kpthread" = "yes" 2090then 2091 CXX="$CXX -Kpthread" 2092 ac_cv_cxx_thread=yes 2093elif test "$ac_cv_kthread" = "yes" 2094then 2095 CXX="$CXX -Kthread" 2096 ac_cv_cxx_thread=yes 2097elif test "$ac_cv_pthread" = "yes" 2098then 2099 CXX="$CXX -pthread" 2100 ac_cv_cxx_thread=yes 2101fi 2102 2103if test $ac_cv_cxx_thread = yes 2104then 2105 echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext 2106 $CXX -c conftest.$ac_ext 2>&5 2107 if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \ 2108 && test -s conftest$ac_exeext && ./conftest$ac_exeext 2109 then 2110 ac_cv_cxx_thread=yes 2111 else 2112 ac_cv_cxx_thread=no 2113 fi 2114 rm -fr conftest* 2115fi 2116AC_MSG_RESULT($ac_cv_cxx_thread) 2117fi 2118CXX="$ac_save_cxx" 2119 2120dnl # check for ANSI or K&R ("traditional") preprocessor 2121dnl AC_MSG_CHECKING(for C preprocessor type) 2122dnl AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 2123dnl #define spam(name, doc) {#name, &name, #name "() -- " doc} 2124dnl int foo; 2125dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something"); 2126dnl ]], [[;]])],[cpp_type=ansi],[AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional]) 2127dnl AC_MSG_RESULT($cpp_type) 2128 2129# checks for header files 2130AC_HEADER_STDC 2131AC_CHECK_HEADERS(asm/types.h crypt.h conio.h direct.h dlfcn.h errno.h \ 2132fcntl.h grp.h \ 2133ieeefp.h io.h langinfo.h libintl.h process.h pthread.h \ 2134sched.h shadow.h signal.h stropts.h termios.h \ 2135utime.h \ 2136poll.h sys/devpoll.h sys/epoll.h sys/poll.h \ 2137sys/audioio.h sys/xattr.h sys/bsdtty.h sys/event.h sys/file.h sys/ioctl.h \ 2138sys/kern_control.h sys/loadavg.h sys/lock.h sys/mkdev.h sys/modem.h \ 2139sys/param.h sys/random.h sys/select.h sys/sendfile.h sys/socket.h sys/statvfs.h \ 2140sys/stat.h sys/syscall.h sys/sys_domain.h sys/termio.h sys/time.h \ 2141sys/times.h sys/types.h sys/uio.h sys/un.h sys/utsname.h sys/wait.h pty.h \ 2142libutil.h sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \ 2143linux/tipc.h linux/random.h spawn.h util.h alloca.h endian.h \ 2144sys/endian.h sys/sysmacros.h linux/memfd.h sys/memfd.h sys/mman.h) 2145AC_HEADER_DIRENT 2146AC_HEADER_MAJOR 2147 2148# bluetooth/bluetooth.h has been known to not compile with -std=c99. 2149# http://permalink.gmane.org/gmane.linux.bluez.kernel/22294 2150SAVE_CFLAGS=$CFLAGS 2151CFLAGS="-std=c99 $CFLAGS" 2152AC_CHECK_HEADERS(bluetooth/bluetooth.h) 2153CFLAGS=$SAVE_CFLAGS 2154 2155# On Darwin (OS X) net/if.h requires sys/socket.h to be imported first. 2156AC_CHECK_HEADERS([net/if.h], [], [], 2157[#include <stdio.h> 2158#ifdef STDC_HEADERS 2159# include <stdlib.h> 2160# include <stddef.h> 2161#else 2162# ifdef HAVE_STDLIB_H 2163# include <stdlib.h> 2164# endif 2165#endif 2166#ifdef HAVE_SYS_SOCKET_H 2167# include <sys/socket.h> 2168#endif 2169]) 2170 2171# On Linux, netlink.h requires asm/types.h 2172AC_CHECK_HEADERS(linux/netlink.h,,,[ 2173#ifdef HAVE_ASM_TYPES_H 2174#include <asm/types.h> 2175#endif 2176#ifdef HAVE_SYS_SOCKET_H 2177#include <sys/socket.h> 2178#endif 2179]) 2180 2181# On Linux, qrtr.h requires asm/types.h 2182AC_CHECK_HEADERS(linux/qrtr.h,,,[ 2183#ifdef HAVE_ASM_TYPES_H 2184#include <asm/types.h> 2185#endif 2186#ifdef HAVE_SYS_SOCKET_H 2187#include <sys/socket.h> 2188#endif 2189]) 2190 2191AC_CHECK_HEADERS(linux/vm_sockets.h,,,[ 2192#ifdef HAVE_SYS_SOCKET_H 2193#include <sys/socket.h> 2194#endif 2195]) 2196 2197# On Linux, can.h and can/raw.h require sys/socket.h 2198AC_CHECK_HEADERS(linux/can.h linux/can/raw.h linux/can/bcm.h,,,[ 2199#ifdef HAVE_SYS_SOCKET_H 2200#include <sys/socket.h> 2201#endif 2202]) 2203 2204# checks for typedefs 2205was_it_defined=no 2206AC_MSG_CHECKING(for clock_t in time.h) 2207AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [ 2208 AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.]) 2209]) 2210AC_MSG_RESULT($was_it_defined) 2211 2212AC_MSG_CHECKING(for makedev) 2213AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 2214#if defined(MAJOR_IN_MKDEV) 2215#include <sys/mkdev.h> 2216#elif defined(MAJOR_IN_SYSMACROS) 2217#include <sys/sysmacros.h> 2218#else 2219#include <sys/types.h> 2220#endif 2221]], [[ 2222 makedev(0, 0) ]]) 2223],[ac_cv_has_makedev=yes],[ac_cv_has_makedev=no]) 2224AC_MSG_RESULT($ac_cv_has_makedev) 2225if test "$ac_cv_has_makedev" = "yes"; then 2226 AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.]) 2227fi 2228 2229# byte swapping 2230AC_MSG_CHECKING(for le64toh) 2231AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 2232#ifdef HAVE_ENDIAN_H 2233#include <endian.h> 2234#elif defined(HAVE_SYS_ENDIAN_H) 2235#include <sys/endian.h> 2236#endif 2237]], [[ 2238 le64toh(1) ]]) 2239],[ac_cv_has_le64toh=yes],[ac_cv_has_le64toh=no]) 2240AC_MSG_RESULT($ac_cv_has_le64toh) 2241if test "$ac_cv_has_le64toh" = "yes"; then 2242 AC_DEFINE(HAVE_HTOLE64, 1, [Define this if you have le64toh()]) 2243fi 2244 2245use_lfs=yes 2246# Don't use largefile support for GNU/Hurd 2247case $ac_sys_system in GNU*) 2248 use_lfs=no 2249esac 2250 2251if test "$use_lfs" = "yes"; then 2252# Two defines needed to enable largefile support on various platforms 2253# These may affect some typedefs 2254case $ac_sys_system/$ac_sys_release in 2255AIX*) 2256 AC_DEFINE(_LARGE_FILES, 1, 2257 [This must be defined on AIX systems to enable large file support.]) 2258 ;; 2259esac 2260AC_DEFINE(_LARGEFILE_SOURCE, 1, 2261[This must be defined on some systems to enable large file support.]) 2262AC_DEFINE(_FILE_OFFSET_BITS, 64, 2263[This must be set to 64 on some systems to enable large file support.]) 2264fi 2265 2266# Add some code to confdefs.h so that the test for off_t works on SCO 2267cat >> confdefs.h <<\EOF 2268#if defined(SCO_DS) 2269#undef _OFF_T 2270#endif 2271EOF 2272 2273# Type availability checks 2274AC_TYPE_MODE_T 2275AC_TYPE_OFF_T 2276AC_TYPE_PID_T 2277AC_DEFINE_UNQUOTED([RETSIGTYPE],[void],[assume C89 semantics that RETSIGTYPE is always void]) 2278AC_TYPE_SIZE_T 2279AC_TYPE_UID_T 2280 2281AC_CHECK_TYPE(ssize_t, 2282 AC_DEFINE(HAVE_SSIZE_T, 1, [Define if your compiler provides ssize_t]),,) 2283AC_CHECK_TYPE(__uint128_t, 2284 AC_DEFINE(HAVE_GCC_UINT128_T, 1, [Define if your compiler provides __uint128_t]),,) 2285 2286# Sizes of various common basic types 2287# ANSI C requires sizeof(char) == 1, so no need to check it 2288AC_CHECK_SIZEOF(int, 4) 2289AC_CHECK_SIZEOF(long, 4) 2290AC_CHECK_SIZEOF(long long, 8) 2291AC_CHECK_SIZEOF(void *, 4) 2292AC_CHECK_SIZEOF(short, 2) 2293AC_CHECK_SIZEOF(float, 4) 2294AC_CHECK_SIZEOF(double, 8) 2295AC_CHECK_SIZEOF(fpos_t, 4) 2296AC_CHECK_SIZEOF(size_t, 4) 2297AC_CHECK_SIZEOF(pid_t, 4) 2298AC_CHECK_SIZEOF(uintptr_t) 2299 2300AC_TYPE_LONG_DOUBLE 2301AC_CHECK_SIZEOF(long double, 16) 2302 2303AC_CHECK_SIZEOF(_Bool, 1) 2304 2305AC_CHECK_SIZEOF(off_t, [], [ 2306#ifdef HAVE_SYS_TYPES_H 2307#include <sys/types.h> 2308#endif 2309]) 2310 2311AC_MSG_CHECKING(whether to enable large file support) 2312if test "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \ 2313 "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then 2314 AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1, 2315 [Defined to enable large file support when an off_t is bigger than a long 2316 and long long is at least as big as an off_t. You may need 2317 to add some flags for configuration and compilation to enable this mode. 2318 (For Solaris and Linux, the necessary defines are already defined.)]) 2319 AC_MSG_RESULT(yes) 2320else 2321 AC_MSG_RESULT(no) 2322fi 2323 2324AC_CHECK_SIZEOF(time_t, [], [ 2325#ifdef HAVE_SYS_TYPES_H 2326#include <sys/types.h> 2327#endif 2328#ifdef HAVE_TIME_H 2329#include <time.h> 2330#endif 2331]) 2332 2333# if have pthread_t then define SIZEOF_PTHREAD_T 2334ac_save_cc="$CC" 2335if test "$ac_cv_kpthread" = "yes" 2336then CC="$CC -Kpthread" 2337elif test "$ac_cv_kthread" = "yes" 2338then CC="$CC -Kthread" 2339elif test "$ac_cv_pthread" = "yes" 2340then CC="$CC -pthread" 2341fi 2342 2343AC_MSG_CHECKING(for pthread_t) 2344have_pthread_t=no 2345AC_COMPILE_IFELSE([ 2346 AC_LANG_PROGRAM([[#include <pthread.h>]], [[pthread_t x; x = *(pthread_t*)0;]]) 2347],[have_pthread_t=yes],[]) 2348AC_MSG_RESULT($have_pthread_t) 2349if test "$have_pthread_t" = yes ; then 2350 AC_CHECK_SIZEOF(pthread_t, [], [ 2351#ifdef HAVE_PTHREAD_H 2352#include <pthread.h> 2353#endif 2354 ]) 2355fi 2356 2357# Issue #25658: POSIX hasn't defined that pthread_key_t is compatible with int. 2358# This checking will be unnecessary after removing deprecated TLS API. 2359AC_CHECK_SIZEOF(pthread_key_t, [], [[#include <pthread.h>]]) 2360AC_MSG_CHECKING(whether pthread_key_t is compatible with int) 2361if test "$ac_cv_sizeof_pthread_key_t" -eq "$ac_cv_sizeof_int" ; then 2362 AC_COMPILE_IFELSE( 2363 [AC_LANG_PROGRAM([[#include <pthread.h>]], [[pthread_key_t k; k * 1;]])], 2364 [ac_pthread_key_t_is_arithmetic_type=yes], 2365 [ac_pthread_key_t_is_arithmetic_type=no] 2366 ) 2367 AC_MSG_RESULT($ac_pthread_key_t_is_arithmetic_type) 2368 if test "$ac_pthread_key_t_is_arithmetic_type" = yes ; then 2369 AC_DEFINE(PTHREAD_KEY_T_IS_COMPATIBLE_WITH_INT, 1, 2370 [Define if pthread_key_t is compatible with int.]) 2371 fi 2372else 2373 AC_MSG_RESULT(no) 2374fi 2375CC="$ac_save_cc" 2376 2377AC_SUBST(OTHER_LIBTOOL_OPT) 2378case $ac_sys_system/$ac_sys_release in 2379 Darwin/@<:@01567@:>@\..*) 2380 OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000" 2381 ;; 2382 Darwin/*) 2383 OTHER_LIBTOOL_OPT="" 2384 ;; 2385esac 2386 2387 2388AC_SUBST(LIBTOOL_CRUFT) 2389case $ac_sys_system/$ac_sys_release in 2390 Darwin/@<:@01567@:>@\..*) 2391 LIBTOOL_CRUFT="-framework System -lcc_dynamic" 2392 if test "${enable_universalsdk}"; then 2393 : 2394 else 2395 LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `/usr/bin/arch`" 2396 fi 2397 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)' 2398 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';; 2399 Darwin/*) 2400 gcc_version=`gcc -dumpversion` 2401 if test ${gcc_version} '<' 4.0 2402 then 2403 LIBTOOL_CRUFT="-lcc_dynamic" 2404 else 2405 LIBTOOL_CRUFT="" 2406 fi 2407 AC_RUN_IFELSE([AC_LANG_SOURCE([[ 2408 #include <unistd.h> 2409 int main(int argc, char*argv[]) 2410 { 2411 if (sizeof(long) == 4) { 2412 return 0; 2413 } else { 2414 return 1; 2415 } 2416 } 2417 ]])],[ac_osx_32bit=yes],[ac_osx_32bit=no],[ac_osx_32bit=yes]) 2418 2419 if test "${ac_osx_32bit}" = "yes"; then 2420 case `/usr/bin/arch` in 2421 i386) 2422 MACOSX_DEFAULT_ARCH="i386" 2423 ;; 2424 ppc) 2425 MACOSX_DEFAULT_ARCH="ppc" 2426 ;; 2427 *) 2428 AC_MSG_ERROR([Unexpected output of 'arch' on OSX]) 2429 ;; 2430 esac 2431 else 2432 case `/usr/bin/arch` in 2433 i386) 2434 MACOSX_DEFAULT_ARCH="x86_64" 2435 ;; 2436 ppc) 2437 MACOSX_DEFAULT_ARCH="ppc64" 2438 ;; 2439 *) 2440 AC_MSG_ERROR([Unexpected output of 'arch' on OSX]) 2441 ;; 2442 esac 2443 2444 fi 2445 2446 LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only ${MACOSX_DEFAULT_ARCH}" 2447 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)' 2448 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';; 2449esac 2450AC_MSG_CHECKING(for --enable-framework) 2451if test "$enable_framework" 2452then 2453 BASECFLAGS="$BASECFLAGS -fno-common -dynamic" 2454 # -F. is needed to allow linking to the framework while 2455 # in the build location. 2456 AC_DEFINE(WITH_NEXT_FRAMEWORK, 1, 2457 [Define if you want to produce an OpenStep/Rhapsody framework 2458 (shared library plus accessory files).]) 2459 AC_MSG_RESULT(yes) 2460 if test $enable_shared = "yes" 2461 then 2462 AC_MSG_ERROR([Specifying both --enable-shared and --enable-framework is not supported, use only --enable-framework instead]) 2463 fi 2464else 2465 AC_MSG_RESULT(no) 2466fi 2467 2468AC_MSG_CHECKING(for dyld) 2469case $ac_sys_system/$ac_sys_release in 2470 Darwin/*) 2471 AC_DEFINE(WITH_DYLD, 1, 2472 [Define if you want to use the new-style (Openstep, Rhapsody, MacOS) 2473 dynamic linker (dyld) instead of the old-style (NextStep) dynamic 2474 linker (rld). Dyld is necessary to support frameworks.]) 2475 AC_MSG_RESULT(always on for Darwin) 2476 ;; 2477 *) 2478 AC_MSG_RESULT(no) 2479 ;; 2480esac 2481 2482# Set info about shared libraries. 2483AC_SUBST(SHLIB_SUFFIX) 2484AC_SUBST(LDSHARED) 2485AC_SUBST(LDCXXSHARED) 2486AC_SUBST(BLDSHARED) 2487AC_SUBST(CCSHARED) 2488AC_SUBST(LINKFORSHARED) 2489 2490# SHLIB_SUFFIX is the extension of shared libraries `(including the dot!) 2491# -- usually .so, .sl on HP-UX, .dll on Cygwin 2492AC_MSG_CHECKING(the extension of shared libraries) 2493if test -z "$SHLIB_SUFFIX"; then 2494 case $ac_sys_system in 2495 hp*|HP*) 2496 case `uname -m` in 2497 ia64) SHLIB_SUFFIX=.so;; 2498 *) SHLIB_SUFFIX=.sl;; 2499 esac 2500 ;; 2501 CYGWIN*) SHLIB_SUFFIX=.dll;; 2502 *) SHLIB_SUFFIX=.so;; 2503 esac 2504fi 2505AC_MSG_RESULT($SHLIB_SUFFIX) 2506 2507# LDSHARED is the ld *command* used to create shared library 2508# -- "cc -G" on SunOS 5.x. 2509# (Shared libraries in this instance are shared modules to be loaded into 2510# Python, as opposed to building Python itself as a shared library.) 2511AC_MSG_CHECKING(LDSHARED) 2512if test -z "$LDSHARED" 2513then 2514 case $ac_sys_system/$ac_sys_release in 2515 AIX*) 2516 BLDSHARED="Modules/ld_so_aix \$(CC) -bI:Modules/python.exp" 2517 LDSHARED="\$(LIBPL)/ld_so_aix \$(CC) -bI:\$(LIBPL)/python.exp" 2518 ;; 2519 SunOS/5*) 2520 if test "$GCC" = "yes" ; then 2521 LDSHARED='$(CC) -shared' 2522 LDCXXSHARED='$(CXX) -shared' 2523 else 2524 LDSHARED='$(CC) -G' 2525 LDCXXSHARED='$(CXX) -G' 2526 fi ;; 2527 hp*|HP*) 2528 if test "$GCC" = "yes" ; then 2529 LDSHARED='$(CC) -shared' 2530 LDCXXSHARED='$(CXX) -shared' 2531 else 2532 LDSHARED='$(CC) -b' 2533 LDCXXSHARED='$(CXX) -b' 2534 fi ;; 2535 Darwin/1.3*) 2536 LDSHARED='$(CC) -bundle' 2537 LDCXXSHARED='$(CXX) -bundle' 2538 if test "$enable_framework" ; then 2539 # Link against the framework. All externals should be defined. 2540 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)' 2541 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)' 2542 LDCXXSHARED="$LDCXXSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)' 2543 else 2544 # No framework. Ignore undefined symbols, assuming they come from Python 2545 LDSHARED="$LDSHARED -undefined suppress" 2546 LDCXXSHARED="$LDCXXSHARED -undefined suppress" 2547 fi ;; 2548 Darwin/1.4*|Darwin/5.*|Darwin/6.*) 2549 LDSHARED='$(CC) -bundle' 2550 LDCXXSHARED='$(CXX) -bundle' 2551 if test "$enable_framework" ; then 2552 # Link against the framework. All externals should be defined. 2553 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)' 2554 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)' 2555 LDCXXSHARED="$LDCXXSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)' 2556 else 2557 # No framework, use the Python app as bundle-loader 2558 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)' 2559 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)' 2560 LDCXXSHARED="$LDCXXSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)' 2561 fi ;; 2562 Darwin/*) 2563 # Use -undefined dynamic_lookup whenever possible (10.3 and later). 2564 # This allows an extension to be used in any Python 2565 2566 dep_target_major=`echo ${MACOSX_DEPLOYMENT_TARGET} | \ 2567 sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\1/'` 2568 dep_target_minor=`echo ${MACOSX_DEPLOYMENT_TARGET} | \ 2569 sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\2/'` 2570 if test ${dep_target_major} -eq 10 && \ 2571 test ${dep_target_minor} -le 2 2572 then 2573 # building for OS X 10.0 through 10.2 2574 LDSHARED='$(CC) -bundle' 2575 LDCXXSHARED='$(CXX) -bundle' 2576 if test "$enable_framework" ; then 2577 # Link against the framework. All externals should be defined. 2578 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)' 2579 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)' 2580 LDCXXSHARED="$LDCXXSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)' 2581 else 2582 # No framework, use the Python app as bundle-loader 2583 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)' 2584 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)' 2585 LDCXXSHARED="$LDCXXSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)' 2586 fi 2587 else 2588 # building for OS X 10.3 and later 2589 LDSHARED='$(CC) -bundle -undefined dynamic_lookup' 2590 LDCXXSHARED='$(CXX) -bundle -undefined dynamic_lookup' 2591 BLDSHARED="$LDSHARED" 2592 fi 2593 ;; 2594 Linux*|GNU*|QNX*|VxWorks*) 2595 LDSHARED='$(CC) -shared' 2596 LDCXXSHARED='$(CXX) -shared';; 2597 FreeBSD*) 2598 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]] 2599 then 2600 LDSHARED='$(CC) -shared' 2601 LDCXXSHARED='$(CXX) -shared' 2602 else 2603 LDSHARED="ld -Bshareable" 2604 fi;; 2605 OpenBSD*) 2606 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]] 2607 then 2608 LDSHARED='$(CC) -shared $(CCSHARED)' 2609 LDCXXSHARED='$(CXX) -shared $(CCSHARED)' 2610 else 2611 case `uname -r` in 2612 [[01]].* | 2.[[0-7]] | 2.[[0-7]].*) 2613 LDSHARED="ld -Bshareable ${LDFLAGS}" 2614 ;; 2615 *) 2616 LDSHARED='$(CC) -shared $(CCSHARED)' 2617 LDCXXSHARED='$(CXX) -shared $(CCSHARED)' 2618 ;; 2619 esac 2620 fi;; 2621 NetBSD*|DragonFly*) 2622 LDSHARED='$(CC) -shared' 2623 LDCXXSHARED='$(CXX) -shared';; 2624 OpenUNIX*|UnixWare*) 2625 if test "$GCC" = "yes" ; then 2626 LDSHARED='$(CC) -shared' 2627 LDCXXSHARED='$(CXX) -shared' 2628 else 2629 LDSHARED='$(CC) -G' 2630 LDCXXSHARED='$(CXX) -G' 2631 fi;; 2632 SCO_SV*) 2633 LDSHARED='$(CC) -Wl,-G,-Bexport' 2634 LDCXXSHARED='$(CXX) -Wl,-G,-Bexport';; 2635 CYGWIN*) 2636 LDSHARED="gcc -shared -Wl,--enable-auto-image-base" 2637 LDCXXSHARED="g++ -shared -Wl,--enable-auto-image-base";; 2638 *) LDSHARED="ld";; 2639 esac 2640fi 2641AC_MSG_RESULT($LDSHARED) 2642LDCXXSHARED=${LDCXXSHARED-$LDSHARED} 2643BLDSHARED=${BLDSHARED-$LDSHARED} 2644# CCSHARED are the C *flags* used to create objects to go into a shared 2645# library (module) -- this is only needed for a few systems 2646AC_MSG_CHECKING(CCSHARED) 2647if test -z "$CCSHARED" 2648then 2649 case $ac_sys_system/$ac_sys_release in 2650 SunOS*) if test "$GCC" = yes; 2651 then CCSHARED="-fPIC"; 2652 elif test `uname -p` = sparc; 2653 then CCSHARED="-xcode=pic32"; 2654 else CCSHARED="-Kpic"; 2655 fi;; 2656 hp*|HP*) if test "$GCC" = yes; 2657 then CCSHARED="-fPIC"; 2658 else CCSHARED="+z"; 2659 fi;; 2660 Linux-android*) ;; 2661 Linux*|GNU*) CCSHARED="-fPIC";; 2662 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";; 2663 OpenUNIX*|UnixWare*) 2664 if test "$GCC" = "yes" 2665 then CCSHARED="-fPIC" 2666 else CCSHARED="-KPIC" 2667 fi;; 2668 SCO_SV*) 2669 if test "$GCC" = "yes" 2670 then CCSHARED="-fPIC" 2671 else CCSHARED="-Kpic -belf" 2672 fi;; 2673 VxWorks*) 2674 CCSHARED="-fpic -D__SO_PICABILINUX__ -ftls-model=global-dynamic" 2675 esac 2676fi 2677AC_MSG_RESULT($CCSHARED) 2678# LINKFORSHARED are the flags passed to the $(CC) command that links 2679# the python executable -- this is only needed for a few systems 2680AC_MSG_CHECKING(LINKFORSHARED) 2681if test -z "$LINKFORSHARED" 2682then 2683 case $ac_sys_system/$ac_sys_release in 2684 AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';; 2685 hp*|HP*) 2686 LINKFORSHARED="-Wl,-E -Wl,+s";; 2687# LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";; 2688 Linux-android*) LINKFORSHARED="-pie -Xlinker -export-dynamic";; 2689 Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";; 2690 # -u libsys_s pulls in all symbols in libsys 2691 Darwin/*) 2692 LINKFORSHARED="$extra_undefs -framework CoreFoundation" 2693 2694 # Issue #18075: the default maximum stack size (8MBytes) is too 2695 # small for the default recursion limit. Increase the stack size 2696 # to ensure that tests don't crash 2697 # Note: This matches the value of THREAD_STACK_SIZE in 2698 # thread_pthread.h 2699 LINKFORSHARED="-Wl,-stack_size,1000000 $LINKFORSHARED" 2700 2701 if test "$enable_framework" 2702 then 2703 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)' 2704 fi 2705 LINKFORSHARED="$LINKFORSHARED";; 2706 OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";; 2707 SCO_SV*) LINKFORSHARED="-Wl,-Bexport";; 2708 ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";; 2709 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) 2710 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]] 2711 then 2712 LINKFORSHARED="-Wl,--export-dynamic" 2713 fi;; 2714 SunOS/5*) case $CC in 2715 *gcc*) 2716 if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null 2717 then 2718 LINKFORSHARED="-Xlinker --export-dynamic" 2719 fi;; 2720 esac;; 2721 CYGWIN*) 2722 if test $enable_shared = "no" 2723 then 2724 LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)' 2725 fi;; 2726 QNX*) 2727 # -Wl,-E causes the symbols to be added to the dynamic 2728 # symbol table so that they can be found when a module 2729 # is loaded. -N 2048K causes the stack size to be set 2730 # to 2048 kilobytes so that the stack doesn't overflow 2731 # when running test_compile.py. 2732 LINKFORSHARED='-Wl,-E -N 2048K';; 2733 VxWorks*) 2734 LINKFORSHARED='--export-dynamic';; 2735 esac 2736fi 2737AC_MSG_RESULT($LINKFORSHARED) 2738 2739 2740AC_SUBST(CFLAGSFORSHARED) 2741AC_MSG_CHECKING(CFLAGSFORSHARED) 2742if test ! "$LIBRARY" = "$LDLIBRARY" 2743then 2744 case $ac_sys_system in 2745 CYGWIN*) 2746 # Cygwin needs CCSHARED when building extension DLLs 2747 # but not when building the interpreter DLL. 2748 CFLAGSFORSHARED='';; 2749 *) 2750 CFLAGSFORSHARED='$(CCSHARED)' 2751 esac 2752fi 2753AC_MSG_RESULT($CFLAGSFORSHARED) 2754 2755# SHLIBS are libraries (except -lc and -lm) to link to the python shared 2756# library (with --enable-shared). 2757# For platforms on which shared libraries are not allowed to have unresolved 2758# symbols, this must be set to $(LIBS) (expanded by make). We do this even 2759# if it is not required, since it creates a dependency of the shared library 2760# to LIBS. This, in turn, means that applications linking the shared libpython 2761# don't need to link LIBS explicitly. The default should be only changed 2762# on systems where this approach causes problems. 2763AC_SUBST(SHLIBS) 2764AC_MSG_CHECKING(SHLIBS) 2765case "$ac_sys_system" in 2766 *) 2767 SHLIBS='$(LIBS)';; 2768esac 2769AC_MSG_RESULT($SHLIBS) 2770 2771 2772# checks for libraries 2773AC_CHECK_LIB(sendfile, sendfile) 2774AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV 2775AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX 2776 2777# checks for uuid.h location 2778AC_CHECK_HEADERS([uuid/uuid.h uuid.h]) 2779 2780AC_MSG_CHECKING(for uuid_generate_time_safe) 2781AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <uuid/uuid.h>]], [[ 2782#ifndef uuid_generate_time_safe 2783void *x = uuid_generate_time_safe 2784#endif 2785]])], 2786 [AC_DEFINE(HAVE_UUID_GENERATE_TIME_SAFE, 1, Define if uuid_generate_time_safe() exists.) 2787 AC_MSG_RESULT(yes)], 2788 [AC_MSG_RESULT(no)] 2789) 2790 2791# AIX provides support for RFC4122 (uuid) in libc.a starting with AIX 6.1 (anno 2007) 2792# FreeBSD and OpenBSD provides support as well 2793AC_MSG_CHECKING(for uuid_create) 2794AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <uuid.h>]], [[ 2795#ifndef uuid_create 2796void *x = uuid_create 2797#endif 2798]])], 2799 [AC_DEFINE(HAVE_UUID_CREATE, 1, Define if uuid_create() exists.) 2800 AC_MSG_RESULT(yes)], 2801 [AC_MSG_RESULT(no)] 2802) 2803 2804# Little-endian FreeBSD, OpenBSD and NetBSD needs encoding into an octet 2805# stream in big-endian byte-order 2806AC_MSG_CHECKING(for uuid_enc_be) 2807AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <uuid.h>]], [[ 2808#ifndef uuid_enc_be 2809void *x = uuid_enc_be 2810#endif 2811]])], 2812 [AC_DEFINE(HAVE_UUID_ENC_BE, 1, Define if uuid_enc_be() exists.) 2813 AC_MSG_RESULT(yes)], 2814 [AC_MSG_RESULT(no)] 2815) 2816 2817# 'Real Time' functions on Solaris 2818# posix4 on Solaris 2.6 2819# pthread (first!) on Linux 2820AC_SEARCH_LIBS(sem_init, pthread rt posix4) 2821 2822# check if we need libintl for locale functions 2823AC_CHECK_LIB(intl, textdomain, 2824 [AC_DEFINE(WITH_LIBINTL, 1, 2825 [Define to 1 if libintl is needed for locale functions.]) 2826 LIBS="-lintl $LIBS"]) 2827 2828# checks for system dependent C++ extensions support 2829case "$ac_sys_system" in 2830 AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support) 2831 AC_LINK_IFELSE([ 2832 AC_LANG_PROGRAM([[#include <load.h>]], 2833 [[loadAndInit("", 0, "")]]) 2834 ],[ 2835 AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1, 2836 [Define for AIX if your compiler is a genuine IBM xlC/xlC_r 2837 and you want support for AIX C++ shared extension modules.]) 2838 AC_MSG_RESULT(yes) 2839 ],[ 2840 AC_MSG_RESULT(no) 2841 ]);; 2842 *) ;; 2843esac 2844 2845# check for systems that require aligned memory access 2846AC_MSG_CHECKING(aligned memory access is required) 2847AC_CACHE_VAL(ac_cv_aligned_required, 2848[AC_RUN_IFELSE([AC_LANG_SOURCE([[ 2849int main() 2850{ 2851 char s[16]; 2852 int i, *p1, *p2; 2853 for (i=0; i < 16; i++) 2854 s[i] = i; 2855 p1 = (int*)(s+1); 2856 p2 = (int*)(s+2); 2857 if (*p1 == *p2) 2858 return 1; 2859 return 0; 2860}]])], 2861[ac_cv_aligned_required=no], 2862[ac_cv_aligned_required=yes], 2863[ac_cv_aligned_required=yes]) 2864]) 2865AC_MSG_RESULT($ac_cv_aligned_required) 2866if test "$ac_cv_aligned_required" = yes ; then 2867 AC_DEFINE([HAVE_ALIGNED_REQUIRED], [1], 2868 [Define if aligned memory access is required]) 2869fi 2870 2871# str, bytes and memoryview hash algorithm 2872AH_TEMPLATE(Py_HASH_ALGORITHM, 2873 [Define hash algorithm for str, bytes and memoryview. 2874 SipHash24: 1, FNV: 2, externally defined: 0]) 2875 2876AC_MSG_CHECKING(for --with-hash-algorithm) 2877dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output 2878AC_ARG_WITH(hash_algorithm, 2879 AS_HELP_STRING([--with-hash-algorithm=@<:@fnv|siphash24@:>@], 2880 [select hash algorithm]), 2881[ 2882AC_MSG_RESULT($withval) 2883case "$withval" in 2884 siphash24) 2885 AC_DEFINE(Py_HASH_ALGORITHM, 1) 2886 ;; 2887 fnv) 2888 AC_DEFINE(Py_HASH_ALGORITHM, 2) 2889 ;; 2890 *) 2891 AC_MSG_ERROR([unknown hash algorithm '$withval']) 2892 ;; 2893esac 2894], 2895[AC_MSG_RESULT(default)]) 2896 2897AC_MSG_CHECKING(for --with-address-sanitizer) 2898AC_ARG_WITH(address_sanitizer, 2899 AS_HELP_STRING([--with-address-sanitizer], 2900 [enable AddressSanitizer (asan)]), 2901[ 2902AC_MSG_RESULT($withval) 2903BASECFLAGS="-fsanitize=address -fno-omit-frame-pointer $BASECFLAGS" 2904LDFLAGS="-fsanitize=address $LDFLAGS" 2905# ASan works by controlling memory allocation, our own malloc interferes. 2906with_pymalloc="no" 2907], 2908[AC_MSG_RESULT(no)]) 2909 2910AC_MSG_CHECKING(for --with-memory-sanitizer) 2911AC_ARG_WITH(memory_sanitizer, 2912 AS_HELP_STRING([--with-memory-sanitizer], 2913 [enable MemorySanitizer (msan)]), 2914[ 2915AC_MSG_RESULT($withval) 2916BASECFLAGS="-fsanitize=memory -fsanitize-memory-track-origins=2 -fno-omit-frame-pointer $BASECFLAGS" 2917LDFLAGS="-fsanitize=memory -fsanitize-memory-track-origins=2 $LDFLAGS" 2918# MSan works by controlling memory allocation, our own malloc interferes. 2919with_pymalloc="no" 2920], 2921[AC_MSG_RESULT(no)]) 2922 2923AC_MSG_CHECKING(for --with-undefined-behavior-sanitizer) 2924AC_ARG_WITH(undefined_behavior_sanitizer, 2925 AS_HELP_STRING([--with-undefined-behavior-sanitizer], 2926 [enable UndefinedBehaviorSanitizer (ubsan)]), 2927[ 2928AC_MSG_RESULT($withval) 2929BASECFLAGS="-fsanitize=undefined $BASECFLAGS" 2930LDFLAGS="-fsanitize=undefined $LDFLAGS" 2931], 2932[AC_MSG_RESULT(no)]) 2933 2934# Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl. 2935AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4 2936AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets 2937 2938AC_MSG_CHECKING(for --with-libs) 2939AC_ARG_WITH(libs, 2940 AS_HELP_STRING([--with-libs='lib1 ...'], [link against additional libs]), 2941[ 2942AC_MSG_RESULT($withval) 2943LIBS="$withval $LIBS" 2944], 2945[AC_MSG_RESULT(no)]) 2946 2947PKG_PROG_PKG_CONFIG 2948 2949# Check for use of the system expat library 2950AC_MSG_CHECKING(for --with-system-expat) 2951AC_ARG_WITH(system_expat, 2952 AS_HELP_STRING([--with-system-expat], [build pyexpat module using an installed expat library]), 2953 [], 2954 [with_system_expat="no"]) 2955 2956AC_MSG_RESULT($with_system_expat) 2957 2958# Check for use of the system libffi library 2959AC_MSG_CHECKING(for --with-system-ffi) 2960AC_ARG_WITH(system_ffi, 2961 AS_HELP_STRING([--with-system-ffi], [build _ctypes module using an installed ffi library]),,,) 2962 2963if test "$ac_sys_system" = "Darwin" 2964then 2965 case "$with_system_ffi" in 2966 "") 2967 with_system_ffi="no" 2968 ;; 2969 yes|no) 2970 ;; 2971 *) 2972 AC_MSG_ERROR([--with-system-ffi accepts no arguments]) 2973 ;; 2974 esac 2975 AC_MSG_RESULT($with_system_ffi) 2976else 2977 AC_MSG_RESULT(yes) 2978 if test "$with_system_ffi" != "" 2979 then 2980 AC_MSG_WARN([--with(out)-system-ffi is ignored on this platform]) 2981 fi 2982 with_system_ffi="yes" 2983fi 2984 2985if test "$with_system_ffi" = "yes" && test -n "$PKG_CONFIG"; then 2986 LIBFFI_INCLUDEDIR="`"$PKG_CONFIG" libffi --cflags-only-I 2>/dev/null | sed -e 's/^-I//;s/ *$//'`" 2987else 2988 LIBFFI_INCLUDEDIR="" 2989fi 2990AC_SUBST(LIBFFI_INCLUDEDIR) 2991 2992# Check for use of the system libmpdec library 2993AC_MSG_CHECKING(for --with-system-libmpdec) 2994AC_ARG_WITH(system_libmpdec, 2995 AS_HELP_STRING([--with-system-libmpdec], [build _decimal module using an installed libmpdec library]), 2996 [], 2997 [with_system_libmpdec="no"]) 2998 2999AC_MSG_RESULT($with_system_libmpdec) 3000 3001# Check for support for loadable sqlite extensions 3002AC_MSG_CHECKING(for --enable-loadable-sqlite-extensions) 3003AC_ARG_ENABLE(loadable-sqlite-extensions, 3004 AS_HELP_STRING([--enable-loadable-sqlite-extensions], [support loadable extensions in _sqlite module]), 3005 [], 3006 [enable_loadable_sqlite_extensions="no"]) 3007 3008AC_MSG_RESULT($enable_loadable_sqlite_extensions) 3009 3010# Check for --with-tcltk-includes=path and --with-tcltk-libs=path 3011AC_SUBST(TCLTK_INCLUDES) 3012AC_SUBST(TCLTK_LIBS) 3013AC_MSG_CHECKING(for --with-tcltk-includes) 3014AC_ARG_WITH(tcltk-includes, 3015 AS_HELP_STRING([--with-tcltk-includes='-I...'], [override search for Tcl and Tk include files]), 3016 [], 3017 [with_tcltk_includes="default"]) 3018AC_MSG_RESULT($with_tcltk_includes) 3019AC_MSG_CHECKING(for --with-tcltk-libs) 3020AC_ARG_WITH(tcltk-libs, 3021 AS_HELP_STRING([--with-tcltk-libs='-L...'], [override search for Tcl and Tk libs]), 3022 [], 3023 [with_tcltk_libs="default"]) 3024AC_MSG_RESULT($with_tcltk_libs) 3025if test "x$with_tcltk_includes" = xdefault || test "x$with_tcltk_libs" = xdefault 3026then 3027 if test "x$with_tcltk_includes" != "x$with_tcltk_libs" 3028 then 3029 AC_MSG_ERROR([use both --with-tcltk-includes='...' and --with-tcltk-libs='...' or neither]) 3030 fi 3031 TCLTK_INCLUDES="" 3032 TCLTK_LIBS="" 3033else 3034 TCLTK_INCLUDES="$with_tcltk_includes" 3035 TCLTK_LIBS="$with_tcltk_libs" 3036fi 3037 3038# Check for --with-dbmliborder 3039AC_MSG_CHECKING(for --with-dbmliborder) 3040AC_ARG_WITH(dbmliborder, 3041 AS_HELP_STRING([--with-dbmliborder=db1:db2:...], [order to check db backends for dbm. Valid value is a colon separated string with the backend names `ndbm', `gdbm' and `bdb'.]), 3042[ 3043if test x$with_dbmliborder = xyes 3044then 3045AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...]) 3046else 3047 for db in `echo $with_dbmliborder | sed 's/:/ /g'`; do 3048 if test x$db != xndbm && test x$db != xgdbm && test x$db != xbdb 3049 then 3050 AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...]) 3051 fi 3052 done 3053fi]) 3054AC_MSG_RESULT($with_dbmliborder) 3055 3056# Templates for things AC_DEFINEd more than once. 3057# For a single AC_DEFINE, no template is needed. 3058AH_TEMPLATE(_REENTRANT, 3059 [Define to force use of thread-safe errno, h_errno, and other functions]) 3060 3061if test "$ac_cv_pthread_is_default" = yes 3062then 3063 # Defining _REENTRANT on system with POSIX threads should not hurt. 3064 AC_DEFINE(_REENTRANT) 3065 posix_threads=yes 3066 if test "$ac_sys_system" = "SunOS"; then 3067 CFLAGS="$CFLAGS -D_REENTRANT" 3068 fi 3069elif test "$ac_cv_kpthread" = "yes" 3070then 3071 CC="$CC -Kpthread" 3072 if test "$ac_cv_cxx_thread" = "yes"; then 3073 CXX="$CXX -Kpthread" 3074 fi 3075 posix_threads=yes 3076elif test "$ac_cv_kthread" = "yes" 3077then 3078 CC="$CC -Kthread" 3079 if test "$ac_cv_cxx_thread" = "yes"; then 3080 CXX="$CXX -Kthread" 3081 fi 3082 posix_threads=yes 3083elif test "$ac_cv_pthread" = "yes" 3084then 3085 CC="$CC -pthread" 3086 if test "$ac_cv_cxx_thread" = "yes"; then 3087 CXX="$CXX -pthread" 3088 fi 3089 posix_threads=yes 3090else 3091 if test ! -z "$withval" -a -d "$withval" 3092 then LDFLAGS="$LDFLAGS -L$withval" 3093 fi 3094 3095 # According to the POSIX spec, a pthreads implementation must 3096 # define _POSIX_THREADS in unistd.h. Some apparently don't 3097 # (e.g. gnu pth with pthread emulation) 3098 AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h) 3099 AC_EGREP_CPP(yes, 3100 [ 3101#include <unistd.h> 3102#ifdef _POSIX_THREADS 3103yes 3104#endif 3105 ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no) 3106 AC_MSG_RESULT($unistd_defines_pthreads) 3107 3108 AC_DEFINE(_REENTRANT) 3109 # Just looking for pthread_create in libpthread is not enough: 3110 # on HP/UX, pthread.h renames pthread_create to a different symbol name. 3111 # So we really have to include pthread.h, and then link. 3112 _libs=$LIBS 3113 LIBS="$LIBS -lpthread" 3114 AC_MSG_CHECKING([for pthread_create in -lpthread]) 3115 AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 3116#include <stdio.h> 3117#include <pthread.h> 3118 3119void * start_routine (void *arg) { exit (0); }]], [[ 3120pthread_create (NULL, NULL, start_routine, NULL)]])],[ 3121 AC_MSG_RESULT(yes) 3122 posix_threads=yes 3123 ],[ 3124 LIBS=$_libs 3125 AC_CHECK_FUNC(pthread_detach, [ 3126 posix_threads=yes 3127 ],[ 3128 AC_CHECK_LIB(pthreads, pthread_create, [ 3129 posix_threads=yes 3130 LIBS="$LIBS -lpthreads" 3131 ], [ 3132 AC_CHECK_LIB(c_r, pthread_create, [ 3133 posix_threads=yes 3134 LIBS="$LIBS -lc_r" 3135 ], [ 3136 AC_CHECK_LIB(pthread, __pthread_create_system, [ 3137 posix_threads=yes 3138 LIBS="$LIBS -lpthread" 3139 ], [ 3140 AC_CHECK_LIB(cma, pthread_create, [ 3141 posix_threads=yes 3142 LIBS="$LIBS -lcma" 3143 ],[ 3144 AC_MSG_ERROR([could not find pthreads on your system]) 3145 ]) 3146 ])])])])]) 3147 3148 AC_CHECK_LIB(mpc, usconfig, [ 3149 LIBS="$LIBS -lmpc" 3150 ]) 3151 3152fi 3153 3154if test "$posix_threads" = "yes"; then 3155 if test "$unistd_defines_pthreads" = "no"; then 3156 AC_DEFINE(_POSIX_THREADS, 1, 3157 [Define if you have POSIX threads, 3158 and your system does not define that.]) 3159 fi 3160 3161 # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8. 3162 case $ac_sys_system/$ac_sys_release in 3163 SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1, 3164 [Defined for Solaris 2.6 bug in pthread header.]) 3165 ;; 3166 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1, 3167 [Define if the Posix semaphores do not work on your system]) 3168 ;; 3169 AIX/*) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1, 3170 [Define if the Posix semaphores do not work on your system]) 3171 ;; 3172 esac 3173 3174 AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported) 3175 AC_CACHE_VAL(ac_cv_pthread_system_supported, 3176 [AC_RUN_IFELSE([AC_LANG_SOURCE([[ 3177 #include <stdio.h> 3178 #include <pthread.h> 3179 void *foo(void *parm) { 3180 return NULL; 3181 } 3182 main() { 3183 pthread_attr_t attr; 3184 pthread_t id; 3185 if (pthread_attr_init(&attr)) exit(-1); 3186 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1); 3187 if (pthread_create(&id, &attr, foo, NULL)) exit(-1); 3188 exit(0); 3189 }]])], 3190 [ac_cv_pthread_system_supported=yes], 3191 [ac_cv_pthread_system_supported=no], 3192 [ac_cv_pthread_system_supported=no]) 3193 ]) 3194 AC_MSG_RESULT($ac_cv_pthread_system_supported) 3195 if test "$ac_cv_pthread_system_supported" = "yes"; then 3196 AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.]) 3197 fi 3198 AC_CHECK_FUNCS(pthread_sigmask, 3199 [case $ac_sys_system in 3200 CYGWIN*) 3201 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1, 3202 [Define if pthread_sigmask() does not work on your system.]) 3203 ;; 3204 esac]) 3205 AC_CHECK_FUNCS(pthread_getcpuclockid) 3206fi 3207 3208 3209# Check for enable-ipv6 3210AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified]) 3211AC_MSG_CHECKING([if --enable-ipv6 is specified]) 3212AC_ARG_ENABLE(ipv6, 3213[ --enable-ipv6 Enable ipv6 (with ipv4) support 3214 --disable-ipv6 Disable ipv6 support], 3215[ case "$enableval" in 3216 no) 3217 AC_MSG_RESULT(no) 3218 ipv6=no 3219 ;; 3220 *) AC_MSG_RESULT(yes) 3221 AC_DEFINE(ENABLE_IPV6) 3222 ipv6=yes 3223 ;; 3224 esac ], 3225 3226[ 3227dnl the check does not work on cross compilation case... 3228 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ /* AF_INET6 available check */ 3229#include <sys/types.h> 3230#include <sys/socket.h>]], 3231[[int domain = AF_INET6;]])],[ 3232 AC_MSG_RESULT(yes) 3233 ipv6=yes 3234],[ 3235 AC_MSG_RESULT(no) 3236 ipv6=no 3237]) 3238 3239if test "$ipv6" = "yes"; then 3240 AC_MSG_CHECKING(if RFC2553 API is available) 3241 AC_COMPILE_IFELSE([ 3242 AC_LANG_PROGRAM([[#include <sys/types.h> 3243#include <netinet/in.h>]], 3244 [[struct sockaddr_in6 x; 3245 x.sin6_scope_id;]]) 3246 ],[ 3247 AC_MSG_RESULT(yes) 3248 ipv6=yes 3249 ],[ 3250 AC_MSG_RESULT(no, IPv6 disabled) 3251 ipv6=no 3252 ]) 3253fi 3254 3255if test "$ipv6" = "yes"; then 3256 AC_DEFINE(ENABLE_IPV6) 3257fi 3258]) 3259 3260ipv6type=unknown 3261ipv6lib=none 3262ipv6trylibc=no 3263 3264if test "$ipv6" = "yes"; then 3265 AC_MSG_CHECKING([ipv6 stack type]) 3266 for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta; 3267 do 3268 case $i in 3269 inria) 3270 dnl http://www.kame.net/ 3271 AC_EGREP_CPP(yes, [ 3272#include <netinet/in.h> 3273#ifdef IPV6_INRIA_VERSION 3274yes 3275#endif], 3276 [ipv6type=$i]) 3277 ;; 3278 kame) 3279 dnl http://www.kame.net/ 3280 AC_EGREP_CPP(yes, [ 3281#include <netinet/in.h> 3282#ifdef __KAME__ 3283yes 3284#endif], 3285 [ipv6type=$i; 3286 ipv6lib=inet6 3287 ipv6libdir=/usr/local/v6/lib 3288 ipv6trylibc=yes]) 3289 ;; 3290 linux-glibc) 3291 dnl http://www.v6.linux.or.jp/ 3292 AC_EGREP_CPP(yes, [ 3293#include <features.h> 3294#if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2)) 3295yes 3296#endif], 3297 [ipv6type=$i; 3298 ipv6trylibc=yes]) 3299 ;; 3300 linux-inet6) 3301 dnl http://www.v6.linux.or.jp/ 3302 if test -d /usr/inet6; then 3303 ipv6type=$i 3304 ipv6lib=inet6 3305 ipv6libdir=/usr/inet6/lib 3306 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS" 3307 fi 3308 ;; 3309 solaris) 3310 if test -f /etc/netconfig; then 3311 if $GREP -q tcp6 /etc/netconfig; then 3312 ipv6type=$i 3313 ipv6trylibc=yes 3314 fi 3315 fi 3316 ;; 3317 toshiba) 3318 AC_EGREP_CPP(yes, [ 3319#include <sys/param.h> 3320#ifdef _TOSHIBA_INET6 3321yes 3322#endif], 3323 [ipv6type=$i; 3324 ipv6lib=inet6; 3325 ipv6libdir=/usr/local/v6/lib]) 3326 ;; 3327 v6d) 3328 AC_EGREP_CPP(yes, [ 3329#include </usr/local/v6/include/sys/v6config.h> 3330#ifdef __V6D__ 3331yes 3332#endif], 3333 [ipv6type=$i; 3334 ipv6lib=v6; 3335 ipv6libdir=/usr/local/v6/lib; 3336 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"]) 3337 ;; 3338 zeta) 3339 AC_EGREP_CPP(yes, [ 3340#include <sys/param.h> 3341#ifdef _ZETA_MINAMI_INET6 3342yes 3343#endif], 3344 [ipv6type=$i; 3345 ipv6lib=inet6; 3346 ipv6libdir=/usr/local/v6/lib]) 3347 ;; 3348 esac 3349 if test "$ipv6type" != "unknown"; then 3350 break 3351 fi 3352 done 3353 AC_MSG_RESULT($ipv6type) 3354fi 3355 3356if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then 3357 if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then 3358 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS" 3359 echo "using lib$ipv6lib" 3360 else 3361 if test $ipv6trylibc = "yes"; then 3362 echo "using libc" 3363 else 3364 echo 'Fatal: no $ipv6lib library found. cannot continue.' 3365 echo "You need to fetch lib$ipv6lib.a from appropriate" 3366 echo 'ipv6 kit and compile beforehand.' 3367 exit 1 3368 fi 3369 fi 3370fi 3371 3372AC_MSG_CHECKING(for CAN_RAW_FD_FRAMES) 3373AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ /* CAN_RAW_FD_FRAMES available check */ 3374#include <linux/can/raw.h>]], 3375[[int can_raw_fd_frames = CAN_RAW_FD_FRAMES;]])],[ 3376 AC_DEFINE(HAVE_LINUX_CAN_RAW_FD_FRAMES, 1, [Define if compiling using Linux 3.6 or later.]) 3377 AC_MSG_RESULT(yes) 3378],[ 3379 AC_MSG_RESULT(no) 3380]) 3381 3382# Check for --with-doc-strings 3383AC_MSG_CHECKING(for --with-doc-strings) 3384AC_ARG_WITH(doc-strings, 3385 AS_HELP_STRING([--with(out)-doc-strings], [disable/enable documentation strings])) 3386 3387if test -z "$with_doc_strings" 3388then with_doc_strings="yes" 3389fi 3390if test "$with_doc_strings" != "no" 3391then 3392 AC_DEFINE(WITH_DOC_STRINGS, 1, 3393 [Define if you want documentation strings in extension modules]) 3394fi 3395AC_MSG_RESULT($with_doc_strings) 3396 3397# Check for Python-specific malloc support 3398AC_MSG_CHECKING(for --with-pymalloc) 3399AC_ARG_WITH(pymalloc, 3400 AS_HELP_STRING([--with(out)-pymalloc], [disable/enable specialized mallocs])) 3401 3402if test -z "$with_pymalloc" 3403then 3404 with_pymalloc="yes" 3405fi 3406if test "$with_pymalloc" != "no" 3407then 3408 AC_DEFINE(WITH_PYMALLOC, 1, 3409 [Define if you want to compile in Python-specific mallocs]) 3410fi 3411AC_MSG_RESULT($with_pymalloc) 3412 3413# Check for --with-c-locale-coercion 3414AC_MSG_CHECKING(for --with-c-locale-coercion) 3415AC_ARG_WITH(c-locale-coercion, 3416 AS_HELP_STRING([--with(out)-c-locale-coercion], 3417 [disable/enable C locale coercion to a UTF-8 based locale])) 3418 3419if test -z "$with_c_locale_coercion" 3420then 3421 with_c_locale_coercion="yes" 3422fi 3423if test "$with_c_locale_coercion" != "no" 3424then 3425 AC_DEFINE(PY_COERCE_C_LOCALE, 1, 3426 [Define if you want to coerce the C locale to a UTF-8 based locale]) 3427fi 3428AC_MSG_RESULT($with_c_locale_coercion) 3429 3430# Check for Valgrind support 3431AC_MSG_CHECKING([for --with-valgrind]) 3432AC_ARG_WITH([valgrind], 3433 AS_HELP_STRING([--with-valgrind], [Enable Valgrind support]),, 3434 with_valgrind=no) 3435AC_MSG_RESULT([$with_valgrind]) 3436if test "$with_valgrind" != no; then 3437 AC_CHECK_HEADER([valgrind/valgrind.h], 3438 [AC_DEFINE([WITH_VALGRIND], 1, [Define if you want pymalloc to be disabled when running under valgrind])], 3439 [AC_MSG_ERROR([Valgrind support requested but headers not available])] 3440 ) 3441 OPT="-DDYNAMIC_ANNOTATIONS_ENABLED=1 $OPT" 3442fi 3443 3444# Check for DTrace support 3445AC_MSG_CHECKING(for --with-dtrace) 3446AC_ARG_WITH(dtrace, 3447 AS_HELP_STRING([--with(out)-dtrace],[disable/enable DTrace support]),, 3448 with_dtrace=no) 3449AC_MSG_RESULT($with_dtrace) 3450 3451AC_SUBST(DTRACE) 3452AC_SUBST(DFLAGS) 3453AC_SUBST(DTRACE_HEADERS) 3454AC_SUBST(DTRACE_OBJS) 3455DTRACE= 3456DFLAGS= 3457DTRACE_HEADERS= 3458DTRACE_OBJS= 3459 3460if test "$with_dtrace" = "yes" 3461then 3462 AC_PATH_PROG(DTRACE, [dtrace], [not found]) 3463 if test "$DTRACE" = "not found"; then 3464 AC_MSG_ERROR([dtrace command not found on \$PATH]) 3465 fi 3466 AC_DEFINE(WITH_DTRACE, 1, [Define if you want to compile in DTrace support]) 3467 DTRACE_HEADERS="Include/pydtrace_probes.h" 3468 3469 # On OS X, DTrace providers do not need to be explicitly compiled and 3470 # linked into the binary. Correspondingly, dtrace(1) is missing the ELF 3471 # generation flag '-G'. We check for presence of this flag, rather than 3472 # hardcoding support by OS, in the interest of robustness. 3473 AC_CACHE_CHECK([whether DTrace probes require linking], 3474 [ac_cv_dtrace_link], [dnl 3475 ac_cv_dtrace_link=no 3476 echo 'BEGIN{}' > conftest.d 3477 "$DTRACE" -G -s conftest.d -o conftest.o > /dev/null 2>&1 && \ 3478 ac_cv_dtrace_link=yes 3479 ]) 3480 if test "$ac_cv_dtrace_link" = "yes"; then 3481 DTRACE_OBJS="Python/pydtrace.o" 3482 fi 3483fi 3484 3485# -I${DLINCLDIR} is added to the compile rule for importdl.o 3486AC_SUBST(DLINCLDIR) 3487DLINCLDIR=. 3488 3489# the dlopen() function means we might want to use dynload_shlib.o. some 3490# platforms, such as AIX, have dlopen(), but don't want to use it. 3491AC_CHECK_FUNCS(dlopen) 3492 3493# DYNLOADFILE specifies which dynload_*.o file we will use for dynamic 3494# loading of modules. 3495AC_SUBST(DYNLOADFILE) 3496AC_MSG_CHECKING(DYNLOADFILE) 3497if test -z "$DYNLOADFILE" 3498then 3499 case $ac_sys_system/$ac_sys_release in 3500 AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c 3501 if test "$ac_cv_func_dlopen" = yes 3502 then DYNLOADFILE="dynload_shlib.o" 3503 else DYNLOADFILE="dynload_aix.o" 3504 fi 3505 ;; 3506 hp*|HP*) DYNLOADFILE="dynload_hpux.o";; 3507 *) 3508 # use dynload_shlib.c and dlopen() if we have it; otherwise stub 3509 # out any dynamic loading 3510 if test "$ac_cv_func_dlopen" = yes 3511 then DYNLOADFILE="dynload_shlib.o" 3512 else DYNLOADFILE="dynload_stub.o" 3513 fi 3514 ;; 3515 esac 3516fi 3517AC_MSG_RESULT($DYNLOADFILE) 3518if test "$DYNLOADFILE" != "dynload_stub.o" 3519then 3520 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1, 3521 [Defined when any dynamic module loading is enabled.]) 3522fi 3523 3524# MACHDEP_OBJS can be set to platform-specific object files needed by Python 3525 3526AC_SUBST(MACHDEP_OBJS) 3527AC_MSG_CHECKING(MACHDEP_OBJS) 3528if test -z "$MACHDEP_OBJS" 3529then 3530 MACHDEP_OBJS=$extra_machdep_objs 3531else 3532 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs" 3533fi 3534if test -z "$MACHDEP_OBJS"; then 3535 AC_MSG_RESULT([none]) 3536else 3537 AC_MSG_RESULT([$MACHDEP_OBJS]) 3538fi 3539 3540# checks for library functions 3541AC_CHECK_FUNCS(alarm accept4 setitimer getitimer bind_textdomain_codeset chown \ 3542 clock confstr copy_file_range ctermid dup3 execv explicit_bzero explicit_memset \ 3543 faccessat fchmod fchmodat fchown fchownat \ 3544 fdwalk fexecve fdopendir fork fpathconf fstatat ftime ftruncate futimesat \ 3545 futimens futimes gai_strerror getentropy \ 3546 getgrgid_r getgrnam_r \ 3547 getgrouplist getgroups getlogin getloadavg getpeername getpgid getpid \ 3548 getpriority getresuid getresgid getpwent getpwnam_r getpwuid_r getspnam getspent getsid getwd \ 3549 if_nameindex \ 3550 initgroups kill killpg lchown lockf linkat lstat lutimes mmap \ 3551 memrchr mbrtowc mkdirat mkfifo \ 3552 madvise mkfifoat mknod mknodat mktime mremap nice openat pathconf pause pipe2 plock poll \ 3553 posix_fallocate posix_fadvise posix_spawn posix_spawnp pread preadv preadv2 \ 3554 pthread_condattr_setclock pthread_init pthread_kill putenv pwrite pwritev pwritev2 \ 3555 readlink readlinkat readv realpath renameat \ 3556 sem_open sem_timedwait sem_getvalue sem_unlink sendfile setegid seteuid \ 3557 setgid sethostname \ 3558 setlocale setregid setreuid setresuid setresgid setsid setpgid setpgrp setpriority setuid setvbuf \ 3559 sched_get_priority_max sched_setaffinity sched_setscheduler sched_setparam \ 3560 sched_rr_get_interval \ 3561 sigaction sigaltstack sigfillset siginterrupt sigpending sigrelse \ 3562 sigtimedwait sigwait sigwaitinfo snprintf strftime strlcpy strsignal symlinkat sync \ 3563 sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \ 3564 truncate uname unlinkat unsetenv utimensat utimes waitid waitpid wait3 wait4 \ 3565 wcscoll wcsftime wcsxfrm wmemcmp writev _getpty rtpSpawn) 3566 3567# Force lchmod off for Linux. Linux disallows changing the mode of symbolic 3568# links. Some libc implementations have a stub lchmod implementation that always 3569# returns an error. 3570if test "$MACHDEP" != linux; then 3571 AC_CHECK_FUNCS(lchmod) 3572fi 3573 3574AC_CHECK_DECL(dirfd, 3575 AC_DEFINE(HAVE_DIRFD, 1, 3576 Define if you have the 'dirfd' function or macro.), , 3577 [#include <sys/types.h> 3578 #include <dirent.h>]) 3579 3580# For some functions, having a definition is not sufficient, since 3581# we want to take their address. 3582AC_MSG_CHECKING(for chroot) 3583AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=chroot]])], 3584 [AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.) 3585 AC_MSG_RESULT(yes)], 3586 [AC_MSG_RESULT(no) 3587]) 3588AC_MSG_CHECKING(for link) 3589AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=link]])], 3590 [AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.) 3591 AC_MSG_RESULT(yes)], 3592 [AC_MSG_RESULT(no) 3593]) 3594AC_MSG_CHECKING(for symlink) 3595AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=symlink]])], 3596 [AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.) 3597 AC_MSG_RESULT(yes)], 3598 [AC_MSG_RESULT(no) 3599]) 3600AC_MSG_CHECKING(for fchdir) 3601AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=fchdir]])], 3602 [AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.) 3603 AC_MSG_RESULT(yes)], 3604 [AC_MSG_RESULT(no) 3605]) 3606AC_MSG_CHECKING(for fsync) 3607AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=fsync]])], 3608 [AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.) 3609 AC_MSG_RESULT(yes)], 3610 [AC_MSG_RESULT(no) 3611]) 3612AC_MSG_CHECKING(for fdatasync) 3613AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=fdatasync]])], 3614 [AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.) 3615 AC_MSG_RESULT(yes)], 3616 [AC_MSG_RESULT(no) 3617]) 3618AC_MSG_CHECKING(for epoll) 3619AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/epoll.h>]], [[void *x=epoll_create]])], 3620 [AC_DEFINE(HAVE_EPOLL, 1, Define if you have the 'epoll' functions.) 3621 AC_MSG_RESULT(yes)], 3622 [AC_MSG_RESULT(no) 3623]) 3624AC_MSG_CHECKING(for epoll_create1) 3625AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/epoll.h>]], [[void *x=epoll_create1]])], 3626 [AC_DEFINE(HAVE_EPOLL_CREATE1, 1, Define if you have the 'epoll_create1' function.) 3627 AC_MSG_RESULT(yes)], 3628 [AC_MSG_RESULT(no) 3629]) 3630AC_MSG_CHECKING(for kqueue) 3631AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3632#include <sys/types.h> 3633#include <sys/event.h> 3634 ]], [[int x=kqueue()]])], 3635 [AC_DEFINE(HAVE_KQUEUE, 1, Define if you have the 'kqueue' functions.) 3636 AC_MSG_RESULT(yes)], 3637 [AC_MSG_RESULT(no) 3638]) 3639AC_MSG_CHECKING(for prlimit) 3640AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3641#include <sys/time.h> 3642#include <sys/resource.h> 3643 ]], [[void *x=prlimit]])], 3644 [AC_DEFINE(HAVE_PRLIMIT, 1, Define if you have the 'prlimit' functions.) 3645 AC_MSG_RESULT(yes)], 3646 [AC_MSG_RESULT(no) 3647]) 3648 3649AC_MSG_CHECKING(for memfd_create) 3650AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3651#ifdef HAVE_SYS_MMAN_H 3652#include <sys/mman.h> 3653#endif 3654#ifdef HAVE_SYS_MEMFD_H 3655#include <sys/memfd.h> 3656#endif 3657]], [[void *x=memfd_create]])], 3658 [AC_DEFINE(HAVE_MEMFD_CREATE, 1, Define if you have the 'memfd_create' function.) 3659 AC_MSG_RESULT(yes)], 3660 [AC_MSG_RESULT(no) 3661]) 3662 3663# On some systems (eg. FreeBSD 5), we would find a definition of the 3664# functions ctermid_r, setgroups in the library, but no prototype 3665# (e.g. because we use _XOPEN_SOURCE). See whether we can take their 3666# address to avoid compiler warnings and potential miscompilations 3667# because of the missing prototypes. 3668 3669AC_MSG_CHECKING(for ctermid_r) 3670AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3671#include <stdio.h> 3672]], [[void* p = ctermid_r]])], 3673 [AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.) 3674 AC_MSG_RESULT(yes)], 3675 [AC_MSG_RESULT(no) 3676]) 3677 3678AC_CACHE_CHECK([for flock declaration], [ac_cv_flock_decl], 3679 [AC_COMPILE_IFELSE( 3680 [AC_LANG_PROGRAM( 3681 [#include <sys/file.h>], 3682 [void* p = flock] 3683 )], 3684 [ac_cv_flock_decl=yes], 3685 [ac_cv_flock_decl=no] 3686 ) 3687]) 3688if test "x${ac_cv_flock_decl}" = xyes; then 3689 AC_CHECK_FUNCS(flock,, 3690 AC_CHECK_LIB(bsd,flock, 3691 [AC_DEFINE(HAVE_FLOCK) 3692 AC_DEFINE(FLOCK_NEEDS_LIBBSD, 1, Define if flock needs to be linked with bsd library.) 3693 ]) 3694 ) 3695fi 3696 3697AC_MSG_CHECKING(for getpagesize) 3698AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3699#include <unistd.h> 3700]], [[void* p = getpagesize]])], 3701 [AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.) 3702 AC_MSG_RESULT(yes)], 3703 [AC_MSG_RESULT(no) 3704]) 3705 3706AC_MSG_CHECKING(for broken unsetenv) 3707AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3708#include <stdlib.h> 3709]], [[int res = unsetenv("DUMMY")]])], 3710 [AC_MSG_RESULT(no)], 3711 [AC_DEFINE(HAVE_BROKEN_UNSETENV, 1, Define if `unsetenv` does not return an int.) 3712 AC_MSG_RESULT(yes) 3713]) 3714 3715dnl check for true 3716AC_CHECK_PROGS(TRUE, true, /bin/true) 3717 3718dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv 3719dnl On others, they are in the C library, so we to take no action 3720AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE], 3721 AC_CHECK_LIB(resolv, inet_aton) 3722) 3723 3724# On Tru64, chflags seems to be present, but calling it will 3725# exit Python 3726AC_CACHE_CHECK([for chflags], [ac_cv_have_chflags], [dnl 3727AC_RUN_IFELSE([AC_LANG_SOURCE([[ 3728#include <sys/stat.h> 3729#include <unistd.h> 3730int main(int argc, char*argv[]) 3731{ 3732 if(chflags(argv[0], 0) != 0) 3733 return 1; 3734 return 0; 3735} 3736]])], 3737[ac_cv_have_chflags=yes], 3738[ac_cv_have_chflags=no], 3739[ac_cv_have_chflags=cross]) 3740]) 3741if test "$ac_cv_have_chflags" = cross ; then 3742 AC_CHECK_FUNC([chflags], [ac_cv_have_chflags="yes"], [ac_cv_have_chflags="no"]) 3743fi 3744if test "$ac_cv_have_chflags" = yes ; then 3745 AC_DEFINE(HAVE_CHFLAGS, 1, [Define to 1 if you have the 'chflags' function.]) 3746fi 3747 3748AC_CACHE_CHECK([for lchflags], [ac_cv_have_lchflags], [dnl 3749AC_RUN_IFELSE([AC_LANG_SOURCE([[ 3750#include <sys/stat.h> 3751#include <unistd.h> 3752int main(int argc, char*argv[]) 3753{ 3754 if(lchflags(argv[0], 0) != 0) 3755 return 1; 3756 return 0; 3757} 3758]])],[ac_cv_have_lchflags=yes],[ac_cv_have_lchflags=no],[ac_cv_have_lchflags=cross]) 3759]) 3760if test "$ac_cv_have_lchflags" = cross ; then 3761 AC_CHECK_FUNC([lchflags], [ac_cv_have_lchflags="yes"], [ac_cv_have_lchflags="no"]) 3762fi 3763if test "$ac_cv_have_lchflags" = yes ; then 3764 AC_DEFINE(HAVE_LCHFLAGS, 1, [Define to 1 if you have the 'lchflags' function.]) 3765fi 3766 3767dnl Check if system zlib has *Copy() functions 3768dnl 3769dnl On MacOSX the linker will search for dylibs on the entire linker path 3770dnl before searching for static libraries. setup.py adds -Wl,-search_paths_first 3771dnl to revert to a more traditional unix behaviour and make it possible to 3772dnl override the system libz with a local static library of libz. Temporarily 3773dnl add that flag to our CFLAGS as well to ensure that we check the version 3774dnl of libz that will be used by setup.py. 3775dnl The -L/usr/local/lib is needed as wel to get the same compilation 3776dnl environment as setup.py (and leaving it out can cause configure to use the 3777dnl wrong version of the library) 3778case $ac_sys_system/$ac_sys_release in 3779Darwin/*) 3780 _CUR_CFLAGS="${CFLAGS}" 3781 _CUR_LDFLAGS="${LDFLAGS}" 3782 CFLAGS="${CFLAGS} -Wl,-search_paths_first" 3783 LDFLAGS="${LDFLAGS} -Wl,-search_paths_first -L/usr/local/lib" 3784 ;; 3785esac 3786 3787AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, [Define if the zlib library has inflateCopy])) 3788 3789case $ac_sys_system/$ac_sys_release in 3790Darwin/*) 3791 CFLAGS="${_CUR_CFLAGS}" 3792 LDFLAGS="${_CUR_LDFLAGS}" 3793 ;; 3794esac 3795 3796AC_MSG_CHECKING(for hstrerror) 3797AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 3798#include <netdb.h> 3799]], [[void* p = hstrerror; hstrerror(0)]])], 3800 [AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.) 3801 AC_MSG_RESULT(yes)], 3802 [AC_MSG_RESULT(no) 3803]) 3804 3805AC_MSG_CHECKING(for inet_aton) 3806AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 3807#include <sys/types.h> 3808#include <sys/socket.h> 3809#include <netinet/in.h> 3810#include <arpa/inet.h> 3811]], [[void* p = inet_aton;inet_aton(0,0)]])], 3812 [AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.) 3813 AC_MSG_RESULT(yes)], 3814 [AC_MSG_RESULT(no) 3815]) 3816 3817AC_MSG_CHECKING(for inet_pton) 3818AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3819#include <sys/types.h> 3820#include <sys/socket.h> 3821#include <netinet/in.h> 3822#include <arpa/inet.h> 3823]], [[void* p = inet_pton]])], 3824 [AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.) 3825 AC_MSG_RESULT(yes)], 3826 [AC_MSG_RESULT(no) 3827]) 3828 3829# On some systems, setgroups is in unistd.h, on others, in grp.h 3830AC_MSG_CHECKING(for setgroups) 3831AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3832#include <unistd.h> 3833#ifdef HAVE_GRP_H 3834#include <grp.h> 3835#endif 3836]], [[void* p = setgroups]])], 3837 [AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.) 3838 AC_MSG_RESULT(yes)], 3839 [AC_MSG_RESULT(no) 3840]) 3841 3842# check for openpty and forkpty 3843 3844AC_CHECK_FUNCS(openpty,, 3845 AC_CHECK_LIB(util,openpty, 3846 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"], 3847 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"]) 3848 ) 3849) 3850AC_CHECK_FUNCS(forkpty,, 3851 AC_CHECK_LIB(util,forkpty, 3852 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"], 3853 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"]) 3854 ) 3855) 3856 3857# check for long file support functions 3858AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs) 3859 3860AC_REPLACE_FUNCS(dup2 strdup) 3861AC_CHECK_FUNCS(getpgrp, 3862 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[getpgrp(0);]])], 3863 [AC_DEFINE(GETPGRP_HAVE_ARG, 1, [Define if getpgrp() must be called as getpgrp(0).])], 3864 []) 3865) 3866AC_CHECK_FUNCS(setpgrp, 3867 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[setpgrp(0,0);]])], 3868 [AC_DEFINE(SETPGRP_HAVE_ARG, 1, [Define if setpgrp() must be called as setpgrp(0, 0).])], 3869 []) 3870) 3871AC_CHECK_FUNCS(gettimeofday, 3872 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/time.h>]], 3873 [[gettimeofday((struct timeval*)0,(struct timezone*)0);]])], 3874 [], 3875 [AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1, 3876 [Define if gettimeofday() does not have second (timezone) argument 3877 This is the case on Motorola V4 (R40V4.2)]) 3878 ]) 3879) 3880 3881# We search for both crypt and crypt_r as one or the other may be defined 3882# This gets us our -lcrypt in LIBS when required on the target platform. 3883AC_SEARCH_LIBS(crypt, crypt) 3884AC_SEARCH_LIBS(crypt_r, crypt) 3885 3886AC_CHECK_FUNC(crypt_r, 3887 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3888#define _GNU_SOURCE /* Required for crypt_r()'s prototype in glibc. */ 3889#include <crypt.h> 3890]], [[ 3891struct crypt_data d; 3892char *r = crypt_r("", "", &d); 3893]])], 3894 [AC_DEFINE(HAVE_CRYPT_R, 1, [Define if you have the crypt_r() function.])], 3895 []) 3896) 3897 3898AC_CHECK_FUNCS(clock_gettime, [], [ 3899 AC_CHECK_LIB(rt, clock_gettime, [ 3900 LIBS="$LIBS -lrt" 3901 AC_DEFINE(HAVE_CLOCK_GETTIME, 1) 3902 AC_DEFINE(TIMEMODULE_LIB, [rt], 3903 [Library needed by timemodule.c: librt may be needed for clock_gettime()]) 3904 ]) 3905]) 3906 3907AC_CHECK_FUNCS(clock_getres, [], [ 3908 AC_CHECK_LIB(rt, clock_getres, [ 3909 AC_DEFINE(HAVE_CLOCK_GETRES, 1) 3910 ]) 3911]) 3912 3913AC_CHECK_FUNCS(clock_settime, [], [ 3914 AC_CHECK_LIB(rt, clock_settime, [ 3915 AC_DEFINE(HAVE_CLOCK_SETTIME, 1) 3916 ]) 3917]) 3918 3919AC_MSG_CHECKING(for major, minor, and makedev) 3920AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 3921#if defined(MAJOR_IN_MKDEV) 3922#include <sys/mkdev.h> 3923#elif defined(MAJOR_IN_SYSMACROS) 3924#include <sys/sysmacros.h> 3925#else 3926#include <sys/types.h> 3927#endif 3928]], [[ 3929 makedev(major(0),minor(0)); 3930]])],[ 3931 AC_DEFINE(HAVE_DEVICE_MACROS, 1, 3932 [Define to 1 if you have the device macros.]) 3933 AC_MSG_RESULT(yes) 3934],[ 3935 AC_MSG_RESULT(no) 3936]) 3937 3938# On OSF/1 V5.1, getaddrinfo is available, but a define 3939# for [no]getaddrinfo in netdb.h. 3940AC_MSG_CHECKING(for getaddrinfo) 3941AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 3942#include <sys/types.h> 3943#include <sys/socket.h> 3944#include <netdb.h> 3945#include <stdio.h> 3946]], [[getaddrinfo(NULL, NULL, NULL, NULL);]])], 3947[have_getaddrinfo=yes], 3948[have_getaddrinfo=no]) 3949AC_MSG_RESULT($have_getaddrinfo) 3950if test $have_getaddrinfo = yes 3951then 3952 AC_MSG_CHECKING(getaddrinfo bug) 3953 AC_CACHE_VAL(ac_cv_buggy_getaddrinfo, 3954 AC_RUN_IFELSE([AC_LANG_SOURCE([[[ 3955#include <stdio.h> 3956#include <sys/types.h> 3957#include <netdb.h> 3958#include <string.h> 3959#include <sys/socket.h> 3960#include <netinet/in.h> 3961 3962int main() 3963{ 3964 int passive, gaierr, inet4 = 0, inet6 = 0; 3965 struct addrinfo hints, *ai, *aitop; 3966 char straddr[INET6_ADDRSTRLEN], strport[16]; 3967 3968 for (passive = 0; passive <= 1; passive++) { 3969 memset(&hints, 0, sizeof(hints)); 3970 hints.ai_family = AF_UNSPEC; 3971 hints.ai_flags = passive ? AI_PASSIVE : 0; 3972 hints.ai_socktype = SOCK_STREAM; 3973 hints.ai_protocol = IPPROTO_TCP; 3974 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) { 3975 (void)gai_strerror(gaierr); 3976 goto bad; 3977 } 3978 for (ai = aitop; ai; ai = ai->ai_next) { 3979 if (ai->ai_addr == NULL || 3980 ai->ai_addrlen == 0 || 3981 getnameinfo(ai->ai_addr, ai->ai_addrlen, 3982 straddr, sizeof(straddr), strport, sizeof(strport), 3983 NI_NUMERICHOST|NI_NUMERICSERV) != 0) { 3984 goto bad; 3985 } 3986 switch (ai->ai_family) { 3987 case AF_INET: 3988 if (strcmp(strport, "54321") != 0) { 3989 goto bad; 3990 } 3991 if (passive) { 3992 if (strcmp(straddr, "0.0.0.0") != 0) { 3993 goto bad; 3994 } 3995 } else { 3996 if (strcmp(straddr, "127.0.0.1") != 0) { 3997 goto bad; 3998 } 3999 } 4000 inet4++; 4001 break; 4002 case AF_INET6: 4003 if (strcmp(strport, "54321") != 0) { 4004 goto bad; 4005 } 4006 if (passive) { 4007 if (strcmp(straddr, "::") != 0) { 4008 goto bad; 4009 } 4010 } else { 4011 if (strcmp(straddr, "::1") != 0) { 4012 goto bad; 4013 } 4014 } 4015 inet6++; 4016 break; 4017 case AF_UNSPEC: 4018 goto bad; 4019 break; 4020 default: 4021 /* another family support? */ 4022 break; 4023 } 4024 } 4025 freeaddrinfo(aitop); 4026 aitop = NULL; 4027 } 4028 4029 if (!(inet4 == 0 || inet4 == 2)) 4030 goto bad; 4031 if (!(inet6 == 0 || inet6 == 2)) 4032 goto bad; 4033 4034 if (aitop) 4035 freeaddrinfo(aitop); 4036 return 0; 4037 4038 bad: 4039 if (aitop) 4040 freeaddrinfo(aitop); 4041 return 1; 4042} 4043]]])], 4044[ac_cv_buggy_getaddrinfo=no], 4045[ac_cv_buggy_getaddrinfo=yes], 4046[ 4047if test "${enable_ipv6+set}" = set; then 4048 ac_cv_buggy_getaddrinfo="no -- configured with --(en|dis)able-ipv6" 4049else 4050 ac_cv_buggy_getaddrinfo=yes 4051fi])) 4052fi 4053 4054AC_MSG_RESULT($ac_cv_buggy_getaddrinfo) 4055 4056if test $have_getaddrinfo = no || test "$ac_cv_buggy_getaddrinfo" = yes 4057then 4058 if test $ipv6 = yes 4059 then 4060 echo 'Fatal: You must get working getaddrinfo() function.' 4061 echo ' or you can specify "--disable-ipv6"'. 4062 exit 1 4063 fi 4064else 4065 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.]) 4066fi 4067 4068AC_CHECK_FUNCS(getnameinfo) 4069 4070# checks for structures 4071AC_HEADER_TIME 4072AC_STRUCT_TM 4073AC_STRUCT_TIMEZONE 4074AC_CHECK_MEMBERS([struct stat.st_rdev]) 4075AC_CHECK_MEMBERS([struct stat.st_blksize]) 4076AC_CHECK_MEMBERS([struct stat.st_flags]) 4077AC_CHECK_MEMBERS([struct stat.st_gen]) 4078AC_CHECK_MEMBERS([struct stat.st_birthtime]) 4079AC_CHECK_MEMBERS([struct stat.st_blocks]) 4080AC_CHECK_MEMBERS([struct passwd.pw_gecos, struct passwd.pw_passwd], [], [], [[ 4081 #include <sys/types.h> 4082 #include <pwd.h> 4083]]) 4084# Issue #21085: In Cygwin, siginfo_t does not have si_band field. 4085AC_CHECK_MEMBERS([siginfo_t.si_band], [], [], [[#include <signal.h>]]) 4086 4087AC_MSG_CHECKING(for time.h that defines altzone) 4088AC_CACHE_VAL(ac_cv_header_time_altzone,[ 4089 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <time.h>]], [[return altzone;]])], 4090 [ac_cv_header_time_altzone=yes], 4091 [ac_cv_header_time_altzone=no]) 4092 ]) 4093AC_MSG_RESULT($ac_cv_header_time_altzone) 4094if test $ac_cv_header_time_altzone = yes; then 4095 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.]) 4096fi 4097 4098was_it_defined=no 4099AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included) 4100AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 4101#include <sys/types.h> 4102#include <sys/select.h> 4103#include <sys/time.h> 4104]], [[;]])],[ 4105 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1, 4106 [Define if you can safely include both <sys/select.h> and <sys/time.h> 4107 (which you can't on SCO ODT 3.0).]) 4108 was_it_defined=yes 4109],[]) 4110AC_MSG_RESULT($was_it_defined) 4111 4112AC_MSG_CHECKING(for addrinfo) 4113AC_CACHE_VAL(ac_cv_struct_addrinfo, 4114AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <netdb.h>]], [[struct addrinfo a]])], 4115 [ac_cv_struct_addrinfo=yes], 4116 [ac_cv_struct_addrinfo=no])) 4117AC_MSG_RESULT($ac_cv_struct_addrinfo) 4118if test $ac_cv_struct_addrinfo = yes; then 4119 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)]) 4120fi 4121 4122AC_MSG_CHECKING(for sockaddr_storage) 4123AC_CACHE_VAL(ac_cv_struct_sockaddr_storage, 4124AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 4125# include <sys/types.h> 4126# include <sys/socket.h>]], [[struct sockaddr_storage s]])], 4127 [ac_cv_struct_sockaddr_storage=yes], 4128 [ac_cv_struct_sockaddr_storage=no])) 4129AC_MSG_RESULT($ac_cv_struct_sockaddr_storage) 4130if test $ac_cv_struct_sockaddr_storage = yes; then 4131 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)]) 4132fi 4133 4134AC_MSG_CHECKING(for sockaddr_alg) 4135AC_CACHE_VAL(ac_cv_struct_sockaddr_alg, 4136AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 4137# include <sys/types.h> 4138# include <sys/socket.h> 4139# include <linux/if_alg.h>]], [[struct sockaddr_alg s]])], 4140 [ac_cv_struct_sockaddr_alg=yes], 4141 [ac_cv_struct_sockaddr_alg=no])) 4142AC_MSG_RESULT($ac_cv_struct_sockaddr_alg) 4143if test $ac_cv_struct_sockaddr_alg = yes; then 4144 AC_DEFINE(HAVE_SOCKADDR_ALG, 1, [struct sockaddr_alg (linux/if_alg.h)]) 4145fi 4146 4147# checks for compiler characteristics 4148 4149AC_C_CHAR_UNSIGNED 4150AC_C_CONST 4151 4152works=no 4153AC_MSG_CHECKING(for working signed char) 4154AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[signed char c;]])], 4155 [works=yes], 4156 [AC_DEFINE(signed, , [Define to empty if the keyword does not work.])] 4157) 4158AC_MSG_RESULT($works) 4159 4160have_prototypes=no 4161AC_MSG_CHECKING(for prototypes) 4162AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[int foo(int x) { return 0; }]], [[return foo(10);]])], 4163 [AC_DEFINE(HAVE_PROTOTYPES, 1, 4164 [Define if your compiler supports function prototype]) 4165 have_prototypes=yes], 4166 [] 4167) 4168AC_MSG_RESULT($have_prototypes) 4169 4170works=no 4171AC_MSG_CHECKING(for variable length prototypes and stdarg.h) 4172AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 4173#include <stdarg.h> 4174int foo(int x, ...) { 4175 va_list va; 4176 va_start(va, x); 4177 va_arg(va, int); 4178 va_arg(va, char *); 4179 va_arg(va, double); 4180 return 0; 4181} 4182]], [[return foo(10, "", 3.14);]])],[ 4183 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1, 4184 [Define if your compiler supports variable length function prototypes 4185 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>]) 4186 works=yes 4187],[]) 4188AC_MSG_RESULT($works) 4189 4190# check for socketpair 4191AC_MSG_CHECKING(for socketpair) 4192AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 4193#include <sys/types.h> 4194#include <sys/socket.h> 4195]], [[void *x=socketpair]])], 4196 [AC_DEFINE(HAVE_SOCKETPAIR, 1, [Define if you have the 'socketpair' function.]) 4197 AC_MSG_RESULT(yes)], 4198 [AC_MSG_RESULT(no)] 4199) 4200 4201# check if sockaddr has sa_len member 4202AC_MSG_CHECKING(if sockaddr has sa_len member) 4203AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h> 4204#include <sys/socket.h>]], [[struct sockaddr x; 4205x.sa_len = 0;]])], 4206 [AC_MSG_RESULT(yes) 4207 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member])], 4208 [AC_MSG_RESULT(no)] 4209) 4210 4211# sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-( 4212AH_TEMPLATE(HAVE_GETHOSTBYNAME_R, 4213 [Define this if you have some version of gethostbyname_r()]) 4214 4215AC_CHECK_FUNC(gethostbyname_r, [ 4216 AC_DEFINE(HAVE_GETHOSTBYNAME_R) 4217 AC_MSG_CHECKING([gethostbyname_r with 6 args]) 4218 OLD_CFLAGS=$CFLAGS 4219 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS" 4220 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 4221# include <netdb.h> 4222 ]], [[ 4223 char *name; 4224 struct hostent *he, *res; 4225 char buffer[2048]; 4226 int buflen = 2048; 4227 int h_errnop; 4228 4229 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop) 4230 ]])],[ 4231 AC_DEFINE(HAVE_GETHOSTBYNAME_R) 4232 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1, 4233 [Define this if you have the 6-arg version of gethostbyname_r().]) 4234 AC_MSG_RESULT(yes) 4235 ],[ 4236 AC_MSG_RESULT(no) 4237 AC_MSG_CHECKING([gethostbyname_r with 5 args]) 4238 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 4239# include <netdb.h> 4240 ]], [[ 4241 char *name; 4242 struct hostent *he; 4243 char buffer[2048]; 4244 int buflen = 2048; 4245 int h_errnop; 4246 4247 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop) 4248 ]])], 4249 [ 4250 AC_DEFINE(HAVE_GETHOSTBYNAME_R) 4251 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1, 4252 [Define this if you have the 5-arg version of gethostbyname_r().]) 4253 AC_MSG_RESULT(yes) 4254 ], [ 4255 AC_MSG_RESULT(no) 4256 AC_MSG_CHECKING([gethostbyname_r with 3 args]) 4257 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 4258# include <netdb.h> 4259 ]], [[ 4260 char *name; 4261 struct hostent *he; 4262 struct hostent_data data; 4263 4264 (void) gethostbyname_r(name, he, &data); 4265 ]])], 4266 [ 4267 AC_DEFINE(HAVE_GETHOSTBYNAME_R) 4268 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1, 4269 [Define this if you have the 3-arg version of gethostbyname_r().]) 4270 AC_MSG_RESULT(yes) 4271 ], [ 4272 AC_MSG_RESULT(no) 4273 ]) 4274 ]) 4275 ]) 4276 CFLAGS=$OLD_CFLAGS 4277], [ 4278 AC_CHECK_FUNCS(gethostbyname) 4279]) 4280AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG) 4281AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG) 4282AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG) 4283AC_SUBST(HAVE_GETHOSTBYNAME_R) 4284AC_SUBST(HAVE_GETHOSTBYNAME) 4285 4286# checks for system services 4287# (none yet) 4288 4289# Linux requires this for correct f.p. operations 4290AC_CHECK_FUNC(__fpu_control, 4291 [], 4292 [AC_CHECK_LIB(ieee, __fpu_control) 4293]) 4294 4295# check for --with-libm=... 4296AC_SUBST(LIBM) 4297case $ac_sys_system in 4298Darwin) ;; 4299*) LIBM=-lm 4300esac 4301AC_MSG_CHECKING(for --with-libm=STRING) 4302AC_ARG_WITH(libm, 4303 AS_HELP_STRING([--with-libm=STRING], [math library]), 4304[ 4305if test "$withval" = no 4306then LIBM= 4307 AC_MSG_RESULT(force LIBM empty) 4308elif test "$withval" != yes 4309then LIBM=$withval 4310 AC_MSG_RESULT(set LIBM="$withval") 4311else AC_MSG_ERROR([proper usage is --with-libm=STRING]) 4312fi], 4313[AC_MSG_RESULT(default LIBM="$LIBM")]) 4314 4315# check for --with-libc=... 4316AC_SUBST(LIBC) 4317AC_MSG_CHECKING(for --with-libc=STRING) 4318AC_ARG_WITH(libc, 4319 AS_HELP_STRING([--with-libc=STRING], [C library]), 4320[ 4321if test "$withval" = no 4322then LIBC= 4323 AC_MSG_RESULT(force LIBC empty) 4324elif test "$withval" != yes 4325then LIBC=$withval 4326 AC_MSG_RESULT(set LIBC="$withval") 4327else AC_MSG_ERROR([proper usage is --with-libc=STRING]) 4328fi], 4329[AC_MSG_RESULT(default LIBC="$LIBC")]) 4330 4331# ************************************** 4332# * Check for gcc x64 inline assembler * 4333# ************************************** 4334 4335AC_MSG_CHECKING(for x64 gcc inline assembler) 4336AC_LINK_IFELSE( [AC_LANG_PROGRAM([[]], [[ 4337 __asm__ __volatile__ ("movq %rcx, %rax"); 4338]])],[have_gcc_asm_for_x64=yes],[have_gcc_asm_for_x64=no]) 4339AC_MSG_RESULT($have_gcc_asm_for_x64) 4340if test "$have_gcc_asm_for_x64" = yes 4341then 4342 AC_DEFINE(HAVE_GCC_ASM_FOR_X64, 1, 4343 [Define if we can use x64 gcc inline assembler]) 4344fi 4345 4346# ************************************************** 4347# * Check for various properties of floating point * 4348# ************************************************** 4349 4350AX_C_FLOAT_WORDS_BIGENDIAN 4351if test "$ax_cv_c_float_words_bigendian" = "yes" 4352then 4353 AC_DEFINE(DOUBLE_IS_BIG_ENDIAN_IEEE754, 1, 4354 [Define if C doubles are 64-bit IEEE 754 binary format, stored 4355 with the most significant byte first]) 4356elif test "$ax_cv_c_float_words_bigendian" = "no" 4357then 4358 AC_DEFINE(DOUBLE_IS_LITTLE_ENDIAN_IEEE754, 1, 4359 [Define if C doubles are 64-bit IEEE 754 binary format, stored 4360 with the least significant byte first]) 4361else 4362 # Some ARM platforms use a mixed-endian representation for doubles. 4363 # While Python doesn't currently have full support for these platforms 4364 # (see e.g., issue 1762561), we can at least make sure that float <-> string 4365 # conversions work. 4366 # FLOAT_WORDS_BIGENDIAN doesnt actually detect this case, but if it's not big 4367 # or little, then it must be this? 4368 AC_DEFINE(DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754, 1, 4369 [Define if C doubles are 64-bit IEEE 754 binary format, stored 4370 in ARM mixed-endian order (byte order 45670123)]) 4371fi 4372 4373# The short float repr introduced in Python 3.1 requires the 4374# correctly-rounded string <-> double conversion functions from 4375# Python/dtoa.c, which in turn require that the FPU uses 53-bit 4376# rounding; this is a problem on x86, where the x87 FPU has a default 4377# rounding precision of 64 bits. For gcc/x86, we can fix this by 4378# using inline assembler to get and set the x87 FPU control word. 4379 4380# This inline assembler syntax may also work for suncc and icc, 4381# so we try it on all platforms. 4382 4383AC_MSG_CHECKING(whether we can use gcc inline assembler to get and set x87 control word) 4384AC_LINK_IFELSE( [AC_LANG_PROGRAM([[]], [[ 4385 unsigned short cw; 4386 __asm__ __volatile__ ("fnstcw %0" : "=m" (cw)); 4387 __asm__ __volatile__ ("fldcw %0" : : "m" (cw)); 4388]])],[have_gcc_asm_for_x87=yes],[have_gcc_asm_for_x87=no]) 4389AC_MSG_RESULT($have_gcc_asm_for_x87) 4390if test "$have_gcc_asm_for_x87" = yes 4391then 4392 AC_DEFINE(HAVE_GCC_ASM_FOR_X87, 1, 4393 [Define if we can use gcc inline assembler to get and set x87 control word]) 4394fi 4395 4396AC_MSG_CHECKING(whether we can use gcc inline assembler to get and set mc68881 fpcr) 4397AC_LINK_IFELSE( [AC_LANG_PROGRAM([[]], [[ 4398 unsigned int fpcr; 4399 __asm__ __volatile__ ("fmove.l %%fpcr,%0" : "=g" (fpcr)); 4400 __asm__ __volatile__ ("fmove.l %0,%%fpcr" : : "g" (fpcr)); 4401]])],[have_gcc_asm_for_mc68881=yes],[have_gcc_asm_for_mc68881=no]) 4402AC_MSG_RESULT($have_gcc_asm_for_mc68881) 4403if test "$have_gcc_asm_for_mc68881" = yes 4404then 4405 AC_DEFINE(HAVE_GCC_ASM_FOR_MC68881, 1, 4406 [Define if we can use gcc inline assembler to get and set mc68881 fpcr]) 4407fi 4408 4409# Detect whether system arithmetic is subject to x87-style double 4410# rounding issues. The result of this test has little meaning on non 4411# IEEE 754 platforms. On IEEE 754, test should return 1 if rounding 4412# mode is round-to-nearest and double rounding issues are present, and 4413# 0 otherwise. See http://bugs.python.org/issue2937 for more info. 4414AC_MSG_CHECKING(for x87-style double rounding) 4415# $BASECFLAGS may affect the result 4416ac_save_cc="$CC" 4417CC="$CC $BASECFLAGS" 4418AC_RUN_IFELSE([AC_LANG_SOURCE([[ 4419#include <stdlib.h> 4420#include <math.h> 4421int main() { 4422 volatile double x, y, z; 4423 /* 1./(1-2**-53) -> 1+2**-52 (correct), 1.0 (double rounding) */ 4424 x = 0.99999999999999989; /* 1-2**-53 */ 4425 y = 1./x; 4426 if (y != 1.) 4427 exit(0); 4428 /* 1e16+2.99999 -> 1e16+2. (correct), 1e16+4. (double rounding) */ 4429 x = 1e16; 4430 y = 2.99999; 4431 z = x + y; 4432 if (z != 1e16+4.) 4433 exit(0); 4434 /* both tests show evidence of double rounding */ 4435 exit(1); 4436} 4437]])], 4438[ac_cv_x87_double_rounding=no], 4439[ac_cv_x87_double_rounding=yes], 4440[ac_cv_x87_double_rounding=no]) 4441CC="$ac_save_cc" 4442AC_MSG_RESULT($ac_cv_x87_double_rounding) 4443if test "$ac_cv_x87_double_rounding" = yes 4444then 4445 AC_DEFINE(X87_DOUBLE_ROUNDING, 1, 4446 [Define if arithmetic is subject to x87-style double rounding issue]) 4447fi 4448 4449# ************************************ 4450# * Check for mathematical functions * 4451# ************************************ 4452 4453LIBS_SAVE=$LIBS 4454LIBS="$LIBS $LIBM" 4455 4456AC_CHECK_FUNCS([acosh asinh atanh copysign erf erfc expm1 finite gamma]) 4457AC_CHECK_FUNCS([hypot lgamma log1p log2 round tgamma]) 4458AC_CHECK_DECLS([isinf, isnan, isfinite], [], [], [[#include <math.h>]]) 4459 4460# For multiprocessing module, check that sem_open 4461# actually works. For FreeBSD versions <= 7.2, 4462# the kernel module that provides POSIX semaphores 4463# isn't loaded by default, so an attempt to call 4464# sem_open results in a 'Signal 12' error. 4465AC_MSG_CHECKING(whether POSIX semaphores are enabled) 4466AC_CACHE_VAL(ac_cv_posix_semaphores_enabled, 4467AC_RUN_IFELSE([AC_LANG_SOURCE([[ 4468#include <unistd.h> 4469#include <fcntl.h> 4470#include <stdio.h> 4471#include <semaphore.h> 4472#include <sys/stat.h> 4473 4474int main(void) { 4475 sem_t *a = sem_open("/autoconf", O_CREAT, S_IRUSR|S_IWUSR, 0); 4476 if (a == SEM_FAILED) { 4477 perror("sem_open"); 4478 return 1; 4479 } 4480 sem_close(a); 4481 sem_unlink("/autoconf"); 4482 return 0; 4483} 4484]])], 4485[ac_cv_posix_semaphores_enabled=yes], 4486[ac_cv_posix_semaphores_enabled=no], 4487[ac_cv_posix_semaphores_enabled=yes]) 4488) 4489AC_MSG_RESULT($ac_cv_posix_semaphores_enabled) 4490if test $ac_cv_posix_semaphores_enabled = no 4491then 4492 AC_DEFINE(POSIX_SEMAPHORES_NOT_ENABLED, 1, 4493 [Define if POSIX semaphores aren't enabled on your system]) 4494fi 4495 4496# Multiprocessing check for broken sem_getvalue 4497AC_MSG_CHECKING(for broken sem_getvalue) 4498AC_CACHE_VAL(ac_cv_broken_sem_getvalue, 4499AC_RUN_IFELSE([AC_LANG_SOURCE([[ 4500#include <unistd.h> 4501#include <fcntl.h> 4502#include <stdio.h> 4503#include <semaphore.h> 4504#include <sys/stat.h> 4505 4506int main(void){ 4507 sem_t *a = sem_open("/autocftw", O_CREAT, S_IRUSR|S_IWUSR, 0); 4508 int count; 4509 int res; 4510 if(a==SEM_FAILED){ 4511 perror("sem_open"); 4512 return 1; 4513 4514 } 4515 res = sem_getvalue(a, &count); 4516 sem_close(a); 4517 sem_unlink("/autocftw"); 4518 return res==-1 ? 1 : 0; 4519} 4520]])], 4521[ac_cv_broken_sem_getvalue=no], 4522[ac_cv_broken_sem_getvalue=yes], 4523[ac_cv_broken_sem_getvalue=yes]) 4524) 4525AC_MSG_RESULT($ac_cv_broken_sem_getvalue) 4526if test $ac_cv_broken_sem_getvalue = yes 4527then 4528 AC_DEFINE(HAVE_BROKEN_SEM_GETVALUE, 1, 4529 [define to 1 if your sem_getvalue is broken.]) 4530fi 4531 4532AC_CHECK_DECLS([RTLD_LAZY, RTLD_NOW, RTLD_GLOBAL, RTLD_LOCAL, RTLD_NODELETE, RTLD_NOLOAD, RTLD_DEEPBIND, RTLD_MEMBER], [], [], [[#include <dlfcn.h>]]) 4533 4534# determine what size digit to use for Python's longs 4535AC_MSG_CHECKING([digit size for Python's longs]) 4536AC_ARG_ENABLE(big-digits, 4537AS_HELP_STRING([--enable-big-digits@<:@=BITS@:>@],[use big digits for Python longs [[BITS=30]]]), 4538[case $enable_big_digits in 4539yes) 4540 enable_big_digits=30 ;; 4541no) 4542 enable_big_digits=15 ;; 4543[15|30]) 4544 ;; 4545*) 4546 AC_MSG_ERROR([bad value $enable_big_digits for --enable-big-digits; value should be 15 or 30]) ;; 4547esac 4548AC_MSG_RESULT($enable_big_digits) 4549AC_DEFINE_UNQUOTED(PYLONG_BITS_IN_DIGIT, $enable_big_digits, [Define as the preferred size in bits of long digits]) 4550], 4551[AC_MSG_RESULT(no value specified)]) 4552 4553# check for wchar.h 4554AC_CHECK_HEADER(wchar.h, [ 4555 AC_DEFINE(HAVE_WCHAR_H, 1, 4556 [Define if the compiler provides a wchar.h header file.]) 4557 wchar_h="yes" 4558], 4559wchar_h="no" 4560) 4561 4562# determine wchar_t size 4563if test "$wchar_h" = yes 4564then 4565 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>]) 4566fi 4567 4568AC_MSG_CHECKING(for UCS-4 tcl) 4569have_ucs4_tcl=no 4570AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 4571#include <tcl.h> 4572#if TCL_UTF_MAX != 6 4573# error "NOT UCS4_TCL" 4574#endif]], [[]])],[ 4575 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6]) 4576 have_ucs4_tcl=yes 4577],[]) 4578AC_MSG_RESULT($have_ucs4_tcl) 4579 4580# check whether wchar_t is signed or not 4581if test "$wchar_h" = yes 4582then 4583 # check whether wchar_t is signed or not 4584 AC_MSG_CHECKING(whether wchar_t is signed) 4585 AC_CACHE_VAL(ac_cv_wchar_t_signed, [ 4586 AC_RUN_IFELSE([AC_LANG_SOURCE([[ 4587 #include <wchar.h> 4588 int main() 4589 { 4590 /* Success: exit code 0 */ 4591 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1); 4592 } 4593 ]])], 4594 [ac_cv_wchar_t_signed=yes], 4595 [ac_cv_wchar_t_signed=no], 4596 [ac_cv_wchar_t_signed=yes])]) 4597 AC_MSG_RESULT($ac_cv_wchar_t_signed) 4598fi 4599 4600AC_MSG_CHECKING(whether wchar_t is usable) 4601# wchar_t is only usable if it maps to an unsigned type 4602if test "$ac_cv_sizeof_wchar_t" -ge 2 \ 4603 -a "$ac_cv_wchar_t_signed" = "no" 4604then 4605 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1, 4606 [Define if you have a useable wchar_t type defined in wchar.h; useable 4607 means wchar_t must be an unsigned type with at least 16 bits. (see 4608 Include/unicodeobject.h).]) 4609 AC_MSG_RESULT(yes) 4610else 4611 AC_MSG_RESULT(no) 4612fi 4613 4614# check for endianness 4615AC_C_BIGENDIAN 4616 4617# ABI version string for Python extension modules. This appears between the 4618# periods in shared library file names, e.g. foo.<SOABI>.so. It is calculated 4619# from the following attributes which affect the ABI of this Python build (in 4620# this order): 4621# 4622# * The Python implementation (always 'cpython-' for us) 4623# * The major and minor version numbers 4624# * --with-pydebug (adds a 'd') 4625# 4626# Thus for example, Python 3.2 built with wide unicode, pydebug, and pymalloc, 4627# would get a shared library ABI version tag of 'cpython-32dmu' and shared 4628# libraries would be named 'foo.cpython-32dmu.so'. 4629# 4630# In Python 3.2 and older, --with-wide-unicode added a 'u' flag. 4631# In Python 3.7 and older, --with-pymalloc added a 'm' flag. 4632AC_SUBST(SOABI) 4633AC_MSG_CHECKING(ABIFLAGS) 4634AC_MSG_RESULT($ABIFLAGS) 4635AC_MSG_CHECKING(SOABI) 4636SOABI='cpython-'`echo $VERSION | tr -d .`${ABIFLAGS}${PLATFORM_TRIPLET:+-$PLATFORM_TRIPLET} 4637AC_MSG_RESULT($SOABI) 4638 4639# Release and debug (Py_DEBUG) ABI are compatible, but not Py_TRACE_REFS ABI 4640if test "$Py_DEBUG" = 'true' -a "$with_trace_refs" != "yes"; then 4641 # Similar to SOABI but remove "d" flag from ABIFLAGS 4642 AC_SUBST(ALT_SOABI) 4643 ALT_SOABI='cpython-'`echo $VERSION | tr -d .``echo $ABIFLAGS | tr -d d`${PLATFORM_TRIPLET:+-$PLATFORM_TRIPLET} 4644 AC_DEFINE_UNQUOTED(ALT_SOABI, "${ALT_SOABI}", 4645 [Alternative SOABI used in debug build to load C extensions built in release mode]) 4646fi 4647 4648AC_SUBST(EXT_SUFFIX) 4649case $ac_sys_system in 4650 Linux*|GNU*|Darwin|VxWorks) 4651 EXT_SUFFIX=.${SOABI}${SHLIB_SUFFIX};; 4652 *) 4653 EXT_SUFFIX=${SHLIB_SUFFIX};; 4654esac 4655 4656AC_MSG_CHECKING(LDVERSION) 4657LDVERSION='$(VERSION)$(ABIFLAGS)' 4658AC_MSG_RESULT($LDVERSION) 4659 4660# On Android and Cygwin the shared libraries must be linked with libpython. 4661AC_SUBST(LIBPYTHON) 4662if test -n "$ANDROID_API_LEVEL" -o "$MACHDEP" = "cygwin"; then 4663 LIBPYTHON="-lpython${VERSION}${ABIFLAGS}" 4664else 4665 LIBPYTHON='' 4666fi 4667 4668dnl define LIBPL after ABIFLAGS and LDVERSION is defined. 4669AC_SUBST(PY_ENABLE_SHARED) 4670if test x$PLATFORM_TRIPLET = x; then 4671 LIBPL='$(prefix)'"/lib/python${VERSION}/config-${LDVERSION}" 4672else 4673 LIBPL='$(prefix)'"/lib/python${VERSION}/config-${LDVERSION}-${PLATFORM_TRIPLET}" 4674fi 4675AC_SUBST(LIBPL) 4676 4677# Check whether right shifting a negative integer extends the sign bit 4678# or fills with zeros (like the Cray J90, according to Tim Peters). 4679AC_MSG_CHECKING(whether right shift extends the sign bit) 4680AC_CACHE_VAL(ac_cv_rshift_extends_sign, [ 4681AC_RUN_IFELSE([AC_LANG_SOURCE([[ 4682int main() 4683{ 4684 exit(((-1)>>3 == -1) ? 0 : 1); 4685} 4686]])], 4687[ac_cv_rshift_extends_sign=yes], 4688[ac_cv_rshift_extends_sign=no], 4689[ac_cv_rshift_extends_sign=yes])]) 4690AC_MSG_RESULT($ac_cv_rshift_extends_sign) 4691if test "$ac_cv_rshift_extends_sign" = no 4692then 4693 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1, 4694 [Define if i>>j for signed int i does not extend the sign bit 4695 when i < 0]) 4696fi 4697 4698# check for getc_unlocked and related locking functions 4699AC_MSG_CHECKING(for getc_unlocked() and friends) 4700AC_CACHE_VAL(ac_cv_have_getc_unlocked, [ 4701AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdio.h>]], [[ 4702 FILE *f = fopen("/dev/null", "r"); 4703 flockfile(f); 4704 getc_unlocked(f); 4705 funlockfile(f); 4706]])],[ac_cv_have_getc_unlocked=yes],[ac_cv_have_getc_unlocked=no])]) 4707AC_MSG_RESULT($ac_cv_have_getc_unlocked) 4708if test "$ac_cv_have_getc_unlocked" = yes 4709then 4710 AC_DEFINE(HAVE_GETC_UNLOCKED, 1, 4711 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()]) 4712fi 4713 4714# check where readline lives 4715# save the value of LIBS so we don't actually link Python with readline 4716LIBS_no_readline=$LIBS 4717 4718# On some systems we need to link readline to a termcap compatible 4719# library. NOTE: Keep the precedence of listed libraries synchronised 4720# with setup.py. 4721py_cv_lib_readline=no 4722AC_MSG_CHECKING([how to link readline libs]) 4723for py_libtermcap in "" tinfo ncursesw ncurses curses termcap; do 4724 if test -z "$py_libtermcap"; then 4725 READLINE_LIBS="-lreadline" 4726 else 4727 READLINE_LIBS="-lreadline -l$py_libtermcap" 4728 fi 4729 LIBS="$READLINE_LIBS $LIBS_no_readline" 4730 AC_LINK_IFELSE( 4731 [AC_LANG_CALL([],[readline])], 4732 [py_cv_lib_readline=yes]) 4733 if test $py_cv_lib_readline = yes; then 4734 break 4735 fi 4736done 4737# Uncomment this line if you want to use READINE_LIBS in Makefile or scripts 4738#AC_SUBST([READLINE_LIBS]) 4739if test $py_cv_lib_readline = no; then 4740 AC_MSG_RESULT([none]) 4741else 4742 AC_MSG_RESULT([$READLINE_LIBS]) 4743 AC_DEFINE(HAVE_LIBREADLINE, 1, 4744 [Define if you have the readline library (-lreadline).]) 4745fi 4746 4747# check for readline 2.2 4748AC_PREPROC_IFELSE([AC_LANG_SOURCE([[#include <readline/readline.h>]])], 4749 [have_readline=yes], 4750 [have_readline=no] 4751) 4752if test $have_readline = yes 4753then 4754 AC_EGREP_HEADER([extern int rl_completion_append_character;], 4755 [readline/readline.h], 4756 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1, 4757 [Define if you have readline 2.2]), ) 4758 AC_EGREP_HEADER([extern int rl_completion_suppress_append;], 4759 [readline/readline.h], 4760 AC_DEFINE(HAVE_RL_COMPLETION_SUPPRESS_APPEND, 1, 4761 [Define if you have rl_completion_suppress_append]), ) 4762fi 4763 4764# check for readline 4.0 4765AC_CHECK_LIB(readline, rl_pre_input_hook, 4766 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1, 4767 [Define if you have readline 4.0]), ,$READLINE_LIBS) 4768 4769# also in 4.0 4770AC_CHECK_LIB(readline, rl_completion_display_matches_hook, 4771 AC_DEFINE(HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK, 1, 4772 [Define if you have readline 4.0]), ,$READLINE_LIBS) 4773 4774# also in 4.0, but not in editline 4775AC_CHECK_LIB(readline, rl_resize_terminal, 4776 AC_DEFINE(HAVE_RL_RESIZE_TERMINAL, 1, 4777 [Define if you have readline 4.0]), ,$READLINE_LIBS) 4778 4779# check for readline 4.2 4780AC_CHECK_LIB(readline, rl_completion_matches, 4781 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1, 4782 [Define if you have readline 4.2]), ,$READLINE_LIBS) 4783 4784# also in readline 4.2 4785AC_PREPROC_IFELSE([AC_LANG_SOURCE([[#include <readline/readline.h>]])], 4786 [have_readline=yes], 4787 [have_readline=no] 4788) 4789if test $have_readline = yes 4790then 4791 AC_EGREP_HEADER([extern int rl_catch_signals;], 4792 [readline/readline.h], 4793 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1, 4794 [Define if you can turn off readline's signal handling.]), ) 4795fi 4796 4797AC_CHECK_LIB(readline, append_history, 4798 AC_DEFINE(HAVE_RL_APPEND_HISTORY, 1, 4799 [Define if readline supports append_history]), ,$READLINE_LIBS) 4800 4801# End of readline checks: restore LIBS 4802LIBS=$LIBS_no_readline 4803 4804AC_MSG_CHECKING(for broken nice()) 4805AC_CACHE_VAL(ac_cv_broken_nice, [ 4806AC_RUN_IFELSE([AC_LANG_SOURCE([[ 4807#include <stdlib.h> 4808#include <unistd.h> 4809int main() 4810{ 4811 int val1 = nice(1); 4812 if (val1 != -1 && val1 == nice(2)) 4813 exit(0); 4814 exit(1); 4815} 4816]])], 4817[ac_cv_broken_nice=yes], 4818[ac_cv_broken_nice=no], 4819[ac_cv_broken_nice=no])]) 4820AC_MSG_RESULT($ac_cv_broken_nice) 4821if test "$ac_cv_broken_nice" = yes 4822then 4823 AC_DEFINE(HAVE_BROKEN_NICE, 1, 4824 [Define if nice() returns success/failure instead of the new priority.]) 4825fi 4826 4827AC_MSG_CHECKING(for broken poll()) 4828AC_CACHE_VAL(ac_cv_broken_poll, 4829AC_RUN_IFELSE([AC_LANG_SOURCE([[ 4830#include <poll.h> 4831 4832int main() 4833{ 4834 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 }; 4835 int poll_test; 4836 4837 close (42); 4838 4839 poll_test = poll(&poll_struct, 1, 0); 4840 if (poll_test < 0) 4841 return 0; 4842 else if (poll_test == 0 && poll_struct.revents != POLLNVAL) 4843 return 0; 4844 else 4845 return 1; 4846} 4847]])], 4848[ac_cv_broken_poll=yes], 4849[ac_cv_broken_poll=no], 4850[ac_cv_broken_poll=no])) 4851AC_MSG_RESULT($ac_cv_broken_poll) 4852if test "$ac_cv_broken_poll" = yes 4853then 4854 AC_DEFINE(HAVE_BROKEN_POLL, 1, 4855 [Define if poll() sets errno on invalid file descriptors.]) 4856fi 4857 4858# check tzset(3) exists and works like we expect it to 4859AC_MSG_CHECKING(for working tzset()) 4860AC_CACHE_VAL(ac_cv_working_tzset, [ 4861AC_RUN_IFELSE([AC_LANG_SOURCE([[ 4862#include <stdlib.h> 4863#include <time.h> 4864#include <string.h> 4865 4866#if HAVE_TZNAME 4867extern char *tzname[]; 4868#endif 4869 4870int main() 4871{ 4872 /* Note that we need to ensure that not only does tzset(3) 4873 do 'something' with localtime, but it works as documented 4874 in the library reference and as expected by the test suite. 4875 This includes making sure that tzname is set properly if 4876 tm->tm_zone does not exist since it is the alternative way 4877 of getting timezone info. 4878 4879 Red Hat 6.2 doesn't understand the southern hemisphere 4880 after New Year's Day. 4881 */ 4882 4883 time_t groundhogday = 1044144000; /* GMT-based */ 4884 time_t midyear = groundhogday + (365 * 24 * 3600 / 2); 4885 4886 putenv("TZ=UTC+0"); 4887 tzset(); 4888 if (localtime(&groundhogday)->tm_hour != 0) 4889 exit(1); 4890#if HAVE_TZNAME 4891 /* For UTC, tzname[1] is sometimes "", sometimes " " */ 4892 if (strcmp(tzname[0], "UTC") || 4893 (tzname[1][0] != 0 && tzname[1][0] != ' ')) 4894 exit(1); 4895#endif 4896 4897 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0"); 4898 tzset(); 4899 if (localtime(&groundhogday)->tm_hour != 19) 4900 exit(1); 4901#if HAVE_TZNAME 4902 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT")) 4903 exit(1); 4904#endif 4905 4906 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0"); 4907 tzset(); 4908 if (localtime(&groundhogday)->tm_hour != 11) 4909 exit(1); 4910#if HAVE_TZNAME 4911 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT")) 4912 exit(1); 4913#endif 4914 4915#if HAVE_STRUCT_TM_TM_ZONE 4916 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT")) 4917 exit(1); 4918 if (strcmp(localtime(&midyear)->tm_zone, "AEST")) 4919 exit(1); 4920#endif 4921 4922 exit(0); 4923} 4924]])], 4925[ac_cv_working_tzset=yes], 4926[ac_cv_working_tzset=no], 4927[ac_cv_working_tzset=no])]) 4928AC_MSG_RESULT($ac_cv_working_tzset) 4929if test "$ac_cv_working_tzset" = yes 4930then 4931 AC_DEFINE(HAVE_WORKING_TZSET, 1, 4932 [Define if tzset() actually switches the local timezone in a meaningful way.]) 4933fi 4934 4935# Look for subsecond timestamps in struct stat 4936AC_MSG_CHECKING(for tv_nsec in struct stat) 4937AC_CACHE_VAL(ac_cv_stat_tv_nsec, 4938AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/stat.h>]], [[ 4939struct stat st; 4940st.st_mtim.tv_nsec = 1; 4941]])], 4942[ac_cv_stat_tv_nsec=yes], 4943[ac_cv_stat_tv_nsec=no])) 4944AC_MSG_RESULT($ac_cv_stat_tv_nsec) 4945if test "$ac_cv_stat_tv_nsec" = yes 4946then 4947 AC_DEFINE(HAVE_STAT_TV_NSEC, 1, 4948 [Define if you have struct stat.st_mtim.tv_nsec]) 4949fi 4950 4951# Look for BSD style subsecond timestamps in struct stat 4952AC_MSG_CHECKING(for tv_nsec2 in struct stat) 4953AC_CACHE_VAL(ac_cv_stat_tv_nsec2, 4954AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/stat.h>]], [[ 4955struct stat st; 4956st.st_mtimespec.tv_nsec = 1; 4957]])], 4958[ac_cv_stat_tv_nsec2=yes], 4959[ac_cv_stat_tv_nsec2=no])) 4960AC_MSG_RESULT($ac_cv_stat_tv_nsec2) 4961if test "$ac_cv_stat_tv_nsec2" = yes 4962then 4963 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1, 4964 [Define if you have struct stat.st_mtimensec]) 4965fi 4966 4967# first curses header check 4968ac_save_cppflags="$CPPFLAGS" 4969if test "$cross_compiling" = no; then 4970 CPPFLAGS="$CPPFLAGS -I/usr/include/ncursesw" 4971fi 4972 4973AC_CHECK_HEADERS(curses.h ncurses.h) 4974 4975# On Solaris, term.h requires curses.h 4976AC_CHECK_HEADERS(term.h,,,[ 4977#ifdef HAVE_CURSES_H 4978#include <curses.h> 4979#endif 4980]) 4981 4982# On HP/UX 11.0, mvwdelch is a block with a return statement 4983AC_MSG_CHECKING(whether mvwdelch is an expression) 4984AC_CACHE_VAL(ac_cv_mvwdelch_is_expression, 4985AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[ 4986 int rtn; 4987 rtn = mvwdelch(0,0,0); 4988]])], 4989[ac_cv_mvwdelch_is_expression=yes], 4990[ac_cv_mvwdelch_is_expression=no])) 4991AC_MSG_RESULT($ac_cv_mvwdelch_is_expression) 4992 4993if test "$ac_cv_mvwdelch_is_expression" = yes 4994then 4995 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1, 4996 [Define if mvwdelch in curses.h is an expression.]) 4997fi 4998 4999# Issue #25720: ncurses has introduced the NCURSES_OPAQUE symbol making opaque 5000# structs since version 5.7. If the macro is defined as zero before including 5001# [n]curses.h, ncurses will expose fields of the structs regardless of the 5002# configuration. 5003AC_MSG_CHECKING(whether WINDOW has _flags) 5004AC_CACHE_VAL(ac_cv_window_has_flags, 5005AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 5006 #define NCURSES_OPAQUE 0 5007 #include <curses.h> 5008]], [[ 5009 WINDOW *w; 5010 w->_flags = 0; 5011]])], 5012[ac_cv_window_has_flags=yes], 5013[ac_cv_window_has_flags=no])) 5014AC_MSG_RESULT($ac_cv_window_has_flags) 5015 5016 5017if test "$ac_cv_window_has_flags" = yes 5018then 5019 AC_DEFINE(WINDOW_HAS_FLAGS, 1, 5020 [Define if WINDOW in curses.h offers a field _flags.]) 5021fi 5022 5023AC_MSG_CHECKING(for is_pad) 5024AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[ 5025#ifndef is_pad 5026void *x=is_pad 5027#endif 5028]])], 5029 [AC_DEFINE(HAVE_CURSES_IS_PAD, 1, Define if you have the 'is_pad' function or macro.) 5030 AC_MSG_RESULT(yes)], 5031 [AC_MSG_RESULT(no)] 5032) 5033 5034AC_MSG_CHECKING(for is_term_resized) 5035AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[void *x=is_term_resized]])], 5036 [AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.) 5037 AC_MSG_RESULT(yes)], 5038 [AC_MSG_RESULT(no)] 5039) 5040 5041AC_MSG_CHECKING(for resize_term) 5042AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[void *x=resize_term]])], 5043 [AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.) 5044 AC_MSG_RESULT(yes)], 5045 [AC_MSG_RESULT(no)] 5046) 5047 5048AC_MSG_CHECKING(for resizeterm) 5049AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[void *x=resizeterm]])], 5050 [AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.) 5051 AC_MSG_RESULT(yes)], 5052 [AC_MSG_RESULT(no)] 5053) 5054 5055AC_MSG_CHECKING(for immedok) 5056AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[ 5057#ifndef immedok 5058void *x=immedok 5059#endif 5060]])], 5061 [AC_DEFINE(HAVE_CURSES_IMMEDOK, 1, Define if you have the 'immedok' function.) 5062 AC_MSG_RESULT(yes)], 5063 [AC_MSG_RESULT(no)] 5064) 5065 5066AC_MSG_CHECKING(for syncok) 5067AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[ 5068#ifndef syncok 5069void *x=syncok 5070#endif 5071]])], 5072 [AC_DEFINE(HAVE_CURSES_SYNCOK, 1, Define if you have the 'syncok' function.) 5073 AC_MSG_RESULT(yes)], 5074 [AC_MSG_RESULT(no)] 5075) 5076 5077AC_MSG_CHECKING(for wchgat) 5078AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[ 5079#ifndef wchgat 5080void *x=wchgat 5081#endif 5082]])], 5083 [AC_DEFINE(HAVE_CURSES_WCHGAT, 1, Define if you have the 'wchgat' function.) 5084 AC_MSG_RESULT(yes)], 5085 [AC_MSG_RESULT(no)] 5086) 5087 5088AC_MSG_CHECKING(for filter) 5089AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[ 5090#ifndef filter 5091void *x=filter 5092#endif 5093]])], 5094 [AC_DEFINE(HAVE_CURSES_FILTER, 1, Define if you have the 'filter' function.) 5095 AC_MSG_RESULT(yes)], 5096 [AC_MSG_RESULT(no)] 5097) 5098 5099AC_MSG_CHECKING(for has_key) 5100AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[ 5101#ifndef has_key 5102void *x=has_key 5103#endif 5104]])], 5105 [AC_DEFINE(HAVE_CURSES_HAS_KEY, 1, Define if you have the 'has_key' function.) 5106 AC_MSG_RESULT(yes)], 5107 [AC_MSG_RESULT(no)] 5108) 5109 5110AC_MSG_CHECKING(for typeahead) 5111AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[ 5112#ifndef typeahead 5113void *x=typeahead 5114#endif 5115]])], 5116 [AC_DEFINE(HAVE_CURSES_TYPEAHEAD, 1, Define if you have the 'typeahead' function.) 5117 AC_MSG_RESULT(yes)], 5118 [AC_MSG_RESULT(no)] 5119) 5120 5121AC_MSG_CHECKING(for use_env) 5122AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[ 5123#ifndef use_env 5124void *x=use_env 5125#endif 5126]])], 5127 [AC_DEFINE(HAVE_CURSES_USE_ENV, 1, Define if you have the 'use_env' function.) 5128 AC_MSG_RESULT(yes)], 5129 [AC_MSG_RESULT(no)] 5130) 5131# last curses configure check 5132CPPFLAGS=$ac_save_cppflags 5133 5134AC_MSG_NOTICE([checking for device files]) 5135 5136dnl NOTE: Inform user how to proceed with files when cross compiling. 5137if test "x$cross_compiling" = xyes; then 5138 if test "${ac_cv_file__dev_ptmx+set}" != set; then 5139 AC_MSG_CHECKING([for /dev/ptmx]) 5140 AC_MSG_RESULT([not set]) 5141 AC_MSG_ERROR([set ac_cv_file__dev_ptmx to yes/no in your CONFIG_SITE file when cross compiling]) 5142 fi 5143 if test "${ac_cv_file__dev_ptc+set}" != set; then 5144 AC_MSG_CHECKING([for /dev/ptc]) 5145 AC_MSG_RESULT([not set]) 5146 AC_MSG_ERROR([set ac_cv_file__dev_ptc to yes/no in your CONFIG_SITE file when cross compiling]) 5147 fi 5148fi 5149 5150AC_CHECK_FILE(/dev/ptmx, [], []) 5151if test "x$ac_cv_file__dev_ptmx" = xyes; then 5152 AC_DEFINE(HAVE_DEV_PTMX, 1, 5153 [Define to 1 if you have the /dev/ptmx device file.]) 5154fi 5155AC_CHECK_FILE(/dev/ptc, [], []) 5156if test "x$ac_cv_file__dev_ptc" = xyes; then 5157 AC_DEFINE(HAVE_DEV_PTC, 1, 5158 [Define to 1 if you have the /dev/ptc device file.]) 5159fi 5160 5161if test $ac_sys_system = Darwin 5162then 5163 LIBS="$LIBS -framework CoreFoundation" 5164fi 5165 5166AC_CACHE_CHECK([for %zd printf() format support], ac_cv_have_size_t_format, [dnl 5167AC_RUN_IFELSE([AC_LANG_SOURCE([[ 5168#include <stdio.h> 5169#include <stddef.h> 5170#include <string.h> 5171 5172#ifdef HAVE_SYS_TYPES_H 5173#include <sys/types.h> 5174#endif 5175 5176#ifdef HAVE_SSIZE_T 5177typedef ssize_t Py_ssize_t; 5178#elif SIZEOF_VOID_P == SIZEOF_LONG 5179typedef long Py_ssize_t; 5180#else 5181typedef int Py_ssize_t; 5182#endif 5183 5184int main() 5185{ 5186 char buffer[256]; 5187 5188 if(sprintf(buffer, "%zd", (size_t)123) < 0) 5189 return 1; 5190 5191 if (strcmp(buffer, "123")) 5192 return 1; 5193 5194 if (sprintf(buffer, "%zd", (Py_ssize_t)-123) < 0) 5195 return 1; 5196 5197 if (strcmp(buffer, "-123")) 5198 return 1; 5199 5200 return 0; 5201} 5202]])], 5203 [ac_cv_have_size_t_format=yes], 5204 [ac_cv_have_size_t_format=no], 5205 [ac_cv_have_size_t_format="cross -- assuming yes" 5206])]) 5207if test "$ac_cv_have_size_t_format" != no ; then 5208 AC_DEFINE(PY_FORMAT_SIZE_T, "z", 5209 [Define to printf format modifier for Py_ssize_t]) 5210fi 5211 5212AC_CHECK_TYPE(socklen_t,, 5213 AC_DEFINE(socklen_t,int, 5214 [Define to `int' if <sys/socket.h> does not define.]),[ 5215#ifdef HAVE_SYS_TYPES_H 5216#include <sys/types.h> 5217#endif 5218#ifdef HAVE_SYS_SOCKET_H 5219#include <sys/socket.h> 5220#endif 5221]) 5222 5223AC_MSG_CHECKING(for broken mbstowcs) 5224AC_CACHE_VAL(ac_cv_broken_mbstowcs, 5225AC_RUN_IFELSE([AC_LANG_SOURCE([[ 5226#include <stdio.h> 5227#include<stdlib.h> 5228int main() { 5229 size_t len = -1; 5230 const char *str = "text"; 5231 len = mbstowcs(NULL, str, 0); 5232 return (len != 4); 5233} 5234]])], 5235[ac_cv_broken_mbstowcs=no], 5236[ac_cv_broken_mbstowcs=yes], 5237[ac_cv_broken_mbstowcs=no])) 5238AC_MSG_RESULT($ac_cv_broken_mbstowcs) 5239if test "$ac_cv_broken_mbstowcs" = yes 5240then 5241 AC_DEFINE(HAVE_BROKEN_MBSTOWCS, 1, 5242 [Define if mbstowcs(NULL, "text", 0) does not return the number of 5243 wide chars that would be converted.]) 5244fi 5245 5246# Check for --with-computed-gotos 5247AC_MSG_CHECKING(for --with-computed-gotos) 5248AC_ARG_WITH(computed-gotos, 5249 AS_HELP_STRING([--with(out)-computed-gotos], 5250 [Use computed gotos in evaluation loop (enabled by default on supported compilers)]), 5251[ 5252if test "$withval" = yes 5253then 5254 AC_DEFINE(USE_COMPUTED_GOTOS, 1, 5255 [Define if you want to use computed gotos in ceval.c.]) 5256 AC_MSG_RESULT(yes) 5257fi 5258if test "$withval" = no 5259then 5260 AC_DEFINE(USE_COMPUTED_GOTOS, 0, 5261 [Define if you want to use computed gotos in ceval.c.]) 5262 AC_MSG_RESULT(no) 5263fi 5264], 5265[AC_MSG_RESULT(no value specified)]) 5266 5267AC_MSG_CHECKING(whether $CC supports computed gotos) 5268AC_CACHE_VAL(ac_cv_computed_gotos, 5269AC_RUN_IFELSE([AC_LANG_SOURCE([[[ 5270int main(int argc, char **argv) 5271{ 5272 static void *targets[1] = { &&LABEL1 }; 5273 goto LABEL2; 5274LABEL1: 5275 return 0; 5276LABEL2: 5277 goto *targets[0]; 5278 return 1; 5279} 5280]]])], 5281[ac_cv_computed_gotos=yes], 5282[ac_cv_computed_gotos=no], 5283[if test "${with_computed_gotos+set}" = set; then 5284 ac_cv_computed_gotos="$with_computed_gotos -- configured --with(out)-computed-gotos" 5285 else 5286 ac_cv_computed_gotos=no 5287 fi])) 5288AC_MSG_RESULT($ac_cv_computed_gotos) 5289case "$ac_cv_computed_gotos" in yes*) 5290 AC_DEFINE(HAVE_COMPUTED_GOTOS, 1, 5291 [Define if the C compiler supports computed gotos.]) 5292esac 5293 5294case $ac_sys_system in 5295AIX*) 5296 AC_DEFINE(HAVE_BROKEN_PIPE_BUF, 1, [Define if the system reports an invalid PIPE_BUF value.]) ;; 5297esac 5298 5299 5300AC_SUBST(THREADHEADERS) 5301 5302for h in `(cd $srcdir;echo Python/thread_*.h)` 5303do 5304 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h" 5305done 5306 5307AC_SUBST(SRCDIRS) 5308SRCDIRS="Parser Objects Python Modules Modules/_io Programs" 5309AC_MSG_CHECKING(for build directories) 5310for dir in $SRCDIRS; do 5311 if test ! -d $dir; then 5312 mkdir $dir 5313 fi 5314done 5315AC_MSG_RESULT(done) 5316 5317# Availability of -O2: 5318AC_MSG_CHECKING(for -O2) 5319saved_cflags="$CFLAGS" 5320CFLAGS="-O2" 5321AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 5322]])],[have_O2=yes],[have_O2=no]) 5323AC_MSG_RESULT($have_O2) 5324CFLAGS="$saved_cflags" 5325 5326# _FORTIFY_SOURCE wrappers for memmove and bcopy are incorrect: 5327# http://sourceware.org/ml/libc-alpha/2010-12/msg00009.html 5328AC_MSG_CHECKING(for glibc _FORTIFY_SOURCE/memmove bug) 5329saved_cflags="$CFLAGS" 5330CFLAGS="-O2 -D_FORTIFY_SOURCE=2" 5331if test "$have_O2" = no; then 5332 CFLAGS="" 5333fi 5334AC_RUN_IFELSE([AC_LANG_SOURCE([[ 5335#include <stdio.h> 5336#include <stdlib.h> 5337#include <string.h> 5338void foo(void *p, void *q) { memmove(p, q, 19); } 5339int main() { 5340 char a[32] = "123456789000000000"; 5341 foo(&a[9], a); 5342 if (strcmp(a, "123456789123456789000000000") != 0) 5343 return 1; 5344 foo(a, &a[9]); 5345 if (strcmp(a, "123456789000000000") != 0) 5346 return 1; 5347 return 0; 5348} 5349]])], 5350[have_glibc_memmove_bug=no], 5351[have_glibc_memmove_bug=yes], 5352[have_glibc_memmove_bug=undefined]) 5353CFLAGS="$saved_cflags" 5354AC_MSG_RESULT($have_glibc_memmove_bug) 5355if test "$have_glibc_memmove_bug" = yes; then 5356 AC_DEFINE(HAVE_GLIBC_MEMMOVE_BUG, 1, 5357 [Define if glibc has incorrect _FORTIFY_SOURCE wrappers 5358 for memmove and bcopy.]) 5359fi 5360 5361if test "$have_gcc_asm_for_x87" = yes; then 5362 # Some versions of gcc miscompile inline asm: 5363 # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=46491 5364 # http://gcc.gnu.org/ml/gcc/2010-11/msg00366.html 5365 case $CC in 5366 *gcc*) 5367 AC_MSG_CHECKING(for gcc ipa-pure-const bug) 5368 saved_cflags="$CFLAGS" 5369 CFLAGS="-O2" 5370 AC_RUN_IFELSE([AC_LANG_SOURCE([[ 5371 __attribute__((noinline)) int 5372 foo(int *p) { 5373 int r; 5374 asm ( "movl \$6, (%1)\n\t" 5375 "xorl %0, %0\n\t" 5376 : "=r" (r) : "r" (p) : "memory" 5377 ); 5378 return r; 5379 } 5380 int main() { 5381 int p = 8; 5382 if ((foo(&p) ? : p) != 6) 5383 return 1; 5384 return 0; 5385 } 5386 ]])], 5387 [have_ipa_pure_const_bug=no], 5388 [have_ipa_pure_const_bug=yes], 5389 [have_ipa_pure_const_bug=undefined]) 5390 CFLAGS="$saved_cflags" 5391 AC_MSG_RESULT($have_ipa_pure_const_bug) 5392 if test "$have_ipa_pure_const_bug" = yes; then 5393 AC_DEFINE(HAVE_IPA_PURE_CONST_BUG, 1, 5394 [Define if gcc has the ipa-pure-const bug.]) 5395 fi 5396 ;; 5397 esac 5398fi 5399 5400# Check for stdatomic.h 5401AC_MSG_CHECKING(for stdatomic.h) 5402AC_LINK_IFELSE( 5403[ 5404 AC_LANG_SOURCE([[ 5405 #include <stdatomic.h> 5406 atomic_int int_var; 5407 atomic_uintptr_t uintptr_var; 5408 int main() { 5409 atomic_store_explicit(&int_var, 5, memory_order_relaxed); 5410 atomic_store_explicit(&uintptr_var, 0, memory_order_relaxed); 5411 int loaded_value = atomic_load_explicit(&int_var, memory_order_seq_cst); 5412 return 0; 5413 } 5414 ]]) 5415],[have_stdatomic_h=yes],[have_stdatomic_h=no]) 5416 5417AC_MSG_RESULT($have_stdatomic_h) 5418 5419if test "$have_stdatomic_h" = yes; then 5420 AC_DEFINE(HAVE_STD_ATOMIC, 1, 5421 [Has stdatomic.h with atomic_int and atomic_uintptr_t]) 5422fi 5423 5424# Check for GCC >= 4.7 __atomic builtins 5425AC_MSG_CHECKING(for GCC >= 4.7 __atomic builtins) 5426AC_LINK_IFELSE( 5427[ 5428 AC_LANG_SOURCE([[ 5429 volatile int val = 1; 5430 int main() { 5431 __atomic_load_n(&val, __ATOMIC_SEQ_CST); 5432 return 0; 5433 } 5434 ]]) 5435],[have_builtin_atomic=yes],[have_builtin_atomic=no]) 5436 5437AC_MSG_RESULT($have_builtin_atomic) 5438 5439if test "$have_builtin_atomic" = yes; then 5440 AC_DEFINE(HAVE_BUILTIN_ATOMIC, 1, [Has builtin atomics]) 5441fi 5442 5443# ensurepip option 5444AC_MSG_CHECKING(for ensurepip) 5445AC_ARG_WITH(ensurepip, 5446 [AS_HELP_STRING([--with(out)-ensurepip=@<:@=upgrade@:>@], 5447 ["install" or "upgrade" using bundled pip])], 5448 [], 5449 [with_ensurepip=upgrade]) 5450AS_CASE($with_ensurepip, 5451 [yes|upgrade],[ENSUREPIP=upgrade], 5452 [install],[ENSUREPIP=install], 5453 [no],[ENSUREPIP=no], 5454 [AC_MSG_ERROR([--with-ensurepip=upgrade|install|no])]) 5455AC_MSG_RESULT($ENSUREPIP) 5456AC_SUBST(ENSUREPIP) 5457 5458# check if the dirent structure of a d_type field and DT_UNKNOWN is defined 5459AC_MSG_CHECKING(if the dirent structure of a d_type field) 5460AC_LINK_IFELSE( 5461[ 5462 AC_LANG_SOURCE([[ 5463 #include <dirent.h> 5464 5465 int main() { 5466 struct dirent entry; 5467 return entry.d_type == DT_UNKNOWN; 5468 } 5469 ]]) 5470],[have_dirent_d_type=yes],[have_dirent_d_type=no]) 5471AC_MSG_RESULT($have_dirent_d_type) 5472 5473if test "$have_dirent_d_type" = yes; then 5474 AC_DEFINE(HAVE_DIRENT_D_TYPE, 1, 5475 [Define to 1 if the dirent structure has a d_type field]) 5476fi 5477 5478# check if the Linux getrandom() syscall is available 5479AC_MSG_CHECKING(for the Linux getrandom() syscall) 5480AC_LINK_IFELSE( 5481[ 5482 AC_LANG_SOURCE([[ 5483 #include <unistd.h> 5484 #include <sys/syscall.h> 5485 #include <linux/random.h> 5486 5487 int main() { 5488 char buffer[1]; 5489 const size_t buflen = sizeof(buffer); 5490 const int flags = GRND_NONBLOCK; 5491 /* ignore the result, Python checks for ENOSYS and EAGAIN at runtime */ 5492 (void)syscall(SYS_getrandom, buffer, buflen, flags); 5493 return 0; 5494 } 5495 ]]) 5496],[have_getrandom_syscall=yes],[have_getrandom_syscall=no]) 5497AC_MSG_RESULT($have_getrandom_syscall) 5498 5499if test "$have_getrandom_syscall" = yes; then 5500 AC_DEFINE(HAVE_GETRANDOM_SYSCALL, 1, 5501 [Define to 1 if the Linux getrandom() syscall is available]) 5502fi 5503 5504# check if the getrandom() function is available 5505# the test was written for the Solaris function of <sys/random.h> 5506AC_MSG_CHECKING(for the getrandom() function) 5507AC_LINK_IFELSE( 5508[ 5509 AC_LANG_SOURCE([[ 5510 #include <sys/random.h> 5511 5512 int main() { 5513 char buffer[1]; 5514 const size_t buflen = sizeof(buffer); 5515 const int flags = 0; 5516 /* ignore the result, Python checks for ENOSYS at runtime */ 5517 (void)getrandom(buffer, buflen, flags); 5518 return 0; 5519 } 5520 ]]) 5521],[have_getrandom=yes],[have_getrandom=no]) 5522AC_MSG_RESULT($have_getrandom) 5523 5524if test "$have_getrandom" = yes; then 5525 AC_DEFINE(HAVE_GETRANDOM, 1, 5526 [Define to 1 if the getrandom() function is available]) 5527fi 5528 5529# checks for POSIX shared memory, used by Modules/_multiprocessing/posixshmem.c 5530# shm_* may only be available if linking against librt 5531save_LIBS="$LIBS" 5532save_includes_default="$ac_includes_default" 5533AC_SEARCH_LIBS(shm_open, rt) 5534if test "$ac_cv_search_shm_open" = "-lrt"; then 5535 AC_DEFINE(SHM_NEEDS_LIBRT, 1, 5536 [Define to 1 if you must link with -lrt for shm_open().]) 5537fi 5538AC_CHECK_HEADERS(sys/mman.h) 5539# temporarily override ac_includes_default for AC_CHECK_FUNCS below 5540ac_includes_default="\ 5541${ac_includes_default} 5542#ifndef __cplusplus 5543# ifdef HAVE_SYS_MMAN_H 5544# include <sys/mman.h> 5545# endif 5546#endif 5547" 5548AC_CHECK_FUNCS([shm_open shm_unlink]) 5549# we don't want to link with librt always, restore LIBS 5550LIBS="$save_LIBS" 5551ac_includes_default="$save_includes_default" 5552 5553# Check for usable OpenSSL 5554AX_CHECK_OPENSSL([have_openssl=yes],[have_openssl=no]) 5555 5556if test "$have_openssl" = yes; then 5557 AC_MSG_CHECKING([for X509_VERIFY_PARAM_set1_host in libssl]) 5558 5559 save_LIBS="$LIBS" 5560 save_LDFLAGS="$LDFLAGS" 5561 save_CPPFLAGS="$CPPFLAGS" 5562 LDFLAGS="$LDFLAGS $OPENSSL_LDFLAGS" 5563 LIBS="$OPENSSL_LIBS $LIBS" 5564 CPPFLAGS="$OPENSSL_INCLUDES $CPPFLAGS" 5565 5566 AC_LINK_IFELSE([AC_LANG_PROGRAM([ 5567 [#include <openssl/x509_vfy.h>] 5568 ], [ 5569 [X509_VERIFY_PARAM *p = X509_VERIFY_PARAM_new();] 5570 [X509_VERIFY_PARAM_set1_host(p, "localhost", 0);] 5571 [X509_VERIFY_PARAM_set1_ip_asc(p, "127.0.0.1");] 5572 [X509_VERIFY_PARAM_set_hostflags(p, 0);] 5573 ]) 5574 ], 5575 [ 5576 ac_cv_has_x509_verify_param_set1_host=yes 5577 ], 5578 [ 5579 ac_cv_has_x509_verify_param_set1_host=no 5580 ]) 5581 AC_MSG_RESULT($ac_cv_has_x509_verify_param_set1_host) 5582 if test "$ac_cv_has_x509_verify_param_set1_host" = "yes"; then 5583 AC_DEFINE(HAVE_X509_VERIFY_PARAM_SET1_HOST, 1, 5584 [Define if libssl has X509_VERIFY_PARAM_set1_host and related function]) 5585 fi 5586 5587 CPPFLAGS="$save_CPPFLAGS" 5588 LDFLAGS="$save_LDFLAGS" 5589 LIBS="$save_LIBS" 5590fi 5591 5592# ssl module default cipher suite string 5593AH_TEMPLATE(PY_SSL_DEFAULT_CIPHERS, 5594 [Default cipher suites list for ssl module. 5595 1: Python's preferred selection, 2: leave OpenSSL defaults untouched, 0: custom string]) 5596AH_TEMPLATE(PY_SSL_DEFAULT_CIPHER_STRING, 5597 [Cipher suite string for PY_SSL_DEFAULT_CIPHERS=0] 5598) 5599 5600AC_MSG_CHECKING(for --with-ssl-default-suites) 5601AC_ARG_WITH(ssl-default-suites, 5602 AS_HELP_STRING([--with-ssl-default-suites=@<:@python|openssl|STRING@:>@], 5603 [Override default cipher suites string, 5604 python: use Python's preferred selection (default), 5605 openssl: leave OpenSSL's defaults untouched, 5606 STRING: use a custom string, 5607 PROTOCOL_SSLv2 ignores the setting]), 5608[ 5609AC_MSG_RESULT($withval) 5610case "$withval" in 5611 python) 5612 AC_DEFINE(PY_SSL_DEFAULT_CIPHERS, 1) 5613 ;; 5614 openssl) 5615 AC_DEFINE(PY_SSL_DEFAULT_CIPHERS, 2) 5616 ;; 5617 *) 5618 AC_DEFINE(PY_SSL_DEFAULT_CIPHERS, 0) 5619 AC_DEFINE_UNQUOTED(PY_SSL_DEFAULT_CIPHER_STRING, "$withval") 5620 ;; 5621esac 5622], 5623[ 5624AC_MSG_RESULT(python) 5625AC_DEFINE(PY_SSL_DEFAULT_CIPHERS, 1) 5626]) 5627 5628 5629# generate output files 5630AC_CONFIG_FILES(Makefile.pre Misc/python.pc Misc/python-embed.pc Misc/python-config.sh) 5631AC_CONFIG_FILES([Modules/ld_so_aix], [chmod +x Modules/ld_so_aix]) 5632AC_OUTPUT 5633 5634echo "creating Modules/Setup.local" >&AS_MESSAGE_FD 5635if test ! -f Modules/Setup.local 5636then 5637 echo "# Edit this file for local setup changes" >Modules/Setup.local 5638fi 5639 5640echo "creating Makefile" >&AS_MESSAGE_FD 5641$SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \ 5642 -s Modules \ 5643 Modules/Setup.local $srcdir/Modules/Setup 5644mv config.c Modules 5645 5646if test "$Py_OPT" = 'false' -a "$Py_DEBUG" != 'true'; then 5647 echo "" >&AS_MESSAGE_FD 5648 echo "" >&AS_MESSAGE_FD 5649 echo "If you want a release build with all stable optimizations active (PGO, etc)," >&AS_MESSAGE_FD 5650 echo "please run ./configure --enable-optimizations" >&AS_MESSAGE_FD 5651 echo "" >&AS_MESSAGE_FD 5652 echo "" >&AS_MESSAGE_FD 5653fi 5654 5655