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