configure.ac

   1 dnl ************************************************************
   2 dnl * Please run autoreconf -ivf -Werror to test your changes! *
   3 dnl ************************************************************
   4 dnl
   5 dnl Python's configure script requires autoconf 2.71, autoconf-archive,
   6 dnl aclocal 1.16, and pkg-config.
   7 dnl
   8 dnl It is recommended to use the Tools/build/regen-configure.sh shell script
   9 dnl to regenerate the configure script.
  10 dnl
  11
  12 # Set VERSION so we only need to edit in one place (i.e., here)
  13 m4_define([PYTHON_VERSION], [3.13])
  14
  15 AC_PREREQ([2.71])
  16
  17 AC_INIT([python],[PYTHON_VERSION],[https://github.com/python/cpython/issues/])
  18
  19 m4_ifdef(
  20     [AX_C_FLOAT_WORDS_BIGENDIAN],
  21     [],
  22     [AC_MSG_ERROR([Please install autoconf-archive package and re-run autoreconf])]
  23 )dnl
  24 m4_ifdef(
  25     [PKG_PROG_PKG_CONFIG],
  26     [],
  27     [AC_MSG_ERROR([Please install pkgconf's m4 macro package and re-run autoreconf])]
  28 )dnl
  29
  30 dnl Helpers for saving and restoring environment variables:
  31 dnl - _SAVE_VAR([VAR])         Helper for SAVE_ENV; stores VAR as save_VAR
  32 dnl - _RESTORE_VAR([VAR])      Helper for RESTORE_ENV; restores VAR from save_VAR
  33 dnl - SAVE_ENV                 Saves CFLAGS, LDFLAGS, LIBS, and CPPFLAGS
  34 dnl - RESTORE_ENV              Restores CFLAGS, LDFLAGS, LIBS, and CPPFLAGS
  35 dnl - WITH_SAVE_ENV([SCRIPT])  Runs SCRIPT wrapped with SAVE_ENV/RESTORE_ENV
  36 AC_DEFUN([_SAVE_VAR], [AS_VAR_COPY([save_][$1], [$1])])dnl
  37 AC_DEFUN([_RESTORE_VAR], [AS_VAR_COPY([$1], [save_][$1])])dnl
  38 AC_DEFUN([SAVE_ENV],
  39 [_SAVE_VAR([CFLAGS])]
  40 [_SAVE_VAR([CPPFLAGS])]
  41 [_SAVE_VAR([LDFLAGS])]
  42 [_SAVE_VAR([LIBS])]
  43 )dnl
  44 AC_DEFUN([RESTORE_ENV],
  45 [_RESTORE_VAR([CFLAGS])]
  46 [_RESTORE_VAR([CPPFLAGS])]
  47 [_RESTORE_VAR([LDFLAGS])]
  48 [_RESTORE_VAR([LIBS])]
  49 )dnl
  50 AC_DEFUN([WITH_SAVE_ENV],
  51 [SAVE_ENV]
  52 [$1]
  53 [RESTORE_ENV]
  54 )dnl
  55
  56 dnl PY_CHECK_FUNC(FUNCTION, [INCLUDES], [AC_DEFINE-VAR])
  57 AC_DEFUN([PY_CHECK_FUNC],
  58 [ AS_VAR_PUSHDEF([py_var], [ac_cv_func_$1])
  59   AS_VAR_PUSHDEF([py_define], m4_ifblank([$3], [[HAVE_]m4_toupper($1)], [$3]))
  60   AC_CACHE_CHECK(
  61     [for $1],
  62     [py_var],
  63     [AC_COMPILE_IFELSE(
  64       [AC_LANG_PROGRAM([$2], [void *x=$1])],
  65       [AS_VAR_SET([py_var], [yes])],
  66       [AS_VAR_SET([py_var], [no])])]
  67   )
  68   AS_VAR_IF(
  69     [py_var],
  70     [yes],
  71     [AC_DEFINE([py_define], [1], [Define if you have the '$1' function.])])
  72   AS_VAR_POPDEF([py_var])
  73   AS_VAR_POPDEF([py_define])
  74 ])
  75
  76 dnl PY_CHECK_LIB(LIBRARY, FUNCTION, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND], [OTHER-LIBRARIES])
  77 dnl Like AC_CHECK_LIB() but does not modify LIBS
  78 AC_DEFUN([PY_CHECK_LIB],
  79 [AS_VAR_COPY([py_check_lib_save_LIBS], [LIBS])]
  80 [AC_CHECK_LIB([$1], [$2], [$3], [$4], [$5])]
  81 [AS_VAR_COPY([LIBS], [py_check_lib_save_LIBS])]
  82 )
  83
  84 dnl PY_CHECK_EMSCRIPTEN_PORT(PKG_VAR, [EMPORT_ARGS])
  85 dnl Use Emscripten port unless user passes ${PKG_VAR}_CFLAGS
  86 dnl or ${PKG_VAR}_LIBS to configure.
  87 AC_DEFUN([PY_CHECK_EMSCRIPTEN_PORT], [
  88   AS_VAR_PUSHDEF([py_cflags], [$1_CFLAGS])
  89   AS_VAR_PUSHDEF([py_libs], [$1_LIBS])
  90   AS_IF([test "$ac_sys_system" = "Emscripten" -a -z "$py_cflags" -a -z "$py_libs"], [
  91     py_cflags="$2"
  92     py_libs="$2"
  93   ])
  94   AS_VAR_POPDEF([py_cflags])
  95   AS_VAR_POPDEF([py_libs])
  96 ])
  97
  98 AC_SUBST([BASECPPFLAGS])
  99 if test "$srcdir" != . -a "$srcdir" != "$(pwd)"; then
 100     # If we're building out-of-tree, we need to make sure the following
 101     # resources get picked up before their $srcdir counterparts.
 102     #   Objects/ -> typeslots.inc
 103     #   Include/ -> Python.h
 104     # (A side effect of this is that these resources will automatically be
 105     #  regenerated when building out-of-tree, regardless of whether or not
 106     #  the $srcdir counterpart is up-to-date.  This is an acceptable trade
 107     #  off.)
 108     BASECPPFLAGS="-IObjects -IInclude -IPython"
 109 else
 110     BASECPPFLAGS=""
 111 fi
 112
 113 AC_SUBST([GITVERSION])
 114 AC_SUBST([GITTAG])
 115 AC_SUBST([GITBRANCH])
 116
 117 if test -e $srcdir/.git
 118 then
 119 AC_CHECK_PROG([HAS_GIT], [git], [found], [not-found])
 120 else
 121 HAS_GIT=no-repository
 122 fi
 123 if test $HAS_GIT = found
 124 then
 125     GITVERSION="git --git-dir \$(srcdir)/.git rev-parse --short HEAD"
 126     GITTAG="git --git-dir \$(srcdir)/.git describe --all --always --dirty"
 127     GITBRANCH="git --git-dir \$(srcdir)/.git name-rev --name-only HEAD"
 128 else
 129     GITVERSION=""
 130     GITTAG=""
 131     GITBRANCH=""
 132 fi
 133
 134 AC_CONFIG_SRCDIR([Include/object.h])
 135 AC_CONFIG_HEADERS([pyconfig.h])
 136
 137 AC_CANONICAL_HOST
 138 AC_SUBST([build])
 139 AC_SUBST([host])
 140
 141 AS_VAR_IF([cross_compiling], [maybe],
 142  [AC_MSG_ERROR([Cross compiling required --host=HOST-TUPLE and --build=ARCH])]
 143 )
 144
 145 # pybuilddir.txt will be created by --generate-posix-vars in the Makefile
 146 rm -f pybuilddir.txt
 147
 148 AC_ARG_WITH([build-python],
 149   [AS_HELP_STRING([--with-build-python=python]PYTHON_VERSION,
 150                   [path to build python binary for cross compiling (default: _bootstrap_python or python]PYTHON_VERSION[)])],
 151   [
 152     AC_MSG_CHECKING([for --with-build-python])
 153
 154     AS_VAR_IF([with_build_python], [yes], [with_build_python=python$PACKAGE_VERSION])
 155     AS_VAR_IF([with_build_python], [no], [AC_MSG_ERROR([invalid --with-build-python option: expected path or "yes", not "no"])])
 156
 157     if ! $(command -v "$with_build_python" >/dev/null 2>&1); then
 158       AC_MSG_ERROR([invalid or missing build python binary "$with_build_python"])
 159     fi
 160     build_python_ver=$($with_build_python -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')")
 161     if test "$build_python_ver" != "$PACKAGE_VERSION"; then
 162       AC_MSG_ERROR(["$with_build_python" has incompatible version $build_python_ver (expected: $PACKAGE_VERSION)])
 163     fi
 164     dnl Build Python interpreter is used for regeneration and freezing.
 165     ac_cv_prog_PYTHON_FOR_REGEN=$with_build_python
 166     PYTHON_FOR_FREEZE="$with_build_python"
 167     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) '$with_build_python
 168     AC_MSG_RESULT([$with_build_python])
 169   ], [
 170     AS_VAR_IF([cross_compiling], [yes],
 171       [AC_MSG_ERROR([Cross compiling requires --with-build-python])]
 172     )
 173     PYTHON_FOR_BUILD='./$(BUILDPYTHON) -E'
 174     PYTHON_FOR_FREEZE="./_bootstrap_python"
 175   ]
 176 )
 177 AC_SUBST([PYTHON_FOR_BUILD])
 178
 179 AC_MSG_CHECKING([for Python interpreter freezing])
 180 AC_MSG_RESULT([$PYTHON_FOR_FREEZE])
 181 AC_SUBST([PYTHON_FOR_FREEZE])
 182
 183 AS_VAR_IF([cross_compiling], [yes],
 184   [
 185     dnl external build Python, freezing depends on Programs/_freeze_module.py
 186     FREEZE_MODULE_BOOTSTRAP='$(PYTHON_FOR_FREEZE) $(srcdir)/Programs/_freeze_module.py'
 187     FREEZE_MODULE_BOOTSTRAP_DEPS='$(srcdir)/Programs/_freeze_module.py'
 188     FREEZE_MODULE='$(FREEZE_MODULE_BOOTSTRAP)'
 189     FREEZE_MODULE_DEPS='$(FREEZE_MODULE_BOOTSTRAP_DEPS)'
 190     PYTHON_FOR_BUILD_DEPS=''
 191   ],
 192   [
 193     dnl internal build tools also depend on Programs/_freeze_module and _bootstrap_python.
 194     FREEZE_MODULE_BOOTSTRAP='./Programs/_freeze_module'
 195     FREEZE_MODULE_BOOTSTRAP_DEPS="Programs/_freeze_module"
 196     FREEZE_MODULE='$(PYTHON_FOR_FREEZE) $(srcdir)/Programs/_freeze_module.py'
 197     FREEZE_MODULE_DEPS="_bootstrap_python \$(srcdir)/Programs/_freeze_module.py"
 198     PYTHON_FOR_BUILD_DEPS='$(BUILDPYTHON)'
 199   ]
 200 )
 201 AC_SUBST([FREEZE_MODULE_BOOTSTRAP])
 202 AC_SUBST([FREEZE_MODULE_BOOTSTRAP_DEPS])
 203 AC_SUBST([FREEZE_MODULE])
 204 AC_SUBST([FREEZE_MODULE_DEPS])
 205 AC_SUBST([PYTHON_FOR_BUILD_DEPS])
 206
 207 AC_CHECK_PROGS([PYTHON_FOR_REGEN],
 208   [python$PACKAGE_VERSION python3.13 python3.12 python3.11 python3.10 python3 python],
 209   [python3])
 210 AC_SUBST([PYTHON_FOR_REGEN])
 211
 212 AC_MSG_CHECKING([Python for regen version])
 213 if command -v "$PYTHON_FOR_REGEN" >/dev/null 2>&1; then
 214   AC_MSG_RESULT([$($PYTHON_FOR_REGEN -V 2>/dev/null)])
 215 else
 216   AC_MSG_RESULT([missing])
 217 fi
 218
 219 dnl Ensure that if prefix is specified, it does not end in a slash. If
 220 dnl it does, we get path names containing '//' which is both ugly and
 221 dnl can cause trouble.
 222
 223 dnl Last slash shouldn't be stripped if prefix=/
 224 if test "$prefix" != "/"; then
 225     prefix=`echo "$prefix" | sed -e 's/\/$//g'`
 226 fi
 227
 228 dnl This is for stuff that absolutely must end up in pyconfig.h.
 229 dnl Please use pyport.h instead, if possible.
 230 AH_TOP([
 231 #ifndef Py_PYCONFIG_H
 232 #define Py_PYCONFIG_H
 233 ])
 234 AH_BOTTOM([
 235 /* Define the macros needed if on a UnixWare 7.x system. */
 236 #if defined(__USLC__) && defined(__SCO_VERSION__)
 237 #define STRICT_SYSV_CURSES /* Don't use ncurses extensions */
 238 #endif
 239
 240 #endif /*Py_PYCONFIG_H*/
 241 ])
 242
 243 # We don't use PACKAGE_ variables, and they cause conflicts
 244 # with other autoconf-based packages that include Python.h
 245 grep -v 'define PACKAGE_' <confdefs.h >confdefs.h.new
 246 rm confdefs.h
 247 mv confdefs.h.new confdefs.h
 248
 249 AC_SUBST([VERSION])
 250 VERSION=PYTHON_VERSION
 251
 252 # Version number of Python's own shared library file.
 253 AC_SUBST([SOVERSION])
 254 SOVERSION=1.0
 255
 256 # The later definition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
 257 # certain features on NetBSD, so we need _NETBSD_SOURCE to re-enable
 258 # them.
 259 AC_DEFINE([_NETBSD_SOURCE], [1],
 260           [Define on NetBSD to activate all library features])
 261
 262 # The later definition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
 263 # certain features on FreeBSD, so we need __BSD_VISIBLE to re-enable
 264 # them.
 265 AC_DEFINE([__BSD_VISIBLE], [1],
 266           [Define on FreeBSD to activate all library features])
 267
 268 # The later definition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
 269 # certain features on Mac OS X, so we need _DARWIN_C_SOURCE to re-enable
 270 # them.
 271 AC_DEFINE([_DARWIN_C_SOURCE], [1],
 272           [Define on Darwin to activate all library features])
 273
 274
 275 define_xopen_source=yes
 276
 277 # Arguments passed to configure.
 278 AC_SUBST([CONFIG_ARGS])
 279 CONFIG_ARGS="$ac_configure_args"
 280
 281 dnl Allow users to disable pkg-config or require pkg-config
 282 AC_ARG_WITH([pkg-config],
 283   [AS_HELP_STRING([[--with-pkg-config=[yes|no|check]]],
 284                   [use pkg-config to detect build options (default is check)])],
 285   [],
 286   [with_pkg_config=check]
 287 )
 288 AS_CASE([$with_pkg_config],
 289   [yes|check], [
 290     if test -z "$PKG_CONFIG"; then
 291       dnl invalidate stale config.cache values
 292       AS_UNSET([PKG_CONFIG])
 293       AS_UNSET([ac_cv_path_ac_pt_PKG_CONFIG])
 294       AS_UNSET([ac_cv_prog_ac_ct_PKG_CONFIG])
 295     fi
 296     PKG_PROG_PKG_CONFIG
 297   ],
 298   [no], [
 299     PKG_CONFIG=''
 300     dnl force AX_CHECK_OPENSSL to ignore pkg-config
 301     ac_cv_path_ac_pt_PKG_CONFIG=''
 302     ac_cv_prog_ac_ct_PKG_CONFIG=''
 303   ],
 304   [AC_MSG_ERROR([invalid argument --with-pkg-config=$with_pkg_config])]
 305 )
 306 if test "$with_pkg_config" = yes -a -z "$PKG_CONFIG"; then
 307   AC_MSG_ERROR([pkg-config is required])]
 308 fi
 309
 310 # Set name for machine-dependent library files
 311 AC_ARG_VAR([MACHDEP], [name for machine-dependent library files])
 312 AC_MSG_CHECKING([MACHDEP])
 313 if test -z "$MACHDEP"
 314 then
 315     # avoid using uname for cross builds
 316     if test "$cross_compiling" = yes; then
 317        # ac_sys_system and ac_sys_release are used for setting
 318        # a lot of different things including 'define_xopen_source'
 319        # in the case statement below.
 320         case "$host" in
 321         *-*-linux-android*)
 322                 ac_sys_system=Linux-android
 323                 ;;
 324         *-*-linux*)
 325                 ac_sys_system=Linux
 326                 ;;
 327         *-*-cygwin*)
 328                 ac_sys_system=Cygwin
 329                 ;;
 330         *-apple-ios*)
 331                 ac_sys_system=iOS
 332                 ;;
 333         *-*-vxworks*)
 334             ac_sys_system=VxWorks
 335             ;;
 336         *-*-emscripten)
 337             ac_sys_system=Emscripten
 338             ;;
 339         *-*-wasi)
 340             ac_sys_system=WASI
 341             ;;
 342         *)
 343                 # for now, limit cross builds to known configurations
 344                 MACHDEP="unknown"
 345                 AC_MSG_ERROR([cross build not supported for $host])
 346         esac
 347         ac_sys_release=
 348     else
 349         ac_sys_system=`uname -s`
 350         if test "$ac_sys_system" = "AIX" \
 351         -o "$ac_sys_system" = "UnixWare" -o "$ac_sys_system" = "OpenUNIX"; then
 352                 ac_sys_release=`uname -v`
 353         else
 354                 ac_sys_release=`uname -r`
 355         fi
 356     fi
 357     ac_md_system=`echo $ac_sys_system |
 358                         tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
 359     ac_md_release=`echo $ac_sys_release |
 360                         tr -d '[/ ]' | sed 's/^[[A-Z]]\.//' | sed 's/\..*//'`
 361     MACHDEP="$ac_md_system$ac_md_release"
 362
 363     case $MACHDEP in
 364         aix*) MACHDEP="aix";;
 365         linux-android*) MACHDEP="android";;
 366         linux*) MACHDEP="linux";;
 367         cygwin*) MACHDEP="cygwin";;
 368         darwin*) MACHDEP="darwin";;
 369         '')     MACHDEP="unknown";;
 370     esac
 371
 372     if test "$ac_sys_system" = "SunOS"; then
 373         # For Solaris, there isn't an OS version specific macro defined
 374         # in most compilers, so we define one here.
 375         SUNOS_VERSION=`echo $ac_sys_release | sed -e 's!\.\([0-9]\)$!.0\1!g' | tr -d '.'`
 376         AC_DEFINE_UNQUOTED([Py_SUNOS_VERSION], [$SUNOS_VERSION],
 377                            [The version of SunOS/Solaris as reported by `uname -r' without the dot.])
 378     fi
 379 fi
 380 AC_MSG_RESULT(["$MACHDEP"])
 381
 382 # On cross-compile builds, configure will look for a host-specific compiler by
 383 # prepending the user-provided host triple to the required binary name.
 384 #
 385 # On iOS, this results in binaries like "arm64-apple-ios12.0-simulator-gcc",
 386 # which isn't a binary that exists, and isn't very convenient, as it contains the
 387 # iOS version. As the default cross-compiler name won't exist, configure falls
 388 # back to gcc, which *definitely* won't work. We're providing wrapper scripts for
 389 # these tools; the binary names of these scripts are better defaults than "gcc".
 390 # This only requires that the user put the platform scripts folder (e.g.,
 391 # "iOS/Resources/bin") in their path, rather than defining platform-specific
 392 # names/paths for AR, CC, CPP, and CXX explicitly; and if the user forgets to
 393 # either put the platform scripts folder in the path, or specify CC etc,
 394 # configure will fail.
 395 if test -z "$AR"; then
 396         case "$host" in
 397                 aarch64-apple-ios*-simulator) AR=arm64-apple-ios-simulator-ar ;;
 398                 aarch64-apple-ios*)           AR=arm64-apple-ios-ar ;;
 399                 x86_64-apple-ios*-simulator)  AR=x86_64-apple-ios-simulator-ar ;;
 400                 *)
 401         esac
 402 fi
 403 if test -z "$CC"; then
 404         case "$host" in
 405                 aarch64-apple-ios*-simulator) CC=arm64-apple-ios-simulator-clang ;;
 406                 aarch64-apple-ios*)           CC=arm64-apple-ios-clang ;;
 407                 x86_64-apple-ios*-simulator)  CC=x86_64-apple-ios-simulator-clang ;;
 408                 *)
 409         esac
 410 fi
 411 if test -z "$CPP"; then
 412         case "$host" in
 413                 aarch64-apple-ios*-simulator) CPP=arm64-apple-ios-simulator-cpp ;;
 414                 aarch64-apple-ios*)           CPP=arm64-apple-ios-cpp ;;
 415                 x86_64-apple-ios*-simulator)  CPP=x86_64-apple-ios-simulator-cpp ;;
 416                 *)
 417         esac
 418 fi
 419 if test -z "$CXX"; then
 420         case "$host" in
 421                 aarch64-apple-ios*-simulator) CXX=arm64-apple-ios-simulator-clang ;;
 422                 aarch64-apple-ios*)           CXX=arm64-apple-ios-clang ;;
 423                 x86_64-apple-ios*-simulator)  CXX=x86_64-apple-ios-simulator-clang ;;
 424                 *)
 425         esac
 426 fi
 427
 428 AC_MSG_CHECKING([for --enable-universalsdk])
 429 AC_ARG_ENABLE([universalsdk],
 430         AS_HELP_STRING([--enable-universalsdk@<:@=SDKDIR@:>@],
 431                        [create a universal binary build.
 432                         SDKDIR specifies which macOS SDK should be used to perform the build,
 433                         see Mac/README.rst. (default is no)]),
 434 [
 435         case $enableval in
 436         yes)
 437                 # Locate the best usable SDK, see Mac/README for more
 438                 # information
 439                 enableval="`/usr/bin/xcodebuild -version -sdk macosx Path 2>/dev/null`"
 440                 if ! ( echo $enableval | grep -E '\.sdk' 1>/dev/null )
 441                 then
 442                         enableval=/Developer/SDKs/MacOSX10.4u.sdk
 443                         if test ! -d "${enableval}"
 444                         then
 445                                 enableval=/
 446                         fi
 447                 fi
 448                 ;;
 449         esac
 450         case $enableval in
 451         no)
 452                 UNIVERSALSDK=
 453                 enable_universalsdk=
 454                 ;;
 455         *)
 456                 UNIVERSALSDK=$enableval
 457                 if test ! -d "${UNIVERSALSDK}"
 458                 then
 459                         AC_MSG_ERROR([--enable-universalsdk specifies non-existing SDK: ${UNIVERSALSDK}])
 460                 fi
 461                 ;;
 462         esac
 463
 464 ],[
 465         UNIVERSALSDK=
 466         enable_universalsdk=
 467 ])
 468 if test -n "${UNIVERSALSDK}"
 469 then
 470         AC_MSG_RESULT([${UNIVERSALSDK}])
 471 else
 472         AC_MSG_RESULT([no])
 473 fi
 474 AC_SUBST([UNIVERSALSDK])
 475
 476 AC_SUBST([ARCH_RUN_32BIT])
 477 ARCH_RUN_32BIT=""
 478
 479 # For backward compatibility reasons we prefer to select '32-bit' if available,
 480 # otherwise use 'intel'
 481 UNIVERSAL_ARCHS="32-bit"
 482 if test "`uname -s`" = "Darwin"
 483 then
 484         if test -n "${UNIVERSALSDK}"
 485         then
 486                 if test -z "`/usr/bin/file -L "${UNIVERSALSDK}/usr/lib/libSystem.dylib" | grep ppc`"
 487                 then
 488                         UNIVERSAL_ARCHS="intel"
 489                 fi
 490         fi
 491 fi
 492
 493 AC_SUBST([LIPO_32BIT_FLAGS])
 494 AC_SUBST([LIPO_INTEL64_FLAGS])
 495 AC_MSG_CHECKING([for --with-universal-archs])
 496 AC_ARG_WITH([universal-archs],
 497     AS_HELP_STRING([--with-universal-archs=ARCH],
 498                    [specify the kind of macOS universal binary that should be created.
 499                     This option is only valid when --enable-universalsdk is set; options are:
 500                     ("universal2", "intel-64", "intel-32", "intel", "32-bit",
 501                     "64-bit", "3-way", or "all")
 502                     see Mac/README.rst]),
 503 [
 504         UNIVERSAL_ARCHS="$withval"
 505 ],
 506 [])
 507 if test -n "${UNIVERSALSDK}"
 508 then
 509         AC_MSG_RESULT([${UNIVERSAL_ARCHS}])
 510 else
 511         AC_MSG_RESULT([no])
 512 fi
 513
 514 AC_ARG_WITH([framework-name],
 515               AS_HELP_STRING([--with-framework-name=FRAMEWORK],
 516                              [specify the name for the python framework on macOS
 517                               only valid when --enable-framework is set. see Mac/README.rst
 518                               (default is 'Python')]),
 519 [
 520     PYTHONFRAMEWORK=${withval}
 521     PYTHONFRAMEWORKDIR=${withval}.framework
 522     PYTHONFRAMEWORKIDENTIFIER=org.python.`echo $withval | tr '[A-Z]' '[a-z]'`
 523     ],[
 524     PYTHONFRAMEWORK=Python
 525     PYTHONFRAMEWORKDIR=Python.framework
 526     PYTHONFRAMEWORKIDENTIFIER=org.python.python
 527 ])
 528 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
 529 AC_ARG_ENABLE([framework],
 530               AS_HELP_STRING([--enable-framework@<:@=INSTALLDIR@:>@],
 531                              [create a Python.framework rather than a traditional Unix install.
 532                               optional INSTALLDIR specifies the installation path. see Mac/README.rst
 533                               (default is no)]),
 534 [
 535         case $enableval in
 536         yes)
 537                 case $ac_sys_system in
 538                         Darwin) enableval=/Library/Frameworks ;;
 539                         iOS)    enableval=iOS/Frameworks/\$\(MULTIARCH\) ;;
 540                         *) AC_MSG_ERROR([Unknown platform for framework build])
 541                 esac
 542         esac
 543
 544         case $enableval in
 545         no)
 546                 case $ac_sys_system in
 547                         iOS) AC_MSG_ERROR([iOS builds must use --enable-framework]) ;;
 548                         *)
 549                                 PYTHONFRAMEWORK=
 550                                 PYTHONFRAMEWORKDIR=no-framework
 551                                 PYTHONFRAMEWORKPREFIX=
 552                                 PYTHONFRAMEWORKINSTALLDIR=
 553                                 PYTHONFRAMEWORKINSTALLNAMEPREFIX=
 554                                 RESSRCDIR=
 555                                 FRAMEWORKINSTALLFIRST=
 556                                 FRAMEWORKINSTALLLAST=
 557                                 FRAMEWORKALTINSTALLFIRST=
 558                                 FRAMEWORKALTINSTALLLAST=
 559                                 FRAMEWORKPYTHONW=
 560                                 INSTALLTARGETS="commoninstall bininstall maninstall"
 561
 562                                 if test "x${prefix}" = "xNONE"; then
 563                                         FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
 564                                 else
 565                                         FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
 566                                 fi
 567                                 enable_framework=
 568                 esac
 569                 ;;
 570         *)
 571                 PYTHONFRAMEWORKPREFIX="${enableval}"
 572                 PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR
 573
 574                 case $ac_sys_system in #(
 575                         Darwin) :
 576                                 FRAMEWORKINSTALLFIRST="frameworkinstallversionedstructure"
 577                                 FRAMEWORKALTINSTALLFIRST="frameworkinstallversionedstructure "
 578                                 FRAMEWORKINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkinstallunixtools"
 579                                 FRAMEWORKALTINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkaltinstallunixtools"
 580                                 FRAMEWORKPYTHONW="frameworkpythonw"
 581                                 FRAMEWORKINSTALLAPPSPREFIX="/Applications"
 582                                 INSTALLTARGETS="commoninstall bininstall maninstall"
 583
 584                                 if test "x${prefix}" = "xNONE" ; then
 585                                         FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
 586
 587                                 else
 588                                         FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
 589                                 fi
 590
 591                                 case "${enableval}" in
 592                                 /System*)
 593                                         FRAMEWORKINSTALLAPPSPREFIX="/Applications"
 594                                         if test "${prefix}" = "NONE" ; then
 595                                                 # See below
 596                                                 FRAMEWORKUNIXTOOLSPREFIX="/usr"
 597                                         fi
 598                                         ;;
 599
 600                                 /Library*)
 601                                         FRAMEWORKINSTALLAPPSPREFIX="/Applications"
 602                                         ;;
 603
 604                                 */Library/Frameworks)
 605                                         MDIR="`dirname "${enableval}"`"
 606                                         MDIR="`dirname "${MDIR}"`"
 607                                         FRAMEWORKINSTALLAPPSPREFIX="${MDIR}/Applications"
 608
 609                                         if test "${prefix}" = "NONE"; then
 610                                                 # User hasn't specified the
 611                                                 # --prefix option, but wants to install
 612                                                 # the framework in a non-default location,
 613                                                 # ensure that the compatibility links get
 614                                                 # installed relative to that prefix as well
 615                                                 # instead of in /usr/local.
 616                                                 FRAMEWORKUNIXTOOLSPREFIX="${MDIR}"
 617                                         fi
 618                                         ;;
 619
 620                                 *)
 621                                         FRAMEWORKINSTALLAPPSPREFIX="/Applications"
 622                                         ;;
 623                                 esac
 624
 625                                 prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION
 626                                 PYTHONFRAMEWORKINSTALLNAMEPREFIX=${prefix}
 627                                 RESSRCDIR=Mac/Resources/framework
 628
 629                                 # Add files for Mac specific code to the list of output
 630                                 # files:
 631                                 AC_CONFIG_FILES([Mac/Makefile])
 632                                 AC_CONFIG_FILES([Mac/PythonLauncher/Makefile])
 633                                 AC_CONFIG_FILES([Mac/Resources/framework/Info.plist])
 634                                 AC_CONFIG_FILES([Mac/Resources/app/Info.plist])
 635                                 ;;
 636                         iOS) :
 637                                 FRAMEWORKINSTALLFIRST="frameworkinstallunversionedstructure"
 638                                 FRAMEWORKALTINSTALLFIRST="frameworkinstallunversionedstructure "
 639                                 FRAMEWORKINSTALLLAST="frameworkinstallmobileheaders"
 640                                 FRAMEWORKALTINSTALLLAST="frameworkinstallmobileheaders"
 641                                 FRAMEWORKPYTHONW=
 642                                 INSTALLTARGETS="libinstall inclinstall sharedinstall"
 643
 644                                 prefix=$PYTHONFRAMEWORKPREFIX
 645                                 PYTHONFRAMEWORKINSTALLNAMEPREFIX="@rpath/$PYTHONFRAMEWORKDIR"
 646                                 RESSRCDIR=iOS/Resources
 647
 648                                 AC_CONFIG_FILES([iOS/Resources/Info.plist])
 649                                 ;;
 650                         *)
 651                                 AC_MSG_ERROR([Unknown platform for framework build])
 652                                 ;;
 653                         esac
 654                 esac
 655         ],[
 656         case $ac_sys_system in
 657                 iOS) AC_MSG_ERROR([iOS builds must use --enable-framework]) ;;
 658                 *)
 659                         PYTHONFRAMEWORK=
 660                         PYTHONFRAMEWORKDIR=no-framework
 661                         PYTHONFRAMEWORKPREFIX=
 662                         PYTHONFRAMEWORKINSTALLDIR=
 663                         PYTHONFRAMEWORKINSTALLNAMEPREFIX=
 664                         RESSRCDIR=
 665                         FRAMEWORKINSTALLFIRST=
 666                         FRAMEWORKINSTALLLAST=
 667                         FRAMEWORKALTINSTALLFIRST=
 668                         FRAMEWORKALTINSTALLLAST=
 669                         FRAMEWORKPYTHONW=
 670                         INSTALLTARGETS="commoninstall bininstall maninstall"
 671                         if test "x${prefix}" = "xNONE" ; then
 672                                 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
 673                         else
 674                                 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
 675                         fi
 676                         enable_framework=
 677         esac
 678 ])
 679 AC_SUBST([PYTHONFRAMEWORK])
 680 AC_SUBST([PYTHONFRAMEWORKIDENTIFIER])
 681 AC_SUBST([PYTHONFRAMEWORKDIR])
 682 AC_SUBST([PYTHONFRAMEWORKPREFIX])
 683 AC_SUBST([PYTHONFRAMEWORKINSTALLDIR])
 684 AC_SUBST([PYTHONFRAMEWORKINSTALLNAMEPREFIX])
 685 AC_SUBST([RESSRCDIR])
 686 AC_SUBST([FRAMEWORKINSTALLFIRST])
 687 AC_SUBST([FRAMEWORKINSTALLLAST])
 688 AC_SUBST([FRAMEWORKALTINSTALLFIRST])
 689 AC_SUBST([FRAMEWORKALTINSTALLLAST])
 690 AC_SUBST([FRAMEWORKPYTHONW])
 691 AC_SUBST([FRAMEWORKUNIXTOOLSPREFIX])
 692 AC_SUBST([FRAMEWORKINSTALLAPPSPREFIX])
 693 AC_SUBST([INSTALLTARGETS])
 694
 695 AC_DEFINE_UNQUOTED([_PYTHONFRAMEWORK], ["${PYTHONFRAMEWORK}"],
 696                    [framework name])
 697
 698 AC_SUBST([_PYTHON_HOST_PLATFORM])
 699 if test "$cross_compiling" = yes; then
 700         case "$host" in
 701         *-*-linux*)
 702                 case "$host_cpu" in
 703                 arm*)
 704                         _host_ident=arm
 705                         ;;
 706                 *)
 707                         _host_ident=$host_cpu
 708                 esac
 709                 ;;
 710         *-*-cygwin*)
 711                 _host_ident=
 712                 ;;
 713         *-apple-ios*)
 714                 _host_os=`echo $host | cut -d '-' -f3`
 715                 _host_device=`echo $host | cut -d '-' -f4`
 716                 _host_device=${_host_device:=os}
 717
 718                 # IPHONEOS_DEPLOYMENT_TARGET is the minimum supported iOS version
 719                 IPHONEOS_DEPLOYMENT_TARGET=${_host_os:3}
 720                 IPHONEOS_DEPLOYMENT_TARGET=${IPHONEOS_DEPLOYMENT_TARGET:=12.0}
 721
 722                 case "$host_cpu" in
 723                         aarch64)
 724                                 _host_ident=${IPHONEOS_DEPLOYMENT_TARGET}-arm64-iphone${_host_device}
 725                                 ;;
 726                         *)
 727                                 _host_ident=${IPHONEOS_DEPLOYMENT_TARGET}-$host_cpu-iphone${_host_device}
 728                                 ;;
 729                 esac
 730                 ;;
 731         *-*-vxworks*)
 732                 _host_ident=$host_cpu
 733                 ;;
 734         wasm32-*-* | wasm64-*-*)
 735                 _host_ident=$host_cpu
 736                 ;;
 737         *)
 738                 # for now, limit cross builds to known configurations
 739                 MACHDEP="unknown"
 740                 AC_MSG_ERROR([cross build not supported for $host])
 741         esac
 742         _PYTHON_HOST_PLATFORM="$MACHDEP${_host_ident:+-$_host_ident}"
 743 fi
 744
 745 # Some systems cannot stand _XOPEN_SOURCE being defined at all; they
 746 # disable features if it is defined, without any means to access these
 747 # features as extensions. For these systems, we skip the definition of
 748 # _XOPEN_SOURCE. Before adding a system to the list to gain access to
 749 # some feature, make sure there is no alternative way to access this
 750 # feature. Also, when using wildcards, make sure you have verified the
 751 # need for not defining _XOPEN_SOURCE on all systems matching the
 752 # wildcard, and that the wildcard does not include future systems
 753 # (which may remove their limitations).
 754 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
 755 case $ac_sys_system/$ac_sys_release in
 756   # On OpenBSD, select(2) is not available if _XOPEN_SOURCE is defined,
 757   # even though select is a POSIX function. Reported by J. Ribbens.
 758   # Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish.
 759   # In addition, Stefan Krah confirms that issue #1244610 exists through
 760   # OpenBSD 4.6, but is fixed in 4.7.
 761   OpenBSD/2.* | OpenBSD/3.* | OpenBSD/4.@<:@0123456@:>@)
 762     define_xopen_source=no
 763     # OpenBSD undoes our definition of __BSD_VISIBLE if _XOPEN_SOURCE is
 764     # also defined. This can be overridden by defining _BSD_SOURCE
 765     # As this has a different meaning on Linux, only define it on OpenBSD
 766     AC_DEFINE([_BSD_SOURCE], [1],
 767               [Define on OpenBSD to activate all library features])
 768     ;;
 769   OpenBSD/*)
 770     # OpenBSD undoes our definition of __BSD_VISIBLE if _XOPEN_SOURCE is
 771     # also defined. This can be overridden by defining _BSD_SOURCE
 772     # As this has a different meaning on Linux, only define it on OpenBSD
 773     AC_DEFINE([_BSD_SOURCE], [1],
 774               [Define on OpenBSD to activate all library features])
 775     ;;
 776   # Defining _XOPEN_SOURCE on NetBSD version prior to the introduction of
 777   # _NETBSD_SOURCE disables certain features (eg. setgroups). Reported by
 778   # Marc Recht
 779   NetBSD/1.5 | NetBSD/1.5.* | NetBSD/1.6 | NetBSD/1.6.* | NetBSD/1.6@<:@A-S@:>@)
 780     define_xopen_source=no;;
 781   # From the perspective of Solaris, _XOPEN_SOURCE is not so much a
 782   # request to enable features supported by the standard as a request
 783   # to disable features not supported by the standard.  The best way
 784   # for Python to use Solaris is simply to leave _XOPEN_SOURCE out
 785   # entirely and define __EXTENSIONS__ instead.
 786   SunOS/*)
 787     define_xopen_source=no;;
 788   # On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,
 789   # but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.
 790   # Reconfirmed for 7.1.4 by Martin v. Loewis.
 791   OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@)
 792     define_xopen_source=no;;
 793   # On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,
 794   # but used in struct sockaddr.sa_family. Reported by Tim Rice.
 795   SCO_SV/3.2)
 796     define_xopen_source=no;;
 797   # On MacOS X 10.2, a bug in ncurses.h means that it craps out if
 798   # _XOPEN_EXTENDED_SOURCE is defined. Apparently, this is fixed in 10.3, which
 799   # identifies itself as Darwin/7.*
 800   # On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
 801   # disables platform specific features beyond repair.
 802   # On Mac OS X 10.3, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
 803   # has no effect, don't bother defining them
 804   Darwin/@<:@6789@:>@.*)
 805     define_xopen_source=no;;
 806   Darwin/@<:@[12]@:>@@<:@0-9@:>@.*)
 807     define_xopen_source=no;;
 808   # On iOS, defining _POSIX_C_SOURCE also disables platform specific features.
 809   iOS/*)
 810     define_xopen_source=no;;
 811   # On QNX 6.3.2, defining _XOPEN_SOURCE prevents netdb.h from
 812   # defining NI_NUMERICHOST.
 813   QNX/6.3.2)
 814     define_xopen_source=no
 815     ;;
 816   # On VxWorks, defining _XOPEN_SOURCE causes compile failures
 817   # in network headers still using system V types.
 818   VxWorks/*)
 819     define_xopen_source=no
 820     ;;
 821
 822   # On HP-UX, defining _XOPEN_SOURCE to 600 or greater hides
 823   # chroot() and other functions
 824   hp*|HP*)
 825     define_xopen_source=no
 826     ;;
 827
 828 esac
 829
 830 if test $define_xopen_source = yes
 831 then
 832   # X/Open 7, incorporating POSIX.1-2008
 833   AC_DEFINE([_XOPEN_SOURCE], [700],
 834             [Define to the level of X/Open that your system supports])
 835
 836   # On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires
 837   # definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else
 838   # several APIs are not declared. Since this is also needed in some
 839   # cases for HP-UX, we define it globally.
 840   AC_DEFINE([_XOPEN_SOURCE_EXTENDED], [1],
 841             [Define to activate Unix95-and-earlier features])
 842
 843   AC_DEFINE([_POSIX_C_SOURCE], [200809L],
 844             [Define to activate features from IEEE Stds 1003.1-2008])
 845 fi
 846
 847 # On HP-UX mbstate_t requires _INCLUDE__STDC_A1_SOURCE
 848 case $ac_sys_system in
 849   hp*|HP*)
 850     define_stdc_a1=yes;;
 851   *)
 852     define_stdc_a1=no;;
 853 esac
 854
 855 if test $define_stdc_a1 = yes
 856 then
 857   AC_DEFINE([_INCLUDE__STDC_A1_SOURCE], [1],
 858             [Define to include mbstate_t for mbrtowc])
 859 fi
 860
 861 # Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,
 862 # it may influence the way we can build extensions, so distutils
 863 # needs to check it
 864 AC_SUBST([CONFIGURE_MACOSX_DEPLOYMENT_TARGET])
 865 AC_SUBST([EXPORT_MACOSX_DEPLOYMENT_TARGET])
 866 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=
 867 EXPORT_MACOSX_DEPLOYMENT_TARGET='#'
 868
 869 # Record the value of IPHONEOS_DEPLOYMENT_TARGET enforced by the selected host triple.
 870 AC_SUBST([IPHONEOS_DEPLOYMENT_TARGET])
 871
 872 # checks for alternative programs
 873
 874 # compiler flags are generated in two sets, BASECFLAGS and OPT.  OPT is just
 875 # for debug/optimization stuff.  BASECFLAGS is for flags that are required
 876 # just to get things to compile and link.  Users are free to override OPT
 877 # when running configure or make.  The build should not break if they do.
 878 # BASECFLAGS should generally not be messed with, however.
 879
 880 # If the user switches compilers, we can't believe the cache
 881 if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
 882 then
 883   AC_MSG_ERROR([cached CC is different -- throw away $cache_file
 884 (it is also a good idea to do 'make clean' before compiling)])
 885 fi
 886
 887 # Don't let AC_PROG_CC set the default CFLAGS. It normally sets -g -O2
 888 # when the compiler supports them, but we don't always want -O2, and
 889 # we set -g later.
 890 if test -z "$CFLAGS"; then
 891         CFLAGS=
 892 fi
 893
 894 dnl Emscripten SDK and WASI SDK default to wasm32.
 895 dnl On Emscripten use MEMORY64 setting to build target wasm64-emscripten.
 896 dnl for wasm64.
 897 AS_CASE([$host],
 898   [wasm64-*-emscripten], [
 899     AS_VAR_APPEND([CFLAGS], [" -sMEMORY64=1"])
 900     AS_VAR_APPEND([LDFLAGS], [" -sMEMORY64=1"])
 901   ],
 902 )
 903
 904 dnl Add the compiler flag for the iOS minimum supported OS version.
 905 AS_CASE([$ac_sys_system],
 906   [iOS], [
 907     AS_VAR_APPEND([CFLAGS], [" -mios-version-min=${IPHONEOS_DEPLOYMENT_TARGET}"])
 908     AS_VAR_APPEND([LDFLAGS], [" -mios-version-min=${IPHONEOS_DEPLOYMENT_TARGET}"])
 909   ],
 910 )
 911
 912 if test "$ac_sys_system" = "Darwin"
 913 then
 914   dnl look for SDKROOT
 915   AC_CHECK_PROG([HAS_XCRUN], [xcrun], [yes], [missing])
 916   AC_MSG_CHECKING([macOS SDKROOT])
 917   if test -z "$SDKROOT"; then
 918     dnl SDKROOT not set
 919     if test "$HAS_XCRUN" = "yes"; then
 920       dnl detect with Xcode
 921       SDKROOT=$(xcrun --show-sdk-path)
 922     else
 923       dnl default to root
 924       SDKROOT="/"
 925     fi
 926   fi
 927   AC_MSG_RESULT([$SDKROOT])
 928
 929         # Compiler selection on MacOSX is more complicated than
 930         # AC_PROG_CC can handle, see Mac/README for more
 931         # information
 932         if test -z "${CC}"
 933         then
 934                 found_gcc=
 935                 found_clang=
 936                 as_save_IFS=$IFS; IFS=:
 937                 for as_dir in $PATH
 938                 do
 939                         IFS=$as_save_IFS
 940                         if test -x "${as_dir}/gcc"; then
 941                                 if test -z "${found_gcc}"; then
 942                                         found_gcc="${as_dir}/gcc"
 943                                 fi
 944                         fi
 945                         if test -x "${as_dir}/clang"; then
 946                                 if test -z "${found_clang}"; then
 947                                         found_clang="${as_dir}/clang"
 948                                 fi
 949                         fi
 950                 done
 951                 IFS=$as_save_IFS
 952
 953                 if test -n "$found_gcc" -a -n "$found_clang"
 954                 then
 955                         if test -n "`"$found_gcc" --version | grep llvm-gcc`"
 956                         then
 957                                 AC_MSG_NOTICE([Detected llvm-gcc, falling back to clang])
 958                                 CC="$found_clang"
 959                                 CXX="$found_clang++"
 960                         fi
 961
 962
 963                 elif test -z "$found_gcc" -a -n "$found_clang"
 964                 then
 965                         AC_MSG_NOTICE([No GCC found, use CLANG])
 966                         CC="$found_clang"
 967                         CXX="$found_clang++"
 968
 969                 elif test -z "$found_gcc" -a -z "$found_clang"
 970                 then
 971                         found_clang=`/usr/bin/xcrun -find clang 2>/dev/null`
 972                         if test -n "${found_clang}"
 973                         then
 974                                 AC_MSG_NOTICE([Using clang from Xcode.app])
 975                                 CC="${found_clang}"
 976                                 CXX="`/usr/bin/xcrun -find clang++`"
 977
 978                         # else: use default behaviour
 979                         fi
 980                 fi
 981         fi
 982 fi
 983 AC_PROG_CC
 984 AC_PROG_CPP
 985 AC_PROG_GREP
 986 AC_PROG_SED
 987 AC_PROG_EGREP
 988
 989 dnl detect compiler name
 990 dnl check for xlc before clang, newer xlc's can use clang as frontend.
 991 dnl check for GCC last, other compilers set __GNUC__, too.
 992 dnl msvc is listed for completeness.
 993 AC_CACHE_CHECK([for CC compiler name], [ac_cv_cc_name], [
 994 cat > conftest.c <<EOF
 995 #if defined(__EMSCRIPTEN__)
 996   emcc
 997 #elif defined(__INTEL_COMPILER) || defined(__ICC)
 998   icc
 999 #elif defined(__ibmxl__) || defined(__xlc__) || defined(__xlC__)
1000   xlc
1001 #elif defined(_MSC_VER)
1002   msvc
1003 #elif defined(__clang__)
1004   clang
1005 #elif defined(__GNUC__)
1006   gcc
1007 #else
1008 #  error unknown compiler
1009 #endif
1010 EOF
1011
1012 if $CPP $CPPFLAGS conftest.c >conftest.out 2>/dev/null; then
1013   ac_cv_cc_name=`grep -v '^#' conftest.out | grep -v '^ *$' | tr -d '   '`
1014   if test $(expr "//$CC" : '.*/\(.*\)') = "mpicc"; then
1015     ac_cv_cc_name="mpicc"
1016   fi
1017 else
1018   ac_cv_cc_name="unknown"
1019 fi
1020 rm -f conftest.c conftest.out
1021 ])
1022
1023 # checks for UNIX variants that set C preprocessor variables
1024 # may set _GNU_SOURCE, __EXTENSIONS__, _POSIX_PTHREAD_SEMANTICS,
1025 # _POSIX_SOURCE, _POSIX_1_SOURCE, and more
1026 AC_USE_SYSTEM_EXTENSIONS
1027
1028 AC_CACHE_CHECK([for GCC compatible compiler],
1029                [ac_cv_gcc_compat],
1030                [AC_PREPROC_IFELSE([AC_LANG_SOURCE([
1031                 #if !defined(__GNUC__)
1032                   #error "not GCC compatible"
1033                 #else
1034                   /* GCC compatible! */
1035                 #endif
1036                ], [])],
1037                [ac_cv_gcc_compat=yes],
1038                [ac_cv_gcc_compat=no])])
1039
1040 AC_SUBST([CXX])
1041
1042 preset_cxx="$CXX"
1043 if test -z "$CXX"
1044 then
1045         case "$CC" in
1046         gcc)    AC_PATH_TOOL([CXX], [g++], [g++], [notfound]) ;;
1047         cc)     AC_PATH_TOOL([CXX], [c++], [c++], [notfound]) ;;
1048         clang|*/clang)     AC_PATH_TOOL([CXX], [clang++], [clang++], [notfound]) ;;
1049         icc|*/icc)         AC_PATH_TOOL([CXX], [icpc], [icpc], [notfound]) ;;
1050         esac
1051         if test "$CXX" = "notfound"
1052         then
1053                 CXX=""
1054         fi
1055 fi
1056 if test -z "$CXX"
1057 then
1058         AC_CHECK_TOOLS([CXX], [$CCC c++ g++ gcc CC cxx cc++ cl], [notfound])
1059         if test "$CXX" = "notfound"
1060         then
1061                 CXX=""
1062         fi
1063 fi
1064 if test "$preset_cxx" != "$CXX"
1065 then
1066         AC_MSG_NOTICE([
1067
1068   By default, distutils will build C++ extension modules with "$CXX".
1069   If this is not intended, then set CXX on the configure command line.
1070   ])
1071 fi
1072
1073
1074 AC_MSG_CHECKING([for the platform triplet based on compiler characteristics])
1075 if $CPP $CPPFLAGS $srcdir/Misc/platform_triplet.c >conftest.out 2>/dev/null; then
1076   PLATFORM_TRIPLET=`grep '^PLATFORM_TRIPLET=' conftest.out | tr -d '    '`
1077   PLATFORM_TRIPLET="${PLATFORM_TRIPLET@%:@PLATFORM_TRIPLET=}"
1078   AC_MSG_RESULT([$PLATFORM_TRIPLET])
1079 else
1080   AC_MSG_RESULT([none])
1081 fi
1082 rm -f conftest.out
1083
1084 dnl On some platforms, using a true "triplet" for MULTIARCH would be redundant.
1085 dnl For example, `arm64-apple-darwin` is redundant, because there isn't a
1086 dnl non-Apple Darwin. Including the CPU architecture can also be potentially
1087 dnl redundant - on macOS, for example, it's possible to do a single compile
1088 dnl pass that includes multiple architectures, so it would be misleading for
1089 dnl MULTIARCH (and thus the sysconfigdata module name) to include a single CPU
1090 dnl architecture. PLATFORM_TRIPLET will be a pair or single value for these
1091 dnl platforms.
1092 AC_MSG_CHECKING([for multiarch])
1093 AS_CASE([$ac_sys_system],
1094   [Darwin*], [MULTIARCH=""],
1095   [iOS], [MULTIARCH=""],
1096   [FreeBSD*], [MULTIARCH=""],
1097   [MULTIARCH=$($CC --print-multiarch 2>/dev/null)]
1098 )
1099 AC_SUBST([MULTIARCH])
1100
1101 if test x$PLATFORM_TRIPLET != x && test x$MULTIARCH != x; then
1102   if test x$PLATFORM_TRIPLET != x$MULTIARCH; then
1103     AC_MSG_ERROR([internal configure error for the platform triplet, please file a bug report])
1104   fi
1105 elif test x$PLATFORM_TRIPLET != x && test x$MULTIARCH = x; then
1106   MULTIARCH=$PLATFORM_TRIPLET
1107 fi
1108 AC_SUBST([PLATFORM_TRIPLET])
1109 AC_MSG_RESULT([$MULTIARCH])
1110
1111 dnl Even if we *do* include the CPU architecture in the MULTIARCH value, some
1112 dnl platforms don't need the CPU architecture in the SOABI tag. These platforms
1113 dnl will have multiple sysconfig modules (one for each CPU architecture), but
1114 dnl use a single "fat" binary at runtime. SOABI_PLATFORM is the component of
1115 dnl the PLATFORM_TRIPLET that will be used in binary module extensions.
1116 AS_CASE([$ac_sys_system],
1117   [iOS], [SOABI_PLATFORM=`echo "$PLATFORM_TRIPLET" | cut -d '-' -f2`],
1118   [SOABI_PLATFORM=$PLATFORM_TRIPLET]
1119 )
1120
1121 if test x$MULTIARCH != x; then
1122   MULTIARCH_CPPFLAGS="-DMULTIARCH=\\\"$MULTIARCH\\\""
1123 fi
1124 AC_SUBST([MULTIARCH_CPPFLAGS])
1125
1126 dnl Support tiers according to https://peps.python.org/pep-0011/
1127 dnl
1128 dnl NOTE: Windows support tiers are defined in PC/pyconfig.h.
1129 dnl
1130 AC_MSG_CHECKING([for PEP 11 support tier])
1131 AS_CASE([$host/$ac_cv_cc_name],
1132   [x86_64-*-linux-gnu/gcc],          [PY_SUPPORT_TIER=1], dnl Linux on AMD64, any vendor, glibc, gcc
1133   [x86_64-apple-darwin*/clang],      [PY_SUPPORT_TIER=1], dnl macOS on Intel, any version
1134   [aarch64-apple-darwin*/clang],     [PY_SUPPORT_TIER=1], dnl macOS on M1, any version
1135   [i686-pc-windows-msvc/msvc],       [PY_SUPPORT_TIER=1], dnl 32bit Windows on Intel, MSVC
1136   [x86_64-pc-windows-msvc/msvc],     [PY_SUPPORT_TIER=1], dnl 64bit Windows on AMD64, MSVC
1137
1138   [aarch64-*-linux-gnu/gcc],         [PY_SUPPORT_TIER=2], dnl Linux ARM64, glibc, gcc+clang
1139   [aarch64-*-linux-gnu/clang],       [PY_SUPPORT_TIER=2],
1140   [powerpc64le-*-linux-gnu/gcc],     [PY_SUPPORT_TIER=2], dnl Linux on PPC64 little endian, glibc, gcc
1141   [wasm32-unknown-wasi/clang],       [PY_SUPPORT_TIER=2], dnl WebAssembly System Interface, clang
1142   [x86_64-*-linux-gnu/clang],        [PY_SUPPORT_TIER=2], dnl Linux on AMD64, any vendor, glibc, clang
1143
1144   [aarch64-pc-windows-msvc/msvc],    [PY_SUPPORT_TIER=3], dnl Windows ARM64, MSVC
1145   [armv7l-*-linux-gnueabihf/gcc],    [PY_SUPPORT_TIER=3], dnl ARMv7 LE with hardware floats, any vendor, glibc, gcc
1146   [powerpc64le-*-linux-gnu/clang],   [PY_SUPPORT_TIER=3], dnl Linux on PPC64 little endian, glibc, clang
1147   [s390x-*-linux-gnu/gcc],           [PY_SUPPORT_TIER=3], dnl Linux on 64bit s390x (big endian), glibc, gcc
1148   [x86_64-*-freebsd*/clang],         [PY_SUPPORT_TIER=3], dnl FreeBSD on AMD64
1149   [aarch64-apple-ios*-simulator/clang],   [PY_SUPPORT_TIER=3], dnl iOS Simulator on arm64
1150   [aarch64-apple-ios*/clang],             [PY_SUPPORT_TIER=3], dnl iOS on ARM64
1151   [PY_SUPPORT_TIER=0]
1152 )
1153
1154 AS_CASE([$PY_SUPPORT_TIER],
1155   [1], [AC_MSG_RESULT([$host/$ac_cv_cc_name has tier 1 (supported)])],
1156   [2], [AC_MSG_RESULT([$host/$ac_cv_cc_name has tier 2 (supported)])],
1157   [3], [AC_MSG_RESULT([$host/$ac_cv_cc_name has tier 3 (partially supported)])],
1158   [AC_MSG_WARN([$host/$ac_cv_cc_name is not supported])]
1159 )
1160
1161 AC_DEFINE_UNQUOTED([PY_SUPPORT_TIER], [$PY_SUPPORT_TIER], [PEP 11 Support tier (1, 2, 3 or 0 for unsupported)])
1162
1163 AC_CACHE_CHECK([for -Wl,--no-as-needed], [ac_cv_wl_no_as_needed], [
1164   save_LDFLAGS="$LDFLAGS"
1165   AS_VAR_APPEND([LDFLAGS], [" -Wl,--no-as-needed"])
1166   AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
1167     [NO_AS_NEEDED="-Wl,--no-as-needed"
1168      ac_cv_wl_no_as_needed=yes],
1169     [NO_AS_NEEDED=""
1170      ac_cv_wl_no_as_needed=no])
1171   LDFLAGS="$save_LDFLAGS"
1172 ])
1173 AC_SUBST([NO_AS_NEEDED])
1174
1175 AC_MSG_CHECKING([for the Android API level])
1176 cat > conftest.c <<EOF
1177 #ifdef __ANDROID__
1178 android_api = __ANDROID_API__
1179 arm_arch = __ARM_ARCH
1180 #else
1181 #error not Android
1182 #endif
1183 EOF
1184
1185 if $CPP $CPPFLAGS conftest.c >conftest.out 2>/dev/null; then
1186   ANDROID_API_LEVEL=`sed -n -e '/__ANDROID_API__/d' -e 's/^android_api = //p' conftest.out`
1187   _arm_arch=`sed -n -e '/__ARM_ARCH/d' -e 's/^arm_arch = //p' conftest.out`
1188   AC_MSG_RESULT([$ANDROID_API_LEVEL])
1189   if test -z "$ANDROID_API_LEVEL"; then
1190     AC_MSG_ERROR([Fatal: you must define __ANDROID_API__])
1191   fi
1192   AC_DEFINE_UNQUOTED([ANDROID_API_LEVEL], [$ANDROID_API_LEVEL],
1193                      [The Android API level.])
1194
1195   AC_MSG_CHECKING([for the Android arm ABI])
1196   AC_MSG_RESULT([$_arm_arch])
1197   if test "$_arm_arch" = 7; then
1198     BASECFLAGS="${BASECFLAGS} -mfloat-abi=softfp -mfpu=vfpv3-d16"
1199     LDFLAGS="${LDFLAGS} -march=armv7-a -Wl,--fix-cortex-a8"
1200   fi
1201 else
1202   AC_MSG_RESULT([not Android])
1203 fi
1204 rm -f conftest.c conftest.out
1205
1206 # Check for unsupported systems
1207 AS_CASE([$ac_sys_system/$ac_sys_release],
1208   [atheos*|Linux*/1*], [
1209     AC_MSG_ERROR([m4_normalize([
1210       This system \($ac_sys_system/$ac_sys_release\) is no longer supported.
1211       See README for details.
1212    ])])
1213  ]
1214 )
1215
1216 AC_MSG_CHECKING([for --with-emscripten-target])
1217 AC_ARG_WITH([emscripten-target],
1218   [AS_HELP_STRING([--with-emscripten-target=@<:@browser|node@:>@], [Emscripten platform])],
1219 [
1220         AS_VAR_IF([ac_sys_system], [Emscripten], [
1221     AS_CASE([$with_emscripten_target],
1222       [browser], [ac_sys_emscripten_target=browser],
1223       [node], [ac_sys_emscripten_target=node],
1224 dnl Debug builds with source map / dwarf symbols. Py_DEBUG builds easily
1225 dnl run out of stack space. Detached sybmols and map prohibit some
1226 dnl optimizations and increase file size. Options are undocumented so we
1227 dnl are free to remove them in the future.
1228       [browser-debug], [ac_sys_emscripten_target=browser-debug],
1229       [node-debug], [ac_sys_emscripten_target=node-debug],
1230       [AC_MSG_ERROR([Invalid argument: --with-emscripten-target=browser|node])]
1231     )
1232   ], [
1233     AC_MSG_ERROR([--with-emscripten-target only applies to Emscripten])
1234   ])
1235 ], [
1236   AS_VAR_IF([ac_sys_system], [Emscripten], [ac_sys_emscripten_target=browser])
1237 ])
1238 AC_MSG_RESULT([$ac_sys_emscripten_target])
1239
1240 dnl On Emscripten dlopen() requires -s MAIN_MODULE and -fPIC. The flags
1241 dnl disables dead code elimination and increases the size of the WASM module
1242 dnl by about 1.5 to 2MB. MAIN_MODULE defines __wasm_mutable_globals__.
1243 dnl See https://emscripten.org/docs/compiling/Dynamic-Linking.html
1244 AC_MSG_CHECKING([for --enable-wasm-dynamic-linking])
1245 AC_ARG_ENABLE([wasm-dynamic-linking],
1246   [AS_HELP_STRING([--enable-wasm-dynamic-linking],
1247                   [Enable dynamic linking support for WebAssembly (default is no)])],
1248 [
1249   AS_CASE([$ac_sys_system],
1250     [Emscripten], [],
1251     [WASI], [AC_MSG_ERROR([WASI dynamic linking is not implemented yet.])],
1252     [AC_MSG_ERROR([--enable-wasm-dynamic-linking only applies to Emscripten and WASI])]
1253   )
1254 ], [
1255   enable_wasm_dynamic_linking=missing
1256 ])
1257 AC_MSG_RESULT([$enable_wasm_dynamic_linking])
1258
1259 AC_MSG_CHECKING([for --enable-wasm-pthreads])
1260 AC_ARG_ENABLE([wasm-pthreads],
1261   [AS_HELP_STRING([--enable-wasm-pthreads],
1262                   [Enable pthread emulation for WebAssembly (default is no)])],
1263 [
1264   AS_CASE([$ac_sys_system],
1265     [Emscripten], [],
1266     [WASI], [],
1267     [AC_MSG_ERROR([--enable-wasm-pthreads only applies to Emscripten and WASI])]
1268   )
1269 ], [
1270   enable_wasm_pthreads=missing
1271 ])
1272 AC_MSG_RESULT([$enable_wasm_pthreads])
1273
1274 AC_MSG_CHECKING([for --with-suffix])
1275 AC_ARG_WITH([suffix],
1276             [AS_HELP_STRING([--with-suffix=SUFFIX], [set executable suffix to SUFFIX (default is empty, yes is mapped to '.exe')])],
1277 [
1278         AS_CASE([$with_suffix],
1279     [no], [EXEEXT=],
1280     [yes], [EXEEXT=.exe],
1281     [EXEEXT=$with_suffix]
1282   )
1283 ], [
1284   AS_CASE([$ac_sys_system/$ac_sys_emscripten_target],
1285     [Emscripten/browser*], [EXEEXT=.js],
1286     [Emscripten/node*], [EXEEXT=.js],
1287     [WASI/*], [EXEEXT=.wasm],
1288     [EXEEXT=]
1289   )
1290 ])
1291 AC_MSG_RESULT([$EXEEXT])
1292
1293 # Test whether we're running on a non-case-sensitive system, in which
1294 # case we give a warning if no ext is given
1295 AC_SUBST([BUILDEXEEXT])
1296 AC_MSG_CHECKING([for case-insensitive build directory])
1297 if test ! -d CaseSensitiveTestDir; then
1298 mkdir CaseSensitiveTestDir
1299 fi
1300
1301 if test -d casesensitivetestdir && test -z "$EXEEXT"
1302 then
1303     AC_MSG_RESULT([yes])
1304     BUILDEXEEXT=.exe
1305 else
1306         AC_MSG_RESULT([no])
1307         BUILDEXEEXT=$EXEEXT
1308 fi
1309 rmdir CaseSensitiveTestDir
1310
1311 case $ac_sys_system in
1312 hp*|HP*)
1313     case $CC in
1314     cc|*/cc) CC="$CC -Ae";;
1315     esac;;
1316 esac
1317
1318 AC_SUBST([LIBRARY])
1319 AC_MSG_CHECKING([LIBRARY])
1320 if test -z "$LIBRARY"
1321 then
1322         LIBRARY='libpython$(VERSION)$(ABIFLAGS).a'
1323 fi
1324 AC_MSG_RESULT([$LIBRARY])
1325
1326 # LDLIBRARY is the name of the library to link against (as opposed to the
1327 # name of the library into which to insert object files). BLDLIBRARY is also
1328 # the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
1329 # is blank as the main program is not linked directly against LDLIBRARY.
1330 # LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
1331 # systems without shared libraries, LDLIBRARY is the same as LIBRARY
1332 # (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,
1333 # DLLLIBRARY is the shared (i.e., DLL) library.
1334 #
1335 # RUNSHARED is used to run shared python without installed libraries
1336 #
1337 # INSTSONAME is the name of the shared library that will be use to install
1338 # on the system - some systems like version suffix, others don't
1339 #
1340 # LDVERSION is the shared library version number, normally the Python version
1341 # with the ABI build flags appended.
1342 AC_SUBST([LDLIBRARY])
1343 AC_SUBST([DLLLIBRARY])
1344 AC_SUBST([BLDLIBRARY])
1345 AC_SUBST([PY3LIBRARY])
1346 AC_SUBST([LDLIBRARYDIR])
1347 AC_SUBST([INSTSONAME])
1348 AC_SUBST([RUNSHARED])
1349 AC_SUBST([LDVERSION])
1350 LDLIBRARY="$LIBRARY"
1351 BLDLIBRARY='$(LDLIBRARY)'
1352 INSTSONAME='$(LDLIBRARY)'
1353 DLLLIBRARY=''
1354 LDLIBRARYDIR=''
1355 RUNSHARED=''
1356 LDVERSION="$VERSION"
1357
1358 # LINKCC is the command that links the python executable -- default is $(CC).
1359 # If CXX is set, and if it is needed to link a main function that was
1360 # compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable:
1361 # python might then depend on the C++ runtime
1362 AC_SUBST([LINKCC])
1363 AC_MSG_CHECKING([LINKCC])
1364 if test -z "$LINKCC"
1365 then
1366         LINKCC='$(PURIFY) $(CC)'
1367         case $ac_sys_system in
1368         QNX*)
1369            # qcc must be used because the other compilers do not
1370            # support -N.
1371            LINKCC=qcc;;
1372         esac
1373 fi
1374 AC_MSG_RESULT([$LINKCC])
1375
1376 # EXPORTSYMS holds the list of exported symbols for AIX.
1377 # EXPORTSFROM holds the module name exporting symbols on AIX.
1378 EXPORTSYMS=
1379 EXPORTSFROM=
1380 AC_SUBST([EXPORTSYMS])
1381 AC_SUBST([EXPORTSFROM])
1382 AC_MSG_CHECKING([EXPORTSYMS])
1383 case $ac_sys_system in
1384 AIX*)
1385         EXPORTSYMS="Modules/python.exp"
1386         EXPORTSFROM=. # the main executable
1387         ;;
1388 esac
1389 AC_MSG_RESULT([$EXPORTSYMS])
1390
1391 # GNULD is set to "yes" if the GNU linker is used.  If this goes wrong
1392 # make sure we default having it set to "no": this is used by
1393 # distutils.unixccompiler to know if it should add --enable-new-dtags
1394 # to linker command lines, and failing to detect GNU ld simply results
1395 # in the same behaviour as before.
1396 AC_SUBST([GNULD])
1397 AC_MSG_CHECKING([for GNU ld])
1398 ac_prog=ld
1399 if test "$GCC" = yes; then
1400        ac_prog=`$CC -print-prog-name=ld`
1401 fi
1402 case `"$ac_prog" -V 2>&1 < /dev/null` in
1403       *GNU*)
1404           GNULD=yes;;
1405       *)
1406           GNULD=no;;
1407 esac
1408 AC_MSG_RESULT([$GNULD])
1409
1410 AC_MSG_CHECKING([for --enable-shared])
1411 AC_ARG_ENABLE([shared],
1412               AS_HELP_STRING([--enable-shared], [enable building a shared Python library (default is no)]))
1413
1414 if test -z "$enable_shared"
1415 then
1416   case $ac_sys_system in
1417   CYGWIN*)
1418     enable_shared="yes";;
1419   *)
1420     enable_shared="no";;
1421   esac
1422 fi
1423 AC_MSG_RESULT([$enable_shared])
1424
1425 # --with-static-libpython
1426 STATIC_LIBPYTHON=1
1427 AC_MSG_CHECKING([for --with-static-libpython])
1428 AC_ARG_WITH([static-libpython],
1429   AS_HELP_STRING([--without-static-libpython],
1430                  [do not build libpythonMAJOR.MINOR.a and do not install python.o (default is yes)]),
1431 [
1432 if test "$withval" = no
1433 then
1434   AC_MSG_RESULT([no]);
1435   STATIC_LIBPYTHON=0
1436 else
1437   AC_MSG_RESULT([yes]);
1438 fi],
1439 [AC_MSG_RESULT([yes])])
1440 AC_SUBST([STATIC_LIBPYTHON])
1441
1442 AC_MSG_CHECKING([for --enable-profiling])
1443 AC_ARG_ENABLE([profiling],
1444               AS_HELP_STRING([--enable-profiling], [enable C-level code profiling with gprof (default is no)]))
1445 if test "x$enable_profiling" = xyes; then
1446   ac_save_cc="$CC"
1447   CC="$CC -pg"
1448   AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void) { return 0; }]])],
1449     [],
1450     [enable_profiling=no])
1451   CC="$ac_save_cc"
1452 else
1453   enable_profiling=no
1454 fi
1455 AC_MSG_RESULT([$enable_profiling])
1456
1457 if test "x$enable_profiling" = xyes; then
1458   BASECFLAGS="-pg $BASECFLAGS"
1459   LDFLAGS="-pg $LDFLAGS"
1460 fi
1461
1462 AC_MSG_CHECKING([LDLIBRARY])
1463
1464 # Apple framework builds need more magic. LDLIBRARY is the dynamic
1465 # library that we build, but we do not want to link against it (we
1466 # will find it with a -framework option). For this reason there is an
1467 # extra variable BLDLIBRARY against which Python and the extension
1468 # modules are linked, BLDLIBRARY. This is normally the same as
1469 # LDLIBRARY, but empty for MacOSX framework builds. iOS does the same,
1470 # but uses a non-versioned framework layout.
1471 if test "$enable_framework"
1472 then
1473   case $ac_sys_system in
1474     Darwin)
1475       LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)';;
1476     iOS)
1477       LDLIBRARY='$(PYTHONFRAMEWORKDIR)/$(PYTHONFRAMEWORK)';;
1478     *)
1479       AC_MSG_ERROR([Unknown platform for framework build]);;
1480   esac
1481   BLDLIBRARY=''
1482   RUNSHARED=DYLD_FRAMEWORK_PATH=`pwd`${DYLD_FRAMEWORK_PATH:+:${DYLD_FRAMEWORK_PATH}}
1483 else
1484   BLDLIBRARY='$(LDLIBRARY)'
1485 fi
1486
1487 # Other platforms follow
1488 if test $enable_shared = "yes"; then
1489   PY_ENABLE_SHARED=1
1490   AC_DEFINE([Py_ENABLE_SHARED], [1],
1491             [Defined if Python is built as a shared library.])
1492   case $ac_sys_system in
1493     CYGWIN*)
1494       LDLIBRARY='libpython$(LDVERSION).dll.a'
1495       BLDLIBRARY='-L. -lpython$(LDVERSION)'
1496       DLLLIBRARY='libpython$(LDVERSION).dll'
1497       ;;
1498     SunOS*)
1499       LDLIBRARY='libpython$(LDVERSION).so'
1500       BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(LDVERSION)'
1501       RUNSHARED=LD_LIBRARY_PATH=`pwd`${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}
1502       INSTSONAME="$LDLIBRARY".$SOVERSION
1503       if test "$with_pydebug" != yes
1504       then
1505         PY3LIBRARY=libpython3.so
1506       fi
1507       ;;
1508     Linux*|GNU*|NetBSD*|FreeBSD*|DragonFly*|OpenBSD*|VxWorks*)
1509       LDLIBRARY='libpython$(LDVERSION).so'
1510       BLDLIBRARY='-L. -lpython$(LDVERSION)'
1511       RUNSHARED=LD_LIBRARY_PATH=`pwd`${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}
1512
1513       # The Android Gradle plugin will only package libraries whose names end
1514       # with ".so".
1515       if test "$ac_sys_system" != "Linux-android"; then
1516           INSTSONAME="$LDLIBRARY".$SOVERSION
1517       fi
1518
1519       if test "$with_pydebug" != yes
1520       then
1521         PY3LIBRARY=libpython3.so
1522       fi
1523       ;;
1524     hp*|HP*)
1525       case `uname -m` in
1526         ia64)
1527           LDLIBRARY='libpython$(LDVERSION).so'
1528           ;;
1529         *)
1530           LDLIBRARY='libpython$(LDVERSION).sl'
1531           ;;
1532       esac
1533       BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(LDVERSION)'
1534       RUNSHARED=SHLIB_PATH=`pwd`${SHLIB_PATH:+:${SHLIB_PATH}}
1535       ;;
1536     Darwin*)
1537       LDLIBRARY='libpython$(LDVERSION).dylib'
1538       BLDLIBRARY='-L. -lpython$(LDVERSION)'
1539       RUNSHARED=DYLD_LIBRARY_PATH=`pwd`${DYLD_LIBRARY_PATH:+:${DYLD_LIBRARY_PATH}}
1540       ;;
1541     iOS)
1542       LDLIBRARY='libpython$(LDVERSION).dylib'
1543       ;;
1544     AIX*)
1545       LDLIBRARY='libpython$(LDVERSION).so'
1546       RUNSHARED=LIBPATH=`pwd`${LIBPATH:+:${LIBPATH}}
1547       ;;
1548
1549   esac
1550 else # shared is disabled
1551   PY_ENABLE_SHARED=0
1552   case $ac_sys_system in
1553     CYGWIN*)
1554       BLDLIBRARY='$(LIBRARY)'
1555       LDLIBRARY='libpython$(LDVERSION).dll.a'
1556       ;;
1557   esac
1558 fi
1559 AC_MSG_RESULT([$LDLIBRARY])
1560
1561 if test "$cross_compiling" = yes; then
1562   RUNSHARED=
1563 fi
1564
1565 AC_MSG_CHECKING([HOSTRUNNER])
1566 AC_ARG_VAR([HOSTRUNNER], [Program to run CPython for the host platform])
1567 if test -z "$HOSTRUNNER"
1568 then
1569   AS_CASE([$ac_sys_system/$ac_sys_emscripten_target],
1570     [Emscripten/node*], [
1571       AC_PATH_TOOL([NODE], [node], [node])
1572       HOSTRUNNER="$NODE"
1573       # bigint for ctypes c_longlong, c_longdouble
1574       # no longer available in Node 16
1575       AC_CACHE_CHECK([for node --experimental-wasm-bigint], [ac_cv_tool_node_wasm_bigint], [
1576         if $NODE -v --experimental-wasm-bigint > /dev/null 2>&1; then
1577           ac_cv_tool_node_wasm_bigint=yes
1578         else
1579           ac_cv_tool_node_wasm_bigint=no
1580         fi
1581       ])
1582       AS_VAR_IF([ac_cv_tool_node_wasm_bigint], [yes], [
1583         AS_VAR_APPEND([HOSTRUNNER], [" --experimental-wasm-bigint"])
1584       ])
1585
1586       AS_VAR_IF([enable_wasm_pthreads], [yes], [
1587         AS_VAR_APPEND([HOSTRUNNER], [" --experimental-wasm-threads"])
1588         # no longer available in Node 16
1589         AC_CACHE_CHECK([for node --experimental-wasm-bulk-memory], [ac_cv_tool_node_wasm_bulk_memory], [
1590           if $NODE -v --experimental-wasm-bulk-memory > /dev/null 2>&1; then
1591             ac_cv_tool_node_wasm_bulk_memory=yes
1592           else
1593             ac_cv_tool_node_wasm_bulk_memory=no
1594           fi
1595         ])
1596         AS_VAR_IF([ac_cv_tool_node_wasm_bulk_memory], [yes], [
1597           AS_VAR_APPEND([HOSTRUNNER], [" --experimental-wasm-bulk-memory"])
1598         ])
1599       ])
1600
1601       AS_VAR_IF([host_cpu], [wasm64], [AS_VAR_APPEND([HOSTRUNNER], [" --experimental-wasm-memory64"])])
1602     ],
1603     dnl TODO: support other WASI runtimes
1604     dnl wasmtime starts the proces with "/" as CWD. For OOT builds add the
1605     dnl directory containing _sysconfigdata to PYTHONPATH.
1606     [WASI/*], [HOSTRUNNER='wasmtime run --wasm max-wasm-stack=8388608 --wasi preview2 --env PYTHONPATH=/$(shell realpath --relative-to $(abs_srcdir) $(abs_builddir))/$(shell cat pybuilddir.txt):/Lib --dir $(srcdir)::/'],
1607     [HOSTRUNNER='']
1608   )
1609 fi
1610 AC_SUBST([HOSTRUNNER])
1611 AC_MSG_RESULT([$HOSTRUNNER])
1612
1613 if test -n "$HOSTRUNNER"; then
1614   dnl Pass hostrunner variable as env var in order to expand shell expressions.
1615   PYTHON_FOR_BUILD="_PYTHON_HOSTRUNNER='$HOSTRUNNER' $PYTHON_FOR_BUILD"
1616 fi
1617
1618 # LIBRARY_DEPS, LINK_PYTHON_OBJS and LINK_PYTHON_DEPS variable
1619 AS_CASE([$ac_sys_system/$ac_sys_emscripten_target],
1620   [Emscripten/browser*], [LIBRARY_DEPS='$(PY3LIBRARY) $(WASM_STDLIB) python.html python.worker.js'],
1621   [LIBRARY_DEPS='$(PY3LIBRARY) $(EXPORTSYMS)']
1622 )
1623 LINK_PYTHON_DEPS='$(LIBRARY_DEPS)'
1624 if test "$PY_ENABLE_SHARED" = 1 || test "$enable_framework" ; then
1625     LIBRARY_DEPS="\$(LDLIBRARY) $LIBRARY_DEPS"
1626     if test "$STATIC_LIBPYTHON" = 1; then
1627         LIBRARY_DEPS="\$(LIBRARY) $LIBRARY_DEPS"
1628     fi
1629     # Link Python program to the shared library
1630     LINK_PYTHON_OBJS='$(BLDLIBRARY)'
1631 else
1632     if test "$STATIC_LIBPYTHON" = 0; then
1633         # Build Python needs object files but don't need to build
1634         # Python static library
1635         LINK_PYTHON_DEPS="$LIBRARY_DEPS \$(LIBRARY_OBJS)"
1636     fi
1637     LIBRARY_DEPS="\$(LIBRARY) $LIBRARY_DEPS"
1638     # Link Python program to object files
1639     LINK_PYTHON_OBJS='$(LIBRARY_OBJS)'
1640 fi
1641 AC_SUBST([LIBRARY_DEPS])
1642 AC_SUBST([LINK_PYTHON_DEPS])
1643 AC_SUBST([LINK_PYTHON_OBJS])
1644
1645 # ar program
1646 AC_SUBST([AR])
1647 AC_CHECK_TOOLS([AR], [ar aal], [ar])
1648
1649 # tweak ARFLAGS only if the user didn't set it on the command line
1650 AC_SUBST([ARFLAGS])
1651 if test -z "$ARFLAGS"
1652 then
1653         ARFLAGS="rcs"
1654 fi
1655
1656 case $MACHDEP in
1657 hp*|HP*)
1658         # install -d does not work on HP-UX
1659         if test -z "$INSTALL"
1660         then
1661                 INSTALL="${srcdir}/install-sh -c"
1662         fi
1663 esac
1664 AC_PROG_INSTALL
1665 AC_PROG_MKDIR_P
1666
1667 # Not every filesystem supports hard links
1668 AC_SUBST([LN])
1669 if test -z "$LN" ; then
1670         case $ac_sys_system in
1671                 CYGWIN*) LN="ln -s";;
1672                 *) LN=ln;;
1673         esac
1674 fi
1675
1676 # For calculating the .so ABI tag.
1677 AC_SUBST([ABIFLAGS])
1678 ABIFLAGS=""
1679
1680 # Check for --disable-gil
1681 # --disable-gil
1682 AC_MSG_CHECKING([for --disable-gil])
1683 AC_ARG_ENABLE([gil],
1684   [AS_HELP_STRING([--disable-gil], [enable experimental support for running without the GIL (default is no)])],
1685   [AS_VAR_IF([enable_gil], [yes], [disable_gil=no], [disable_gil=yes])], [disable_gil=no]
1686 )
1687 AC_MSG_RESULT([$disable_gil])
1688
1689 if test "$disable_gil" = "yes"
1690 then
1691   AC_DEFINE([Py_GIL_DISABLED], [1],
1692             [Define if you want to disable the GIL])
1693   # Add "t" for "threaded"
1694   ABIFLAGS="${ABIFLAGS}t"
1695 fi
1696
1697 # Check for --with-pydebug
1698 AC_MSG_CHECKING([for --with-pydebug])
1699 AC_ARG_WITH([pydebug],
1700   [AS_HELP_STRING([--with-pydebug], [build with Py_DEBUG defined (default is no)]) ],
1701 [
1702 if test "$withval" != no
1703 then
1704   AC_DEFINE([Py_DEBUG], [1],
1705   [Define if you want to build an interpreter with many run-time checks.])
1706   AC_MSG_RESULT([yes]);
1707   Py_DEBUG='true'
1708   ABIFLAGS="${ABIFLAGS}d"
1709 else AC_MSG_RESULT([no]); Py_DEBUG='false'
1710 fi],
1711 [AC_MSG_RESULT([no])])
1712
1713 # Check for --with-trace-refs
1714 # --with-trace-refs
1715 AC_MSG_CHECKING([for --with-trace-refs])
1716 AC_ARG_WITH([trace-refs],
1717   [AS_HELP_STRING([--with-trace-refs], [enable tracing references for debugging purpose (default is no)])],
1718   [], [with_trace_refs=no]
1719 )
1720 AC_MSG_RESULT([$with_trace_refs])
1721
1722 if test "$with_trace_refs" = "yes"
1723 then
1724   AC_DEFINE([Py_TRACE_REFS], [1],
1725             [Define if you want to enable tracing references for debugging purpose])
1726 fi
1727
1728
1729 # Check for --enable-pystats
1730 AC_MSG_CHECKING([for --enable-pystats])
1731 AC_ARG_ENABLE([pystats],
1732   [AS_HELP_STRING(
1733     [--enable-pystats],
1734     [enable internal statistics gathering (default is no)]
1735   )],
1736   [], [enable_pystats=no]
1737 )
1738 AC_MSG_RESULT([$enable_pystats])
1739
1740 AS_VAR_IF([enable_pystats], [yes], [
1741   AC_DEFINE([Py_STATS], [1], [Define if you want to enable internal statistics gathering.])
1742 ])
1743
1744 # Check for --with-assertions.
1745 # This allows enabling assertions without Py_DEBUG.
1746 assertions='false'
1747 AC_MSG_CHECKING([for --with-assertions])
1748 AC_ARG_WITH([assertions],
1749             AS_HELP_STRING([--with-assertions],[build with C assertions enabled (default is no)]),
1750 [
1751 if test "$withval" != no
1752 then
1753   assertions='true'
1754 fi],
1755 [])
1756 if test "$assertions" = 'true'; then
1757   AC_MSG_RESULT([yes])
1758 elif test "$Py_DEBUG" = 'true'; then
1759   assertions='true'
1760   AC_MSG_RESULT([implied by --with-pydebug])
1761 else
1762   AC_MSG_RESULT([no])
1763 fi
1764
1765 # Check for --enable-experimental-jit:
1766 AC_MSG_CHECKING([for --enable-experimental-jit])
1767 AC_ARG_ENABLE([experimental-jit],
1768               [AS_HELP_STRING([--enable-experimental-jit],
1769                               [build the experimental just-in-time compiler (default is no)])],
1770               [],
1771               [enable_experimental_jit=no])
1772 AS_VAR_IF([enable_experimental_jit],
1773           [no],
1774           [],
1775           [AS_VAR_APPEND([CFLAGS_NODIST], [" -D_Py_JIT"])
1776            AS_VAR_SET([REGEN_JIT_COMMAND],
1777                       ["\$(PYTHON_FOR_REGEN) \$(srcdir)/Tools/jit/build.py $host"])
1778            AS_VAR_SET([JIT_STENCILS_H], ["jit_stencils.h"])
1779            AS_VAR_IF([Py_DEBUG],
1780                      [true],
1781                      [AS_VAR_APPEND([REGEN_JIT_COMMAND], [" --debug"])],
1782                      [])])
1783 AC_SUBST([REGEN_JIT_COMMAND])
1784 AC_SUBST([JIT_STENCILS_H])
1785 AC_MSG_RESULT([$enable_experimental_jit])
1786
1787 # Enable optimization flags
1788 AC_SUBST([DEF_MAKE_ALL_RULE])
1789 AC_SUBST([DEF_MAKE_RULE])
1790 Py_OPT='false'
1791 AC_MSG_CHECKING([for --enable-optimizations])
1792 AC_ARG_ENABLE([optimizations], AS_HELP_STRING(
1793                 [--enable-optimizations],
1794                 [enable expensive, stable optimizations (PGO, etc.) (default is no)]),
1795 [
1796 if test "$enableval" != no
1797 then
1798   Py_OPT='true'
1799   AC_MSG_RESULT([yes]);
1800 else
1801   Py_OPT='false'
1802   AC_MSG_RESULT([no]);
1803 fi],
1804 [AC_MSG_RESULT([no])])
1805
1806 if test "$Py_OPT" = 'true' ; then
1807   # Intentionally not forcing Py_LTO='true' here.  Too many toolchains do not
1808   # compile working code using it and both test_distutils and test_gdb are
1809   # broken when you do manage to get a toolchain that works with it.  People
1810   # who want LTO need to use --with-lto themselves.
1811   DEF_MAKE_ALL_RULE="profile-opt"
1812   REQUIRE_PGO="yes"
1813   DEF_MAKE_RULE="build_all"
1814   case $CC in
1815     *gcc*)
1816       AX_CHECK_COMPILE_FLAG([-fno-semantic-interposition],[
1817       CFLAGS_NODIST="$CFLAGS_NODIST -fno-semantic-interposition"
1818       LDFLAGS_NODIST="$LDFLAGS_NODIST -fno-semantic-interposition"
1819       ], [], [-Werror])
1820       ;;
1821   esac
1822 elif test "$ac_sys_system" = "Emscripten" -o "$ac_sys_system" = "WASI"; then
1823   dnl Emscripten does not support shared extensions yet. Build
1824   dnl "python.[js,wasm]", "pybuilddir.txt", and "platform" files.
1825   DEF_MAKE_ALL_RULE="build_wasm"
1826   REQUIRE_PGO="no"
1827   DEF_MAKE_RULE="all"
1828 else
1829   DEF_MAKE_ALL_RULE="build_all"
1830   REQUIRE_PGO="no"
1831   DEF_MAKE_RULE="all"
1832 fi
1833
1834 AC_ARG_VAR([PROFILE_TASK], [Python args for PGO generation task])
1835 AC_MSG_CHECKING([PROFILE_TASK])
1836 if test -z "$PROFILE_TASK"
1837 then
1838         PROFILE_TASK='-m test --pgo --timeout=$(TESTTIMEOUT)'
1839 fi
1840 AC_MSG_RESULT([$PROFILE_TASK])
1841
1842 # Make llvm-related checks work on systems where llvm tools are not installed with their
1843 # normal names in the default $PATH (ie: Ubuntu).  They exist under the
1844 # non-suffixed name in their versioned llvm directory.
1845
1846 llvm_bin_dir=''
1847 llvm_path="${PATH}"
1848 if test "${CC}" = "clang"
1849 then
1850   clang_bin=`which clang`
1851   # Some systems install clang elsewhere as a symlink to the real path
1852   # which is where the related llvm tools are located.
1853   if test -L "${clang_bin}"
1854   then
1855     clang_dir=`dirname "${clang_bin}"`
1856     clang_bin=`readlink "${clang_bin}"`
1857     llvm_bin_dir="${clang_dir}/"`dirname "${clang_bin}"`
1858     llvm_path="${llvm_path}${PATH_SEPARATOR}${llvm_bin_dir}"
1859   fi
1860 fi
1861
1862 # Enable LTO flags
1863 AC_MSG_CHECKING([for --with-lto])
1864 AC_ARG_WITH([lto],
1865   [AS_HELP_STRING([--with-lto=@<:@full|thin|no|yes@:>@], [enable Link-Time-Optimization in any build (default is no)])],
1866 [
1867 case "$withval" in
1868     full)
1869         Py_LTO='true'
1870         Py_LTO_POLICY='full'
1871         AC_MSG_RESULT([yes])
1872         ;;
1873     thin)
1874         Py_LTO='true'
1875         Py_LTO_POLICY='thin'
1876         AC_MSG_RESULT([yes])
1877         ;;
1878     yes)
1879         Py_LTO='true'
1880         Py_LTO_POLICY='default'
1881         AC_MSG_RESULT([yes])
1882         ;;
1883     no)
1884         Py_LTO='false'
1885         AC_MSG_RESULT([no])
1886         ;;
1887     *)
1888         Py_LTO='false'
1889         AC_MSG_ERROR([unknown lto option: '$withval'])
1890         ;;
1891 esac
1892 ],
1893 [AC_MSG_RESULT([no])])
1894 if test "$Py_LTO" = 'true' ; then
1895   case $CC in
1896     *clang*)
1897       LDFLAGS_NOLTO="-fno-lto"
1898       dnl Clang linker requires -flto in order to link objects with LTO information.
1899       dnl Thin LTO is faster and works for object files with full LTO information, too.
1900       AX_CHECK_COMPILE_FLAG([-flto=thin],[LDFLAGS_NOLTO="-flto=thin"],[LDFLAGS_NOLTO="-flto"])
1901       AC_SUBST([LLVM_AR])
1902       AC_PATH_TOOL([LLVM_AR], [llvm-ar], [''], [${llvm_path}])
1903       AC_SUBST([LLVM_AR_FOUND])
1904       if test -n "${LLVM_AR}" -a -x "${LLVM_AR}"
1905       then
1906         LLVM_AR_FOUND="found"
1907       else
1908         LLVM_AR_FOUND="not-found"
1909       fi
1910       if test "$ac_sys_system" = "Darwin" -a "${LLVM_AR_FOUND}" = "not-found"
1911       then
1912         # The Apple-supplied ar in Xcode or the Command Line Tools is apparently sufficient
1913         found_llvm_ar=`/usr/bin/xcrun -find ar 2>/dev/null`
1914         if test -n "${found_llvm_ar}"
1915         then
1916           LLVM_AR='/usr/bin/xcrun ar'
1917           LLVM_AR_FOUND=found
1918           AC_MSG_NOTICE([llvm-ar found via xcrun: ${LLVM_AR}])
1919         fi
1920       fi
1921       if test $LLVM_AR_FOUND = not-found
1922       then
1923         LLVM_PROFR_ERR=yes
1924         AC_MSG_ERROR([llvm-ar is required for a --with-lto build with clang but could not be found.])
1925       else
1926         LLVM_AR_ERR=no
1927       fi
1928       AR="${LLVM_AR}"
1929       case $ac_sys_system in
1930         Darwin*)
1931           # Any changes made here should be reflected in the GCC+Darwin case below
1932           if test $Py_LTO_POLICY = default
1933           then
1934             # Check that ThinLTO is accepted.
1935             AX_CHECK_COMPILE_FLAG([-flto=thin],[
1936               LTOFLAGS="-flto=thin -Wl,-export_dynamic -Wl,-object_path_lto,\"\$@\".lto"
1937               LTOCFLAGS="-flto=thin"
1938               ],[
1939               LTOFLAGS="-flto -Wl,-export_dynamic -Wl,-object_path_lto,\"\$@\".lto"
1940               LTOCFLAGS="-flto"
1941               ]
1942             )
1943           else
1944             LTOFLAGS="-flto=${Py_LTO_POLICY} -Wl,-export_dynamic -Wl,-object_path_lto,\"\$@\".lto"
1945             LTOCFLAGS="-flto=${Py_LTO_POLICY}"
1946           fi
1947           ;;
1948         *)
1949           if test $Py_LTO_POLICY = default
1950           then
1951             # Check that ThinLTO is accepted
1952             AX_CHECK_COMPILE_FLAG([-flto=thin],[LTOFLAGS="-flto=thin"],[LTOFLAGS="-flto"])
1953           else
1954             LTOFLAGS="-flto=${Py_LTO_POLICY}"
1955           fi
1956           ;;
1957       esac
1958       ;;
1959     *emcc*)
1960       if test "$Py_LTO_POLICY" != "default"; then
1961         AC_MSG_ERROR([emcc supports only default lto.])
1962       fi
1963       LTOFLAGS="-flto"
1964       LTOCFLAGS="-flto"
1965       ;;
1966     *gcc*)
1967       if test $Py_LTO_POLICY = thin
1968       then
1969         AC_MSG_ERROR([thin lto is not supported under gcc compiler.])
1970       fi
1971       dnl flag to disable lto during linking
1972       LDFLAGS_NOLTO="-fno-lto"
1973       case $ac_sys_system in
1974         Darwin*)
1975           LTOFLAGS="-flto -Wl,-export_dynamic -Wl,-object_path_lto,\"\$@\".lto"
1976           LTOCFLAGS="-flto"
1977           ;;
1978         *)
1979           LTOFLAGS="-flto -fuse-linker-plugin -ffat-lto-objects -flto-partition=none"
1980           ;;
1981       esac
1982       ;;
1983   esac
1984
1985   if test "$ac_cv_prog_cc_g" = "yes"
1986   then
1987       # bpo-30345: Add -g to LDFLAGS when compiling with LTO
1988       # to get debug symbols.
1989       LTOFLAGS="$LTOFLAGS -g"
1990   fi
1991
1992   CFLAGS_NODIST="$CFLAGS_NODIST ${LTOCFLAGS-$LTOFLAGS}"
1993   LDFLAGS_NODIST="$LDFLAGS_NODIST $LTOFLAGS"
1994 fi
1995
1996 # Enable PGO flags.
1997 AC_SUBST([PGO_PROF_GEN_FLAG])
1998 AC_SUBST([PGO_PROF_USE_FLAG])
1999 AC_SUBST([LLVM_PROF_MERGER])
2000 AC_SUBST([LLVM_PROF_FILE])
2001 AC_SUBST([LLVM_PROF_ERR])
2002 AC_SUBST([LLVM_PROFDATA])
2003 AC_PATH_TOOL([LLVM_PROFDATA], [llvm-profdata], [''], [${llvm_path}])
2004 AC_SUBST([LLVM_PROF_FOUND])
2005 if test -n "${LLVM_PROFDATA}" -a -x "${LLVM_PROFDATA}"
2006 then
2007   LLVM_PROF_FOUND="found"
2008 else
2009   LLVM_PROF_FOUND="not-found"
2010 fi
2011 if test "$ac_sys_system" = "Darwin" -a "${LLVM_PROF_FOUND}" = "not-found"
2012 then
2013   found_llvm_profdata=`/usr/bin/xcrun -find llvm-profdata 2>/dev/null`
2014   if test -n "${found_llvm_profdata}"
2015   then
2016     # llvm-profdata isn't directly in $PATH in some cases.
2017     # https://apple.stackexchange.com/questions/197053/
2018     LLVM_PROFDATA='/usr/bin/xcrun llvm-profdata'
2019     LLVM_PROF_FOUND=found
2020     AC_MSG_NOTICE([llvm-profdata found via xcrun: ${LLVM_PROFDATA}])
2021   fi
2022 fi
2023 LLVM_PROF_ERR=no
2024
2025 # GNU Autoconf recommends the use of expr instead of basename.
2026 AS_VAR_SET([CC_BASENAME], [$(expr "//$CC" : '.*/\(.*\)')])
2027 case "$CC_BASENAME" in
2028   *clang*)
2029     # Any changes made here should be reflected in the GCC+Darwin case below
2030     PGO_PROF_GEN_FLAG="-fprofile-instr-generate"
2031     PGO_PROF_USE_FLAG="-fprofile-instr-use=\"\$(shell pwd)/code.profclangd\""
2032     LLVM_PROF_MERGER=m4_normalize("
2033         ${LLVM_PROFDATA} merge
2034             -output=\"\$(shell pwd)/code.profclangd\"
2035             \"\$(shell pwd)\"/*.profclangr
2036     ")
2037     LLVM_PROF_FILE="LLVM_PROFILE_FILE=\"\$(shell pwd)/code-%p.profclangr\""
2038     if test $LLVM_PROF_FOUND = not-found
2039     then
2040       LLVM_PROF_ERR=yes
2041       if test "${REQUIRE_PGO}" = "yes"
2042       then
2043         AC_MSG_ERROR([llvm-profdata is required for a --enable-optimizations build but could not be found.])
2044       fi
2045     fi
2046     ;;
2047   *gcc*)
2048     case $ac_sys_system in
2049       Darwin*)
2050         PGO_PROF_GEN_FLAG="-fprofile-instr-generate"
2051         PGO_PROF_USE_FLAG="-fprofile-instr-use=\"\$(shell pwd)/code.profclangd\""
2052         LLVM_PROF_MERGER=m4_normalize("
2053             ${LLVM_PROFDATA} merge
2054                 -output=\"\$(shell pwd)/code.profclangd\"
2055                 \"\$(shell pwd)\"/*.profclangr
2056         ")
2057         LLVM_PROF_FILE="LLVM_PROFILE_FILE=\"\$(shell pwd)/code-%p.profclangr\""
2058         if test "${LLVM_PROF_FOUND}" = "not-found"
2059         then
2060           LLVM_PROF_ERR=yes
2061           if test "${REQUIRE_PGO}" = "yes"
2062           then
2063             AC_MSG_ERROR([llvm-profdata is required for a --enable-optimizations build but could not be found.])
2064           fi
2065         fi
2066         ;;
2067       *)
2068         PGO_PROF_GEN_FLAG="-fprofile-generate"
2069         PGO_PROF_USE_FLAG="-fprofile-use -fprofile-correction"
2070         LLVM_PROF_MERGER="true"
2071         LLVM_PROF_FILE=""
2072         ;;
2073     esac
2074     ;;
2075   *icc*)
2076     PGO_PROF_GEN_FLAG="-prof-gen"
2077     PGO_PROF_USE_FLAG="-prof-use"
2078     LLVM_PROF_MERGER="true"
2079     LLVM_PROF_FILE=""
2080     ;;
2081 esac
2082
2083 # BOLT optimization. Always configured after PGO since it always runs after PGO.
2084 Py_BOLT='false'
2085 AC_MSG_CHECKING([for --enable-bolt])
2086 AC_ARG_ENABLE([bolt], [AS_HELP_STRING(
2087                 [--enable-bolt],
2088                 [enable usage of the llvm-bolt post-link optimizer (default is no)])],
2089 [
2090 if test "$enableval" != no
2091 then
2092   Py_BOLT='true'
2093   AC_MSG_RESULT([yes]);
2094 else
2095   Py_BOLT='false'
2096   AC_MSG_RESULT([no]);
2097 fi],
2098 [AC_MSG_RESULT([no])])
2099
2100 AC_SUBST([PREBOLT_RULE])
2101 if test "$Py_BOLT" = 'true' ; then
2102   PREBOLT_RULE="${DEF_MAKE_ALL_RULE}"
2103   DEF_MAKE_ALL_RULE="bolt-opt"
2104   DEF_MAKE_RULE="build_all"
2105
2106   # -fno-reorder-blocks-and-partition is required for bolt to work.
2107   # Possibly GCC only.
2108   AX_CHECK_COMPILE_FLAG([-fno-reorder-blocks-and-partition],[
2109       CFLAGS_NODIST="$CFLAGS_NODIST -fno-reorder-blocks-and-partition"
2110   ])
2111
2112   # These flags are required for bolt to work:
2113   LDFLAGS_NODIST="$LDFLAGS_NODIST -Wl,--emit-relocs"
2114
2115   # These flags are required to get good performance from bolt:
2116   CFLAGS_NODIST="$CFLAGS_NODIST -fno-pie"
2117   # We want to add these no-pie flags to linking executables but not shared libraries:
2118   LINKCC="$LINKCC -fno-pie -no-pie"
2119   AC_SUBST([LLVM_BOLT])
2120   AC_PATH_TOOL([LLVM_BOLT], [llvm-bolt], [''], [${llvm_path}])
2121   if test -n "${LLVM_BOLT}" -a -x "${LLVM_BOLT}"
2122   then
2123     AC_MSG_RESULT(["Found llvm-bolt"])
2124   else
2125     AC_MSG_ERROR([llvm-bolt is required for a --enable-bolt build but could not be found.])
2126   fi
2127
2128   AC_SUBST([MERGE_FDATA])
2129   AC_PATH_TOOL([MERGE_FDATA], [merge-fdata], [''], [${llvm_path}])
2130   if test -n "${MERGE_FDATA}" -a -x "${MERGE_FDATA}"
2131   then
2132     AC_MSG_RESULT(["Found merge-fdata"])
2133   else
2134     AC_MSG_ERROR([merge-fdata is required for a --enable-bolt build but could not be found.])
2135   fi
2136 fi
2137
2138 dnl Enable BOLT of libpython if built.
2139 AC_SUBST([BOLT_BINARIES])
2140 BOLT_BINARIES='$(BUILDPYTHON)'
2141 AS_VAR_IF([enable_shared], [yes], [
2142   BOLT_BINARIES="${BOLT_BINARIES} \$(INSTSONAME)"
2143 ])
2144
2145 AC_ARG_VAR(
2146   [BOLT_INSTRUMENT_FLAGS],
2147   [Arguments to llvm-bolt when instrumenting binaries]
2148 )
2149 AC_MSG_CHECKING([BOLT_INSTRUMENT_FLAGS])
2150 if test -z "${BOLT_INSTRUMENT_FLAGS}"
2151 then
2152   BOLT_INSTRUMENT_FLAGS=
2153 fi
2154 AC_MSG_RESULT([$BOLT_INSTRUMENT_FLAGS])
2155
2156 AC_ARG_VAR(
2157   [BOLT_APPLY_FLAGS],
2158   [Arguments to llvm-bolt when creating a BOLT optimized binary]
2159 )
2160 AC_MSG_CHECKING([BOLT_APPLY_FLAGS])
2161 if test -z "${BOLT_APPLY_FLAGS}"
2162 then
2163   AS_VAR_SET(
2164     [BOLT_APPLY_FLAGS],
2165     [m4_normalize("
2166      -update-debug-sections
2167      -reorder-blocks=ext-tsp
2168      -reorder-functions=hfsort+
2169      -split-functions
2170      -icf=1
2171      -inline-all
2172      -split-eh
2173      -reorder-functions-use-hot-size
2174      -peepholes=none
2175      -jump-tables=aggressive
2176      -inline-ap
2177      -indirect-call-promotion=all
2178      -dyno-stats
2179      -use-gnu-stack
2180      -frame-opt=hot
2181    ")]
2182   )
2183 fi
2184 AC_MSG_RESULT([$BOLT_APPLY_FLAGS])
2185
2186 # XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
2187 # merged with this chunk of code?
2188
2189 # Optimizer/debugger flags
2190 # ------------------------
2191 # (The following bit of code is complicated enough - please keep things
2192 # indented properly.  Just pretend you're editing Python code. ;-)
2193
2194 # There are two parallel sets of case statements below, one that checks to
2195 # see if OPT was set and one that does BASECFLAGS setting based upon
2196 # compiler and platform.  BASECFLAGS tweaks need to be made even if the
2197 # user set OPT.
2198
2199 case $CC in
2200     *clang*)
2201         cc_is_clang=1
2202         ;;
2203     *)
2204         if $CC --version 2>&1 | grep -q clang
2205         then
2206             cc_is_clang=1
2207         else
2208             cc_is_clang=
2209         fi
2210 esac
2211
2212 dnl Historically, some of our code assumed that signed integer overflow
2213 dnl is defined behaviour via twos-complement.
2214 dnl Set STRICT_OVERFLOW_CFLAGS and NO_STRICT_OVERFLOW_CFLAGS depending on compiler support.
2215 dnl Pass the latter to modules that depend on such behaviour.
2216 _SAVE_VAR([CFLAGS])
2217 CFLAGS="-fstrict-overflow -fno-strict-overflow"
2218 AC_CACHE_CHECK([if $CC supports -fstrict-overflow and -fno-strict-overflow],
2219                [ac_cv_cc_supports_fstrict_overflow],
2220   AC_COMPILE_IFELSE(
2221     [AC_LANG_PROGRAM([[]], [[]])],
2222     [ac_cv_cc_supports_fstrict_overflow=yes],
2223     [ac_cv_cc_supports_fstrict_overflow=no]
2224   )
2225 )
2226 _RESTORE_VAR([CFLAGS])
2227
2228 AS_VAR_IF([ac_cv_cc_supports_fstrict_overflow], [yes],
2229           [STRICT_OVERFLOW_CFLAGS="-fstrict-overflow"
2230            NO_STRICT_OVERFLOW_CFLAGS="-fno-strict-overflow"],
2231           [STRICT_OVERFLOW_CFLAGS=""
2232            NO_STRICT_OVERFLOW_CFLAGS=""])
2233
2234 AC_MSG_CHECKING([for --with-strict-overflow])
2235 AC_ARG_WITH([strict-overflow],
2236   AS_HELP_STRING(
2237     [--with-strict-overflow],
2238     [if 'yes', add -fstrict-overflow to CFLAGS, else add -fno-strict-overflow (default is no)]
2239   ),
2240   [
2241     AS_VAR_IF(
2242       [ac_cv_cc_supports_fstrict_overflow], [no],
2243       [AC_MSG_WARN([--with-strict-overflow=yes requires a compiler that supports -fstrict-overflow])],
2244       []
2245     )
2246   ],
2247   [with_strict_overflow=no]
2248 )
2249 AC_MSG_RESULT([$with_strict_overflow])
2250
2251 # Check if CC supports -Og optimization level
2252 _SAVE_VAR([CFLAGS])
2253 CFLAGS="-Og"
2254 AC_CACHE_CHECK([if $CC supports -Og optimization level],
2255                [ac_cv_cc_supports_og],
2256   AC_COMPILE_IFELSE(
2257     [
2258       AC_LANG_PROGRAM([[]], [[]])
2259     ],[
2260       ac_cv_cc_supports_og=yes
2261     ],[
2262       ac_cv_cc_supports_og=no
2263     ])
2264 )
2265 _RESTORE_VAR([CFLAGS])
2266
2267 # Optimization messes up debuggers, so turn it off for
2268 # debug builds.
2269 PYDEBUG_CFLAGS="-O0"
2270 AS_VAR_IF([ac_cv_cc_supports_og], [yes],
2271           [PYDEBUG_CFLAGS="-Og"])
2272
2273 # tweak OPT based on compiler and platform, only if the user didn't set
2274 # it on the command line
2275 AC_SUBST([OPT])
2276 AC_SUBST([CFLAGS_ALIASING])
2277 if test "${OPT-unset}" = "unset"
2278 then
2279     case $GCC in
2280     yes)
2281         if test -n "${cc_is_clang}"
2282         then
2283             # bpo-30104: disable strict aliasing to compile correctly dtoa.c,
2284             # see Makefile.pre.in for more information
2285             CFLAGS_ALIASING="-fno-strict-aliasing"
2286         fi
2287
2288         case $ac_cv_prog_cc_g in
2289         yes)
2290             if test "$Py_DEBUG" = 'true' ; then
2291                 OPT="-g $PYDEBUG_CFLAGS -Wall"
2292             else
2293                 OPT="-g -O3 -Wall"
2294             fi
2295             ;;
2296         *)
2297             OPT="-O3 -Wall"
2298             ;;
2299         esac
2300
2301         case $ac_sys_system in
2302             SCO_SV*) OPT="$OPT -m486 -DSCO5"
2303             ;;
2304         esac
2305         ;;
2306
2307     *)
2308         OPT="-O"
2309         ;;
2310     esac
2311 fi
2312
2313 # WASM flags
2314 AS_CASE([$ac_sys_system],
2315   [Emscripten], [
2316     dnl build with WASM debug info if either Py_DEBUG is set or the target is
2317     dnl node-debug or browser-debug.
2318     AS_VAR_IF([Py_DEBUG], [yes], [wasm_debug=yes], [wasm_debug=no])
2319
2320     dnl Start with 20 MB and allow to grow
2321     AS_VAR_APPEND([LDFLAGS_NODIST], [" -sALLOW_MEMORY_GROWTH -sTOTAL_MEMORY=20971520"])
2322
2323     dnl map int64_t and uint64_t to JS bigint
2324     AS_VAR_APPEND([LDFLAGS_NODIST], [" -sWASM_BIGINT"])
2325
2326     dnl Include file system support
2327     AS_VAR_APPEND([LDFLAGS_NODIST], [" -sFORCE_FILESYSTEM -lidbfs.js -lnodefs.js -lproxyfs.js -lworkerfs.js"])
2328
2329     AS_VAR_IF([enable_wasm_dynamic_linking], [yes], [
2330       AS_VAR_APPEND([LINKFORSHARED], [" -sMAIN_MODULE"])
2331     ])
2332
2333     AS_VAR_IF([enable_wasm_pthreads], [yes], [
2334       AS_VAR_APPEND([CFLAGS_NODIST], [" -pthread"])
2335       AS_VAR_APPEND([LDFLAGS_NODIST], [" -sUSE_PTHREADS"])
2336       AS_VAR_APPEND([LINKFORSHARED], [" -sPROXY_TO_PTHREAD"])
2337     ])
2338
2339     AS_CASE([$ac_sys_emscripten_target],
2340       [browser*], [
2341         AS_VAR_IF([ac_sys_emscripten_target], [browser-debug], [wasm_debug=yes])
2342         AS_VAR_APPEND([LINKFORSHARED], [" --preload-file=\$(WASM_ASSETS_DIR)"])
2343         WASM_ASSETS_DIR=".\$(prefix)"
2344         WASM_STDLIB="\$(WASM_ASSETS_DIR)/local/lib/python\$(VERSION)/os.py"
2345         dnl separate-dwarf does not seem to work in Chrome DevTools Support.
2346         WASM_LINKFORSHARED_DEBUG="-gsource-map --emit-symbol-map"
2347       ],
2348       [node*], [
2349         AS_VAR_IF([ac_sys_emscripten_target], [node-debug], [wasm_debug=yes])
2350         AS_VAR_APPEND([LDFLAGS_NODIST], [" -sALLOW_MEMORY_GROWTH -sNODERAWFS"])
2351         AS_VAR_APPEND([LINKFORSHARED], [" -sEXIT_RUNTIME"])
2352         WASM_LINKFORSHARED_DEBUG="-gseparate-dwarf --emit-symbol-map"
2353       ]
2354     )
2355
2356     AS_VAR_IF([wasm_debug], [yes], [
2357       AS_VAR_APPEND([LDFLAGS_NODIST], [" -sASSERTIONS"])
2358       AS_VAR_APPEND([LINKFORSHARED], [" $WASM_LINKFORSHARED_DEBUG"])
2359     ], [
2360       AS_VAR_APPEND([LINKFORSHARED], [" -O2 -g0"])
2361     ])
2362   ],
2363   [WASI], [
2364     AC_DEFINE([_WASI_EMULATED_SIGNAL], [1], [Define to 1 if you want to emulate signals on WASI])
2365     AC_DEFINE([_WASI_EMULATED_GETPID], [1], [Define to 1 if you want to emulate getpid() on WASI])
2366     AC_DEFINE([_WASI_EMULATED_PROCESS_CLOCKS], [1], [Define to 1 if you want to emulate process clocks on WASI])
2367     LIBS="$LIBS -lwasi-emulated-signal -lwasi-emulated-getpid -lwasi-emulated-process-clocks"
2368     echo "#define _WASI_EMULATED_SIGNAL 1" >> confdefs.h
2369
2370     AS_VAR_IF([enable_wasm_pthreads], [yes], [
2371       # Note: update CFLAGS because ac_compile/ac_link needs this too.
2372       # without this, configure fails to find pthread_create, sem_init,
2373       # etc because they are only available in the sysroot for
2374       # wasm32-wasi-threads.
2375       # Note: wasi-threads requires --import-memory.
2376       # Note: wasi requires --export-memory.
2377       # Note: --export-memory is implicit unless --import-memory is given
2378       # Note: this requires LLVM >= 16.
2379       AS_VAR_APPEND([CFLAGS], [" -target wasm32-wasi-threads -pthread"])
2380       AS_VAR_APPEND([CFLAGS_NODIST], [" -target wasm32-wasi-threads -pthread"])
2381       AS_VAR_APPEND([LDFLAGS_NODIST], [" -target wasm32-wasi-threads -pthread"])
2382       AS_VAR_APPEND([LDFLAGS_NODIST], [" -Wl,--import-memory"])
2383       AS_VAR_APPEND([LDFLAGS_NODIST], [" -Wl,--export-memory"])
2384       AS_VAR_APPEND([LDFLAGS_NODIST], [" -Wl,--max-memory=10485760"])
2385     ])
2386
2387     dnl increase initial memory and stack size, move stack first
2388     dnl https://github.com/WebAssembly/wasi-libc/issues/233
2389     AS_VAR_APPEND([LDFLAGS_NODIST], [" -z stack-size=524288 -Wl,--stack-first -Wl,--initial-memory=10485760"])
2390   ]
2391 )
2392
2393 AS_CASE([$enable_wasm_dynamic_linking],
2394   [yes], [ac_cv_func_dlopen=yes],
2395   [no], [ac_cv_func_dlopen=no],
2396   [missing], []
2397 )
2398
2399 AC_SUBST([BASECFLAGS])
2400 AC_SUBST([CFLAGS_NODIST])
2401 AC_SUBST([LDFLAGS_NODIST])
2402 AC_SUBST([LDFLAGS_NOLTO])
2403 AC_SUBST([WASM_ASSETS_DIR])
2404 AC_SUBST([WASM_STDLIB])
2405
2406 # The -arch flags for universal builds on macOS
2407 UNIVERSAL_ARCH_FLAGS=
2408 AC_SUBST([UNIVERSAL_ARCH_FLAGS])
2409
2410 dnl PY_CHECK_CC_WARNING(ENABLE, WARNING, [MSG])
2411 AC_DEFUN([PY_CHECK_CC_WARNING], [
2412   AS_VAR_PUSHDEF([py_var], [ac_cv_$1_]m4_normalize($2)[_warning])
2413   AC_CACHE_CHECK([m4_ifblank([$3], [if we can $1 $CC $2 warning], [$3])], [py_var], [
2414     AS_VAR_COPY([py_cflags], [CFLAGS])
2415     AS_VAR_APPEND([CFLAGS], ["-W$2 -Werror"])
2416     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
2417                       [AS_VAR_SET([py_var], [yes])],
2418                       [AS_VAR_SET([py_var], [no])])
2419     AS_VAR_COPY([CFLAGS], [py_cflags])
2420   ])
2421   AS_VAR_POPDEF([py_var])
2422 ])
2423
2424 # tweak BASECFLAGS based on compiler and platform
2425 AS_VAR_IF([with_strict_overflow], [yes],
2426           [BASECFLAGS="$BASECFLAGS $STRICT_OVERFLOW_CFLAGS"],
2427           [BASECFLAGS="$BASECFLAGS $NO_STRICT_OVERFLOW_CFLAGS"])
2428
2429 case $GCC in
2430 yes)
2431     CFLAGS_NODIST="$CFLAGS_NODIST -std=c11"
2432
2433     PY_CHECK_CC_WARNING([enable], [extra], [if we can add -Wextra])
2434     AS_VAR_IF([ac_cv_enable_extra_warning], [yes],
2435               [CFLAGS_NODIST="$CFLAGS_NODIST -Wextra"])
2436
2437     # Python doesn't violate C99 aliasing rules, but older versions of
2438     # GCC produce warnings for legal Python code.  Enable
2439     # -fno-strict-aliasing on versions of GCC that support but produce
2440     # warnings.  See Issue3326
2441      ac_save_cc="$CC"
2442      CC="$CC -fno-strict-aliasing"
2443      save_CFLAGS="$CFLAGS"
2444      AC_CACHE_CHECK([whether $CC accepts and needs -fno-strict-aliasing],
2445                     [ac_cv_no_strict_aliasing],
2446        AC_COMPILE_IFELSE(
2447          [
2448            AC_LANG_PROGRAM([[]], [[]])
2449          ],[
2450            CC="$ac_save_cc -fstrict-aliasing"
2451            CFLAGS="$CFLAGS -Werror -Wstrict-aliasing"
2452            AC_COMPILE_IFELSE(
2453              [
2454                AC_LANG_PROGRAM([[void f(int **x) {}]],
2455                  [[double *x; f((int **) &x);]])
2456              ],[
2457                ac_cv_no_strict_aliasing=no
2458              ],[
2459                ac_cv_no_strict_aliasing=yes
2460              ])
2461          ],[
2462            ac_cv_no_strict_aliasing=no
2463          ]))
2464      CFLAGS="$save_CFLAGS"
2465      CC="$ac_save_cc"
2466     AS_VAR_IF([ac_cv_no_strict_aliasing], [yes],
2467               [BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"])
2468
2469     # ICC doesn't recognize the option, but only emits a warning
2470     ## XXX does it emit an unused result warning and can it be disabled?
2471     AS_CASE(["$CC_BASENAME"],
2472             [*icc*], [ac_cv_disable_unused_result_warning=no]
2473             [PY_CHECK_CC_WARNING([disable], [unused-result])])
2474     AS_VAR_IF([ac_cv_disable_unused_result_warning], [yes],
2475               [BASECFLAGS="$BASECFLAGS -Wno-unused-result"
2476                CFLAGS_NODIST="$CFLAGS_NODIST -Wno-unused-result"])
2477
2478     PY_CHECK_CC_WARNING([disable], [unused-parameter])
2479     AS_VAR_IF([ac_cv_disable_unused_parameter_warning], [yes],
2480               [CFLAGS_NODIST="$CFLAGS_NODIST -Wno-unused-parameter"])
2481
2482     PY_CHECK_CC_WARNING([disable], [int-conversion])
2483     AS_VAR_IF([ac_cv_disable_int_conversion], [yes],
2484               [CFLAGS_NODIST="$CFLAGS_NODIST -Wno-int-conversion"])
2485
2486     PY_CHECK_CC_WARNING([disable], [missing-field-initializers])
2487     AS_VAR_IF([ac_cv_disable_missing_field_initializers_warning], [yes],
2488               [CFLAGS_NODIST="$CFLAGS_NODIST -Wno-missing-field-initializers"])
2489
2490     PY_CHECK_CC_WARNING([enable], [sign-compare])
2491     AS_VAR_IF([ac_cv_enable_sign_compare_warning], [yes],
2492               [BASECFLAGS="$BASECFLAGS -Wsign-compare"])
2493
2494     PY_CHECK_CC_WARNING([enable], [unreachable-code])
2495     # Don't enable unreachable code warning in debug mode, since it usually
2496     # results in non-standard code paths.
2497     # Issue #24324: Unfortunately, the unreachable code warning does not work
2498     # correctly on gcc and has been silently removed from the compiler.
2499     # It is supported on clang but on OS X systems gcc may be an alias
2500     # for clang.  Try to determine if the compiler is not really gcc and,
2501     # if so, only then enable the warning.
2502     if test $ac_cv_enable_unreachable_code_warning = yes && \
2503         test "$Py_DEBUG" != "true" && \
2504         test -z "`$CC --version 2>/dev/null | grep 'Free Software Foundation'`"
2505     then
2506       BASECFLAGS="$BASECFLAGS -Wunreachable-code"
2507     else
2508       ac_cv_enable_unreachable_code_warning=no
2509     fi
2510
2511     PY_CHECK_CC_WARNING([enable], [strict-prototypes])
2512     AS_VAR_IF([ac_cv_enable_strict_prototypes_warning], [yes],
2513               [CFLAGS_NODIST="$CFLAGS_NODIST -Wstrict-prototypes"])
2514
2515      ac_save_cc="$CC"
2516      CC="$CC -Werror=implicit-function-declaration"
2517      AC_CACHE_CHECK([if we can make implicit function declaration an error in $CC],
2518                     [ac_cv_enable_implicit_function_declaration_error],
2519        AC_COMPILE_IFELSE(
2520          [
2521            AC_LANG_PROGRAM([[]], [[]])
2522          ],[
2523            ac_cv_enable_implicit_function_declaration_error=yes
2524          ],[
2525            ac_cv_enable_implicit_function_declaration_error=no
2526          ]))
2527      CC="$ac_save_cc"
2528
2529     AS_VAR_IF([ac_cv_enable_implicit_function_declaration_error], [yes],
2530               [CFLAGS_NODIST="$CFLAGS_NODIST -Werror=implicit-function-declaration"])
2531
2532      ac_save_cc="$CC"
2533      CC="$CC -fvisibility=hidden"
2534      AC_CACHE_CHECK([if we can use visibility in $CC], [ac_cv_enable_visibility],
2535        AC_COMPILE_IFELSE(
2536          [
2537            AC_LANG_PROGRAM([[]], [[]])
2538          ],[
2539            ac_cv_enable_visibility=yes
2540          ],[
2541            ac_cv_enable_visibility=no
2542          ]))
2543      CC="$ac_save_cc"
2544
2545     AS_VAR_IF([ac_cv_enable_visibility], [yes],
2546               [CFLAGS_NODIST="$CFLAGS_NODIST -fvisibility=hidden"])
2547
2548     # if using gcc on alpha, use -mieee to get (near) full IEEE 754
2549     # support.  Without this, treatment of subnormals doesn't follow
2550     # the standard.
2551     case $host in
2552          alpha*)
2553                 BASECFLAGS="$BASECFLAGS -mieee"
2554                 ;;
2555     esac
2556
2557     case $ac_sys_system in
2558         SCO_SV*)
2559             BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
2560             ;;
2561
2562     Darwin*)
2563         # -Wno-long-double, -no-cpp-precomp, and -mno-fused-madd
2564         # used to be here, but non-Apple gcc doesn't accept them.
2565         if test "${CC}" = gcc
2566         then
2567             AC_MSG_CHECKING([which compiler should be used])
2568             case "${UNIVERSALSDK}" in
2569             */MacOSX10.4u.sdk)
2570                 # Build using 10.4 SDK, force usage of gcc when the
2571                 # compiler is gcc, otherwise the user will get very
2572                 # confusing error messages when building on OSX 10.6
2573                 CC=gcc-4.0
2574                 CPP=cpp-4.0
2575                 ;;
2576             esac
2577             AC_MSG_RESULT([$CC])
2578         fi
2579
2580         LIPO_INTEL64_FLAGS=""
2581         if test "${enable_universalsdk}"
2582         then
2583             case "$UNIVERSAL_ARCHS" in
2584             32-bit)
2585                UNIVERSAL_ARCH_FLAGS="-arch ppc -arch i386"
2586                LIPO_32BIT_FLAGS=""
2587                ARCH_RUN_32BIT=""
2588                ;;
2589             64-bit)
2590                UNIVERSAL_ARCH_FLAGS="-arch ppc64 -arch x86_64"
2591                LIPO_32BIT_FLAGS=""
2592                ARCH_RUN_32BIT="true"
2593                ;;
2594             all)
2595                UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch ppc64 -arch x86_64"
2596                LIPO_32BIT_FLAGS="-extract ppc7400 -extract i386"
2597                ARCH_RUN_32BIT="/usr/bin/arch -i386 -ppc"
2598                ;;
2599             universal2)
2600                UNIVERSAL_ARCH_FLAGS="-arch arm64 -arch x86_64"
2601                LIPO_32BIT_FLAGS=""
2602                LIPO_INTEL64_FLAGS="-extract x86_64"
2603                ARCH_RUN_32BIT="true"
2604                ;;
2605             intel)
2606                UNIVERSAL_ARCH_FLAGS="-arch i386 -arch x86_64"
2607                LIPO_32BIT_FLAGS="-extract i386"
2608                ARCH_RUN_32BIT="/usr/bin/arch -i386"
2609                ;;
2610             intel-32)
2611                UNIVERSAL_ARCH_FLAGS="-arch i386"
2612                LIPO_32BIT_FLAGS=""
2613                ARCH_RUN_32BIT=""
2614                ;;
2615             intel-64)
2616                UNIVERSAL_ARCH_FLAGS="-arch x86_64"
2617                LIPO_32BIT_FLAGS=""
2618                ARCH_RUN_32BIT="true"
2619                ;;
2620             3-way)
2621                UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch x86_64"
2622                LIPO_32BIT_FLAGS="-extract ppc7400 -extract i386"
2623                ARCH_RUN_32BIT="/usr/bin/arch -i386 -ppc"
2624                ;;
2625             *)
2626                AC_MSG_ERROR([proper usage is --with-universal-arch=universal2|32-bit|64-bit|all|intel|3-way])
2627                ;;
2628             esac
2629
2630             if test "${UNIVERSALSDK}" != "/"
2631             then
2632                 CFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${CFLAGS}"
2633                 LDFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
2634                 CPPFLAGS="-isysroot ${UNIVERSALSDK} ${CPPFLAGS}"
2635             else
2636                 CFLAGS="${UNIVERSAL_ARCH_FLAGS} ${CFLAGS}"
2637                 LDFLAGS="${UNIVERSAL_ARCH_FLAGS} ${LDFLAGS}"
2638             fi
2639         fi
2640
2641         # Calculate an appropriate deployment target for this build:
2642         # The deployment target value is used explicitly to enable certain
2643         # features are enabled (such as builtin libedit support for readline)
2644         # through the use of Apple's Availability Macros and is used as a
2645         # component of the string returned by distutils.get_platform().
2646         #
2647         # Use the value from:
2648         # 1. the MACOSX_DEPLOYMENT_TARGET environment variable if specified
2649         # 2. the operating system version of the build machine if >= 10.6
2650         # 3. If running on OS X 10.3 through 10.5, use the legacy tests
2651         #       below to pick either 10.3, 10.4, or 10.5 as the target.
2652         # 4. If we are running on OS X 10.2 or earlier, good luck!
2653
2654         AC_MSG_CHECKING([which MACOSX_DEPLOYMENT_TARGET to use])
2655         cur_target_major=`sw_vers -productVersion | \
2656                 sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\1/'`
2657         cur_target_minor=`sw_vers -productVersion | \
2658                 sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\2/'`
2659         cur_target="${cur_target_major}.${cur_target_minor}"
2660         if test ${cur_target_major} -eq 10 && \
2661            test ${cur_target_minor} -ge 3 && \
2662            test ${cur_target_minor} -le 5
2663         then
2664             # OS X 10.3 through 10.5
2665             cur_target=10.3
2666             if test ${enable_universalsdk}
2667             then
2668                 case "$UNIVERSAL_ARCHS" in
2669                 all|3-way|intel|64-bit)
2670                     # These configurations were first supported in 10.5
2671                     cur_target='10.5'
2672                     ;;
2673                 esac
2674             else
2675                 if test `/usr/bin/arch` = "i386"
2676                 then
2677                     # 10.4 was the first release to support Intel archs
2678                     cur_target="10.4"
2679                 fi
2680             fi
2681         fi
2682         CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
2683
2684         # Make sure that MACOSX_DEPLOYMENT_TARGET is set in the
2685         # environment with a value that is the same as what we'll use
2686         # in the Makefile to ensure that we'll get the same compiler
2687         # environment during configure and build time.
2688         MACOSX_DEPLOYMENT_TARGET="$CONFIGURE_MACOSX_DEPLOYMENT_TARGET"
2689         export MACOSX_DEPLOYMENT_TARGET
2690         EXPORT_MACOSX_DEPLOYMENT_TARGET=''
2691         AC_MSG_RESULT([$MACOSX_DEPLOYMENT_TARGET])
2692
2693         AC_MSG_CHECKING([if specified universal architectures work])
2694         AC_LINK_IFELSE([AC_LANG_PROGRAM([[@%:@include <stdio.h>]], [[printf("%d", 42);]])],
2695             [AC_MSG_RESULT([yes])],
2696             [AC_MSG_RESULT([no])
2697              AC_MSG_ERROR([check config.log and use the '--with-universal-archs' option])
2698         ])
2699
2700         # end of Darwin* tests
2701         ;;
2702     esac
2703     ;;
2704
2705 *)
2706     case $ac_sys_system in
2707     OpenUNIX*|UnixWare*)
2708         BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
2709         ;;
2710     SCO_SV*)
2711         BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
2712         ;;
2713     esac
2714     ;;
2715 esac
2716
2717 case "$CC_BASENAME" in
2718 *mpicc*)
2719     CFLAGS_NODIST="$CFLAGS_NODIST"
2720     ;;
2721 *icc*)
2722     # ICC needs -fp-model strict or floats behave badly
2723     CFLAGS_NODIST="$CFLAGS_NODIST -fp-model strict"
2724     ;;
2725 *xlc*)
2726     CFLAGS_NODIST="$CFLAGS_NODIST -qalias=noansi -qmaxmem=-1"
2727     ;;
2728 esac
2729
2730 if test "$assertions" = 'true'; then
2731   :
2732 else
2733   OPT="-DNDEBUG $OPT"
2734 fi
2735
2736 if test "$ac_arch_flags"
2737 then
2738         BASECFLAGS="$BASECFLAGS $ac_arch_flags"
2739 fi
2740
2741 # On some compilers, pthreads are available without further options
2742 # (e.g. MacOS X). On some of these systems, the compiler will not
2743 # complain if unaccepted options are passed (e.g. gcc on Mac OS X).
2744 # So we have to see first whether pthreads are available without
2745 # options before we can check whether -Kpthread improves anything.
2746 AC_CACHE_CHECK([whether pthreads are available without options],
2747                [ac_cv_pthread_is_default],
2748 [AC_RUN_IFELSE([AC_LANG_SOURCE([[
2749 #include <stdio.h>
2750 #include <pthread.h>
2751
2752 void* routine(void* p){return NULL;}
2753
2754 int main(void){
2755   pthread_t p;
2756   if(pthread_create(&p,NULL,routine,NULL)!=0)
2757     return 1;
2758   (void)pthread_detach(p);
2759   return 0;
2760 }
2761 ]])],[
2762   ac_cv_pthread_is_default=yes
2763   ac_cv_kthread=no
2764   ac_cv_pthread=no
2765 ],[ac_cv_pthread_is_default=no],[ac_cv_pthread_is_default=no])
2766 ])
2767
2768
2769 if test $ac_cv_pthread_is_default = yes
2770 then
2771   ac_cv_kpthread=no
2772 else
2773 # -Kpthread, if available, provides the right #defines
2774 # and linker options to make pthread_create available
2775 # Some compilers won't report that they do not support -Kpthread,
2776 # so we need to run a program to see whether it really made the
2777 # function available.
2778 AC_CACHE_CHECK([whether $CC accepts -Kpthread], [ac_cv_kpthread],
2779 [ac_save_cc="$CC"
2780 CC="$CC -Kpthread"
2781 AC_RUN_IFELSE([AC_LANG_SOURCE([[
2782 #include <stdio.h>
2783 #include <pthread.h>
2784
2785 void* routine(void* p){return NULL;}
2786
2787 int main(void){
2788   pthread_t p;
2789   if(pthread_create(&p,NULL,routine,NULL)!=0)
2790     return 1;
2791   (void)pthread_detach(p);
2792   return 0;
2793 }
2794 ]])],[ac_cv_kpthread=yes],[ac_cv_kpthread=no],[ac_cv_kpthread=no])
2795 CC="$ac_save_cc"])
2796 fi
2797
2798 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
2799 then
2800 # -Kthread, if available, provides the right #defines
2801 # and linker options to make pthread_create available
2802 # Some compilers won't report that they do not support -Kthread,
2803 # so we need to run a program to see whether it really made the
2804 # function available.
2805 AC_CACHE_CHECK([whether $CC accepts -Kthread], [ac_cv_kthread],
2806 [ac_save_cc="$CC"
2807 CC="$CC -Kthread"
2808 AC_RUN_IFELSE([AC_LANG_SOURCE([[
2809 #include <stdio.h>
2810 #include <pthread.h>
2811
2812 void* routine(void* p){return NULL;}
2813
2814 int main(void){
2815   pthread_t p;
2816   if(pthread_create(&p,NULL,routine,NULL)!=0)
2817     return 1;
2818   (void)pthread_detach(p);
2819   return 0;
2820 }
2821 ]])],[ac_cv_kthread=yes],[ac_cv_kthread=no],[ac_cv_kthread=no])
2822 CC="$ac_save_cc"])
2823 fi
2824
2825 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
2826 then
2827 # -pthread, if available, provides the right #defines
2828 # and linker options to make pthread_create available
2829 # Some compilers won't report that they do not support -pthread,
2830 # so we need to run a program to see whether it really made the
2831 # function available.
2832 AC_CACHE_CHECK([whether $CC accepts -pthread], [ac_cv_pthread],
2833 [ac_save_cc="$CC"
2834 CC="$CC -pthread"
2835 AC_RUN_IFELSE([AC_LANG_SOURCE([[
2836 #include <stdio.h>
2837 #include <pthread.h>
2838
2839 void* routine(void* p){return NULL;}
2840
2841 int main(void){
2842   pthread_t p;
2843   if(pthread_create(&p,NULL,routine,NULL)!=0)
2844     return 1;
2845   (void)pthread_detach(p);
2846   return 0;
2847 }
2848 ]])],[ac_cv_pthread=yes],[ac_cv_pthread=no],[ac_cv_pthread=no])
2849 CC="$ac_save_cc"])
2850 fi
2851
2852 # If we have set a CC compiler flag for thread support then
2853 # check if it works for CXX, too.
2854 if test ! -z "$CXX"
2855 then
2856 AC_CACHE_CHECK([whether $CXX also accepts flags for thread support], [ac_cv_cxx_thread],
2857 [ac_save_cxx="$CXX"
2858
2859 if test "$ac_cv_kpthread" = "yes"
2860 then
2861   CXX="$CXX -Kpthread"
2862   ac_cv_cxx_thread=yes
2863 elif test "$ac_cv_kthread" = "yes"
2864 then
2865   CXX="$CXX -Kthread"
2866   ac_cv_cxx_thread=yes
2867 elif test "$ac_cv_pthread" = "yes"
2868 then
2869   CXX="$CXX -pthread"
2870   ac_cv_cxx_thread=yes
2871 else
2872   ac_cv_cxx_thread=no
2873 fi
2874
2875 if test $ac_cv_cxx_thread = yes
2876 then
2877   echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
2878   $CXX -c conftest.$ac_ext 2>&5
2879   if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
2880      && test -s conftest$ac_exeext && ./conftest$ac_exeext
2881   then
2882     ac_cv_cxx_thread=yes
2883   else
2884     ac_cv_cxx_thread=no
2885   fi
2886   rm -fr conftest*
2887 fi
2888 CXX="$ac_save_cxx"])
2889 else
2890   ac_cv_cxx_thread=no
2891 fi
2892
2893 dnl # check for ANSI or K&R ("traditional") preprocessor
2894 dnl AC_MSG_CHECKING(for C preprocessor type)
2895 dnl AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
2896 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
2897 dnl int foo;
2898 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
2899 dnl ]], [[;]])],[cpp_type=ansi],[AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional])
2900 dnl AC_MSG_RESULT($cpp_type)
2901
2902 dnl autoconf 2.71 deprecates STDC_HEADERS, keep for backwards compatibility
2903 dnl assume C99 compilers provide ANSI C headers
2904 AC_DEFINE([STDC_HEADERS], [1],
2905           [Define to 1 if you have the ANSI C header files.])
2906
2907 # checks for header files
2908 AC_CHECK_HEADERS([ \
2909   alloca.h asm/types.h bluetooth.h conio.h direct.h dlfcn.h endian.h errno.h fcntl.h grp.h \
2910   io.h langinfo.h libintl.h libutil.h linux/auxvec.h sys/auxv.h linux/fs.h linux/limits.h linux/memfd.h \
2911   linux/random.h linux/soundcard.h \
2912   linux/tipc.h linux/wait.h netdb.h net/ethernet.h netinet/in.h netpacket/packet.h poll.h process.h pthread.h pty.h \
2913   sched.h setjmp.h shadow.h signal.h spawn.h stropts.h sys/audioio.h sys/bsdtty.h sys/devpoll.h \
2914   sys/endian.h sys/epoll.h sys/event.h sys/eventfd.h sys/file.h sys/ioctl.h sys/kern_control.h \
2915   sys/loadavg.h sys/lock.h sys/memfd.h sys/mkdev.h sys/mman.h sys/modem.h sys/param.h sys/poll.h \
2916   sys/random.h sys/resource.h sys/select.h sys/sendfile.h sys/socket.h sys/soundcard.h sys/stat.h \
2917   sys/statvfs.h sys/sys_domain.h sys/syscall.h sys/sysmacros.h sys/termio.h sys/time.h sys/times.h sys/timerfd.h \
2918   sys/types.h sys/uio.h sys/un.h sys/utsname.h sys/wait.h sys/xattr.h sysexits.h syslog.h \
2919   termios.h util.h utime.h utmp.h \
2920 ])
2921 AC_HEADER_DIRENT
2922 AC_HEADER_MAJOR
2923
2924 # bluetooth/bluetooth.h has been known to not compile with -std=c99.
2925 # http://permalink.gmane.org/gmane.linux.bluez.kernel/22294
2926 SAVE_CFLAGS=$CFLAGS
2927 CFLAGS="-std=c99 $CFLAGS"
2928 AC_CHECK_HEADERS([bluetooth/bluetooth.h])
2929 CFLAGS=$SAVE_CFLAGS
2930
2931 # On Darwin (OS X) net/if.h requires sys/socket.h to be imported first.
2932 AC_CHECK_HEADERS([net/if.h], [], [],
2933 [#include <stdio.h>
2934 #include <stdlib.h>
2935 #include <stddef.h>
2936 #ifdef HAVE_SYS_SOCKET_H
2937 # include <sys/socket.h>
2938 #endif
2939 ])
2940
2941 # On Linux, netlink.h requires asm/types.h
2942 # On FreeBSD, netlink.h is located in netlink/netlink.h
2943 AC_CHECK_HEADERS([linux/netlink.h netlink/netlink.h], [], [], [
2944 #ifdef HAVE_ASM_TYPES_H
2945 #include <asm/types.h>
2946 #endif
2947 #ifdef HAVE_SYS_SOCKET_H
2948 #include <sys/socket.h>
2949 #endif
2950 ])
2951
2952 # On Linux, qrtr.h requires asm/types.h
2953 AC_CHECK_HEADERS([linux/qrtr.h], [], [], [
2954 #ifdef HAVE_ASM_TYPES_H
2955 #include <asm/types.h>
2956 #endif
2957 #ifdef HAVE_SYS_SOCKET_H
2958 #include <sys/socket.h>
2959 #endif
2960 ])
2961
2962 AC_CHECK_HEADERS([linux/vm_sockets.h], [], [], [
2963 #ifdef HAVE_SYS_SOCKET_H
2964 #include <sys/socket.h>
2965 #endif
2966 ])
2967
2968 # On Linux, can.h, can/bcm.h, can/j1939.h, can/raw.h require sys/socket.h
2969 # On NetBSD, netcan/can.h requires sys/socket.h
2970 AC_CHECK_HEADERS(
2971 [linux/can.h linux/can/bcm.h linux/can/j1939.h linux/can/raw.h netcan/can.h],
2972 [], [], [
2973 #ifdef HAVE_SYS_SOCKET_H
2974 #include <sys/socket.h>
2975 #endif
2976 ])
2977
2978 # Check for clock_t in time.h.
2979 AC_CHECK_TYPES([clock_t], [],
2980                [AC_DEFINE([clock_t], [long],
2981                           [Define to 'long' if <time.h> does not define clock_t.])],
2982                [@%:@include <time.h>])
2983
2984 AC_CACHE_CHECK([for makedev], [ac_cv_func_makedev], [
2985 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
2986 #if defined(MAJOR_IN_MKDEV)
2987 #include <sys/mkdev.h>
2988 #elif defined(MAJOR_IN_SYSMACROS)
2989 #include <sys/sysmacros.h>
2990 #else
2991 #include <sys/types.h>
2992 #endif
2993 ]], [[
2994   makedev(0, 0) ]])
2995 ],[ac_cv_func_makedev=yes],[ac_cv_func_makedev=no])
2996 ])
2997
2998 AS_VAR_IF([ac_cv_func_makedev], [yes], [
2999     AC_DEFINE([HAVE_MAKEDEV], [1],
3000               [Define this if you have the makedev macro.])
3001 ])
3002
3003 # byte swapping
3004 AC_CACHE_CHECK([for le64toh], [ac_cv_func_le64toh], [
3005 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
3006 #ifdef HAVE_ENDIAN_H
3007 #include <endian.h>
3008 #elif defined(HAVE_SYS_ENDIAN_H)
3009 #include <sys/endian.h>
3010 #endif
3011 ]], [[
3012    le64toh(1) ]])
3013 ],[ac_cv_func_le64toh=yes],[ac_cv_func_le64toh=no])
3014 ])
3015
3016 AS_VAR_IF([ac_cv_func_le64toh], [yes], [
3017     AC_DEFINE([HAVE_HTOLE64], [1],
3018               [Define this if you have le64toh()])
3019 ])
3020
3021 use_lfs=yes
3022 # Don't use largefile support for GNU/Hurd
3023 case $ac_sys_system in GNU*)
3024   use_lfs=no
3025 esac
3026
3027 if test "$use_lfs" = "yes"; then
3028 # Two defines needed to enable largefile support on various platforms
3029 # These may affect some typedefs
3030 case $ac_sys_system/$ac_sys_release in
3031 AIX*)
3032     AC_DEFINE([_LARGE_FILES], [1],
3033     [This must be defined on AIX systems to enable large file support.])
3034     ;;
3035 esac
3036 AC_DEFINE([_LARGEFILE_SOURCE], [1],
3037 [This must be defined on some systems to enable large file support.])
3038 AC_DEFINE([_FILE_OFFSET_BITS], [64],
3039 [This must be set to 64 on some systems to enable large file support.])
3040 fi
3041
3042 # Add some code to confdefs.h so that the test for off_t works on SCO
3043 cat >> confdefs.h <<\EOF
3044 #if defined(SCO_DS)
3045 #undef _OFF_T
3046 #endif
3047 EOF
3048
3049 # Type availability checks
3050 AC_TYPE_MODE_T
3051 AC_TYPE_OFF_T
3052 AC_TYPE_PID_T
3053 AC_DEFINE_UNQUOTED([RETSIGTYPE],[void],[assume C89 semantics that RETSIGTYPE is always void])
3054 AC_TYPE_SIZE_T
3055 AC_TYPE_UID_T
3056
3057 AC_CHECK_TYPES([ssize_t])
3058 AC_CHECK_TYPES([__uint128_t],
3059                [AC_DEFINE([HAVE_GCC_UINT128_T], [1],
3060                           [Define if your compiler provides __uint128_t])])
3061
3062 # Sizes and alignments of various common basic types
3063 # ANSI C requires sizeof(char) == 1, so no need to check it
3064 AC_CHECK_SIZEOF([int], [4])
3065 AC_CHECK_SIZEOF([long], [4])
3066 AC_CHECK_ALIGNOF([long])
3067 AC_CHECK_SIZEOF([long long], [8])
3068 AC_CHECK_SIZEOF([void *], [4])
3069 AC_CHECK_SIZEOF([short], [2])
3070 AC_CHECK_SIZEOF([float], [4])
3071 AC_CHECK_SIZEOF([double], [8])
3072 AC_CHECK_SIZEOF([fpos_t], [4])
3073 AC_CHECK_SIZEOF([size_t], [4])
3074 AC_CHECK_ALIGNOF([size_t])
3075 AC_CHECK_SIZEOF([pid_t], [4])
3076 AC_CHECK_SIZEOF([uintptr_t])
3077 AC_CHECK_ALIGNOF([max_align_t])
3078
3079 AC_TYPE_LONG_DOUBLE
3080 AC_CHECK_SIZEOF([long double], [16])
3081
3082 AC_CHECK_SIZEOF([_Bool], [1])
3083
3084 AC_CHECK_SIZEOF([off_t], [], [
3085 #ifdef HAVE_SYS_TYPES_H
3086 #include <sys/types.h>
3087 #endif
3088 ])
3089
3090 AC_MSG_CHECKING([whether to enable large file support])
3091 if test "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
3092         "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
3093   have_largefile_support="yes"
3094 else
3095   have_largefile_support="no"
3096 fi
3097 dnl LFS does not work with Emscripten 3.1
3098 AS_CASE([$ac_sys_system],
3099   [Emscripten], [have_largefile_support="no"]
3100 )
3101 AS_VAR_IF([have_largefile_support], [yes], [
3102   AC_DEFINE([HAVE_LARGEFILE_SUPPORT], [1],
3103   [Defined to enable large file support when an off_t is bigger than a long
3104    and long long is at least as big as an off_t. You may need
3105    to add some flags for configuration and compilation to enable this mode.
3106    (For Solaris and Linux, the necessary defines are already defined.)])
3107   AC_MSG_RESULT([yes])
3108 ], [
3109   AC_MSG_RESULT([no])
3110 ])
3111
3112 AC_CHECK_SIZEOF([time_t], [], [
3113 #ifdef HAVE_SYS_TYPES_H
3114 #include <sys/types.h>
3115 #endif
3116 #ifdef HAVE_TIME_H
3117 #include <time.h>
3118 #endif
3119 ])
3120
3121 # if have pthread_t then define SIZEOF_PTHREAD_T
3122 ac_save_cc="$CC"
3123 if test "$ac_cv_kpthread" = "yes"
3124 then CC="$CC -Kpthread"
3125 elif test "$ac_cv_kthread" = "yes"
3126 then CC="$CC -Kthread"
3127 elif test "$ac_cv_pthread" = "yes"
3128 then CC="$CC -pthread"
3129 fi
3130
3131 AC_CACHE_CHECK([for pthread_t], [ac_cv_have_pthread_t], [
3132 AC_COMPILE_IFELSE([
3133   AC_LANG_PROGRAM([[@%:@include <pthread.h>]], [[pthread_t x; x = *(pthread_t*)0;]])
3134 ], [ac_cv_have_pthread_t=yes], [ac_cv_have_pthread_t=no])
3135 ])
3136 AS_VAR_IF([ac_cv_have_pthread_t], [yes], [
3137   AC_CHECK_SIZEOF([pthread_t], [], [
3138 #ifdef HAVE_PTHREAD_H
3139 #include <pthread.h>
3140 #endif
3141   ])
3142 ])
3143
3144 # Issue #25658: POSIX hasn't defined that pthread_key_t is compatible with int.
3145 # This checking will be unnecessary after removing deprecated TLS API.
3146 AC_CHECK_SIZEOF([pthread_key_t], [], [[@%:@include <pthread.h>]])
3147 AC_CACHE_CHECK([whether pthread_key_t is compatible with int], [ac_cv_pthread_key_t_is_arithmetic_type], [
3148 if test "$ac_cv_sizeof_pthread_key_t" -eq "$ac_cv_sizeof_int" ; then
3149   AC_COMPILE_IFELSE(
3150     [AC_LANG_PROGRAM([[@%:@include <pthread.h>]], [[pthread_key_t k; k * 1;]])],
3151     [ac_cv_pthread_key_t_is_arithmetic_type=yes],
3152     [ac_cv_pthread_key_t_is_arithmetic_type=no]
3153   )
3154 else
3155   ac_cv_pthread_key_t_is_arithmetic_type=no
3156 fi
3157 ])
3158 AS_VAR_IF([ac_cv_pthread_key_t_is_arithmetic_type], [yes], [
3159     AC_DEFINE([PTHREAD_KEY_T_IS_COMPATIBLE_WITH_INT], [1],
3160               [Define if pthread_key_t is compatible with int.])
3161 ])
3162
3163 CC="$ac_save_cc"
3164
3165 AC_MSG_CHECKING([for --enable-framework])
3166 if test "$enable_framework"
3167 then
3168         BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
3169         # -F. is needed to allow linking to the framework while
3170         # in the build location.
3171         AC_DEFINE([WITH_NEXT_FRAMEWORK], [1],
3172          [Define if you want to produce an OpenStep/Rhapsody framework
3173          (shared library plus accessory files).])
3174         AC_MSG_RESULT([yes])
3175         if test $enable_shared = "yes"
3176         then
3177                 AC_MSG_ERROR([Specifying both --enable-shared and --enable-framework is not supported, use only --enable-framework instead])
3178         fi
3179 else
3180         AC_MSG_RESULT([no])
3181 fi
3182
3183 # Check for --with-dsymutil
3184 AC_SUBST([DSYMUTIL])
3185 AC_SUBST([DSYMUTIL_PATH])
3186 DSYMUTIL=
3187 DSYMUTIL_PATH=
3188 AC_MSG_CHECKING([for --with-dsymutil])
3189 AC_ARG_WITH(
3190   [dsymutil],
3191   [AS_HELP_STRING(
3192     [--with-dsymutil],
3193     [link debug information into final executable with dsymutil in macOS  (default is no)]
3194   )],
3195 [
3196 if test "$withval" != no
3197 then
3198   if test "$MACHDEP" != "darwin"; then
3199     AC_MSG_ERROR([dsymutil debug linking is only available in macOS.])
3200   fi
3201  AC_MSG_RESULT([yes]);
3202   DSYMUTIL='true'
3203 else AC_MSG_RESULT([no]); DSYMUTIL=
3204 fi],
3205 [AC_MSG_RESULT([no])])
3206
3207 if test "$DSYMUTIL"; then
3208   AC_PATH_PROG([DSYMUTIL_PATH], [dsymutil], [not found])
3209   if test "$DSYMUTIL_PATH" = "not found"; then
3210       AC_MSG_ERROR([dsymutil command not found on \$PATH])
3211   fi
3212 fi
3213
3214 AC_MSG_CHECKING([for dyld])
3215 case $ac_sys_system/$ac_sys_release in
3216   Darwin/*)
3217     AC_DEFINE([WITH_DYLD], [1],
3218         [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
3219          dynamic linker (dyld) instead of the old-style (NextStep) dynamic
3220          linker (rld). Dyld is necessary to support frameworks.])
3221     AC_MSG_RESULT([always on for Darwin])
3222         ;;
3223   *)
3224         AC_MSG_RESULT([no])
3225         ;;
3226 esac
3227
3228 AC_MSG_CHECKING([for --with-address-sanitizer])
3229 AC_ARG_WITH([address_sanitizer],
3230             AS_HELP_STRING([--with-address-sanitizer],
3231                            [enable AddressSanitizer memory error detector, 'asan' (default is no)]),
3232 [
3233 AC_MSG_RESULT([$withval])
3234 BASECFLAGS="-fsanitize=address -fno-omit-frame-pointer $BASECFLAGS"
3235 LDFLAGS="-fsanitize=address $LDFLAGS"
3236 # ASan works by controlling memory allocation, our own malloc interferes.
3237 with_pymalloc="no"
3238 ],
3239 [AC_MSG_RESULT([no])])
3240
3241 AC_MSG_CHECKING([for --with-memory-sanitizer])
3242 AC_ARG_WITH(
3243   [memory_sanitizer],
3244   [AS_HELP_STRING(
3245     [--with-memory-sanitizer],
3246     [enable MemorySanitizer allocation error detector, 'msan' (default is no)]
3247   )],
3248 [
3249 AC_MSG_RESULT([$withval])
3250 AX_CHECK_COMPILE_FLAG([-fsanitize=memory],[
3251 BASECFLAGS="-fsanitize=memory -fsanitize-memory-track-origins=2 -fno-omit-frame-pointer $BASECFLAGS"
3252 LDFLAGS="-fsanitize=memory -fsanitize-memory-track-origins=2 $LDFLAGS"
3253 ],[AC_MSG_ERROR([The selected compiler doesn't support memory sanitizer])])
3254 # MSan works by controlling memory allocation, our own malloc interferes.
3255 with_pymalloc="no"
3256 ],
3257 [AC_MSG_RESULT([no])])
3258
3259 AC_MSG_CHECKING([for --with-undefined-behavior-sanitizer])
3260 AC_ARG_WITH(
3261   [undefined_behavior_sanitizer],
3262   [AS_HELP_STRING(
3263     [--with-undefined-behavior-sanitizer],
3264     [enable UndefinedBehaviorSanitizer undefined behaviour detector, 'ubsan' (default is no)]
3265   )],
3266 [
3267 AC_MSG_RESULT([$withval])
3268 BASECFLAGS="-fsanitize=undefined $BASECFLAGS"
3269 LDFLAGS="-fsanitize=undefined $LDFLAGS"
3270 with_ubsan="yes"
3271 ],
3272 [
3273 AC_MSG_RESULT([no])
3274 with_ubsan="no"
3275 ])
3276
3277 AC_MSG_CHECKING([for --with-thread-sanitizer])
3278 AC_ARG_WITH(
3279   [thread_sanitizer],
3280   [AS_HELP_STRING(
3281     [--with-thread-sanitizer],
3282     [enable ThreadSanitizer data race detector, 'tsan' (default is no)]
3283   )],
3284 [
3285 AC_MSG_RESULT([$withval])
3286 BASECFLAGS="-fsanitize=thread $BASECFLAGS"
3287 LDFLAGS="-fsanitize=thread $LDFLAGS"
3288 with_tsan="yes"
3289 ],
3290 [
3291 AC_MSG_RESULT([no])
3292 with_tsan="no"
3293 ])
3294
3295 # Set info about shared libraries.
3296 AC_SUBST([SHLIB_SUFFIX])
3297 AC_SUBST([LDSHARED])
3298 AC_SUBST([LDCXXSHARED])
3299 AC_SUBST([BLDSHARED])
3300 AC_SUBST([CCSHARED])
3301 AC_SUBST([LINKFORSHARED])
3302
3303 # SHLIB_SUFFIX is the extension of shared libraries `(including the dot!)
3304 # -- usually .so, .sl on HP-UX, .dll on Cygwin
3305 AC_MSG_CHECKING([the extension of shared libraries])
3306 if test -z "$SHLIB_SUFFIX"; then
3307         case $ac_sys_system in
3308         hp*|HP*)
3309                 case `uname -m` in
3310                         ia64) SHLIB_SUFFIX=.so;;
3311                         *)    SHLIB_SUFFIX=.sl;;
3312                 esac
3313                 ;;
3314         CYGWIN*)   SHLIB_SUFFIX=.dll;;
3315         *)         SHLIB_SUFFIX=.so;;
3316         esac
3317 fi
3318 AC_MSG_RESULT([$SHLIB_SUFFIX])
3319
3320 # LDSHARED is the ld *command* used to create shared library
3321 # -- "cc -G" on SunOS 5.x.
3322 # (Shared libraries in this instance are shared modules to be loaded into
3323 # Python, as opposed to building Python itself as a shared library.)
3324 AC_MSG_CHECKING([LDSHARED])
3325 if test -z "$LDSHARED"
3326 then
3327         case $ac_sys_system/$ac_sys_release in
3328         AIX*)
3329                 BLDSHARED="Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
3330                 LDSHARED="\$(LIBPL)/ld_so_aix \$(CC) -bI:\$(LIBPL)/python.exp"
3331                 ;;
3332         SunOS/5*)
3333                 if test "$GCC" = "yes" ; then
3334                         LDSHARED='$(CC) -shared'
3335                         LDCXXSHARED='$(CXX) -shared'
3336                 else
3337                         LDSHARED='$(CC) -G'
3338                         LDCXXSHARED='$(CXX) -G'
3339                 fi ;;
3340         hp*|HP*)
3341                 if test "$GCC" = "yes" ; then
3342                         LDSHARED='$(CC) -shared'
3343                         LDCXXSHARED='$(CXX) -shared'
3344                 else
3345                         LDSHARED='$(CC) -b'
3346                         LDCXXSHARED='$(CXX) -b'
3347                 fi ;;
3348         Darwin/1.3*)
3349                 LDSHARED='$(CC) -bundle'
3350                 LDCXXSHARED='$(CXX) -bundle'
3351                 if test "$enable_framework" ; then
3352                         # Link against the framework. All externals should be defined.
3353                         BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
3354                         LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
3355                         LDCXXSHARED="$LDCXXSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
3356                 else
3357                         # No framework. Ignore undefined symbols, assuming they come from Python
3358                         LDSHARED="$LDSHARED -undefined suppress"
3359                         LDCXXSHARED="$LDCXXSHARED -undefined suppress"
3360                 fi ;;
3361         Darwin/1.4*|Darwin/5.*|Darwin/6.*)
3362                 LDSHARED='$(CC) -bundle'
3363                 LDCXXSHARED='$(CXX) -bundle'
3364                 if test "$enable_framework" ; then
3365                         # Link against the framework. All externals should be defined.
3366                         BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
3367                         LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
3368                         LDCXXSHARED="$LDCXXSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
3369                 else
3370                         # No framework, use the Python app as bundle-loader
3371                         BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
3372                         LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
3373                         LDCXXSHARED="$LDCXXSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
3374                 fi ;;
3375         Darwin/*)
3376                 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
3377                 # This allows an extension to be used in any Python
3378
3379                 dep_target_major=`echo ${MACOSX_DEPLOYMENT_TARGET} | \
3380                                 sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\1/'`
3381                 dep_target_minor=`echo ${MACOSX_DEPLOYMENT_TARGET} | \
3382                                 sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\2/'`
3383                 if test ${dep_target_major} -eq 10 && \
3384                    test ${dep_target_minor} -le 2
3385                 then
3386                         # building for OS X 10.0 through 10.2
3387                         AC_MSG_ERROR([MACOSX_DEPLOYMENT_TARGET too old ($MACOSX_DEPLOYMENT_TARGET), only 10.3 or later is supported])
3388                 else
3389                         # building for OS X 10.3 and later
3390                         LDSHARED='$(CC) -bundle -undefined dynamic_lookup'
3391                         LDCXXSHARED='$(CXX) -bundle -undefined dynamic_lookup'
3392                         BLDSHARED="$LDSHARED"
3393                 fi
3394                 ;;
3395         iOS/*)
3396                 LDSHARED='$(CC) -dynamiclib -F . -framework $(PYTHONFRAMEWORK)'
3397                 LDCXXSHARED='$(CXX) -dynamiclib -F . -framework $(PYTHONFRAMEWORK)'
3398                 BLDSHARED="$LDSHARED"
3399                 ;;
3400         Emscripten|WASI)
3401                 LDSHARED='$(CC) -shared'
3402                 LDCXXSHARED='$(CXX) -shared';;
3403         Linux*|GNU*|QNX*|VxWorks*|Haiku*)
3404                 LDSHARED='$(CC) -shared'
3405                 LDCXXSHARED='$(CXX) -shared';;
3406         FreeBSD*)
3407                 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
3408                 then
3409                         LDSHARED='$(CC) -shared'
3410                         LDCXXSHARED='$(CXX) -shared'
3411                 else
3412                         LDSHARED="ld -Bshareable"
3413                 fi;;
3414         OpenBSD*)
3415                 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
3416                 then
3417                                 LDSHARED='$(CC) -shared $(CCSHARED)'
3418                                 LDCXXSHARED='$(CXX) -shared $(CCSHARED)'
3419                 else
3420                                 case `uname -r` in
3421                                 [[01]].* | 2.[[0-7]] | 2.[[0-7]].*)
3422                                    LDSHARED="ld -Bshareable ${LDFLAGS}"
3423                                    ;;
3424                                 *)
3425                                    LDSHARED='$(CC) -shared $(CCSHARED)'
3426                                    LDCXXSHARED='$(CXX) -shared $(CCSHARED)'
3427                                    ;;
3428                                 esac
3429                 fi;;
3430         NetBSD*|DragonFly*)
3431                 LDSHARED='$(CC) -shared'
3432                 LDCXXSHARED='$(CXX) -shared';;
3433         OpenUNIX*|UnixWare*)
3434                 if test "$GCC" = "yes" ; then
3435                         LDSHARED='$(CC) -shared'
3436                         LDCXXSHARED='$(CXX) -shared'
3437                 else
3438                         LDSHARED='$(CC) -G'
3439                         LDCXXSHARED='$(CXX) -G'
3440                 fi;;
3441         SCO_SV*)
3442                 LDSHARED='$(CC) -Wl,-G,-Bexport'
3443                 LDCXXSHARED='$(CXX) -Wl,-G,-Bexport';;
3444         WASI*)
3445                 AS_VAR_IF([enable_wasm_dynamic_linking], [yes], [
3446                         dnl not iplemented yet
3447                 ]);;
3448         CYGWIN*)
3449                 LDSHARED="gcc -shared -Wl,--enable-auto-image-base"
3450                 LDCXXSHARED="g++ -shared -Wl,--enable-auto-image-base";;
3451         *)      LDSHARED="ld";;
3452         esac
3453 fi
3454
3455 dnl Emscripten's emconfigure sets LDSHARED. Set BLDSHARED outside the
3456 dnl test -z $LDSHARED block to configure BLDSHARED for side module support.
3457 if test "$enable_wasm_dynamic_linking" = "yes" -a "$ac_sys_system" = "Emscripten"; then
3458   BLDSHARED='$(CC) -shared -sSIDE_MODULE=1'
3459 fi
3460
3461 AC_MSG_RESULT([$LDSHARED])
3462 LDCXXSHARED=${LDCXXSHARED-$LDSHARED}
3463
3464 AC_MSG_CHECKING([BLDSHARED flags])
3465 BLDSHARED=${BLDSHARED-$LDSHARED}
3466 AC_MSG_RESULT([$BLDSHARED])
3467
3468 # CCSHARED are the C *flags* used to create objects to go into a shared
3469 # library (module) -- this is only needed for a few systems
3470 AC_MSG_CHECKING([CCSHARED])
3471 if test -z "$CCSHARED"
3472 then
3473         case $ac_sys_system/$ac_sys_release in
3474         SunOS*) if test "$GCC" = yes;
3475                 then CCSHARED="-fPIC";
3476                 elif test `uname -p` = sparc;
3477                 then CCSHARED="-xcode=pic32";
3478                 else CCSHARED="-Kpic";
3479                 fi;;
3480         hp*|HP*) if test "$GCC" = yes;
3481                  then CCSHARED="-fPIC";
3482                  else CCSHARED="+z";
3483                  fi;;
3484         Linux*|GNU*) CCSHARED="-fPIC";;
3485         Emscripten*|WASI*)
3486                 AS_VAR_IF([enable_wasm_dynamic_linking], [yes], [
3487                         CCSHARED="-fPIC"
3488                 ]);;
3489         FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
3490         Haiku*) CCSHARED="-fPIC";;
3491         OpenUNIX*|UnixWare*)
3492                 if test "$GCC" = "yes"
3493                 then CCSHARED="-fPIC"
3494                 else CCSHARED="-KPIC"
3495                 fi;;
3496         SCO_SV*)
3497                 if test "$GCC" = "yes"
3498                 then CCSHARED="-fPIC"
3499                 else CCSHARED="-Kpic -belf"
3500                 fi;;
3501         VxWorks*)
3502                 CCSHARED="-fpic -D__SO_PICABILINUX__  -ftls-model=global-dynamic"
3503         esac
3504 fi
3505 AC_MSG_RESULT([$CCSHARED])
3506 # LINKFORSHARED are the flags passed to the $(CC) command that links
3507 # the python executable -- this is only needed for a few systems
3508 AC_MSG_CHECKING([LINKFORSHARED])
3509 if test -z "$LINKFORSHARED"
3510 then
3511         case $ac_sys_system/$ac_sys_release in
3512         AIX*)   LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
3513         hp*|HP*)
3514             LINKFORSHARED="-Wl,-E -Wl,+s";;
3515 #           LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
3516         Linux-android*) LINKFORSHARED="-pie -Xlinker -export-dynamic";;
3517         Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
3518         # -u libsys_s pulls in all symbols in libsys
3519         Darwin/*|iOS/*)
3520                 LINKFORSHARED="$extra_undefs -framework CoreFoundation"
3521
3522                 # Issue #18075: the default maximum stack size (8MBytes) is too
3523                 # small for the default recursion limit. Increase the stack size
3524                 # to ensure that tests don't crash
3525                 stack_size="1000000"  # 16 MB
3526                 if test "$with_ubsan" = "yes"
3527                 then
3528                         # Undefined behavior sanitizer requires an even deeper stack
3529                         stack_size="4000000"  # 64 MB
3530                 fi
3531
3532                 AC_DEFINE_UNQUOTED([THREAD_STACK_SIZE],
3533                                 [0x$stack_size],
3534                                 [Custom thread stack size depending on chosen sanitizer runtimes.])
3535
3536                 if test $ac_sys_system = "Darwin"; then
3537                         LINKFORSHARED="-Wl,-stack_size,$stack_size $LINKFORSHARED"
3538
3539                         if test "$enable_framework"; then
3540                                 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
3541                         fi
3542                         LINKFORSHARED="$LINKFORSHARED"
3543                 elif test $ac_sys_system = "iOS"; then
3544                         LINKFORSHARED="-Wl,-stack_size,$stack_size $LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/$(PYTHONFRAMEWORK)'
3545                 fi
3546                 ;;
3547         OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
3548         SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
3549         ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
3550         FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
3551                 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
3552                 then
3553                         LINKFORSHARED="-Wl,--export-dynamic"
3554                 fi;;
3555         SunOS/5*) case $CC in
3556                   *gcc*)
3557                     if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
3558                     then
3559                         LINKFORSHARED="-Xlinker --export-dynamic"
3560                     fi;;
3561                   esac;;
3562         CYGWIN*)
3563                 if test $enable_shared = "no"
3564                 then
3565                         LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
3566                 fi;;
3567         QNX*)
3568                 # -Wl,-E causes the symbols to be added to the dynamic
3569                 # symbol table so that they can be found when a module
3570                 # is loaded.  -N 2048K causes the stack size to be set
3571                 # to 2048 kilobytes so that the stack doesn't overflow
3572                 # when running test_compile.py.
3573                 LINKFORSHARED='-Wl,-E -N 2048K';;
3574         VxWorks*)
3575                 LINKFORSHARED='-Wl,-export-dynamic';;
3576         esac
3577 fi
3578 AC_MSG_RESULT([$LINKFORSHARED])
3579
3580
3581 AC_SUBST([CFLAGSFORSHARED])
3582 AC_MSG_CHECKING([CFLAGSFORSHARED])
3583 if test ! "$LIBRARY" = "$LDLIBRARY"
3584 then
3585         case $ac_sys_system in
3586         CYGWIN*)
3587                 # Cygwin needs CCSHARED when building extension DLLs
3588                 # but not when building the interpreter DLL.
3589                 CFLAGSFORSHARED='';;
3590         *)
3591                 CFLAGSFORSHARED='$(CCSHARED)'
3592         esac
3593 fi
3594
3595 dnl WASM dynamic linking requires -fPIC.
3596 AS_VAR_IF([enable_wasm_dynamic_linking], [yes], [
3597   CFLAGSFORSHARED='$(CCSHARED)'
3598 ])
3599
3600 AC_MSG_RESULT([$CFLAGSFORSHARED])
3601
3602 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
3603 # library (with --enable-shared).
3604 # For platforms on which shared libraries are not allowed to have unresolved
3605 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
3606 # if it is not required, since it creates a dependency of the shared library
3607 # to LIBS. This, in turn, means that applications linking the shared libpython
3608 # don't need to link LIBS explicitly. The default should be only changed
3609 # on systems where this approach causes problems.
3610 AC_SUBST([SHLIBS])
3611 AC_MSG_CHECKING([SHLIBS])
3612 case "$ac_sys_system" in
3613         *)
3614                 SHLIBS='$(LIBS)';;
3615 esac
3616 AC_MSG_RESULT([$SHLIBS])
3617
3618 dnl perf trampoline is Linux specific and requires an arch-specific
3619 dnl trampoline in asssembly.
3620 AC_MSG_CHECKING([perf trampoline])
3621 AS_CASE([$PLATFORM_TRIPLET],
3622   [x86_64-linux-gnu], [perf_trampoline=yes],
3623   [aarch64-linux-gnu], [perf_trampoline=yes],
3624   [perf_trampoline=no]
3625 )
3626 AC_MSG_RESULT([$perf_trampoline])
3627
3628 AS_VAR_IF([perf_trampoline], [yes], [
3629   AC_DEFINE([PY_HAVE_PERF_TRAMPOLINE], [1], [Define to 1 if you have the perf trampoline.])
3630   PERF_TRAMPOLINE_OBJ=Python/asm_trampoline.o
3631
3632   dnl perf needs frame pointers for unwinding, include compiler option in debug builds
3633   AS_VAR_IF([Py_DEBUG], [true], [
3634     AS_VAR_APPEND([BASECFLAGS], [" -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer"])
3635   ])
3636 ])
3637 AC_SUBST([PERF_TRAMPOLINE_OBJ])
3638
3639 # checks for libraries
3640 AC_CHECK_LIB([sendfile], [sendfile])
3641 AC_CHECK_LIB([dl], [dlopen])       # Dynamic linking for SunOS/Solaris and SYSV
3642 AC_CHECK_LIB([dld], [shl_load])    # Dynamic linking for HP-UX
3643
3644
3645 dnl check for uuid dependencies
3646 AH_TEMPLATE([HAVE_UUID_H], [Define to 1 if you have the <uuid.h> header file.])
3647 AH_TEMPLATE([HAVE_UUID_UUID_H], [Define to 1 if you have the <uuid/uuid.h> header file.])
3648 AH_TEMPLATE([HAVE_UUID_GENERATE_TIME_SAFE], [Define if uuid_generate_time_safe() exists.])
3649 have_uuid=missing
3650
3651 dnl AIX provides support for RFC4122 (uuid) in libc.a starting with AIX 6.1
3652 dnl (anno 2007). FreeBSD and OpenBSD provides support in libc as well.
3653 dnl Little-endian FreeBSD, OpenBSD and NetBSD needs encoding into an octet
3654 dnl stream in big-endian byte-order
3655 AC_CHECK_HEADERS([uuid.h],
3656   [AC_CHECK_FUNCS([uuid_create uuid_enc_be],
3657     [have_uuid=yes
3658     LIBUUID_CFLAGS=${LIBUUID_CFLAGS-""}
3659     LIBUUID_LIBS=${LIBUUID_LIBS-""}
3660   ])
3661 ])
3662
3663 AS_VAR_IF([have_uuid], [missing], [
3664   PKG_CHECK_MODULES(
3665     [LIBUUID], [uuid >= 2.20],
3666       [dnl linux-util's libuuid has uuid_generate_time_safe() since v2.20 (2011)
3667       dnl and provides <uuid.h>.
3668       have_uuid=yes
3669       AC_DEFINE([HAVE_UUID_H], [1])
3670       AC_DEFINE([HAVE_UUID_GENERATE_TIME_SAFE], [1])
3671     ], [
3672       WITH_SAVE_ENV([
3673         CPPFLAGS="$CPPFLAGS $LIBUUID_CFLAGS"
3674         LDFLAGS="$LDFLAGS $LIBUUID_LIBS"
3675         AC_CHECK_HEADERS([uuid/uuid.h], [
3676           PY_CHECK_LIB([uuid], [uuid_generate_time], [have_uuid=yes])
3677           PY_CHECK_LIB([uuid], [uuid_generate_time_safe],
3678             [have_uuid=yes
3679             AC_DEFINE([HAVE_UUID_GENERATE_TIME_SAFE], [1]) ]) ])
3680         AS_VAR_IF([have_uuid], [yes], [
3681           LIBUUID_CFLAGS=${LIBUUID_CFLAGS-""}
3682           LIBUUID_LIBS=${LIBUUID_LIBS-"-luuid"}
3683         ])
3684       ])
3685     ]
3686   )
3687 ])
3688
3689 dnl macOS has uuid/uuid.h but uuid_generate_time is in libc
3690 AS_VAR_IF([have_uuid], [missing], [
3691   AC_CHECK_HEADERS([uuid/uuid.h], [
3692     AC_CHECK_FUNC([uuid_generate_time], [
3693       have_uuid=yes
3694       LIBUUID_CFLAGS=${LIBUUID_CFLAGS-""}
3695       LIBUUID_LIBS=${LIBUUID_LIBS-""}
3696     ])
3697   ])
3698 ])
3699
3700 AS_VAR_IF([have_uuid], [missing], [have_uuid=no])
3701
3702 # 'Real Time' functions on Solaris
3703 # posix4 on Solaris 2.6
3704 # pthread (first!) on Linux
3705 AC_SEARCH_LIBS([sem_init], [pthread rt posix4])
3706
3707 # check if we need libintl for locale functions
3708 AC_CHECK_LIB([intl], [textdomain],
3709         [AC_DEFINE([WITH_LIBINTL], [1],
3710         [Define to 1 if libintl is needed for locale functions.])
3711         LIBS="-lintl $LIBS"])
3712
3713 # checks for system dependent C++ extensions support
3714 case "$ac_sys_system" in
3715         AIX*)   AC_MSG_CHECKING([for genuine AIX C++ extensions support])
3716                 AC_LINK_IFELSE([
3717                   AC_LANG_PROGRAM([[@%:@include <load.h>]],
3718                                   [[loadAndInit("", 0, "")]])
3719                 ],[
3720                   AC_DEFINE([AIX_GENUINE_CPLUSPLUS], [1],
3721                       [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
3722                        and you want support for AIX C++ shared extension modules.])
3723                   AC_MSG_RESULT([yes])
3724                 ],[
3725                   AC_MSG_RESULT([no])
3726                 ])
3727 dnl The AIX_BUILDDATE is obtained from the kernel fileset - bos.mp64
3728 # BUILD_GNU_TYPE + AIX_BUILDDATE are used to construct the platform_tag
3729 # of the AIX system used to build/package Python executable. This tag serves
3730 # as a baseline for bdist module packages
3731                AC_MSG_CHECKING([for the system builddate])
3732                AIX_BUILDDATE=$(lslpp -Lcq bos.mp64 | awk -F:  '{ print $NF }')
3733                AC_DEFINE_UNQUOTED([AIX_BUILDDATE], [$AIX_BUILDDATE],
3734                    [BUILD_GNU_TYPE + AIX_BUILDDATE are used to construct the PEP425 tag of the build system.])
3735                AC_MSG_RESULT([$AIX_BUILDDATE])
3736                ;;
3737         *) ;;
3738 esac
3739
3740 # check for systems that require aligned memory access
3741 AC_CACHE_CHECK([aligned memory access is required], [ac_cv_aligned_required],
3742 [AC_RUN_IFELSE([AC_LANG_SOURCE([[
3743 int main(void)
3744 {
3745     char s[16];
3746     int i, *p1, *p2;
3747     for (i=0; i < 16; i++)
3748         s[i] = i;
3749     p1 = (int*)(s+1);
3750     p2 = (int*)(s+2);
3751     if (*p1 == *p2)
3752         return 1;
3753     return 0;
3754 }]])],
3755 [ac_cv_aligned_required=no],
3756 [ac_cv_aligned_required=yes],
3757 [
3758 # "yes" changes the hash function to FNV, which causes problems with Numba
3759 # (https://github.com/numba/numba/blob/0.59.0/numba/cpython/hashing.py#L470).
3760 if test "$ac_sys_system" = "Linux-android"; then
3761   ac_cv_aligned_required=no
3762 else
3763   ac_cv_aligned_required=yes
3764 fi])
3765 ])
3766 if test "$ac_cv_aligned_required" = yes ; then
3767   AC_DEFINE([HAVE_ALIGNED_REQUIRED], [1],
3768     [Define if aligned memory access is required])
3769 fi
3770
3771 # str, bytes and memoryview hash algorithm
3772 AH_TEMPLATE([Py_HASH_ALGORITHM],
3773   [Define hash algorithm for str, bytes and memoryview.
3774    SipHash24: 1, FNV: 2, SipHash13: 3, externally defined: 0])
3775
3776 AC_MSG_CHECKING([for --with-hash-algorithm])
3777 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
3778 AC_ARG_WITH(
3779   [hash_algorithm],
3780   [AS_HELP_STRING(
3781     [--with-hash-algorithm=@<:@fnv|siphash13|siphash24@:>@],
3782     [select hash algorithm for use in Python/pyhash.c (default is SipHash13)]
3783   )],
3784 [
3785 AC_MSG_RESULT([$withval])
3786 case "$withval" in
3787     siphash13)
3788         AC_DEFINE([Py_HASH_ALGORITHM], [3])
3789         ;;
3790     siphash24)
3791         AC_DEFINE([Py_HASH_ALGORITHM], [1])
3792         ;;
3793     fnv)
3794         AC_DEFINE([Py_HASH_ALGORITHM], [2])
3795         ;;
3796     *)
3797         AC_MSG_ERROR([unknown hash algorithm '$withval'])
3798         ;;
3799 esac
3800 ],
3801 [AC_MSG_RESULT([default])])
3802
3803 validate_tzpath() {
3804     # Checks that each element of the path is an absolute path
3805     if test -z "$1"; then
3806         # Empty string is allowed: it indicates no system TZPATH
3807         return 0
3808     fi
3809
3810     # Bad paths are those that don't start with /
3811     dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
3812     if ( echo $1 | grep '\(^\|:\)\(@<:@^/@:>@\|$\)' > /dev/null); then
3813         AC_MSG_ERROR([--with-tzpath must contain only absolute paths, not $1])
3814         return 1;
3815     fi
3816 }
3817
3818 TZPATH="/usr/share/zoneinfo:/usr/lib/zoneinfo:/usr/share/lib/zoneinfo:/etc/zoneinfo"
3819 AC_MSG_CHECKING([for --with-tzpath])
3820 AC_ARG_WITH(
3821   [tzpath],
3822   [AS_HELP_STRING(
3823     [--with-tzpath=<list of absolute paths separated by pathsep>],
3824     [Select the default time zone search path for zoneinfo.TZPATH]
3825   )],
3826 [
3827 case "$withval" in
3828     yes)
3829         AC_MSG_ERROR([--with-tzpath requires a value])
3830         ;;
3831     *)
3832         validate_tzpath "$withval"
3833         TZPATH="$withval"
3834         AC_MSG_RESULT(["$withval"])
3835         ;;
3836 esac
3837 ],
3838 [validate_tzpath "$TZPATH"
3839  AC_MSG_RESULT(["$TZPATH"])])
3840 AC_SUBST([TZPATH])
3841
3842 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
3843 AC_CHECK_LIB([nsl], [t_open], [LIBS="-lnsl $LIBS"]) # SVR4
3844 AC_CHECK_LIB([socket], [socket], [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
3845
3846 case $ac_sys_system/$ac_sys_release in
3847     Haiku*)
3848         AC_CHECK_LIB([network], [socket], [LIBS="-lnetwork $LIBS"], [], [$LIBS])
3849     ;;
3850 esac
3851
3852 AC_MSG_CHECKING([for --with-libs])
3853 AC_ARG_WITH(
3854   [libs],
3855   [AS_HELP_STRING(
3856     [--with-libs='lib1 ...'],
3857     [link against additional libs (default is no)]
3858   )],
3859 [
3860 AC_MSG_RESULT([$withval])
3861 LIBS="$withval $LIBS"
3862 ],
3863 [AC_MSG_RESULT([no])])
3864
3865 # Check for use of the system expat library
3866 AC_MSG_CHECKING([for --with-system-expat])
3867 AC_ARG_WITH(
3868   [system_expat],
3869   [AS_HELP_STRING(
3870      [--with-system-expat],
3871      [build pyexpat module using an installed expat library, see Doc/library/pyexpat.rst (default is no)]
3872   )], [], [with_system_expat="no"])
3873
3874 AC_MSG_RESULT([$with_system_expat])
3875
3876 AS_VAR_IF([with_system_expat], [yes], [
3877   LIBEXPAT_CFLAGS=${LIBEXPAT_CFLAGS-""}
3878   LIBEXPAT_LDFLAGS=${LIBEXPAT_LDFLAGS-"-lexpat"}
3879   LIBEXPAT_INTERNAL=
3880 ], [
3881   LIBEXPAT_CFLAGS="-I\$(srcdir)/Modules/expat"
3882   LIBEXPAT_LDFLAGS="-lm \$(LIBEXPAT_A)"
3883   LIBEXPAT_INTERNAL="\$(LIBEXPAT_HEADERS) \$(LIBEXPAT_A)"
3884 ])
3885
3886 AC_SUBST([LIBEXPAT_CFLAGS])
3887 AC_SUBST([LIBEXPAT_INTERNAL])
3888
3889 dnl detect libffi
3890 have_libffi=missing
3891 AS_VAR_IF([ac_sys_system], [Darwin], [
3892   WITH_SAVE_ENV([
3893     CFLAGS="-I${SDKROOT}/usr/include/ffi $CFLAGS"
3894     AC_CHECK_HEADER([ffi.h], [
3895       AC_CHECK_LIB([ffi], [ffi_call], [
3896         dnl use ffi from SDK root
3897         have_libffi=yes
3898         LIBFFI_CFLAGS="-I${SDKROOT}/usr/include/ffi -DUSING_APPLE_OS_LIBFFI=1"
3899         LIBFFI_LIBS="-lffi"
3900       ])
3901     ])
3902   ])
3903 ])
3904 AS_VAR_IF([have_libffi], [missing], [
3905   PKG_CHECK_MODULES([LIBFFI], [libffi], [have_libffi=yes], [
3906     WITH_SAVE_ENV([
3907       CPPFLAGS="$CPPFLAGS $LIBFFI_CFLAGS"
3908       LDFLAGS="$LDFLAGS $LIBFFI_LIBS"
3909       AC_CHECK_HEADER([ffi.h], [
3910         AC_CHECK_LIB([ffi], [ffi_call], [
3911           have_libffi=yes
3912           LIBFFI_CFLAGS=${LIBFFI_CFLAGS-""}
3913           LIBFFI_LIBS=${LIBFFI_LIBS-"-lffi"}
3914         ], [have_libffi=no])
3915       ])
3916     ])
3917   ])
3918 ])
3919
3920 AS_VAR_IF([have_libffi], [yes], [
3921   ctypes_malloc_closure=no
3922   AS_CASE([$ac_sys_system],
3923     [Darwin], [
3924       dnl when do we need USING_APPLE_OS_LIBFFI?
3925       ctypes_malloc_closure=yes
3926     ],
3927     [iOS], [
3928       ctypes_malloc_closure=yes
3929     ],
3930     [sunos5], [AS_VAR_APPEND([LIBFFI_LIBS], [" -mimpure-text"])]
3931   )
3932   AS_VAR_IF([ctypes_malloc_closure], [yes], [
3933     MODULE__CTYPES_MALLOC_CLOSURE=_ctypes/malloc_closure.c
3934     AS_VAR_APPEND([LIBFFI_CFLAGS], [" -DUSING_MALLOC_CLOSURE_DOT_C=1"])
3935   ])
3936   AC_SUBST([MODULE__CTYPES_MALLOC_CLOSURE])
3937
3938   dnl HAVE_LIBDL: for dlopen, see gh-76828
3939   AS_VAR_IF([ac_cv_lib_dl_dlopen], [yes], [AS_VAR_APPEND([LIBFFI_LIBS], [" -ldl"])])
3940
3941   WITH_SAVE_ENV([
3942     CFLAGS="$LIBFFI_CFLAGS $CFLAGS"
3943     LDFLAGS="$LIBFFI_LIBS $LDFLAGS"
3944
3945     PY_CHECK_FUNC([ffi_prep_cif_var], [@%:@include <ffi.h>])
3946     PY_CHECK_FUNC([ffi_prep_closure_loc], [@%:@include <ffi.h>])
3947     PY_CHECK_FUNC([ffi_closure_alloc], [@%:@include <ffi.h>])
3948   ])
3949 ])
3950
3951 # Check for use of the system libmpdec library
3952 AC_MSG_CHECKING([for --with-system-libmpdec])
3953 AC_ARG_WITH(
3954   [system_libmpdec],
3955   [AS_HELP_STRING(
3956     [--with-system-libmpdec],
3957     [build _decimal module using an installed libmpdec library, see Doc/library/decimal.rst (default is no)]
3958   )],
3959   [],
3960   [with_system_libmpdec="no"])
3961 AC_MSG_RESULT([$with_system_libmpdec])
3962
3963 AS_VAR_IF([with_system_libmpdec], [yes], [
3964   LIBMPDEC_CFLAGS=${LIBMPDEC_CFLAGS-""}
3965   LIBMPDEC_LDFLAGS=${LIBMPDEC_LDFLAGS-"-lmpdec"}
3966   LIBMPDEC_INTERNAL=
3967 ], [
3968   LIBMPDEC_CFLAGS="-I\$(srcdir)/Modules/_decimal/libmpdec"
3969   LIBMPDEC_LDFLAGS="-lm \$(LIBMPDEC_A)"
3970   LIBMPDEC_INTERNAL="\$(LIBMPDEC_HEADERS) \$(LIBMPDEC_A)"
3971
3972   dnl Disable forced inlining in debug builds, see GH-94847
3973   AS_VAR_IF([with_pydebug], [yes], [
3974     AS_VAR_APPEND([LIBMPDEC_CFLAGS], [" -DTEST_COVERAGE"])
3975   ])
3976 ])
3977
3978 AC_SUBST([LIBMPDEC_CFLAGS])
3979 AC_SUBST([LIBMPDEC_INTERNAL])
3980
3981 # Check whether _decimal should use a coroutine-local or thread-local context
3982 AC_MSG_CHECKING([for --with-decimal-contextvar])
3983 AC_ARG_WITH(
3984   [decimal_contextvar],
3985   [AS_HELP_STRING(
3986     [--with-decimal-contextvar],
3987     [build _decimal module using a coroutine-local rather than a thread-local context (default is yes)]
3988   )],
3989   [],
3990   [with_decimal_contextvar="yes"])
3991
3992 if test "$with_decimal_contextvar" != "no"
3993 then
3994     AC_DEFINE([WITH_DECIMAL_CONTEXTVAR], [1],
3995       [Define if you want build the _decimal module using a coroutine-local rather than a thread-local context])
3996 fi
3997
3998 AC_MSG_RESULT([$with_decimal_contextvar])
3999
4000 # Check for libmpdec machine flavor
4001 AC_MSG_CHECKING([for decimal libmpdec machine])
4002 AS_CASE([$ac_sys_system],
4003   [Darwin*], [libmpdec_system=Darwin],
4004   [SunOS*], [libmpdec_system=sunos],
4005   [libmpdec_system=other]
4006 )
4007
4008 libmpdec_machine=unknown
4009 if test "$libmpdec_system" = Darwin; then
4010     # universal here means: build libmpdec with the same arch options
4011     # the python interpreter was built with
4012     libmpdec_machine=universal
4013 elif test $ac_cv_sizeof_size_t -eq 8; then
4014     if test "$ac_cv_gcc_asm_for_x64" = yes; then
4015         libmpdec_machine=x64
4016     elif test "$ac_cv_type___uint128_t" = yes; then
4017         libmpdec_machine=uint128
4018     else
4019         libmpdec_machine=ansi64
4020     fi
4021 elif test $ac_cv_sizeof_size_t -eq 4; then
4022     if test "$ac_cv_gcc_asm_for_x87" = yes -a "$libmpdec_system" != sunos; then
4023         AS_CASE([$CC],
4024             [*gcc*],   [libmpdec_machine=ppro],
4025             [*clang*], [libmpdec_machine=ppro],
4026             [libmpdec_machine=ansi32]
4027         )
4028     else
4029         libmpdec_machine=ansi32
4030     fi
4031 fi
4032 AC_MSG_RESULT([$libmpdec_machine])
4033
4034 AS_CASE([$libmpdec_machine],
4035   [x64],         [AS_VAR_APPEND([LIBMPDEC_CFLAGS], [" -DCONFIG_64=1 -DASM=1"])],
4036   [uint128],     [AS_VAR_APPEND([LIBMPDEC_CFLAGS], [" -DCONFIG_64=1 -DANSI=1 -DHAVE_UINT128_T=1"])],
4037   [ansi64],      [AS_VAR_APPEND([LIBMPDEC_CFLAGS], [" -DCONFIG_64=1 -DANSI=1"])],
4038   [ppro],        [AS_VAR_APPEND([LIBMPDEC_CFLAGS], [" -DCONFIG_32=1 -DANSI=1 -DASM=1 -Wno-unknown-pragmas"])],
4039   [ansi32],      [AS_VAR_APPEND([LIBMPDEC_CFLAGS], [" -DCONFIG_32=1 -DANSI=1"])],
4040   [ansi-legacy], [AS_VAR_APPEND([LIBMPDEC_CFLAGS], [" -DCONFIG_32=1 -DANSI=1 -DLEGACY_COMPILER=1"])],
4041   [universal],   [AS_VAR_APPEND([LIBMPDEC_CFLAGS], [" -DUNIVERSAL=1"])],
4042   [AC_MSG_ERROR([_decimal: unsupported architecture])]
4043 )
4044
4045 if test "$have_ipa_pure_const_bug" = yes; then
4046     # Some versions of gcc miscompile inline asm:
4047     # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=46491
4048     # https://gcc.gnu.org/ml/gcc/2010-11/msg00366.html
4049     AS_VAR_APPEND([LIBMPDEC_CFLAGS], [" -fno-ipa-pure-const"])
4050 fi
4051
4052 if test "$have_glibc_memmove_bug" = yes; then
4053     # _FORTIFY_SOURCE wrappers for memmove and bcopy are incorrect:
4054     # https://sourceware.org/ml/libc-alpha/2010-12/msg00009.html
4055     AS_VAR_APPEND([LIBMPDEC_CFLAGS], [" -U_FORTIFY_SOURCE"])
4056 fi
4057
4058
4059 dnl detect sqlite3 from Emscripten emport
4060 PY_CHECK_EMSCRIPTEN_PORT([LIBSQLITE3], [-sUSE_SQLITE3])
4061
4062 dnl Check for SQLite library. Use pkg-config if available.
4063 PKG_CHECK_MODULES(
4064   [LIBSQLITE3], [sqlite3 >= 3.15.2], [], [
4065     LIBSQLITE3_CFLAGS=${LIBSQLITE3_CFLAGS-""}
4066     LIBSQLITE3_LIBS=${LIBSQLITE3_LIBS-"-lsqlite3"}
4067   ]
4068 )
4069 AS_VAR_APPEND([LIBSQLITE3_CFLAGS], [' -I$(srcdir)/Modules/_sqlite'])
4070
4071 dnl PY_CHECK_SQLITE_FUNC(FUNCTION, IF-FOUND, IF-NOT-FOUND)
4072 AC_DEFUN([PY_CHECK_SQLITE_FUNC], [
4073   AC_CHECK_LIB([sqlite3], [$1], [$2], [
4074     m4_ifblank([$3], [have_supported_sqlite3=no], [$3])
4075   ])
4076 ])
4077
4078 WITH_SAVE_ENV([
4079 dnl bpo-45774/GH-29507: The CPP check in AC_CHECK_HEADER can fail on FreeBSD,
4080 dnl hence CPPFLAGS instead of CFLAGS.
4081   CPPFLAGS="$CPPFLAGS $LIBSQLITE3_CFLAGS"
4082   LDFLAGS="$LIBSQLITE3_LIBS $LDFLAGS"
4083
4084   AC_CHECK_HEADER([sqlite3.h], [
4085     have_sqlite3=yes
4086
4087     AC_COMPILE_IFELSE([
4088       AC_LANG_PROGRAM([
4089         #include <sqlite3.h>
4090         #if SQLITE_VERSION_NUMBER < 3015002
4091         #  error "SQLite 3.15.2 or higher required"
4092         #endif
4093       ], [])
4094     ], [
4095       have_supported_sqlite3=yes
4096       dnl Check that required functions are in place. A lot of stuff may be
4097       dnl omitted with SQLITE_OMIT_* compile time defines.
4098       PY_CHECK_SQLITE_FUNC([sqlite3_bind_double])
4099       PY_CHECK_SQLITE_FUNC([sqlite3_column_decltype])
4100       PY_CHECK_SQLITE_FUNC([sqlite3_column_double])
4101       PY_CHECK_SQLITE_FUNC([sqlite3_complete])
4102       PY_CHECK_SQLITE_FUNC([sqlite3_progress_handler])
4103       PY_CHECK_SQLITE_FUNC([sqlite3_result_double])
4104       PY_CHECK_SQLITE_FUNC([sqlite3_set_authorizer])
4105       PY_CHECK_SQLITE_FUNC([sqlite3_trace_v2], [], [
4106         PY_CHECK_SQLITE_FUNC([sqlite3_trace])
4107       ])
4108       PY_CHECK_SQLITE_FUNC([sqlite3_value_double])
4109       AC_CHECK_LIB([sqlite3], [sqlite3_load_extension],
4110         [have_sqlite3_load_extension=yes],
4111         [have_sqlite3_load_extension=no]
4112       )
4113       AC_CHECK_LIB([sqlite3], [sqlite3_serialize], [
4114         AC_DEFINE(
4115           [PY_SQLITE_HAVE_SERIALIZE], [1],
4116           [Define if SQLite was compiled with the serialize API]
4117         )
4118       ])
4119     ], [
4120       have_supported_sqlite3=no
4121     ])
4122   ])
4123 ])
4124
4125 dnl Check for support for loadable sqlite extensions
4126 AC_MSG_CHECKING([for --enable-loadable-sqlite-extensions])
4127 AC_ARG_ENABLE([loadable-sqlite-extensions],
4128   AS_HELP_STRING(
4129     [--enable-loadable-sqlite-extensions], [
4130       support loadable extensions in the sqlite3 module, see
4131       Doc/library/sqlite3.rst (default is no)
4132     ]
4133   ), [
4134     AS_VAR_IF([have_sqlite3_load_extension], [no], [
4135       AC_MSG_RESULT([n/a])
4136       AC_MSG_WARN([Your version of SQLite does not support loadable extensions])
4137     ], [
4138       AC_MSG_RESULT([yes])
4139       AC_DEFINE(
4140         [PY_SQLITE_ENABLE_LOAD_EXTENSION], [1],
4141         [Define to 1 to build the sqlite module with loadable extensions support.]
4142       )
4143     ])
4144   ], [
4145     AC_MSG_RESULT([no])
4146   ]
4147 )
4148
4149 dnl
4150 dnl Detect Tcl/Tk. Use pkg-config if available.
4151 dnl
4152 found_tcltk=no
4153 for _QUERY in \
4154   "tcl >= 8.5.12 tk >= 8.5.12" \
4155   "tcl8.6 tk8.6" \
4156   "tcl86 tk86" \
4157   "tcl8.5 >= 8.5.12 tk8.5 >= 8.5.12" \
4158   "tcl85 >= 8.5.12 tk85 >= 8.5.12" \
4159 ; do
4160   PKG_CHECK_EXISTS([$_QUERY], [
4161     PKG_CHECK_MODULES([TCLTK], [$_QUERY], [found_tcltk=yes], [found_tcltk=no])
4162   ])
4163   AS_VAR_IF([found_tcltk], [yes], [break])
4164 done
4165
4166 AS_VAR_IF([found_tcltk], [no], [
4167   TCLTK_CFLAGS=${TCLTK_CFLAGS-""}
4168   TCLTK_LIBS=${TCLTK_LIBS-""}
4169 ])
4170
4171 dnl FreeBSD has an X11 dependency which is not implicitly resolved.
4172 AS_CASE([$ac_sys_system],
4173   [FreeBSD*], [
4174     PKG_CHECK_EXISTS([x11], [
4175       PKG_CHECK_MODULES([X11], [x11], [
4176         TCLTK_CFLAGS="$TCLTK_CFLAGS $X11_CFLAGS"
4177         TCLTK_LIBS="$TCLTK_LIBS $X11_LIBS"
4178       ])
4179     ])
4180   ]
4181 )
4182
4183 WITH_SAVE_ENV([
4184   CPPFLAGS="$CPPFLAGS $TCLTK_CFLAGS"
4185   LIBS="$TCLTK_LIBS $LDFLAGS"
4186
4187   AC_LINK_IFELSE([
4188     AC_LANG_PROGRAM([
4189       #include <tcl.h>
4190       #include <tk.h>
4191       #if defined(TK_HEX_VERSION)
4192       #  if TK_HEX_VERSION < 0x0805020c
4193       #    error "Tk older than 8.5.12 not supported"
4194       #  endif
4195       #endif
4196       #if (TCL_MAJOR_VERSION < 8) || \
4197           ((TCL_MAJOR_VERSION == 8) && (TCL_MINOR_VERSION < 5)) || \
4198           ((TCL_MAJOR_VERSION == 8) && (TCL_MINOR_VERSION == 5) && (TCL_RELEASE_SERIAL < 12))
4199       #  error "Tcl older than 8.5.12 not supported"
4200       #endif
4201       #if (TK_MAJOR_VERSION < 8) || \
4202           ((TK_MAJOR_VERSION == 8) && (TK_MINOR_VERSION < 5)) || \
4203           ((TK_MAJOR_VERSION == 8) && (TK_MINOR_VERSION == 5) && (TK_RELEASE_SERIAL < 12))
4204       #  error "Tk older than 8.5.12 not supported"
4205       #endif
4206     ], [
4207       void *x1 = Tcl_Init;
4208       void *x2 = Tk_Init;
4209     ])
4210   ], [
4211     have_tcltk=yes
4212     dnl The X11/xlib.h file bundled in the Tk sources can cause function
4213     dnl prototype warnings from the compiler. Since we cannot easily fix
4214     dnl that, suppress the warnings here instead.
4215     AS_VAR_APPEND([TCLTK_CFLAGS], [" -Wno-strict-prototypes -DWITH_APPINIT=1"])
4216   ], [
4217     have_tcltk=no
4218   ])
4219 ])
4220
4221 dnl check for _gdbmmodule dependencies
4222 dnl NOTE: gdbm does not provide a pkgconf file.
4223 AC_ARG_VAR([GDBM_CFLAGS], [C compiler flags for gdbm])
4224 AC_ARG_VAR([GDBM_LIBS], [additional linker flags for gdbm])
4225 WITH_SAVE_ENV([
4226   CPPFLAGS="$CPPFLAGS $GDBM_CFLAGS"
4227   LDFLAGS="$GDBM_LIBS $LDFLAGS"
4228   AC_CHECK_HEADERS([gdbm.h], [
4229     AC_CHECK_LIB([gdbm], [gdbm_open], [
4230       have_gdbm=yes
4231       GDBM_LIBS=${GDBM_LIBS-"-lgdbm"}
4232     ], [have_gdbm=no])
4233   ], [have_gdbm=no])
4234 ])
4235
4236 dnl check for _dbmmodule.c dependencies
4237 dnl ndbm, gdbm_compat, libdb
4238 AC_CHECK_HEADERS([ndbm.h], [
4239   WITH_SAVE_ENV([
4240     AC_SEARCH_LIBS([dbm_open], [ndbm gdbm_compat])
4241   ])
4242 ])
4243
4244 AC_MSG_CHECKING([for ndbm presence and linker args])
4245 AS_CASE([$ac_cv_search_dbm_open],
4246   [*ndbm*|*gdbm_compat*], [
4247     dbm_ndbm="$ac_cv_search_dbm_open"
4248     have_ndbm=yes
4249   ],
4250   [none*], [
4251     dbm_ndbm=""
4252     have_ndbm=yes
4253   ],
4254   [no], [have_ndbm=no]
4255 )
4256 AC_MSG_RESULT([$have_ndbm ($dbm_ndbm)])
4257
4258 dnl "gdbm-ndbm.h" and "gdbm/ndbm.h" are both normalized to "gdbm_ndbm_h"
4259 dnl unset ac_cv_header_gdbm_ndbm_h to prevent false positive cache hits.
4260 AS_UNSET([ac_cv_header_gdbm_ndbm_h])
4261 AC_CACHE_VAL([ac_cv_header_gdbm_slash_ndbm_h], [
4262   AC_CHECK_HEADER(
4263     [gdbm/ndbm.h],
4264     [ac_cv_header_gdbm_slash_ndbm_h=yes], [ac_cv_header_gdbm_slash_ndbm_h=no]
4265   )
4266 ])
4267 AS_VAR_IF([ac_cv_header_gdbm_slash_ndbm_h], [yes], [
4268   AC_DEFINE([HAVE_GDBM_NDBM_H], [1], [Define to 1 if you have the <gdbm/ndbm.h> header file.])
4269 ])
4270
4271 AS_UNSET([ac_cv_header_gdbm_ndbm_h])
4272 AC_CACHE_VAL([ac_cv_header_gdbm_dash_ndbm_h], [
4273   AC_CHECK_HEADER(
4274     [gdbm-ndbm.h],
4275     [ac_cv_header_gdbm_dash_ndbm_h=yes], [ac_cv_header_gdbm_dash_ndbm_h=no]
4276   )
4277 ])
4278 AS_VAR_IF([ac_cv_header_gdbm_dash_ndbm_h], [yes], [
4279   AC_DEFINE([HAVE_GDBM_DASH_NDBM_H], [1], [Define to 1 if you have the <gdbm-ndbm.h> header file.])
4280 ])
4281 AS_UNSET([ac_cv_header_gdbm_ndbm_h])
4282
4283 if test "$ac_cv_header_gdbm_slash_ndbm_h" = yes -o "$ac_cv_header_gdbm_dash_ndbm_h" = yes; then
4284   AS_UNSET([ac_cv_search_dbm_open])
4285   WITH_SAVE_ENV([
4286     AC_SEARCH_LIBS([dbm_open], [gdbm_compat], [have_gdbm_compat=yes], [have_gdbm_compat=no])
4287   ])
4288 fi
4289
4290 # Check for libdb >= 5 with dbm_open()
4291 # db.h re-defines the name of the function
4292 AC_CHECK_HEADERS([db.h], [
4293   AC_CACHE_CHECK([for libdb], [ac_cv_have_libdb], [
4294     WITH_SAVE_ENV([
4295       LIBS="$LIBS -ldb"
4296       AC_LINK_IFELSE([AC_LANG_PROGRAM([
4297         #define DB_DBM_HSEARCH 1
4298         #include <db.h>
4299         #if DB_VERSION_MAJOR < 5
4300           #error "dh.h: DB_VERSION_MAJOR < 5 is not supported."
4301         #endif
4302         ], [DBM *dbm = dbm_open(NULL, 0, 0)])
4303       ], [ac_cv_have_libdb=yes], [ac_cv_have_libdb=no])
4304     ])
4305   ])
4306   AS_VAR_IF([ac_cv_have_libdb], [yes], [
4307     AC_DEFINE([HAVE_LIBDB], [1], [Define to 1 if you have the `db' library (-ldb).])
4308   ])
4309 ])
4310
4311 # Check for --with-dbmliborder
4312 AC_MSG_CHECKING([for --with-dbmliborder])
4313 AC_ARG_WITH(
4314   [dbmliborder],
4315   [AS_HELP_STRING(
4316     [--with-dbmliborder=db1:db2:...],
4317     [override order to check db backends for dbm; a valid value is a colon separated string with the backend names `ndbm', `gdbm' and `bdb'.]
4318   )],
4319   [], [with_dbmliborder=gdbm:ndbm:bdb])
4320
4321 have_gdbm_dbmliborder=no
4322 as_save_IFS=$IFS
4323 IFS=:
4324 for db in $with_dbmliborder; do
4325     AS_CASE([$db],
4326       [ndbm], [],
4327       [gdbm], [have_gdbm_dbmliborder=yes],
4328       [bdb], [],
4329       [with_dbmliborder=error]
4330     )
4331 done
4332 IFS=$as_save_IFS
4333 AS_VAR_IF([with_dbmliborder], [error], [
4334   AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:... (gdbm:ndbm:bdb)])
4335 ])
4336 AC_MSG_RESULT([$with_dbmliborder])
4337
4338 AC_MSG_CHECKING([for _dbm module CFLAGS and LIBS])
4339 have_dbm=no
4340 as_save_IFS=$IFS
4341 IFS=:
4342 for db in $with_dbmliborder; do
4343   case "$db" in
4344     ndbm)
4345       if test "$have_ndbm" = yes; then
4346         DBM_CFLAGS="-DUSE_NDBM"
4347         DBM_LIBS="$dbm_ndbm"
4348         have_dbm=yes
4349         break
4350       fi
4351       ;;
4352     gdbm)
4353       if test "$have_gdbm_compat" = yes; then
4354         DBM_CFLAGS="-DUSE_GDBM_COMPAT"
4355         DBM_LIBS="-lgdbm_compat"
4356         have_dbm=yes
4357         break
4358       fi
4359       ;;
4360     bdb)
4361       if test "$ac_cv_have_libdb" = yes; then
4362         DBM_CFLAGS="-DUSE_BERKDB"
4363         DBM_LIBS="-ldb"
4364         have_dbm=yes
4365         break
4366       fi
4367      ;;
4368   esac
4369 done
4370 IFS=$as_save_IFS
4371 AC_MSG_RESULT([$DBM_CFLAGS $DBM_LIBS])
4372
4373 # Templates for things AC_DEFINEd more than once.
4374 # For a single AC_DEFINE, no template is needed.
4375 AH_TEMPLATE([_REENTRANT],
4376   [Define to force use of thread-safe errno, h_errno, and other functions])
4377
4378 if test "$ac_cv_pthread_is_default" = yes
4379 then
4380     # Defining _REENTRANT on system with POSIX threads should not hurt.
4381     AC_DEFINE([_REENTRANT])
4382     posix_threads=yes
4383     if test "$ac_sys_system" = "SunOS"; then
4384         CFLAGS="$CFLAGS -D_REENTRANT"
4385     fi
4386 elif test "$ac_cv_kpthread" = "yes"
4387 then
4388     CC="$CC -Kpthread"
4389     if test "$ac_cv_cxx_thread" = "yes"; then
4390         CXX="$CXX -Kpthread"
4391     fi
4392     posix_threads=yes
4393 elif test "$ac_cv_kthread" = "yes"
4394 then
4395     CC="$CC -Kthread"
4396     if test "$ac_cv_cxx_thread" = "yes"; then
4397         CXX="$CXX -Kthread"
4398     fi
4399     posix_threads=yes
4400 elif test "$ac_cv_pthread" = "yes"
4401 then
4402     CC="$CC -pthread"
4403     if test "$ac_cv_cxx_thread" = "yes"; then
4404         CXX="$CXX -pthread"
4405     fi
4406     posix_threads=yes
4407 else
4408     if test ! -z "$withval" -a -d "$withval"
4409     then LDFLAGS="$LDFLAGS -L$withval"
4410     fi
4411
4412     # According to the POSIX spec, a pthreads implementation must
4413     # define _POSIX_THREADS in unistd.h. Some apparently don't
4414     # (e.g. gnu pth with pthread emulation)
4415     AC_MSG_CHECKING([for _POSIX_THREADS in unistd.h])
4416     AX_CHECK_DEFINE([unistd.h], [_POSIX_THREADS],
4417                     [unistd_defines_pthreads=yes],
4418                     [unistd_defines_pthreads=no])
4419     AC_MSG_RESULT([$unistd_defines_pthreads])
4420
4421     AC_DEFINE([_REENTRANT])
4422     # Just looking for pthread_create in libpthread is not enough:
4423     # on HP/UX, pthread.h renames pthread_create to a different symbol name.
4424     # So we really have to include pthread.h, and then link.
4425     _libs=$LIBS
4426     LIBS="$LIBS -lpthread"
4427     AC_MSG_CHECKING([for pthread_create in -lpthread])
4428     AC_LINK_IFELSE([AC_LANG_PROGRAM([[
4429 #include <stdio.h>
4430 #include <stdlib.h>
4431 #include <pthread.h>
4432
4433 void * start_routine (void *arg) { exit (0); }]], [[
4434 pthread_create (NULL, NULL, start_routine, NULL)]])],[
4435     AC_MSG_RESULT([yes])
4436     posix_threads=yes
4437     ],[
4438     LIBS=$_libs
4439     AC_CHECK_FUNC([pthread_detach], [
4440     posix_threads=yes
4441     ],[
4442     AC_CHECK_LIB([pthreads], [pthread_create], [
4443     posix_threads=yes
4444     LIBS="$LIBS -lpthreads"
4445     ], [
4446     AC_CHECK_LIB([c_r], [pthread_create], [
4447     posix_threads=yes
4448     LIBS="$LIBS -lc_r"
4449     ], [
4450     AC_CHECK_LIB([pthread], [__pthread_create_system], [
4451     posix_threads=yes
4452     LIBS="$LIBS -lpthread"
4453     ], [
4454     AC_CHECK_LIB([cma], [pthread_create], [
4455     posix_threads=yes
4456     LIBS="$LIBS -lcma"
4457     ],[
4458     AS_CASE([$ac_sys_system],
4459       [WASI], [posix_threads=stub],
4460       [AC_MSG_ERROR([could not find pthreads on your system])]
4461     )
4462     ])])])])])])
4463
4464     AC_CHECK_LIB([mpc], [usconfig], [
4465     LIBS="$LIBS -lmpc"
4466     ])
4467
4468 fi
4469
4470 if test "$posix_threads" = "yes"; then
4471       if test "$unistd_defines_pthreads" = "no"; then
4472          AC_DEFINE([_POSIX_THREADS], [1],
4473          [Define if you have POSIX threads,
4474           and your system does not define that.])
4475       fi
4476
4477       # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
4478       case  $ac_sys_system/$ac_sys_release in
4479       SunOS/5.6) AC_DEFINE([HAVE_PTHREAD_DESTRUCTOR], [1],
4480                        [Defined for Solaris 2.6 bug in pthread header.])
4481                        ;;
4482       SunOS/5.8) AC_DEFINE([HAVE_BROKEN_POSIX_SEMAPHORES], [1],
4483                        [Define if the Posix semaphores do not work on your system])
4484                        ;;
4485       AIX/*) AC_DEFINE([HAVE_BROKEN_POSIX_SEMAPHORES], [1],
4486                        [Define if the Posix semaphores do not work on your system])
4487                        ;;
4488       NetBSD/*) AC_DEFINE([HAVE_BROKEN_POSIX_SEMAPHORES], [1],
4489                        [Define if the Posix semaphores do not work on your system])
4490                        ;;
4491       esac
4492
4493       AC_CACHE_CHECK([if PTHREAD_SCOPE_SYSTEM is supported], [ac_cv_pthread_system_supported],
4494       [AC_RUN_IFELSE([AC_LANG_SOURCE([[
4495       #include <stdio.h>
4496       #include <pthread.h>
4497       void *foo(void *parm) {
4498         return NULL;
4499       }
4500       int main(void) {
4501         pthread_attr_t attr;
4502         pthread_t id;
4503         if (pthread_attr_init(&attr)) return (-1);
4504         if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) return (-1);
4505         if (pthread_create(&id, &attr, foo, NULL)) return (-1);
4506         return (0);
4507       }]])],
4508       [ac_cv_pthread_system_supported=yes],
4509       [ac_cv_pthread_system_supported=no],
4510       [ac_cv_pthread_system_supported=no])
4511       ])
4512       if test "$ac_cv_pthread_system_supported" = "yes"; then
4513         AC_DEFINE([PTHREAD_SYSTEM_SCHED_SUPPORTED], [1],
4514                   [Defined if PTHREAD_SCOPE_SYSTEM supported.])
4515       fi
4516       AC_CHECK_FUNCS([pthread_sigmask],
4517         [case $ac_sys_system in
4518         CYGWIN*)
4519           AC_DEFINE([HAVE_BROKEN_PTHREAD_SIGMASK], [1],
4520             [Define if pthread_sigmask() does not work on your system.])
4521             ;;
4522         esac])
4523       AC_CHECK_FUNCS([pthread_getcpuclockid])
4524 fi
4525
4526 AS_VAR_IF([posix_threads], [stub], [
4527   AC_DEFINE([HAVE_PTHREAD_STUBS], [1], [Define if platform requires stubbed pthreads support])
4528 ])
4529
4530 # Check for enable-ipv6
4531 AH_TEMPLATE([ENABLE_IPV6], [Define if --enable-ipv6 is specified])
4532 AC_MSG_CHECKING([if --enable-ipv6 is specified])
4533 AC_ARG_ENABLE([ipv6],
4534   [AS_HELP_STRING(
4535     [--enable-ipv6],
4536     [enable ipv6 (with ipv4) support, see Doc/library/socket.rst (default is yes if supported)]
4537   )],
4538 [ case "$enableval" in
4539   no)
4540        AC_MSG_RESULT([no])
4541        ipv6=no
4542        ;;
4543   *)   AC_MSG_RESULT([yes])
4544        AC_DEFINE([ENABLE_IPV6])
4545        ipv6=yes
4546        ;;
4547   esac ],
4548
4549 [
4550 dnl the check does not work on cross compilation case...
4551   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ /* AF_INET6 available check */
4552 #include <sys/types.h>
4553 @%:@include <sys/socket.h>]],
4554 [[int domain = AF_INET6;]])],[
4555   ipv6=yes
4556 ],[
4557   ipv6=no
4558 ])
4559
4560 AS_CASE([$ac_sys_system],
4561   [WASI], [ipv6=no]
4562 )
4563
4564 AC_MSG_RESULT([$ipv6])
4565
4566 if test "$ipv6" = "yes"; then
4567         AC_MSG_CHECKING([if RFC2553 API is available])
4568         AC_COMPILE_IFELSE([
4569           AC_LANG_PROGRAM([[#include <sys/types.h>
4570 @%:@include <netinet/in.h>]],
4571                           [[struct sockaddr_in6 x;
4572                             x.sin6_scope_id;]])
4573         ],[
4574           AC_MSG_RESULT([yes])
4575           ipv6=yes
4576         ],[
4577           AC_MSG_RESULT([no], [IPv6 disabled])
4578           ipv6=no
4579         ])
4580 fi
4581
4582 if test "$ipv6" = "yes"; then
4583         AC_DEFINE([ENABLE_IPV6])
4584 fi
4585 ])
4586
4587 ipv6type=unknown
4588 ipv6lib=none
4589 ipv6trylibc=no
4590
4591 if test "$ipv6" = yes -a "$cross_compiling" = no; then
4592         for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
4593         do
4594                 case $i in
4595                 inria)
4596                         dnl http://www.kame.net/
4597                         AX_CHECK_DEFINE([netinet/in.h], [IPV6_INRIA_VERSION], [ipv6type=$i])
4598                         ;;
4599                 kame)
4600                         dnl http://www.kame.net/
4601                         AX_CHECK_DEFINE([netinet/in.h], [__KAME__],
4602                             [ipv6type=$i
4603                              ipv6lib=inet6
4604                              ipv6libdir=/usr/local/v6/lib
4605                              ipv6trylibc=yes])
4606                         ;;
4607                 linux-glibc)
4608                         dnl Advanced IPv6 support was added to glibc 2.1 in 1999.
4609                         AX_CHECK_DEFINE([features.h], [__GLIBC__],
4610                             [ipv6type=$i
4611                              ipv6trylibc=yes])
4612                         ;;
4613                 linux-inet6)
4614                         dnl http://www.v6.linux.or.jp/
4615                         if test -d /usr/inet6; then
4616                                 ipv6type=$i
4617                                 ipv6lib=inet6
4618                                 ipv6libdir=/usr/inet6/lib
4619                                 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
4620                         fi
4621                         ;;
4622                 solaris)
4623                         if test -f /etc/netconfig; then
4624                           if $GREP -q tcp6 /etc/netconfig; then
4625                                 ipv6type=$i
4626                                 ipv6trylibc=yes
4627                           fi
4628                         fi
4629                         ;;
4630                 toshiba)
4631                         AX_CHECK_DEFINE([sys/param.h], [_TOSHIBA_INET6],
4632                             [ipv6type=$i
4633                              ipv6lib=inet6
4634                              ipv6libdir=/usr/local/v6/lib])
4635                         ;;
4636                 v6d)
4637                         AX_CHECK_DEFINE([/usr/local/v6/include/sys/v6config.h], [__V6D__],
4638                             [ipv6type=$i
4639                              ipv6lib=v6
4640                              ipv6libdir=/usr/local/v6/lib
4641                              BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
4642                         ;;
4643                 zeta)
4644                         AX_CHECK_DEFINE([sys/param.h], [_ZETA_MINAMI_INET6],
4645                             [ipv6type=$i
4646                              ipv6lib=inet6
4647                              ipv6libdir=/usr/local/v6/lib])
4648                         ;;
4649                 esac
4650                 if test "$ipv6type" != "unknown"; then
4651                         break
4652                 fi
4653         done
4654         AC_MSG_CHECKING([ipv6 stack type])
4655         AC_MSG_RESULT([$ipv6type])
4656 fi
4657
4658 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
4659     AC_MSG_CHECKING([ipv6 library])
4660         if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
4661                 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
4662                 AC_MSG_RESULT([lib$ipv6lib])
4663         else
4664     AS_VAR_IF([ipv6trylibc], [yes], [
4665       AC_MSG_RESULT([libc])
4666     ], [
4667       AC_MSG_ERROR([m4_normalize([
4668         No $ipv6lib library found; cannot continue.
4669         You need to fetch lib$ipv6lib.a from appropriate
4670         ipv6 kit and compile beforehand.
4671       ])])
4672     ])
4673         fi
4674 fi
4675
4676
4677 AC_CACHE_CHECK([CAN_RAW_FD_FRAMES], [ac_cv_can_raw_fd_frames], [
4678 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ /* CAN_RAW_FD_FRAMES available check */
4679 @%:@include <linux/can/raw.h>]],
4680 [[int can_raw_fd_frames = CAN_RAW_FD_FRAMES;]])],
4681 [ac_cv_can_raw_fd_frames=yes],
4682 [ac_cv_can_raw_fd_frames=no])
4683 ])
4684 AS_VAR_IF([ac_cv_can_raw_fd_frames], [yes], [
4685     AC_DEFINE([HAVE_LINUX_CAN_RAW_FD_FRAMES], [1],
4686               [Define if compiling using Linux 3.6 or later.])
4687 ])
4688
4689 AC_CACHE_CHECK([for CAN_RAW_JOIN_FILTERS], [ac_cv_can_raw_join_filters], [
4690 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
4691 @%:@include <linux/can/raw.h>]],
4692 [[int can_raw_join_filters = CAN_RAW_JOIN_FILTERS;]])],
4693 [ac_cv_can_raw_join_filters=yes],
4694 [ac_cv_can_raw_join_filters=no])
4695 ])
4696 AS_VAR_IF([ac_cv_can_raw_join_filters], [yes], [
4697     AC_DEFINE([HAVE_LINUX_CAN_RAW_JOIN_FILTERS], [1],
4698               [Define if compiling using Linux 4.1 or later.])
4699 ])
4700
4701 # Check for --with-doc-strings
4702 AC_MSG_CHECKING([for --with-doc-strings])
4703 AC_ARG_WITH(
4704   [doc-strings],
4705   [AS_HELP_STRING([--with-doc-strings], [enable documentation strings (default is yes)])])
4706
4707 if test -z "$with_doc_strings"
4708 then with_doc_strings="yes"
4709 fi
4710 if test "$with_doc_strings" != "no"
4711 then
4712     AC_DEFINE([WITH_DOC_STRINGS], [1],
4713       [Define if you want documentation strings in extension modules])
4714 fi
4715 AC_MSG_RESULT([$with_doc_strings])
4716
4717 # Check for stdatomic.h, required for mimalloc.
4718 AC_CACHE_CHECK([for stdatomic.h], [ac_cv_header_stdatomic_h], [
4719 AC_LINK_IFELSE(
4720 [
4721   AC_LANG_SOURCE([[
4722     #include <stdatomic.h>
4723     atomic_int int_var;
4724     atomic_uintptr_t uintptr_var;
4725     int main() {
4726       atomic_store_explicit(&int_var, 5, memory_order_relaxed);
4727       atomic_store_explicit(&uintptr_var, 0, memory_order_relaxed);
4728       int loaded_value = atomic_load_explicit(&int_var, memory_order_seq_cst);
4729       return 0;
4730     }
4731   ]])
4732 ],[ac_cv_header_stdatomic_h=yes],[ac_cv_header_stdatomic_h=no])
4733 ])
4734
4735 AS_VAR_IF([ac_cv_header_stdatomic_h], [yes], [
4736     AC_DEFINE(HAVE_STD_ATOMIC, 1,
4737               [Has stdatomic.h with atomic_int and atomic_uintptr_t])
4738 ])
4739
4740 # Check for GCC >= 4.7 and clang __atomic builtin functions
4741 AC_CACHE_CHECK([for builtin __atomic_load_n and __atomic_store_n functions], [ac_cv_builtin_atomic], [
4742 AC_LINK_IFELSE(
4743 [
4744   AC_LANG_SOURCE([[
4745     int val;
4746     int main() {
4747       __atomic_store_n(&val, 1, __ATOMIC_SEQ_CST);
4748       (void)__atomic_load_n(&val, __ATOMIC_SEQ_CST);
4749       return 0;
4750     }
4751   ]])
4752 ],[ac_cv_builtin_atomic=yes],[ac_cv_builtin_atomic=no])
4753 ])
4754
4755 AS_VAR_IF([ac_cv_builtin_atomic], [yes], [
4756     AC_DEFINE(HAVE_BUILTIN_ATOMIC, 1, [Has builtin __atomic_load_n() and __atomic_store_n() functions])
4757 ])
4758
4759 # --with-mimalloc
4760 AC_MSG_CHECKING([for --with-mimalloc])
4761 AC_ARG_WITH([mimalloc],
4762   [AS_HELP_STRING([--with-mimalloc],
4763                  [build with mimalloc memory allocator (default is yes if C11 stdatomic.h is available.)])],
4764   [],
4765   [with_mimalloc="$ac_cv_header_stdatomic_h"]
4766 )
4767
4768 if test "$with_mimalloc" != no; then
4769   if test "$ac_cv_header_stdatomic_h" != yes; then
4770     # mimalloc-atomic.h wants C11 stdatomic.h on POSIX
4771     AC_MSG_ERROR([mimalloc requires stdatomic.h, use --without-mimalloc to disable mimalloc.])
4772   fi
4773   with_mimalloc=yes
4774   AC_DEFINE([WITH_MIMALLOC], [1], [Define if you want to compile in mimalloc memory allocator.])
4775   AC_SUBST([MIMALLOC_HEADERS], ['$(MIMALLOC_HEADERS)'])
4776 elif test "$disable_gil" = "yes"; then
4777   AC_MSG_ERROR([--disable-gil requires mimalloc memory allocator (--with-mimalloc).])
4778 fi
4779
4780 AC_MSG_RESULT([$with_mimalloc])
4781 AC_SUBST([WITH_MIMALLOC])
4782 AC_SUBST([MIMALLOC_HEADERS])
4783
4784 # Check for Python-specific malloc support
4785 AC_MSG_CHECKING([for --with-pymalloc])
4786 AC_ARG_WITH(
4787   [pymalloc],
4788   [AS_HELP_STRING([--with-pymalloc], [enable specialized mallocs (default is yes)])])
4789
4790 if test -z "$with_pymalloc"
4791 then
4792   dnl default to yes except for wasm32-emscripten and wasm32-wasi.
4793   AS_CASE([$ac_sys_system],
4794     [Emscripten], [with_pymalloc="no"],
4795     [WASI], [with_pymalloc="no"],
4796     [with_pymalloc="yes"]
4797   )
4798 fi
4799 if test "$with_pymalloc" != "no"
4800 then
4801     AC_DEFINE([WITH_PYMALLOC], [1],
4802      [Define if you want to compile in Python-specific mallocs])
4803 fi
4804 AC_MSG_RESULT([$with_pymalloc])
4805
4806 # Check whether objects such as float, tuple and dict are using
4807 # freelists to optimization memory allocation.
4808 AC_MSG_CHECKING([for --with-freelists])
4809 AC_ARG_WITH(
4810   [freelists],
4811   [AS_HELP_STRING([--with-freelists], [enable object freelists (default is yes)])])
4812
4813 if test -z "$with_freelists"
4814 then
4815     with_freelists="yes"
4816 fi
4817 if test "$with_freelists" != "no"
4818 then
4819     AC_DEFINE([WITH_FREELISTS], [1],
4820      [Define if you want to compile in object freelists optimization])
4821 fi
4822 AC_MSG_RESULT([$with_freelists])
4823
4824 # Check for --with-c-locale-coercion
4825 AC_MSG_CHECKING([for --with-c-locale-coercion])
4826 AC_ARG_WITH(
4827   [c-locale-coercion],
4828   [AS_HELP_STRING([--with-c-locale-coercion], [enable C locale coercion to a UTF-8 based locale (default is yes)])])
4829
4830 if test -z "$with_c_locale_coercion"
4831 then
4832     with_c_locale_coercion="yes"
4833 fi
4834 if test "$with_c_locale_coercion" != "no"
4835 then
4836     AC_DEFINE([PY_COERCE_C_LOCALE], [1],
4837       [Define if you want to coerce the C locale to a UTF-8 based locale])
4838 fi
4839 AC_MSG_RESULT([$with_c_locale_coercion])
4840
4841 # Check for Valgrind support
4842 AC_MSG_CHECKING([for --with-valgrind])
4843 AC_ARG_WITH(
4844   [valgrind],
4845   [AS_HELP_STRING([--with-valgrind], [enable Valgrind support (default is no)])],
4846   [], [with_valgrind=no]
4847 )
4848 AC_MSG_RESULT([$with_valgrind])
4849 if test "$with_valgrind" != no; then
4850     AC_CHECK_HEADER([valgrind/valgrind.h],
4851       [AC_DEFINE([WITH_VALGRIND], 1, [Define if you want pymalloc to be disabled when running under valgrind])],
4852       [AC_MSG_ERROR([Valgrind support requested but headers not available])]
4853     )
4854     OPT="-DDYNAMIC_ANNOTATIONS_ENABLED=1 $OPT"
4855 fi
4856
4857 # Check for DTrace support
4858 AC_MSG_CHECKING([for --with-dtrace])
4859 AC_ARG_WITH(
4860   [dtrace],
4861   [AS_HELP_STRING([--with-dtrace], [enable DTrace support (default is no)])],
4862   [], [with_dtrace=no])
4863 AC_MSG_RESULT([$with_dtrace])
4864
4865 AC_SUBST([DTRACE])
4866 AC_SUBST([DFLAGS])
4867 AC_SUBST([DTRACE_HEADERS])
4868 AC_SUBST([DTRACE_OBJS])
4869 DTRACE=
4870 DTRACE_HEADERS=
4871 DTRACE_OBJS=
4872
4873 if test "$with_dtrace" = "yes"
4874 then
4875     AC_PATH_PROG([DTRACE], [dtrace], [not found])
4876     if test "$DTRACE" = "not found"; then
4877         AC_MSG_ERROR([dtrace command not found on \$PATH])
4878     fi
4879     AC_DEFINE([WITH_DTRACE], [1],
4880               [Define if you want to compile in DTrace support])
4881     DTRACE_HEADERS="Include/pydtrace_probes.h"
4882
4883     # On OS X, DTrace providers do not need to be explicitly compiled and
4884     # linked into the binary. Correspondingly, dtrace(1) is missing the ELF
4885     # generation flag '-G'. We check for presence of this flag, rather than
4886     # hardcoding support by OS, in the interest of robustness.
4887     AC_CACHE_CHECK([whether DTrace probes require linking],
4888         [ac_cv_dtrace_link], [dnl
4889             ac_cv_dtrace_link=no
4890             echo 'BEGIN{}' > conftest.d
4891             "$DTRACE" $DFLAGS -G -s conftest.d -o conftest.o > /dev/null 2>&1 && \
4892                 ac_cv_dtrace_link=yes
4893       ])
4894     if test "$ac_cv_dtrace_link" = "yes"; then
4895         DTRACE_OBJS="Python/pydtrace.o"
4896     fi
4897 fi
4898
4899 dnl Platform-specific C and header files.
4900 PLATFORM_HEADERS=
4901 PLATFORM_OBJS=
4902
4903 AS_CASE([$ac_sys_system],
4904   [Emscripten], [
4905     AS_VAR_APPEND([PLATFORM_OBJS], [' Python/emscripten_signal.o Python/emscripten_trampoline.o'])
4906     AS_VAR_APPEND([PLATFORM_HEADERS], [' $(srcdir)/Include/internal/pycore_emscripten_signal.h $(srcdir)/Include/internal/pycore_emscripten_trampoline.h'])
4907   ],
4908 )
4909 AC_SUBST([PLATFORM_HEADERS])
4910 AC_SUBST([PLATFORM_OBJS])
4911
4912 # -I${DLINCLDIR} is added to the compile rule for importdl.o
4913 AC_SUBST([DLINCLDIR])
4914 DLINCLDIR=.
4915
4916 # the dlopen() function means we might want to use dynload_shlib.o. some
4917 # platforms have dlopen(), but don't want to use it.
4918 AC_CHECK_FUNCS([dlopen])
4919
4920 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
4921 # loading of modules.
4922 AC_SUBST([DYNLOADFILE])
4923 AC_MSG_CHECKING([DYNLOADFILE])
4924 if test -z "$DYNLOADFILE"
4925 then
4926         case $ac_sys_system/$ac_sys_release in
4927         hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
4928         *)
4929         # use dynload_shlib.c and dlopen() if we have it; otherwise stub
4930         # out any dynamic loading
4931         if test "$ac_cv_func_dlopen" = yes
4932         then DYNLOADFILE="dynload_shlib.o"
4933         else DYNLOADFILE="dynload_stub.o"
4934         fi
4935         ;;
4936         esac
4937 fi
4938 AC_MSG_RESULT([$DYNLOADFILE])
4939 if test "$DYNLOADFILE" != "dynload_stub.o"
4940 then
4941         AC_DEFINE([HAVE_DYNAMIC_LOADING], [1],
4942         [Defined when any dynamic module loading is enabled.])
4943 fi
4944
4945 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
4946
4947 AC_SUBST([MACHDEP_OBJS])
4948 AC_MSG_CHECKING([MACHDEP_OBJS])
4949 if test -z "$MACHDEP_OBJS"
4950 then
4951         MACHDEP_OBJS=$extra_machdep_objs
4952 else
4953         MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
4954 fi
4955 if test -z "$MACHDEP_OBJS"; then
4956   AC_MSG_RESULT([none])
4957 else
4958   AC_MSG_RESULT([$MACHDEP_OBJS])
4959 fi
4960
4961 if test "$ac_sys_system" = "Linux-android"; then
4962   # When these functions are used in an unprivileged process, they crash rather
4963   # than returning an error.
4964   blocked_funcs="chroot initgroups setegid seteuid setgid sethostname
4965     setregid setresgid setresuid setreuid setuid"
4966
4967   # These functions are unimplemented and always return an error
4968   # (https://android.googlesource.com/platform/system/sepolicy/+/refs/heads/android13-release/public/domain.te#1044)
4969   blocked_funcs="$blocked_funcs sem_open sem_unlink"
4970
4971   # Before API level 23, when fchmodat is called with the unimplemented flag
4972   # AT_SYMLINK_NOFOLLOW, instead of returning ENOTSUP as it should, it actually
4973   # follows the symlink.
4974   if test "$ANDROID_API_LEVEL" -lt 23; then
4975     blocked_funcs="$blocked_funcs fchmodat"
4976   fi
4977
4978   for name in $blocked_funcs; do
4979     AS_VAR_PUSHDEF([func_var], [ac_cv_func_$name])
4980     AS_VAR_SET([func_var], [no])
4981     AS_VAR_POPDEF([func_var])
4982   done
4983 fi
4984
4985 # checks for library functions
4986 AC_CHECK_FUNCS([ \
4987   accept4 alarm bind_textdomain_codeset chmod chown clock closefrom close_range confstr \
4988   copy_file_range ctermid dup dup3 execv explicit_bzero explicit_memset \
4989   faccessat fchmod fchmodat fchown fchownat fdopendir fdwalk fexecve \
4990   fork fork1 fpathconf fstatat ftime ftruncate futimens futimes futimesat \
4991   gai_strerror getegid geteuid getgid getgrent getgrgid getgrgid_r \
4992   getgrnam_r getgrouplist gethostname getitimer getloadavg getlogin \
4993   getpeername getpgid getpid getppid getpriority _getpty \
4994   getpwent getpwnam_r getpwuid getpwuid_r getresgid getresuid getrusage getsid getspent \
4995   getspnam getuid getwd grantpt if_nameindex initgroups kill killpg lchown linkat \
4996   lockf lstat lutimes madvise mbrtowc memrchr mkdirat mkfifo mkfifoat \
4997   mknod mknodat mktime mmap mremap nice openat opendir pathconf pause pipe \
4998   pipe2 plock poll posix_fadvise posix_fallocate posix_openpt posix_spawn posix_spawnp \
4999   posix_spawn_file_actions_addclosefrom_np \
5000   pread preadv preadv2 process_vm_readv pthread_cond_timedwait_relative_np pthread_condattr_setclock pthread_init \
5001   pthread_kill ptsname ptsname_r pwrite pwritev pwritev2 readlink readlinkat readv realpath renameat \
5002   rtpSpawn sched_get_priority_max sched_rr_get_interval sched_setaffinity \
5003   sched_setparam sched_setscheduler sem_clockwait sem_getvalue sem_open \
5004   sem_timedwait sem_unlink sendfile setegid seteuid setgid sethostname \
5005   setitimer setlocale setpgid setpgrp setpriority setregid setresgid \
5006   setresuid setreuid setsid setuid setvbuf shutdown sigaction sigaltstack \
5007   sigfillset siginterrupt sigpending sigrelse sigtimedwait sigwait \
5008   sigwaitinfo snprintf splice strftime strlcpy strsignal symlinkat sync \
5009   sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile \
5010   tmpnam tmpnam_r truncate ttyname umask uname unlinkat unlockpt utimensat utimes vfork \
5011   wait wait3 wait4 waitid waitpid wcscoll wcsftime wcsxfrm wmemcmp writev \
5012 ])
5013
5014 # Force lchmod off for Linux. Linux disallows changing the mode of symbolic
5015 # links. Some libc implementations have a stub lchmod implementation that always
5016 # returns an error.
5017 if test "$MACHDEP" != linux; then
5018   AC_CHECK_FUNCS([lchmod])
5019 fi
5020
5021 # iOS defines some system methods that can be linked (so they are
5022 # found by configure), but either raise a compilation error (because the
5023 # header definition prevents usage - autoconf doesn't use the headers), or
5024 # raise an error if used at runtime. Force these symbols off.
5025 if test "$ac_sys_system" != "iOS" ; then
5026   AC_CHECK_FUNCS([getentropy getgroups system])
5027 fi
5028
5029 AC_CHECK_DECL([dirfd],
5030               [AC_DEFINE([HAVE_DIRFD], [1],
5031                          [Define if you have the 'dirfd' function or macro.])],
5032               [],
5033               [@%:@include <sys/types.h>
5034                @%:@include <dirent.h>])
5035
5036 # For some functions, having a definition is not sufficient, since
5037 # we want to take their address.
5038 PY_CHECK_FUNC([chroot], [@%:@include <unistd.h>])
5039 PY_CHECK_FUNC([link], [@%:@include <unistd.h>])
5040 PY_CHECK_FUNC([symlink], [@%:@include <unistd.h>])
5041 PY_CHECK_FUNC([fchdir], [@%:@include <unistd.h>])
5042 PY_CHECK_FUNC([fsync], [@%:@include <unistd.h>])
5043 PY_CHECK_FUNC([fdatasync], [@%:@include <unistd.h>])
5044 PY_CHECK_FUNC([epoll_create], [@%:@include <sys/epoll.h>], [HAVE_EPOLL])
5045 PY_CHECK_FUNC([epoll_create1], [@%:@include <sys/epoll.h>])
5046 PY_CHECK_FUNC([kqueue],[
5047 #include <sys/types.h>
5048 #include <sys/event.h>
5049 ])
5050 PY_CHECK_FUNC([prlimit], [
5051 #include <sys/time.h>
5052 #include <sys/resource.h>
5053 ])
5054
5055 PY_CHECK_FUNC([_dyld_shared_cache_contains_path], [@%:@include <mach-o/dyld.h>], [HAVE_DYLD_SHARED_CACHE_CONTAINS_PATH])
5056
5057 PY_CHECK_FUNC([memfd_create], [
5058 #ifdef HAVE_SYS_MMAN_H
5059 #include <sys/mman.h>
5060 #endif
5061 #ifdef HAVE_SYS_MEMFD_H
5062 #include <sys/memfd.h>
5063 #endif
5064 ])
5065
5066 PY_CHECK_FUNC([eventfd], [
5067 #ifdef HAVE_SYS_EVENTFD_H
5068 #include <sys/eventfd.h>
5069 #endif
5070 ])
5071
5072 PY_CHECK_FUNC([timerfd_create], [
5073 #ifdef HAVE_SYS_TIMERFD_H
5074 #include <sys/timerfd.h>
5075 #endif
5076 ],
5077 [HAVE_TIMERFD_CREATE])
5078
5079 # On some systems (eg. FreeBSD 5), we would find a definition of the
5080 # functions ctermid_r, setgroups in the library, but no prototype
5081 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
5082 # address to avoid compiler warnings and potential miscompilations
5083 # because of the missing prototypes.
5084
5085 PY_CHECK_FUNC([ctermid_r], [@%:@include <stdio.h>])
5086
5087 AC_CACHE_CHECK([for flock declaration], [ac_cv_flock_decl],
5088   [AC_COMPILE_IFELSE(
5089     [AC_LANG_PROGRAM(
5090       [@%:@include <sys/file.h>],
5091       [void* p = flock]
5092     )],
5093     [ac_cv_flock_decl=yes],
5094     [ac_cv_flock_decl=no]
5095   )
5096 ])
5097 dnl Linking with libbsd may be necessary on AIX for flock function.
5098 AS_VAR_IF([ac_cv_flock_decl], [yes],
5099   [AC_CHECK_FUNCS([flock], [],
5100     [AC_CHECK_LIB([bsd], [flock], [FCNTL_LIBS="-lbsd"])])])
5101
5102 PY_CHECK_FUNC([getpagesize], [@%:@include <unistd.h>])
5103
5104 AC_CACHE_CHECK([for broken unsetenv], [ac_cv_broken_unsetenv],
5105   [AC_COMPILE_IFELSE(
5106     [AC_LANG_PROGRAM(
5107       [@%:@include <stdlib.h>],
5108       [int res = unsetenv("DUMMY")])],
5109     [ac_cv_broken_unsetenv=no],
5110     [ac_cv_broken_unsetenv=yes]
5111   )
5112 ])
5113 AS_VAR_IF([ac_cv_broken_unsetenv], [yes], [
5114   AC_DEFINE([HAVE_BROKEN_UNSETENV], [1],
5115             [Define if 'unsetenv' does not return an int.])
5116 ])
5117
5118 dnl check for true
5119 AC_CHECK_PROGS([TRUE], [true], [/bin/true])
5120
5121 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
5122 dnl On others, they are in the C library, so we to take no action
5123 AC_CHECK_LIB([c], [inet_aton], [$ac_cv_prog_TRUE],
5124   AC_CHECK_LIB([resolv], [inet_aton])
5125 )
5126
5127 # On Tru64, chflags seems to be present, but calling it will
5128 # exit Python
5129 AC_CACHE_CHECK([for chflags], [ac_cv_have_chflags], [dnl
5130 AC_RUN_IFELSE([AC_LANG_SOURCE([[
5131 #include <sys/stat.h>
5132 #include <unistd.h>
5133 int main(int argc, char *argv[])
5134 {
5135   if(chflags(argv[0], 0) != 0)
5136     return 1;
5137   return 0;
5138 }
5139 ]])],
5140 [ac_cv_have_chflags=yes],
5141 [ac_cv_have_chflags=no],
5142 [ac_cv_have_chflags=cross])
5143 ])
5144 if test "$ac_cv_have_chflags" = cross ; then
5145   AC_CHECK_FUNC([chflags], [ac_cv_have_chflags="yes"], [ac_cv_have_chflags="no"])
5146 fi
5147 if test "$ac_cv_have_chflags" = yes ; then
5148   AC_DEFINE([HAVE_CHFLAGS], [1],
5149             [Define to 1 if you have the 'chflags' function.])
5150 fi
5151
5152 AC_CACHE_CHECK([for lchflags], [ac_cv_have_lchflags], [dnl
5153 AC_RUN_IFELSE([AC_LANG_SOURCE([[
5154 #include <sys/stat.h>
5155 #include <unistd.h>
5156 int main(int argc, char *argv[])
5157 {
5158   if(lchflags(argv[0], 0) != 0)
5159     return 1;
5160   return 0;
5161 }
5162 ]])],[ac_cv_have_lchflags=yes],[ac_cv_have_lchflags=no],[ac_cv_have_lchflags=cross])
5163 ])
5164 if test "$ac_cv_have_lchflags" = cross ; then
5165   AC_CHECK_FUNC([lchflags], [ac_cv_have_lchflags="yes"], [ac_cv_have_lchflags="no"])
5166 fi
5167 if test "$ac_cv_have_lchflags" = yes ; then
5168   AC_DEFINE([HAVE_LCHFLAGS], [1],
5169             [Define to 1 if you have the 'lchflags' function.])
5170 fi
5171
5172 dnl Check for compression libraries
5173 AH_TEMPLATE([HAVE_ZLIB_COPY], [Define if the zlib library has inflateCopy])
5174
5175 dnl detect zlib from Emscripten emport
5176 PY_CHECK_EMSCRIPTEN_PORT([ZLIB], [-sUSE_ZLIB])
5177
5178 PKG_CHECK_MODULES([ZLIB], [zlib >= 1.2.0], [
5179   have_zlib=yes
5180   dnl zlib 1.2.0 (2003) added inflateCopy
5181   AC_DEFINE([HAVE_ZLIB_COPY], [1])
5182 ], [
5183   WITH_SAVE_ENV([
5184     CPPFLAGS="$CPPFLAGS $ZLIB_CFLAGS"
5185     LDFLAGS="$LDFLAGS $ZLIB_LIBS"
5186     AC_CHECK_HEADERS([zlib.h], [
5187       PY_CHECK_LIB([z], [gzread], [have_zlib=yes], [have_zlib=no])
5188     ], [have_zlib=no])
5189     AS_VAR_IF([have_zlib], [yes], [
5190       ZLIB_CFLAGS=${ZLIB_CFLAGS-""}
5191       ZLIB_LIBS=${ZLIB_LIBS-"-lz"}
5192       PY_CHECK_LIB([z], [inflateCopy], [AC_DEFINE([HAVE_ZLIB_COPY], [1])])
5193     ])
5194   ])
5195 ])
5196
5197 dnl binascii can use zlib for optimized crc32.
5198 AS_VAR_IF([have_zlib], [yes], [
5199   BINASCII_CFLAGS="-DUSE_ZLIB_CRC32 $ZLIB_CFLAGS"
5200   BINASCII_LIBS="$ZLIB_LIBS"
5201 ])
5202
5203 dnl detect bzip2 from Emscripten emport
5204 PY_CHECK_EMSCRIPTEN_PORT([BZIP2], [-sUSE_BZIP2])
5205
5206 PKG_CHECK_MODULES([BZIP2], [bzip2], [have_bzip2=yes], [
5207   WITH_SAVE_ENV([
5208     CPPFLAGS="$CPPFLAGS $BZIP2_CFLAGS"
5209     LDFLAGS="$LDFLAGS $BZIP2_LIBS"
5210     AC_CHECK_HEADERS([bzlib.h], [
5211       AC_CHECK_LIB([bz2], [BZ2_bzCompress], [have_bzip2=yes], [have_bzip2=no])
5212     ], [have_bzip2=no])
5213     AS_VAR_IF([have_bzip2], [yes], [
5214       BZIP2_CFLAGS=${BZIP2_CFLAGS-""}
5215       BZIP2_LIBS=${BZIP2_LIBS-"-lbz2"}
5216     ])
5217   ])
5218 ])
5219
5220 PKG_CHECK_MODULES([LIBLZMA], [liblzma], [have_liblzma=yes], [
5221   WITH_SAVE_ENV([
5222     CPPFLAGS="$CPPFLAGS $LIBLZMA_CFLAGS"
5223     LDFLAGS="$LDFLAGS $LIBLZMA_LIBS"
5224     AC_CHECK_HEADERS([lzma.h], [
5225       AC_CHECK_LIB([lzma], [lzma_easy_encoder], [have_liblzma=yes], [have_liblzma=no])
5226     ], [have_liblzma=no])
5227     AS_VAR_IF([have_liblzma], [yes], [
5228       LIBLZMA_CFLAGS=${LIBLZMA_CFLAGS-""}
5229       LIBLZMA_LIBS=${LIBLZMA_LIBS-"-llzma"}
5230     ])
5231   ])
5232 ])
5233
5234 dnl PY_CHECK_NETDB_FUNC(FUNCTION)
5235 AC_DEFUN([PY_CHECK_NETDB_FUNC], [PY_CHECK_FUNC([$1], [@%:@include <netdb.h>])])
5236
5237 PY_CHECK_NETDB_FUNC([hstrerror])
5238 dnl not available in WASI yet
5239 PY_CHECK_NETDB_FUNC([getservbyname])
5240 PY_CHECK_NETDB_FUNC([getservbyport])
5241 PY_CHECK_NETDB_FUNC([gethostbyname])
5242 PY_CHECK_NETDB_FUNC([gethostbyaddr])
5243 PY_CHECK_NETDB_FUNC([getprotobyname])
5244
5245 dnl PY_CHECK_SOCKET_FUNC(FUNCTION)
5246 AC_DEFUN([PY_CHECK_SOCKET_FUNC], [PY_CHECK_FUNC([$1], [
5247 #include <sys/types.h>
5248 #include <sys/socket.h>
5249 #include <netinet/in.h>
5250 #include <arpa/inet.h>
5251 ])])
5252
5253 PY_CHECK_SOCKET_FUNC([inet_aton])
5254 PY_CHECK_SOCKET_FUNC([inet_ntoa])
5255 PY_CHECK_SOCKET_FUNC([inet_pton])
5256 dnl not available in WASI yet
5257 PY_CHECK_SOCKET_FUNC([getpeername])
5258 PY_CHECK_SOCKET_FUNC([getsockname])
5259 PY_CHECK_SOCKET_FUNC([accept])
5260 PY_CHECK_SOCKET_FUNC([bind])
5261 PY_CHECK_SOCKET_FUNC([connect])
5262 PY_CHECK_SOCKET_FUNC([listen])
5263 PY_CHECK_SOCKET_FUNC([recvfrom])
5264 PY_CHECK_SOCKET_FUNC([sendto])
5265 PY_CHECK_SOCKET_FUNC([setsockopt])
5266 PY_CHECK_SOCKET_FUNC([socket])
5267
5268 # On some systems, setgroups is in unistd.h, on others, in grp.h
5269 PY_CHECK_FUNC([setgroups], [
5270 #include <unistd.h>
5271 #ifdef HAVE_GRP_H
5272 #include <grp.h>
5273 #endif
5274 ])
5275
5276 # check for openpty, login_tty, and forkpty
5277
5278 AC_CHECK_FUNCS([openpty], [],
5279   [AC_CHECK_LIB([util], [openpty],
5280     [AC_DEFINE([HAVE_OPENPTY]) LIBS="$LIBS -lutil"],
5281     [AC_CHECK_LIB([bsd], [openpty],
5282       [AC_DEFINE([HAVE_OPENPTY]) LIBS="$LIBS -lbsd"])])])
5283 AC_SEARCH_LIBS([login_tty], [util],
5284  [AC_DEFINE([HAVE_LOGIN_TTY], [1], [Define to 1 if you have the `login_tty' function.])]
5285 )
5286 AC_CHECK_FUNCS([forkpty], [],
5287   [AC_CHECK_LIB([util], [forkpty],
5288     [AC_DEFINE([HAVE_FORKPTY]) LIBS="$LIBS -lutil"],
5289     [AC_CHECK_LIB([bsd], [forkpty],
5290       [AC_DEFINE([HAVE_FORKPTY]) LIBS="$LIBS -lbsd"])])])
5291
5292 # check for long file support functions
5293 AC_CHECK_FUNCS([fseek64 fseeko fstatvfs ftell64 ftello statvfs])
5294
5295 AC_REPLACE_FUNCS([dup2])
5296 AC_CHECK_FUNCS([getpgrp],
5297   [AC_COMPILE_IFELSE(
5298     [AC_LANG_PROGRAM([@%:@include <unistd.h>],
5299       [getpgrp(0);])],
5300     [AC_DEFINE([GETPGRP_HAVE_ARG], [1],
5301       [Define if getpgrp() must be called as getpgrp(0).])],
5302     [])])
5303 AC_CHECK_FUNCS([setpgrp],
5304   [AC_COMPILE_IFELSE(
5305     [AC_LANG_PROGRAM([@%:@include <unistd.h>],
5306       [setpgrp(0,0);])],
5307     [AC_DEFINE([SETPGRP_HAVE_ARG], [1],
5308       [Define if setpgrp() must be called as setpgrp(0, 0).])],
5309   [])])
5310
5311 # check for namespace functions
5312 AC_CHECK_FUNCS([setns unshare])
5313
5314 AC_CHECK_FUNCS([clock_gettime], [], [
5315     AC_CHECK_LIB([rt], [clock_gettime], [
5316         LIBS="$LIBS -lrt"
5317         AC_DEFINE([HAVE_CLOCK_GETTIME], [1])
5318         AC_DEFINE([TIMEMODULE_LIB], [rt],
5319                   [Library needed by timemodule.c: librt may be needed for clock_gettime()])
5320     ])
5321 ])
5322
5323 AC_CHECK_FUNCS([clock_getres], [], [
5324     AC_CHECK_LIB([rt], [clock_getres], [
5325         AC_DEFINE([HAVE_CLOCK_GETRES], [1])
5326     ])
5327 ])
5328
5329 # On Android and iOS, clock_settime can be linked (so it is found by
5330 # configure), but when used in an unprivileged process, it crashes rather than
5331 # returning an error. Force the symbol off.
5332 if test "$ac_sys_system" != "Linux-android" && test "$ac_sys_system" != "iOS"
5333 then
5334   AC_CHECK_FUNCS([clock_settime], [], [
5335       AC_CHECK_LIB([rt], [clock_settime], [
5336           AC_DEFINE([HAVE_CLOCK_SETTIME], [1])
5337       ])
5338   ])
5339 fi
5340
5341 # On Android before API level 23, clock_nanosleep returns the wrong value when
5342 # interrupted by a signal (https://issuetracker.google.com/issues/216495770).
5343 if ! { test "$ac_sys_system" = "Linux-android" &&
5344        test "$ANDROID_API_LEVEL" -lt 23; }; then
5345   AC_CHECK_FUNCS([clock_nanosleep], [], [
5346       AC_CHECK_LIB([rt], [clock_nanosleep], [
5347           AC_DEFINE([HAVE_CLOCK_NANOSLEEP], [1])
5348       ])
5349   ])
5350 fi
5351
5352 AC_CHECK_FUNCS([nanosleep], [], [
5353     AC_CHECK_LIB([rt], [nanosleep], [
5354         AC_DEFINE([HAVE_NANOSLEEP], [1])
5355     ])
5356 ])
5357
5358 AC_CACHE_CHECK([for major, minor, and makedev], [ac_cv_device_macros], [
5359 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
5360 #if defined(MAJOR_IN_MKDEV)
5361 #include <sys/mkdev.h>
5362 #elif defined(MAJOR_IN_SYSMACROS)
5363 #include <sys/types.h>
5364 #include <sys/sysmacros.h>
5365 #else
5366 #include <sys/types.h>
5367 #endif
5368 ]], [[
5369   makedev(major(0),minor(0));
5370 ]])],[ac_cv_device_macros=yes], [ac_cv_device_macros=no])
5371 ])
5372 AS_VAR_IF([ac_cv_device_macros], [yes], [
5373   AC_DEFINE([HAVE_DEVICE_MACROS], [1],
5374             [Define to 1 if you have the device macros.])
5375 ])
5376
5377 dnl no longer used, now always defined for backwards compatibility
5378 AC_DEFINE([SYS_SELECT_WITH_SYS_TIME], [1],
5379   [Define if  you can safely include both <sys/select.h> and <sys/time.h>
5380    (which you can't on SCO ODT 3.0).])
5381
5382 # On OSF/1 V5.1, getaddrinfo is available, but a define
5383 # for [no]getaddrinfo in netdb.h.
5384 AC_CACHE_CHECK([for getaddrinfo], [ac_cv_func_getaddrinfo], [
5385 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
5386 #include <sys/types.h>
5387 #include <sys/socket.h>
5388 #include <netdb.h>
5389 #include <stdio.h>
5390 ]], [[getaddrinfo(NULL, NULL, NULL, NULL);]])],
5391 [ac_cv_func_getaddrinfo=yes],
5392 [ac_cv_func_getaddrinfo=no])
5393 ])
5394
5395 AS_VAR_IF([ac_cv_func_getaddrinfo], [yes], [
5396   AC_CACHE_CHECK([getaddrinfo bug], [ac_cv_buggy_getaddrinfo],
5397   AC_RUN_IFELSE([AC_LANG_SOURCE([[[
5398 #include <stdio.h>
5399 #include <sys/types.h>
5400 #include <netdb.h>
5401 #include <string.h>
5402 #include <sys/socket.h>
5403 #include <netinet/in.h>
5404
5405 int main(void)
5406 {
5407   int passive, gaierr, inet4 = 0, inet6 = 0;
5408   struct addrinfo hints, *ai, *aitop;
5409   char straddr[INET6_ADDRSTRLEN], strport[16];
5410
5411   for (passive = 0; passive <= 1; passive++) {
5412     memset(&hints, 0, sizeof(hints));
5413     hints.ai_family = AF_UNSPEC;
5414     hints.ai_flags = passive ? AI_PASSIVE : 0;
5415     hints.ai_socktype = SOCK_STREAM;
5416     hints.ai_protocol = IPPROTO_TCP;
5417     if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
5418       (void)gai_strerror(gaierr);
5419       goto bad;
5420     }
5421     for (ai = aitop; ai; ai = ai->ai_next) {
5422       if (ai->ai_addr == NULL ||
5423           ai->ai_addrlen == 0 ||
5424           getnameinfo(ai->ai_addr, ai->ai_addrlen,
5425                       straddr, sizeof(straddr), strport, sizeof(strport),
5426                       NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
5427         goto bad;
5428       }
5429       switch (ai->ai_family) {
5430       case AF_INET:
5431         if (strcmp(strport, "54321") != 0) {
5432           goto bad;
5433         }
5434         if (passive) {
5435           if (strcmp(straddr, "0.0.0.0") != 0) {
5436             goto bad;
5437           }
5438         } else {
5439           if (strcmp(straddr, "127.0.0.1") != 0) {
5440             goto bad;
5441           }
5442         }
5443         inet4++;
5444         break;
5445       case AF_INET6:
5446         if (strcmp(strport, "54321") != 0) {
5447           goto bad;
5448         }
5449         if (passive) {
5450           if (strcmp(straddr, "::") != 0) {
5451             goto bad;
5452           }
5453         } else {
5454           if (strcmp(straddr, "::1") != 0) {
5455             goto bad;
5456           }
5457         }
5458         inet6++;
5459         break;
5460       case AF_UNSPEC:
5461         goto bad;
5462         break;
5463       default:
5464         /* another family support? */
5465         break;
5466       }
5467     }
5468     freeaddrinfo(aitop);
5469     aitop = NULL;
5470   }
5471
5472   if (!(inet4 == 0 || inet4 == 2))
5473     goto bad;
5474   if (!(inet6 == 0 || inet6 == 2))
5475     goto bad;
5476
5477   if (aitop)
5478     freeaddrinfo(aitop);
5479   return 0;
5480
5481  bad:
5482   if (aitop)
5483     freeaddrinfo(aitop);
5484   return 1;
5485 }
5486 ]]])],
5487 [ac_cv_buggy_getaddrinfo=no],
5488 [ac_cv_buggy_getaddrinfo=yes],
5489 [
5490 if test "$ac_sys_system" = "Linux-android" || test "$ac_sys_system" = "iOS"; then
5491   ac_cv_buggy_getaddrinfo="no"
5492 elif test "${enable_ipv6+set}" = set; then
5493   ac_cv_buggy_getaddrinfo="no -- configured with --(en|dis)able-ipv6"
5494 else
5495   ac_cv_buggy_getaddrinfo=yes
5496 fi]))
5497
5498 dnl if ac_cv_func_getaddrinfo
5499 ])
5500
5501 if test "$ac_cv_func_getaddrinfo" = no -o "$ac_cv_buggy_getaddrinfo" = yes
5502 then
5503   AS_VAR_IF([ipv6], [yes], [
5504     AC_MSG_ERROR([m4_normalize([
5505       You must get working getaddrinfo() function
5506       or pass the "--disable-ipv6" option to configure.
5507     ])])
5508   ])
5509 else
5510         AC_DEFINE([HAVE_GETADDRINFO], [1],
5511       [Define if you have the getaddrinfo function.])
5512 fi
5513
5514 AC_CHECK_FUNCS([getnameinfo])
5515
5516 # checks for structures
5517 AC_STRUCT_TM
5518 AC_STRUCT_TIMEZONE
5519 AC_CHECK_MEMBERS([struct stat.st_rdev])
5520 AC_CHECK_MEMBERS([struct stat.st_blksize])
5521 AC_CHECK_MEMBERS([struct stat.st_flags])
5522 AC_CHECK_MEMBERS([struct stat.st_gen])
5523 AC_CHECK_MEMBERS([struct stat.st_birthtime])
5524 AC_CHECK_MEMBERS([struct stat.st_blocks])
5525 AC_CHECK_MEMBERS([struct passwd.pw_gecos, struct passwd.pw_passwd], [], [], [[
5526   #include <sys/types.h>
5527   #include <pwd.h>
5528 ]])
5529 # Issue #21085: In Cygwin, siginfo_t does not have si_band field.
5530 AC_CHECK_MEMBERS([siginfo_t.si_band], [], [], [[@%:@include <signal.h>]])
5531
5532 AC_CACHE_CHECK([for time.h that defines altzone], [ac_cv_header_time_altzone], [
5533   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <time.h>]], [[return altzone;]])],
5534     [ac_cv_header_time_altzone=yes],
5535     [ac_cv_header_time_altzone=no])
5536   ])
5537 if test $ac_cv_header_time_altzone = yes; then
5538   AC_DEFINE([HAVE_ALTZONE], [1],
5539     [Define this if your time.h defines altzone.])
5540 fi
5541
5542 AC_CACHE_CHECK([for addrinfo], [ac_cv_struct_addrinfo],
5543 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <netdb.h>]], [[struct addrinfo a]])],
5544   [ac_cv_struct_addrinfo=yes],
5545   [ac_cv_struct_addrinfo=no]))
5546 if test $ac_cv_struct_addrinfo = yes; then
5547         AC_DEFINE([HAVE_ADDRINFO], [1], [struct addrinfo (netdb.h)])
5548 fi
5549
5550 AC_CACHE_CHECK([for sockaddr_storage], [ac_cv_struct_sockaddr_storage],
5551 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
5552 #               include <sys/types.h>
5553 @%:@            include <sys/socket.h>]], [[struct sockaddr_storage s]])],
5554   [ac_cv_struct_sockaddr_storage=yes],
5555   [ac_cv_struct_sockaddr_storage=no]))
5556 if test $ac_cv_struct_sockaddr_storage = yes; then
5557         AC_DEFINE([HAVE_SOCKADDR_STORAGE], [1],
5558       [struct sockaddr_storage (sys/socket.h)])
5559 fi
5560
5561 AC_CACHE_CHECK([for sockaddr_alg], [ac_cv_struct_sockaddr_alg],
5562 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
5563 #               include <sys/types.h>
5564 #               include <sys/socket.h>
5565 @%:@            include <linux/if_alg.h>]], [[struct sockaddr_alg s]])],
5566   [ac_cv_struct_sockaddr_alg=yes],
5567   [ac_cv_struct_sockaddr_alg=no]))
5568 if test $ac_cv_struct_sockaddr_alg = yes; then
5569         AC_DEFINE([HAVE_SOCKADDR_ALG], [1],
5570       [struct sockaddr_alg (linux/if_alg.h)])
5571 fi
5572
5573 # checks for compiler characteristics
5574
5575 AC_C_CONST
5576
5577 AC_CACHE_CHECK([for working signed char], [ac_cv_working_signed_char_c], [
5578 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[signed char c;]])],
5579   [ac_cv_working_signed_char_c=yes], [ac_cv_working_signed_char_c=no])
5580 ])
5581 AS_VAR_IF([ac_cv_working_signed_char_c], [no], [
5582   AC_DEFINE([signed], [], [Define to empty if the keyword does not work.])
5583 ])
5584
5585 AC_CACHE_CHECK([for prototypes], [ac_cv_function_prototypes], [
5586 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[int foo(int x) { return 0; }]], [[return foo(10);]])],
5587   [ac_cv_function_prototypes=yes], [ac_cv_function_prototypes=no])
5588 ])
5589 AS_VAR_IF([ac_cv_function_prototypes], [yes], [
5590   AC_DEFINE([HAVE_PROTOTYPES], [1],
5591      [Define if your compiler supports function prototype])
5592 ])
5593
5594
5595 # check for socketpair
5596 PY_CHECK_FUNC([socketpair], [
5597 #include <sys/types.h>
5598 #include <sys/socket.h>
5599 ])
5600
5601 # check if sockaddr has sa_len member
5602 AC_CACHE_CHECK([if sockaddr has sa_len member], [ac_cv_struct_sockaddr_sa_len], [
5603 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h>
5604 @%:@include <sys/socket.h>]], [[struct sockaddr x;
5605 x.sa_len = 0;]])],
5606   [ac_cv_struct_sockaddr_sa_len=yes], [ac_cv_struct_sockaddr_sa_len=no])
5607 ])
5608 AS_VAR_IF([ac_cv_struct_sockaddr_sa_len], [yes], [
5609    AC_DEFINE([HAVE_SOCKADDR_SA_LEN], [1],
5610      [Define if sockaddr has sa_len member])
5611 ])
5612
5613 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
5614 AH_TEMPLATE([HAVE_GETHOSTBYNAME_R],
5615   [Define this if you have some version of gethostbyname_r()])
5616
5617 AC_CHECK_FUNC([gethostbyname_r],
5618   [AC_DEFINE([HAVE_GETHOSTBYNAME_R])
5619   AC_MSG_CHECKING([gethostbyname_r with 6 args])
5620   OLD_CFLAGS=$CFLAGS
5621   CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
5622   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
5623 #   include <netdb.h>
5624   ]], [[
5625     char *name;
5626     struct hostent *he, *res;
5627     char buffer[2048];
5628     int buflen = 2048;
5629     int h_errnop;
5630
5631     (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
5632   ]])],[
5633     AC_DEFINE([HAVE_GETHOSTBYNAME_R])
5634     AC_DEFINE([HAVE_GETHOSTBYNAME_R_6_ARG], [1],
5635     [Define this if you have the 6-arg version of gethostbyname_r().])
5636     AC_MSG_RESULT([yes])
5637   ],[
5638     AC_MSG_RESULT([no])
5639     AC_MSG_CHECKING([gethostbyname_r with 5 args])
5640     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
5641 #       include <netdb.h>
5642       ]], [[
5643         char *name;
5644         struct hostent *he;
5645         char buffer[2048];
5646         int buflen = 2048;
5647         int h_errnop;
5648
5649         (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
5650       ]])],
5651       [
5652         AC_DEFINE([HAVE_GETHOSTBYNAME_R])
5653         AC_DEFINE([HAVE_GETHOSTBYNAME_R_5_ARG], [1],
5654           [Define this if you have the 5-arg version of gethostbyname_r().])
5655         AC_MSG_RESULT([yes])
5656       ], [
5657         AC_MSG_RESULT([no])
5658         AC_MSG_CHECKING([gethostbyname_r with 3 args])
5659         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
5660 #           include <netdb.h>
5661           ]], [[
5662             char *name;
5663             struct hostent *he;
5664             struct hostent_data data;
5665
5666             (void) gethostbyname_r(name, he, &data);
5667           ]])],
5668           [
5669             AC_DEFINE([HAVE_GETHOSTBYNAME_R])
5670             AC_DEFINE([HAVE_GETHOSTBYNAME_R_3_ARG], [1],
5671               [Define this if you have the 3-arg version of gethostbyname_r().])
5672             AC_MSG_RESULT([yes])
5673           ], [
5674            AC_MSG_RESULT([no])
5675         ])
5676     ])
5677   ])
5678   CFLAGS=$OLD_CFLAGS
5679 ], [
5680   AC_CHECK_FUNCS([gethostbyname])
5681 ])
5682 AC_SUBST([HAVE_GETHOSTBYNAME_R_6_ARG])
5683 AC_SUBST([HAVE_GETHOSTBYNAME_R_5_ARG])
5684 AC_SUBST([HAVE_GETHOSTBYNAME_R_3_ARG])
5685 AC_SUBST([HAVE_GETHOSTBYNAME_R])
5686 AC_SUBST([HAVE_GETHOSTBYNAME])
5687
5688 # checks for system services
5689 # (none yet)
5690
5691 # Linux requires this for correct f.p. operations
5692 AC_CHECK_FUNC([__fpu_control],
5693   [],
5694   [AC_CHECK_LIB([ieee], [__fpu_control])
5695 ])
5696
5697 # check for --with-libm=...
5698 AC_SUBST([LIBM])
5699 case $ac_sys_system in
5700 Darwin) ;;
5701 *) LIBM=-lm
5702 esac
5703 AC_MSG_CHECKING([for --with-libm=STRING])
5704 AC_ARG_WITH([libm],
5705   [AS_HELP_STRING([--with-libm=STRING], [override libm math library to STRING (default is system-dependent)])],
5706 [
5707 if test "$withval" = no
5708 then LIBM=
5709      AC_MSG_RESULT([force LIBM empty])
5710 elif test "$withval" != yes
5711 then LIBM=$withval
5712      AC_MSG_RESULT([set LIBM="$withval"])
5713 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
5714 fi],
5715 [AC_MSG_RESULT([default LIBM="$LIBM"])])
5716
5717 # check for --with-libc=...
5718 AC_SUBST([LIBC])
5719 AC_MSG_CHECKING([for --with-libc=STRING])
5720 AC_ARG_WITH([libc],
5721   [AS_HELP_STRING([--with-libc=STRING], [override libc C library to STRING (default is system-dependent)])],
5722 [
5723 if test "$withval" = no
5724 then LIBC=
5725      AC_MSG_RESULT([force LIBC empty])
5726 elif test "$withval" != yes
5727 then LIBC=$withval
5728      AC_MSG_RESULT([set LIBC="$withval"])
5729 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
5730 fi],
5731 [AC_MSG_RESULT([default LIBC="$LIBC"])])
5732
5733 # **************************************
5734 # * Check for gcc x64 inline assembler *
5735 # **************************************
5736
5737
5738 AC_CACHE_CHECK([for x64 gcc inline assembler], [ac_cv_gcc_asm_for_x64], [
5739 AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[
5740   __asm__ __volatile__ ("movq %rcx, %rax");
5741 ]])],[ac_cv_gcc_asm_for_x64=yes],[ac_cv_gcc_asm_for_x64=no])
5742 ])
5743
5744 AS_VAR_IF([ac_cv_gcc_asm_for_x64], [yes], [
5745     AC_DEFINE([HAVE_GCC_ASM_FOR_X64], [1],
5746     [Define if we can use x64 gcc inline assembler])
5747 ])
5748
5749 # **************************************************
5750 # * Check for various properties of floating point *
5751 # **************************************************
5752
5753 AX_C_FLOAT_WORDS_BIGENDIAN
5754 if test "$ax_cv_c_float_words_bigendian" = "yes"
5755 then
5756   AC_DEFINE([DOUBLE_IS_BIG_ENDIAN_IEEE754], [1],
5757   [Define if C doubles are 64-bit IEEE 754 binary format, stored
5758    with the most significant byte first])
5759 elif test "$ax_cv_c_float_words_bigendian" = "no"
5760 then
5761   AC_DEFINE([DOUBLE_IS_LITTLE_ENDIAN_IEEE754], [1],
5762   [Define if C doubles are 64-bit IEEE 754 binary format, stored
5763    with the least significant byte first])
5764 else
5765   # Some ARM platforms use a mixed-endian representation for doubles.
5766   # While Python doesn't currently have full support for these platforms
5767   # (see e.g., issue 1762561), we can at least make sure that float <-> string
5768   # conversions work.
5769   # FLOAT_WORDS_BIGENDIAN doesnt actually detect this case, but if it's not big
5770   # or little, then it must be this?
5771   AC_DEFINE([DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754], [1],
5772   [Define if C doubles are 64-bit IEEE 754 binary format, stored
5773    in ARM mixed-endian order (byte order 45670123)])
5774 fi
5775
5776 # The short float repr introduced in Python 3.1 requires the
5777 # correctly-rounded string <-> double conversion functions from
5778 # Python/dtoa.c, which in turn require that the FPU uses 53-bit
5779 # rounding; this is a problem on x86, where the x87 FPU has a default
5780 # rounding precision of 64 bits.  For gcc/x86, we can fix this by
5781 # using inline assembler to get and set the x87 FPU control word.
5782
5783 # This inline assembler syntax may also work for suncc and icc,
5784 # so we try it on all platforms.
5785
5786 AC_CACHE_CHECK([whether we can use gcc inline assembler to get and set x87 control word], [ac_cv_gcc_asm_for_x87], [
5787 AC_LINK_IFELSE(   [AC_LANG_PROGRAM([[]], [[
5788   unsigned short cw;
5789   __asm__ __volatile__ ("fnstcw %0" : "=m" (cw));
5790   __asm__ __volatile__ ("fldcw %0" : : "m" (cw));
5791 ]])],[ac_cv_gcc_asm_for_x87=yes],[ac_cv_gcc_asm_for_x87=no])
5792 ])
5793 AS_VAR_IF([ac_cv_gcc_asm_for_x87], [yes], [
5794     AC_DEFINE([HAVE_GCC_ASM_FOR_X87], [1],
5795     [Define if we can use gcc inline assembler to get and set x87 control word])
5796 ])
5797
5798 AC_CACHE_CHECK([whether we can use gcc inline assembler to get and set mc68881 fpcr], [ac_cv_gcc_asm_for_mc68881], [
5799 AC_LINK_IFELSE(   [AC_LANG_PROGRAM([[]], [[
5800   unsigned int fpcr;
5801   __asm__ __volatile__ ("fmove.l %%fpcr,%0" : "=g" (fpcr));
5802   __asm__ __volatile__ ("fmove.l %0,%%fpcr" : : "g" (fpcr));
5803 ]])],[ac_cv_gcc_asm_for_mc68881=yes],[ac_cv_gcc_asm_for_mc68881=no])
5804 ])
5805 AS_VAR_IF([ac_cv_gcc_asm_for_mc68881], [yes], [
5806     AC_DEFINE([HAVE_GCC_ASM_FOR_MC68881], [1],
5807     [Define if we can use gcc inline assembler to get and set mc68881 fpcr])
5808 ])
5809
5810 # Detect whether system arithmetic is subject to x87-style double
5811 # rounding issues.  The result of this test has little meaning on non
5812 # IEEE 754 platforms.  On IEEE 754, test should return 1 if rounding
5813 # mode is round-to-nearest and double rounding issues are present, and
5814 # 0 otherwise.  See https://github.com/python/cpython/issues/47186 for more info.
5815 AC_CACHE_CHECK([for x87-style double rounding], [ac_cv_x87_double_rounding], [
5816 # $BASECFLAGS may affect the result
5817 ac_save_cc="$CC"
5818 CC="$CC $BASECFLAGS"
5819 AC_RUN_IFELSE([AC_LANG_SOURCE([[
5820 #include <stdlib.h>
5821 #include <math.h>
5822 int main(void) {
5823     volatile double x, y, z;
5824     /* 1./(1-2**-53) -> 1+2**-52 (correct), 1.0 (double rounding) */
5825     x = 0.99999999999999989; /* 1-2**-53 */
5826     y = 1./x;
5827     if (y != 1.)
5828         exit(0);
5829     /* 1e16+2.99999 -> 1e16+2. (correct), 1e16+4. (double rounding) */
5830     x = 1e16;
5831     y = 2.99999;
5832     z = x + y;
5833     if (z != 1e16+4.)
5834         exit(0);
5835     /* both tests show evidence of double rounding */
5836     exit(1);
5837 }
5838 ]])],
5839 [ac_cv_x87_double_rounding=no],
5840 [ac_cv_x87_double_rounding=yes],
5841 [ac_cv_x87_double_rounding=no])
5842 CC="$ac_save_cc"
5843 ])
5844
5845 AS_VAR_IF([ac_cv_x87_double_rounding], [yes], [
5846   AC_DEFINE([X87_DOUBLE_ROUNDING], [1],
5847   [Define if arithmetic is subject to x87-style double rounding issue])
5848 ])
5849
5850 # ************************************
5851 # * Check for mathematical functions *
5852 # ************************************
5853
5854 LIBS_SAVE=$LIBS
5855 LIBS="$LIBS $LIBM"
5856
5857 AC_CHECK_FUNCS(
5858   [acosh asinh atanh erf erfc expm1 log1p log2],
5859   [],
5860   [AC_MSG_ERROR([Python requires C99 compatible libm])]
5861 )
5862 LIBS=$LIBS_SAVE
5863
5864 dnl For multiprocessing module, check that sem_open
5865 dnl actually works.  For FreeBSD versions <= 7.2,
5866 dnl the kernel module that provides POSIX semaphores
5867 dnl isn't loaded by default, so an attempt to call
5868 dnl sem_open results in a 'Signal 12' error.
5869 AC_CACHE_CHECK([whether POSIX semaphores are enabled], [ac_cv_posix_semaphores_enabled],
5870   AC_RUN_IFELSE([
5871     AC_LANG_SOURCE([
5872       #include <unistd.h>
5873       #include <fcntl.h>
5874       #include <stdio.h>
5875       #include <semaphore.h>
5876       #include <sys/stat.h>
5877
5878       int main(void) {
5879         sem_t *a = sem_open("/autoconf", O_CREAT, S_IRUSR|S_IWUSR, 0);
5880         if (a == SEM_FAILED) {
5881           perror("sem_open");
5882           return 1;
5883         }
5884         sem_close(a);
5885         sem_unlink("/autoconf");
5886         return 0;
5887       }
5888     ])
5889   ],
5890   [ac_cv_posix_semaphores_enabled=yes],
5891   [ac_cv_posix_semaphores_enabled=no],
5892   [ac_cv_posix_semaphores_enabled=yes])
5893 )
5894 AS_VAR_IF([ac_cv_posix_semaphores_enabled], [no], [
5895   AC_DEFINE(
5896     [POSIX_SEMAPHORES_NOT_ENABLED], [1],
5897     [Define if POSIX semaphores aren't enabled on your system]
5898   )
5899 ])
5900
5901 dnl Multiprocessing check for broken sem_getvalue
5902 AC_CACHE_CHECK([for broken sem_getvalue], [ac_cv_broken_sem_getvalue],
5903   AC_RUN_IFELSE([
5904     AC_LANG_SOURCE([
5905       #include <unistd.h>
5906       #include <fcntl.h>
5907       #include <stdio.h>
5908       #include <semaphore.h>
5909       #include <sys/stat.h>
5910
5911       int main(void){
5912         sem_t *a = sem_open("/autocftw", O_CREAT, S_IRUSR|S_IWUSR, 0);
5913         int count;
5914         int res;
5915         if(a==SEM_FAILED){
5916           perror("sem_open");
5917           return 1;
5918
5919         }
5920         res = sem_getvalue(a, &count);
5921         sem_close(a);
5922         sem_unlink("/autocftw");
5923         return res==-1 ? 1 : 0;
5924       }
5925     ])
5926   ],
5927   [ac_cv_broken_sem_getvalue=no],
5928   [ac_cv_broken_sem_getvalue=yes],
5929   [ac_cv_broken_sem_getvalue=yes])
5930 )
5931 AS_VAR_IF([ac_cv_broken_sem_getvalue], [yes], [
5932   AC_DEFINE(
5933     [HAVE_BROKEN_SEM_GETVALUE], [1],
5934     [define to 1 if your sem_getvalue is broken.]
5935   )
5936 ])
5937
5938 AC_CHECK_DECLS([RTLD_LAZY, RTLD_NOW, RTLD_GLOBAL, RTLD_LOCAL, RTLD_NODELETE, RTLD_NOLOAD, RTLD_DEEPBIND, RTLD_MEMBER], [], [], [[@%:@include <dlfcn.h>]])
5939
5940 # determine what size digit to use for Python's longs
5941 AC_MSG_CHECKING([digit size for Python's longs])
5942 AC_ARG_ENABLE([big-digits],
5943 AS_HELP_STRING([--enable-big-digits@<:@=15|30@:>@],[use big digits (30 or 15 bits) for Python longs (default is 30)]]),
5944 [case $enable_big_digits in
5945 yes)
5946   enable_big_digits=30 ;;
5947 no)
5948   enable_big_digits=15 ;;
5949 [15|30])
5950   ;;
5951 *)
5952   AC_MSG_ERROR([bad value $enable_big_digits for --enable-big-digits; value should be 15 or 30]) ;;
5953 esac
5954 AC_MSG_RESULT([$enable_big_digits])
5955 AC_DEFINE_UNQUOTED([PYLONG_BITS_IN_DIGIT], [$enable_big_digits],
5956   [Define as the preferred size in bits of long digits])
5957 ],
5958 [AC_MSG_RESULT([no value specified])])
5959
5960 # check for wchar.h
5961 AC_CHECK_HEADER([wchar.h], [
5962   AC_DEFINE([HAVE_WCHAR_H], [1],
5963   [Define if the compiler provides a wchar.h header file.])
5964   wchar_h="yes"
5965 ],
5966 wchar_h="no"
5967 )
5968
5969 # determine wchar_t size
5970 if test "$wchar_h" = yes
5971 then
5972   AC_CHECK_SIZEOF([wchar_t], [4], [m4_normalize([
5973     #include <wchar.h>
5974   ])])
5975 fi
5976
5977 # check whether wchar_t is signed or not
5978 if test "$wchar_h" = yes
5979 then
5980   # check whether wchar_t is signed or not
5981   AC_CACHE_CHECK([whether wchar_t is signed], [ac_cv_wchar_t_signed], [
5982   AC_RUN_IFELSE([AC_LANG_SOURCE([[
5983   #include <wchar.h>
5984   int main()
5985   {
5986         /* Success: exit code 0 */
5987         return ((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
5988   }
5989   ]])],
5990   [ac_cv_wchar_t_signed=yes],
5991   [ac_cv_wchar_t_signed=no],
5992   [ac_cv_wchar_t_signed=yes])])
5993 fi
5994
5995 AC_MSG_CHECKING([whether wchar_t is usable])
5996 # wchar_t is only usable if it maps to an unsigned type
5997 if test "$ac_cv_sizeof_wchar_t" -ge 2 \
5998           -a "$ac_cv_wchar_t_signed" = "no"
5999 then
6000   AC_DEFINE([HAVE_USABLE_WCHAR_T], [1],
6001   [Define if you have a useable wchar_t type defined in wchar.h; useable
6002    means wchar_t must be an unsigned type with at least 16 bits. (see
6003    Include/unicodeobject.h).])
6004   AC_MSG_RESULT([yes])
6005 else
6006   AC_MSG_RESULT([no])
6007 fi
6008
6009 case $ac_sys_system/$ac_sys_release in
6010 SunOS/*)
6011   if test -f /etc/os-release; then
6012     OS_NAME=$(awk -F= '/^NAME=/ {print substr($2,2,length($2)-2)}' /etc/os-release)
6013     if test "x$OS_NAME" = "xOracle Solaris"; then
6014       # bpo-43667: In Oracle Solaris, the internal form of wchar_t in
6015       # non-Unicode locales is not Unicode and hence cannot be used directly.
6016       # https://docs.oracle.com/cd/E37838_01/html/E61053/gmwke.html
6017       AC_DEFINE([HAVE_NON_UNICODE_WCHAR_T_REPRESENTATION], [1],
6018       [Define if the internal form of wchar_t in non-Unicode locales
6019        is not Unicode.])
6020     fi
6021   fi
6022   ;;
6023 esac
6024
6025 # check for endianness
6026 AC_C_BIGENDIAN
6027
6028 # ABI version string for Python extension modules.  This appears between the
6029 # periods in shared library file names, e.g. foo.<SOABI>.so.  It is calculated
6030 # from the following attributes which affect the ABI of this Python build (in
6031 # this order):
6032 #
6033 # * The Python implementation (always 'cpython-' for us)
6034 # * The major and minor version numbers
6035 # * --disable-gil (adds a 't')
6036 # * --with-pydebug (adds a 'd')
6037 #
6038 # Thus for example, Python 3.2 built with wide unicode, pydebug, and pymalloc,
6039 # would get a shared library ABI version tag of 'cpython-32dmu' and shared
6040 # libraries would be named 'foo.cpython-32dmu.so'.
6041 #
6042 # In Python 3.2 and older, --with-wide-unicode added a 'u' flag.
6043 # In Python 3.7 and older, --with-pymalloc added a 'm' flag.
6044 AC_SUBST([SOABI])
6045 AC_MSG_CHECKING([ABIFLAGS])
6046 AC_MSG_RESULT([$ABIFLAGS])
6047 AC_MSG_CHECKING([SOABI])
6048 SOABI='cpython-'`echo $VERSION | tr -d .`${ABIFLAGS}${SOABI_PLATFORM:+-$SOABI_PLATFORM}
6049 AC_MSG_RESULT([$SOABI])
6050
6051 # Release build, debug build (Py_DEBUG), and trace refs build (Py_TRACE_REFS)
6052 # are ABI compatible
6053 if test "$Py_DEBUG" = 'true'; then
6054   # Similar to SOABI but remove "d" flag from ABIFLAGS
6055   AC_SUBST([ALT_SOABI])
6056   ALT_SOABI='cpython-'`echo $VERSION | tr -d .``echo $ABIFLAGS | tr -d d`${SOABI_PLATFORM:+-$SOABI_PLATFORM}
6057   AC_DEFINE_UNQUOTED([ALT_SOABI], ["${ALT_SOABI}"],
6058             [Alternative SOABI used in debug build to load C extensions built in release mode])
6059 fi
6060
6061 AC_SUBST([EXT_SUFFIX])
6062 EXT_SUFFIX=.${SOABI}${SHLIB_SUFFIX}
6063
6064 AC_MSG_CHECKING([LDVERSION])
6065 LDVERSION='$(VERSION)$(ABIFLAGS)'
6066 AC_MSG_RESULT([$LDVERSION])
6067
6068 # Configure the flags and dependencies used when compiling shared modules
6069 AC_SUBST([MODULE_DEPS_SHARED])
6070 AC_SUBST([MODULE_LDFLAGS])
6071 MODULE_DEPS_SHARED='$(MODULE_DEPS_STATIC) $(EXPORTSYMS)'
6072 MODULE_LDFLAGS=''
6073
6074 # On Android and Cygwin the shared libraries must be linked with libpython.
6075 if test "$PY_ENABLE_SHARED" = "1" && ( test -n "$ANDROID_API_LEVEL" || test "$MACHDEP" = "cygwin"); then
6076   MODULE_DEPS_SHARED="$MODULE_DEPS_SHARED \$(LDLIBRARY)"
6077   MODULE_LDFLAGS="\$(BLDLIBRARY)"
6078 fi
6079
6080 # On iOS the shared libraries must be linked with the Python framework
6081 if test "$ac_sys_system" = "iOS"; then
6082   MODULE_DEPS_SHARED="$MODULE_DEPS_SHARED \$(PYTHONFRAMEWORKDIR)/\$(PYTHONFRAMEWORK)"
6083 fi
6084
6085
6086 AC_SUBST([BINLIBDEST])
6087 BINLIBDEST='$(LIBDIR)/python$(VERSION)'
6088
6089
6090 # Check for --with-platlibdir
6091 # /usr/$LIDIRNAME/python$VERSION
6092 AC_SUBST([PLATLIBDIR])
6093 PLATLIBDIR="lib"
6094 AC_MSG_CHECKING([for --with-platlibdir])
6095 AC_ARG_WITH(
6096   [platlibdir],
6097   [AS_HELP_STRING(
6098     [--with-platlibdir=DIRNAME],
6099     [Python library directory name (default is "lib")]
6100   )],
6101 [
6102 # ignore 3 options:
6103 #   --with-platlibdir
6104 #   --with-platlibdir=
6105 #   --without-platlibdir
6106 if test -n "$withval" -a "$withval" != yes -a "$withval" != no
6107 then
6108   AC_MSG_RESULT([yes])
6109   PLATLIBDIR="$withval"
6110   BINLIBDEST='${exec_prefix}/${PLATLIBDIR}/python$(VERSION)'
6111 else
6112   AC_MSG_RESULT([no])
6113 fi],
6114 [AC_MSG_RESULT([no])])
6115
6116
6117 dnl define LIBPL after ABIFLAGS and LDVERSION is defined.
6118 AC_SUBST([PY_ENABLE_SHARED])
6119 if test x$PLATFORM_TRIPLET = x; then
6120   LIBPL='$(prefix)'"/${PLATLIBDIR}/python${VERSION}/config-${LDVERSION}"
6121 else
6122   LIBPL='$(prefix)'"/${PLATLIBDIR}/python${VERSION}/config-${LDVERSION}-${PLATFORM_TRIPLET}"
6123 fi
6124 AC_SUBST([LIBPL])
6125
6126 # Check for --with-wheel-pkg-dir=PATH
6127 AC_SUBST([WHEEL_PKG_DIR])
6128 WHEEL_PKG_DIR=""
6129 AC_MSG_CHECKING([for --with-wheel-pkg-dir])
6130 AC_ARG_WITH(
6131   [wheel-pkg-dir],
6132   [AS_HELP_STRING(
6133     [--with-wheel-pkg-dir=PATH],
6134     [Directory of wheel packages used by ensurepip (default: none)]
6135   )],
6136 [
6137 if test -n "$withval"; then
6138   AC_MSG_RESULT([yes])
6139   WHEEL_PKG_DIR="$withval"
6140 else
6141   AC_MSG_RESULT([no])
6142 fi],
6143 [AC_MSG_RESULT([no])])
6144
6145 # Check whether right shifting a negative integer extends the sign bit
6146 # or fills with zeros (like the Cray J90, according to Tim Peters).
6147 AC_CACHE_CHECK([whether right shift extends the sign bit], [ac_cv_rshift_extends_sign], [
6148 AC_RUN_IFELSE([AC_LANG_SOURCE([[
6149 int main(void)
6150 {
6151         return (((-1)>>3 == -1) ? 0 : 1);
6152 }
6153 ]])],
6154 [ac_cv_rshift_extends_sign=yes],
6155 [ac_cv_rshift_extends_sign=no],
6156 [ac_cv_rshift_extends_sign=yes])])
6157 if test "$ac_cv_rshift_extends_sign" = no
6158 then
6159   AC_DEFINE([SIGNED_RIGHT_SHIFT_ZERO_FILLS], [1],
6160   [Define if i>>j for signed int i does not extend the sign bit
6161    when i < 0])
6162 fi
6163
6164 # check for getc_unlocked and related locking functions
6165 AC_CACHE_CHECK([for getc_unlocked() and friends], [ac_cv_have_getc_unlocked], [
6166 AC_LINK_IFELSE([AC_LANG_PROGRAM([[@%:@include <stdio.h>]], [[
6167         FILE *f = fopen("/dev/null", "r");
6168         flockfile(f);
6169         getc_unlocked(f);
6170         funlockfile(f);
6171 ]])],[ac_cv_have_getc_unlocked=yes],[ac_cv_have_getc_unlocked=no])])
6172 if test "$ac_cv_have_getc_unlocked" = yes
6173 then
6174   AC_DEFINE([HAVE_GETC_UNLOCKED], [1],
6175   [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
6176 fi
6177
6178 dnl Check for libreadline and libedit
6179 dnl - libreadline provides "readline/readline.h" header and "libreadline"
6180 dnl   shared library. pkg-config file is readline.pc
6181 dnl - libedit provides "editline/readline.h" header and "libedit" shared
6182 dnl   library. pkg-config file ins libedit.pc
6183 dnl - editline is not supported ("readline.h" and "libeditline" shared library)
6184 dnl
6185 dnl NOTE: In the past we checked if readline needs an additional termcap
6186 dnl library (tinfo ncursesw ncurses termcap). We now assume that libreadline
6187 dnl or readline.pc provide correct linker information.
6188
6189 AH_TEMPLATE([WITH_EDITLINE], [Define to build the readline module against libedit.])
6190
6191 AC_ARG_WITH(
6192   [readline],
6193   [AS_HELP_STRING([--with(out)-readline@<:@=editline|readline|no@:>@],
6194                   [use libedit for backend or disable readline module])],
6195   [
6196     AS_CASE([$with_readline],
6197       [editline|edit], [with_readline=edit],
6198       [yes|readline], [with_readline=readline],
6199       [no], [],
6200       [AC_MSG_ERROR([proper usage is --with(out)-readline@<:@=editline|readline|no@:>@])]
6201     )
6202   ],
6203   [with_readline=readline]
6204 )
6205
6206 AS_VAR_IF([with_readline], [readline], [
6207   PKG_CHECK_MODULES([LIBREADLINE], [readline], [
6208     LIBREADLINE=readline
6209     READLINE_CFLAGS=$LIBREADLINE_CFLAGS
6210     READLINE_LIBS=$LIBREADLINE_LIBS
6211   ], [
6212     WITH_SAVE_ENV([
6213       CPPFLAGS="$CPPFLAGS $LIBREADLINE_CFLAGS"
6214       LDFLAGS="$LDFLAGS $LIBREADLINE_LIBS"
6215       AC_CHECK_HEADERS([readline/readline.h], [
6216         AC_CHECK_LIB([readline], [readline], [
6217           LIBREADLINE=readline
6218           READLINE_CFLAGS=${LIBREADLINE_CFLAGS-""}
6219           READLINE_LIBS=${LIBREADLINE_LIBS-"-lreadline"}
6220         ], [with_readline=no])
6221       ], [with_readline=no])
6222     ])
6223   ])
6224 ])
6225
6226 AS_VAR_IF([with_readline], [edit], [
6227   PKG_CHECK_MODULES([LIBEDIT], [libedit], [
6228     AC_DEFINE([WITH_EDITLINE], [1])
6229     LIBREADLINE=edit
6230     READLINE_CFLAGS=$LIBEDIT_CFLAGS
6231     READLINE_LIBS=$LIBEDIT_LIBS
6232   ], [
6233     WITH_SAVE_ENV([
6234       CPPFLAGS="$CPPFLAGS $LIBEDIT_CFLAGS"
6235       LDFLAGS="$LDFLAGS $LIBEDIT_LIBS"
6236       AC_CHECK_HEADERS([editline/readline.h], [
6237         AC_CHECK_LIB([edit], [readline], [
6238           LIBREADLINE=edit
6239           AC_DEFINE([WITH_EDITLINE], [1])
6240           READLINE_CFLAGS=${LIBEDIT_CFLAGS-""}
6241           READLINE_LIBS=${LIBEDIT_LIBS-"-ledit"}
6242         ], [with_readline=no])
6243       ], [with_readline=no])
6244     ])
6245   ])
6246 ])
6247
6248 dnl pyconfig.h defines _XOPEN_SOURCE=700
6249 READLINE_CFLAGS=$(echo $READLINE_CFLAGS | sed 's/-D_XOPEN_SOURCE=600//g')
6250
6251 AC_MSG_CHECKING([how to link readline])
6252 AS_VAR_IF([with_readline], [no], [
6253   AC_MSG_RESULT([no])
6254 ], [
6255   AC_MSG_RESULT([$with_readline (CFLAGS: $READLINE_CFLAGS, LIBS: $READLINE_LIBS)])
6256
6257   WITH_SAVE_ENV([
6258     CPPFLAGS="$CPPFLAGS $READLINE_CFLAGS"
6259     LIBS="$READLINE_LIBS $LIBS"
6260     LIBS_SAVE=$LIBS
6261
6262     m4_define([readline_includes], [
6263       #include <stdio.h> /* Must be first for Gnu Readline */
6264       #ifdef WITH_EDITLINE
6265       # include <editline/readline.h>
6266       #else
6267       # include <readline/readline.h>
6268       # include <readline/history.h>
6269       #endif
6270     ])
6271
6272     # check for readline 2.2
6273     AC_CHECK_DECL([rl_completion_append_character], [
6274       AC_DEFINE([HAVE_RL_COMPLETION_APPEND_CHARACTER], [1], [Define if you have readline 2.2])
6275     ], [], [readline_includes])
6276
6277     AC_CHECK_DECL([rl_completion_suppress_append], [
6278       AC_DEFINE([HAVE_RL_COMPLETION_SUPPRESS_APPEND], [1], [Define if you have rl_completion_suppress_append])
6279     ], [], [readline_includes])
6280
6281     # check for readline 4.0
6282     AC_CACHE_CHECK([for rl_pre_input_hook in -l$LIBREADLINE], [ac_cv_readline_rl_pre_input_hook], [
6283       AC_LINK_IFELSE(
6284         [AC_LANG_PROGRAM([readline_includes], [void *x = rl_pre_input_hook])],
6285         [ac_cv_readline_rl_pre_input_hook=yes], [ac_cv_readline_rl_pre_input_hook=no]
6286       )
6287     ])
6288     AS_VAR_IF([ac_cv_readline_rl_pre_input_hook], [yes], [
6289       AC_DEFINE([HAVE_RL_PRE_INPUT_HOOK], [1], [Define if you have readline 4.0])
6290     ])
6291
6292     # also in 4.0
6293     AC_CACHE_CHECK([for rl_completion_display_matches_hook in -l$LIBREADLINE], [ac_cv_readline_rl_completion_display_matches_hook], [
6294       AC_LINK_IFELSE(
6295         [AC_LANG_PROGRAM([readline_includes], [void *x = rl_completion_display_matches_hook])],
6296         [ac_cv_readline_rl_completion_display_matches_hook=yes], [ac_cv_readline_rl_completion_display_matches_hook=no]
6297       )
6298     ])
6299     AS_VAR_IF([ac_cv_readline_rl_completion_display_matches_hook], [yes], [
6300       AC_DEFINE([HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK], [1], [Define if you have readline 4.0])
6301     ])
6302
6303     # also in 4.0, but not in editline
6304       AC_CACHE_CHECK([for rl_resize_terminal in -l$LIBREADLINE], [ac_cv_readline_rl_resize_terminal], [
6305       AC_LINK_IFELSE(
6306         [AC_LANG_PROGRAM([readline_includes], [void *x = rl_resize_terminal])],
6307         [ac_cv_readline_rl_resize_terminal=yes], [ac_cv_readline_rl_resize_terminal=no]
6308       )
6309     ])
6310     AS_VAR_IF([ac_cv_readline_rl_resize_terminal], [yes], [
6311       AC_DEFINE([HAVE_RL_RESIZE_TERMINAL], [1], [Define if you have readline 4.0])
6312     ])
6313
6314     # check for readline 4.2
6315     AC_CACHE_CHECK([for rl_completion_matches in -l$LIBREADLINE], [ac_cv_readline_rl_completion_matches], [
6316       AC_LINK_IFELSE(
6317         [AC_LANG_PROGRAM([readline_includes], [void *x = rl_completion_matches])],
6318         [ac_cv_readline_rl_completion_matches=yes], [ac_cv_readline_rl_completion_matches=no]
6319       )
6320     ])
6321     AS_VAR_IF([ac_cv_readline_rl_completion_matches], [yes], [
6322       AC_DEFINE([HAVE_RL_COMPLETION_MATCHES], [1], [Define if you have readline 4.2])
6323     ])
6324
6325     # also in readline 4.2
6326     AC_CHECK_DECL([rl_catch_signals], [
6327       AC_DEFINE([HAVE_RL_CATCH_SIGNAL], [1], [Define if you can turn off readline's signal handling.])
6328     ], [], [readline_includes])
6329
6330     AC_CACHE_CHECK([for append_history in -l$LIBREADLINE], [ac_cv_readline_append_history], [
6331       AC_LINK_IFELSE(
6332         [AC_LANG_PROGRAM([readline_includes], [void *x = append_history])],
6333         [ac_cv_readline_append_history=yes], [ac_cv_readline_append_history=no]
6334       )
6335     ])
6336     AS_VAR_IF([ac_cv_readline_append_history], [yes], [
6337       AC_DEFINE([HAVE_RL_APPEND_HISTORY], [1], [Define if readline supports append_history])
6338     ])
6339
6340     # in readline as well as newer editline (April 2023)
6341     AC_CHECK_TYPES([rl_compdisp_func_t], [], [], [readline_includes])
6342
6343     m4_undefine([readline_includes])
6344   ])dnl WITH_SAVE_ENV()
6345 ])
6346
6347 AC_CACHE_CHECK([for broken nice()], [ac_cv_broken_nice], [
6348 AC_RUN_IFELSE([AC_LANG_SOURCE([[
6349 #include <stdlib.h>
6350 #include <unistd.h>
6351 int main(void)
6352 {
6353         int val1 = nice(1);
6354         if (val1 != -1 && val1 == nice(2))
6355                 exit(0);
6356         exit(1);
6357 }
6358 ]])],
6359 [ac_cv_broken_nice=yes],
6360 [ac_cv_broken_nice=no],
6361 [ac_cv_broken_nice=no])])
6362 if test "$ac_cv_broken_nice" = yes
6363 then
6364   AC_DEFINE([HAVE_BROKEN_NICE], [1],
6365   [Define if nice() returns success/failure instead of the new priority.])
6366 fi
6367
6368 AC_CACHE_CHECK([for broken poll()], [ac_cv_broken_poll],
6369 AC_RUN_IFELSE([AC_LANG_SOURCE([[
6370 #include <poll.h>
6371 #include <unistd.h>
6372
6373 int main(void)
6374 {
6375     struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
6376     int poll_test;
6377
6378     close (42);
6379
6380     poll_test = poll(&poll_struct, 1, 0);
6381     if (poll_test < 0)
6382         return 0;
6383     else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
6384         return 0;
6385     else
6386         return 1;
6387 }
6388 ]])],
6389 [ac_cv_broken_poll=yes],
6390 [ac_cv_broken_poll=no],
6391 [ac_cv_broken_poll=no]))
6392 if test "$ac_cv_broken_poll" = yes
6393 then
6394   AC_DEFINE([HAVE_BROKEN_POLL], [1],
6395       [Define if poll() sets errno on invalid file descriptors.])
6396 fi
6397
6398 # check tzset(3) exists and works like we expect it to
6399 AC_CACHE_CHECK([for working tzset()], [ac_cv_working_tzset], [
6400 AC_RUN_IFELSE([AC_LANG_SOURCE([[
6401 #include <stdlib.h>
6402 #include <time.h>
6403 #include <string.h>
6404
6405 #if HAVE_TZNAME
6406 extern char *tzname[];
6407 #endif
6408
6409 int main(void)
6410 {
6411         /* Note that we need to ensure that not only does tzset(3)
6412            do 'something' with localtime, but it works as documented
6413            in the library reference and as expected by the test suite.
6414            This includes making sure that tzname is set properly if
6415            tm->tm_zone does not exist since it is the alternative way
6416            of getting timezone info.
6417
6418            Red Hat 6.2 doesn't understand the southern hemisphere
6419            after New Year's Day.
6420         */
6421
6422         time_t groundhogday = 1044144000; /* GMT-based */
6423         time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
6424
6425         putenv("TZ=UTC+0");
6426         tzset();
6427         if (localtime(&groundhogday)->tm_hour != 0)
6428             exit(1);
6429 #if HAVE_TZNAME
6430         /* For UTC, tzname[1] is sometimes "", sometimes "   " */
6431         if (strcmp(tzname[0], "UTC") ||
6432                 (tzname[1][0] != 0 && tzname[1][0] != ' '))
6433             exit(1);
6434 #endif
6435
6436         putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
6437         tzset();
6438         if (localtime(&groundhogday)->tm_hour != 19)
6439             exit(1);
6440 #if HAVE_TZNAME
6441         if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
6442             exit(1);
6443 #endif
6444
6445         putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
6446         tzset();
6447         if (localtime(&groundhogday)->tm_hour != 11)
6448             exit(1);
6449 #if HAVE_TZNAME
6450         if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
6451             exit(1);
6452 #endif
6453
6454 #if HAVE_STRUCT_TM_TM_ZONE
6455         if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
6456             exit(1);
6457         if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
6458             exit(1);
6459 #endif
6460
6461         exit(0);
6462 }
6463 ]])],
6464 [ac_cv_working_tzset=yes],
6465 [ac_cv_working_tzset=no],
6466 [ac_cv_working_tzset=no])])
6467 if test "$ac_cv_working_tzset" = yes
6468 then
6469   AC_DEFINE([HAVE_WORKING_TZSET], [1],
6470   [Define if tzset() actually switches the local timezone in a meaningful way.])
6471 fi
6472
6473 # Look for subsecond timestamps in struct stat
6474 AC_CACHE_CHECK([for tv_nsec in struct stat], [ac_cv_stat_tv_nsec],
6475 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <sys/stat.h>]], [[
6476 struct stat st;
6477 st.st_mtim.tv_nsec = 1;
6478 ]])],
6479 [ac_cv_stat_tv_nsec=yes],
6480 [ac_cv_stat_tv_nsec=no]))
6481 if test "$ac_cv_stat_tv_nsec" = yes
6482 then
6483   AC_DEFINE([HAVE_STAT_TV_NSEC], [1],
6484   [Define if you have struct stat.st_mtim.tv_nsec])
6485 fi
6486
6487 # Look for BSD style subsecond timestamps in struct stat
6488 AC_CACHE_CHECK([for tv_nsec2 in struct stat], [ac_cv_stat_tv_nsec2],
6489 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <sys/stat.h>]], [[
6490 struct stat st;
6491 st.st_mtimespec.tv_nsec = 1;
6492 ]])],
6493 [ac_cv_stat_tv_nsec2=yes],
6494 [ac_cv_stat_tv_nsec2=no]))
6495 if test "$ac_cv_stat_tv_nsec2" = yes
6496 then
6497   AC_DEFINE([HAVE_STAT_TV_NSEC2], [1],
6498   [Define if you have struct stat.st_mtimensec])
6499 fi
6500
6501 dnl check for ncurses/ncursesw and panel/panelw
6502 dnl NOTE: old curses is not detected.
6503 dnl have_curses=[no, ncursesw, ncurses]
6504 dnl have_panel=[no, panelw, panel]
6505 have_curses=no
6506 have_panel=no
6507
6508 AH_TEMPLATE([HAVE_NCURSESW], [Define to 1 if you have the `ncursesw' library.])
6509 AC_CHECK_HEADERS([curses.h ncurses.h])
6510
6511 AS_VAR_IF([ac_cv_header_ncurses_h], [yes], [
6512   if test "$ac_sys_system" != "Darwin"; then
6513     dnl On macOS, there is no separate /usr/lib/libncursesw nor libpanelw.
6514     PKG_CHECK_MODULES([CURSES], [ncursesw], [
6515       AC_DEFINE([HAVE_NCURSESW], [1])
6516       have_curses=ncursesw
6517     ], [
6518       WITH_SAVE_ENV([
6519         AC_CHECK_LIB([ncursesw], [initscr], [
6520           AC_DEFINE([HAVE_NCURSESW], [1])
6521           have_curses=ncursesw
6522           CURSES_CFLAGS=${CURSES_CFLAGS-""}
6523           CURSES_LIBS=${CURSES_LIBS-"-lncursesw"}
6524         ])
6525       ])
6526     ])
6527   fi
6528
6529   AS_VAR_IF([have_curses], [no], [
6530     PKG_CHECK_MODULES([CURSES], [ncurses], [
6531       have_curses=ncurses
6532     ], [
6533       WITH_SAVE_ENV([
6534         AC_CHECK_LIB([ncurses], [initscr], [
6535           have_curses=ncurses
6536           CURSES_CFLAGS=${CURSES_CFLAGS-""}
6537           CURSES_LIBS=${CURSES_LIBS-"-lncurses"}
6538         ])
6539       ])
6540     ])
6541   ])
6542
6543 ])dnl ac_cv_header_ncurses_h = yes
6544
6545 dnl remove _XOPEN_SOURCE macro from curses cflags. pyconfig.h sets
6546 dnl the macro to 700.
6547 CURSES_CFLAGS=$(echo $CURSES_CFLAGS | sed 's/-D_XOPEN_SOURCE=600//g')
6548
6549 if test "$have_curses" != no -a "$ac_sys_system" = "Darwin"; then
6550   dnl On macOS, there is no separate /usr/lib/libncursesw nor libpanelw.
6551   dnl System-supplied ncurses combines libncurses/libpanel and supports wide
6552   dnl characters, so we can use it like ncursesw.
6553   dnl If a locally-supplied version of libncursesw is found, we will use that.
6554   dnl There should also be a libpanelw.
6555   dnl _XOPEN_SOURCE defines are usually excluded for macOS, but we need
6556   dnl _XOPEN_SOURCE_EXTENDED here for ncurses wide char support.
6557
6558   AS_VAR_APPEND([CURSES_CFLAGS], [" -D_XOPEN_SOURCE_EXTENDED=1"])
6559   AC_DEFINE([HAVE_NCURSESW], [1])
6560 fi
6561
6562 dnl TODO: detect "curses" and special cases tinfo, terminfo, or termcap
6563
6564 AC_MSG_CHECKING([curses module flags])
6565 AS_VAR_IF([have_curses], [no], [
6566   AC_MSG_RESULT([no])
6567 ], [
6568   AC_MSG_RESULT([$have_curses (CFLAGS: $CURSES_CFLAGS, LIBS: $CURSES_LIBS)])
6569 ])
6570
6571 dnl check for ncurses' panel/panelw library
6572 AC_CHECK_HEADERS([panel.h])
6573
6574 AS_VAR_IF([ac_cv_header_panel_h], [yes], [
6575
6576   if test "$ac_sys_system" != "Darwin"; then
6577     dnl On macOS, there is no separate /usr/lib/libncursesw nor libpanelw.
6578     AS_VAR_IF([have_curses], [ncursesw], [
6579       PKG_CHECK_MODULES([PANEL], [panelw], [
6580         have_panel=panelw
6581       ], [
6582         WITH_SAVE_ENV([
6583           AC_CHECK_LIB([panelw], [update_panels], [
6584             have_panel=panelw
6585             PANEL_CFLAGS=${PANEL_CFLAGS-""}
6586             PANEL_LIBS=${PANEL_LIBS-"-lpanelw"}
6587           ])
6588         ])
6589       ])
6590     ])
6591   fi
6592
6593   AS_VAR_IF([have_curses], [ncurses], [
6594     PKG_CHECK_MODULES([PANEL], [panel], [
6595       have_panel=panel
6596     ], [
6597       WITH_SAVE_ENV([
6598         AC_CHECK_LIB([panel], [update_panels], [
6599           have_panel=panel
6600           PANEL_CFLAGS=${PANEL_CFLAGS-""}
6601           PANEL_LIBS=${PANEL_LIBS-"-lpanel"}
6602         ])
6603       ])
6604     ])
6605   ])
6606
6607 ])dnl ac_cv_header_panel_h = yes
6608
6609 dnl pyconfig.h defines _XOPEN_SOURCE=700
6610 PANEL_CFLAGS=$(echo $PANEL_CFLAGS | sed 's/-D_XOPEN_SOURCE=600//g')
6611
6612 AC_MSG_CHECKING([panel flags])
6613 AS_VAR_IF([have_panel], [no], [
6614   AC_MSG_RESULT([no])
6615 ], [
6616   AC_MSG_RESULT([$have_panel (CFLAGS: $PANEL_CFLAGS, LIBS: $PANEL_LIBS)])
6617 ])
6618
6619 # first curses header check
6620 ac_save_cppflags="$CPPFLAGS"
6621 if test "$cross_compiling" = no; then
6622   CPPFLAGS="$CPPFLAGS -I/usr/include/ncursesw"
6623 fi
6624
6625 # On Solaris, term.h requires curses.h
6626 AC_CHECK_HEADERS([term.h], [], [], [
6627 #ifdef HAVE_CURSES_H
6628 #include <curses.h>
6629 #endif
6630 ])
6631
6632 # On HP/UX 11.0, mvwdelch is a block with a return statement
6633 AC_CACHE_CHECK([whether mvwdelch is an expression], [ac_cv_mvwdelch_is_expression],
6634 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <curses.h>]], [[
6635   int rtn;
6636   rtn = mvwdelch(0,0,0);
6637 ]])],
6638 [ac_cv_mvwdelch_is_expression=yes],
6639 [ac_cv_mvwdelch_is_expression=no]))
6640
6641 if test "$ac_cv_mvwdelch_is_expression" = yes
6642 then
6643   AC_DEFINE([MVWDELCH_IS_EXPRESSION], [1],
6644   [Define if mvwdelch in curses.h is an expression.])
6645 fi
6646
6647 # Issue #25720: ncurses has introduced the NCURSES_OPAQUE symbol making opaque
6648 # structs since version 5.7.  If the macro is defined as zero before including
6649 # [n]curses.h, ncurses will expose fields of the structs regardless of the
6650 # configuration.
6651 AC_CACHE_CHECK([whether WINDOW has _flags], [ac_cv_window_has_flags],
6652 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
6653   #define NCURSES_OPAQUE 0
6654   #include <curses.h>
6655 ]], [[
6656   WINDOW *w;
6657   w->_flags = 0;
6658 ]])],
6659 [ac_cv_window_has_flags=yes],
6660 [ac_cv_window_has_flags=no]))
6661
6662
6663 if test "$ac_cv_window_has_flags" = yes
6664 then
6665   AC_DEFINE([WINDOW_HAS_FLAGS], [1],
6666   [Define if WINDOW in curses.h offers a field _flags.])
6667 fi
6668
6669 dnl PY_CHECK_CURSES_FUNC(FUNCTION)
6670 AC_DEFUN([PY_CHECK_CURSES_FUNC],
6671 [ AS_VAR_PUSHDEF([py_var], [ac_cv_lib_curses_$1])
6672   AS_VAR_PUSHDEF([py_define], [HAVE_CURSES_]m4_toupper($1))
6673   AC_CACHE_CHECK(
6674     [for curses function $1],
6675     [py_var],
6676     [AC_COMPILE_IFELSE(
6677       [AC_LANG_PROGRAM(
6678         [@%:@include <curses.h>], [
6679         #ifndef $1
6680         void *x=$1
6681         #endif
6682       ])],
6683       [AS_VAR_SET([py_var], [yes])],
6684       [AS_VAR_SET([py_var], [no])])]
6685   )
6686   AS_VAR_IF(
6687     [py_var],
6688     [yes],
6689     [AC_DEFINE([py_define], [1], [Define if you have the '$1' function.])])
6690   AS_VAR_POPDEF([py_var])
6691   AS_VAR_POPDEF([py_define])
6692 ])
6693
6694 PY_CHECK_CURSES_FUNC([is_pad])
6695 PY_CHECK_CURSES_FUNC([is_term_resized])
6696 PY_CHECK_CURSES_FUNC([resize_term])
6697 PY_CHECK_CURSES_FUNC([resizeterm])
6698 PY_CHECK_CURSES_FUNC([immedok])
6699 PY_CHECK_CURSES_FUNC([syncok])
6700 PY_CHECK_CURSES_FUNC([wchgat])
6701 PY_CHECK_CURSES_FUNC([filter])
6702 PY_CHECK_CURSES_FUNC([has_key])
6703 PY_CHECK_CURSES_FUNC([typeahead])
6704 PY_CHECK_CURSES_FUNC([use_env])
6705 CPPFLAGS=$ac_save_cppflags
6706
6707 AC_MSG_NOTICE([checking for device files])
6708
6709 dnl NOTE: Inform user how to proceed with files when cross compiling.
6710 dnl Some cross-compile builds are predictable; they won't ever
6711 dnl have /dev/ptmx or /dev/ptc, so we can set them explicitly.
6712 if test "$ac_sys_system" = "Linux-android" || test "$ac_sys_system" = "iOS"; then
6713   ac_cv_file__dev_ptmx=no
6714   ac_cv_file__dev_ptc=no
6715 else
6716   if test "x$cross_compiling" = xyes; then
6717     if test "${ac_cv_file__dev_ptmx+set}" != set; then
6718       AC_MSG_CHECKING([for /dev/ptmx])
6719       AC_MSG_RESULT([not set])
6720       AC_MSG_ERROR([set ac_cv_file__dev_ptmx to yes/no in your CONFIG_SITE file when cross compiling])
6721     fi
6722     if test "${ac_cv_file__dev_ptc+set}" != set; then
6723       AC_MSG_CHECKING([for /dev/ptc])
6724       AC_MSG_RESULT([not set])
6725       AC_MSG_ERROR([set ac_cv_file__dev_ptc to yes/no in your CONFIG_SITE file when cross compiling])
6726     fi
6727   fi
6728
6729   AC_CHECK_FILE([/dev/ptmx], [], [])
6730   if test "x$ac_cv_file__dev_ptmx" = xyes; then
6731     AC_DEFINE([HAVE_DEV_PTMX], [1],
6732     [Define to 1 if you have the /dev/ptmx device file.])
6733   fi
6734   AC_CHECK_FILE([/dev/ptc], [], [])
6735   if test "x$ac_cv_file__dev_ptc" = xyes; then
6736     AC_DEFINE([HAVE_DEV_PTC], [1],
6737     [Define to 1 if you have the /dev/ptc device file.])
6738   fi
6739 fi
6740
6741 if test $ac_sys_system = Darwin
6742 then
6743         LIBS="$LIBS -framework CoreFoundation"
6744 fi
6745
6746 AC_CHECK_TYPES([socklen_t], [],
6747                [AC_DEFINE([socklen_t], [int],
6748                           [Define to 'int' if <sys/socket.h> does not define.])], [
6749 #ifdef HAVE_SYS_TYPES_H
6750 #include <sys/types.h>
6751 #endif
6752 #ifdef HAVE_SYS_SOCKET_H
6753 #include <sys/socket.h>
6754 #endif
6755 ])
6756
6757 AC_CACHE_CHECK([for broken mbstowcs], [ac_cv_broken_mbstowcs],
6758 AC_RUN_IFELSE([AC_LANG_SOURCE([[
6759 #include <stddef.h>
6760 #include <stdio.h>
6761 #include <stdlib.h>
6762 int main(void) {
6763     size_t len = -1;
6764     const char *str = "text";
6765     len = mbstowcs(NULL, str, 0);
6766     return (len != 4);
6767 }
6768 ]])],
6769 [ac_cv_broken_mbstowcs=no],
6770 [ac_cv_broken_mbstowcs=yes],
6771 [ac_cv_broken_mbstowcs=no]))
6772 if test "$ac_cv_broken_mbstowcs" = yes
6773 then
6774   AC_DEFINE([HAVE_BROKEN_MBSTOWCS], [1],
6775   [Define if mbstowcs(NULL, "text", 0) does not return the number of
6776    wide chars that would be converted.])
6777 fi
6778
6779 # Check for --with-computed-gotos
6780 AC_MSG_CHECKING([for --with-computed-gotos])
6781 AC_ARG_WITH(
6782   [computed-gotos],
6783   [AS_HELP_STRING(
6784     [--with-computed-gotos],
6785     [enable computed gotos in evaluation loop (enabled by default on supported compilers)]
6786   )],
6787 [
6788 if test "$withval" = yes
6789 then
6790   AC_DEFINE([USE_COMPUTED_GOTOS], [1],
6791   [Define if you want to use computed gotos in ceval.c.])
6792   AC_MSG_RESULT([yes])
6793 fi
6794 if test "$withval" = no
6795 then
6796   AC_DEFINE([USE_COMPUTED_GOTOS], [0],
6797   [Define if you want to use computed gotos in ceval.c.])
6798   AC_MSG_RESULT([no])
6799 fi
6800 ],
6801 [AC_MSG_RESULT([no value specified])])
6802
6803 AC_CACHE_CHECK([whether $CC supports computed gotos], [ac_cv_computed_gotos],
6804 AC_RUN_IFELSE([AC_LANG_SOURCE([[[
6805 int main(int argc, char **argv)
6806 {
6807     static void *targets[1] = { &&LABEL1 };
6808     goto LABEL2;
6809 LABEL1:
6810     return 0;
6811 LABEL2:
6812     goto *targets[0];
6813     return 1;
6814 }
6815 ]]])],
6816 [ac_cv_computed_gotos=yes],
6817 [ac_cv_computed_gotos=no],
6818 [if test "${with_computed_gotos+set}" = set; then
6819    ac_cv_computed_gotos="$with_computed_gotos -- configured --with(out)-computed-gotos"
6820  else
6821    ac_cv_computed_gotos=no
6822  fi]))
6823 case "$ac_cv_computed_gotos" in yes*)
6824   AC_DEFINE([HAVE_COMPUTED_GOTOS], [1],
6825   [Define if the C compiler supports computed gotos.])
6826 esac
6827
6828 case $ac_sys_system in
6829 AIX*)
6830   AC_DEFINE([HAVE_BROKEN_PIPE_BUF], [1],
6831     [Define if the system reports an invalid PIPE_BUF value.]) ;;
6832 esac
6833
6834
6835 AC_SUBST([THREADHEADERS])
6836
6837 for h in `(cd $srcdir;echo Python/thread_*.h)`
6838 do
6839   THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
6840 done
6841
6842 AC_SUBST([SRCDIRS])
6843 SRCDIRS="\
6844   Modules \
6845   Modules/_blake2 \
6846   Modules/_ctypes \
6847   Modules/_decimal \
6848   Modules/_decimal/libmpdec \
6849   Modules/_hacl \
6850   Modules/_io \
6851   Modules/_multiprocessing \
6852   Modules/_sqlite \
6853   Modules/_sre \
6854   Modules/_testcapi \
6855   Modules/_testinternalcapi \
6856   Modules/_testlimitedcapi \
6857   Modules/_xxtestfuzz \
6858   Modules/cjkcodecs \
6859   Modules/expat \
6860   Objects \
6861   Objects/mimalloc \
6862   Objects/mimalloc/prim \
6863   Parser \
6864   Parser/tokenizer \
6865   Parser/lexer \
6866   Programs \
6867   Python \
6868   Python/frozen_modules"
6869 AC_MSG_CHECKING([for build directories])
6870 for dir in $SRCDIRS; do
6871     if test ! -d $dir; then
6872         mkdir $dir
6873     fi
6874 done
6875 AC_MSG_RESULT([done])
6876
6877 # Availability of -O2:
6878 AC_CACHE_CHECK([for -O2], [ac_cv_compile_o2], [
6879 saved_cflags="$CFLAGS"
6880 CFLAGS="-O2"
6881 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [ac_cv_compile_o2=yes], [ac_cv_compile_o2=no])
6882 CFLAGS="$saved_cflags"
6883 ])
6884
6885 # _FORTIFY_SOURCE wrappers for memmove and bcopy are incorrect:
6886 # http://sourceware.org/ml/libc-alpha/2010-12/msg00009.html
6887 AC_MSG_CHECKING([for glibc _FORTIFY_SOURCE/memmove bug])
6888 saved_cflags="$CFLAGS"
6889 CFLAGS="-O2 -D_FORTIFY_SOURCE=2"
6890 if test "$ac_cv_compile_o2" = no; then
6891     CFLAGS=""
6892 fi
6893 AC_RUN_IFELSE([AC_LANG_SOURCE([[
6894 #include <stdio.h>
6895 #include <stdlib.h>
6896 #include <string.h>
6897 void foo(void *p, void *q) { memmove(p, q, 19); }
6898 int main(void) {
6899   char a[32] = "123456789000000000";
6900   foo(&a[9], a);
6901   if (strcmp(a, "123456789123456789000000000") != 0)
6902     return 1;
6903   foo(a, &a[9]);
6904   if (strcmp(a, "123456789000000000") != 0)
6905     return 1;
6906   return 0;
6907 }
6908 ]])],
6909 [have_glibc_memmove_bug=no],
6910 [have_glibc_memmove_bug=yes],
6911 [have_glibc_memmove_bug=undefined])
6912 CFLAGS="$saved_cflags"
6913 AC_MSG_RESULT([$have_glibc_memmove_bug])
6914 if test "$have_glibc_memmove_bug" = yes; then
6915     AC_DEFINE([HAVE_GLIBC_MEMMOVE_BUG], [1],
6916     [Define if glibc has incorrect _FORTIFY_SOURCE wrappers
6917      for memmove and bcopy.])
6918 fi
6919
6920 if test "$ac_cv_gcc_asm_for_x87" = yes; then
6921     # Some versions of gcc miscompile inline asm:
6922     # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=46491
6923     # http://gcc.gnu.org/ml/gcc/2010-11/msg00366.html
6924     case $CC in
6925         *gcc*)
6926             AC_MSG_CHECKING([for gcc ipa-pure-const bug])
6927             saved_cflags="$CFLAGS"
6928             CFLAGS="-O2"
6929             AC_RUN_IFELSE([AC_LANG_SOURCE([[
6930             __attribute__((noinline)) int
6931             foo(int *p) {
6932               int r;
6933               asm ( "movl \$6, (%1)\n\t"
6934                     "xorl %0, %0\n\t"
6935                     : "=r" (r) : "r" (p) : "memory"
6936               );
6937               return r;
6938             }
6939             int main(void) {
6940               int p = 8;
6941               if ((foo(&p) ? : p) != 6)
6942                 return 1;
6943               return 0;
6944             }
6945             ]])],
6946             [have_ipa_pure_const_bug=no],
6947             [have_ipa_pure_const_bug=yes],
6948             [have_ipa_pure_const_bug=undefined])
6949             CFLAGS="$saved_cflags"
6950             AC_MSG_RESULT([$have_ipa_pure_const_bug])
6951             if test "$have_ipa_pure_const_bug" = yes; then
6952                 AC_DEFINE([HAVE_IPA_PURE_CONST_BUG], [1],
6953                           [Define if gcc has the ipa-pure-const bug.])
6954             fi
6955         ;;
6956     esac
6957 fi
6958
6959 # ensurepip option
6960 AC_MSG_CHECKING([for ensurepip])
6961 AC_ARG_WITH([ensurepip],
6962     [AS_HELP_STRING([--with-ensurepip@<:@=install|upgrade|no@:>@],
6963         ["install" or "upgrade" using bundled pip (default is upgrade)])],
6964     [],
6965     [
6966       AS_CASE([$ac_sys_system],
6967         [Emscripten], [with_ensurepip=no],
6968         [WASI], [with_ensurepip=no],
6969         [iOS], [with_ensurepip=no],
6970         [with_ensurepip=upgrade]
6971       )
6972     ])
6973 AS_CASE([$with_ensurepip],
6974     [yes|upgrade],[ENSUREPIP=upgrade],
6975     [install],[ENSUREPIP=install],
6976     [no],[ENSUREPIP=no],
6977     [AC_MSG_ERROR([--with-ensurepip=upgrade|install|no])])
6978 AC_MSG_RESULT([$ENSUREPIP])
6979 AC_SUBST([ENSUREPIP])
6980
6981 # check if the dirent structure of a d_type field and DT_UNKNOWN is defined
6982 AC_CACHE_CHECK([if the dirent structure of a d_type field], [ac_cv_dirent_d_type], [
6983 AC_LINK_IFELSE(
6984 [
6985   AC_LANG_SOURCE([[
6986     #include <dirent.h>
6987
6988     int main(void) {
6989       struct dirent entry;
6990       return entry.d_type == DT_UNKNOWN;
6991     }
6992   ]])
6993 ],[ac_cv_dirent_d_type=yes],[ac_cv_dirent_d_type=no])
6994 ])
6995
6996 AS_VAR_IF([ac_cv_dirent_d_type], [yes], [
6997     AC_DEFINE([HAVE_DIRENT_D_TYPE], [1],
6998               [Define to 1 if the dirent structure has a d_type field])
6999 ])
7000
7001 # check if the Linux getrandom() syscall is available
7002 AC_CACHE_CHECK([for the Linux getrandom() syscall], [ac_cv_getrandom_syscall], [
7003 AC_LINK_IFELSE(
7004 [
7005   AC_LANG_SOURCE([[
7006     #include <stddef.h>
7007     #include <unistd.h>
7008     #include <sys/syscall.h>
7009     #include <linux/random.h>
7010
7011     int main(void) {
7012         char buffer[1];
7013         const size_t buflen = sizeof(buffer);
7014         const int flags = GRND_NONBLOCK;
7015         /* ignore the result, Python checks for ENOSYS and EAGAIN at runtime */
7016         (void)syscall(SYS_getrandom, buffer, buflen, flags);
7017         return 0;
7018     }
7019   ]])
7020 ],[ac_cv_getrandom_syscall=yes],[ac_cv_getrandom_syscall=no])
7021 ])
7022
7023 AS_VAR_IF([ac_cv_getrandom_syscall], [yes], [
7024     AC_DEFINE([HAVE_GETRANDOM_SYSCALL], [1],
7025               [Define to 1 if the Linux getrandom() syscall is available])
7026 ])
7027
7028 # check if the getrandom() function is available
7029 # the test was written for the Solaris function of <sys/random.h>
7030 AC_CACHE_CHECK([for the getrandom() function], [ac_cv_func_getrandom], [
7031 AC_LINK_IFELSE(
7032 [
7033   AC_LANG_SOURCE([[
7034     #include <stddef.h>
7035     #include <sys/random.h>
7036
7037     int main(void) {
7038         char buffer[1];
7039         const size_t buflen = sizeof(buffer);
7040         const int flags = 0;
7041         /* ignore the result, Python checks for ENOSYS at runtime */
7042         (void)getrandom(buffer, buflen, flags);
7043         return 0;
7044     }
7045   ]])
7046 ],[ac_cv_func_getrandom=yes],[ac_cv_func_getrandom=no])
7047 ])
7048
7049 AS_VAR_IF([ac_cv_func_getrandom], [yes], [
7050     AC_DEFINE([HAVE_GETRANDOM], [1],
7051               [Define to 1 if the getrandom() function is available])
7052 ])
7053
7054 # checks for POSIX shared memory, used by Modules/_multiprocessing/posixshmem.c
7055 # shm_* may only be available if linking against librt
7056 POSIXSHMEM_CFLAGS='-I$(srcdir)/Modules/_multiprocessing'
7057 WITH_SAVE_ENV([
7058   AC_SEARCH_LIBS([shm_open], [rt])
7059   AS_VAR_IF([ac_cv_search_shm_open], [-lrt], [POSIXSHMEM_LIBS="-lrt"])
7060
7061   dnl Temporarily override ac_includes_default for AC_CHECK_FUNCS below.
7062   _SAVE_VAR([ac_includes_default])
7063   ac_includes_default="\
7064   ${ac_includes_default}
7065   #ifndef __cplusplus
7066   #  ifdef HAVE_SYS_MMAN_H
7067   #    include <sys/mman.h>
7068   #  endif
7069   #endif
7070   "
7071   AC_CHECK_FUNCS([shm_open shm_unlink], [have_posix_shmem=yes], [have_posix_shmem=no])
7072   _RESTORE_VAR([ac_includes_default])
7073 ])
7074
7075 # Check for usable OpenSSL
7076 AX_CHECK_OPENSSL([have_openssl=yes],[have_openssl=no])
7077
7078 # rpath to libssl and libcrypto
7079 AS_VAR_IF([GNULD], [yes], [
7080   rpath_arg="-Wl,--enable-new-dtags,-rpath="
7081 ], [
7082   if test "$ac_sys_system" = "Darwin"
7083   then
7084      rpath_arg="-Wl,-rpath,"
7085   else
7086      rpath_arg="-Wl,-rpath="
7087   fi
7088 ])
7089
7090 AC_MSG_CHECKING([for --with-openssl-rpath])
7091 AC_ARG_WITH([openssl-rpath],
7092     AS_HELP_STRING([--with-openssl-rpath=@<:@DIR|auto|no@:>@],
7093                    [Set runtime library directory (rpath) for OpenSSL libraries,
7094                     no (default): don't set rpath,
7095                     auto: auto-detect rpath from --with-openssl and pkg-config,
7096                     DIR: set an explicit rpath
7097                    ]),
7098     [],
7099     [with_openssl_rpath=no]
7100 )
7101 AS_CASE([$with_openssl_rpath],
7102     [auto|yes], [
7103       OPENSSL_RPATH=auto
7104       dnl look for linker directories
7105       for arg in "$OPENSSL_LDFLAGS"; do
7106         AS_CASE([$arg],
7107           [-L*], [OPENSSL_LDFLAGS_RPATH="$OPENSSL_LDFLAGS_RPATH ${rpath_arg}$(echo $arg | cut -c3-)"]
7108         )
7109       done
7110     ],
7111     [no], [OPENSSL_RPATH=],
7112     [AS_IF(
7113         [test -d "$with_openssl_rpath"],
7114         [
7115           OPENSSL_RPATH="$with_openssl_rpath"
7116           OPENSSL_LDFLAGS_RPATH="${rpath_arg}$with_openssl_rpath"
7117         ],
7118         AC_MSG_ERROR([--with-openssl-rpath "$with_openssl_rpath" is not a directory]))
7119     ]
7120 )
7121 AC_MSG_RESULT([$OPENSSL_RPATH])
7122
7123 # This static linking is NOT OFFICIALLY SUPPORTED and not advertised.
7124 # Requires static OpenSSL build with position-independent code. Some features
7125 # like DSO engines or external OSSL providers don't work. Only tested with GCC
7126 # and clang on X86_64.
7127 AS_VAR_IF([PY_UNSUPPORTED_OPENSSL_BUILD], [static], [
7128   AC_MSG_CHECKING([for unsupported static openssl build])
7129   new_OPENSSL_LIBS=
7130   for arg in $OPENSSL_LIBS; do
7131     AS_CASE([$arg],
7132       [-l*], [
7133         libname=$(echo $arg | cut -c3-)
7134         new_OPENSSL_LIBS="$new_OPENSSL_LIBS -l:lib${libname}.a -Wl,--exclude-libs,lib${libname}.a"
7135       ],
7136       [new_OPENSSL_LIBS="$new_OPENSSL_LIBS $arg"]
7137     )
7138   done
7139   dnl include libz for OpenSSL build flavors with compression support
7140   OPENSSL_LIBS="$new_OPENSSL_LIBS $ZLIB_LIBS"
7141   AC_MSG_RESULT([$OPENSSL_LIBS])
7142 ])
7143
7144 dnl AX_CHECK_OPENSSL does not export libcrypto-only libs
7145 LIBCRYPTO_LIBS=
7146 for arg in $OPENSSL_LIBS; do
7147   AS_CASE([$arg],
7148     [-l*ssl*|-Wl*ssl*], [],
7149     [LIBCRYPTO_LIBS="$LIBCRYPTO_LIBS $arg"]
7150   )
7151 done
7152
7153 # check if OpenSSL libraries work as expected
7154 WITH_SAVE_ENV([
7155   LIBS="$LIBS $OPENSSL_LIBS"
7156   CFLAGS="$CFLAGS $OPENSSL_INCLUDES"
7157   LDFLAGS="$LDFLAGS $OPENSSL_LDFLAGS $OPENSSL_LDFLAGS_RPATH"
7158
7159   AC_CACHE_CHECK([whether OpenSSL provides required ssl module APIs], [ac_cv_working_openssl_ssl], [
7160     AC_LINK_IFELSE([AC_LANG_PROGRAM([
7161       #include <openssl/opensslv.h>
7162       #include <openssl/ssl.h>
7163       #if OPENSSL_VERSION_NUMBER < 0x10101000L
7164         #error "OpenSSL >= 1.1.1 is required"
7165       #endif
7166       static void keylog_cb(const SSL *ssl, const char *line) {}
7167     ], [
7168       SSL_CTX *ctx = SSL_CTX_new(TLS_client_method());
7169       SSL_CTX_set_keylog_callback(ctx, keylog_cb);
7170       SSL *ssl = SSL_new(ctx);
7171       X509_VERIFY_PARAM *param = SSL_get0_param(ssl);
7172       X509_VERIFY_PARAM_set1_host(param, "python.org", 0);
7173       SSL_free(ssl);
7174       SSL_CTX_free(ctx);
7175     ])], [ac_cv_working_openssl_ssl=yes], [ac_cv_working_openssl_ssl=no])
7176   ])
7177 ])
7178
7179 WITH_SAVE_ENV([
7180   LIBS="$LIBS $LIBCRYPTO_LIBS"
7181   CFLAGS="$CFLAGS $OPENSSL_INCLUDES"
7182   LDFLAGS="$LDFLAGS $OPENSSL_LDFLAGS $OPENSSL_LDFLAGS_RPATH"
7183
7184   AC_CACHE_CHECK([whether OpenSSL provides required hashlib module APIs], [ac_cv_working_openssl_hashlib], [
7185     AC_LINK_IFELSE([AC_LANG_PROGRAM([
7186       #include <openssl/opensslv.h>
7187       #include <openssl/evp.h>
7188       #if OPENSSL_VERSION_NUMBER < 0x10101000L
7189         #error "OpenSSL >= 1.1.1 is required"
7190       #endif
7191     ], [
7192       OBJ_nid2sn(NID_md5);
7193       OBJ_nid2sn(NID_sha1);
7194       OBJ_nid2sn(NID_sha3_512);
7195       OBJ_nid2sn(NID_blake2b512);
7196       EVP_PBE_scrypt(NULL, 0, NULL, 0, 2, 8, 1, 0, NULL, 0);
7197     ])], [ac_cv_working_openssl_hashlib=yes], [ac_cv_working_openssl_hashlib=no])
7198   ])
7199 ])
7200
7201 # ssl module default cipher suite string
7202 AH_TEMPLATE([PY_SSL_DEFAULT_CIPHERS],
7203   [Default cipher suites list for ssl module.
7204    1: Python's preferred selection, 2: leave OpenSSL defaults untouched, 0: custom string])
7205 AH_TEMPLATE([PY_SSL_DEFAULT_CIPHER_STRING],
7206   [Cipher suite string for PY_SSL_DEFAULT_CIPHERS=0]
7207 )
7208
7209 AC_MSG_CHECKING([for --with-ssl-default-suites])
7210 AC_ARG_WITH(
7211   [ssl-default-suites],
7212   [AS_HELP_STRING(
7213     [--with-ssl-default-suites=@<:@python|openssl|STRING@:>@],
7214     [override default cipher suites string,
7215      python: use Python's preferred selection (default),
7216      openssl: leave OpenSSL's defaults untouched,
7217      STRING: use a custom string,
7218      python and STRING also set TLS 1.2 as minimum TLS version]
7219   )],
7220 [
7221 AC_MSG_RESULT([$withval])
7222 case "$withval" in
7223     python)
7224         AC_DEFINE([PY_SSL_DEFAULT_CIPHERS], [1])
7225         ;;
7226     openssl)
7227         AC_DEFINE([PY_SSL_DEFAULT_CIPHERS], [2])
7228         ;;
7229     *)
7230         AC_DEFINE([PY_SSL_DEFAULT_CIPHERS], [0])
7231         AC_DEFINE_UNQUOTED([PY_SSL_DEFAULT_CIPHER_STRING], ["$withval"])
7232         ;;
7233 esac
7234 ],
7235 [
7236 AC_MSG_RESULT([python])
7237 AC_DEFINE([PY_SSL_DEFAULT_CIPHERS], [1])
7238 ])
7239
7240 # builtin hash modules
7241 default_hashlib_hashes="md5,sha1,sha2,sha3,blake2"
7242 AC_DEFINE([PY_BUILTIN_HASHLIB_HASHES], [], [enabled builtin hash modules]
7243 )
7244 AC_MSG_CHECKING([for --with-builtin-hashlib-hashes])
7245 AC_ARG_WITH(
7246   [builtin-hashlib-hashes],
7247   [AS_HELP_STRING(
7248     [--with-builtin-hashlib-hashes=md5,sha1,sha2,sha3,blake2],
7249     [builtin hash modules, md5, sha1, sha2, sha3 (with shake), blake2]
7250   )],
7251 [
7252   AS_CASE([$with_builtin_hashlib_hashes],
7253     [yes], [with_builtin_hashlib_hashes=$default_hashlib_hashes],
7254     [no], [with_builtin_hashlib_hashes=""]
7255   )
7256 ], [with_builtin_hashlib_hashes=$default_hashlib_hashes])
7257
7258 AC_MSG_RESULT([$with_builtin_hashlib_hashes])
7259 AC_DEFINE_UNQUOTED([PY_BUILTIN_HASHLIB_HASHES],
7260   ["$with_builtin_hashlib_hashes"])
7261
7262 as_save_IFS=$IFS
7263 IFS=,
7264 for builtin_hash in $with_builtin_hashlib_hashes; do
7265     AS_CASE([$builtin_hash],
7266       [md5], [with_builtin_md5=yes],
7267       [sha1], [with_builtin_sha1=yes],
7268       [sha2], [with_builtin_sha2=yes],
7269       [sha3], [with_builtin_sha3=yes],
7270       [blake2], [with_builtin_blake2=yes]
7271     )
7272 done
7273 IFS=$as_save_IFS
7274
7275 dnl libb2 for blake2. _blake2 module falls back to vendored copy.
7276 AS_VAR_IF([with_builtin_blake2], [yes], [
7277   PKG_CHECK_MODULES([LIBB2], [libb2], [
7278     have_libb2=yes
7279     AC_DEFINE([HAVE_LIBB2], [1],
7280               [Define to 1 if you want to build _blake2 module with libb2])
7281   ], [have_libb2=no])
7282 ])
7283
7284 # Check whether to disable test modules. Once set, setup.py will not build
7285 # test extension modules and "make install" will not install test suites.
7286 AC_MSG_CHECKING([for --disable-test-modules])
7287 AC_ARG_ENABLE([test-modules],
7288   [AS_HELP_STRING([--disable-test-modules], [don't build nor install test modules])], [
7289   AS_VAR_IF([enable_test_modules], [yes], [TEST_MODULES=yes], [TEST_MODULES=no])
7290 ], [
7291   AS_CASE([$ac_sys_system/$ac_sys_emscripten_target],
7292     [Emscripten/browser*], [TEST_MODULES=no],
7293     [TEST_MODULES=yes]
7294   )
7295 ])
7296 AC_MSG_RESULT([$TEST_MODULES])
7297 AC_SUBST([TEST_MODULES])
7298
7299 # gh-109054: Check if -latomic is needed to get <pyatomic.h> atomic functions.
7300 # On Linux aarch64, GCC may require programs and libraries to be linked
7301 # explicitly to libatomic. Call _Py_atomic_or_uint64() which may require
7302 # libatomic __atomic_fetch_or_8(), or not, depending on the C compiler and the
7303 # compiler flags.
7304 #
7305 # gh-112779: On RISC-V, GCC 12 and earlier require libatomic support for 1-byte
7306 # and 2-byte operations, but not for 8-byte operations.
7307 #
7308 # Avoid #include <Python.h> or #include <pyport.h>. The <Python.h> header
7309 # requires <pyconfig.h> header which is only written below by AC_OUTPUT below.
7310 # If the check is done after AC_OUTPUT, modifying LIBS has no effect
7311 # anymore.  <pyport.h> cannot be included alone, it's designed to be included
7312 # by <Python.h>: it expects other includes and macros to be defined.
7313 _SAVE_VAR([CPPFLAGS])
7314 CPPFLAGS="${BASECPPFLAGS} -I. -I${srcdir}/Include ${CPPFLAGS}"
7315
7316 AC_CACHE_CHECK([whether libatomic is needed by <pyatomic.h>],
7317                [ac_cv_libatomic_needed],
7318 [AC_RUN_IFELSE([AC_LANG_SOURCE([[
7319 // pyatomic.h needs uint64_t and Py_ssize_t types
7320 #include <stdint.h>  // int64_t, intptr_t
7321 #ifdef HAVE_SYS_TYPES_H
7322 #  include <sys/types.h> // ssize_t
7323 #endif
7324 // Code adapted from Include/pyport.h
7325 #if HAVE_SSIZE_T
7326 typedef ssize_t Py_ssize_t;
7327 #elif SIZEOF_VOID_P == SIZEOF_SIZE_T
7328 typedef intptr_t Py_ssize_t;
7329 #else
7330 #  error "unable to define Py_ssize_t"
7331 #endif
7332
7333 #include "pyatomic.h"
7334
7335 int main()
7336 {
7337     uint64_t value;
7338     _Py_atomic_store_uint64(&value, 2);
7339     if (_Py_atomic_or_uint64(&value, 8) != 2) {
7340         return 1; // error
7341     }
7342     if (_Py_atomic_load_uint64(&value) != 10) {
7343         return 1; // error
7344     }
7345     uint8_t byte = 0xb8;
7346     if (_Py_atomic_or_uint8(&byte, 0x2d) != 0xb8) {
7347         return 1; // error
7348     }
7349     if (_Py_atomic_load_uint8(&byte) != 0xbd) {
7350         return 1; // error
7351     }
7352     return 0; // all good
7353 }
7354 ]])],
7355   [ac_cv_libatomic_needed=no],  dnl build succeeded
7356   [ac_cv_libatomic_needed=yes], dnl build failed
7357   [ac_cv_libatomic_needed=no])  dnl cross compilation
7358 ])
7359
7360 AS_VAR_IF([ac_cv_libatomic_needed], [yes],
7361           [LIBS="${LIBS} -latomic"
7362            LIBATOMIC=${LIBATOMIC-"-latomic"}])
7363 _RESTORE_VAR([CPPFLAGS])
7364
7365
7366 # stdlib
7367 AC_DEFUN([PY_STDLIB_MOD_SET_NA], [
7368   m4_foreach([mod], [$@], [
7369     AS_VAR_SET([py_cv_module_]mod, [n/a])])
7370 ])
7371
7372 # stdlib not available
7373 dnl Modules that are not available on some platforms
7374 AS_CASE([$ac_sys_system],
7375   [AIX], [PY_STDLIB_MOD_SET_NA([_scproxy])],
7376   [VxWorks*], [PY_STDLIB_MOD_SET_NA([_scproxy], [termios], [grp])],
7377   dnl The _scproxy module is available on macOS
7378   [Darwin], [],
7379   [iOS], [
7380     dnl subprocess and multiprocessing are not supported (no fork syscall).
7381     dnl curses and tkinter user interface are not available.
7382     dnl gdbm and nis aren't available
7383     dnl Stub implementations are provided for pwd, grp etc APIs
7384     PY_STDLIB_MOD_SET_NA(
7385       [_curses],
7386       [_curses_panel],
7387       [_gdbm],
7388       [_multiprocessing],
7389       [_posixshmem],
7390       [_posixsubprocess],
7391       [_scproxy],
7392       [_tkinter],
7393       [grp],
7394       [nis],
7395       [readline],
7396       [pwd],
7397       [spwd],
7398       [syslog],
7399     )
7400   ],
7401   [CYGWIN*], [PY_STDLIB_MOD_SET_NA([_scproxy])],
7402   [QNX*], [PY_STDLIB_MOD_SET_NA([_scproxy])],
7403   [FreeBSD*], [PY_STDLIB_MOD_SET_NA([_scproxy])],
7404   [Emscripten|WASI], [
7405     dnl subprocess and multiprocessing are not supported (no fork syscall).
7406     dnl curses and tkinter user interface are not available.
7407     dnl dbm and gdbm aren't available, too.
7408     dnl Emscripten and WASI provide only stubs for pwd, grp APIs.
7409     dnl resource functions (get/setrusage) are stubs, too.
7410     PY_STDLIB_MOD_SET_NA(
7411       [_curses],
7412       [_curses_panel],
7413       [_dbm],
7414       [_gdbm],
7415       [_multiprocessing],
7416       [_posixshmem],
7417       [_posixsubprocess],
7418       [_scproxy],
7419       [_tkinter],
7420       [_xxsubinterpreters],
7421       [_xxinterpchannels],
7422       [_xxinterpqueues],
7423       [grp],
7424       [pwd],
7425       [resource],
7426       [syslog],
7427     )
7428     AS_CASE([$ac_sys_system/$ac_sys_emscripten_target],
7429       [Emscripten/browser*], [
7430         dnl These modules are not particularly useful in browsers.
7431         PY_STDLIB_MOD_SET_NA(
7432           [fcntl],
7433           [readline],
7434           [termios],
7435         )
7436       ],
7437       [Emscripten/node*], [],
7438       [WASI/*], [
7439         dnl WASI SDK 15.0 does not support file locking, mmap, and more.
7440         dnl Test modules that must be compiled as shared libraries are not supported
7441         dnl (see Modules/Setup.stdlib.in).
7442         PY_STDLIB_MOD_SET_NA(
7443           [_ctypes_test],
7444           [_testexternalinspection],
7445           [_testimportmultiple],
7446           [_testmultiphase],
7447           [_testsinglephase],
7448           [fcntl],
7449           [mmap],
7450           [termios],
7451           [xxlimited],
7452           [xxlimited_35],
7453         )
7454       ]
7455     )
7456   ],
7457   [PY_STDLIB_MOD_SET_NA([_scproxy])]
7458 )
7459
7460 dnl AC_MSG_NOTICE([m4_set_list([_PY_STDLIB_MOD_SET_NA])])
7461
7462 dnl Default value for Modules/Setup.stdlib build type
7463 AS_CASE([$host_cpu],
7464   [wasm32|wasm64], [MODULE_BUILDTYPE=static],
7465   [MODULE_BUILDTYPE=${MODULE_BUILDTYPE:-shared}]
7466 )
7467 AC_SUBST([MODULE_BUILDTYPE])
7468
7469 dnl _MODULE_BLOCK_ADD([VAR], [VALUE])
7470 dnl internal: adds $1=quote($2) to MODULE_BLOCK
7471 AC_DEFUN([_MODULE_BLOCK_ADD], [AS_VAR_APPEND([MODULE_BLOCK], ["$1=_AS_QUOTE([$2])$as_nl"])])
7472 MODULE_BLOCK=
7473
7474 dnl Check for stdlib extension modules
7475 dnl PY_STDLIB_MOD([NAME], [ENABLED-TEST], [SUPPORTED-TEST], [CFLAGS], [LDFLAGS])
7476 dnl sets MODULE_$NAME_STATE based on PY_STDLIB_MOD_SET_NA(), ENABLED-TEST,
7477 dnl and SUPPORTED_TEST. ENABLED-TEST and SUPPORTED-TEST default to true if
7478 dnl empty.
7479 dnl    n/a: marked unavailable on platform by PY_STDLIB_MOD_SET_NA()
7480 dnl    yes: enabled and supported
7481 dnl    missing: enabled and not supported
7482 dnl    disabled: not enabled
7483 dnl sets MODULE_$NAME_CFLAGS and MODULE_$NAME_LDFLAGS
7484 AC_DEFUN([PY_STDLIB_MOD], [
7485   AC_MSG_CHECKING([for stdlib extension module $1])
7486   m4_pushdef([modcond], [MODULE_]m4_toupper([$1]))dnl
7487   m4_pushdef([modstate], [py_cv_module_$1])dnl
7488   dnl Check if module has been disabled by PY_STDLIB_MOD_SET_NA()
7489   AS_IF([test "$modstate" != "n/a"], [
7490     AS_IF([m4_ifblank([$2], [true], [$2])],
7491        [AS_IF([m4_ifblank([$3], [true], [$3])], [modstate=yes], [modstate=missing])],
7492        [modstate=disabled])
7493   ])
7494   _MODULE_BLOCK_ADD(modcond[_STATE], [$modstate])
7495   AS_VAR_IF([modstate], [yes], [
7496     m4_ifblank([$4], [], [_MODULE_BLOCK_ADD([MODULE_]m4_toupper([$1])[_CFLAGS], [$4])])
7497     m4_ifblank([$5], [], [_MODULE_BLOCK_ADD([MODULE_]m4_toupper([$1])[_LDFLAGS], [$5])])
7498   ])
7499   AM_CONDITIONAL(modcond, [test "$modstate" = yes])
7500   AC_MSG_RESULT([$modstate])
7501   m4_popdef([modcond])dnl
7502   m4_popdef([modstate])dnl
7503 ])
7504
7505 dnl Define simple stdlib extension module
7506 dnl Always enable unless the module is disabled by PY_STDLIB_MOD_SET_NA
7507 dnl PY_STDLIB_MOD_SIMPLE([NAME], [CFLAGS], [LDFLAGS])
7508 dnl cflags and ldflags are optional
7509 AC_DEFUN([PY_STDLIB_MOD_SIMPLE], [
7510   m4_pushdef([modcond], [MODULE_]m4_toupper([$1]))dnl
7511   m4_pushdef([modstate], [py_cv_module_$1])dnl
7512   dnl Check if module has been disabled by PY_STDLIB_MOD_SET_NA()
7513   AS_IF([test "$modstate" != "n/a"], [modstate=yes])
7514   AM_CONDITIONAL(modcond, [test "$modstate" = yes])
7515   _MODULE_BLOCK_ADD(modcond[_STATE], [$modstate])
7516   AS_VAR_IF([modstate], [yes], [
7517     m4_ifblank([$2], [], [_MODULE_BLOCK_ADD([MODULE_]m4_toupper([$1])[_CFLAGS], [$2])])
7518     m4_ifblank([$3], [], [_MODULE_BLOCK_ADD([MODULE_]m4_toupper([$1])[_LDFLAGS], [$3])])
7519   ])
7520   m4_popdef([modcond])dnl
7521   m4_popdef([modstate])dnl
7522 ])
7523
7524 dnl static modules in Modules/Setup.bootstrap
7525 PY_STDLIB_MOD_SIMPLE([_io], [-I\$(srcdir)/Modules/_io], [])
7526 PY_STDLIB_MOD_SIMPLE([time], [], [$TIMEMODULE_LIB])
7527
7528 dnl always enabled extension modules
7529 PY_STDLIB_MOD_SIMPLE([array])
7530 PY_STDLIB_MOD_SIMPLE([_asyncio])
7531 PY_STDLIB_MOD_SIMPLE([_bisect])
7532 PY_STDLIB_MOD_SIMPLE([_contextvars])
7533 PY_STDLIB_MOD_SIMPLE([_csv])
7534 PY_STDLIB_MOD_SIMPLE([_heapq])
7535 PY_STDLIB_MOD_SIMPLE([_json])
7536 PY_STDLIB_MOD_SIMPLE([_lsprof])
7537 PY_STDLIB_MOD_SIMPLE([_opcode])
7538 PY_STDLIB_MOD_SIMPLE([_pickle])
7539 PY_STDLIB_MOD_SIMPLE([_posixsubprocess])
7540 PY_STDLIB_MOD_SIMPLE([_queue])
7541 PY_STDLIB_MOD_SIMPLE([_random])
7542 PY_STDLIB_MOD_SIMPLE([select])
7543 PY_STDLIB_MOD_SIMPLE([_struct])
7544 PY_STDLIB_MOD_SIMPLE([_typing])
7545 PY_STDLIB_MOD_SIMPLE([_xxsubinterpreters])
7546 PY_STDLIB_MOD_SIMPLE([_xxinterpchannels])
7547 PY_STDLIB_MOD_SIMPLE([_xxinterpqueues])
7548 PY_STDLIB_MOD_SIMPLE([_zoneinfo])
7549
7550 dnl multiprocessing modules
7551 PY_STDLIB_MOD([_multiprocessing],
7552   [], [test "$ac_cv_func_sem_unlink" = "yes"],
7553   [-I\$(srcdir)/Modules/_multiprocessing])
7554 PY_STDLIB_MOD([_posixshmem],
7555   [], [test "$have_posix_shmem" = "yes"],
7556   [$POSIXSHMEM_CFLAGS], [$POSIXSHMEM_LIBS])
7557
7558 dnl needs libm
7559 PY_STDLIB_MOD_SIMPLE([_statistics], [], [$LIBM])
7560 PY_STDLIB_MOD_SIMPLE([cmath], [], [$LIBM])
7561 PY_STDLIB_MOD_SIMPLE([math], [], [$LIBM])
7562
7563 dnl needs libm and on some platforms librt
7564 PY_STDLIB_MOD_SIMPLE([_datetime], [], [$TIMEMODULE_LIB $LIBM])
7565
7566 dnl modules with some unix dependencies
7567 PY_STDLIB_MOD([fcntl],
7568   [], [test "$ac_cv_header_sys_ioctl_h" = "yes" -a "$ac_cv_header_fcntl_h" = "yes"],
7569   [], [$FCNTL_LIBS])
7570 PY_STDLIB_MOD([mmap],
7571   [], [test "$ac_cv_header_sys_mman_h" = "yes" -a "$ac_cv_header_sys_stat_h" = "yes"])
7572 PY_STDLIB_MOD([_socket],
7573   [], m4_flatten([test "$ac_cv_header_sys_socket_h" = "yes"
7574                     -a "$ac_cv_header_sys_types_h" = "yes"
7575                     -a "$ac_cv_header_netinet_in_h" = "yes"]))
7576
7577 dnl platform specific extensions
7578 PY_STDLIB_MOD([grp], [],
7579   [test "$ac_cv_func_getgrent" = "yes" &&
7580    { test "$ac_cv_func_getgrgid" = "yes" || test "$ac_cv_func_getgrgid_r" = "yes"; }])
7581 PY_STDLIB_MOD([pwd], [], [test "$ac_cv_func_getpwuid" = yes -o "$ac_cv_func_getpwuid_r" = yes])
7582 PY_STDLIB_MOD([resource], [], [test "$ac_cv_header_sys_resource_h" = yes])
7583 PY_STDLIB_MOD([_scproxy],
7584   [test "$ac_sys_system" = "Darwin"], [],
7585   [], [-framework SystemConfiguration -framework CoreFoundation])
7586 PY_STDLIB_MOD([syslog], [], [test "$ac_cv_header_syslog_h" = yes])
7587 PY_STDLIB_MOD([termios], [], [test "$ac_cv_header_termios_h" = yes])
7588
7589 dnl _elementtree loads libexpat via CAPI hook in pyexpat
7590 PY_STDLIB_MOD([pyexpat],
7591   [], [test "$ac_cv_header_sys_time_h" = "yes"],
7592   [$LIBEXPAT_CFLAGS], [$LIBEXPAT_LDFLAGS])
7593 PY_STDLIB_MOD([_elementtree], [], [], [$LIBEXPAT_CFLAGS], [])
7594 PY_STDLIB_MOD_SIMPLE([_codecs_cn])
7595 PY_STDLIB_MOD_SIMPLE([_codecs_hk])
7596 PY_STDLIB_MOD_SIMPLE([_codecs_iso2022])
7597 PY_STDLIB_MOD_SIMPLE([_codecs_jp])
7598 PY_STDLIB_MOD_SIMPLE([_codecs_kr])
7599 PY_STDLIB_MOD_SIMPLE([_codecs_tw])
7600 PY_STDLIB_MOD_SIMPLE([_multibytecodec])
7601 PY_STDLIB_MOD_SIMPLE([unicodedata])
7602
7603 dnl By default we always compile these even when OpenSSL is available
7604 dnl (issue #14693). The modules are small.
7605 PY_STDLIB_MOD([_md5],
7606   [test "$with_builtin_md5" = yes], [],
7607   [-I\$(srcdir)/Modules/_hacl/include -I\$(srcdir)/Modules/_hacl/internal -D_BSD_SOURCE -D_DEFAULT_SOURCE])
7608 PY_STDLIB_MOD([_sha1],
7609   [test "$with_builtin_sha1" = yes], [],
7610   [-I\$(srcdir)/Modules/_hacl/include -I\$(srcdir)/Modules/_hacl/internal -D_BSD_SOURCE -D_DEFAULT_SOURCE])
7611 PY_STDLIB_MOD([_sha2],
7612   [test "$with_builtin_sha2" = yes], [],
7613   [-I\$(srcdir)/Modules/_hacl/include -I\$(srcdir)/Modules/_hacl/internal -D_BSD_SOURCE -D_DEFAULT_SOURCE])
7614 PY_STDLIB_MOD([_sha3], [test "$with_builtin_sha3" = yes])
7615 PY_STDLIB_MOD([_blake2],
7616   [test "$with_builtin_blake2" = yes], [],
7617   [$LIBB2_CFLAGS], [$LIBB2_LIBS])
7618
7619 PY_STDLIB_MOD([_ctypes],
7620   [], [test "$have_libffi" = yes],
7621   [$NO_STRICT_OVERFLOW_CFLAGS $LIBFFI_CFLAGS], [$LIBFFI_LIBS])
7622 PY_STDLIB_MOD([_curses],
7623   [], [test "$have_curses" != "no"],
7624   [$CURSES_CFLAGS], [$CURSES_LIBS]
7625 )
7626 PY_STDLIB_MOD([_curses_panel],
7627   [], [test "$have_panel" != "no"],
7628   [$PANEL_CFLAGS $CURSES_CFLAGS], [$PANEL_LIBS $CURSES_LIBS]
7629 )
7630 PY_STDLIB_MOD([_decimal], [], [], [$LIBMPDEC_CFLAGS], [$LIBMPDEC_LDFLAGS])
7631 PY_STDLIB_MOD([_dbm],
7632   [test -n "$with_dbmliborder"], [test "$have_dbm" != "no"],
7633   [$DBM_CFLAGS], [$DBM_LIBS])
7634 PY_STDLIB_MOD([_gdbm],
7635   [test "$have_gdbm_dbmliborder" = yes], [test "$have_gdbm" = yes],
7636   [$GDBM_CFLAGS], [$GDBM_LIBS])
7637  PY_STDLIB_MOD([readline],
7638   [], [test "$with_readline" != "no"],
7639   [$READLINE_CFLAGS], [$READLINE_LIBS])
7640 PY_STDLIB_MOD([_sqlite3],
7641   [test "$have_sqlite3" = "yes"],
7642   [test "$have_supported_sqlite3" = "yes"],
7643   [$LIBSQLITE3_CFLAGS], [$LIBSQLITE3_LIBS])
7644 PY_STDLIB_MOD([_tkinter],
7645   [], [test "$have_tcltk" = "yes"],
7646   [$TCLTK_CFLAGS], [$TCLTK_LIBS])
7647 PY_STDLIB_MOD([_uuid],
7648   [], [test "$have_uuid" = "yes"],
7649   [$LIBUUID_CFLAGS], [$LIBUUID_LIBS])
7650
7651 dnl compression libs
7652 PY_STDLIB_MOD([zlib], [], [test "$have_zlib" = yes],
7653   [$ZLIB_CFLAGS], [$ZLIB_LIBS])
7654 dnl binascii can use zlib for optimized crc32.
7655 PY_STDLIB_MOD_SIMPLE([binascii], [$BINASCII_CFLAGS], [$BINASCII_LIBS])
7656 PY_STDLIB_MOD([_bz2], [], [test "$have_bzip2" = yes],
7657   [$BZIP2_CFLAGS], [$BZIP2_LIBS])
7658 PY_STDLIB_MOD([_lzma], [], [test "$have_liblzma" = yes],
7659   [$LIBLZMA_CFLAGS], [$LIBLZMA_LIBS])
7660
7661 dnl OpenSSL bindings
7662 PY_STDLIB_MOD([_ssl], [], [test "$ac_cv_working_openssl_ssl" = yes],
7663   [$OPENSSL_INCLUDES], [$OPENSSL_LDFLAGS $OPENSSL_LDFLAGS_RPATH $OPENSSL_LIBS])
7664 PY_STDLIB_MOD([_hashlib], [], [test "$ac_cv_working_openssl_hashlib" = yes],
7665   [$OPENSSL_INCLUDES], [$OPENSSL_LDFLAGS $OPENSSL_LDFLAGS_RPATH $LIBCRYPTO_LIBS])
7666
7667 dnl test modules
7668 PY_STDLIB_MOD([_testcapi],
7669     [test "$TEST_MODULES" = yes],
7670     dnl Modules/_testcapi needs -latomic for 32bit AIX build
7671     [], [], [$LIBATOMIC])
7672 PY_STDLIB_MOD([_testclinic], [test "$TEST_MODULES" = yes])
7673 PY_STDLIB_MOD([_testclinic_limited], [test "$TEST_MODULES" = yes])
7674 PY_STDLIB_MOD([_testlimitedcapi], [test "$TEST_MODULES" = yes])
7675 PY_STDLIB_MOD([_testinternalcapi], [test "$TEST_MODULES" = yes])
7676 PY_STDLIB_MOD([_testbuffer], [test "$TEST_MODULES" = yes])
7677 PY_STDLIB_MOD([_testimportmultiple], [test "$TEST_MODULES" = yes], [test "$ac_cv_func_dlopen" = yes])
7678 PY_STDLIB_MOD([_testmultiphase], [test "$TEST_MODULES" = yes], [test "$ac_cv_func_dlopen" = yes])
7679 PY_STDLIB_MOD([_testsinglephase], [test "$TEST_MODULES" = yes], [test "$ac_cv_func_dlopen" = yes])
7680 PY_STDLIB_MOD([_testexternalinspection], [test "$TEST_MODULES" = yes])
7681 PY_STDLIB_MOD([xxsubtype], [test "$TEST_MODULES" = yes])
7682 PY_STDLIB_MOD([_xxtestfuzz], [test "$TEST_MODULES" = yes])
7683 PY_STDLIB_MOD([_ctypes_test],
7684   [test "$TEST_MODULES" = yes], [test "$have_libffi" = yes -a "$ac_cv_func_dlopen" = yes],
7685   [], [$LIBM])
7686
7687 dnl Limited API template modules.
7688 dnl Emscripten does not support shared libraries yet.
7689 PY_STDLIB_MOD([xxlimited], [test "$TEST_MODULES" = yes], [test "$ac_cv_func_dlopen" = yes])
7690 PY_STDLIB_MOD([xxlimited_35], [test "$TEST_MODULES" = yes], [test "$ac_cv_func_dlopen" = yes])
7691
7692 # substitute multiline block, must come after last PY_STDLIB_MOD()
7693 AC_SUBST([MODULE_BLOCK])
7694
7695 # generate output files
7696 AC_CONFIG_FILES(m4_normalize([
7697   Makefile.pre
7698   Misc/python.pc
7699   Misc/python-embed.pc
7700   Misc/python-config.sh
7701 ]))
7702 AC_CONFIG_FILES(m4_normalize([
7703   Modules/Setup.bootstrap
7704   Modules/Setup.stdlib
7705 ]))
7706 AC_CONFIG_FILES([Modules/ld_so_aix], [chmod +x Modules/ld_so_aix])
7707 # Generate files like pyconfig.h
7708 AC_OUTPUT
7709
7710 AC_MSG_NOTICE([creating Modules/Setup.local])
7711 if test ! -f Modules/Setup.local
7712 then
7713         echo "# Edit this file for local setup changes" >Modules/Setup.local
7714 fi
7715
7716 AC_MSG_NOTICE([creating Makefile])
7717 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
7718                         -s Modules \
7719                         Modules/Setup.local Modules/Setup.stdlib Modules/Setup.bootstrap $srcdir/Modules/Setup
7720 if test $? -ne 0; then
7721   AC_MSG_ERROR([makesetup failed])
7722 fi
7723
7724 mv config.c Modules
7725
7726 if test -z "$PKG_CONFIG"; then
7727   AC_MSG_WARN([pkg-config is missing. Some dependencies may not be detected correctly.])
7728 fi
7729
7730 if test "$Py_OPT" = 'false' -a "$Py_DEBUG" != 'true'; then
7731   AC_MSG_NOTICE([
7732
7733 If you want a release build with all stable optimizations active (PGO, etc),
7734 please run ./configure --enable-optimizations
7735 ])
7736 fi
7737
7738 AS_VAR_IF([PY_SUPPORT_TIER], [0], [AC_MSG_WARN([
7739
7740 Platform "$host" with compiler "$ac_cv_cc_name" is not supported by the
7741 CPython core team, see https://peps.python.org/pep-0011/ for more information.
7742 ])])
7743
7744 if test "$ac_cv_header_stdatomic_h" != "yes"; then
7745   AC_MSG_NOTICE(m4_normalize([
7746     Your compiler or platform does have a working C11 stdatomic.h. A future
7747     version of Python may require stdatomic.h.
7748   ]))
7749 fi