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

AC_INIT(README)

AC_CONFIG_HEADER(include/SDL_config.h)

AC_GNU_SOURCE

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

#

# Making releases:

# Edit include/SDL/SDL_version.h and change the version, then:

#   SDL_MICRO_VERSION += 1;

#   SDL_INTERFACE_AGE += 1;

#   SDL_BINARY_AGE += 1;

# if any functions have been added, set SDL_INTERFACE_AGE to 0.

# if backwards compatibility has been broken,

# set SDL_BINARY_AGE and SDL_INTERFACE_AGE to 0.

#

SDL_MAJOR_VERSION=1

SDL_MINOR_VERSION=3

SDL_MICRO_VERSION=0

SDL_INTERFACE_AGE=0

SDL_BINARY_AGE=0

SDL_VERSION=$SDL_MAJOR_VERSION.$SDL_MINOR_VERSION.$SDL_MICRO_VERSION

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_RELEASE=$SDL_MAJOR_VERSION.$SDL_MINOR_VERSION

LT_CURRENT=`expr $SDL_MICRO_VERSION - $SDL_INTERFACE_AGE`

LT_REVISION=$SDL_INTERFACE_AGE

LT_AGE=`expr $SDL_BINARY_AGE - $SDL_INTERFACE_AGE`

AC_SUBST(LT_RELEASE)

AC_SUBST(LT_CURRENT)

AC_SUBST(LT_REVISION)

AC_SUBST(LT_AGE)

dnl Detect the canonical build and host environments

AC_CONFIG_AUX_DIRS($srcdir/build-scripts)

AC_CANONICAL_HOST

AC_C_BIGENDIAN

if test x$ac_cv_c_bigendian = xyes; then

    AC_DEFINE(SDL_BYTEORDER, 4321)

else

    AC_DEFINE(SDL_BYTEORDER, 1234)

fi

dnl Set up the compiler and linker flags

INCLUDE="-I$srcdir/include"

if test x$srcdir != x.; then

    # Remove SDL_config.h from the source directory, since it's the

    # default one, and we want to include the one that we generate.

    if test -f $srcdir/include/SDL_config.h; then

        rm $srcdir/include/SDL_config.h

    fi

    INCLUDE="-Iinclude $INCLUDE"

fi

case "$host" in

    *-*-cygwin*)

        # We build SDL on cygwin without the UNIX emulation layer

        BASE_CFLAGS="-I/usr/include/mingw -mno-cygwin"

        BASE_LDFLAGS="-mno-cygwin"

        ;;

    *)

        BASE_CFLAGS="-D_GNU_SOURCE=1"

        BASE_LDFLAGS=""

        ;;

esac

BUILD_CFLAGS="$CFLAGS $CPPFLAGS"

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="-lSDL $BASE_LDFLAGS"

CPPFLAGS="$CPPFLAGS $EXTRA_CFLAGS"

CFLAGS="$CFLAGS $EXTRA_CFLAGS"

LDFLAGS="$LDFLAGS $EXTRA_LDFLAGS"

dnl Check for tools

AC_LIBTOOL_WIN32_DLL

AC_PROG_LIBTOOL

AC_PROG_CC

AC_PROG_CXX

AC_PROG_INSTALL

AC_PROG_MAKE_SET

if test -z "$host_alias"; then

    hostaliaswindres=

else

    hostaliaswindres="$host_alias-windres"

fi

AC_CHECK_PROGS(WINDRES, [windres $hostaliaswindres $host_os-windres])

dnl Check for compiler characteristics

AC_C_CONST

AC_C_INLINE

AC_C_VOLATILE

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

AC_ARG_ENABLE(libc,

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

              , enable_libc=yes)

if test x$enable_libc = xyes; then

    AC_DEFINE(HAVE_LIBC)

    dnl Check for C library headers

    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 inttypes.h stdint.h ctype.h math.h iconv.h signal.h)

    dnl Check for typedefs, structures, etc.

    AC_TYPE_SIZE_T

    if test x$ac_cv_header_inttypes_h = xyes -o x$ac_cv_header_stdint_h = xyes; then

        AC_CHECK_TYPE(int64_t)

        if test x$ac_cv_type_int64_t = xyes; then

            AC_DEFINE(SDL_HAS_64BIT_TYPE)

        fi

        have_inttypes=yes

    fi

    dnl Checks for library functions.

    case "$host" in

    *-*-cygwin* | *-*-mingw32*)

        ;;

    *)

        AC_FUNC_ALLOCA

        ;;

    esac

    AC_FUNC_MEMCMP

    if test x$ac_cv_func_memcmp_working = xyes; then

        AC_DEFINE(HAVE_MEMCMP)

    fi

    AC_FUNC_STRTOD

    if test x$ac_cv_func_strtod = xyes; then

        AC_DEFINE(HAVE_STRTOD)

    fi

    AC_CHECK_FUNCS(malloc calloc realloc free getenv putenv unsetenv qsort abs bcopy memset memcpy memmove strlen strlcpy strlcat strdup _strrev _strupr _strlwr strchr strrchr strstr itoa _ltoa _uitoa _ultoa strtol strtoul _i64toa _ui64toa strtoll strtoull atoi atof strcmp strncmp _stricmp strcasecmp _strnicmp strncasecmp sscanf snprintf vsnprintf iconv sigaction setjmp nanosleep)

    AC_CHECK_LIB(iconv, libiconv_open, [EXTRA_LDFLAGS="$EXTRA_LDFLAGS -liconv"])

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

fi

if test x$have_inttypes != xyes; then

    AC_CHECK_SIZEOF(char, 1)

    AC_CHECK_SIZEOF(short, 2)

    AC_CHECK_SIZEOF(int, 4)

    AC_CHECK_SIZEOF(long, 4)

    AC_CHECK_SIZEOF(long long, 8)

    if test x$ac_cv_sizeof_char = x1; then

        AC_DEFINE(int8_t, signed char)

        AC_DEFINE(uint8_t, unsigned char)

    fi

    if test x$ac_cv_sizeof_short = x2; then

        AC_DEFINE(int16_t, signed short)

        AC_DEFINE(uint16_t, unsigned short)

    else

        if test x$ac_cv_sizeof_int = x2; then

            AC_DEFINE(int16_t, signed int)

            AC_DEFINE(uint16_t, unsigned int)

        fi

    fi

    if test x$ac_cv_sizeof_int = x4; then

        AC_DEFINE(int32_t, signed int)

        AC_DEFINE(uint32_t, unsigned int)

    else

        if test x$ac_cv_sizeof_long = x4; then

            AC_DEFINE(int32_t, signed long)

            AC_DEFINE(uint32_t, unsigned long)

        fi

    fi

    if test x$ac_cv_sizeof_long = x8; then

        AC_DEFINE(int64_t, signed long)

        AC_DEFINE(uint64_t, unsigned long)

        AC_DEFINE(SDL_HAS_64BIT_TYPE)

    else

        if test x$ac_cv_sizeof_long_long = x8; then

            AC_DEFINE(int64_t, signed long long)

            AC_DEFINE(uint64_t, unsigned long long)

            AC_DEFINE(SDL_HAS_64BIT_TYPE)

        fi

    fi

    AC_DEFINE(size_t, unsigned int)

    AC_DEFINE(uintptr_t, unsigned long)

fi

# Standard C sources

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

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

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

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

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

SOURCES="$SOURCES $srcdir/src/file/*.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"

dnl Enable/disable various subsystems of the SDL library

AC_ARG_ENABLE(audio,

AC_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)

fi

AC_ARG_ENABLE(video,

AC_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)

fi

AC_ARG_ENABLE(events,

AC_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)

fi

AC_ARG_ENABLE(joystick,

AC_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)

else

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

fi

AC_ARG_ENABLE(haptic,

AC_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)

else

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

fi

AC_ARG_ENABLE(cdrom,

AC_HELP_STRING([--enable-cdrom], [Enable the cdrom subsystem [[default=yes]]]),

              , enable_cdrom=yes)

if test x$enable_cdrom != xyes; then

    AC_DEFINE(SDL_CDROM_DISABLED)

fi

AC_ARG_ENABLE(threads,

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

              , enable_threads=yes)

if test x$enable_threads != xyes; then

    AC_DEFINE(SDL_THREADS_DISABLED)

fi

AC_ARG_ENABLE(timers,

AC_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)

fi

AC_ARG_ENABLE(file,

AC_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)

fi

AC_ARG_ENABLE(loadso,

AC_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)

fi

AC_ARG_ENABLE(cpuinfo,

AC_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)

fi

AC_ARG_ENABLE(assembly,

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

              , enable_assembly=yes)

if test x$enable_assembly = xyes; then

    AC_DEFINE(SDL_ASSEMBLY_ROUTINES)

    dnl Check for various instruction support

    AC_ARG_ENABLE(mmx,

AC_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_TRY_COMPILE([

        #include <mmintrin.h>

        #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"

        fi

    fi

    AC_ARG_ENABLE(3dnow,

AC_HELP_STRING([--enable-3dnow], [use MMX 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_TRY_COMPILE([

        #include <mm3dnow.h>

        #ifndef __3dNOW__

        #error Assembler CPP flag not enabled

        #endif

        ],[

        ],[

        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"

        fi

    fi

    AC_ARG_ENABLE(sse,

AC_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_TRY_COMPILE([

        #include <xmmintrin.h>

        #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"

        fi

    fi

    AC_ARG_ENABLE(sse2,

AC_HELP_STRING([--enable-sse2], [use SSE2 assembly routines [[default=yes]]]),

                  , enable_sse2=yes)

    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_TRY_COMPILE([

        #include <emmintrin.h>

        #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"

        fi

    fi

    AC_ARG_ENABLE(altivec,

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

                  , enable_altivec=yes)

    if test x$enable_altivec = xyes; then

        have_altivec_h_hdr=no

        AC_CHECK_HEADER(altivec.h, have_altivec_h_hdr=yes)

        save_CFLAGS="$CFLAGS"

        have_gcc_altivec=no

        AC_MSG_CHECKING(for Altivec with GCC -maltivec option)

        altivec_CFLAGS="-maltivec"

        CFLAGS="$save_CFLAGS $altivec_CFLAGS"

        if test x$have_altivec_h_hdr = xyes; then

          AC_TRY_COMPILE([

          #include <altivec.h>

          vector unsigned int vzero() {

              return vec_splat_u32(0);

          }

          ],[

          ],[

          have_gcc_altivec=yes

          ])

          AC_MSG_RESULT($have_gcc_altivec)

        else

          AC_TRY_COMPILE([

          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 -faltivec option)

            altivec_CFLAGS="-faltivec"

            CFLAGS="$save_CFLAGS $altivec_CFLAGS"

            if test x$have_altivec_h_hdr = xyes; then

              AC_TRY_COMPILE([

              #include <altivec.h>

              vector unsigned int vzero() {

                  return vec_splat_u32(0);

              }

              ],[

              ],[

              have_gcc_altivec=yes

              ])

              AC_MSG_RESULT($have_gcc_altivec)

            else

              AC_TRY_COMPILE([

              vector unsigned int vzero() {

                  return vec_splat_u32(0);

              }

              ],[

              ],[

              have_gcc_altivec=yes

              ])

              AC_MSG_RESULT($have_gcc_altivec)

            fi

        fi

        CFLAGS="$save_CFLAGS"

        if test x$have_gcc_altivec = xyes; then

            AC_DEFINE(SDL_ALTIVEC_BLITTERS)

            if test x$have_altivec_h_hdr = xyes; then

              AC_DEFINE(HAVE_ALTIVEC_H)

            fi

            EXTRA_CFLAGS="$EXTRA_CFLAGS $altivec_CFLAGS"

        fi

    fi

fi

dnl See if the OSS audio interface is supported

CheckOSS()

{

    AC_ARG_ENABLE(oss,

AC_HELP_STRING([--enable-oss], [support the OSS audio API [[default=yes]]]),

                  , enable_oss=yes)

    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_TRY_COMPILE([

              #include <sys/soundcard.h>

            ],[

              int arg = SNDCTL_DSP_SETFRAGMENT;

            ],[

            have_oss=yes

            ])

        fi

        if test x$have_oss != xyes; then

            AC_TRY_COMPILE([

              #include <soundcard.h>