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