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