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