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