dnl Process this file with autoconf to produce a configure script.

AC_PREREQ([2.63])

AC_INIT

AC_CONFIG_SRCDIR([src/SDL.c])

AC_CONFIG_HEADERS([include/SDL_config.h])

AC_CONFIG_AUX_DIR([build-scripts])

AC_CONFIG_MACRO_DIR([acinclude])

dnl Save the CFLAGS to see whether they were passed in or generated

orig_CFLAGS="$CFLAGS"

dnl Set various version strings - taken gratefully from the GTk sources

# See docs/release_checklist.md

SDL_MAJOR_VERSION=2

SDL_MINOR_VERSION=27

SDL_MICRO_VERSION=1

SDL_VERSION=$SDL_MAJOR_VERSION.$SDL_MINOR_VERSION.$SDL_MICRO_VERSION

SDL_BINARY_AGE=`expr $SDL_MINOR_VERSION \* 100 + $SDL_MICRO_VERSION`

AS_CASE(["$SDL_MINOR_VERSION"],

[*@<:@02468@:>@],

dnl Stable branch, 2.24.1 -> libSDL2-2.0.so.0.2400.1

[SDL_INTERFACE_AGE="$SDL_MICRO_VERSION"],

[*],

dnl Development branch, 2.23.1 -> libSDL2-2.0.so.0.2301.0

[SDL_INTERFACE_AGE=0])

AC_SUBST(SDL_MAJOR_VERSION)

AC_SUBST(SDL_MINOR_VERSION)

AC_SUBST(SDL_MICRO_VERSION)

AC_SUBST(SDL_INTERFACE_AGE)

AC_SUBST(SDL_BINARY_AGE)

AC_SUBST(SDL_VERSION)

# libtool versioning

LT_INIT([win32-dll])

LT_LANG([Windows Resource])

# For historical reasons, the library name redundantly includes the major

# version twice: libSDL2-2.0.so.0.

# TODO: in SDL 3, stop using -release, which will simplify it to libSDL3.so.0

LT_RELEASE=2.0

# Increment this if there is an incompatible change - but if that happens,

# we should rename the library from SDL2 to SDL3, at which point this would

# reset to 0 anyway.

LT_MAJOR=0

LT_AGE=`expr $SDL_BINARY_AGE - $SDL_INTERFACE_AGE`

LT_CURRENT=`expr $LT_MAJOR + $LT_AGE`

LT_REVISION=$SDL_INTERFACE_AGE

m4_pattern_allow([^LT_])

AC_SUBST(LT_RELEASE)

AC_SUBST(LT_CURRENT)

AC_SUBST(LT_REVISION)

AC_SUBST(LT_AGE)

dnl Detect the canonical build and host environments

dnl AC_CANONICAL_HOST

dnl Check for tools

AC_PROG_AWK

AC_PROG_CC

AC_PROG_CXX

AC_PROG_EGREP

AC_PROG_FGREP

AC_PROG_INSTALL

AC_PROG_MAKE_SET

PKG_PROG_PKG_CONFIG

if [ test -z "$AWK" ]; then

AC_MSG_ERROR([*** awk not found, aborting])

fi

AC_CHECK_PROGS([SORT], [gsort sort], [false])

AS_IF([! "$SORT" -V </dev/null >/dev/null], [AC_MSG_WARN([sort(1) that supports the -V option is required to find dynamic libraries])])

dnl 64-bit file offsets if possible unless --disable-largefile is specified

AC_SYS_LARGEFILE

dnl Make sure that srcdir is a full pathname

case "$host" in

*-*-mingw*)

# Except on msys, where make can't handle full pathnames (bug 1972)

;;

*)

srcdir=`cd $srcdir && pwd`

;;

esac

dnl Set up the compiler and linker flags

INCLUDE="-I$srcdir/include"

dnl Don't use our khronos headers on QNX.

case "$host" in

*-*-nto-qnx*)

;;

*)

INCLUDE="$INCLUDE -idirafter $srcdir/src/video/khronos"

;;

esac

dnl use CXX for linker on Haiku

case "$host" in

*-*-haiku*)

LINKER='$(CXX)'

LIBTOOLLINKERTAG='CXX'

;;

*)

LINKER='$(CC)'

LIBTOOLLINKERTAG='CC'

;;

esac

AC_SUBST(LINKER)

AC_SUBST(LIBTOOLLINKERTAG)

if test x$srcdir != x.; then

INCLUDE="-Iinclude $INCLUDE"

elif test -d .git; then

AC_MSG_ERROR([

*** When building from a git clone you should configure and build in a

separate directory so you don't clobber SDL_config.h, SDL_revision.h

])

fi

BASE_CFLAGS=""

BASE_LDFLAGS=""

case "$host" in

*-*-cygwin*)

# We build SDL on cygwin without the UNIX emulation layer

save_CFLAGS="$CFLAGS"

have_no_cygwin=no

AC_MSG_CHECKING(for GCC -mno-cygwin option)

CFLAGS="$save_CFLAGS -mno-cygwin"

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[])], [have_no_cygwin=yes],[])

AC_MSG_RESULT($have_no_cygwin)

CFLAGS="$save_CFLAGS"

if test x$have_no_cygwin = xyes; then

BASE_CFLAGS="-mno-cygwin"

BASE_LDFLAGS="-mno-cygwin"

fi

BASE_CFLAGS="$BASE_CFLAGS -I/usr/include/mingw"

;;

esac

# Uncomment the following line if you want to force SDL and applications

# built with it to be compiled for a particular architecture.

#AX_GCC_ARCHFLAG([no], [BASE_CFLAGS="$BASE_CFLAGS $ax_cv_gcc_archflag]")

BUILD_CFLAGS="$CFLAGS $CPPFLAGS -DUSING_GENERATED_CONFIG_H"

# The default optimization for SDL is -O3 (Bug #31)

if test "x$orig_CFLAGS" = x; then

BUILD_CFLAGS=`echo $BUILD_CFLAGS | sed 's/-O2/-O3/'`

fi

EXTRA_CFLAGS="$INCLUDE $BASE_CFLAGS"

BUILD_LDFLAGS="$LDFLAGS"

EXTRA_LDFLAGS="$BASE_LDFLAGS"

## These are common directories to find software packages

#for path in /usr/freeware /usr/pkg /usr/X11R6 /usr/local; do

# if test -d $path/include; then

# EXTRA_CFLAGS="$EXTRA_CFLAGS -I$path/include"

# fi

# if test -d $path/lib; then

# EXTRA_LDFLAGS="$EXTRA_LDFLAGS -L$path/lib"

# fi

#done

SDL_CFLAGS="$BASE_CFLAGS"

SDL_LIBS="-lSDL2"

if test "x$BASE_LDFLAGS" != x; then

SDL_LIBS="$SDL_LIBS $BASE_LDFLAGS"

fi

if test "x$EXTRA_CFLAGS" != x; then

CPPFLAGS="$CPPFLAGS $EXTRA_CFLAGS"

CFLAGS="$CFLAGS $EXTRA_CFLAGS"

fi

if test "x$EXTRA_LDFLAGS" != x; then

LDFLAGS="$LDFLAGS $EXTRA_LDFLAGS"

fi

dnl set this to use on systems that use lib64 instead of lib

base_libdir=`echo \${libdir} | sed 's/.*\/\(.*\)/\1/; q'`

dnl Function to find a library in the compiler search path

find_lib()

{

gcc_bin_path=[`$CC -print-search-dirs 2>/dev/null | $FGREP programs: | sed 's/[^=]*=\(.*\)/\1/' | sed 's/:/ /g'`]

gcc_lib_path=[`$CC -print-search-dirs 2>/dev/null | $FGREP libraries: | sed 's/[^=]*=\(.*\)/\1/' | sed 's/:/ /g'`]

env_lib_path=[`echo $LIBS $LDFLAGS $* | sed 's/-L[ ]*//g'`]

if test "$cross_compiling" = yes; then

host_lib_path=""

else

host_lib_path="/usr/$base_libdir /usr/local/$base_libdir"

fi

for path in $env_lib_path $gcc_bin_path $gcc_lib_path $host_lib_path; do

lib=[`ls -- $path/$1 2>/dev/null | sed 's,.*/,,' | "$SORT" -V -r | $AWK 'BEGIN{FS="."}{ print NF, $0 }' | "$SORT" -n -s | sed 's,[0-9]* ,,' | head -1`]

if test x$lib != x; then

echo $lib

return

fi

done

}

dnl Check for compiler characteristics

AC_C_CONST

AC_C_INLINE

AC_C_VOLATILE

dnl See whether we want assertions for debugging/sanity checking SDL itself.

AC_ARG_ENABLE(assertions,

[AS_HELP_STRING([--enable-assertions],

[Enable internal sanity checks (auto/disabled/release/enabled/paranoid) [default=auto]])],

, enable_assertions=auto)

case "$enable_assertions" in

auto) # Use optimization settings to determine assertion level

;;

disabled)

AC_DEFINE(SDL_DEFAULT_ASSERT_LEVEL, 0, [ ])

;;

release)

AC_DEFINE(SDL_DEFAULT_ASSERT_LEVEL, 1, [ ])

;;

enabled)

AC_DEFINE(SDL_DEFAULT_ASSERT_LEVEL, 2, [ ])

;;

paranoid)

AC_DEFINE(SDL_DEFAULT_ASSERT_LEVEL, 3, [ ])

;;

*)

AC_MSG_ERROR([*** unknown assertion level. stop.])

;;

esac

dnl For use in static assertions

EXTRA_CFLAGS="$EXTRA_CFLAGS -DSDL_BUILD_MAJOR_VERSION=$SDL_MAJOR_VERSION -DSDL_BUILD_MINOR_VERSION=$SDL_MINOR_VERSION -DSDL_BUILD_MICRO_VERSION=$SDL_MICRO_VERSION"

dnl See whether we can use gcc style dependency tracking

AC_ARG_ENABLE(dependency-tracking,

[AS_HELP_STRING([--enable-dependency-tracking],

[Use gcc -MMD -MT dependency tracking [default=yes]])],

, enable_dependency_tracking=yes)

if test x$enable_dependency_tracking = xyes; then

have_gcc_mmd_mt=no

AC_MSG_CHECKING(for GCC -MMD -MT option)

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[

#if !defined(__GNUC__) || __GNUC__ < 3

#error Dependency tracking requires GCC 3.0 or newer

#endif

]],[])], [have_gcc_mmd_mt=yes],[])

AC_MSG_RESULT($have_gcc_mmd_mt)

if test x$have_gcc_mmd_mt = xyes; then

DEPENDENCY_TRACKING_OPTIONS="-MMD -MT \$@"

fi

fi

AC_MSG_CHECKING(for linker option --no-undefined)

have_no_undefined=no

case "$host" in

dnl Skip this on platforms where it is just simply busted.

*-*-openbsd*)

;;

*)

save_LDFLAGS="$LDFLAGS"

LDFLAGS="$LDFLAGS -Wl,--no-undefined"

AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], [

have_no_undefined=yes

BUILD_LDFLAGS="$BUILD_LDFLAGS -Wl,--no-undefined"

],[])

LDFLAGS="$save_LDFLAGS"

;;

esac

AC_MSG_RESULT($have_no_undefined)

AC_MSG_CHECKING(for linker option --dynamicbase)

have_dynamicbase=no

case "$host" in

*)

save_LDFLAGS="$LDFLAGS"

LDFLAGS="$LDFLAGS -Wl,--dynamicbase"

AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], [

have_dynamicbase=yes

EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,--dynamicbase"

],[])

LDFLAGS="$save_LDFLAGS"

;;

esac

AC_MSG_RESULT($have_dynamicbase)

AC_MSG_CHECKING(for linker option --nxcompat)

have_nxcompat=no

case "$host" in

*)

save_LDFLAGS="$LDFLAGS"

LDFLAGS="$LDFLAGS -Wl,--nxcompat"

AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], [

have_nxcompat=yes

EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,--nxcompat"

],[])

LDFLAGS="$save_LDFLAGS"

;;

esac

AC_MSG_RESULT($have_nxcompat)

AC_MSG_CHECKING(for linker option --high-entropy-va)

have_high_entropy_va=no

case "$host" in

*)

save_LDFLAGS="$LDFLAGS"

LDFLAGS="$LDFLAGS -Wl,--high-entropy-va"

AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], [

have_high_entropy_va=yes

EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,--high-entropy-va"

],[])

LDFLAGS="$save_LDFLAGS"

;;

esac

AC_MSG_RESULT($have_high_entropy_va)

dnl See whether we are allowed to use the system C library

AC_ARG_ENABLE(libc,

[AS_HELP_STRING([--enable-libc], [Use the system C library [default=yes]])],

, enable_libc=yes)

dnl See whether we are allowed to use libiconv

AC_ARG_ENABLE(system-iconv,

[AS_HELP_STRING([--enable-system-iconv], [Use iconv() from system-installed libraries [default=yes]])],

, enable_system_iconv=yes)

if test x$enable_libc = xyes; then

AC_DEFINE(HAVE_LIBC, 1, [ ])

dnl Check for C library headers

dnl AC_CHECK_INCLUDES_DEFAULT is an autoconf-2.7x thing where AC_HEADER_STDC is deprecated.

m4_ifdef([AC_CHECK_INCLUDES_DEFAULT], [AC_CHECK_INCLUDES_DEFAULT], [AC_HEADER_STDC])

AC_CHECK_HEADERS(sys/types.h stdio.h stdlib.h stddef.h stdarg.h malloc.h memory.h string.h strings.h wchar.h inttypes.h stdint.h limits.h ctype.h math.h float.h iconv.h signal.h linux/input.h)

dnl Check for typedefs, structures, etc.

AC_TYPE_SIZE_T

dnl Check for defines

AC_CHECK_DEFINE(M_PI, math.h)

AC_FUNC_ALLOCA

dnl Checks for library functions.

AC_CHECK_FUNC(mprotect,

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[

#include <sys/types.h>

#include <sys/mman.h>

]],[])], [

AC_DEFINE(HAVE_MPROTECT, 1, [ ])

],[]),

)

AC_CHECK_FUNCS(malloc calloc realloc free getenv setenv putenv unsetenv bsearch qsort abs bcopy memset memcmp memcpy memmove wcslen wcslcpy wcslcat _wcsdup wcsdup wcsstr wcscmp wcsncmp wcscasecmp _wcsicmp wcsncasecmp _wcsnicmp strlen strlcpy strlcat _strrev _strupr _strlwr index rindex strchr strrchr strstr strtok_r itoa _ltoa _uitoa _ultoa strtod strtol strtoul _i64toa _ui64toa strtoll strtoull atoi atof strcmp strncmp _stricmp strcasecmp _strnicmp strncasecmp strcasestr vsscanf vsnprintf fopen64 fseeko fseeko64 sigaction setjmp nanosleep sysconf sysctlbyname getauxval elf_aux_info poll _Exit)

AC_CHECK_LIB(m, pow, [LIBS="$LIBS -lm"; EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lm"])

AC_CHECK_FUNCS(acos acosf asin asinf atan atanf atan2 atan2f ceil ceilf copysign copysignf cos cosf exp expf fabs fabsf floor floorf trunc truncf fmod fmodf log logf log10 log10f lround lroundf pow powf round roundf scalbn scalbnf sin sinf sqrt sqrtf tan tanf)

if test x$enable_system_iconv = xyes; then

AC_CHECK_LIB(iconv, iconv_open, [LIBS="$LIBS -liconv"; EXTRA_LDFLAGS="$EXTRA_LDFLAGS -liconv"])

AC_CHECK_FUNCS(iconv)

fi

AC_CHECK_MEMBER(struct sigaction.sa_sigaction,[AC_DEFINE([HAVE_SA_SIGACTION], 1, [ ])], ,[#include <signal.h>])

dnl Check for additional non-standard headers

AC_CHECK_HEADERS(libunwind.h)

fi

dnl AC_CHECK_SIZEOF(void*)

dnl See whether we can use gcc atomic operations on this architecture

AC_ARG_ENABLE(gcc-atomics,

[AS_HELP_STRING([--enable-gcc-atomics],

[Use gcc builtin atomics [default=yes]])],

, enable_gcc_atomics=yes)

if test x$enable_gcc_atomics = xyes; then

have_gcc_atomics=no

AC_MSG_CHECKING(for GCC builtin atomic operations)

AC_LINK_IFELSE([AC_LANG_PROGRAM([],[[

int a;

void *x, *y, *z;

__sync_lock_test_and_set(&a, 4);

__sync_lock_test_and_set(&x, y);

__sync_fetch_and_add(&a, 1);

__sync_bool_compare_and_swap(&a, 5, 10);

__sync_bool_compare_and_swap(&x, y, z);

]])],

[have_gcc_atomics=yes],[])

AC_MSG_RESULT($have_gcc_atomics)

if test x$have_gcc_atomics = xyes; then

AC_DEFINE(HAVE_GCC_ATOMICS, 1, [ ])

else

# See if we have the minimum operation needed for GCC atomics

AC_LINK_IFELSE([AC_LANG_PROGRAM([],[[

int a;

__sync_lock_test_and_set(&a, 1);

__sync_lock_release(&a);

]])], [have_gcc_sync_lock_test_and_set=yes],[])

if test x$have_gcc_sync_lock_test_and_set = xyes; then

AC_DEFINE(HAVE_GCC_SYNC_LOCK_TEST_AND_SET, 1, [ ])

fi

fi

fi

# Standard C sources

SOURCES="$SOURCES $srcdir/src/*.c"

SOURCES="$SOURCES $srcdir/src/atomic/*.c"

SOURCES="$SOURCES $srcdir/src/audio/*.c"

SOURCES="$SOURCES $srcdir/src/cpuinfo/*.c"

SOURCES="$SOURCES $srcdir/src/dynapi/*.c"

SOURCES="$SOURCES $srcdir/src/events/*.c"

SOURCES="$SOURCES $srcdir/src/file/*.c"

SOURCES="$SOURCES $srcdir/src/haptic/*.c"

SOURCES="$SOURCES $srcdir/src/hidapi/*.c"

SOURCES="$SOURCES $srcdir/src/joystick/*.c"

SOURCES="$SOURCES $srcdir/src/libm/*.c"

SOURCES="$SOURCES $srcdir/src/misc/*.c"

SOURCES="$SOURCES $srcdir/src/power/*.c"

#SOURCES="$SOURCES $srcdir/src/filesystem/*.c"

SOURCES="$SOURCES $srcdir/src/render/*.c"

SOURCES="$SOURCES $srcdir/src/render/*/*.c"

SOURCES="$SOURCES $srcdir/src/sensor/*.c"

SOURCES="$SOURCES $srcdir/src/stdlib/*.c"

SOURCES="$SOURCES $srcdir/src/thread/*.c"

SOURCES="$SOURCES $srcdir/src/timer/*.c"

SOURCES="$SOURCES $srcdir/src/video/*.c"

SOURCES="$SOURCES $srcdir/src/video/yuv2rgb/*.c"

SOURCES="$SOURCES $srcdir/src/locale/*.c"

dnl Enable/disable various subsystems of the SDL library

case "$host" in

*-*-emscripten*)

default_atomic=no

;;

*)

default_atomic=yes

;;

esac

AC_ARG_ENABLE(atomic,

[AS_HELP_STRING([--enable-atomic], [Enable the atomic operations subsystem [default=yes]])],

, enable_atomic=$default_atomic)

if test x$enable_atomic != xyes; then

AC_DEFINE(SDL_ATOMIC_DISABLED, 1, [ ])

else

SUMMARY_modules="${SUMMARY_modules} atomic"

fi

AC_ARG_ENABLE(audio,

[AS_HELP_STRING([--enable-audio], [Enable the audio subsystem [default=yes]])],

, enable_audio=yes)

if test x$enable_audio != xyes; then

AC_DEFINE(SDL_AUDIO_DISABLED, 1, [ ])

else

SUMMARY_modules="${SUMMARY_modules} audio"

fi

AC_ARG_ENABLE(video,

[AS_HELP_STRING([--enable-video], [Enable the video subsystem [default=yes]])],

, enable_video=yes)

if test x$enable_video != xyes; then

AC_DEFINE(SDL_VIDEO_DISABLED, 1, [ ])

else

SUMMARY_modules="${SUMMARY_modules} video"

fi

AC_ARG_ENABLE(render,

[AS_HELP_STRING([--enable-render], [Enable the render subsystem [default=yes]])],

, enable_render=yes)

if test x$enable_render != xyes; then

AC_DEFINE(SDL_RENDER_DISABLED, 1, [ ])

else

SUMMARY_modules="${SUMMARY_modules} render"

fi

AC_ARG_ENABLE(events,

[AS_HELP_STRING([--enable-events], [Enable the events subsystem [default=yes]])],

, enable_events=yes)

if test x$enable_events != xyes; then

AC_DEFINE(SDL_EVENTS_DISABLED, 1, [ ])

else

SUMMARY_modules="${SUMMARY_modules} events"

fi

AC_ARG_ENABLE(joystick,

[AS_HELP_STRING([--enable-joystick], [Enable the joystick subsystem [default=yes]])],

, enable_joystick=yes)

if test x$enable_joystick != xyes; then

AC_DEFINE(SDL_JOYSTICK_DISABLED, 1, [ ])

else

SUMMARY_modules="${SUMMARY_modules} joystick"

fi

AC_ARG_ENABLE(haptic,

[AS_HELP_STRING([--enable-haptic], [Enable the haptic (force feedback) subsystem [default=yes]])],

, enable_haptic=yes)

if test x$enable_haptic != xyes; then

AC_DEFINE(SDL_HAPTIC_DISABLED, 1, [ ])

else

SUMMARY_modules="${SUMMARY_modules} haptic"

fi

AC_ARG_ENABLE(hidapi,

[AS_HELP_STRING([--enable-hidapi], [Enable the HIDAPI subsystem [default=yes]])],

, enable_hidapi=yes)

if test x$enable_hidapi != xyes; then

AC_DEFINE(SDL_HIDAPI_DISABLED, 1, [ ])

else

SUMMARY_modules="${SUMMARY_modules} hidapi"

fi

AC_ARG_ENABLE(sensor,

[AS_HELP_STRING([--enable-sensor], [Enable the sensor subsystem [default=yes]])],

, enable_sensor=yes)

if test x$enable_sensor != xyes; then

AC_DEFINE(SDL_SENSOR_DISABLED, 1, [ ])

else

SUMMARY_modules="${SUMMARY_modules} sensor"

fi

AC_ARG_ENABLE(power,

[AS_HELP_STRING([--enable-power], [Enable the power subsystem [default=yes]])],

, enable_power=yes)

if test x$enable_power != xyes; then

AC_DEFINE(SDL_POWER_DISABLED, 1, [ ])

else

SUMMARY_modules="${SUMMARY_modules} power"

fi

AC_ARG_ENABLE(filesystem,

[AS_HELP_STRING([--enable-filesystem], [Enable the filesystem subsystem [default=yes]])],

, enable_filesystem=yes)

if test x$enable_filesystem != xyes; then

AC_DEFINE(SDL_FILESYSTEM_DISABLED, 1, [ ])

else

SUMMARY_modules="${SUMMARY_modules} filesystem"

fi

# Many subsystems depend on threads, so leave them enabled by default

#AC_ARG_ENABLE(threads,

#[AS_HELP_STRING([--enable-threads], [Enable the threading subsystem [default=yes]])],

# , enable_threads=yes)

enable_threads=yes

if test x$enable_threads != xyes; then

AC_DEFINE(SDL_THREADS_DISABLED, 1, [ ])

else

SUMMARY_modules="${SUMMARY_modules} threads"

fi

AC_ARG_ENABLE(timers,

[AS_HELP_STRING([--enable-timers], [Enable the timer subsystem [default=yes]])],

, enable_timers=yes)

if test x$enable_timers != xyes; then

AC_DEFINE(SDL_TIMERS_DISABLED, 1, [ ])

else

SUMMARY_modules="${SUMMARY_modules} timers"

fi

AC_ARG_ENABLE(file,

[AS_HELP_STRING([--enable-file], [Enable the file subsystem [default=yes]])],

, enable_file=yes)

if test x$enable_file != xyes; then

AC_DEFINE(SDL_FILE_DISABLED, 1, [ ])

else

SUMMARY_modules="${SUMMARY_modules} file"

fi

AC_ARG_ENABLE(misc,

[AS_HELP_STRING([--enable-misc], [Enable the misc subsystem [default=yes]])],

, enable_misc=yes)

if test x$enable_misc != xyes; then

AC_DEFINE(SDL_MISC_DISABLED, 1, [ ])

else

SUMMARY_modules="${SUMMARY_modules} misc"

fi

AC_ARG_ENABLE(locale,

[AS_HELP_STRING([--enable-locale], [Enable the locale subsystem [default=yes]])],

, enable_locale=yes)

if test x$enable_locale != xyes; then

AC_DEFINE(SDL_LOCALE_DISABLED, 1, [ ])

else

SUMMARY_modules="${SUMMARY_modules} locale"

fi

AC_ARG_ENABLE(loadso,

[AS_HELP_STRING([--enable-loadso], [Enable the shared object loading subsystem [default=yes]])],

, enable_loadso=yes)

if test x$enable_loadso != xyes; then

AC_DEFINE(SDL_LOADSO_DISABLED, 1, [ ])

else

SUMMARY_modules="${SUMMARY_modules} loadso"

fi

AC_ARG_ENABLE(cpuinfo,

[AS_HELP_STRING([--enable-cpuinfo], [Enable the cpuinfo subsystem [default=yes]])],

, enable_cpuinfo=yes)

if test x$enable_cpuinfo != xyes; then

AC_DEFINE(SDL_CPUINFO_DISABLED, 1, [ ])

else

SUMMARY_modules="${SUMMARY_modules} cpuinfo"

fi

AC_ARG_ENABLE(assembly,

[AS_HELP_STRING([--enable-assembly], [Enable assembly routines [default=yes]])],

, enable_assembly=yes)

if test x$enable_assembly = xyes; then

SUMMARY_modules="${SUMMARY_modules} assembly"

# Make sure that we don't generate floating point code that would

# cause illegal instruction exceptions on older processors

case "$host" in

*-*-darwin*)

# Don't need to worry about Apple hardware, it's all SSE capable

default_ssemath=yes

;;

*64-*-*)

# x86 64-bit architectures all have SSE instructions

default_ssemath=yes

;;

*)

default_ssemath=no

;;

esac

AC_ARG_ENABLE(ssemath,

[AS_HELP_STRING([--enable-ssemath], [Allow GCC to use SSE floating point math [default=maybe]])],

, enable_ssemath=$default_ssemath)

if test x$enable_ssemath = xno; then

if test x$have_gcc_sse = xyes -o x$have_gcc_sse2 = xyes -o x$have_gcc_sse3 = xyes; then

EXTRA_CFLAGS="$EXTRA_CFLAGS -mfpmath=387"

fi

fi

dnl Check for various instruction support

AC_ARG_ENABLE(mmx,

[AS_HELP_STRING([--enable-mmx], [use MMX assembly routines [default=yes]])],

, enable_mmx=yes)

if test x$enable_mmx = xyes; then

save_CFLAGS="$CFLAGS"

have_gcc_mmx=no

AC_MSG_CHECKING(for GCC -mmmx option)

mmx_CFLAGS="-mmmx"

CFLAGS="$save_CFLAGS $mmx_CFLAGS"

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[

#ifdef __MINGW32__

#include <_mingw.h>

#ifdef __MINGW64_VERSION_MAJOR

#include <intrin.h>

#else

#include <mmintrin.h>

#endif

#else

#include <mmintrin.h>

#endif

#ifndef __MMX__

#error Assembler CPP flag not enabled

#endif

]],[])], [have_gcc_mmx=yes],[])

AC_MSG_RESULT($have_gcc_mmx)

CFLAGS="$save_CFLAGS"

if test x$have_gcc_mmx = xyes; then

EXTRA_CFLAGS="$EXTRA_CFLAGS $mmx_CFLAGS"

SUMMARY_math="${SUMMARY_math} mmx"

fi

fi

AC_ARG_ENABLE(3dnow,

[AS_HELP_STRING([--enable-3dnow], [use 3DNow! assembly routines [default=yes]])],

, enable_3dnow=yes)

if test x$enable_3dnow = xyes; then

save_CFLAGS="$CFLAGS"

have_gcc_3dnow=no

AC_MSG_CHECKING(for GCC -m3dnow option)

amd3dnow_CFLAGS="-m3dnow"

CFLAGS="$save_CFLAGS $amd3dnow_CFLAGS"

AC_LINK_IFELSE([AC_LANG_PROGRAM([[

#include <mm3dnow.h>

#ifndef __3dNOW__

#error Assembler CPP flag not enabled

#endif

]], [[

void *p = 0;

_m_prefetch(p);

]])],

[have_gcc_3dnow=yes],[])

AC_MSG_RESULT($have_gcc_3dnow)

CFLAGS="$save_CFLAGS"

if test x$have_gcc_3dnow = xyes; then

EXTRA_CFLAGS="$EXTRA_CFLAGS $amd3dnow_CFLAGS"

SUMMARY_math="${SUMMARY_math} 3dnow"

fi

fi

AC_ARG_ENABLE(sse,

[AS_HELP_STRING([--enable-sse], [use SSE assembly routines [default=yes]])],

, enable_sse=yes)

if test x$enable_sse = xyes; then

save_CFLAGS="$CFLAGS"

have_gcc_sse=no

AC_MSG_CHECKING(for GCC -msse option)

sse_CFLAGS="-msse"

CFLAGS="$save_CFLAGS $sse_CFLAGS"

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[

#ifdef __MINGW32__

#include <_mingw.h>

#ifdef __MINGW64_VERSION_MAJOR

#include <intrin.h>

#else

#include <xmmintrin.h>

#endif

#else

#include <xmmintrin.h>

#endif

#ifndef __SSE__

#error Assembler CPP flag not enabled

#endif

]],[])], [have_gcc_sse=yes],[])

AC_MSG_RESULT($have_gcc_sse)

CFLAGS="$save_CFLAGS"

if test x$have_gcc_sse = xyes; then

EXTRA_CFLAGS="$EXTRA_CFLAGS $sse_CFLAGS"

SUMMARY_math="${SUMMARY_math} sse"

fi

fi

AC_ARG_ENABLE(sse2,

[AS_HELP_STRING([--enable-sse2], [use SSE2 assembly routines [default=maybe]])],

, enable_sse2=$default_ssemath)

if test x$enable_sse2 = xyes; then

save_CFLAGS="$CFLAGS"

have_gcc_sse2=no

AC_MSG_CHECKING(for GCC -msse2 option)

sse2_CFLAGS="-msse2"

CFLAGS="$save_CFLAGS $sse2_CFLAGS"

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[

#ifdef __MINGW32__

#include <_mingw.h>

#ifdef __MINGW64_VERSION_MAJOR

#include <intrin.h>

#else

#include <emmintrin.h>

#endif

#else

#include <emmintrin.h>

#endif

#ifndef __SSE2__

#error Assembler CPP flag not enabled

#endif

]],[])], [have_gcc_sse2=yes],[])

AC_MSG_RESULT($have_gcc_sse2)

CFLAGS="$save_CFLAGS"

if test x$have_gcc_sse2 = xyes; then

EXTRA_CFLAGS="$EXTRA_CFLAGS $sse2_CFLAGS"

SUMMARY_math="${SUMMARY_math} sse2"

fi

fi

AC_ARG_ENABLE(sse3,

[AS_HELP_STRING([--enable-sse3], [use SSE3 assembly routines [default=maybe]])],

, enable_sse3=$default_ssemath)

if test x$enable_sse3 = xyes; then

save_CFLAGS="$CFLAGS"

have_gcc_sse3=no

AC_MSG_CHECKING(for GCC -msse3 option)

sse3_CFLAGS="-msse3"

CFLAGS="$save_CFLAGS $sse3_CFLAGS"

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[

#ifdef __MINGW32__

#include <_mingw.h>

#ifdef __MINGW64_VERSION_MAJOR

#include <intrin.h>

#else

#include <pmmintrin.h>

#endif

#else

#include <pmmintrin.h>

#endif

#ifndef __SSE2__

#error Assembler CPP flag not enabled

#endif

]],[])], [have_gcc_sse3=yes],[])

AC_MSG_RESULT($have_gcc_sse3)

CFLAGS="$save_CFLAGS"

if test x$have_gcc_sse3 = xyes; then

EXTRA_CFLAGS="$EXTRA_CFLAGS $sse3_CFLAGS"

SUMMARY_math="${SUMMARY_math} sse3"

fi

fi

AC_MSG_CHECKING(for immintrin.h)

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <immintrin.h>]])],

[have_immintrin_h_hdr=yes],[have_immintrin_h_hdr=no])

AC_MSG_RESULT($have_immintrin_h_hdr)

if test x$have_immintrin_h_hdr = xyes; then

AC_DEFINE(HAVE_IMMINTRIN_H, 1, [ ])

fi

AC_ARG_ENABLE(altivec,

[AS_HELP_STRING([--enable-altivec], [use Altivec assembly routines [default=yes]])],

, enable_altivec=yes)

if test x$enable_altivec = xyes; then

save_CFLAGS="$CFLAGS"

have_gcc_altivec=no

have_altivec_h_hdr=no

altivec_CFLAGS="-maltivec"

CFLAGS="$save_CFLAGS $altivec_CFLAGS"

AC_MSG_CHECKING(for Altivec with GCC altivec.h and -maltivec option)

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[

#include <altivec.h>

vector unsigned int vzero() {

return vec_splat_u32(0);

}

]],[])], [

have_gcc_altivec=yes

have_altivec_h_hdr=yes

],[])

AC_MSG_RESULT($have_gcc_altivec)

if test x$have_gcc_altivec = xno; then

AC_MSG_CHECKING(for Altivec with GCC -maltivec option)

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[

vector unsigned int vzero() {

return vec_splat_u32(0);

}

]],[])], [have_gcc_altivec=yes],[])

AC_MSG_RESULT($have_gcc_altivec)

fi

if test x$have_gcc_altivec = xno; then

AC_MSG_CHECKING(for Altivec with GCC altivec.h and -faltivec option)

altivec_CFLAGS="-faltivec"

CFLAGS="$save_CFLAGS $altivec_CFLAGS"

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[

#include <altivec.h>

vector unsigned int vzero() {

return vec_splat_u32(0);

}

]],[])], [

have_gcc_altivec=yes

have_altivec_h_hdr=yes

],[])

AC_MSG_RESULT($have_gcc_altivec)

fi

if test x$have_gcc_altivec = xno; then

AC_MSG_CHECKING(for Altivec with GCC -faltivec option)

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[

vector unsigned int vzero() {

return vec_splat_u32(0);

}

]],[])], [have_gcc_altivec=yes],[])

AC_MSG_RESULT($have_gcc_altivec)

fi

CFLAGS="$save_CFLAGS"

if test x$have_gcc_altivec = xyes; then

AC_DEFINE(SDL_ALTIVEC_BLITTERS, 1, [ ])

if test x$have_altivec_h_hdr = xyes; then

AC_DEFINE(HAVE_ALTIVEC_H, 1, [ ])

fi

EXTRA_CFLAGS="$EXTRA_CFLAGS $altivec_CFLAGS"

SUMMARY_math="${SUMMARY_math} altivec"

fi

fi

fi

AC_ARG_ENABLE(lsx,

[AS_HELP_STRING([--enable-lsx], [use LSX assembly routines [default=yes]])],

, enable_lsx=yes)

if test x$enable_lsx = xyes; then

save_CFLAGS="$CFLAGS"

have_gcc_lsx=no

AC_MSG_CHECKING(for GCC -mlsx option)

lsx_CFLAGS="-mlsx"

CFLAGS="$save_CFLAGS $lsx_CFLAGS"

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[

#ifndef __loongarch_sx

#error Assembler CPP flag not enabled

#endif

]], [])], [have_gcc_lsx=yes], [])

AC_MSG_RESULT($have_gcc_lsx)

CFLAGS="$save_CFLAGS"

if test x$have_gcc_lsx = xyes; then

EXTRA_CFLAGS="$EXTRA_CFLAGS $lsx_CFLAGS"

SUMMARY_math="${SUMMARY_math} lsx"

fi

fi

AC_MSG_CHECKING(for lsxintrin.h)

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <lsxintrin.h>]])],

[have_lsxintrin_h_hdr=yes],[have_lsxintrin_h_hdr=no])

AC_MSG_RESULT($have_lsxintrin_h_hdr)

if test x$have_lsxintrin_h_hdr = xyes; then

AC_DEFINE(HAVE_LSXINTRIN_H, 1, [ ])

fi

AC_ARG_ENABLE(lasx,

[AS_HELP_STRING([--enable-lasx], [use LASX assembly routines [default=yes]])],

, enable_LASX=yes)

if test x$enable_LASX = xyes; then

save_CFLAGS="$CFLAGS"

have_gcc_lasx=no

AC_MSG_CHECKING(for GCC -mlasx option)

lasx_CFLAGS="-mlasx"

CFLAGS="$save_CFLAGS $lasx_CFLAGS"

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[

#ifndef __loongarch_asx

#error Assembler CPP flag not enabled

#endif

]], [])], [have_gcc_lasx=yes], [])

AC_MSG_RESULT($have_gcc_lasx)

CFLAGS="$save_CFLAGS"

if test x$have_gcc_lasx = xyes; then

EXTRA_CFLAGS="$EXTRA_CFLAGS $lasx_CFLAGS"

SUMMARY_math="${SUMMARY_math} lasx"

fi

fi

AC_MSG_CHECKING(for lasxintrin.h)

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <lasxintrin.h>]])],

[have_lasxintrin_h_hdr=yes],[have_lasxintrin_h_hdr=no])

AC_MSG_RESULT($have_lasxintrin_h_hdr)

if test x$have_lasxintrin_h_hdr = xyes; then

AC_DEFINE(HAVE_LASXINTRIN_H, 1, [ ])

fi

dnl See if the OSS audio interface is supported

CheckOSS()

{

AC_ARG_ENABLE(oss,

[AS_HELP_STRING([--enable-oss], [support the OSS audio API [default=maybe]])],

, enable_oss=maybe)

if test x$enable_oss = xmaybe; then

enable_oss=yes

fi

if test x$enable_audio = xyes -a x$enable_oss = xyes; then

AC_MSG_CHECKING(for OSS audio support)

have_oss=no

if test x$have_oss != xyes; then

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[

#include <sys/soundcard.h>

]], [[

int arg = SNDCTL_DSP_SETFRAGMENT;

]])], [have_oss=yes],[])

fi

AC_MSG_RESULT($have_oss)

if test x$have_oss = xyes; then

SUMMARY_audio="${SUMMARY_audio} oss"

AC_DEFINE(SDL_AUDIO_DRIVER_OSS, 1, [ ])

SOURCES="$SOURCES $srcdir/src/audio/dsp/*.c"

have_audio=yes

# We may need to link with ossaudio emulation library

case "$host" in

*-*-netbsd*)

EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lossaudio";;

esac

fi

fi

}

dnl See if the ALSA audio interface is supported

CheckALSA()

{

AC_ARG_ENABLE(alsa,

[AS_HELP_STRING([--enable-alsa], [support the ALSA audio API [default=yes]])],

, enable_alsa=yes)

if test x$enable_audio = xyes -a x$enable_alsa = xyes; then

AM_PATH_ALSA(1.0.11, have_alsa=yes, have_alsa=no)

# Restore all flags from before the ALSA detection runs

CFLAGS="$alsa_save_CFLAGS"

LDFLAGS="$alsa_save_LDFLAGS"

LIBS="$alsa_save_LIBS"

if test x$have_alsa = xyes; then

AC_ARG_ENABLE(alsa-shared,

[AS_HELP_STRING([--enable-alsa-shared], [dynamically load ALSA audio support [default=yes]])],

, enable_alsa_shared=yes)

alsa_lib=[`find_lib "libasound.so.*" "$ALSA_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]

AC_DEFINE(SDL_AUDIO_DRIVER_ALSA, 1, [ ])

SOURCES="$SOURCES $srcdir/src/audio/alsa/*.c"

EXTRA_CFLAGS="$EXTRA_CFLAGS $ALSA_CFLAGS"

if test x$have_loadso != xyes && \

test x$enable_alsa_shared = xyes; then

AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic ALSA loading])

fi

if test x$have_loadso = xyes && \

test x$enable_alsa_shared = xyes && test x$alsa_lib != x; then

echo "-- dynamic libasound -> $alsa_lib"

AC_DEFINE_UNQUOTED(SDL_AUDIO_DRIVER_ALSA_DYNAMIC, "$alsa_lib", [ ])

SUMMARY_audio="${SUMMARY_audio} alsa(dynamic)"

else

EXTRA_LDFLAGS="$EXTRA_LDFLAGS $ALSA_LIBS"

SUMMARY_audio="${SUMMARY_audio} alsa"

fi

have_audio=yes

fi

fi

}

dnl Find JACK Audio