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