~ubuntu-branches/debian/sid/kdevelop/sid

dnl    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

dnl    Boston, MA 02110-1301, USA.

AC_TRY_LINK([#include <X11/Intrinsic.h>], [${x_direct_test_function}(1)],

dnl KDE_FIND_PATH(program-name, variable-name, list-of-dirs,

dnl     if-not-found, test-parameter, prepend-path)

dnl

dnl Look for program-name in list-of-dirs+$PATH.

dnl If prepend-path is set, look in $PATH+list-of-dirs instead.

dnl If found, $variable-name is set. If not, if-not-found is evaluated.

dnl test-parameter: if set, the program is executed with this arg,

dnl                 and only a successful exit code is required.

        dirs=""

        done

        if test -z "$6"; then  dnl Append dirs in PATH (default)

          dirs="$3 $dirs"

        else  dnl Prepend dirs in PATH (if 6th arg is set)

          dirs="$dirs $3"

        fi

AC_DEFUN([KDE_SET_DEFAULT_BINDIRS],

[

    kde_default_bindirs="/usr/bin /usr/local/bin /opt/local/bin /usr/X11R6/bin /opt/kde/bin /opt/kde3/bin /usr/kde/bin /usr/local/kde/bin"

    test -n "$KDEDIR" && kde_default_bindirs="$KDEDIR/bin $kde_default_bindirs"

    if test -n "$KDEDIRS"; then

       kde_save_IFS=$IFS

       IFS=:

       for dir in $KDEDIRS; do

            kde_default_bindirs="$dir/bin $kde_default_bindirs "

       done

       IFS=$kde_save_IFS

    fi

])

 

        AC_HELP_STRING([--without-arts],[build without aRts [default=no]]),

    AM_CONDITIONAL(include_ARTS, test "$build_arts" '!=' "no")

    if test "$build_arts" = "no"; then

        AC_DEFINE(WITHOUT_ARTS, 1, [Defined if compiling without arts])

    fi

        KDE_SET_DEFAULT_BINDIRS

        kde_default_bindirs="$exec_prefix/bin $prefix/bin $kde_libs_prefix/bin $kde_default_bindirs"

        if test "$build_arts" '!=' "no"; then

        kde33ornewer=1

            kde33ornewer=

            if test "$kde_qtver" = "3"; then

              if test "$kde_qtsubver" -le 1; then

              fi

              if test "$kde_qtsubver" -le 2; then

                kde33ornewer=

              fi

              if test "$KDECONFIG" != "compiled"; then

                if test `$KDECONFIG --version | grep KDE | sed 's/KDE: \(...\).*/\1/'` = 3.2; then

                  kde33ornewer=

                fi

              fi

        if test -n "$kde33ornewer"; then

            KDE_FIND_PATH(makekdewidgets, MAKEKDEWIDGETS, [$kde_default_bindirs], [KDE_MISSING_PROG_ERROR(makekdewidgets)])

            AC_SUBST(MAKEKDEWIDGETS)

        fi

        KDE_FIND_PATH(xmllint, XMLLINT, [${prefix}/bin ${exec_prefix}/bin], [XMLLINT=""])

        if test -n "$MEINPROC" -a "$MEINPROC" != "compiled"; then

   # sys/bitypes.h is needed for uint32_t and friends on Tru64

   AC_CHECK_HEADERS(sys/bitypes.h)

 

   # for some image handling on Mac OS X

   AC_CHECK_HEADERS(Carbon/Carbon.h)

 

     FRAMEWORK_COREAUDIO="-Wl,-framework,CoreAudio"

   KDE_CHECK_PIE_SUPPORT

# used to disable x11-specific stuff on special platforms

AM_CONDITIONAL(include_x11, test "$kde_use_qt_emb" = "no" && test "$kde_use_qt_mac" = "no")

 

all_libraries="$X_LDFLAGS $LDFLAGS_AS_NEEDED $LDFLAGS_NEW_DTAGS"

  # Current default Qt version: 3.3

  kde_qtsubver=3

            if test $kde_qtsubver -gt 2; then

                kde_qt_minversion=">= Qt 3.3 and < 4.0"

            else

                kde_qt_minversion=">= Qt 3.2 and < 4.0"

            fi

            kde_qt_minversion=">= Qt 3.1 (20021021) and < 4.0"

      kde_qt_minversion=">= Qt 3.0 and < 4.0"

       kde_qt_verstring="QT_VERSION >= 0x03@VER@00 && QT_VERSION < 0x040000"

       kde_qt_verstring="QT_VERSION >= 300 && QT_VERSION < 0x040000"

if test $kde_qtver = 4; then

  kde_qt_dirs="$QTDIR /usr/lib/qt4 /usr/lib/qt /usr/share/qt4"

fi

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

  qtlib="qte"

  qtlib="qt"

kde_int_qt="-l$qtlib"

 

  LIBQT="-l$qtlib-mt"

  kde_int_qt="-l$qtlib-mt"

 all_libraries="$QT_LDFLAGS $all_libraries"

        AC_MSG_ERROR([

you need to install kdelibs first.

 

If you did install kdelibs, then the Qt version that is picked up by

this configure is not the same version you used to compile kdelibs. 

The Qt Plugin installed by kdelibs is *ONLY* loadable if it is the 

_same Qt version_, compiled with the _same compiler_ and the same Qt

configuration settings.

])

dnl Check if the linker supports --enable-new-dtags and --as-needed

AC_DEFUN([KDE_CHECK_NEW_LDFLAGS],

[

  AC_ARG_ENABLE(new_ldflags,

                AC_HELP_STRING([--enable-new-ldflags],

                [enable the new linker flags]),

        kde_use_new_ldflags=$enableval, 

        kde_use_new_ldflags=no)

 

  LDFLAGS_AS_NEEDED=""

  LDFLAGS_NEW_DTAGS=""

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

       LDFLAGS_NEW_DTAGS=""

       KDE_CHECK_COMPILER_FLAG([Wl,--enable-new-dtags],

                [LDFLAGS_NEW_DTAGS="-Wl,--enable-new-dtags"],)

 

       KDE_CHECK_COMPILER_FLAG([Wl,--as-needed],

                [LDFLAGS_AS_NEEDED="-Wl,--as-needed"],)

  fi

  AC_SUBST(LDFLAGS_AS_NEEDED)

  AC_SUBST(LDFLAGS_NEW_DTAGS)

])

 

kde_incdirs="$kde_libs_prefix/include /usr/lib/kde/include /usr/local/kde/include /usr/local/include /usr/kde/include /usr/include/kde /usr/include /opt/kde3/include /opt/kde/include $x_includes $qt_includes"

kde_libdirs="$kde_libs_prefix/lib${kdelibsuff} /usr/lib/kde/lib${kdelibsuff} /usr/local/kde/lib${kdelibsuff} /usr/kde/lib${kdelibsuff} /usr/lib${kdelibsuff}/kde /usr/lib${kdelibsuff}/kde3 /usr/lib${kdelibsuff} /usr/X11R6/lib${kdelibsuff} /usr/local/lib${kdelibsuff} /opt/kde3/lib${kdelibsuff} /opt/kde/lib${kdelibsuff} /usr/X11R6/kde/lib${kdelibsuff}"

else dnl test -z $1, e.g. from kdelibs

 all_libraries="$KDE_LDFLAGS $all_libraries"

   case $host in 

               *cygwin*) lib_kded="-lkdeinit_kded" ;;

               *) lib_kded="" ;;

       esac

   AC_SUBST(LIB_KDED, $lib_kded)

   AC_SUBST(LIB_KJS, "-lkjs")

   AC_SUBST(LIB_KIMPROXY, "-lkimproxy")

   AC_SUBST(LIB_KNEWSTUFF, "-lknewstuff")

   AC_SUBST(LIB_KDNSSD, "-lkdnssd")

   AC_SUBST(LIB_KUNITTEST, "-lkunittest")

AC_DEFUN([AC_CHECK_MKSTEMP],

[

        KDE_CHECK_FUNC_EXT(mkstemp, [

#include <stdlib.h>

#include <unistd.h>

],

        [

mkstemp("/tmp/aaaXXXXXX");

],

        [int mkstemp(char *)],

        [MKSTEMP])

])

 

  KDE_CHECK_FUNC_EXT(res_init,

    [res_init()],

    [int res_init(void)],

    [RES_INIT])

AC_DEFUN([AC_CHECK_RES_QUERY],

[

        KDE_CHECK_FUNC_EXT(res_query, [

#include <sys/types.h>

#include <netinet/in.h>

#include <arpa/nameser.h>

#include <resolv.h>

#include <netdb.h>

],

[

res_query(NULL, 0, 0, NULL, 0);

],

        [int res_query(const char *, int, int, unsigned char *, int)],

        [RES_QUERY])

])

 

AC_DEFUN([AC_CHECK_DN_SKIPNAME],

[

        KDE_CHECK_FUNC_EXT(dn_skipname, [

#include <sys/types.h>

#include <netinet/in.h>

#include <arpa/nameser.h>

#include <resolv.h>

],

[

dn_skipname (NULL, NULL);

],

        [int dn_skipname (unsigned char *, unsigned char *)],

        [DN_SKIPNAME])

])

 

 

[

void jpeg_CreateDecompress();

[jpeg_CreateDecompress();],

AC_DEFUN([KDE_FIND_LIBEXR],

[

AC_REQUIRE([KDE_CHECK_EXTRA_LIBS])

AC_REQUIRE([AC_FIND_ZLIB])

AC_CACHE_VAL(ac_cv_libexr,

[

  if test -z "$PKG_CONFIG"; then

    AC_PATH_PROG(PKG_CONFIG, pkg-config, no)

  fi

 

  AC_MSG_CHECKING([for OpenEXR libraries])

 

  if test "$PKG_CONFIG" = "no" ; then

     AC_MSG_RESULT(no)

     echo "*** The pkg-config script could not be found. Make sure it is"

     echo "*** in your path, or set the PKG_CONFIG environment variable"

     echo "*** to the full path to pkg-config."

     echo "*** Or see http://www.freedesktop.org/software/pkgconfig to get pkg-config."

  else

     if !(`$PKG_CONFIG --exists OpenEXR`) ; then

        AC_MSG_RESULT(no)

        EXRSTATUS=no

     else

        if !(`$PKG_CONFIG --atleast-version="1.1.1" OpenEXR`) ; then

           AC_MSG_RESULT(no)

           EXRSTATUS=old

        else

           kde_save_LIBS="$LIBS"

           LIBS="$LIBS $all_libraries $USER_LDFLAGS `pkg-config --libs OpenEXR` $LIBZ"

           AC_LANG_SAVE

           AC_LANG_CPLUSPLUS

           kde_save_CXXFLAGS="$CXXFLAGS"

           EXR_FLAGS=`$PKG_CONFIG --cflags OpenEXR`

           CXXFLAGS="$CXXFLAGS $all_includes $USER_INCLUDES $EXR_FLAGS"

 

           AC_TRY_LINK(dnl

               [

               #include <ImfRgbaFile.h>

               ],

               [

               using namespace Imf;

               RgbaInputFile file ("dummy");

               return 0;

               ],

               eval "ac_cv_libexr='`pkg-config --libs OpenEXR`'",

               eval "ac_cv_libexr=no"

           )

           LIBS="$kde_save_LIBS"

           CXXFLAGS="$kde_save_CXXFLAGS"

           AC_LANG_RESTORE

           ])dnl

           if eval "test ! \"`echo $ac_cv_libexr`\" = no"; then

               AC_DEFINE_UNQUOTED(HAVE_EXR, 1, [Define if you have OpenEXR])

               LIB_EXR="$ac_cv_libexr"

               AC_MSG_RESULT($ac_cv_libexr)

           else

               AC_MSG_RESULT(no)

               LIB_EXR=""

           fi

        fi

     fi

  fi

  AC_SUBST(LIB_EXR)

  AC_SUBST(EXR_FLAGS)

])

 

 

AC_DEFUN([KDE_CHECK_C_COMPILER_FLAG],

[

AC_MSG_CHECKING([whether $CC supports -$1])

kde_cache=`echo $1 | sed 'y% .=/+-,%____p__%'`

AC_CACHE_VAL(kde_cv_prog_cc_$kde_cache,

[

  AC_LANG_SAVE

  AC_LANG_C

  save_CFLAGS="$CFLAGS"

  CFLAGS="$CFLAGS -$1"

  AC_TRY_LINK([],[ return 0; ], [eval "kde_cv_prog_cc_$kde_cache=yes"], [])

  CFLAGS="$save_CFLAGS"

  AC_LANG_RESTORE

])

if eval "test \"`echo '$kde_cv_prog_cc_'$kde_cache`\" = yes"; then

 AC_MSG_RESULT(yes)

 :

 $2

else

 AC_MSG_RESULT(no)

 :

 $3

fi

])

 

 

 

AC_DEFUN([KDE_CHECK_FOR_BAD_COMPILER],

[

  AC_MSG_CHECKING([whether $CC is blacklisted])

 

  dnl In theory we have tu run this test against $CC and $CXX

  dnl in C and in C++ mode, because its perfectly legal for

  dnl the user to mix compiler versions, since C has a defined

  dnl ABI. 

  dnl 

  dnl For now, we assume the user is not on crack.

 

  AC_TRY_COMPILE([

#ifdef __GNUC__

#if __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 0

choke me

#endif

#endif

], ,

  kde_bad_compiler=no, 

  kde_bad_compiler=yes

)

 

  AC_MSG_RESULT($kde_bad_compiler)

 

if test "$kde_bad_compiler" = "yes"; then

  AC_MSG_ERROR([

 

This particular compiler version is blacklisted because it

is known to miscompile KDE. Please use a newer version, or

if that is not yet available, choose an older version. 

 

Please do not report a bug or bother us reporting this

configure error. We know about it, and we introduced

it by intention to avoid untraceable bugs or crashes in KDE.

 

])

fi

 

])

 

 

AC_DEFUN([KDE_CHECK_FOR_OPT_NOINLINE_MATCH],

[

  AC_CACHE_CHECK([whether system headers can cope with -O2 -fno-inline],

    kde_cv_opt_noinline_match,

  [

  kde_cv_opt_noinline_match=irrelevant

  dnl if we don't use both -O2 and -fno-inline, this check is moot

  if echo "$CFLAGS" | grep -e -O2 >/dev/null 2>/dev/null \

     && echo "$CFLAGS" | grep -e -fno-inline >/dev/null 2>/dev/null ; then

 

    ac_cflags_save="$CFLAGS"

    CFLAGS="$CFLAGS -D_USE_GNU"

 

    AC_TRY_LINK([

  #include <string.h>

], [  const char *pt, *et;

  et = __extension__      ({ char __a0, __a1, __a2;       (__builtin_constant_p (  ";,"  ) && ((size_t)(const void *)((   ";,"   )+ 1) - (size_t)(const void *)(   ";,"   ) == 1)        ? ((__a0 =((__const char  *) (  ";,"  ))[0], __a0 == '\0')     ? ((void) (  pt ),((void *)0) )        : ((__a1 = ((__const char *) (  ";,"  ))[1], __a1== '\0')      ? (__extension__ (__builtin_constant_p (  __a0 ) && ( __a0 ) == '\0'   ? (char *) __rawmemchr (   pt  ,   __a0)       : strchr(   pt  ,   __a0 )))   : ((__a2 = ((__const char *) (  ";,"  ))[2], __a2 == '\0')      ? __strpbrk_c2 (  pt , __a0, __a1)      :(((__const char *) (  ";,"  ))[3] == '\0'     ? __strpbrk_c3 (  pt ,__a0, __a1, __a2): strpbrk (  pt ,   ";,"  ))))) : strpbrk (  pt ,  ";,"  )); }) ;

],

    kde_cv_opt_noinline_match=yes,

    kde_cv_opt_noinline_match=no

    )

 

    CFLAGS="$ac_cflags_save"

  fi

  ])

])

 

 

  AC_ARG_ENABLE(warnings,AC_HELP_STRING([--disable-warnings],[disables compilation with -Wall and similar]),

        CFLAGS="-g -O2 -fno-schedule-insns -fno-inline $CFLAGS"

  KDE_CHECK_FOR_BAD_COMPILER

 

          CXXFLAGS="-g -O2 -fno-schedule-insns -fno-inline $CXXFLAGS"

      fi

        CXXFLAGS="-Wall -W -Wpointer-arith $CXXFLAGS"

            CFLAGS="-std=iso9899:1990 -W -Wall -Wchar-subscripts -Wshadow -Wpointer-arith -Wmissing-prototypes -Wwrite-strings -D_XOPEN_SOURCE=500 -D_BSD_SOURCE $CFLAGS"

            KDE_CHECK_COMPILER_FLAG(Wmissing-format-attribute, [CXXFLAGS="$CXXFLAGS -Wformat-security -Wmissing-format-attribute"])

            KDE_CHECK_C_COMPILER_FLAG(Wmissing-format-attribute, [CFLAGS="$CFLAGS -Wformat-security -Wmissing-format-attribute"])

        dnl ### FIXME: revert for KDE 4

        KDE_CHECK_COMPILER_FLAG(Wno-non-virtual-dtor,[CXXFLAGS="$CXXFLAGS -Wno-non-virtual-dtor"])

 

  AC_ARG_ENABLE(pch,

     AC_HELP_STRING([--enable-pch],

                    [enables precompiled header support (currently only KCC or gcc >=3.4+unsermake) [default=no]]),

    [ kde_use_pch=$enableval ],[ kde_use_pch=no ])

 

  HAVE_GCC_VISIBILITY=0

  AC_SUBST([HAVE_GCC_VISIBILITY])

 

    gcc_no_reorder_blocks=NO

    KDE_CHECK_COMPILER_FLAG(fno-reorder-blocks,[gcc_no_reorder_blocks=YES])

    if test $kde_use_debug_code != "no" && \

       test $kde_use_debug_code != "full" && \

       test "YES" = "$gcc_no_reorder_blocks" ; then

          CXXFLAGS="$CXXFLAGS -fno-reorder-blocks"

          CFLAGS="$CFLAGS -fno-reorder-blocks"

    fi

    ENABLE_PERMISSIVE_FLAG="-fpermissive"

 

    if test "$kde_use_pch" = "yes"; then

        AC_MSG_CHECKING(whether gcc supports precompiling c header files)

        echo >conftest.h

        if $CC -x c-header conftest.h >/dev/null 2>/dev/null; then

            kde_gcc_supports_pch=yes

            AC_MSG_RESULT(yes)

        else

            kde_gcc_supports_pch=no

            AC_MSG_RESULT(no)

        fi

        if test "$kde_gcc_supports_pch" = "yes"; then

            AC_MSG_CHECKING(whether gcc supports precompiling c++ header files)

            if $CXX -x c++-header conftest.h >/dev/null 2>/dev/null; then

                kde_gcc_supports_pch=yes

                AC_MSG_RESULT(yes)

            else

                kde_gcc_supports_pch=no

                AC_MSG_RESULT(no)

            fi

        fi

        rm -f conftest.h conftest.h.gch

    fi

 

    KDE_CHECK_FOR_OPT_NOINLINE_MATCH

    if test "x$kde_cv_opt_noinline_match" = "xno" ; then

       CFLAGS="`echo "$CFLAGS" | sed "s/ -fno-inline//"`"

    fi

  AM_CONDITIONAL(unsermake_enable_pch, test "$kde_use_pch" = "yes" && test "$kde_gcc_supports_pch" = "yes")

  AC_ARG_ENABLE(coverage,

    AC_HELP_STRING([--enable-coverage],[use gcc coverage testing]), [

      if test "$am_cv_CC_dependencies_compiler_type" = "gcc3"; then

        ac_coverage_compiler="-fprofile-arcs -ftest-coverage"

        ac_coverage_linker="-lgcc"

      elif test "$am_cv_CC_dependencies_compiler_type" = "gcc"; then

        ac_coverage_compiler="-fprofile-arcs -ftest-coverage"

        ac_coverage_linker=""

      else

        AC_MSG_ERROR([coverage with your compiler is not supported])

      fi

      CFLAGS="$CFLAGS $ac_coverage_compiler"

      CXXFLAGS="$CXXFLAGS $ac_coverage_compiler"

      LDFLAGS="$LDFLAGS $ac_coverage_linker"

    ])

 

  AC_SUBST(ENABLE_PERMISSIVE_FLAG)

  KDE_CHECK_NEW_LDFLAGS

AC_DEFUN([KDE_CHECK_VISIBILITY_GCC_BUG],

  [

    AC_CACHE_CHECK([for gcc -fvisibility-inlines-hidden bug], kde_cv_val_gcc_visibility_bug,

      [

        AC_LANG_SAVE

        AC_LANG_CPLUSPLUS

 

        safe_CXXFLAGS=$CXXFLAGS

        safe_LDFLAGS=$LDFLAGS

        CXXFLAGS="$CXXFLAGS -fPIC -fvisibility-inlines-hidden -O0"

        LDFLAGS="$LDFLAGS -shared -fPIC"

 

        AC_TRY_LINK(

        [

          /* http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19664 */

          #include <string>

          int some_function( void ) __attribute__ ((visibility("default")));

          int some_function( void )

          {

            std::string s("blafasel");

            return 0;

          }

        ], [/* elvis is alive */],

        kde_cv_val_gcc_visibility_bug=no, kde_cv_val_gcc_visibility_bug=yes)

 

        CXXFLAGS=$safe_CXXFLAGS

        LDFLAGS=$safe_LDFLAGS

        AC_LANG_RESTORE

      ]

    )

 

    if test x$kde_cv_val_gcc_visibility_bug = xno; then

      CXXFLAGS="$CXXFLAGS -fvisibility-inlines-hidden"

    fi

  ]

)

 

AC_DEFUN([KDE_ENABLE_HIDDEN_VISIBILITY],

[

  AC_BEFORE([AC_PATH_QT_1_3], [KDE_ENABLE_HIDDEN_VISIBILITY])

 

  AC_MSG_CHECKING([grepping for visibility push/pop in headers])

 

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

    AC_LANG_SAVE

    AC_LANG_CPLUSPLUS

    AC_EGREP_CPP(

       [GCC visibility push],

       [ #include <exception> 

       ], 

    [

      AC_MSG_RESULT(yes)

      kde_stdc_visibility_patched=yes ],

    [ 

      AC_MSG_RESULT(no)

      AC_MSG_WARN([Your libstdc++ doesn't appear to be patched for 

                   visibility support. Disabling -fvisibility=hidden])

 

      kde_stdc_visibility_patched=no ])

 

    AC_LANG_RESTORE

 

    kde_have_gcc_visibility=no

    KDE_CHECK_COMPILER_FLAG(fvisibility=hidden, 

    [

      kde_have_gcc_visibility=yes

      dnl the whole toolchain is just a mess, gcc is just too buggy

      dnl to handle STL with visibility enabled. Lets reconsider 

      dnl when gcc 4.2 is out or when things get fixed in the compiler.

      dnl Contact mueller@kde.org for details.

      AC_ARG_ENABLE(gcc-hidden-visibility,

        AC_HELP_STRING([--enable-gcc-hidden-visibility],[toolchain hidden visibility [default=no]]),

          [kde_have_gcc_visibility=$enableval],

          [kde_have_gcc_visibility=no])

 

      AC_CACHE_CHECK([if Qt is patched for -fvisibility], kde_cv_val_qt_gcc_visibility_patched,

        [

          AC_LANG_SAVE

          AC_LANG_CPLUSPLUS

 

          safe_CXXFLAGS=$CXXFLAGS

          CXXFLAGS="$CXXFLAGS $all_includes"

 

          AC_TRY_COMPILE(

          [

#include <qglobal.h>

#if Q_EXPORT - 0 != 0

/* if this compiles, then Q_EXPORT is undefined */

/* if Q_EXPORT is nonempty, this will break compilation */

#endif

          ], [/* elvis is alive */],

          kde_cv_val_qt_gcc_visibility_patched=no, kde_cv_val_qt_gcc_visibility_patched=yes)

 

          CXXFLAGS=$safe_CXXFLAGS

          AC_LANG_RESTORE

        ]

      )

 

      if test x$kde_have_gcc_visibility = "xyes" && test x$kde_stdc_visibility_patched = "xyes" && test x$kde_cv_val_qt_gcc_visibility_patched = "xyes"; then

        CXXFLAGS="$CXXFLAGS -fvisibility=hidden"

        KDE_CHECK_VISIBILITY_GCC_BUG

        HAVE_GCC_VISIBILITY=1

        AC_DEFINE_UNQUOTED(__KDE_HAVE_GCC_VISIBILITY, "$HAVE_GCC_VISIBILITY", [define to 1 if -fvisibility is supported])

      fi

    ])

  fi

])

 

# This hack ensures that libtool creates shared libs for kunittest plugins. By default check_LTLIBRARIES makes static libs.

KDE_CHECK_PLUGIN="\$(KDE_PLUGIN) -rpath \$(libdir)"

AC_SUBST(KDE_CHECK_PLUGIN)

 

            [/lib directory suffix (64,32,none,auto[=default])]),

            kdelibsuff=$enableval, kdelibsuff="auto")

    

    if test "$kdelibsuff" = "auto"; then

    

cat > conftest.c << EOF

#include <stdio.h>

int main() {

 return 0;

}

EOF

        kdelibsuff=`$CC conftest.c -o conftest.out; ldd conftest.out |sed -ne '/libc.so/{

    s,.*/lib\([[^\/]]*\)/.*,\1, 

    p 

}'`

        rm -rf conftest.*

    fi  

        

    if test "$kdelibsuff" = "no" || test "$kdelibsuff" = "none"; then

        AC_DEFINE_UNQUOTED(KDELIBSUFF, ["${kdelibsuff}"], Suffix for lib directories)

dnl Not used - kept for compat only?

  KDE_RPATH="-R \$(libdir)"

 

  if test "$kde_libraries" != "$libdir"; then

      KDE_RPATH="$KDE_RPATH -R \$(kde_libraries)"

  fi

AC_DEFUN([AC_CHECK_SOCKLEN_T],

[

   AC_MSG_CHECKING(for socklen_t)

   AC_CACHE_VAL(kde_cv_socklen_t,

   [

      AC_LANG_PUSH(C++)

      kde_cv_socklen_t=no

         #include <sys/types.h>

         #include <sys/socket.h>

      ],

      [

         socklen_t len;

         getpeername(0,0,&len);

      ],

      [

         kde_cv_socklen_t=yes

         kde_cv_socklen_t_equiv=socklen_t

      ])

      AC_LANG_POP(C++)

   ])

   AC_MSG_RESULT($kde_cv_socklen_t)

   if test $kde_cv_socklen_t = no; then

      AC_MSG_CHECKING([for socklen_t equivalent for socket functions])

      AC_CACHE_VAL(kde_cv_socklen_t_equiv,

      [

         kde_cv_socklen_t_equiv=int

         AC_LANG_PUSH(C++)

         for t in int size_t unsigned long "unsigned long"; do

            AC_TRY_COMPILE([

               #include <sys/types.h>

               #include <sys/socket.h>

            ],

            [

               $t len;

               getpeername(0,0,&len);

            ],

            [

               kde_cv_socklen_t_equiv="$t"

               break

            ])

         done

         AC_LANG_POP(C++)

      ])

      AC_MSG_RESULT($kde_cv_socklen_t_equiv)

   fi

   AC_DEFINE_UNQUOTED(kde_socklen_t, $kde_cv_socklen_t_equiv,

                     [type to use in place of socklen_t if not defined])

   AC_DEFINE_UNQUOTED(ksize_t, $kde_cv_socklen_t_equiv,

                     [type to use in place of socklen_t if not defined (deprecated, use kde_socklen_t)])

      LDFLAGS="$LDFLAGS $DPMS_LDFLAGS $all_libraries"

      LIBS="-lX11 -lXext $LIBSOCKET"

              LIBS="-lXdpms $LIBS"

   [#include <X11/Xlib.h>

   #include <X11/extensions/dpms.h>])

   [#include <X11/Xlib.h>

   #include <X11/extensions/dpms.h>])

    ac_save_ldflags=$LDFLAGS

    ac_save_cxxflags=$CXXFLAGS

    ac_save_libs=$LIBS

    LDFLAGS="$LDFLAGS $GL_LDFLAGS $X_LDFLAGS $all_libraries"

    LIBS="$LIBS -lGL -lGLU"

    test "x$kde_use_qt_mac" != xyes && test "x$kde_use_qt_emb" != xyes && LIBS="$LIBS -lX11"

    LIBS="$LIBS $LIB_XEXT -lm $LIBSOCKET"

        ac_cv_have_gl="yes", ac_cv_have_gl="no")

    LDFLAGS=$ac_save_ldflags

    CXXFLAGS=$ac_save_cxxflags

    LIBS=$ac_save_libs

       GLLIB='-lGLU -lGL $(LIB_X11)'

       GLLIB="$GL_LDFLAGS -lGLU -lGL "'$(LIB_X11)'

  dnl This code is here specifically to handle the

  dnl various flavors of threading library on FreeBSD

  dnl 4-, 5-, and 6-, and the (weird) rules around it.

  dnl There may be an environment PTHREAD_LIBS that 

  dnl specifies what to use; otherwise, search for it.

  dnl -pthread is special cased and unsets LIBPTHREAD

  dnl below if found.

    if test "x$PTHREAD_LIBS" = "x-pthread" ; then

      LIBPTHREAD="PTHREAD"

    else

      PTHREAD_LIBS_save="$PTHREAD_LIBS"

      PTHREAD_LIBS=`echo "$PTHREAD_LIBS_save" | sed -e 's,^-l,,g'`

      AC_MSG_CHECKING([for pthread_create in $PTHREAD_LIBS])

      KDE_CHECK_LIB($PTHREAD_LIBS, pthread_create, [

          LIBPTHREAD="$PTHREAD_LIBS_save"])

      PTHREAD_LIBS="$PTHREAD_LIBS_save"

    fi

  dnl Is this test really needed, in the face of the Tru64 test below?

    AC_CHECK_LIB(pthread, pthread_create, [LIBPTHREAD="-lpthread"])

  fi

 

  dnl This is a special Tru64 check, see BR 76171 issue #18.

  if test -z "$LIBPTHREAD" ; then

    AC_MSG_CHECKING([for pthread_create in -lpthread])

    kde_safe_libs=$LIBS

    LIBS="$LIBS -lpthread"

    AC_TRY_LINK([#include <pthread.h>],[(void)pthread_create(0,0,0,0);],[

        AC_MSG_RESULT(yes)

        LIBPTHREAD="-lpthread"],[

        AC_MSG_RESULT(no)])

    LIBS=$kde_safe_libs

  fi

 

  dnl Un-special-case for FreeBSD.

  if test "x$LIBPTHREAD" = "xPTHREAD" ; then

    LIBPTHREAD=""

  KDE_CHECK_PYTHON_INTERN("2.5",

    [KDE_CHECK_PYTHON_INTERN("2.4",

     [KDE_CHECK_PYTHON_INTERN("2.3",