Subversion Repositories Kolibri OS

dnl Process this file with autoconf to create configure.

AC_PREREQ([2.60])

dnl Tell the user about autoconf.html in the --help output

m4_divert_once([HELP_END], [

See docs/autoconf.html for more details on the options for Mesa.])

AC_INIT([Mesa], [9.2.5],

    [https://bugs.freedesktop.org/enter_bug.cgi?product=Mesa])

AC_CONFIG_AUX_DIR([bin])

AC_CONFIG_MACRO_DIR([m4])

AC_CANONICAL_SYSTEM

AM_INIT_AUTOMAKE([foreign])

dnl http://people.gnome.org/~walters/docs/build-api.txt

dnl We don't support srcdir != builddir.

echo \#buildapi-variable-no-builddir >/dev/null

# Support silent build rules, requires at least automake-1.11. Disable

# by either passing --disable-silent-rules to configure or passing V=1

# to make

m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])],

    [AC_SUBST([AM_DEFAULT_VERBOSITY], [1])])

m4_ifdef([AM_PROG_AR], [AM_PROG_AR])

dnl Set internal versions

OSMESA_VERSION=8

AC_SUBST([OSMESA_VERSION])

dnl Versions for external dependencies

LIBDRM_REQUIRED=2.4.24

LIBDRM_RADEON_REQUIRED=2.4.46

LIBDRM_INTEL_REQUIRED=2.4.38

LIBDRM_NVVIEUX_REQUIRED=2.4.33

LIBDRM_NOUVEAU_REQUIRED="2.4.33 libdrm >= 2.4.41"

LIBDRM_FREEDRENO_REQUIRED=2.4.39

DRI2PROTO_REQUIRED=2.6

GLPROTO_REQUIRED=1.4.14

LIBDRM_XORG_REQUIRED=2.4.24

LIBKMS_XORG_REQUIRED=1.0.0

dnl Check for progs

AC_PROG_CPP

AC_PROG_CC

AX_PROG_CC_FOR_BUILD

AC_PROG_CXX

AX_PROG_CXX_FOR_BUILD

AM_PROG_CC_C_O

AM_PROG_AS

AC_CHECK_PROGS([MAKE], [gmake make])

AC_CHECK_PROGS([PYTHON2], [python2 python])

AX_PYTHON_MODULE([libxml2], [needed])

AC_PROG_SED

AC_PROG_MKDIR_P

LT_PREREQ([2.2])

LT_INIT([disable-static])

AX_PROG_BISON([],

              AS_IF([test ! -f "$srcdir/src/glsl/glcpp/glcpp-parse.c"],

                    [AC_MSG_ERROR([bison not found - unable to compile glcpp-parse.y])]))

AX_PROG_FLEX([],

             AS_IF([test ! -f "$srcdir/src/glsl/glcpp/glcpp-lex.c"],

                   [AC_MSG_ERROR([flex not found - unable to compile glcpp-lex.l])]))

AC_PATH_PROG([PERL], [perl])

AC_CHECK_PROG(INDENT, indent, indent, cat)

if test "x$INDENT" != "xcat"; then

    AC_SUBST(INDENT_FLAGS, '-i4 -nut -br -brs -npcs -ce -TGLubyte -TGLbyte -TBool')

fi

AC_PROG_INSTALL

dnl We need a POSIX shell for parts of the build. Assume we have one

dnl in most cases.

case "$host_os" in

solaris*)

    # Solaris /bin/sh is too old/non-POSIX compliant

    AC_PATH_PROGS(POSIX_SHELL, [ksh93 ksh sh])

    SHELL="$POSIX_SHELL"

    ;;

esac

dnl clang is mostly GCC-compatible, but its version is much lower,

dnl so we have to check for it.

AC_MSG_CHECKING([if compiling with clang])

AC_COMPILE_IFELSE(

[AC_LANG_PROGRAM([], [[

#ifndef __clang__

       not clang

#endif

]])],

[acv_mesa_CLANG=yes], [acv_mesa_CLANG=no])

AC_MSG_RESULT([$acv_mesa_CLANG])

dnl If we're using GCC, make sure that it is at least version 3.3.0.  Older

dnl versions are explictly not supported.

GEN_ASM_OFFSETS=no

if test "x$GCC" = xyes -a "x$acv_mesa_CLANG" = xno; then

    AC_MSG_CHECKING([whether gcc version is sufficient])

    major=0

    minor=0

    GCC_VERSION=`$CC -dumpversion`

    if test $? -eq 0; then

        GCC_VERSION_MAJOR=`echo $GCC_VERSION | cut -d. -f1`

        GCC_VERSION_MINOR=`echo $GCC_VERSION | cut -d. -f2`

    fi

    if test $GCC_VERSION_MAJOR -lt 3 -o $GCC_VERSION_MAJOR -eq 3 -a $GCC_VERSION_MINOR -lt 3 ; then

        AC_MSG_RESULT([no])

        AC_MSG_ERROR([If using GCC, version 3.3.0 or later is required.])

    else

        AC_MSG_RESULT([yes])

    fi

    if test "x$cross_compiling" = xyes; then

        GEN_ASM_OFFSETS=yes

    fi

fi

AM_CONDITIONAL([GEN_ASM_OFFSETS], test "x$GEN_ASM_OFFSETS" = xyes)

dnl Make sure the pkg-config macros are defined

m4_ifndef([PKG_PROG_PKG_CONFIG],

    [m4_fatal([Could not locate the pkg-config autoconf macros.

  These are usually located in /usr/share/aclocal/pkg.m4. If your macros

  are in a different location, try setting the environment variable

  ACLOCAL="aclocal -I/other/macro/dir" before running autoreconf.])])

PKG_PROG_PKG_CONFIG()

dnl LIB_DIR - library basename

LIB_DIR=`echo $libdir | $SED 's%.*/%%'`

AC_SUBST([LIB_DIR])

dnl Cache LDFLAGS and CPPFLAGS so we can add to them and restore later

_SAVE_LDFLAGS="$LDFLAGS"

_SAVE_CPPFLAGS="$CPPFLAGS"

dnl build host compiler macros

DEFINES_FOR_BUILD=""

AC_SUBST([DEFINES_FOR_BUILD])

case "$build_os" in

linux*|*-gnu*|gnu*)

    DEFINES_FOR_BUILD="$DEFINES_FOR_BUILD -D_GNU_SOURCE"

    ;;

solaris*)

    DEFINES_FOR_BUILD="$DEFINES_FOR_BUILD -DSVR4"

    ;;

cygwin*)

    DEFINES_FOR_BUILD="$DEFINES_FOR_BUILD"

    ;;

esac

dnl Compiler macros

DEFINES=""

AC_SUBST([DEFINES])

case "$host_os" in

linux*|*-gnu*|gnu*)

    DEFINES="$DEFINES -D_GNU_SOURCE -DHAVE_PTHREAD"

    ;;

solaris*)

    DEFINES="$DEFINES -DHAVE_PTHREAD -DSVR4"

    ;;

cygwin*)

    DEFINES="$DEFINES -DHAVE_PTHREAD"

    ;;

esac

dnl Add flags for gcc and g++

if test "x$GCC" = xyes; then

    case "$host_os" in

    cygwin*)

        CFLAGS="$CFLAGS -Wall -std=gnu99"

        ;;

    *)

        CFLAGS_FOR_BUILD="$CFLAGS_FOR_BUILD -Wall -std=c99"

        CFLAGS="$CFLAGS -Wall -std=c99"

        ;;

    esac

    # Enable -Werror=implicit-function-declaration and

    # -Werror=missing-prototypes, if available, or otherwise, just

    # -Wmissing-prototypes.  This is particularly useful to avoid

    # generating a loadable driver module that has undefined symbols.

    save_CFLAGS="$CFLAGS"

    AC_MSG_CHECKING([whether $CC supports -Werror=missing-prototypes])

    CFLAGS="$CFLAGS -Werror=implicit-function-declaration"

    CFLAGS="$CFLAGS -Werror=missing-prototypes"

    AC_LINK_IFELSE([AC_LANG_PROGRAM()],

		   AC_MSG_RESULT([yes]),

		   [CFLAGS="$save_CFLAGS -Wmissing-prototypes";

		    AC_MSG_RESULT([no])]);

    # Enable -fvisibility=hidden if using a gcc that supports it

    save_CFLAGS="$CFLAGS"

    AC_MSG_CHECKING([whether $CC supports -fvisibility=hidden])

    VISIBILITY_CFLAGS="-fvisibility=hidden"

    CFLAGS="$CFLAGS $VISIBILITY_CFLAGS"

    AC_LINK_IFELSE([AC_LANG_PROGRAM()], AC_MSG_RESULT([yes]),

		   [VISIBILITY_CFLAGS=""; AC_MSG_RESULT([no])]);

    # Restore CFLAGS; VISIBILITY_CFLAGS are added to it where needed.

    CFLAGS=$save_CFLAGS

    # Work around aliasing bugs - developers should comment this out

    CFLAGS_FOR_BUILD="$CFLAGS_FOR_BUILD -fno-strict-aliasing"

    CFLAGS="$CFLAGS -fno-strict-aliasing"

    # gcc's builtin memcmp is slower than glibc's

    # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43052

    CFLAGS_FOR_BUILD="$CFLAGS_FOR_BUILD -fno-builtin-memcmp"

    CFLAGS="$CFLAGS -fno-builtin-memcmp"

fi

if test "x$GXX" = xyes; then

    CXXFLAGS_FOR_BUILD="$CXXFLAGS_FOR_BUILD -Wall"

    CXXFLAGS="$CXXFLAGS -Wall"

    # Enable -fvisibility=hidden if using a gcc that supports it

    save_CXXFLAGS="$CXXFLAGS"

    AC_MSG_CHECKING([whether $CXX supports -fvisibility=hidden])

    VISIBILITY_CXXFLAGS="-fvisibility=hidden"

    CXXFLAGS="$CXXFLAGS $VISIBILITY_CXXFLAGS"

    AC_LANG_PUSH([C++])

    AC_LINK_IFELSE([AC_LANG_PROGRAM()], AC_MSG_RESULT([yes]),

		   [VISIBILITY_CXXFLAGS="" ; AC_MSG_RESULT([no])]);

    AC_LANG_POP([C++])

    # Restore CXXFLAGS; VISIBILITY_CXXFLAGS are added to it where needed.

    CXXFLAGS=$save_CXXFLAGS

    # Work around aliasing bugs - developers should comment this out

    CXXFLAGS_FOR_BUILD="$CXXFLAGS_FOR_BUILD -fno-strict-aliasing"

    CXXFLAGS="$CXXFLAGS -fno-strict-aliasing"

    # gcc's builtin memcmp is slower than glibc's

    # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43052

    CXXFLAGS_FOR_BUILD="$CXXFLAGS_FOR_BUILD -fno-builtin-memcmp"

    CXXFLAGS="$CXXFLAGS -fno-builtin-memcmp"

fi

dnl even if the compiler appears to support it, using visibility attributes isn't

dnl going to do anything useful currently on cygwin apart from emit lots of warnings

case "$host_os" in

cygwin*)

    VISIBILITY_CFLAGS=""

    VISIBILITY_CXXFLAGS=""

    ;;

esac

AC_SUBST([VISIBILITY_CFLAGS])

AC_SUBST([VISIBILITY_CXXFLAGS])

dnl

dnl Hacks to enable 32 or 64 bit build

dnl

AC_ARG_ENABLE([32-bit],

    [AS_HELP_STRING([--enable-32-bit],

        [build 32-bit libraries @<:@default=auto@:>@])],

    [enable_32bit="$enableval"],

    [enable_32bit=auto]

)

if test "x$enable_32bit" = xyes; then

    if test "x$GCC" = xyes; then

        CFLAGS="$CFLAGS -m32"

        CCASFLAGS="$CCASFLAGS -m32"

    fi

    if test "x$GXX" = xyes; then

        CXXFLAGS="$CXXFLAGS -m32"

    fi

fi

AC_ARG_ENABLE([64-bit],

    [AS_HELP_STRING([--enable-64-bit],

        [build 64-bit libraries @<:@default=auto@:>@])],

    [enable_64bit="$enableval"],

    [enable_64bit=auto]

)

if test "x$enable_64bit" = xyes; then

    if test "x$GCC" = xyes; then

        CFLAGS="$CFLAGS -m64"

    fi

    if test "x$GXX" = xyes; then

        CXXFLAGS="$CXXFLAGS -m64"

    fi

fi

dnl Can't have static and shared libraries, default to static if user

dnl explicitly requested. If both disabled, set to static since shared

dnl was explicitly requested.

case "x$enable_static$enable_shared" in

xyesyes )

    AC_MSG_WARN([Cannot build static and shared libraries, disabling shared])

    enable_shared=no

    ;;

xnono )

    AC_MSG_WARN([Cannot disable both static and shared libraries, enabling static])

    enable_static=yes

    ;;

esac

AM_CONDITIONAL(BUILD_SHARED, test "x$enable_shared" = xyes)

dnl

dnl other compiler options

dnl

AC_ARG_ENABLE([debug],

    [AS_HELP_STRING([--enable-debug],

        [use debug compiler flags and macros @<:@default=disabled@:>@])],

    [enable_debug="$enableval"],

    [enable_debug=no]

)

if test "x$enable_debug" = xyes; then

    DEFINES_FOR_BUILD="$DEFINES_FOR_BUILD -DDEBUG"

    if test "x$GCC_FOR_BUILD" = xyes; then

        CFLAGS_FOR_BUILD="$CFLAGS_FOR_BUILD -g -O0"

    fi

    if test "x$GXX_FOR_BUILD" = xyes; then

        CXXFLAGS_FOR_BUILD="$CXXFLAGS_FOR_BUILD -g -O0"

    fi

    DEFINES="$DEFINES -DDEBUG"

    if test "x$GCC" = xyes; then

        CFLAGS="$CFLAGS -g -O0"

    fi

    if test "x$GXX" = xyes; then

        CXXFLAGS="$CXXFLAGS -g -O0"

    fi

fi

dnl

dnl library names

dnl

LIB_PREFIX_GLOB='lib'

LIB_VERSION_SEPARATOR='.'

if test "$enable_static" = yes; then

    LIB_EXTENSION='a'

else

    case "$host_os" in

    darwin* )

        LIB_EXTENSION='dylib' ;;

    cygwin* )

        dnl prefix can be 'cyg' or 'lib'

        LIB_PREFIX_GLOB='???'

        LIB_VERSION_SEPARATOR='-'

        LIB_EXTENSION='dll' ;;

    aix* )

        LIB_EXTENSION='a' ;;

    * )

        LIB_EXTENSION='so' ;;

    esac

fi

AC_ARG_WITH([gl-lib-name],

  [AS_HELP_STRING([--with-gl-lib-name@<:@=NAME@:>@],

    [specify GL library name @<:@default=GL@:>@])],

  [GL_LIB=$withval],

  [GL_LIB=GL])

AC_ARG_WITH([osmesa-lib-name],

  [AS_HELP_STRING([--with-osmesa-lib-name@<:@=NAME@:>@],

    [specify OSMesa library name @<:@default=OSMesa@:>@])],

  [OSMESA_LIB=$withval],

  [OSMESA_LIB=OSMesa])

AS_IF([test "x$GL_LIB" = xyes], [GL_LIB=GL])

AS_IF([test "x$OSMESA_LIB" = xyes], [OSMESA_LIB=OSMesa])

dnl

dnl Mangled Mesa support

dnl

AC_ARG_ENABLE([mangling],

  [AS_HELP_STRING([--enable-mangling],

    [enable mangled symbols and library name @<:@default=disabled@:>@])],

  [enable_mangling="${enableval}"],

  [enable_mangling=no]

)

if test "x${enable_mangling}" = "xyes" ; then

  DEFINES="${DEFINES} -DUSE_MGL_NAMESPACE"

  GL_LIB="Mangled${GL_LIB}"

  OSMESA_LIB="Mangled${OSMESA_LIB}"

fi

AC_SUBST([GL_LIB])

AC_SUBST([OSMESA_LIB])

dnl

dnl potentially-infringing-but-nobody-knows-for-sure stuff

dnl

AC_ARG_ENABLE([texture-float],

    [AS_HELP_STRING([--enable-texture-float],

        [enable floating-point textures and renderbuffers @<:@default=disabled@:>@])],

    [enable_texture_float="$enableval"],

    [enable_texture_float=no]

)

if test "x$enable_texture_float" = xyes; then

    AC_MSG_WARN([Floating-point textures enabled.])

    AC_MSG_WARN([Please consult docs/patents.txt with your lawyer before building Mesa.])

    DEFINES="$DEFINES -DTEXTURE_FLOAT_ENABLED"

fi

GL_LIB_NAME='lib$(GL_LIB).'${LIB_EXTENSION}

OSMESA_LIB_NAME='lib$(OSMESA_LIB).'${LIB_EXTENSION}

EGL_LIB_NAME='lib$(EGL_LIB).'${LIB_EXTENSION}

GLESv1_CM_LIB_NAME='lib$(GLESv1_CM_LIB).'${LIB_EXTENSION}

GLESv2_LIB_NAME='lib$(GLESv2_LIB).'${LIB_EXTENSION}

VG_LIB_NAME='lib$(VG_LIB).'${LIB_EXTENSION}

GLAPI_LIB_NAME='lib$(GLAPI_LIB).'${LIB_EXTENSION}

GL_LIB_GLOB=${LIB_PREFIX_GLOB}'$(GL_LIB)'${LIB_VERSION_SEPARATOR}'*'${LIB_EXTENSION}'*'

EGL_LIB_GLOB=${LIB_PREFIX_GLOB}'$(EGL_LIB)'${LIB_VERSION_SEPARATOR}'*'${LIB_EXTENSION}'*'

EGL_LIB_GLOB=${LIB_PREFIX_GLOB}'$(EGL_LIB)'${LIB_VERSION_SEPARATOR}'*'${LIB_EXTENSION}'*'

GLESv1_CM_LIB_GLOB=${LIB_PREFIX_GLOB}'$(GLESv1_CM_LIB)'${LIB_VERSION_SEPARATOR}'*'${LIB_EXTENSION}'*'

GLESv2_LIB_GLOB=${LIB_PREFIX_GLOB}'$(GLESv2_LIB)'${LIB_VERSION_SEPARATOR}'*'${LIB_EXTENSION}'*'

VG_LIB_GLOB=${LIB_PREFIX_GLOB}'$(VG_LIB)'${LIB_VERSION_SEPARATOR}'*'${LIB_EXTENSION}'*'

GLAPI_LIB_GLOB=${LIB_PREFIX_GLOB}'$(GLAPI_LIB)'${LIB_VERSION_SEPARATOR}'*'${LIB_EXTENSION}'*'

AC_SUBST([GL_LIB_NAME])

AC_SUBST([OSMESA_LIB_NAME])

AC_SUBST([EGL_LIB_NAME])

AC_SUBST([GLESv1_CM_LIB_NAME])

AC_SUBST([GLESv2_LIB_NAME])

AC_SUBST([VG_LIB_NAME])

AC_SUBST([GLAPI_LIB_NAME])

AC_SUBST([GL_LIB_GLOB])

AC_SUBST([EGL_LIB_GLOB])

AC_SUBST([GLESv1_CM_LIB_GLOB])

AC_SUBST([GLESv2_LIB_GLOB])

AC_SUBST([VG_LIB_GLOB])

AC_SUBST([GLAPI_LIB_GLOB])

dnl

dnl Arch/platform-specific settings

dnl

AC_ARG_ENABLE([asm],

    [AS_HELP_STRING([--disable-asm],

        [disable assembly usage @<:@default=enabled on supported plaforms@:>@])],

    [enable_asm="$enableval"],

    [enable_asm=yes]

)

asm_arch=""

AC_MSG_CHECKING([whether to enable assembly])

test "x$enable_asm" = xno && AC_MSG_RESULT([no])

# disable if cross compiling on x86/x86_64 since we must run gen_matypes

if test "x$enable_asm" = xyes && test "x$cross_compiling" = xyes; then

    case "$host_cpu" in

    i?86 | x86_64 | amd64)

        enable_asm=no

        AC_MSG_RESULT([no, cross compiling])

        ;;

    esac

fi

# check for supported arches

if test "x$enable_asm" = xyes; then

    case "$host_cpu" in

    i?86)

        case "$host_os" in

        linux* | *freebsd* | dragonfly* | *netbsd* | openbsd*)

            test "x$enable_64bit" = xyes && asm_arch=x86_64 || asm_arch=x86

            ;;

        gnu*)

            asm_arch=x86

            ;;

        esac

        ;;

    x86_64|amd64)

        case "$host_os" in

        linux* | *freebsd* | dragonfly* | *netbsd* | openbsd*)

            test "x$enable_32bit" = xyes && asm_arch=x86 || asm_arch=x86_64

            ;;

        esac

        ;;

    sparc*)

        case "$host_os" in

        linux*)

            asm_arch=sparc

            ;;

        esac

        ;;

    esac

    case "$asm_arch" in

    x86)

        DEFINES="$DEFINES -DUSE_X86_ASM -DUSE_MMX_ASM -DUSE_3DNOW_ASM -DUSE_SSE_ASM"

        AC_MSG_RESULT([yes, x86])

        ;;

    x86_64|amd64)

        DEFINES="$DEFINES -DUSE_X86_64_ASM"

        AC_MSG_RESULT([yes, x86_64])

        ;;

    sparc)

        DEFINES="$DEFINES -DUSE_SPARC_ASM"

        AC_MSG_RESULT([yes, sparc])

        ;;

    *)

        AC_MSG_RESULT([no, platform not supported])

        ;;

    esac

fi

dnl Check to see if dlopen is in default libraries (like Solaris, which

dnl has it in libc), or if libdl is needed to get it.

AC_CHECK_FUNC([dlopen], [DEFINES="$DEFINES -DHAVE_DLOPEN"],

    [AC_CHECK_LIB([dl], [dlopen],

       [DEFINES="$DEFINES -DHAVE_DLOPEN"; DLOPEN_LIBS="-ldl"])])

AC_SUBST([DLOPEN_LIBS])

case "$host_os" in

darwin*|mingw*)

    ;;

*)

    AC_CHECK_FUNCS([clock_gettime], [CLOCK_LIB=],

                   [AC_CHECK_LIB([rt], [clock_gettime], [CLOCK_LIB=-lrt],

                                 [AC_MSG_ERROR([Couldn't find clock_gettime])])])

    AC_SUBST([CLOCK_LIB])

    ;;

esac

dnl See if posix_memalign is available

AC_CHECK_FUNC([posix_memalign], [DEFINES="$DEFINES -DHAVE_POSIX_MEMALIGN"])

dnl Check for pthreads

AX_PTHREAD

dnl AX_PTHREADS leaves PTHREAD_LIBS empty for gcc and sets PTHREAD_CFLAGS

dnl to -pthread, which causes problems if we need -lpthread to appear in

dnl pkgconfig files.

test -z "$PTHREAD_LIBS" && PTHREAD_LIBS="-lpthread"

dnl SELinux awareness.

AC_ARG_ENABLE([selinux],

    [AS_HELP_STRING([--enable-selinux],

        [Build SELinux-aware Mesa @<:@default=disabled@:>@])],

    [MESA_SELINUX="$enableval"],

    [MESA_SELINUX=no])

if test "x$enable_selinux" = "xyes"; then

    AC_CHECK_HEADER([selinux/selinux.h],[],

                    [AC_MSG_ERROR([SELinux headers not found])])

    AC_CHECK_LIB([selinux],[is_selinux_enabled],[],

                 [AC_MSG_ERROR([SELinux library not found])])

    SELINUX_LIBS="-lselinux"

    DEFINES="$DEFINES -DMESA_SELINUX"

fi

AC_SUBST([SELINUX_LIBS])

dnl Options for APIs

AC_ARG_ENABLE([opengl],

    [AS_HELP_STRING([--disable-opengl],

        [disable support for standard OpenGL API @<:@default=no@:>@])],

    [enable_opengl="$enableval"],

    [enable_opengl=yes])

AC_ARG_ENABLE([gles1],

    [AS_HELP_STRING([--enable-gles1],

        [enable support for OpenGL ES 1.x API @<:@default=no@:>@])],

    [enable_gles1="$enableval"],

    [enable_gles1=no])

AC_ARG_ENABLE([gles2],

    [AS_HELP_STRING([--enable-gles2],

        [enable support for OpenGL ES 2.x API @<:@default=no@:>@])],

    [enable_gles2="$enableval"],

    [enable_gles2=no])

AC_ARG_ENABLE([openvg],

    [AS_HELP_STRING([--enable-openvg],

        [enable support for OpenVG API @<:@default=no@:>@])],

    [enable_openvg="$enableval"],

    [enable_openvg=no])

AC_ARG_ENABLE([dri],

    [AS_HELP_STRING([--enable-dri],

        [enable DRI modules @<:@default=enabled@:>@])],

    [enable_dri="$enableval"],

    [enable_dri=yes])

AC_ARG_ENABLE([glx],

    [AS_HELP_STRING([--enable-glx],

        [enable GLX library @<:@default=enabled@:>@])],

    [enable_glx="$enableval"],

    [enable_glx=yes])

AC_ARG_ENABLE([osmesa],

    [AS_HELP_STRING([--enable-osmesa],

        [enable OSMesa library @<:@default=disabled@:>@])],

    [enable_osmesa="$enableval"],

    [enable_osmesa=no])

AC_ARG_ENABLE([gallium-osmesa],

    [AS_HELP_STRING([--enable-gallium-osmesa],

        [enable Gallium implementation of the OSMesa library @<:@default=disabled@:>@])],

    [enable_gallium_osmesa="$enableval"],

    [enable_gallium_osmesa=no])

AC_ARG_ENABLE([egl],

    [AS_HELP_STRING([--disable-egl],

        [disable EGL library @<:@default=enabled@:>@])],

    [enable_egl="$enableval"],

    [enable_egl=yes])

AC_ARG_ENABLE([xorg],

    [AS_HELP_STRING([--enable-xorg],

        [enable support for X.Org DDX API @<:@default=no@:>@])],

    [enable_xorg="$enableval"],

    [enable_xorg=no])

AC_ARG_ENABLE([xa],

    [AS_HELP_STRING([--enable-xa],

        [enable build of the XA X Acceleration API @<:@default=no@:>@])],

    [enable_xa="$enableval"],

    [enable_xa=no])

AC_ARG_ENABLE([gbm],

   [AS_HELP_STRING([--enable-gbm],

         [enable gbm library @<:@default=auto@:>@])],

   [enable_gbm="$enableval"],

   [enable_gbm=auto])

AC_ARG_ENABLE([xvmc],

   [AS_HELP_STRING([--enable-xvmc],

         [enable xvmc library @<:@default=auto@:>@])],

   [enable_xvmc="$enableval"],

   [enable_xvmc=auto])

AC_ARG_ENABLE([vdpau],

   [AS_HELP_STRING([--enable-vdpau],

         [enable vdpau library @<:@default=auto@:>@])],

   [enable_vdpau="$enableval"],

   [enable_vdpau=auto])

AC_ARG_ENABLE([opencl],

   [AS_HELP_STRING([--enable-opencl],

         [enable OpenCL library NOTE: Enabling this option will also enable

          --with-llvm-shared-libs

          @<:@default=no@:>@])],

   [],

   [enable_opencl=no])

AC_ARG_ENABLE([xlib_glx],

    [AS_HELP_STRING([--enable-xlib-glx],

        [make GLX library Xlib-based instead of DRI-based @<:@default=disabled@:>@])],

    [enable_xlib_glx="$enableval"],

    [enable_xlib_glx=no])

AC_ARG_ENABLE([gallium_egl],

    [AS_HELP_STRING([--enable-gallium-egl],

        [enable optional EGL state tracker (not required

         for EGL support in Gallium with OpenGL and OpenGL ES)

         @<:@default=disable@:>@])],

    [enable_gallium_egl="$enableval"],

    [enable_gallium_egl=no])

AC_ARG_ENABLE([gallium_gbm],

    [AS_HELP_STRING([--enable-gallium-gbm],

        [enable optional gbm state tracker (not required for

         gbm support in Gallium)

         @<:@default=auto@:>@])],

    [enable_gallium_gbm="$enableval"],

    [enable_gallium_gbm=auto])

AC_ARG_ENABLE([r600-llvm-compiler],

    [AS_HELP_STRING([--enable-r600-llvm-compiler],

        [Enable experimental LLVM backend for graphics shaders @<:@default=disable@:>@])],

    [enable_r600_llvm="$enableval"],

    [enable_r600_llvm=no])

AC_ARG_ENABLE([gallium_tests],

    [AS_HELP_STRING([--enable-gallium-tests],

        [Enable optional Gallium tests) @<:@default=disable@:>@])],

    [enable_gallium_tests="$enableval"],

    [enable_gallium_tests=no])

# Option for Gallium drivers

# Keep this in sync with the --with-gallium-drivers help string default value

GALLIUM_DRIVERS_DEFAULT="r300,r600,svga,swrast"

AC_ARG_WITH([gallium-drivers],

    [AS_HELP_STRING([--with-gallium-drivers@<:@=DIRS...@:>@],

        [comma delimited Gallium drivers list, e.g.

        "i915,ilo,nouveau,r300,r600,radeonsi,freedreno,svga,swrast"

        @<:@default=r300,r600,svga,swrast@:>@])],

    [with_gallium_drivers="$withval"],

    [with_gallium_drivers="$GALLIUM_DRIVERS_DEFAULT"])

# Doing '--without-gallium-drivers' will set this variable to 'no'.  Clear it

# here so that the script doesn't choke on an unknown driver name later.

case "$with_gallium_drivers" in

    yes) with_gallium_drivers="$GALLIUM_DRIVERS_DEFAULT" ;;

    no) with_gallium_drivers='' ;;

esac

if test "x$enable_opengl" = xno -a \

        "x$enable_gles1" = xno -a \

        "x$enable_gles2" = xno -a \

        "x$enable_openvg" = xno -a \

        "x$enable_xorg" = xno -a \

        "x$enable_xa" = xno -a \

        "x$enable_xvmc" = xno -a \

        "x$enable_vdpau" = xno -a \

        "x$enable_opencl" = xno; then

    AC_MSG_ERROR([at least one API should be enabled])

fi

# Building OpenGL ES1 and/or ES2 without OpenGL is not supported on mesa 9.0.x

if test "x$enable_opengl" = xno -a \

        "x$enable_gles1" = xyes; then

    AC_MSG_ERROR([Building OpenGL ES1 without OpenGL is not supported])

fi

if test "x$enable_opengl" = xno -a \

        "x$enable_gles2" = xyes; then

    AC_MSG_ERROR([Building OpenGL ES2 without OpenGL is not supported])

fi

AM_CONDITIONAL(HAVE_OPENGL, test "x$enable_opengl" = xyes)

AM_CONDITIONAL(HAVE_OPENGL_ES1, test "x$enable_gles1" = xyes)

AM_CONDITIONAL(HAVE_OPENGL_ES2, test "x$enable_gles2" = xyes)

AM_CONDITIONAL(NEED_OPENGL_COMMON, test "x$enable_opengl" = xyes -o \

                                        "x$enable_gles1" = xyes -o \

                                        "x$enable_gles2" = xyes)

if test "x$enable_glx" = xno; then

    AC_MSG_WARN([GLX disabled, disabling Xlib-GLX])

    enable_xlib_glx=no

fi

if test "x$enable_dri$enable_xlib_glx" = xyesyes; then

    AC_MSG_ERROR([DRI and Xlib-GLX cannot be built together])

fi

if test "x$enable_opengl$enable_xlib_glx" = xnoyes; then

    AC_MSG_ERROR([Xlib-GLX cannot be built without OpenGL])

fi

# Disable GLX if OpenGL is not enabled

if test "x$enable_glx$enable_opengl" = xyesno; then

    AC_MSG_WARN([OpenGL not enabled, disabling GLX])

    enable_glx=no

fi

# Disable GLX if DRI and Xlib-GLX are not enabled

if test "x$enable_glx" = xyes -a \

        "x$enable_dri" = xno -a \

        "x$enable_xlib_glx" = xno; then

    AC_MSG_WARN([Neither DRI nor Xlib-GLX enabled, disabling GLX])

    enable_glx=no

fi

AM_CONDITIONAL(HAVE_DRI_GLX, test "x$enable_glx" = xyes -a \

                                  "x$enable_dri" = xyes)

AM_CONDITIONAL(HAVE_DRI, test "x$enable_dri" = xyes)

AM_CONDITIONAL(NEED_LIBMESA, test "x$enable_xlib_glx" = xyes -o \

                                  "x$enable_osmesa" = xyes)

AC_ARG_ENABLE([shared-glapi],

    [AS_HELP_STRING([--enable-shared-glapi],

        [Enable shared glapi for OpenGL @<:@default=yes@:>@])],

    [enable_shared_glapi="$enableval"],

    [enable_shared_glapi="$enable_dri"])

# Shared GLAPI is only useful for DRI

if test "x$enable_dri" = xno; then

    AC_MSG_NOTICE([Shared GLAPI is only useful for DRI, disabling])

    enable_shared_glapi=no

fi

AM_CONDITIONAL(HAVE_SHARED_GLAPI, test "x$enable_shared_glapi" = xyes)

dnl

dnl Driver specific build directories

dnl

GALLIUM_TARGET_DIRS=""

GALLIUM_WINSYS_DIRS="sw"

GALLIUM_DRIVERS_DIRS="galahad trace rbug noop identity"

GALLIUM_STATE_TRACKERS_DIRS=""

case "x$enable_glx$enable_xlib_glx" in

xyesyes)

    GALLIUM_WINSYS_DIRS="$GALLIUM_WINSYS_DIRS sw/xlib"

    GALLIUM_TARGET_DIRS="$GALLIUM_TARGET_DIRS libgl-xlib"

    GALLIUM_STATE_TRACKERS_DIRS="glx $GALLIUM_STATE_TRACKERS_DIRS"

    NEED_WINSYS_XLIB="yes"

    ;;

esac

if test "x$enable_dri" = xyes; then

    GALLIUM_WINSYS_DIRS="$GALLIUM_WINSYS_DIRS sw/dri"

    GALLIUM_STATE_TRACKERS_DIRS="dri $GALLIUM_STATE_TRACKERS_DIRS"

fi

if test "x$enable_gallium_osmesa" = xyes; then

    if test -z "$with_gallium_drivers"; then

        AC_MSG_ERROR([Cannot enable gallium_osmesa without Gallium])

    fi

    if test "x$enable_osmesa" = xyes; then

        AC_MSG_ERROR([Cannot enable both classic and Gallium OSMesa implementations])

    fi

    GALLIUM_STATE_TRACKERS_DIRS="osmesa $GALLIUM_STATE_TRACKERS_DIRS"

    GALLIUM_TARGET_DIRS="$GALLIUM_TARGET_DIRS osmesa"

fi

AC_SUBST([MESA_LLVM])

# Check for libdrm

PKG_CHECK_MODULES([LIBDRM], [libdrm >= $LIBDRM_REQUIRED],

                  [have_libdrm=yes], [have_libdrm=no])

if test "x$enable_dri" = xyes; then

    # DRI must be shared, I think

    if test "$enable_static" = yes; then

        AC_MSG_ERROR([Cannot use static libraries for DRI drivers])

    fi

    # not a hard requirement as swrast does not depend on it

    if test "x$have_libdrm" = xyes; then

        DRI_PC_REQ_PRIV="libdrm >= $LIBDRM_REQUIRED"

    fi

fi

dnl Direct rendering or just indirect rendering

case "$host_os" in

gnu*)

    dnl Disable by default on GNU/Hurd

    driglx_direct_default="no"

    ;;

cygwin*)

    dnl Disable by default on cygwin

    driglx_direct_default="no"

    ;;

*)

    driglx_direct_default="yes"

    ;;

esac

AC_ARG_ENABLE([driglx-direct],

    [AS_HELP_STRING([--disable-driglx-direct],

        [disable direct rendering in GLX and EGL for DRI \

            @<:@default=auto@:>@])],

    [driglx_direct="$enableval"],

    [driglx_direct="$driglx_direct_default"])

dnl

dnl libGL configuration per driver

dnl

case "x$enable_glx$enable_xlib_glx" in

xyesyes)

    # Xlib-based GLX

    PKG_CHECK_MODULES([XLIBGL], [x11 xext])

    GL_PC_REQ_PRIV="x11 xext"

    X11_INCLUDES="$X11_INCLUDES $XLIBGL_CFLAGS"

    GL_LIB_DEPS="$XLIBGL_LIBS"

    GL_LIB_DEPS="$GL_LIB_DEPS $SELINUX_LIBS -lm $PTHREAD_LIBS $DLOPEN_LIBS"

    GL_PC_LIB_PRIV="$GL_PC_LIB_PRIV $SELINUX_LIBS -lm $PTHREAD_LIBS"

    ;;

xyesno)

    # DRI-based GLX

    PKG_CHECK_MODULES([GLPROTO], [glproto >= $GLPROTO_REQUIRED])

    if test x"$driglx_direct" = xyes; then

        if test "x$have_libdrm" != xyes; then

            AC_MSG_ERROR([Direct rendering requires libdrm >= $LIBDRM_REQUIRED])

        fi

        PKG_CHECK_MODULES([DRI2PROTO], [dri2proto >= $DRI2PROTO_REQUIRED])

        GL_PC_REQ_PRIV="$GL_PC_REQ_PRIV libdrm >= $LIBDRM_REQUIRED"

    fi

    # find the DRI deps for libGL

    dri_modules="x11 xext xdamage xfixes x11-xcb xcb-glx >= 1.8.1 xcb-dri2 >= 1.8"

    # add xf86vidmode if available

    PKG_CHECK_MODULES([XF86VIDMODE], [xxf86vm], HAVE_XF86VIDMODE=yes, HAVE_XF86VIDMODE=no)

    if test "$HAVE_XF86VIDMODE" = yes ; then

        dri_modules="$dri_modules xxf86vm"

    fi

    PKG_CHECK_MODULES([DRIGL], [$dri_modules])

    GL_PC_REQ_PRIV="$GL_PC_REQ_PRIV $dri_modules"

    X11_INCLUDES="$X11_INCLUDES $DRIGL_CFLAGS"

    GL_LIB_DEPS="$DRIGL_LIBS"

    # need DRM libs, $PTHREAD_LIBS, etc.

    GL_LIB_DEPS="$GL_LIB_DEPS $LIBDRM_LIBS -lm $PTHREAD_LIBS $DLOPEN_LIBS"

    GL_PC_LIB_PRIV="-lm $PTHREAD_LIBS $DLOPEN_LIBS"

    ;;

esac

# This is outside the case (above) so that it is invoked even for non-GLX

# builds.

AM_CONDITIONAL(HAVE_XF86VIDMODE, test "x$HAVE_XF86VIDMODE" = xyes)

GLESv1_CM_LIB_DEPS="$LIBDRM_LIBS -lm $PTHREAD_LIBS $DLOPEN_LIBS"

GLESv1_CM_PC_LIB_PRIV="-lm $PTHREAD_LIBS $DLOPEN_LIBS"

GLESv2_LIB_DEPS="$LIBDRM_LIBS -lm $PTHREAD_LIBS $DLOPEN_LIBS"

GLESv2_PC_LIB_PRIV="-lm $PTHREAD_LIBS $DLOPEN_LIBS"

AC_SUBST([X11_INCLUDES])

AC_SUBST([GL_LIB_DEPS])

AC_SUBST([GL_PC_REQ_PRIV])

AC_SUBST([GL_PC_LIB_PRIV])

AC_SUBST([GL_PC_CFLAGS])

AC_SUBST([DRI_PC_REQ_PRIV])

AC_SUBST([GLESv1_CM_LIB_DEPS])

AC_SUBST([GLESv1_CM_PC_LIB_PRIV])

AC_SUBST([GLESv2_LIB_DEPS])

AC_SUBST([GLESv2_PC_LIB_PRIV])

DRI_LIB_DEPS="\$(top_builddir)/src/mesa/libdricore/libdricore${VERSION}.la"

AC_SUBST([HAVE_XF86VIDMODE])

dnl

dnl More GLX setup

dnl

case "x$enable_glx$enable_xlib_glx" in

xyesyes)

    DEFINES="$DEFINES -DUSE_XSHM"

    ;;

xyesno)

    DEFINES="$DEFINES -DGLX_INDIRECT_RENDERING"

    if test "x$driglx_direct" = xyes; then

        DEFINES="$DEFINES -DGLX_DIRECT_RENDERING"

    fi

    ;;

esac

dnl

dnl TLS detection

dnl

AC_ARG_ENABLE([glx-tls],

    [AS_HELP_STRING([--enable-glx-tls],

        [enable TLS support in GLX @<:@default=disabled@:>@])],

    [GLX_USE_TLS="$enableval"],

    [GLX_USE_TLS=no])

AC_SUBST(GLX_TLS, ${GLX_USE_TLS})

AS_IF([test "x$GLX_USE_TLS" = xyes -a "x$ax_pthread_ok" = xyes],

      [DEFINES="${DEFINES} -DGLX_USE_TLS -DHAVE_PTHREAD"])

dnl

dnl More DRI setup

dnl

dnl Directory for DRI drivers

AC_ARG_WITH([dri-driverdir],

    [AS_HELP_STRING([--with-dri-driverdir=DIR],

        [directory for the DRI drivers @<:@${libdir}/dri@:>@])],

    [DRI_DRIVER_INSTALL_DIR="$withval"],

    [DRI_DRIVER_INSTALL_DIR='${libdir}/dri'])

AC_SUBST([DRI_DRIVER_INSTALL_DIR])

dnl Extra search path for DRI drivers

AC_ARG_WITH([dri-searchpath],

    [AS_HELP_STRING([--with-dri-searchpath=DIRS...],

        [semicolon delimited DRI driver search directories @<:@${libdir}/dri@:>@])],

    [DRI_DRIVER_SEARCH_DIR="$withval"],

    [DRI_DRIVER_SEARCH_DIR='${DRI_DRIVER_INSTALL_DIR}'])

AC_SUBST([DRI_DRIVER_SEARCH_DIR])

dnl Which drivers to build - default is chosen by platform

AC_ARG_WITH([dri-drivers],

    [AS_HELP_STRING([--with-dri-drivers@<:@=DIRS...@:>@],

        [comma delimited DRI drivers list, e.g.

        "swrast,i965,radeon" @<:@default=auto@:>@])],

    [with_dri_drivers="$withval"],

    [with_dri_drivers=yes])

if test "x$with_dri_drivers" = x; then

    with_dri_drivers=no

fi

dnl If $with_dri_drivers is yes, directories will be added through

dnl platform checks

DRI_DIRS=""

case "$with_dri_drivers" in

no) ;;

yes)

    # classic DRI drivers

    if test "x$enable_opengl" = xyes; then

        DRI_DIRS="yes"

    fi

    ;;

*)

    # verify the requested driver directories exist

    dri_drivers=`IFS=', '; echo $with_dri_drivers`

    for driver in $dri_drivers; do

        test -d "$srcdir/src/mesa/drivers/dri/$driver" || \

            AC_MSG_ERROR([DRI driver directory '$driver' does not exist])

    done

    DRI_DIRS="$dri_drivers"

    if test -n "$DRI_DIRS" -a "x$enable_opengl" != xyes; then

        AC_MSG_ERROR([--with-dri-drivers requires OpenGL])

    fi

    ;;

esac

dnl Set DRI_DIRS, DEFINES and LIB_DEPS

if test "x$enable_dri" = xyes; then

    # Platform specific settings and drivers to build

    case "$host_os" in

    linux*)

        DEFINES="$DEFINES -DUSE_EXTERNAL_DXTN_LIB=1"

        DEFINES="$DEFINES -DHAVE_ALIAS"

        case "$host_cpu" in

        x86_64|amd64)

            if test "x$DRI_DIRS" = "xyes"; then

                DRI_DIRS="i915 i965 nouveau r200 radeon swrast"

            fi

            ;;

        powerpc*)

            # Build only the drivers for cards that exist on PowerPC.

            if test "x$DRI_DIRS" = "xyes"; then

                DRI_DIRS="r200 radeon swrast"

            fi

            ;;

        sparc*)

            # Build only the drivers for cards that exist on sparc

            if test "x$DRI_DIRS" = "xyes"; then

                DRI_DIRS="r200 radeon swrast"

            fi

            ;;

        esac

        ;;

    freebsd* | dragonfly* | *netbsd* | openbsd*)

        DEFINES="$DEFINES -DHAVE_PTHREAD -DUSE_EXTERNAL_DXTN_LIB=1"

        DEFINES="$DEFINES -DHAVE_ALIAS"

        if test "x$DRI_DIRS" = "xyes"; then

            DRI_DIRS="i915 i965 nouveau r200 radeon swrast"

        fi

        ;;

    gnu*)

        DEFINES="$DEFINES -DUSE_EXTERNAL_DXTN_LIB=1"

        DEFINES="$DEFINES -DHAVE_ALIAS"

	;;

    solaris*)

        DEFINES="$DEFINES -DUSE_EXTERNAL_DXTN_LIB=1"

        ;;

    cygwin*)

        DEFINES="$DEFINES -DUSE_EXTERNAL_DXTN_LIB=1"

        if test "x$DRI_DIRS" = "xyes"; then

            DRI_DIRS="swrast"

        fi

        ;;

    esac

    # default drivers

    if test "x$DRI_DIRS" = "xyes"; then

        DRI_DIRS="i915 i965 nouveau r200 radeon swrast"

    fi

    DRI_DIRS=`echo "$DRI_DIRS" | $SED 's/  */ /g'`

    # Check for expat

    EXPAT_INCLUDES=""

    EXPAT_LIB=-lexpat

    AC_ARG_WITH([expat],

        [AS_HELP_STRING([--with-expat=DIR],

            [expat install directory])],[

        EXPAT_INCLUDES="-I$withval/include"

        CPPFLAGS="$CPPFLAGS $EXPAT_INCLUDES"

        LDFLAGS="$LDFLAGS -L$withval/$LIB_DIR"

        EXPAT_LIB="-L$withval/$LIB_DIR -lexpat"

        ])

    AC_CHECK_HEADER([expat.h],[],[AC_MSG_ERROR([Expat required for DRI.])])

    save_LIBS="$LIBS"

    AC_CHECK_LIB([expat],[XML_ParserCreate],[],

        [AC_MSG_ERROR([Expat required for DRI.])])

    LIBS="$save_LIBS"

    # If we are building any DRI driver other than swrast.

    if test -n "$DRI_DIRS" -a x"$DRI_DIRS" != xswrast; then

        # ... libdrm is required

        if test "x$have_libdrm" != xyes; then

            AC_MSG_ERROR([DRI drivers requires libdrm >= $LIBDRM_REQUIRED])

        fi

        # ... and build dricommon

        HAVE_COMMON_DRI=yes

    fi

    # put all the necessary libs together

    DRI_LIB_DEPS="$DRI_LIB_DEPS $SELINUX_LIBS $LIBDRM_LIBS $EXPAT_LIB -lm $PTHREAD_LIBS $DLOPEN_LIBS"

    GALLIUM_DRI_LIB_DEPS="$GALLIUM_DRI_LIB_DEPS $SELINUX_LIBS $LIBDRM_LIBS $EXPAT_LIB -lm $CLOCK_LIB $PTHREAD_LIBS $DLOPEN_LIBS"

fi

AM_CONDITIONAL(NEED_LIBDRICORE, test -n "$DRI_DIRS")

AC_SUBST([EXPAT_INCLUDES])

AC_SUBST([DRI_LIB_DEPS])

AC_SUBST([GALLIUM_DRI_LIB_DEPS])

case $DRI_DIRS in

*i915*|*i965*)

    PKG_CHECK_MODULES([INTEL], [libdrm_intel >= $LIBDRM_INTEL_REQUIRED])

    for d in $(echo $DRI_DIRS | sed 's/,/ /g'); do

        case $d in

        i915)

            HAVE_I915_DRI=yes;

            ;;

        i965)

            HAVE_I965_DRI=yes;

            ;;

        esac

    done

    ;;

esac

case $DRI_DIRS in

*nouveau*)

    PKG_CHECK_MODULES([NOUVEAU], [libdrm_nouveau >= $LIBDRM_NVVIEUX_REQUIRED])

    HAVE_NOUVEAU_DRI=yes;

    ;;

esac

case $DRI_DIRS in

*radeon*|*r200*)

    PKG_CHECK_MODULES([RADEON], [libdrm_radeon >= $LIBDRM_RADEON_REQUIRED])

    for d in $(echo $DRI_DIRS | sed 's/,/ /g'); do

        case $d in

        radeon)

            HAVE_RADEON_DRI=yes;

            ;;

        r200)

            HAVE_R200_DRI=yes;

            ;;

        esac

    done

    ;;

esac

case $DRI_DIRS in

*swrast*)

    HAVE_SWRAST_DRI=yes;

    ;;

esac

dnl

dnl OSMesa configuration

dnl

dnl Configure the channel bits for OSMesa (libOSMesa, libOSMesa16, ...)

AC_ARG_WITH([osmesa-bits],

    [AS_HELP_STRING([--with-osmesa-bits=BITS],

        [OSMesa channel bits and library name: 8, 16, 32 @<:@default=8@:>@])],

    [osmesa_bits="$withval"],

    [osmesa_bits=8])