mirror of
https://git.lyx.org/repos/lyx.git
synced 2024-11-26 11:16:55 +00:00
f4b8943ebb
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@952 a592a061-630c-0410-9148-cb99ea01b6c8
4606 lines
132 KiB
Bash
4606 lines
132 KiB
Bash
dnl Some useful functions for LyXs configure.in -*- sh -*-
|
|
dnl Author: Jean-Marc Lasgouttes (Jean-Marc.Lasgouttes@inria.fr)
|
|
dnl Lars Gullik Bjønnes (larsbj@lyx.org)
|
|
dnl Allan Rae (rae@lyx.org)
|
|
|
|
|
|
dnl Usage LYX_GET_VERSION Sets "lyx_version" to the version of LyX being
|
|
dnl built, displays it and sets variable "lyx_devel" to yes or no depending
|
|
dnl whether the version is a development release or not.
|
|
AC_DEFUN(LYX_GET_VERSION,[
|
|
changequote(, ) dnl
|
|
VERSION=`grep '#define *LYX_VERSION' $1 |
|
|
sed -e 's/^.*"\(.*\)"$/\1/' 2>/dev/null`
|
|
echo "configuring LyX version $VERSION"
|
|
if echo "$VERSION" | grep 'cvs' >/dev/null ; then
|
|
lyx_devel_version=yes
|
|
echo "WARNING: This is a development version. Expect bugs."
|
|
else
|
|
lyx_devel_version=no
|
|
fi
|
|
if echo "$VERSION" | grep 'pre' > /dev/null ; then
|
|
lyx_prerelease=yes
|
|
echo "WARNING: This is a prerelease. Be careful and backup your documents."
|
|
else
|
|
lyx_prerelease=no
|
|
fi
|
|
changequote([, ]) dnl
|
|
PACKAGE=lyx${program_suffix}
|
|
AC_SUBST(lyx_devel_version)
|
|
if test $lyx_devel_version = yes ; then
|
|
AC_DEFINE(DEVEL_VERSION, 1, Define if you are building a development version of LyX)
|
|
fi])
|
|
|
|
dnl Usage: LYX_ERROR(message) Displays the warning "message" and sets the
|
|
dnl flag lyx_error to yes.
|
|
AC_DEFUN(LYX_ERROR,[
|
|
lyx_error_txt="$lyx_error_txt
|
|
** $1
|
|
"
|
|
lyx_error=yes])
|
|
|
|
|
|
dnl Usage: LYX_WARNING(message) Displays the warning "message" and sets the
|
|
dnl flag lyx_warning to yes.
|
|
AC_DEFUN(LYX_WARNING,[
|
|
lyx_warning_txt="$lyx_warning_txt
|
|
== $1
|
|
"
|
|
lyx_warning=yes])
|
|
|
|
|
|
dnl Usage: LYX_LIB_ERROR(file,library) Displays an error message indication
|
|
dnl that 'file' cannot be found because 'lib' may be uncorrectly installed.
|
|
AC_DEFUN(LYX_LIB_ERROR,[
|
|
LYX_ERROR([Cannot find $1. Please check that the $2 library
|
|
is correctly installed on your system.])])
|
|
|
|
|
|
dnl Usage: LYX_CHECK_ERRORS Displays a warning message if a LYX_ERROR
|
|
dnl has occured previously.
|
|
AC_DEFUN(LYX_CHECK_ERRORS,[
|
|
if test x$lyx_error = xyes; then
|
|
cat <<EOF
|
|
**** The following problems have been detected by configure.
|
|
**** Please check the messages below before running 'make'.
|
|
**** (see the section 'Problems' in the INSTALL file)
|
|
$lyx_error_txt
|
|
$lyx_warning_txt
|
|
deleting cache $cache_file
|
|
EOF
|
|
rm -f $cache_file
|
|
else
|
|
|
|
if test x$lyx_warning = xyes; then
|
|
cat <<EOF
|
|
=== The following minor problems have been detected by configure.
|
|
=== Please check the messages below before running 'make'.
|
|
=== (see the section 'Problems' in the INSTALL file)
|
|
$lyx_warning_txt
|
|
EOF
|
|
fi
|
|
cat <<EOF
|
|
Configuration of LyX was successful.
|
|
Type 'make' to compile the program,
|
|
and then 'make install' to install it.
|
|
EOF
|
|
fi])
|
|
|
|
|
|
dnl LYX_SEARCH_PROG(VARIABLE-NAME,PROGRAMS-LIST,ACTION-IF-FOUND)
|
|
dnl
|
|
define(LYX_SEARCH_PROG,[dnl
|
|
for ac_prog in $2 ; do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog ; ac_word=$[2]
|
|
if test -z "[$]$1"; then
|
|
IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":"
|
|
for ac_dir in $PATH; do
|
|
test -z "$ac_dir" && ac_dir=.
|
|
if test -f [$ac_dir/$ac_word]; then
|
|
$1="$ac_prog"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$ac_save_ifs"
|
|
fi
|
|
|
|
if test -n "[$]$1"; then
|
|
ac_result=yes
|
|
else
|
|
ac_result=no
|
|
fi
|
|
ifelse($3,,,[$3])
|
|
test -n "[$]$1" && break
|
|
done
|
|
])dnl
|
|
|
|
|
|
AC_DEFUN(LYX_PROG_CXX_WORKS,
|
|
[AC_LANG_SAVE
|
|
AC_LANG_CPLUSPLUS
|
|
AC_TRY_COMPILER([class foo { int bar; }; int main(){return(0);}], ac_cv_prog_cxx_works, ac_cv_prog_cxx_cross)
|
|
AC_LANG_RESTORE
|
|
if test $ac_cv_prog_cxx_works = no; then
|
|
CXX=
|
|
fi
|
|
cross_compiling=$ac_cv_prog_cxx_cross
|
|
])
|
|
|
|
|
|
AC_DEFUN(LYX_PROG_CXX,
|
|
[AC_BEFORE([$0], [AC_PROG_CXXCPP])dnl
|
|
AC_MSG_CHECKING([for a working C++ compiler])
|
|
LYX_SEARCH_PROG(CXX, $CCC g++ gcc c++ CC cxx xlC cc++, LYX_PROG_CXX_WORKS)
|
|
|
|
if test -z "$CXX" ; then
|
|
AC_ERROR([Unable to find a working C++ compiler])
|
|
fi
|
|
|
|
AC_SUBST(CXX)
|
|
AC_MSG_RESULT($CXX)
|
|
|
|
AC_MSG_CHECKING([whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) is a cross-compiler])
|
|
AC_MSG_RESULT($cross_compiling)
|
|
|
|
AC_PROG_CXX_GNU
|
|
|
|
dnl We might want to get or shut warnings.
|
|
AC_ARG_WITH(warnings,
|
|
[ --with-warnings tell the compiler to display more warnings],,
|
|
[ if test $lyx_devel_version = yes -o $lyx_prerelease = yes && test $ac_cv_prog_gxx = yes ; then
|
|
with_warnings=yes;
|
|
else
|
|
with_warnings=no;
|
|
fi;])
|
|
if test x$with_warnings = xyes ; then
|
|
lyx_flags="$lyx_flags warnings"
|
|
AC_DEFINE(WITH_WARNINGS, 1,
|
|
[Define this if you want to see the warning directives put here and
|
|
there by the developpers to get attention])
|
|
fi
|
|
|
|
# optimize less for development versions
|
|
if test $lyx_devel_version = yes -o $lyx_prerelease = yes ; then
|
|
lyx_opt="-O"
|
|
else
|
|
lyx_opt="-O2"
|
|
fi
|
|
|
|
# set the debug flags correctly.
|
|
if test $ac_cv_prog_gxx = yes; then
|
|
GXX=yes
|
|
dnl Check whether -g works, even if CXXFLAGS is set, in case the package
|
|
dnl plays around with CXXFLAGS (such as to build both debugging and
|
|
dnl normal versions of a library), tasteless as that idea is.
|
|
ac_test_CXXFLAGS="${CXXFLAGS+set}"
|
|
ac_save_CXXFLAGS="$CXXFLAGS"
|
|
CXXFLAGS=
|
|
dnl Check the version of g++
|
|
gxx_version=`${CXX} --version`
|
|
|
|
AC_PROG_CXX_G
|
|
if test "$ac_test_CXXFLAGS" = set; then
|
|
CXXFLAGS="$ac_save_CXXFLAGS"
|
|
elif test $ac_cv_prog_cxx_g = yes; then
|
|
case $gxx_version in
|
|
2.95.1) CXXFLAGS="-g $lyx_opt -fpermissive -fno-rtti -fno-exceptions";;
|
|
2.95.*) CXXFLAGS="-g $lyx_opt -fno-rtti -fno-exceptions";;
|
|
2.96*) CXXFLAGS="-g $lyx_opt -fhonor-std -fvtable-thunks -ffunction-sections -fdata-sections";;
|
|
*2.91.*) CXXFLAGS="-g $lyx_opt -fno-rtti -fno-exceptions";;
|
|
*) CXXFLAGS="-g $lyx_opt -fno-rtti -fno-exceptions";;
|
|
esac
|
|
else
|
|
CXXFLAGS="$lyx_opt"
|
|
fi
|
|
if test x$with_warnings = xyes ; then
|
|
case $gxx_version in
|
|
2.95.*) CXXFLAGS="$CXXFLAGS -W -Wall -Wconversion -Winline";;
|
|
2.96*) CXXFLAGS="$CXXFLAGS -W -Wall -Wconversion -Winline";;
|
|
*) CXXFLAGS="$CXXFLAGS -ansi -W -Wall -Wno-return-type";;
|
|
esac
|
|
if test $lyx_devel_version = yes ; then
|
|
case $gxx_version in
|
|
2.95.*) ;;
|
|
2.96*) ;;
|
|
*2.91*) ;;
|
|
*) CXXFLAGS="$CXXFLAGS -pedantic";;
|
|
esac
|
|
fi
|
|
fi
|
|
else
|
|
GXX=
|
|
test "${CXXFLAGS+set}" = set || CXXFLAGS="-g"
|
|
fi
|
|
])dnl
|
|
|
|
|
|
dnl Usage: LYX_CXX_RTTI : checks whether the C++ compiler
|
|
dnl supports RTTI
|
|
AC_DEFUN(LYX_CXX_RTTI,[
|
|
### Check whether the compiler supports runtime type information
|
|
AC_CACHE_CHECK(whether the C++ compiler supports RTTI,lyx_cv_rtti,
|
|
[AC_TRY_RUN([
|
|
class rtti {
|
|
public:
|
|
virtual int tag() { return 0; }
|
|
};
|
|
class derived1 : public rtti {
|
|
public:
|
|
int tag() { return 1; }
|
|
};
|
|
class derived2 : public rtti {
|
|
public:
|
|
int tag() { return 2; }
|
|
};
|
|
int main() {
|
|
derived1 * foo1 = new derived1();
|
|
derived2 * foo2 = new derived2();
|
|
rtti * bar = foo1;
|
|
derived1 * bar1 = dynamic_cast<derived1 *>(bar);
|
|
if (bar1 == 0)
|
|
exit(1);
|
|
bar = foo2;
|
|
bar1 = dynamic_cast<derived1 *>(bar);
|
|
if (bar1 != 0)
|
|
exit(1);
|
|
return 0;
|
|
}
|
|
],lyx_cv_rtti=yes,lyx_cv_rtti=no,lyx_cv_rtti=no)
|
|
])
|
|
if test x$lyx_cv_rtti = xyes ; then
|
|
AC_DEFINE(HAVE_RTTI, 1,
|
|
[Define to 1 if your compiler supports runtime type information])
|
|
fi])
|
|
|
|
|
|
dnl Usage: LYX_CXX_EXPLICIT : checks whether the C++ compiler
|
|
dnl understands the "explicit" directive.
|
|
AC_DEFUN(LYX_CXX_EXPLICIT,[
|
|
### Check whether the compiler understands the keyword `explicit'
|
|
AC_CACHE_CHECK(whether the C++ compiler understands explicit,lyx_cv_explicit,
|
|
[AC_TRY_COMPILE([
|
|
class Expl {
|
|
public:
|
|
explicit Expl() {};
|
|
};],,lyx_cv_explicit=yes,lyx_cv_explicit=no)
|
|
])
|
|
if test $lyx_cv_explicit = no ; then
|
|
AC_DEFINE(explicit,[ ],
|
|
[Define to nothing if your compiler does not understand the
|
|
'explicit' directive])
|
|
fi])
|
|
|
|
|
|
dnl Usage: LYX_CXX_STL_STACK : checks whether the C++ compiler
|
|
dnl has a working stl stack template
|
|
AC_DEFUN(LYX_CXX_STL_STACK,[
|
|
AC_CACHE_CHECK(for broken STL stack template,lyx_cv_broken_stack,
|
|
[AC_TRY_COMPILE([
|
|
#include <stack>
|
|
using std::stack;
|
|
],[
|
|
stack<int> stakk;
|
|
stakk.push(0);
|
|
],lyx_cv_broken_stack=no,lyx_cv_broken_stack=yes)
|
|
])
|
|
if test $lyx_cv_broken_stack = yes ; then
|
|
AC_DEFINE(BROKEN_STL_STACK, 1,
|
|
[Define if you have the STL from libg++ 2.7.x, where stack<> is not defined
|
|
correctly])
|
|
fi])
|
|
|
|
|
|
dnl Usage: LYX_STD_COUNT : checks wherer the C++ library have a conforming
|
|
dnl count template, if not the old HP version is assumed.
|
|
AC_DEFUN(LYX_STD_COUNT,[
|
|
AC_CACHE_CHECK(for conforming std::count,lyx_cv_std_count,
|
|
[AC_TRY_COMPILE([
|
|
#include <string>
|
|
#include <algorithm>
|
|
using std::string;
|
|
using std::count;
|
|
int countChar(string const & a, char const c)
|
|
{
|
|
return count(a.begin(), a.end(), c);
|
|
}
|
|
],[
|
|
string a("hello");
|
|
int i = countChar(a, 'l');
|
|
],lyx_cv_std_count=yes,lyx_cv_std_count=no)
|
|
])
|
|
if test $lyx_cv_std_count = yes ; then
|
|
AC_DEFINE(HAVE_STD_COUNT, 1,
|
|
[Define if you have a conforming std::count template, otherwise HP version of count template is assumed.])
|
|
fi])
|
|
|
|
|
|
dnl Usage: LYX_CXX_STL_MODERN_STREAMS : checks whether the C++ compiler
|
|
dnl supports modern STL streams
|
|
AC_DEFUN(LYX_CXX_STL_MODERN_STREAMS,[
|
|
AC_CACHE_CHECK(for modern STL streams,lyx_cv_modern_streams,
|
|
[AC_TRY_COMPILE([
|
|
#include <iostream>
|
|
],[
|
|
std::streambuf * test = std::cerr.rdbuf();
|
|
test->pubsync();
|
|
],lyx_cv_modern_streams=yes,lyx_cv_modern_streams=no)
|
|
])
|
|
if test $lyx_cv_modern_streams = yes ; then
|
|
AC_DEFINE(MODERN_STL_STREAMS, 1,
|
|
[Define if you have modern standard-compliant STL streams])
|
|
fi])
|
|
|
|
|
|
dnl Usage: LYX_CXX_STL_STRING : checks whether the C++ compiler
|
|
dnl has a std::string that is usable for LyX. LyX does not require this
|
|
dnl std::string to be standard.
|
|
AC_DEFUN(LYX_CXX_STL_STRING,[
|
|
AC_REQUIRE([LYX_PROG_CXX])
|
|
AC_MSG_CHECKING(whether the included std::string should be used)
|
|
AC_ARG_WITH(included-string,
|
|
[ --with-included-string use LyX string class instead of STL string],
|
|
[lyx_cv_with_included_string=$withval],
|
|
[AC_CACHE_CHECK([],lyx_cv_with_included_string,
|
|
[AC_TRY_COMPILE([
|
|
#include <string>
|
|
using std::string;
|
|
],[
|
|
// LyX has reduced its requirements on the basic_string
|
|
// implementation so that the basic_string supplied
|
|
// with gcc is usable. In particular this means that
|
|
// lyx does not use std::string::clear and not the
|
|
// strncmp version of std::string::compare. This is mainly
|
|
// done so that LyX can use precompiled C++ libraries that
|
|
// already uses the systems basic_string, e.g. gtk--
|
|
string a("hello there");
|
|
a.erase();
|
|
a = "hey";
|
|
//char s[] = "y";
|
|
//int t = a.compare(a.length() - 1, 1, s);
|
|
a.erase();
|
|
],[
|
|
lyx_cv_with_included_string=no
|
|
],[
|
|
lyx_cv_with_included_string=yes
|
|
])
|
|
])
|
|
])
|
|
if test x$lyx_cv_with_included_string = xyes ; then
|
|
AC_DEFINE(USE_INCLUDED_STRING, 1,
|
|
[Define to use the lyxstring class bundled with LyX.])
|
|
lyx_flags="$lyx_flags included-string"
|
|
fi
|
|
AM_CONDITIONAL(USE_LYXSTRING, test x$lyx_cv_with_included_string = xyes)
|
|
dnl AC_MSG_RESULT([$with_included_string])
|
|
])
|
|
|
|
|
|
dnl Usage: LYX_CXX_GOOD_STD_STRING : checks whether the C++ compiler
|
|
dnl has a std::string that is close to the standard. So close that
|
|
dnl methods not found in "unstandard" std::strings are present here.
|
|
AC_DEFUN(LYX_CXX_GOOD_STD_STRING,[
|
|
AC_REQUIRE([LYX_PROG_CXX])
|
|
AC_CACHE_CHECK([whether the systems std::string is really good],
|
|
[lyx_cv_std_string_good],
|
|
[AC_TRY_COMPILE([
|
|
#include <string>
|
|
using std::string;
|
|
],[
|
|
// From a std::string that is supposed to be close to the
|
|
// standard we require at least three things:
|
|
// - clear() and erase()
|
|
// - the strncmp of compare()
|
|
// - push_back()
|
|
string a("hello there");
|
|
a.erase();
|
|
a = "hey";
|
|
char s[] = "y";
|
|
int t = a.compare(a.length() - 1, 1, s);
|
|
a.push_back('g');
|
|
a.clear();
|
|
],[
|
|
lyx_cv_std_string_good=yes
|
|
],[
|
|
lyx_cv_std_string_good=no
|
|
|
|
])
|
|
])
|
|
if test x$lyx_cv_std_string_good = xyes ; then
|
|
AC_DEFINE(STD_STRING_IS_GOOD, 1,
|
|
[Define is the systems std::string is really good.])
|
|
fi
|
|
])
|
|
|
|
|
|
dnl Usage: LYX_REGEX : checks if the header regex.h is available
|
|
dnl if it is not available the automake variable USE_REGEX will be
|
|
dnl defined and the regex.h and regex.c that we provide will be used.
|
|
AC_DEFUN(LYX_REGEX,[
|
|
AC_CHECK_HEADERS(regex.h, lyx_regex=no, lyx_regex=yes)
|
|
AM_CONDITIONAL(USE_REGEX, test x$lyx_regex = xyes)
|
|
])
|
|
|
|
|
|
dnl LYX_CXX_MUTABLE
|
|
AC_DEFUN(LYX_CXX_MUTABLE, [
|
|
AC_REQUIRE([LYX_PROG_CXX])
|
|
AC_CACHE_CHECK([if C++ compiler supports mutable],
|
|
lyx_cv_cxx_mutable,[
|
|
AC_TRY_COMPILE(
|
|
[
|
|
class k {
|
|
mutable char *c;
|
|
public:
|
|
void foo() const { c=0; }
|
|
};
|
|
],[
|
|
],[
|
|
lyx_cv_cxx_mutable=yes
|
|
],[
|
|
lyx_cv_cxx_mutable=no
|
|
])
|
|
])
|
|
if test $lyx_cv_cxx_mutable = yes ; then
|
|
AC_DEFINE(HAVE_MUTABLE, 1,
|
|
[Defined if your compiler suports 'mutable'.])
|
|
fi
|
|
])
|
|
|
|
|
|
dnl LYX_CXX_PARTIAL
|
|
AC_DEFUN(LYX_CXX_PARTIAL, [
|
|
AC_REQUIRE([LYX_PROG_CXX])
|
|
AC_CACHE_CHECK([if C++ compiler supports partial specialization],
|
|
[lyx_cv_cxx_partial_specialization],
|
|
[AC_TRY_COMPILE(
|
|
[
|
|
template<class T, class K>
|
|
class k {
|
|
public:
|
|
};
|
|
template<class T> class k<void,T> { };
|
|
],[
|
|
k<float, float> b;
|
|
k<void,void> a;
|
|
],[
|
|
lyx_cv_cxx_partial_specialization=yes
|
|
],[
|
|
lyx_cv_cxx_partial_specialization=no
|
|
])
|
|
])
|
|
if test x$lyx_cv_cxx_partial_specialization = xyes ; then
|
|
AC_DEFINE(HAVE_PARTIAL_SPECIALIZATION, 1,
|
|
[Defined if your compiler supports partial specialization.])
|
|
fi
|
|
])
|
|
|
|
|
|
dnl Usage: LYX_CXX_NAMESPACES : checks whether the C++ compiler
|
|
dnl has a correct namespace handling and define CXX_WORKING_NAMESPACES
|
|
dnl if true. This macro does not do a thourough test, but it should be
|
|
dnl good enough to suit our needs.
|
|
AC_DEFUN(LYX_CXX_NAMESPACES,[
|
|
AC_CACHE_CHECK(for correct namespaces support,lyx_cv_cxx_namespace,
|
|
[AC_TRY_COMPILE([
|
|
namespace foo {
|
|
int bar;
|
|
}
|
|
],[
|
|
foo::bar = 0;
|
|
return 0;
|
|
],lyx_cv_cxx_namespace=yes,lyx_cv_cxx_namespace=no)
|
|
])
|
|
if test x$lyx_cv_cxx_namespace = xyes ; then
|
|
AC_DEFINE(CXX_WORKING_NAMESPACES, 1,
|
|
[Define if your C++ compiler has correct support for namespaces])
|
|
fi
|
|
])
|
|
|
|
|
|
dnl Usage: LYX_CXX_CHEADERS : checks whether the C++ compiler
|
|
dnl provides wrappers for C headers and use our alternate version otherwise.
|
|
AC_DEFUN(LYX_CXX_CHEADERS,[
|
|
AC_CACHE_CHECK(for C headers wrappers,lyx_cv_cxx_cheaders,
|
|
[AC_TRY_CPP([
|
|
#include <clocale>
|
|
#include <cctype>
|
|
#include <cerrno>
|
|
#include <cmath>
|
|
#include <csignal>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <ctime>],[lyx_cv_cxx_cheaders=yes],[lyx_cv_cxx_cheaders=no])])
|
|
if test $lyx_cv_cxx_cheaders = no ; then
|
|
LYX_ADD_INC_DIR(lyx_cppflags,\$(top_srcdir)/src/cheaders)
|
|
fi])
|
|
|
|
|
|
dnl Usage LYX_PATH_XPM: Checks for xpm library and header
|
|
AC_DEFUN(LYX_PATH_XPM,[
|
|
### Check for Xpm library
|
|
AC_CHECK_LIB(Xpm, XpmCreateBufferFromImage,LYX_LIBS="-lXpm $LYX_LIBS",
|
|
[LYX_LIB_ERROR(libXpm,Xpm)], $LYX_LIBS)
|
|
|
|
### Check for Xpm headers
|
|
lyx_cv_xpm_h_location="<xpm.h>"
|
|
AC_CHECK_HEADER(X11/xpm.h,[
|
|
ac_cv_header_xpm_h=yes
|
|
lyx_cv_xpm_h_location="<X11/xpm.h>"],[
|
|
AC_CHECK_HEADER(xpm.h,[],[
|
|
LYX_LIB_ERROR(xpm.h,Xpm)])])
|
|
AC_DEFINE_UNQUOTED(XPM_H_LOCATION,$lyx_cv_xpm_h_location)
|
|
|
|
### Test for the header version
|
|
if test $ac_cv_header_xpm_h = yes; then
|
|
AC_CACHE_CHECK([xpm header version],lyx_cv_xpmversion,
|
|
[ cat > conftest.$ac_ext <<EOF
|
|
#line __oline__ "configure"
|
|
#include "confdefs.h"
|
|
|
|
#include XPM_H_LOCATION
|
|
"%%%"lyx_cv_xpmv=XpmVersion;lyx_cv_xpmr=XpmRevision"%%%"
|
|
EOF
|
|
eval `(eval "$ac_cpp conftest.$ac_ext") 2>&5 | \
|
|
grep '^"%%%"' 2>/dev/null | \
|
|
sed -e 's/^"%%%"\(.*\)"%%%"/\1/' -e 's/ //g'`
|
|
case "$lyx_cv_xpmr" in
|
|
changequote(,)
|
|
[0-9]) lyxxpmr_alpha=`echo $lyx_cv_xpmr |tr 123456789 abcdefghi`
|
|
lyxxpmv_alpha=" (aka 3.$lyx_cv_xpmv$lyxxpmr_alpha)";;
|
|
changequote([,])
|
|
*) ;;
|
|
esac
|
|
lyx_cv_xpmversion="$lyx_cv_xpmv.$lyx_cv_xpmr$lyxxpmv_alpha"
|
|
rm -f conftest*])
|
|
case "$lyx_cv_xpmr" in
|
|
changequote(,)
|
|
[789]|[0-9][0-9]*) ;;
|
|
changequote([,])
|
|
*) LYX_WARNING([Version $lyx_cv_xpmversion of the Xpm library is a bit old.
|
|
If you experience strange crashes with LyX, try to upgrade
|
|
to at least version 4.7 (aka 3.4g).
|
|
If you have installed a newer version of the library, check whether you
|
|
have an old xpm.h header file in your include path.]);;
|
|
esac
|
|
fi])
|
|
|
|
|
|
dnl Usage LYX_PATH_XFORMS: Checks for xforms library and flags
|
|
AC_DEFUN(LYX_PATH_XFORMS,[
|
|
### Check for xforms library
|
|
AC_CHECK_LIB(forms, fl_initialize, LYX_LIBS="-lforms $LYX_LIBS",
|
|
[AC_CHECK_LIB(xforms, fl_initialize, LYX_LIBS="-lxforms $LYX_LIBS",
|
|
[LYX_LIB_ERROR(libforms or libxforms,xforms)], $LYX_LIBS)], $LYX_LIBS)
|
|
|
|
### Check for xforms headers
|
|
lyx_cv_forms_h_location="<forms.h>"
|
|
AC_CHECK_HEADER(X11/forms.h,[
|
|
ac_cv_header_forms_h=yes
|
|
lyx_cv_forms_h_location="<X11/forms.h>"],[
|
|
AC_CHECK_HEADER(forms.h,[],[
|
|
LYX_LIB_ERROR(forms.h,forms)])])
|
|
AC_DEFINE_UNQUOTED(FORMS_H_LOCATION,$lyx_cv_forms_h_location)
|
|
if test $ac_cv_header_forms_h = yes; then
|
|
AC_CACHE_CHECK([xforms header version],lyx_cv_xfversion,
|
|
[ cat > conftest.$ac_ext <<EOF
|
|
#line __oline__ "configure"
|
|
#include "confdefs.h"
|
|
|
|
#include FORMS_H_LOCATION
|
|
#if ! defined(FL_INCLUDE_VERSION)
|
|
"%%%"(unknown)"%%%"
|
|
#else
|
|
"%%%"FL_VERSION.FL_REVISION"%%%"
|
|
#endif
|
|
EOF
|
|
lyx_cv_xfversion=`(eval "$ac_cpp conftest.$ac_ext") 2>&5 | \
|
|
grep '^"%%%"' 2>/dev/null | \
|
|
sed -e 's/^"%%%"\(.*\)"%%%"/\1/' -e 's/ //g'`
|
|
rm -f conftest*])
|
|
case "$lyx_cv_xfversion" in
|
|
"(unknown)"|0.8[1-7])
|
|
LYX_ERROR(dnl
|
|
Version $lyx_cv_xfversion of xforms is not compatible with LyX.
|
|
This version of LyX works best with versions 0.88 (recommended) and later.) ;;
|
|
0.88) ;;
|
|
0.89) LYX_WARNING(dnl
|
|
LyX should work ok with version $lyx_cv_xfversion of xforms[,] but
|
|
it is an unproven version and might still have some bugs. If you
|
|
have problems[,] please use version 0.88 instead.) ;;
|
|
*) LYX_WARNING(dnl
|
|
Version $lyx_cv_xfversion of xforms might not be compatible with LyX[,]
|
|
since it is newer than 0.88. You might have slight problems with it.);;
|
|
esac
|
|
fi])
|
|
|
|
|
|
dnl Usage: LYX_HPUX Checks for HP-UX and update CXXFLAGS accordingly
|
|
AC_DEFUN(LYX_HPUX,
|
|
[#It seems that HPUX requires using -fpcc-struct-return with gcc.
|
|
AC_CACHE_CHECK(for HP-UX,ac_cv_hpux,[
|
|
os=`uname -s | tr '[A-Z]' '[a-z]'`
|
|
ac_cv_hpux=no
|
|
test "$os" = hp-ux && ac_cv_hpux=yes])
|
|
if test "$ac_cv_hpux" = yes; then
|
|
test "x$GXX" = xyes && CXXFLAGS="$CXXFLAGS -fpcc-struct-return"
|
|
fi])
|
|
|
|
|
|
dnl Usage: LYX_SUNOS4 Checks for SunOS 4.x and sets the flag lyx_broken_headers
|
|
dnl if necessary
|
|
AC_DEFUN(LYX_SUNOS4,
|
|
[#The headers are not correct under SunOS4
|
|
AC_CACHE_CHECK(for SunOS 4.x,ac_cv_sunos4,[
|
|
changequote(, ) dnl
|
|
os=`uname -a | sed -e 's/^\([^ ]*\) [^ ]* \([0-9]\)\..*/\1\2/'`
|
|
changequote([, ]) dnl
|
|
ac_cv_sunos4=no
|
|
test "$os" = SunOS4 && ac_cv_sunos4=yes])
|
|
if test "$ac_cv_sunos4" = yes; then
|
|
test "x$GXX" = xyes && lyx_broken_headers=yes
|
|
fi])
|
|
|
|
|
|
dnl Usage: LYX_SCO Checks for SCO and sets the flag lyx_broken_headers
|
|
dnl if necessary
|
|
AC_DEFUN(LYX_SCO,
|
|
[AC_CACHE_CHECK(for SCO 3.2v4,ac_cv_sco,[
|
|
ac_cv_sco=no
|
|
if test `uname -s` != "SCO_SV"; then
|
|
lyx_machine_rel=`uname -m`:`uname -r`
|
|
if test $lyx_machine_rel = i386:3.2 || test $lyx_machine_rel = i486:3.2;
|
|
then
|
|
if test -f /usr/options/cb.name; then
|
|
ac_cv_sco=no
|
|
elif /bin/uname -X 2>/dev/null >/dev/null ; then
|
|
ac_cv_sco=yes
|
|
fi
|
|
fi
|
|
fi])
|
|
if test "$ac_cv_sco" = yes; then
|
|
test "x$GXX" = xyes && lyx_broken_headers=yes
|
|
fi])
|
|
|
|
dnl Usage: LYX_FUNC_PUTENV_ARGTYPE
|
|
dnl Checks whether putenv() takes 'char const *' or 'char *' as
|
|
dnl argument. This is needed because Solaris 7 (wrongly?) uses 'char *',
|
|
dnl while everybody else uses the former...
|
|
AC_DEFUN(LYX_FUNC_PUTENV_ARGTYPE,
|
|
[AC_MSG_CHECKING([type of argument for putenv()])
|
|
AC_CACHE_VAL(lyx_cv_func_putenv_arg,dnl
|
|
[AC_TRY_COMPILE(dnl
|
|
[#include <cstdlib>],
|
|
[char const * foo = "bar";
|
|
putenv(foo);],dnl
|
|
[lyx_cv_func_putenv_arg='char const *'],[lyx_cv_func_putenv_arg='char *'])])
|
|
AC_MSG_RESULT($lyx_cv_func_putenv_arg)
|
|
AC_DEFINE_UNQUOTED(PUTENV_TYPE_ARG,$lyx_cv_func_putenv_arg,dnl
|
|
[Define to the type of the argument of putenv(). Needed on Solaris 7.])])
|
|
|
|
|
|
dnl Usage: LYX_WITH_DIR(dir-name,desc,dir-var-name,default-value,
|
|
dnl [default-yes-value])
|
|
dnl Adds a --with-'dir-name' option (described by 'desc') and puts the
|
|
dnl resulting directory name in 'dir-var-name'.
|
|
AC_DEFUN(LYX_WITH_DIR,[
|
|
AC_ARG_WITH($1,[ --with-$1 specify $2])
|
|
AC_MSG_CHECKING([for $2])
|
|
if test -z "$with_$3"; then
|
|
AC_CACHE_VAL(lyx_cv_$3, lyx_cv_$3=$4)
|
|
else
|
|
test "x$with_$3" = xyes && with_$3=$5
|
|
lyx_cv_$3="$with_$3"
|
|
fi
|
|
AC_MSG_RESULT($lyx_cv_$3)])
|
|
|
|
|
|
dnl Usage: LYX_LOOP_DIR(value,action)
|
|
dnl Executes action for values of variable `dir' in `values'. `values' can
|
|
dnl use ":" as a separator.
|
|
AC_DEFUN(LYX_LOOP_DIR,[
|
|
IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
|
|
for dir in `eval "echo $1"`; do
|
|
if test ! "$dir" = NONE; then
|
|
test ! -d "$dir" && AC_ERROR([\"$dir\" is not a directory])
|
|
$2
|
|
fi
|
|
done
|
|
IFS=$ac_save_ifs
|
|
])
|
|
|
|
|
|
dnl Usage: LYX_ADD_LIB_DIR(var-name,dir) Adds a -L directive to variable
|
|
dnl var-name.
|
|
AC_DEFUN(LYX_ADD_LIB_DIR,[
|
|
$1="${$1} -L$2"
|
|
if test "`(uname) 2>/dev/null`" = SunOS &&
|
|
uname -r | grep '^5' >/dev/null; then
|
|
if test $ac_cv_prog_gxx = yes ; then
|
|
$1="${$1} -Wl[,]-R$2"
|
|
else
|
|
$1="${$1} -R$2"
|
|
fi
|
|
fi])
|
|
|
|
|
|
dnl Usage: LYX_ADD_INC_DIR(var-name,dir) Adds a -I directive to variable
|
|
dnl var-name.
|
|
AC_DEFUN(LYX_ADD_INC_DIR,[$1="${$1} -I$2 "])
|
|
|
|
### Check which libsigc++ we're using and make sure any external one works
|
|
### Check for libsigc++ library
|
|
AC_DEFUN(LYX_WITH_SIGC,
|
|
[AC_MSG_CHECKING(whether the included libsigc++ should be used)
|
|
AC_ARG_WITH([included-libsigc],
|
|
[ --without-included-libsigc
|
|
Use the libsigc++ installed on the system],
|
|
[lyx_use_included_libsigc=$withval],
|
|
[lyx_use_included_libsigc=yes])
|
|
AC_MSG_RESULT([$lyx_use_included_libsigc])
|
|
if test x$lyx_use_included_libsigc = xno; then
|
|
### Check for libsigc++
|
|
## can't use AC_SUBST right here!
|
|
AM_PATH_SIGC(0.8.7,
|
|
[ INCLUDED_SIGC=
|
|
],
|
|
[LYX_ERROR(dnl
|
|
[Cannot find libsigc++ library or headers at least as recent as 0.8.7.
|
|
Check your installation. Have you installed the development package?])
|
|
])
|
|
else
|
|
### Use the included libsigc++
|
|
### sigc-config hasn't been created yet so we can't just do the same as above
|
|
### unless of course someone gets keen and merges the sigc++ configure.in
|
|
### with this one. We don't really gain much by doing that though except
|
|
### a considerably smaller dist and more difficult maintenance.
|
|
### It'd also mean we'd have the equivalent of config/gettext.m4
|
|
lyx_flags="$lyx_flags included-libsigc"
|
|
SIGC_LIBS="\`\${top_builddir}/sigc++/sigc-config --libs-names | sed -e 's/-lsigc//'\`"
|
|
# Libsigc++ always installs into a subdirectory called sigc++. Therefore we
|
|
# have to always use #include <sigc++/signal_system.h> in our code.
|
|
# Remember if you decide to do anything to the sigc++ code to do your mods on
|
|
# the makeLyXsigc.sh script in development/tools using a current cvs checkout
|
|
# of libsigc++. A tarball distribution doesn't have everything in it that we
|
|
# need.
|
|
# We need both these -I entries to build when builddir != srcdir
|
|
if test "x$src_dir" = "x." ; then
|
|
SIGC_CFLAGS="-I\${top_srcdir}"
|
|
else
|
|
SIGC_CFLAGS="-I\${top_builddir} -I\${top_srcdir}"
|
|
fi
|
|
INCLUDED_SIGC="\${top_builddir}/sigc++/libsigc.la"
|
|
## can't substitute these here like this otherwise all remaining tests fail
|
|
## instead we SUBST directly into the Makefiles
|
|
##LIBS="$LIBS \$SIGC_LIBS"
|
|
##CPPFLAGS="$CPPFLAGS \$SIGC_CFLAGS"
|
|
AC_SUBST(SIGC_LIBS)
|
|
AC_SUBST(SIGC_CFLAGS)
|
|
fi
|
|
AC_SUBST(INCLUDED_SIGC)
|
|
])
|
|
|
|
### Check for a headers existence and location iff it exists
|
|
## This is supposed to be a generalised version of LYX_STL_STRING_FWD
|
|
## It almost works. I've tried a few variations but they give errors
|
|
## of one sort or other: bad substitution or file not found etc. The
|
|
## actual header _is_ found though and the cache variable is set however
|
|
## the reported setting (on screen) is equal to $ac_safe for some unknown
|
|
## reason.
|
|
## Additionally, autoheader can't figure out what to use as the name in
|
|
## the config.h.in file so we need to write our own entries there -- one for
|
|
## each header in the form PATH_HEADER_NAME_H
|
|
##
|
|
AC_DEFUN(LYX_PATH_HEADER,
|
|
[ AC_CHECK_HEADER($1,[
|
|
ac_tr_safe=PATH_`echo $ac_safe | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
|
|
### the only remaining problem is getting the second parameter to this
|
|
### AC_CACHE_CACHE to print correctly. Currently it just results in value
|
|
### of $ac_safe being printed.
|
|
AC_CACHE_CHECK([path to $1],[lyx_cv_path2_$ac_safe],
|
|
[ cat > conftest.$ac_ext <<EOF
|
|
#line __oline__ "configure"
|
|
#include "confdefs.h"
|
|
|
|
#include <$1>
|
|
EOF
|
|
lyx_path_header_path=`(eval "$ac_cpp conftest.$ac_ext") 2>&5 | \
|
|
grep $1 2>/dev/null | \
|
|
sed -e 's/.*\(".*$1"\).*/\1/' -e "1q"`
|
|
eval "lyx_cv_path2_${ac_safe}=\$lyx_path_header_path"
|
|
rm -f conftest*])
|
|
AC_DEFINE_UNQUOTED($ac_tr_safe, $lyx_path_header_path)])
|
|
])
|
|
### end of LYX_PATH_HEADER
|
|
|
|
### Check for stl_string_fwd.h existence and location if it exists
|
|
AC_DEFUN(LYX_STL_STRING_FWD,
|
|
[ AC_CHECK_HEADER(stl_string_fwd.h,[
|
|
AC_CACHE_CHECK([path to stl_string_fwd.h],lyx_cv_path_stl_string_fwd_h,
|
|
[ cat > conftest.$ac_ext <<EOF
|
|
#line __oline__ "configure"
|
|
#include "confdefs.h"
|
|
|
|
#include <stl_string_fwd.h>
|
|
EOF
|
|
lyx_cv_path_stl_string_fwd_h=`(eval "$ac_cpp conftest.$ac_ext") 2>&5 | \
|
|
grep 'stl_string_fwd.h' 2>/dev/null | \
|
|
sed -e 's/.*\(".*stl_string_fwd.h"\).*/\1/' -e "1q"`
|
|
rm -f conftest*])
|
|
AC_DEFINE_UNQUOTED(STL_STRING_FWD_H_LOCATION,$lyx_cv_path_stl_string_fwd_h,
|
|
[define this to the location of stl_string_fwd.h to be used with #include,
|
|
NOTE: Do not set it to <stl_string_fwd.h> as that will find the LyX
|
|
supplied version of the header.
|
|
e.g. <../include/stl_string_fwd.h> or better yet use an absolute path])])
|
|
])
|
|
|
|
|
|
dnl AC_VALIDATE_CACHE_SYSTEM_TYPE[(cmd)]
|
|
dnl if the cache file is inconsistent with the current host,
|
|
dnl target and build system types, execute CMD or print a default
|
|
dnl error message.
|
|
AC_DEFUN(AC_VALIDATE_CACHE_SYSTEM_TYPE, [
|
|
AC_REQUIRE([AC_CANONICAL_SYSTEM])
|
|
AC_MSG_CHECKING([config.cache system type])
|
|
if { test x"${ac_cv_host_system_type+set}" = x"set" &&
|
|
test x"$ac_cv_host_system_type" != x"$host"; } ||
|
|
{ test x"${ac_cv_build_system_type+set}" = x"set" &&
|
|
test x"$ac_cv_build_system_type" != x"$build"; } ||
|
|
{ test x"${ac_cv_target_system_type+set}" = x"set" &&
|
|
test x"$ac_cv_target_system_type" != x"$target"; }; then
|
|
AC_MSG_RESULT([different])
|
|
ifelse($#, 1, [$1],
|
|
[AC_MSG_ERROR(["you must remove config.cache and restart configure"])])
|
|
else
|
|
AC_MSG_RESULT([same])
|
|
fi
|
|
ac_cv_host_system_type="$host"
|
|
ac_cv_build_system_type="$build"
|
|
ac_cv_target_system_type="$target"
|
|
])
|
|
|
|
dnl We use this until autoconf fixes its version.
|
|
AC_DEFUN(LYX_FUNC_SELECT_ARGTYPES,
|
|
[AC_MSG_CHECKING([types of arguments for select()])
|
|
AC_CACHE_VAL(ac_cv_func_select_arg234,dnl
|
|
[AC_CACHE_VAL(ac_cv_func_select_arg1,dnl
|
|
[AC_CACHE_VAL(ac_cv_func_select_arg5,dnl
|
|
[for ac_cv_func_select_arg234 in 'fd_set *' 'int *' 'void *'; do
|
|
for ac_cv_func_select_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do for ac_cv_func_select_arg5 in 'struct timeval *' 'const struct timeval *'; do
|
|
AC_TRY_COMPILE(dnl
|
|
[#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_TIME_H
|
|
#include <sys/time.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_SELECT_H
|
|
#include <sys/select.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_SOCKET_H
|
|
#include <sys/socket.h>
|
|
#endif
|
|
extern int select ($ac_cv_func_select_arg1,$ac_cv_func_select_arg234,$ac_cv_func_select_arg234,$ac_cv_func_select_arg234,$ac_cv_func_select_arg5);],,dnl
|
|
[ac_not_found=no ; break 3],ac_not_found=yes)
|
|
done
|
|
done
|
|
done
|
|
])dnl AC_CACHE_VAL
|
|
])dnl AC_CACHE_VAL
|
|
])dnl AC_CACHE_VAL
|
|
if test "$ac_not_found" = yes; then
|
|
ac_cv_func_select_arg1=int
|
|
ac_cv_func_select_arg234='int *'
|
|
ac_cv_func_select_arg5='struct timeval *'
|
|
fi
|
|
AC_MSG_RESULT([$ac_cv_func_select_arg1,$ac_cv_func_select_arg234,$ac_cv_func_select_arg5])
|
|
AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG1,$ac_cv_func_select_arg1)
|
|
AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG234,($ac_cv_func_select_arg234))
|
|
AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG5,($ac_cv_func_select_arg5))
|
|
])
|
|
|
|
### Check which frontend we want to use. The default is XForms
|
|
###
|
|
AC_DEFUN(LYX_USE_FRONTEND,
|
|
[AC_MSG_CHECKING(what frontend should be used as main GUI)
|
|
AC_ARG_WITH(frontend,
|
|
[ --with-frontend[=value] Use THIS frontend as main GUI:
|
|
Possible values: xforms,kde,gtk],
|
|
[lyx_use_frontend="$withval"], [lyx_use_frontend="xforms"])
|
|
AC_MSG_RESULT($lyx_use_frontend)
|
|
lyx_flags="$lyx_flags frontend-$lyx_use_frontend"
|
|
AC_SUBST(FRONTEND)
|
|
AC_SUBST(FRONTEND_GUILIB)
|
|
AC_SUBST(FRONTEND_LDFLAGS)
|
|
AC_SUBST(FRONTEND_INCLUDES)
|
|
AC_SUBST(FRONTEND_LIBS)
|
|
])
|
|
## libtool.m4 - Configure libtool for the target system. -*-Shell-script-*-
|
|
## Copyright (C) 1996-1999 Free Software Foundation, Inc.
|
|
## Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
|
|
##
|
|
## This program is free software; you can redistribute it and/or modify
|
|
## it under the terms of the GNU General Public License as published by
|
|
## the Free Software Foundation; either version 2 of the License, or
|
|
## (at your option) any later version.
|
|
##
|
|
## This program is distributed in the hope that it will be useful, but
|
|
## WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
## General Public License for more details.
|
|
##
|
|
## You should have received a copy of the GNU General Public License
|
|
## along with this program; if not, write to the Free Software
|
|
## Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
##
|
|
## As a special exception to the GNU General Public License, if you
|
|
## distribute this file as part of a program that contains a
|
|
## configuration script generated by Autoconf, you may include it under
|
|
## the same distribution terms that you use for the rest of that program.
|
|
|
|
# serial 40 AC_PROG_LIBTOOL
|
|
AC_DEFUN(AC_PROG_LIBTOOL,
|
|
[AC_REQUIRE([AC_LIBTOOL_SETUP])dnl
|
|
|
|
# Save cache, so that ltconfig can load it
|
|
AC_CACHE_SAVE
|
|
|
|
# Actually configure libtool. ac_aux_dir is where install-sh is found.
|
|
CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
|
|
LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
|
|
LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" \
|
|
DLLTOOL="$DLLTOOL" AS="$AS" OBJDUMP="$OBJDUMP" \
|
|
${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
|
|
$libtool_flags --no-verify $ac_aux_dir/ltmain.sh $lt_target \
|
|
|| AC_MSG_ERROR([libtool configure failed])
|
|
|
|
# Reload cache, that may have been modified by ltconfig
|
|
AC_CACHE_LOAD
|
|
|
|
# This can be used to rebuild libtool when needed
|
|
LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh"
|
|
|
|
# Always use our own libtool.
|
|
LIBTOOL='$(SHELL) $(top_builddir)/libtool'
|
|
AC_SUBST(LIBTOOL)dnl
|
|
|
|
# Redirect the config.log output again, so that the ltconfig log is not
|
|
# clobbered by the next message.
|
|
exec 5>>./config.log
|
|
])
|
|
|
|
AC_DEFUN(AC_LIBTOOL_SETUP,
|
|
[AC_PREREQ(2.13)dnl
|
|
AC_REQUIRE([AC_ENABLE_SHARED])dnl
|
|
AC_REQUIRE([AC_ENABLE_STATIC])dnl
|
|
AC_REQUIRE([AC_ENABLE_FAST_INSTALL])dnl
|
|
AC_REQUIRE([AC_CANONICAL_HOST])dnl
|
|
AC_REQUIRE([AC_CANONICAL_BUILD])dnl
|
|
AC_REQUIRE([AC_PROG_RANLIB])dnl
|
|
AC_REQUIRE([AC_PROG_CC])dnl
|
|
AC_REQUIRE([AC_PROG_LD])dnl
|
|
AC_REQUIRE([AC_PROG_NM])dnl
|
|
AC_REQUIRE([AC_PROG_LN_S])dnl
|
|
dnl
|
|
|
|
case "$target" in
|
|
NONE) lt_target="$host" ;;
|
|
*) lt_target="$target" ;;
|
|
esac
|
|
|
|
# Check for any special flags to pass to ltconfig.
|
|
libtool_flags="--cache-file=$cache_file"
|
|
test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
|
|
test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
|
|
test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
|
|
test "$ac_cv_prog_gcc" = yes && libtool_flags="$libtool_flags --with-gcc"
|
|
test "$ac_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
|
|
ifdef([AC_PROVIDE_AC_LIBTOOL_DLOPEN],
|
|
[libtool_flags="$libtool_flags --enable-dlopen"])
|
|
ifdef([AC_PROVIDE_AC_LIBTOOL_WIN32_DLL],
|
|
[libtool_flags="$libtool_flags --enable-win32-dll"])
|
|
AC_ARG_ENABLE(libtool-lock,
|
|
[ --disable-libtool-lock avoid locking (might break parallel builds)])
|
|
test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
|
|
test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
|
|
|
|
# Some flags need to be propagated to the compiler or linker for good
|
|
# libtool support.
|
|
case "$lt_target" in
|
|
*-*-irix6*)
|
|
# Find out which ABI we are using.
|
|
echo '[#]line __oline__ "configure"' > conftest.$ac_ext
|
|
if AC_TRY_EVAL(ac_compile); then
|
|
case "`/usr/bin/file conftest.o`" in
|
|
*32-bit*)
|
|
LD="${LD-ld} -32"
|
|
;;
|
|
*N32*)
|
|
LD="${LD-ld} -n32"
|
|
;;
|
|
*64-bit*)
|
|
LD="${LD-ld} -64"
|
|
;;
|
|
esac
|
|
fi
|
|
rm -rf conftest*
|
|
;;
|
|
|
|
*-*-sco3.2v5*)
|
|
# On SCO OpenServer 5, we need -belf to get full-featured binaries.
|
|
SAVE_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS -belf"
|
|
AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,
|
|
[AC_TRY_LINK([],[],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])])
|
|
if test x"$lt_cv_cc_needs_belf" != x"yes"; then
|
|
# this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
|
|
CFLAGS="$SAVE_CFLAGS"
|
|
fi
|
|
;;
|
|
|
|
ifdef([AC_PROVIDE_AC_LIBTOOL_WIN32_DLL],
|
|
[*-*-cygwin* | *-*-mingw*)
|
|
AC_CHECK_TOOL(DLLTOOL, dlltool, false)
|
|
AC_CHECK_TOOL(AS, as, false)
|
|
AC_CHECK_TOOL(OBJDUMP, objdump, false)
|
|
;;
|
|
])
|
|
esac
|
|
])
|
|
|
|
# AC_LIBTOOL_DLOPEN - enable checks for dlopen support
|
|
AC_DEFUN(AC_LIBTOOL_DLOPEN, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])])
|
|
|
|
# AC_LIBTOOL_WIN32_DLL - declare package support for building win32 dll's
|
|
AC_DEFUN(AC_LIBTOOL_WIN32_DLL, [AC_BEFORE([$0], [AC_LIBTOOL_SETUP])])
|
|
|
|
# AC_ENABLE_SHARED - implement the --enable-shared flag
|
|
# Usage: AC_ENABLE_SHARED[(DEFAULT)]
|
|
# Where DEFAULT is either `yes' or `no'. If omitted, it defaults to
|
|
# `yes'.
|
|
AC_DEFUN(AC_ENABLE_SHARED, [dnl
|
|
define([AC_ENABLE_SHARED_DEFAULT], ifelse($1, no, no, yes))dnl
|
|
AC_ARG_ENABLE(shared,
|
|
changequote(<<, >>)dnl
|
|
<< --enable-shared[=PKGS] build shared libraries [default=>>AC_ENABLE_SHARED_DEFAULT],
|
|
changequote([, ])dnl
|
|
[p=${PACKAGE-default}
|
|
case "$enableval" in
|
|
yes) enable_shared=yes ;;
|
|
no) enable_shared=no ;;
|
|
*)
|
|
enable_shared=no
|
|
# Look at the argument we got. We use all the common list separators.
|
|
IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
|
|
for pkg in $enableval; do
|
|
if test "X$pkg" = "X$p"; then
|
|
enable_shared=yes
|
|
fi
|
|
done
|
|
IFS="$ac_save_ifs"
|
|
;;
|
|
esac],
|
|
enable_shared=AC_ENABLE_SHARED_DEFAULT)dnl
|
|
])
|
|
|
|
# AC_DISABLE_SHARED - set the default shared flag to --disable-shared
|
|
AC_DEFUN(AC_DISABLE_SHARED, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
|
|
AC_ENABLE_SHARED(no)])
|
|
|
|
# AC_ENABLE_STATIC - implement the --enable-static flag
|
|
# Usage: AC_ENABLE_STATIC[(DEFAULT)]
|
|
# Where DEFAULT is either `yes' or `no'. If omitted, it defaults to
|
|
# `yes'.
|
|
AC_DEFUN(AC_ENABLE_STATIC, [dnl
|
|
define([AC_ENABLE_STATIC_DEFAULT], ifelse($1, no, no, yes))dnl
|
|
AC_ARG_ENABLE(static,
|
|
changequote(<<, >>)dnl
|
|
<< --enable-static[=PKGS] build static libraries [default=>>AC_ENABLE_STATIC_DEFAULT],
|
|
changequote([, ])dnl
|
|
[p=${PACKAGE-default}
|
|
case "$enableval" in
|
|
yes) enable_static=yes ;;
|
|
no) enable_static=no ;;
|
|
*)
|
|
enable_static=no
|
|
# Look at the argument we got. We use all the common list separators.
|
|
IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
|
|
for pkg in $enableval; do
|
|
if test "X$pkg" = "X$p"; then
|
|
enable_static=yes
|
|
fi
|
|
done
|
|
IFS="$ac_save_ifs"
|
|
;;
|
|
esac],
|
|
enable_static=AC_ENABLE_STATIC_DEFAULT)dnl
|
|
])
|
|
|
|
# AC_DISABLE_STATIC - set the default static flag to --disable-static
|
|
AC_DEFUN(AC_DISABLE_STATIC, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
|
|
AC_ENABLE_STATIC(no)])
|
|
|
|
|
|
# AC_ENABLE_FAST_INSTALL - implement the --enable-fast-install flag
|
|
# Usage: AC_ENABLE_FAST_INSTALL[(DEFAULT)]
|
|
# Where DEFAULT is either `yes' or `no'. If omitted, it defaults to
|
|
# `yes'.
|
|
AC_DEFUN(AC_ENABLE_FAST_INSTALL, [dnl
|
|
define([AC_ENABLE_FAST_INSTALL_DEFAULT], ifelse($1, no, no, yes))dnl
|
|
AC_ARG_ENABLE(fast-install,
|
|
changequote(<<, >>)dnl
|
|
<< --enable-fast-install[=PKGS] optimize for fast installation [default=>>AC_ENABLE_FAST_INSTALL_DEFAULT],
|
|
changequote([, ])dnl
|
|
[p=${PACKAGE-default}
|
|
case "$enableval" in
|
|
yes) enable_fast_install=yes ;;
|
|
no) enable_fast_install=no ;;
|
|
*)
|
|
enable_fast_install=no
|
|
# Look at the argument we got. We use all the common list separators.
|
|
IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
|
|
for pkg in $enableval; do
|
|
if test "X$pkg" = "X$p"; then
|
|
enable_fast_install=yes
|
|
fi
|
|
done
|
|
IFS="$ac_save_ifs"
|
|
;;
|
|
esac],
|
|
enable_fast_install=AC_ENABLE_FAST_INSTALL_DEFAULT)dnl
|
|
])
|
|
|
|
# AC_ENABLE_FAST_INSTALL - set the default to --disable-fast-install
|
|
AC_DEFUN(AC_DISABLE_FAST_INSTALL, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
|
|
AC_ENABLE_FAST_INSTALL(no)])
|
|
|
|
# AC_PROG_LD - find the path to the GNU or non-GNU linker
|
|
AC_DEFUN(AC_PROG_LD,
|
|
[AC_ARG_WITH(gnu-ld,
|
|
[ --with-gnu-ld assume the C compiler uses GNU ld [default=no]],
|
|
test "$withval" = no || with_gnu_ld=yes, with_gnu_ld=no)
|
|
AC_REQUIRE([AC_PROG_CC])dnl
|
|
AC_REQUIRE([AC_CANONICAL_HOST])dnl
|
|
AC_REQUIRE([AC_CANONICAL_BUILD])dnl
|
|
ac_prog=ld
|
|
if test "$ac_cv_prog_gcc" = yes; then
|
|
# Check if gcc -print-prog-name=ld gives a path.
|
|
AC_MSG_CHECKING([for ld used by GCC])
|
|
ac_prog=`($CC -print-prog-name=ld) 2>&5`
|
|
case "$ac_prog" in
|
|
# Accept absolute paths.
|
|
changequote(,)dnl
|
|
[\\/]* | [A-Za-z]:[\\/]*)
|
|
re_direlt='/[^/][^/]*/\.\./'
|
|
changequote([,])dnl
|
|
# Canonicalize the path of ld
|
|
ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
|
|
while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
|
|
ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
|
|
done
|
|
test -z "$LD" && LD="$ac_prog"
|
|
;;
|
|
"")
|
|
# If it fails, then pretend we aren't using GCC.
|
|
ac_prog=ld
|
|
;;
|
|
*)
|
|
# If it is relative, then search for the first ld in PATH.
|
|
with_gnu_ld=unknown
|
|
;;
|
|
esac
|
|
elif test "$with_gnu_ld" = yes; then
|
|
AC_MSG_CHECKING([for GNU ld])
|
|
else
|
|
AC_MSG_CHECKING([for non-GNU ld])
|
|
fi
|
|
AC_CACHE_VAL(ac_cv_path_LD,
|
|
[if test -z "$LD"; then
|
|
IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
|
|
for ac_dir in $PATH; do
|
|
test -z "$ac_dir" && ac_dir=.
|
|
if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
|
|
ac_cv_path_LD="$ac_dir/$ac_prog"
|
|
# Check to see if the program is GNU ld. I'd rather use --version,
|
|
# but apparently some GNU ld's only accept -v.
|
|
# Break only if it was the GNU/non-GNU ld that we prefer.
|
|
if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
|
|
test "$with_gnu_ld" != no && break
|
|
else
|
|
test "$with_gnu_ld" != yes && break
|
|
fi
|
|
fi
|
|
done
|
|
IFS="$ac_save_ifs"
|
|
else
|
|
ac_cv_path_LD="$LD" # Let the user override the test with a path.
|
|
fi])
|
|
LD="$ac_cv_path_LD"
|
|
if test -n "$LD"; then
|
|
AC_MSG_RESULT($LD)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])
|
|
AC_PROG_LD_GNU
|
|
])
|
|
|
|
AC_DEFUN(AC_PROG_LD_GNU,
|
|
[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], ac_cv_prog_gnu_ld,
|
|
[# I'd rather use --version here, but apparently some GNU ld's only accept -v.
|
|
if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
|
|
ac_cv_prog_gnu_ld=yes
|
|
else
|
|
ac_cv_prog_gnu_ld=no
|
|
fi])
|
|
])
|
|
|
|
# AC_PROG_NM - find the path to a BSD-compatible name lister
|
|
AC_DEFUN(AC_PROG_NM,
|
|
[AC_MSG_CHECKING([for BSD-compatible nm])
|
|
AC_CACHE_VAL(ac_cv_path_NM,
|
|
[if test -n "$NM"; then
|
|
# Let the user override the test.
|
|
ac_cv_path_NM="$NM"
|
|
else
|
|
IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
|
|
for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
|
|
test -z "$ac_dir" && ac_dir=.
|
|
if test -f $ac_dir/nm || test -f $ac_dir/nm$ac_exeext ; then
|
|
# Check to see if the nm accepts a BSD-compat flag.
|
|
# Adding the `sed 1q' prevents false positives on HP-UX, which says:
|
|
# nm: unknown option "B" ignored
|
|
if ($ac_dir/nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
|
|
ac_cv_path_NM="$ac_dir/nm -B"
|
|
break
|
|
elif ($ac_dir/nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
|
|
ac_cv_path_NM="$ac_dir/nm -p"
|
|
break
|
|
else
|
|
ac_cv_path_NM=${ac_cv_path_NM="$ac_dir/nm"} # keep the first match, but
|
|
continue # so that we can try to find one that supports BSD flags
|
|
fi
|
|
fi
|
|
done
|
|
IFS="$ac_save_ifs"
|
|
test -z "$ac_cv_path_NM" && ac_cv_path_NM=nm
|
|
fi])
|
|
NM="$ac_cv_path_NM"
|
|
AC_MSG_RESULT([$NM])
|
|
])
|
|
|
|
# AC_CHECK_LIBM - check for math library
|
|
AC_DEFUN(AC_CHECK_LIBM,
|
|
[AC_REQUIRE([AC_CANONICAL_HOST])dnl
|
|
LIBM=
|
|
case "$lt_target" in
|
|
*-*-beos* | *-*-cygwin*)
|
|
# These system don't have libm
|
|
;;
|
|
*-ncr-sysv4.3*)
|
|
AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw")
|
|
AC_CHECK_LIB(m, main, LIBM="$LIBM -lm")
|
|
;;
|
|
*)
|
|
AC_CHECK_LIB(m, main, LIBM="-lm")
|
|
;;
|
|
esac
|
|
])
|
|
|
|
# AC_LIBLTDL_CONVENIENCE[(dir)] - sets LIBLTDL to the link flags for
|
|
# the libltdl convenience library, adds --enable-ltdl-convenience to
|
|
# the configure arguments. Note that LIBLTDL is not AC_SUBSTed, nor
|
|
# is AC_CONFIG_SUBDIRS called. If DIR is not provided, it is assumed
|
|
# to be `${top_builddir}/libltdl'. Make sure you start DIR with
|
|
# '${top_builddir}/' (note the single quotes!) if your package is not
|
|
# flat, and, if you're not using automake, define top_builddir as
|
|
# appropriate in the Makefiles.
|
|
AC_DEFUN(AC_LIBLTDL_CONVENIENCE, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
|
|
case "$enable_ltdl_convenience" in
|
|
no) AC_MSG_ERROR([this package needs a convenience libltdl]) ;;
|
|
"") enable_ltdl_convenience=yes
|
|
ac_configure_args="$ac_configure_args --enable-ltdl-convenience" ;;
|
|
esac
|
|
LIBLTDL=ifelse($#,1,$1,['${top_builddir}/libltdl'])/libltdlc.la
|
|
INCLTDL=ifelse($#,1,-I$1,['-I${top_builddir}/libltdl'])
|
|
])
|
|
|
|
# AC_LIBLTDL_INSTALLABLE[(dir)] - sets LIBLTDL to the link flags for
|
|
# the libltdl installable library, and adds --enable-ltdl-install to
|
|
# the configure arguments. Note that LIBLTDL is not AC_SUBSTed, nor
|
|
# is AC_CONFIG_SUBDIRS called. If DIR is not provided, it is assumed
|
|
# to be `${top_builddir}/libltdl'. Make sure you start DIR with
|
|
# '${top_builddir}/' (note the single quotes!) if your package is not
|
|
# flat, and, if you're not using automake, define top_builddir as
|
|
# appropriate in the Makefiles.
|
|
# In the future, this macro may have to be called after AC_PROG_LIBTOOL.
|
|
AC_DEFUN(AC_LIBLTDL_INSTALLABLE, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
|
|
AC_CHECK_LIB(ltdl, main,
|
|
[test x"$enable_ltdl_install" != xyes && enable_ltdl_install=no],
|
|
[if test x"$enable_ltdl_install" = xno; then
|
|
AC_MSG_WARN([libltdl not installed, but installation disabled])
|
|
else
|
|
enable_ltdl_install=yes
|
|
fi
|
|
])
|
|
if test x"$enable_ltdl_install" = x"yes"; then
|
|
ac_configure_args="$ac_configure_args --enable-ltdl-install"
|
|
LIBLTDL=ifelse($#,1,$1,['${top_builddir}/libltdl'])/libltdl.la
|
|
INCLTDL=ifelse($#,1,-I$1,['-I${top_builddir}/libltdl'])
|
|
else
|
|
ac_configure_args="$ac_configure_args --enable-ltdl-install=no"
|
|
LIBLTDL="-lltdl"
|
|
INCLTDL=
|
|
fi
|
|
])
|
|
|
|
dnl old names
|
|
AC_DEFUN(AM_PROG_LIBTOOL, [indir([AC_PROG_LIBTOOL])])dnl
|
|
AC_DEFUN(AM_ENABLE_SHARED, [indir([AC_ENABLE_SHARED], $@)])dnl
|
|
AC_DEFUN(AM_ENABLE_STATIC, [indir([AC_ENABLE_STATIC], $@)])dnl
|
|
AC_DEFUN(AM_DISABLE_SHARED, [indir([AC_DISABLE_SHARED], $@)])dnl
|
|
AC_DEFUN(AM_DISABLE_STATIC, [indir([AC_DISABLE_STATIC], $@)])dnl
|
|
AC_DEFUN(AM_PROG_LD, [indir([AC_PROG_LD])])dnl
|
|
AC_DEFUN(AM_PROG_NM, [indir([AC_PROG_NM])])dnl
|
|
|
|
dnl This is just to silence aclocal about the macro not being used
|
|
ifelse([AC_DISABLE_FAST_INSTALL])dnl
|
|
# Macro to add for using GNU gettext.
|
|
# Ulrich Drepper <drepper@cygnus.com>, 1995.
|
|
#
|
|
# This file can be copied and used freely without restrictions. It can
|
|
# be used in projects which are not available under the GNU Public License
|
|
# but which still want to provide support for the GNU gettext functionality.
|
|
# Please note that the actual code is *not* freely available.
|
|
|
|
# serial 5
|
|
|
|
AC_DEFUN(AM_WITH_NLS,
|
|
[AC_MSG_CHECKING([whether NLS is requested])
|
|
dnl Default is enabled NLS
|
|
AC_ARG_ENABLE(nls,
|
|
[ --disable-nls do not use Native Language Support],
|
|
USE_NLS=$enableval, USE_NLS=yes)
|
|
AC_MSG_RESULT($USE_NLS)
|
|
AC_SUBST(USE_NLS)
|
|
|
|
USE_INCLUDED_LIBINTL=no
|
|
|
|
dnl If we use NLS figure out what method
|
|
if test "$USE_NLS" = "yes"; then
|
|
AC_DEFINE(ENABLE_NLS)
|
|
AC_MSG_CHECKING([whether included gettext is requested])
|
|
AC_ARG_WITH(included-gettext,
|
|
[ --with-included-gettext use the GNU gettext library included here],
|
|
nls_cv_force_use_gnu_gettext=$withval,
|
|
nls_cv_force_use_gnu_gettext=no)
|
|
AC_MSG_RESULT($nls_cv_force_use_gnu_gettext)
|
|
|
|
nls_cv_use_gnu_gettext="$nls_cv_force_use_gnu_gettext"
|
|
if test "$nls_cv_force_use_gnu_gettext" != "yes"; then
|
|
dnl User does not insist on using GNU NLS library. Figure out what
|
|
dnl to use. If gettext or catgets are available (in this order) we
|
|
dnl use this. Else we have to fall back to GNU NLS library.
|
|
dnl catgets is only used if permitted by option --with-catgets.
|
|
nls_cv_header_intl=
|
|
nls_cv_header_libgt=
|
|
CATOBJEXT=NONE
|
|
|
|
AC_CHECK_HEADER(libintl.h,
|
|
[AC_CACHE_CHECK([for gettext in libc], gt_cv_func_gettext_libc,
|
|
[AC_TRY_LINK([#include <libintl.h>], [return (int) gettext ("")],
|
|
gt_cv_func_gettext_libc=yes, gt_cv_func_gettext_libc=no)])
|
|
|
|
if test "$gt_cv_func_gettext_libc" != "yes"; then
|
|
AC_CHECK_LIB(intl, bindtextdomain,
|
|
[AC_CACHE_CHECK([for gettext in libintl],
|
|
gt_cv_func_gettext_libintl,
|
|
[AC_CHECK_LIB(intl, gettext,
|
|
dnl ============== A fix is here! ======================
|
|
dnl -lintl was not added to the LIBS variable in this case
|
|
[gt_cv_func_gettext_libintl=yes
|
|
INTLLIBS="-lintl"],
|
|
dnl ==== end of fix
|
|
gt_cv_func_gettext_libintl=no)],
|
|
gt_cv_func_gettext_libintl=no)])
|
|
fi
|
|
|
|
if test "$gt_cv_func_gettext_libc" = "yes" \
|
|
|| test "$gt_cv_func_gettext_libintl" = "yes"; then
|
|
AC_DEFINE(HAVE_GETTEXT)
|
|
AM_PATH_PROG_WITH_TEST(MSGFMT, msgfmt,
|
|
[test -z "`$ac_dir/$ac_word -h 2>&1 | grep 'dv '`"], no)dnl
|
|
if test "$MSGFMT" != "no"; then
|
|
AC_CHECK_FUNCS(dcgettext)
|
|
AC_PATH_PROG(GMSGFMT, gmsgfmt, $MSGFMT)
|
|
AM_PATH_PROG_WITH_TEST(XGETTEXT, xgettext,
|
|
[test -z "`$ac_dir/$ac_word -h 2>&1 | grep '(HELP)'`"], :)
|
|
AC_TRY_LINK(, [extern int _nl_msg_cat_cntr;
|
|
return _nl_msg_cat_cntr],
|
|
[CATOBJEXT=.gmo
|
|
DATADIRNAME=share],
|
|
[CATOBJEXT=.mo
|
|
DATADIRNAME=lib])
|
|
INSTOBJEXT=.mo
|
|
fi
|
|
fi
|
|
])
|
|
|
|
if test "$CATOBJEXT" = "NONE"; then
|
|
AC_MSG_CHECKING([whether catgets can be used])
|
|
AC_ARG_WITH(catgets,
|
|
[ --with-catgets use catgets functions if available],
|
|
nls_cv_use_catgets=$withval, nls_cv_use_catgets=no)
|
|
AC_MSG_RESULT($nls_cv_use_catgets)
|
|
|
|
if test "$nls_cv_use_catgets" = "yes"; then
|
|
dnl No gettext in C library. Try catgets next.
|
|
AC_CHECK_LIB(i, main)
|
|
AC_CHECK_FUNC(catgets,
|
|
[AC_DEFINE(HAVE_CATGETS)
|
|
INTLOBJS="\$(CATOBJS)"
|
|
AC_PATH_PROG(GENCAT, gencat, no)dnl
|
|
if test "$GENCAT" != "no"; then
|
|
AC_PATH_PROG(GMSGFMT, gmsgfmt, no)
|
|
if test "$GMSGFMT" = "no"; then
|
|
AM_PATH_PROG_WITH_TEST(GMSGFMT, msgfmt,
|
|
[test -z "`$ac_dir/$ac_word -h 2>&1 | grep 'dv '`"], no)
|
|
fi
|
|
AM_PATH_PROG_WITH_TEST(XGETTEXT, xgettext,
|
|
[test -z "`$ac_dir/$ac_word -h 2>&1 | grep '(HELP)'`"], :)
|
|
USE_INCLUDED_LIBINTL=yes
|
|
CATOBJEXT=.cat
|
|
INSTOBJEXT=.cat
|
|
DATADIRNAME=lib
|
|
INTLDEPS='$(top_builddir)/intl/libintl.a'
|
|
INTLLIBS=$INTLDEPS
|
|
LIBS=`echo $LIBS | sed -e 's/-lintl//'`
|
|
nls_cv_header_intl=intl/libintl.h
|
|
nls_cv_header_libgt=intl/libgettext.h
|
|
fi])
|
|
fi
|
|
fi
|
|
|
|
if test "$CATOBJEXT" = "NONE"; then
|
|
dnl Neither gettext nor catgets in included in the C library.
|
|
dnl Fall back on GNU gettext library.
|
|
nls_cv_use_gnu_gettext=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$nls_cv_use_gnu_gettext" = "yes"; then
|
|
dnl Mark actions used to generate GNU NLS library.
|
|
INTLOBJS="\$(GETTOBJS)"
|
|
AM_PATH_PROG_WITH_TEST(MSGFMT, msgfmt,
|
|
[test -z "`$ac_dir/$ac_word -h 2>&1 | grep 'dv '`"], msgfmt)
|
|
AC_PATH_PROG(GMSGFMT, gmsgfmt, $MSGFMT)
|
|
AM_PATH_PROG_WITH_TEST(XGETTEXT, xgettext,
|
|
[test -z "`$ac_dir/$ac_word -h 2>&1 | grep '(HELP)'`"], :)
|
|
AC_SUBST(MSGFMT)
|
|
USE_INCLUDED_LIBINTL=yes
|
|
CATOBJEXT=.gmo
|
|
INSTOBJEXT=.mo
|
|
DATADIRNAME=share
|
|
INTLDEPS='$(top_builddir)/intl/libintl.a'
|
|
INTLLIBS=$INTLDEPS
|
|
LIBS=`echo $LIBS | sed -e 's/-lintl//'`
|
|
nls_cv_header_intl=intl/libintl.h
|
|
nls_cv_header_libgt=intl/libgettext.h
|
|
fi
|
|
|
|
dnl Test whether we really found GNU xgettext.
|
|
if test "$XGETTEXT" != ":"; then
|
|
dnl If it is no GNU xgettext we define it as : so that the
|
|
dnl Makefiles still can work.
|
|
if $XGETTEXT --omit-header /dev/null 2> /dev/null; then
|
|
: ;
|
|
else
|
|
AC_MSG_RESULT(
|
|
[found xgettext program is not GNU xgettext; ignore it])
|
|
XGETTEXT=":"
|
|
fi
|
|
fi
|
|
|
|
# We need to process the po/ directory.
|
|
POSUB=po
|
|
else
|
|
DATADIRNAME=share
|
|
nls_cv_header_intl=intl/libintl.h
|
|
nls_cv_header_libgt=intl/libgettext.h
|
|
fi
|
|
AC_LINK_FILES($nls_cv_header_libgt, $nls_cv_header_intl)
|
|
AC_OUTPUT_COMMANDS(
|
|
[case "$CONFIG_FILES" in *po/Makefile.in*)
|
|
sed -e "/POTFILES =/r po/POTFILES" po/Makefile.in > po/Makefile
|
|
esac])
|
|
|
|
|
|
# If this is used in GNU gettext we have to set USE_NLS to `yes'
|
|
# because some of the sources are only built for this goal.
|
|
if test "$PACKAGE" = gettext; then
|
|
USE_NLS=yes
|
|
USE_INCLUDED_LIBINTL=yes
|
|
fi
|
|
|
|
dnl These rules are solely for the distribution goal. While doing this
|
|
dnl we only have to keep exactly one list of the available catalogs
|
|
dnl in configure.in.
|
|
for lang in $ALL_LINGUAS; do
|
|
GMOFILES="$GMOFILES $lang.gmo"
|
|
POFILES="$POFILES $lang.po"
|
|
done
|
|
|
|
dnl Make all variables we use known to autoconf.
|
|
AC_SUBST(USE_INCLUDED_LIBINTL)
|
|
AC_SUBST(CATALOGS)
|
|
AC_SUBST(CATOBJEXT)
|
|
AC_SUBST(DATADIRNAME)
|
|
AC_SUBST(GMOFILES)
|
|
AC_SUBST(INSTOBJEXT)
|
|
AC_SUBST(INTLDEPS)
|
|
AC_SUBST(INTLLIBS)
|
|
AC_SUBST(INTLOBJS)
|
|
AC_SUBST(POFILES)
|
|
AC_SUBST(POSUB)
|
|
])
|
|
|
|
AC_DEFUN(AM_GNU_GETTEXT,
|
|
[AC_REQUIRE([AC_PROG_MAKE_SET])dnl
|
|
AC_REQUIRE([AC_PROG_CC])dnl
|
|
AC_REQUIRE([AC_PROG_RANLIB])dnl
|
|
AC_REQUIRE([AC_ISC_POSIX])dnl
|
|
AC_REQUIRE([AC_HEADER_STDC])dnl
|
|
AC_REQUIRE([AC_C_CONST])dnl
|
|
AC_REQUIRE([AC_C_INLINE])dnl
|
|
AC_REQUIRE([AC_TYPE_OFF_T])dnl
|
|
AC_REQUIRE([AC_TYPE_SIZE_T])dnl
|
|
AC_REQUIRE([AC_FUNC_ALLOCA])dnl
|
|
AC_REQUIRE([AC_FUNC_MMAP])dnl
|
|
|
|
AC_CHECK_HEADERS([argz.h limits.h locale.h nl_types.h malloc.h string.h \
|
|
unistd.h sys/param.h])
|
|
AC_CHECK_FUNCS([getcwd munmap putenv setenv setlocale strchr strcasecmp \
|
|
strdup __argz_count __argz_stringify __argz_next])
|
|
|
|
if test "${ac_cv_func_stpcpy+set}" != "set"; then
|
|
AC_CHECK_FUNCS(stpcpy)
|
|
fi
|
|
if test "${ac_cv_func_stpcpy}" = "yes"; then
|
|
AC_DEFINE(HAVE_STPCPY)
|
|
fi
|
|
|
|
AM_LC_MESSAGES
|
|
AM_WITH_NLS
|
|
|
|
if test "x$CATOBJEXT" != "x"; then
|
|
if test "x$ALL_LINGUAS" = "x"; then
|
|
LINGUAS=
|
|
else
|
|
AC_MSG_CHECKING(for catalogs to be installed)
|
|
NEW_LINGUAS=
|
|
dnl ============== Fix is here! ======================
|
|
dnl Some sh do not like substitution in bounds of for loops
|
|
dnl for lang in ${LINGUAS=$ALL_LINGUAS}; do
|
|
tmplinguas=${LINGUAS=$ALL_LINGUAS}
|
|
for lang in ${tmplinguas}; do
|
|
dnl ==== end of fix
|
|
case "$ALL_LINGUAS" in
|
|
*$lang*) NEW_LINGUAS="$NEW_LINGUAS $lang" ;;
|
|
esac
|
|
done
|
|
LINGUAS=$NEW_LINGUAS
|
|
AC_MSG_RESULT($LINGUAS)
|
|
fi
|
|
|
|
dnl Construct list of names of catalog files to be constructed.
|
|
if test -n "$LINGUAS"; then
|
|
for lang in $LINGUAS; do CATALOGS="$CATALOGS $lang$CATOBJEXT"; done
|
|
fi
|
|
fi
|
|
|
|
dnl The reference to <locale.h> in the installed <libintl.h> file
|
|
dnl must be resolved because we cannot expect the users of this
|
|
dnl to define HAVE_LOCALE_H.
|
|
if test $ac_cv_header_locale_h = yes; then
|
|
INCLUDE_LOCALE_H="#include <locale.h>"
|
|
else
|
|
INCLUDE_LOCALE_H="\
|
|
/* The system does not provide the header <locale.h>. Take care yourself. */"
|
|
fi
|
|
AC_SUBST(INCLUDE_LOCALE_H)
|
|
|
|
dnl Determine which catalog format we have (if any is needed)
|
|
dnl For now we know about two different formats:
|
|
dnl Linux libc-5 and the normal X/Open format
|
|
test -d intl || mkdir intl
|
|
if test "$CATOBJEXT" = ".cat"; then
|
|
AC_CHECK_HEADER(linux/version.h, msgformat=linux, msgformat=xopen)
|
|
|
|
dnl Transform the SED scripts while copying because some dumb SEDs
|
|
dnl cannot handle comments.
|
|
sed -e '/^#/d' $srcdir/intl/$msgformat-msg.sed > intl/po2msg.sed
|
|
fi
|
|
dnl po2tbl.sed is always needed.
|
|
sed -e '/^#.*[^\\]$/d' -e '/^#$/d' \
|
|
$srcdir/intl/po2tbl.sed.in > intl/po2tbl.sed
|
|
|
|
dnl In the intl/Makefile.in we have a special dependency which makes
|
|
dnl only sense for gettext. We comment this out for non-gettext
|
|
dnl packages.
|
|
if test "$PACKAGE" = "gettext"; then
|
|
GT_NO="#NO#"
|
|
GT_YES=
|
|
else
|
|
GT_NO=
|
|
GT_YES="#YES#"
|
|
fi
|
|
AC_SUBST(GT_NO)
|
|
AC_SUBST(GT_YES)
|
|
|
|
dnl If the AC_CONFIG_AUX_DIR macro for autoconf is used we possibly
|
|
dnl find the mkinstalldirs script in another subdir but ($top_srcdir).
|
|
dnl Try to locate is.
|
|
MKINSTALLDIRS=
|
|
if test -n "$ac_aux_dir"; then
|
|
MKINSTALLDIRS="$ac_aux_dir/mkinstalldirs"
|
|
fi
|
|
if test -z "$MKINSTALLDIRS"; then
|
|
MKINSTALLDIRS="\$(top_srcdir)/mkinstalldirs"
|
|
fi
|
|
AC_SUBST(MKINSTALLDIRS)
|
|
|
|
dnl *** For now the libtool support in intl/Makefile is not for real.
|
|
l=
|
|
AC_SUBST(l)
|
|
|
|
dnl Generate list of files to be processed by xgettext which will
|
|
dnl be included in po/Makefile.
|
|
test -d po || mkdir po
|
|
if test "x$srcdir" != "x."; then
|
|
if test "x`echo $srcdir | sed 's@/.*@@'`" = "x"; then
|
|
posrcprefix="$srcdir/"
|
|
else
|
|
posrcprefix="../$srcdir/"
|
|
fi
|
|
else
|
|
posrcprefix="../"
|
|
fi
|
|
rm -f po/POTFILES
|
|
sed -e "/^#/d" -e "/^\$/d" -e "s,.*, $posrcprefix& \\\\," -e "\$s/\(.*\) \\\\/\1/" \
|
|
< $srcdir/po/POTFILES.in > po/POTFILES
|
|
])
|
|
# Check whether LC_MESSAGES is available in <locale.h>.
|
|
# Ulrich Drepper <drepper@cygnus.com>, 1995.
|
|
#
|
|
# This file can be copied and used freely without restrictions. It can
|
|
# be used in projects which are not available under the GNU Public License
|
|
# but which still want to provide support for the GNU gettext functionality.
|
|
# Please note that the actual code is *not* freely available.
|
|
|
|
# serial 1
|
|
|
|
AC_DEFUN(AM_LC_MESSAGES,
|
|
[if test $ac_cv_header_locale_h = yes; then
|
|
AC_CACHE_CHECK([for LC_MESSAGES], am_cv_val_LC_MESSAGES,
|
|
[AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
|
|
am_cv_val_LC_MESSAGES=yes, am_cv_val_LC_MESSAGES=no)])
|
|
if test $am_cv_val_LC_MESSAGES = yes; then
|
|
AC_DEFINE(HAVE_LC_MESSAGES)
|
|
fi
|
|
fi])
|
|
# Search path for a program which passes the given test.
|
|
# Ulrich Drepper <drepper@cygnus.com>, 1996.
|
|
#
|
|
# This file can be copied and used freely without restrictions. It can
|
|
# be used in projects which are not available under the GNU Public License
|
|
# but which still want to provide support for the GNU gettext functionality.
|
|
# Please note that the actual code is *not* freely available.
|
|
|
|
# serial 1
|
|
|
|
dnl AM_PATH_PROG_WITH_TEST(VARIABLE, PROG-TO-CHECK-FOR,
|
|
dnl TEST-PERFORMED-ON-FOUND_PROGRAM [, VALUE-IF-NOT-FOUND [, PATH]])
|
|
AC_DEFUN(AM_PATH_PROG_WITH_TEST,
|
|
[# Extract the first word of "$2", so it can be a program name with args.
|
|
set dummy $2; ac_word=[$]2
|
|
AC_MSG_CHECKING([for $ac_word])
|
|
AC_CACHE_VAL(ac_cv_path_$1,
|
|
[case "[$]$1" in
|
|
/*)
|
|
ac_cv_path_$1="[$]$1" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
|
|
for ac_dir in ifelse([$5], , $PATH, [$5]); do
|
|
test -z "$ac_dir" && ac_dir=.
|
|
if test -f $ac_dir/$ac_word; then
|
|
if [$3]; then
|
|
ac_cv_path_$1="$ac_dir/$ac_word"
|
|
break
|
|
fi
|
|
fi
|
|
done
|
|
IFS="$ac_save_ifs"
|
|
dnl If no 4th arg is given, leave the cache variable unset,
|
|
dnl so AC_PATH_PROGS will keep looking.
|
|
ifelse([$4], , , [ test -z "[$]ac_cv_path_$1" && ac_cv_path_$1="$4"
|
|
])dnl
|
|
;;
|
|
esac])dnl
|
|
$1="$ac_cv_path_$1"
|
|
if test -n "[$]$1"; then
|
|
AC_MSG_RESULT([$]$1)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
AC_SUBST($1)dnl
|
|
])
|
|
# Configure paths for Libsigc++
|
|
# Based on Gtk-- script by Erik Andersen and Tero Pulkkinen
|
|
|
|
dnl Test for Libsigc++, and define SIGC_CFLAGS and SIGC_LIBS
|
|
dnl to be used as follows:
|
|
dnl AM_PATH_SIGC(MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
|
|
dnl
|
|
AC_DEFUN(AM_PATH_SIGC,
|
|
[dnl
|
|
dnl Get the cflags and libraries from the sigc-config script
|
|
dnl
|
|
|
|
dnl
|
|
dnl Prefix options
|
|
dnl
|
|
AC_ARG_WITH(sigc-prefix,
|
|
[ --with-sigc-prefix=PREFIX
|
|
Prefix where libsigc++ is installed (optional)]
|
|
, sigc_config_prefix="$withval", sigc_config_prefix="")
|
|
|
|
AC_ARG_WITH(sigc-exec-prefix,
|
|
[ --with-sigc-exec-prefix=PREFIX
|
|
Exec prefix where libsigc++ is installed (optional)]
|
|
, sigc_config_exec_prefix="$withval", sigc_config_exec_prefix="")
|
|
|
|
AC_ARG_ENABLE(sigctest,
|
|
[ --disable-sigctest Do not try to compile and run a test libsigc++
|
|
program],
|
|
, enable_sigctest=yes)
|
|
|
|
dnl
|
|
dnl Prefix handling
|
|
dnl
|
|
if test x$sigc_config_exec_prefix != x ; then
|
|
sigc_config_args="$sigc_config_args --exec-prefix=$sigc_config_exec_prefix"
|
|
if test x${SIGC_CONFIG+set} != xset ; then
|
|
SIGC_CONFIG=$sigc_config_exec_prefix/bin/sigc-config
|
|
fi
|
|
fi
|
|
if test x$sigc_config_prefix != x ; then
|
|
sigc_config_args="$sigc_config_args --prefix=$sigc_config_prefix"
|
|
if test x${SIGC_CONFIG+set} != xset ; then
|
|
SIGC_CONFIG=$sigc_config_prefix/bin/sigc-config
|
|
fi
|
|
fi
|
|
|
|
dnl
|
|
dnl See if sigc-config is alive
|
|
dnl
|
|
AC_PATH_PROG(SIGC_CONFIG, sigc-config, no)
|
|
sigc_version_min=$1
|
|
|
|
dnl
|
|
dnl Version check
|
|
dnl
|
|
AC_MSG_CHECKING(for libsigc++ - version >= $sigc_version_min)
|
|
no_sigc=""
|
|
if test "$SIGC_CONFIG" = "no" ; then
|
|
no_sigc=yes
|
|
else
|
|
sigc_version=`$SIGC_CONFIG --version`
|
|
|
|
SIGC_CFLAGS=`$SIGC_CONFIG $sigc_config_args --cflags`
|
|
SIGC_LIBS=`$SIGC_CONFIG $sigc_config_args --libs`
|
|
SIGC_MACROS=`$SIGC_CONFIG $sigc_config_args --libs`
|
|
|
|
sigc_major_version=`echo $sigc_version | \
|
|
sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'`
|
|
sigc_minor_version=`echo $sigc_version | \
|
|
sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'`
|
|
sigc_micro_version=`echo $sigc_version | \
|
|
sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`
|
|
|
|
sigc_major_min=`echo $sigc_version_min | \
|
|
sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'`
|
|
sigc_minor_min=`echo $sigc_version_min | \
|
|
sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'`
|
|
sigc_micro_min=`echo $sigc_version_min | \
|
|
sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`
|
|
|
|
sigc_version_proper=`expr \
|
|
$sigc_major_version \> $sigc_major_min \| \
|
|
$sigc_major_version \= $sigc_major_min \& \
|
|
$sigc_minor_version \> $sigc_minor_min \| \
|
|
$sigc_major_version \= $sigc_major_min \& \
|
|
$sigc_minor_version \= $sigc_minor_min \& \
|
|
$sigc_micro_version \>= $sigc_micro_min `
|
|
|
|
if test "$sigc_version_proper" = "1" ; then
|
|
AC_MSG_RESULT([$sigc_major_version.$sigc_minor_version.$sigc_micro_version])
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
no_sigc=yes
|
|
fi
|
|
|
|
if test "X$no_sigc" = "Xyes" ; then
|
|
enable_sigctest=no
|
|
fi
|
|
|
|
AC_LANG_SAVE
|
|
AC_LANG_CPLUSPLUS
|
|
|
|
dnl
|
|
dnl
|
|
dnl
|
|
if test "x$enable_sigctest" = "xyes" ; then
|
|
AC_MSG_CHECKING(if libsigc++ sane)
|
|
ac_save_CXXFLAGS="$CXXFLAGS"
|
|
ac_save_LIBS="$LIBS"
|
|
CXXFLAGS="$CXXFLAGS $SIGC_CFLAGS"
|
|
LIBS="$LIBS $SIGC_LIBS"
|
|
|
|
rm -f conf.sigctest
|
|
AC_TRY_RUN([
|
|
#include <stdio.h>
|
|
#include <sigc++/signal_system.h>
|
|
|
|
#ifdef SIGC_CXX_NAMESPACES
|
|
using namespace SigC;
|
|
#endif
|
|
|
|
int foo1(int i)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
int main(int argc,char **argv)
|
|
{
|
|
if (sigc_major_version!=$sigc_major_version ||
|
|
sigc_minor_version!=$sigc_minor_version ||
|
|
sigc_micro_version!=$sigc_micro_version)
|
|
{ printf("(%d.%d.%d) ",
|
|
sigc_major_version,sigc_minor_version,sigc_micro_version);
|
|
return 1;
|
|
}
|
|
Signal1<int,int> sig1;
|
|
sig1.connect(slot(foo1));
|
|
sig1(1);
|
|
return 0;
|
|
}
|
|
|
|
],[
|
|
AC_MSG_RESULT(yes)
|
|
],[
|
|
AC_MSG_RESULT(no)
|
|
no_sigc=yes
|
|
]
|
|
,[echo $ac_n "cross compiling; assumed OK... $ac_c"])
|
|
|
|
CXXFLAGS="$ac_save_CXXFLAGS"
|
|
LIBS="$ac_save_LIBS"
|
|
fi
|
|
fi
|
|
|
|
dnl
|
|
dnl
|
|
if test "x$no_sigc" = x ; then
|
|
ifelse([$2], , :, [$2])
|
|
else
|
|
SIGC_CFLAGS=""
|
|
SIGC_LIBS=""
|
|
SIGC_MACROS=""
|
|
ifelse([$3], , :, [$3])
|
|
fi
|
|
|
|
AC_LANG_RESTORE
|
|
|
|
AC_SUBST(SIGC_CFLAGS)
|
|
AC_SUBST(SIGC_LIBS)
|
|
AC_SUBST(SIGC_MACROS)
|
|
])
|
|
|
|
# Configure paths and libs when using KDE GUI
|
|
## -*- shell-script -*-
|
|
|
|
## This file is part of the KDE libraries/packages
|
|
## Copyright (C) 1997 Janos Farkas (chexum@shadow.banki.hu)
|
|
## (C) 1997 Stephan Kulow (coolo@kde.org)
|
|
|
|
## This file is free software; you can redistribute it and/or
|
|
## modify it under the terms of the GNU Library General Public
|
|
## License as published by the Free Software Foundation; either
|
|
## version 2 of the License, or (at your option) any later version.
|
|
|
|
## This library is distributed in the hope that it will be useful,
|
|
## but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
## Library General Public License for more details.
|
|
|
|
## You should have received a copy of the GNU Library General Public License
|
|
## along with this library; see the file COPYING.LIB. If not, write to
|
|
## the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
## Boston, MA 02111-1307, USA.
|
|
|
|
## IMPORTANT NOTE:
|
|
## Please do not modify this file unless you expect your modifications to be
|
|
## carried into every other module in the repository. If you decide that you
|
|
## really want to modify it, contact coolo@kde.org mentioning that you have
|
|
## and that the modified file should be committed to every module.
|
|
##
|
|
## Single-module modifications are best placed in configure.in for kdelibs
|
|
## and kdebase or configure.in.1 if present.
|
|
|
|
|
|
## ------------------------------------------------------------------------
|
|
## Find a file (or one of more files in a list of dirs)
|
|
## ------------------------------------------------------------------------
|
|
##
|
|
AC_DEFUN(AC_FIND_FILE,
|
|
[
|
|
$3=NO
|
|
for i in $2;
|
|
do
|
|
for j in $1;
|
|
do
|
|
if test -r "$i/$j"; then
|
|
$3=$i
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
])
|
|
|
|
AC_DEFUN(KDE_FIND_PATH,
|
|
[
|
|
AC_MSG_CHECKING([for $1])
|
|
AC_CACHE_VAL(kde_cv_path_$1,
|
|
[
|
|
kde_cv_path_$1="NONE"
|
|
if test -n "$$2"; then
|
|
kde_cv_path_$1="$$2";
|
|
else
|
|
dirs="$3"
|
|
kde_save_IFS=$IFS
|
|
IFS=':'
|
|
for dir in $PATH; do
|
|
dirs="$dirs $dir"
|
|
done
|
|
IFS=$kde_save_IFS
|
|
|
|
for dir in $dirs; do
|
|
if test -x "$dir/$1"; then
|
|
if test -n "$5"
|
|
then
|
|
evalstr="$dir/$1 $5 2>&1 "
|
|
if eval $evalstr; then
|
|
kde_cv_path_$1="$dir/$1"
|
|
break
|
|
fi
|
|
else
|
|
kde_cv_path_$1="$dir/$1"
|
|
break
|
|
fi
|
|
fi
|
|
done
|
|
|
|
fi
|
|
|
|
])
|
|
|
|
if test -z "$kde_cv_path_$1" || test "$kde_cv_path_$1" = "NONE"; then
|
|
AC_MSG_RESULT(not found)
|
|
$4
|
|
else
|
|
AC_MSG_RESULT($kde_cv_path_$1)
|
|
$2=$kde_cv_path_$1
|
|
fi
|
|
])
|
|
AC_DEFUN(KDE_MOC_ERROR_MESSAGE,
|
|
[
|
|
AC_MSG_ERROR([No Qt meta object compiler (moc) found!
|
|
Please check whether you installed Qt correctly.
|
|
You need to have a running moc binary.
|
|
configure tried to run $ac_cv_path_moc and the test didn't
|
|
succeed. If configure shouldn't have tried this one, set
|
|
the environment variable MOC to the right one before running
|
|
configure.
|
|
])
|
|
])
|
|
|
|
dnl ------------------------------------------------------------------------
|
|
dnl Find the meta object compiler in the PATH, in $QTDIR/bin, and some
|
|
dnl more usual places
|
|
dnl ------------------------------------------------------------------------
|
|
dnl
|
|
AC_DEFUN(AC_PATH_QT_MOC,
|
|
[
|
|
KDE_FIND_PATH(moc, MOC, [$ac_qt_bindir $QTDIR/bin \
|
|
/usr/bin /usr/X11R6/bin /usr/lib/qt/bin \
|
|
/usr/local/qt/bin], [KDE_MOC_ERROR_MESSAGE])
|
|
|
|
if test -z "$MOC"; then
|
|
if test -n "$ac_cv_path_moc"; then
|
|
output=`eval "$ac_cv_path_moc --help 2>&1 | sed -e '1q' | grep Qt"`
|
|
fi
|
|
echo "configure:__oline__: tried to call $ac_cv_path_moc --help 2>&1 | sed -e '1q' | grep Qt" >&AC_FD_CC
|
|
echo "configure:__oline__: moc output: $output" >&AC_FD_CC
|
|
|
|
if test -z "$output"; then
|
|
KDE_MOC_ERROR_MESSAGE
|
|
fi
|
|
fi
|
|
|
|
AC_SUBST(MOC)
|
|
])
|
|
|
|
AC_DEFUN(KDE_REPLACE_ROOT,
|
|
$1=`echo "$$1" | sed -e "s#^/#\$\{install_root\}/#"`
|
|
)
|
|
|
|
AC_DEFUN(AC_CREATE_KFSSTND,
|
|
[
|
|
AC_REQUIRE([AC_CHECK_RPATH])
|
|
|
|
if test "$1" = "default"; then
|
|
|
|
AC_MSG_CHECKING(for KDE paths)
|
|
|
|
if test -z "$kde_htmldir"; then
|
|
kde_htmldir="\$(prefix)/share/doc/HTML"
|
|
fi
|
|
if test -z "$kde_appsdir"; then
|
|
kde_appsdir="\$(prefix)/share/applnk"
|
|
fi
|
|
if test -z "$kde_icondir"; then
|
|
kde_icondir="\$(prefix)/share/icons"
|
|
fi
|
|
if test -z "$kde_sounddir"; then
|
|
kde_sounddir="\$(prefix)/share/sounds"
|
|
fi
|
|
if test -z "$kde_datadir"; then
|
|
kde_datadir="\$(prefix)/share/apps"
|
|
fi
|
|
if test -z "$kde_locale"; then
|
|
kde_locale="\$(prefix)/share/locale"
|
|
fi
|
|
if test -z "$kde_cgidir"; then
|
|
kde_cgidir="\$(exec_prefix)/cgi-bin"
|
|
fi
|
|
if test -z "$kde_confdir"; then
|
|
kde_confdir="\$(prefix)/share/config"
|
|
fi
|
|
if test -z "$kde_mimedir"; then
|
|
kde_mimedir="\$(prefix)/share/mimelnk"
|
|
fi
|
|
if test -z "$kde_toolbardir"; then
|
|
kde_toolbardir="\$(prefix)/share/toolbar"
|
|
fi
|
|
if test -z "$kde_wallpaperdir"; then
|
|
kde_wallpaperdir="\$(prefix)/share/wallpapers"
|
|
fi
|
|
if test -z "$kde_bindir"; then
|
|
kde_bindir="\$(exec_prefix)/bin"
|
|
fi
|
|
if test -z "$kde_partsdir"; then
|
|
kde_partsdir="\$(exec_prefix)/parts"
|
|
fi
|
|
AC_MSG_RESULT(defaults)
|
|
|
|
else
|
|
|
|
AC_CACHE_VAL(kde_cv_all_paths,
|
|
[
|
|
AC_MSG_CHECKING([for kde headers installed])
|
|
AC_LANG_CPLUSPLUS
|
|
cat > conftest.$ac_ext <<EOF
|
|
#include <stdio.h>
|
|
#include "confdefs.h"
|
|
#include <kapp.h>
|
|
|
|
int main() {
|
|
printf("kde_htmldir=\\"%s\\"\n", KApplication::kde_htmldir().data());
|
|
printf("kde_appsdir=\\"%s\\"\n", KApplication::kde_appsdir().data());
|
|
printf("kde_icondir=\\"%s\\"\n", KApplication::kde_icondir().data());
|
|
printf("kde_sounddir=\\"%s\\"\n", KApplication::kde_sounddir().data());
|
|
printf("kde_datadir=\\"%s\\"\n", KApplication::kde_datadir().data());
|
|
printf("kde_locale=\\"%s\\"\n", KApplication::kde_localedir().data());
|
|
printf("kde_cgidir=\\"%s\\"\n", KApplication::kde_cgidir().data());
|
|
printf("kde_confdir=\\"%s\\"\n", KApplication::kde_configdir().data());
|
|
printf("kde_mimedir=\\"%s\\"\n", KApplication::kde_mimedir().data());
|
|
printf("kde_toolbardir=\\"%s\\"\n", KApplication::kde_toolbardir().data());
|
|
printf("kde_wallpaperdir=\\"%s\\"\n", KApplication::kde_wallpaperdir().data());
|
|
printf("kde_bindir=\\"%s\\"\n", KApplication::kde_bindir().data());
|
|
printf("kde_partsdir=\\"%s\\"\n", KApplication::kde_partsdir().data());
|
|
return 0;
|
|
}
|
|
EOF
|
|
|
|
if test -n "$kde_libraries"; then
|
|
KDE_TEST_RPATH="-rpath $kde_libraries"
|
|
fi
|
|
|
|
if test -n "$qt_libraries"; then
|
|
KDE_TEST_RPATH="$KDE_TEST_RPATH -rpath $qt_libraries"
|
|
fi
|
|
|
|
if test -n "$x_libraries"; then
|
|
KDE_TEST_RPATH="$KDE_TEST_RPATH -rpath $x_libraries"
|
|
fi
|
|
|
|
KDE_TEST_RPATH="$KDE_TEST_RPATH $KDE_EXTRA_RPATH"
|
|
|
|
ac_compile='${CXX-g++} -c $CXXFLAGS $all_includes $CPPFLAGS conftest.$ac_ext'
|
|
if AC_TRY_EVAL(ac_compile); then
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_ERROR([your system is not able to compile a small KDE application!
|
|
Check, if you installed the KDE header files correctly.])
|
|
fi
|
|
|
|
AC_MSG_CHECKING([for kde libraries installed])
|
|
ac_link='/bin/sh ./libtool --mode=link ${CXX-g++} -o conftest $CXXFLAGS $all_includes $CPPFLAGS $LDFLAGS $all_libraries conftest.$ac_ext $LIBS -lkdecore -lqt -lXext -lX11 $LIBSOCKET $KDE_TEST_RPATH 1>&5'
|
|
|
|
if AC_TRY_EVAL(ac_link) && test -s conftest; then
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_ERROR([your system fails at linking a small KDE application!
|
|
Check, if your compiler is installed correctly and if you have used the
|
|
same compiler to compile Qt and kdelibs as you did use now])
|
|
fi
|
|
|
|
AC_MSG_CHECKING([for KDE paths])
|
|
if eval `./conftest 2>&5`; then
|
|
AC_MSG_RESULT(done)
|
|
else
|
|
AC_MSG_RESULT(problems)
|
|
fi
|
|
|
|
./conftest 2> /dev/null >&5 # make an echo for config.log
|
|
kde_have_all_paths=yes
|
|
AC_LANG_CPLUSPLUS
|
|
|
|
if test "$kde_have_all_paths" = "yes"; then
|
|
kde_cv_all_paths="kde_have_all_paths=\"yes\" \
|
|
kde_htmldir=\"$kde_htmldir\" \
|
|
kde_appsdir=\"$kde_appsdir\" \
|
|
kde_icondir=\"$kde_icondir\" \
|
|
kde_sounddir=\"$kde_sounddir\" \
|
|
kde_datadir=\"$kde_datadir\" \
|
|
kde_locale=\"$kde_locale\" \
|
|
kde_cgidir=\"$kde_cgidir\" \
|
|
kde_confdir=\"$kde_confdir\" \
|
|
kde_mimedir=\"$kde_mimedir\" \
|
|
kde_toolbardir=\"$kde_toolbardir\" \
|
|
kde_wallpaperdir=\"$kde_wallpaperdir\" \
|
|
kde_bindir=\"$kde_bindir\" \
|
|
kde_partsdir=\"$kde_partsdir\""
|
|
fi
|
|
rm -fr conftest*
|
|
|
|
])
|
|
|
|
eval "$kde_cv_all_paths"
|
|
|
|
if test -z "$kde_htmldir" || test -z "$kde_appsdir" ||
|
|
test -z "$kde_icondir" || test -z "$kde_sounddir" ||
|
|
test -z "$kde_datadir" || test -z "$kde_locale" ||
|
|
test -z "$kde_cgidir" || test -z "$kde_confdir" ||
|
|
test -z "$kde_mimedir" || test -z "$kde_toolbardir" ||
|
|
test -z "$kde_wallpaperdir" || test -z "$kde_bindir" ||
|
|
test -z "$kde_partsdir" || test "$kde_have_all_paths" != "yes"; then
|
|
kde_have_all_paths=no
|
|
AC_MSG_ERROR([configure could not run a little KDE program to test the environment.
|
|
Since it had compiled and linked before, it must be a strange problem on your system.
|
|
Look at config.log for details. If you are not able to fix this, please contact Stephan Kulow <coolo@kde.org>.])
|
|
fi
|
|
|
|
if test -n "$install_root"; then
|
|
KDE_REPLACE_ROOT(kde_htmldir)
|
|
KDE_REPLACE_ROOT(kde_appsdir)
|
|
KDE_REPLACE_ROOT(kde_icondir)
|
|
KDE_REPLACE_ROOT(kde_sounddir)
|
|
KDE_REPLACE_ROOT(kde_datadir)
|
|
KDE_REPLACE_ROOT(kde_locale)
|
|
KDE_REPLACE_ROOT(kde_cgidir)
|
|
KDE_REPLACE_ROOT(kde_confdir)
|
|
KDE_REPLACE_ROOT(kde_mimedir)
|
|
KDE_REPLACE_ROOT(kde_toolbardir)
|
|
KDE_REPLACE_ROOT(kde_wallpaperdir)
|
|
KDE_REPLACE_ROOT(kde_bindir)
|
|
KDE_REPLACE_ROOT(kde_partsdir)
|
|
AC_SUBST(install_root)
|
|
fi
|
|
|
|
fi
|
|
|
|
bindir=$kde_bindir
|
|
|
|
])
|
|
|
|
AC_DEFUN(AC_SUBST_KFSSTND,
|
|
[
|
|
AC_SUBST(kde_htmldir)
|
|
AC_SUBST(kde_appsdir)
|
|
AC_SUBST(kde_icondir)
|
|
AC_SUBST(kde_sounddir)
|
|
kde_minidir="$kde_icondir/mini"
|
|
AC_SUBST(kde_minidir)
|
|
AC_SUBST(kde_datadir)
|
|
AC_SUBST(kde_locale)
|
|
AC_SUBST(kde_cgidir)
|
|
AC_SUBST(kde_confdir)
|
|
AC_SUBST(kde_mimedir)
|
|
AC_SUBST(kde_toolbardir)
|
|
AC_SUBST(kde_wallpaperdir)
|
|
AC_SUBST(kde_bindir)
|
|
AC_SUBST(kde_partsdir)
|
|
])
|
|
|
|
AC_DEFUN(KDE_MISC_TESTS,
|
|
[
|
|
AC_LANG_C
|
|
dnl Checks for libraries.
|
|
AC_CHECK_LIB(compat, main, [LIBCOMPAT="-lcompat"]) dnl for FreeBSD
|
|
AC_SUBST(LIBCOMPAT)
|
|
AC_CHECK_LIB(crypt, main, [LIBCRYPT="-lcrypt"]) dnl for BSD
|
|
AC_SUBST(LIBCRYPT)
|
|
AC_CHECK_LIB(dnet, dnet_ntoa, [X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet"])
|
|
if test $ac_cv_lib_dnet_dnet_ntoa = no; then
|
|
AC_CHECK_LIB(dnet_stub, dnet_ntoa,
|
|
[X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet_stub"])
|
|
fi
|
|
AC_CHECK_FUNC(gethostbyname)
|
|
if test $ac_cv_func_gethostbyname = no; then
|
|
AC_CHECK_LIB(nsl, gethostbyname, X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl")
|
|
fi
|
|
AC_CHECK_FUNC(connect)
|
|
if test $ac_cv_func_connect = no; then
|
|
AC_CHECK_LIB(socket, connect, X_EXTRA_LIBS="-lsocket $X_EXTRA_LIBS", ,
|
|
$X_EXTRA_LIBS)
|
|
fi
|
|
|
|
AC_CHECK_FUNC(remove)
|
|
if test $ac_cv_func_remove = no; then
|
|
AC_CHECK_LIB(posix, remove, X_EXTRA_LIBS="$X_EXTRA_LIBS -lposix")
|
|
fi
|
|
|
|
# BSDI BSD/OS 2.1 needs -lipc for XOpenDisplay.
|
|
AC_CHECK_FUNC(shmat)
|
|
if test $ac_cv_func_shmat = no; then
|
|
AC_CHECK_LIB(ipc, shmat, X_EXTRA_LIBS="$X_EXTRA_LIBS -lipc")
|
|
fi
|
|
|
|
LIBSOCKET=$X_EXTRA_LIBS
|
|
AC_SUBST(LIBSOCKET)
|
|
AC_SUBST(X_EXTRA_LIBS)
|
|
AC_CHECK_LIB(ucb, killpg, [LIBUCB="-lucb"]) dnl for Solaris2.4
|
|
AC_SUBST(LIBUCB)
|
|
|
|
case $host in dnl this *is* LynxOS specific
|
|
*-*-lynxos* )
|
|
AC_MSG_CHECKING([LynxOS header file wrappers])
|
|
[CFLAGS="$CFLAGS -D__NO_INCLUDE_WARN__"]
|
|
AC_MSG_RESULT(disabled)
|
|
AC_CHECK_LIB(bsd, gethostbyname, [LIBSOCKET="-lbsd"]) dnl for LynxOS
|
|
;;
|
|
esac
|
|
|
|
])
|
|
|
|
## ------------------------------------------------------------------------
|
|
## Find the header files and libraries for X-Windows. Extended the
|
|
## macro AC_PATH_X
|
|
## ------------------------------------------------------------------------
|
|
##
|
|
AC_DEFUN(K_PATH_X,
|
|
[
|
|
AC_MSG_CHECKING(for X)
|
|
AC_CACHE_VAL(ac_cv_have_x,
|
|
[# One or both of the vars are not set, and there is no cached value.
|
|
ac_x_includes=NO ac_x_libraries=NO
|
|
AC_PATH_X_DIRECT
|
|
AC_PATH_X_XMKMF
|
|
if test "$ac_x_includes" = NO || test "$ac_x_libraries" = NO; then
|
|
AC_MSG_ERROR([Can't find X includes. Please check your installation and add the correct paths!])
|
|
else
|
|
# Record where we found X for the cache.
|
|
ac_cv_have_x="have_x=yes \
|
|
ac_x_includes=$ac_x_includes ac_x_libraries=$ac_x_libraries"
|
|
fi])dnl
|
|
eval "$ac_cv_have_x"
|
|
|
|
if test "$have_x" != yes; then
|
|
AC_MSG_RESULT($have_x)
|
|
no_x=yes
|
|
else
|
|
# If each of the values was on the command line, it overrides each guess.
|
|
test "x$x_includes" = xNONE && x_includes=$ac_x_includes
|
|
test "x$x_libraries" = xNONE && x_libraries=$ac_x_libraries
|
|
# Update the cache value to reflect the command line values.
|
|
ac_cv_have_x="have_x=yes \
|
|
ac_x_includes=$x_includes ac_x_libraries=$x_libraries"
|
|
AC_MSG_RESULT([libraries $x_libraries, headers $x_includes])
|
|
fi
|
|
|
|
if test -z "$x_includes" || test "x$x_includes" = xNONE; then
|
|
X_INCLUDES=""
|
|
x_includes="."; dnl better than nothing :-
|
|
else
|
|
X_INCLUDES="-I$x_includes"
|
|
fi
|
|
|
|
if test -z "$x_libraries" || test "x$x_libraries" = xNONE; then
|
|
X_LDFLAGS=""
|
|
x_libraries="/usr/lib"; dnl better than nothing :-
|
|
else
|
|
X_LDFLAGS="-L$x_libraries"
|
|
fi
|
|
all_includes="$all_includes $X_INCLUDES"
|
|
all_libraries="$all_libraries $X_LDFLAGS"
|
|
|
|
AC_SUBST(X_INCLUDES)
|
|
AC_SUBST(X_LDFLAGS)
|
|
AC_SUBST(x_libraries)
|
|
AC_SUBST(x_includes)
|
|
])
|
|
|
|
AC_DEFUN(KDE_PRINT_QT_PROGRAM,
|
|
[
|
|
AC_LANG_CPLUSPLUS
|
|
cat > conftest.$ac_ext <<EOF
|
|
#include "confdefs.h"
|
|
#include <qmovie.h>
|
|
#include <qapplication.h>
|
|
int main() {
|
|
QMovie m;
|
|
m.setSpeed(20);
|
|
return 0;
|
|
}
|
|
EOF
|
|
])
|
|
|
|
AC_DEFUN(KDE_CHECK_QT_DIRECT,
|
|
[
|
|
AC_MSG_CHECKING([if Qt compiles without flags])
|
|
AC_CACHE_VAL(kde_cv_qt_direct,
|
|
[
|
|
ac_LD_LIBRARY_PATH_safe=$LD_LIBRARY_PATH
|
|
ac_LIBRARY_PATH="$LIBRARY_PATH"
|
|
ac_cxxflags_safe="$CXXFLAGS"
|
|
ac_ldflags_safe="$LDFLAGS"
|
|
ac_libs_safe="$LIBS"
|
|
|
|
CXXFLAGS="$CXXFLAGS -I$qt_includes"
|
|
LDFLAGS="$X_LDFLAGS"
|
|
LIBS="-lqt -lXext -lX11 $LIBSOCKET"
|
|
LD_LIBRARY_PATH=
|
|
export LD_LIBRARY_PATH
|
|
LIBRARY_PATH=
|
|
export LIBRARY_PATH
|
|
|
|
KDE_PRINT_QT_PROGRAM
|
|
|
|
if AC_TRY_EVAL(ac_link) && test -s conftest; then
|
|
kde_cv_qt_direct="yes"
|
|
else
|
|
kde_cv_qt_direct="no"
|
|
echo "configure: failed program was:" >&AC_FD_CC
|
|
cat conftest.$ac_ext >&AC_FD_CC
|
|
fi
|
|
rm -f conftest*
|
|
CXXFLAGS="$ac_cxxflags_safe"
|
|
LDFLAGS="$ac_ldflags_safe"
|
|
LIBS="$ac_libs_safe"
|
|
|
|
LD_LIBRARY_PATH="$ac_LD_LIBRARY_PATH_safe"
|
|
export LD_LIBRARY_PATH
|
|
LIBRARY_PATH="$ac_LIBRARY_PATH"
|
|
export LIBRARY_PATH
|
|
])
|
|
|
|
if test "$kde_cv_qt_direct" = "yes"; then
|
|
AC_MSG_RESULT(yes)
|
|
$1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
$2
|
|
fi
|
|
])
|
|
|
|
## ------------------------------------------------------------------------
|
|
## Try to find the Qt headers and libraries.
|
|
## $(QT_LDFLAGS) will be -Lqtliblocation (if needed)
|
|
## and $(QT_INCLUDES) will be -Iqthdrlocation (if needed)
|
|
## ------------------------------------------------------------------------
|
|
##
|
|
AC_DEFUN(AC_PATH_QT_1_3,
|
|
[
|
|
AC_REQUIRE([K_PATH_X])
|
|
|
|
AC_MSG_CHECKING([for Qt])
|
|
ac_qt_includes=NO ac_qt_libraries=NO ac_qt_bindir=NO
|
|
qt_libraries=""
|
|
qt_includes=""
|
|
AC_ARG_WITH(qt-dir,
|
|
[ --with-qt-dir where the root of qt is installed ],
|
|
[ ac_qt_includes="$withval"/include
|
|
ac_qt_libraries="$withval"/lib
|
|
ac_qt_bindir="$withval"/bin
|
|
])
|
|
|
|
AC_ARG_WITH(qt-includes,
|
|
[ --with-qt-includes where the Qt includes are. ],
|
|
[
|
|
ac_qt_includes="$withval"
|
|
])
|
|
|
|
kde_qt_libs_given=no
|
|
|
|
AC_ARG_WITH(qt-libraries,
|
|
[ --with-qt-libraries where the Qt library is installed.],
|
|
[ ac_qt_libraries="$withval"
|
|
kde_qt_libs_given=yes
|
|
])
|
|
|
|
if test "$ac_qt_includes" = NO || test "$ac_qt_libraries" = NO; then
|
|
|
|
AC_CACHE_VAL(ac_cv_have_qt,
|
|
[#try to guess Qt locations
|
|
|
|
qt_incdirs="$ac_qt_includes /usr/lib/qt/include /usr/local/qt/include /usr/include/qt /usr/include /usr/X11R6/include/X11/qt $x_includes $QTINC"
|
|
test -n "$QTDIR" && qt_incdirs="$QTDIR/include $QTDIR $qt_incdirs"
|
|
AC_FIND_FILE(qmovie.h, $qt_incdirs, qt_incdir)
|
|
ac_qt_includes="$qt_incdir"
|
|
|
|
if test ! "$ac_qt_libraries" = "NO"; then
|
|
qt_libdirs="$ac_qt_libraries"
|
|
fi
|
|
|
|
qt_libdirs="$qt_libdirs /usr/lib/qt/lib /usr/X11R6/lib /usr/lib /usr/local/qt/lib /usr/lib/qt $x_libraries $QTLIB"
|
|
test -n "$QTDIR" && qt_libdirs="$QTDIR/lib $QTDIR $qt_libdirs"
|
|
|
|
test=NONE
|
|
qt_libdir=NONE
|
|
for dir in $qt_libdirs; do
|
|
try="ls -1 $dir/libqt*"
|
|
if test=`eval $try 2> /dev/null`; then qt_libdir=$dir; break; else echo "tried $dir" >&AC_FD_CC ; fi
|
|
done
|
|
|
|
dnl AC_FIND_FILE(libqt.so libqt.so.1.40 libqt.so.1.41 libqt.so.1 libqt.a libqt.sl, $qt_libdirs, qt_libdir)
|
|
ac_qt_libraries="$qt_libdir"
|
|
|
|
ac_cxxflags_safe="$CXXFLAGS"
|
|
ac_ldflags_safe="$LDFLAGS"
|
|
ac_libs_safe="$LIBS"
|
|
|
|
CXXFLAGS="$CXXFLAGS -I$qt_incdir"
|
|
LDFLAGS="-L$qt_libdir $X_LDFLAGS"
|
|
LIBS="$LIBS -lqt -lXext -lX11 $LIBSOCKET"
|
|
|
|
KDE_PRINT_QT_PROGRAM
|
|
|
|
if AC_TRY_EVAL(ac_link) && test -s conftest; then
|
|
rm -f conftest*
|
|
else
|
|
echo "configure: failed program was:" >&AC_FD_CC
|
|
cat conftest.$ac_ext >&AC_FD_CC
|
|
ac_qt_libraries="NO"
|
|
fi
|
|
rm -f conftest*
|
|
CXXFLAGS="$ac_cxxflags_safe"
|
|
LDFLAGS="$ac_ldflags_safe"
|
|
LIBS="$ac_libs_safe"
|
|
|
|
if test "$ac_qt_includes" = NO || test "$ac_qt_libraries" = NO; then
|
|
ac_cv_have_qt="have_qt=no"
|
|
ac_qt_notfound=""
|
|
if test "$ac_qt_includes" = NO; then
|
|
if test "$ac_qt_libraries" = NO; then
|
|
ac_qt_notfound="(headers and libraries)";
|
|
else
|
|
ac_qt_notfound="(headers)";
|
|
fi
|
|
else
|
|
ac_qt_notfound="(libraries)";
|
|
fi
|
|
|
|
AC_MSG_ERROR([Qt-1.4 $ac_qt_notfound not found. Please check your installation! ]);
|
|
else
|
|
have_qt="yes"
|
|
fi
|
|
])
|
|
else
|
|
have_qt="yes"
|
|
fi
|
|
|
|
eval "$ac_cv_have_qt"
|
|
|
|
if test "$have_qt" != yes; then
|
|
AC_MSG_RESULT([$have_qt]);
|
|
else
|
|
ac_cv_have_qt="have_qt=yes \
|
|
ac_qt_includes=$ac_qt_includes ac_qt_libraries=$ac_qt_libraries"
|
|
AC_MSG_RESULT([libraries $ac_qt_libraries, headers $ac_qt_includes])
|
|
|
|
qt_libraries="$ac_qt_libraries"
|
|
qt_includes="$ac_qt_includes"
|
|
fi
|
|
|
|
if test ! "$kde_qt_libs_given" = "yes"; then
|
|
KDE_CHECK_QT_DIRECT(qt_libraries= ,[])
|
|
fi
|
|
|
|
AC_SUBST(qt_libraries)
|
|
AC_SUBST(qt_includes)
|
|
|
|
if test "$qt_includes" = "$x_includes" || test -z "$qt_includes"; then
|
|
QT_INCLUDES="";
|
|
else
|
|
QT_INCLUDES="-I$qt_includes"
|
|
all_includes="$QT_INCLUDES $all_includes"
|
|
fi
|
|
|
|
if test "$qt_libraries" = "$x_libraries" || test -z "$qt_libraries"; then
|
|
QT_LDFLAGS=""
|
|
else
|
|
QT_LDFLAGS="-L$qt_libraries"
|
|
all_libraries="$QT_LDFLAGS $all_libraries"
|
|
fi
|
|
|
|
AC_SUBST(QT_INCLUDES)
|
|
AC_SUBST(QT_LDFLAGS)
|
|
AC_PATH_QT_MOC
|
|
])
|
|
|
|
AC_DEFUN(AC_PATH_QT,
|
|
[
|
|
AC_PATH_QT_1_3
|
|
])
|
|
|
|
## ------------------------------------------------------------------------
|
|
## Now, the same with KDE
|
|
## $(KDE_LDFLAGS) will be the kdeliblocation (if needed)
|
|
## and $(kde_includes) will be the kdehdrlocation (if needed)
|
|
## ------------------------------------------------------------------------
|
|
##
|
|
AC_DEFUN(AC_BASE_PATH_KDE,
|
|
[
|
|
AC_REQUIRE([KDE_MISC_TESTS])
|
|
AC_REQUIRE([AC_PATH_QT])dnl
|
|
AC_MSG_CHECKING([for KDE])
|
|
|
|
if test "${prefix}" != NONE; then
|
|
kde_includes=${prefix}/include
|
|
ac_kde_includes=$prefix/include
|
|
|
|
if test "${exec_prefix}" != NONE; then
|
|
kde_libraries=${exec_prefix}/lib
|
|
ac_kde_libraries=$exec_prefix/lib
|
|
else
|
|
kde_libraries=${prefix}/lib
|
|
ac_kde_libraries=$prefix/lib
|
|
fi
|
|
else
|
|
ac_kde_includes=
|
|
ac_kde_libraries=
|
|
kde_libraries=""
|
|
kde_includes=""
|
|
fi
|
|
|
|
AC_CACHE_VAL(ac_cv_have_kde,
|
|
[#try to guess kde locations
|
|
|
|
if test -z "$1"; then
|
|
|
|
kde_incdirs="$ac_kde_includes /usr/lib/kde/include /usr/local/kde/include /usr/kde/include /usr/include/kde /usr/include /opt/kde/include $x_includes $qt_includes"
|
|
test -n "$KDEDIR" && kde_incdirs="$KDEDIR/include $KDEDIR $kde_incdirs"
|
|
AC_FIND_FILE(ksock.h, $kde_incdirs, kde_incdir)
|
|
ac_kde_includes="$kde_incdir"
|
|
|
|
if test -n "$ac_kde_includes" && test ! -r "$ac_kde_includes/ksock.h"; then
|
|
AC_MSG_ERROR([
|
|
in the prefix, you've chosen, are no kde headers installed. This will fail.
|
|
So, check this please and use another prefix!])
|
|
fi
|
|
|
|
kde_libdirs="$ac_kde_libraries /usr/lib/kde/lib /usr/local/kde/lib /usr/kde/lib /usr/lib/kde /usr/lib /usr/X11R6/lib /opt/kde/lib /usr/X11R6/kde/lib"
|
|
test -n "$KDEDIR" && kde_libdirs="$KDEDIR/lib $KDEDIR $kde_libdirs"
|
|
AC_FIND_FILE(libkdecore.la, $kde_libdirs, kde_libdir)
|
|
ac_kde_libraries="$kde_libdir"
|
|
|
|
if test -n "$ac_kde_libraries" && test ! -r "$ac_kde_libraries/libkdecore.la"; then
|
|
AC_MSG_ERROR([
|
|
in the prefix, you've chosen $ac_kde_libraries, are no kde libraries installed. This will fail.
|
|
So, check this please and use another prefix!])
|
|
fi
|
|
ac_kde_libraries="$kde_libdir"
|
|
|
|
if test "$ac_kde_includes" = NO || test "$ac_kde_libraries" = NO; then
|
|
ac_cv_have_kde="have_kde=no"
|
|
else
|
|
ac_cv_have_kde="have_kde=yes \
|
|
ac_kde_includes=$ac_kde_includes ac_kde_libraries=$ac_kde_libraries"
|
|
fi
|
|
|
|
else dnl test -z $1
|
|
|
|
ac_cv_have_kde="have_kde=no"
|
|
|
|
fi
|
|
])dnl
|
|
|
|
eval "$ac_cv_have_kde"
|
|
|
|
if test "$have_kde" != "yes"; then
|
|
if test "${prefix}" = NONE; then
|
|
ac_kde_prefix="$ac_default_prefix"
|
|
else
|
|
ac_kde_prefix="$prefix"
|
|
fi
|
|
if test "$exec_prefix" = NONE; then
|
|
ac_kde_exec_prefix="$ac_kde_prefix"
|
|
AC_MSG_RESULT([will be installed in $ac_kde_prefix])
|
|
else
|
|
ac_kde_exec_prefix="$exec_prefix"
|
|
AC_MSG_RESULT([will be installed in $ac_kde_prefix and $ac_kde_exec_prefix])
|
|
fi
|
|
|
|
kde_libraries="${ac_kde_exec_prefix}/lib"
|
|
kde_includes=${ac_kde_prefix}/include
|
|
|
|
else
|
|
ac_cv_have_kde="have_kde=yes \
|
|
ac_kde_includes=$ac_kde_includes ac_kde_libraries=$ac_kde_libraries"
|
|
AC_MSG_RESULT([libraries $ac_kde_libraries, headers $ac_kde_includes])
|
|
|
|
kde_libraries="$ac_kde_libraries"
|
|
kde_includes="$ac_kde_includes"
|
|
fi
|
|
AC_SUBST(kde_libraries)
|
|
AC_SUBST(kde_includes)
|
|
|
|
if test "$kde_includes" = "$x_includes" || test "$kde_includes" = "$qt_includes" ; then
|
|
KDE_INCLUDES=""
|
|
else
|
|
KDE_INCLUDES="-I$kde_includes"
|
|
all_includes="$KDE_INCLUDES $all_includes"
|
|
fi
|
|
|
|
if test "$kde_libraries" = "$x_libraries" || test "$kde_libraries" = "$qt_libraries" ; then
|
|
KDE_LDFLAGS=""
|
|
else
|
|
KDE_LDFLAGS="-L$kde_libraries"
|
|
all_libraries="$KDE_LDFLAGS $all_libraries"
|
|
fi
|
|
|
|
AC_SUBST(KDE_LDFLAGS)
|
|
AC_SUBST(KDE_INCLUDES)
|
|
|
|
KDE_CHECK_EXTRA_LIBS
|
|
|
|
AC_SUBST(all_includes)
|
|
AC_SUBST(all_libraries)
|
|
|
|
])
|
|
|
|
AC_DEFUN(KDE_CHECK_EXTRA_LIBS,
|
|
[
|
|
AC_MSG_CHECKING(for extra includes)
|
|
AC_ARG_WITH(extra-includes, [ --with-extra-includes adds non standard include paths],
|
|
kde_use_extra_includes="$withval",
|
|
kde_use_extra_includes=NONE
|
|
)
|
|
if test -n "$kde_use_extra_includes" && \
|
|
test "$kde_use_extra_includes" != "NONE"; then
|
|
|
|
ac_save_ifs=$IFS
|
|
IFS=':'
|
|
for dir in $kde_use_extra_includes; do
|
|
all_includes="$all_includes -I$dir"
|
|
USER_INCLUDES="$USER_INCLUDES -I$dir"
|
|
done
|
|
IFS=$ac_save_ifs
|
|
kde_use_extra_includes="added"
|
|
else
|
|
kde_use_extra_includes="no"
|
|
fi
|
|
|
|
AC_MSG_RESULT($kde_use_extra_includes)
|
|
|
|
AC_MSG_CHECKING(for extra libs)
|
|
AC_ARG_WITH(extra-libs, [ --with-extra-libs adds non standard library paths],
|
|
kde_use_extra_libs=$withval,
|
|
kde_use_extra_libs=NONE
|
|
)
|
|
if test -n "$kde_use_extra_libs" && \
|
|
test "$kde_use_extra_libs" != "NONE"; then
|
|
|
|
ac_save_ifs=$IFS
|
|
IFS=':'
|
|
for dir in $kde_use_extra_libs; do
|
|
all_libraries="$all_libraries -L$dir"
|
|
KDE_EXTRA_RPATH="$KDE_EXTRA_RPATH -rpath $dir"
|
|
USER_LDFLAGS="$USER_LDFLAGS -L$dir"
|
|
done
|
|
IFS=$ac_save_ifs
|
|
kde_use_extra_libs="added"
|
|
else
|
|
kde_use_extra_libs="no"
|
|
fi
|
|
|
|
AC_MSG_RESULT($kde_use_extra_libs)
|
|
|
|
])
|
|
|
|
AC_DEFUN(KDE_CHECK_KIMGIO,
|
|
[
|
|
AC_REQUIRE([AC_FIND_TIFF])
|
|
AC_REQUIRE([AC_FIND_JPEG])
|
|
AC_REQUIRE([AC_FIND_PNG])
|
|
|
|
LIB_KIMGIO='-lkimgio $(LIBJPEG) $(LIBTIFF) $(LIBPNG) -lm'
|
|
AC_SUBST(LIB_KIMGIO)
|
|
LIB_KHTMLW='-lkhtmlw $(LIB_KIMGIO) -ljscript'
|
|
AC_SUBST(LIB_KHTMLW)
|
|
LIB_KHTML='-lkhtml $(LIB_KIMGIO) -ljscript'
|
|
AC_SUBST(LIB_KHTML)
|
|
])
|
|
|
|
AC_DEFUN(KDE_CREATE_LIBS_ALIASES,
|
|
[
|
|
AC_REQUIRE([KDE_MISC_TESTS])
|
|
|
|
KDE_LIBS='-lqt -lkdecore -lkdeui -lkfm -lkfile'
|
|
AC_SUBST(KDE_LIBS)
|
|
# LIB_X11='-lX11 $(LIBSOCKET)'
|
|
# AC_SUBST(LIB_X11)
|
|
# LIB_QT='-lqt $(LIB_X11)'
|
|
# AC_SUBST(LIB_QT)
|
|
# LIB_KDECORE='-lkdecore -lXext $(LIB_QT)'
|
|
# AC_SUBST(LIB_KDECORE)
|
|
# LIB_KDEUI='-lkdeui $(LIB_KDECORE)'
|
|
# AC_SUBST(LIB_KDEUI)
|
|
# LIB_KFM='-lkfm $(LIB_KDECORE)'
|
|
# AC_SUBST(LIB_KFM)
|
|
# LIB_KFILE='-lkfile $(LIB_KFM) $(LIB_KDEUI)'
|
|
# AC_SUBST(LIB_KFILE)
|
|
])
|
|
|
|
AC_DEFUN(AC_PATH_KDE,
|
|
[
|
|
AC_BASE_PATH_KDE
|
|
AC_ARG_ENABLE(path-check, [ --disable-path-check don't try to find out, where to install],
|
|
[
|
|
if test "$enableval" = "no";
|
|
then ac_use_path_checking="default"
|
|
else ac_use_path_checking=""
|
|
fi
|
|
], [ac_use_path_checking=""]
|
|
)
|
|
|
|
AC_ARG_WITH(install-root, [ --with-install-root the root, where to install to [default=/]],
|
|
[
|
|
if test "$withval" = "no";
|
|
then kde_install_root="";
|
|
else kde_install_root=$withval;
|
|
fi
|
|
], [kde_install_root=""]
|
|
)
|
|
|
|
if test -n "$kde_install_root"; then
|
|
install_root="$kde_install_root"
|
|
else
|
|
install_root=
|
|
fi
|
|
|
|
AC_CREATE_KFSSTND($ac_use_path_checking)
|
|
|
|
AC_SUBST_KFSSTND
|
|
KDE_CREATE_LIBS_ALIASES
|
|
])
|
|
|
|
dnl slightly changed version of AC_CHECK_FUNC(setenv)
|
|
AC_DEFUN(AC_CHECK_SETENV,
|
|
[AC_MSG_CHECKING([for setenv])
|
|
AC_CACHE_VAL(ac_cv_func_setenv,
|
|
[AC_LANG_C
|
|
AC_TRY_LINK(
|
|
dnl Don't include <ctype.h> because on OSF/1 3.0 it includes <sys/types.h>
|
|
dnl which includes <sys/select.h> which contains a prototype for
|
|
dnl select. Similarly for bzero.
|
|
[#include <assert.h>
|
|
]ifelse(AC_LANG, CPLUSPLUS, [#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
])dnl
|
|
[/* We use char because int might match the return type of a gcc2
|
|
builtin and then its argument prototype would still apply. */
|
|
#include <stdlib.h>
|
|
], [
|
|
/* The GNU C library defines this for functions which it implements
|
|
to always fail with ENOSYS. Some functions are actually named
|
|
something starting with __ and the normal name is an alias. */
|
|
#if defined (__stub_$1) || defined (__stub___$1)
|
|
choke me
|
|
#else
|
|
setenv("TEST", "alle", 1);
|
|
#endif
|
|
], eval "ac_cv_func_setenv=yes", eval "ac_cv_func_setenv=no")])
|
|
|
|
if test "$ac_cv_func_setenv" = "yes"; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE_UNQUOTED(HAVE_FUNC_SETENV)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(AC_CHECK_GETDOMAINNAME,
|
|
[
|
|
AC_LANG_CPLUSPLUS
|
|
save_CXXFLAGS="$CXXFLAGS"
|
|
if test "$GCC" = "yes"; then
|
|
CXXFLAGS="$CXXFLAGS -pedantic-errors"
|
|
fi
|
|
AC_MSG_CHECKING(for getdomainname)
|
|
AC_CACHE_VAL(ac_cv_func_getdomainname,
|
|
[
|
|
AC_TRY_COMPILE([
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
],
|
|
[
|
|
char buffer[200];
|
|
getdomainname(buffer, 200);
|
|
],
|
|
ac_cv_func_getdomainname=yes,
|
|
ac_cv_func_getdomainname=no)
|
|
])
|
|
AC_MSG_RESULT($ac_cv_func_getdomainname)
|
|
if eval "test \"`echo `$ac_cv_func_getdomainname\" = yes"; then
|
|
AC_DEFINE(HAVE_GETDOMAINNAME)
|
|
fi
|
|
CXXFLAGS="$save_CXXFLAGS"
|
|
])
|
|
|
|
AC_DEFUN(AC_CHECK_GETHOSTNAME,
|
|
[
|
|
AC_LANG_CPLUSPLUS
|
|
save_CXXFLAGS="$CXXFLAGS"
|
|
if test "$GCC" = "yes"; then
|
|
CXXFLAGS="$CXXFLAGS -pedantic-errors"
|
|
fi
|
|
|
|
AC_MSG_CHECKING([for gethostname])
|
|
AC_CACHE_VAL(ac_cv_func_gethostname,
|
|
[
|
|
AC_TRY_COMPILE([
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
],
|
|
[
|
|
char buffer[200];
|
|
gethostname(buffer, 200);
|
|
],
|
|
ac_cv_func_gethostname=yes,
|
|
ac_cv_func_gethostname=no)
|
|
])
|
|
AC_MSG_RESULT($ac_cv_func_gethostname)
|
|
if eval "test \"`echo `$ac_cv_func_gethostname\" = yes"; then
|
|
AC_DEFINE(HAVE_GETHOSTNAME)
|
|
fi
|
|
CXXFLAGS="$save_CXXFLAGS"
|
|
])
|
|
|
|
AC_DEFUN(AC_CHECK_USLEEP,
|
|
[
|
|
AC_LANG_CPLUSPLUS
|
|
|
|
AC_MSG_CHECKING([for usleep])
|
|
AC_CACHE_VAL(ac_cv_func_usleep,
|
|
[
|
|
ac_libs_safe="$LIBS"
|
|
LIBS="$LIBS $LIBUCB"
|
|
AC_TRY_LINK([
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
],
|
|
[
|
|
usleep(200);
|
|
],
|
|
ac_cv_func_usleep=yes,
|
|
ac_cv_func_usleep=no)
|
|
])
|
|
AC_MSG_RESULT($ac_cv_func_usleep)
|
|
if eval "test \"`echo `$ac_cv_func_usleep\" = yes"; then
|
|
AC_DEFINE(HAVE_USLEEP)
|
|
fi
|
|
LIBS="$ac_libs_safe"
|
|
])
|
|
|
|
AC_DEFUN(AC_FIND_GIF,
|
|
[AC_MSG_CHECKING([for giflib])
|
|
AC_CACHE_VAL(ac_cv_lib_gif,
|
|
[ac_save_LIBS="$LIBS"
|
|
LIBS="$all_libraries -lgif -lX11 $LIBSOCKET"
|
|
AC_TRY_LINK(dnl
|
|
[
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
int GifLastError(void);
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
/* We use char because int might match the return type of a gcc2
|
|
builtin and then its argument prototype would still apply. */
|
|
],
|
|
[return GifLastError();],
|
|
eval "ac_cv_lib_gif=yes",
|
|
eval "ac_cv_lib_gif=no")
|
|
LIBS="$ac_save_LIBS"
|
|
])dnl
|
|
if eval "test \"`echo $ac_cv_lib_gif`\" = yes"; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE_UNQUOTED(HAVE_LIBGIF)
|
|
else
|
|
AC_MSG_ERROR(You need giflib23. Please install the kdesupport package)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(AC_FIND_JPEG,
|
|
[AC_MSG_CHECKING([for jpeglib])
|
|
AC_CACHE_VAL(ac_cv_lib_jpeg,
|
|
[ac_save_LIBS="$LIBS"
|
|
LIBS="$all_libraries -ljpeg -lm"
|
|
AC_TRY_LINK(
|
|
[/* Override any gcc2 internal prototype to avoid an error. */
|
|
struct jpeg_decompress_struct;
|
|
typedef struct jpeg_decompress_struct * j_decompress_ptr;
|
|
typedef int size_t;
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
void jpeg_CreateDecompress(j_decompress_ptr cinfo,
|
|
int version, size_t structsize);
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
/* We use char because int might match the return type of a gcc2
|
|
builtin and then its argument prototype would still apply. */
|
|
],
|
|
[jpeg_CreateDecompress(0L, 0, 0);],
|
|
eval "ac_cv_lib_jpeg=-ljpeg",
|
|
eval "ac_cv_lib_jpeg=no")
|
|
LIBS="$ac_save_LIBS"
|
|
|
|
dnl what to do, if the normal way fails:
|
|
if eval "test \"`echo $ac_cv_lib_jpeg`\" = no"; then
|
|
if test -f "$kde_libraries/libjpeg.so"; then
|
|
test -f ./libjpegkde.so || $LN_S $kde_libraries/libjpeg.so ./libjpegkde.so
|
|
ac_cv_lib_jpeg="-L\${topdir} -ljpegkde"
|
|
else if test -f "$kde_libraries/libjpeg.sl"; then
|
|
test -f ./libjpegkde.sl ||$LN_S $kde_libraries/libjpeg.sl ./libjpegkde.sl
|
|
ac_cv_lib_jpeg="-L\${topdir} -ljpegkde"
|
|
else if test -f "$kde_libraries/libjpeg.a"; then
|
|
test -f ./libjpegkde.a || $LN_S $kde_libraries/libjpeg.a ./libjpegkde.a
|
|
ac_cv_lib_jpeg="-L\${topdir} -ljpegkde"
|
|
else
|
|
AC_MSG_ERROR([
|
|
You need jpeglib6a. Please install the kdesupport package.
|
|
If you have already installed kdesupport, you may have an
|
|
old libjpeg somewhere.
|
|
In this case copy $KDEDIR/lib/libjpeg* to /usr/lib.
|
|
])
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
])dnl
|
|
if eval "test ! \"`echo $ac_cv_lib_jpeg`\" = no"; then
|
|
LIBJPEG="$ac_cv_lib_jpeg"
|
|
AC_SUBST(LIBJPEG)
|
|
AC_MSG_RESULT($ac_cv_lib_jpeg)
|
|
AC_DEFINE_UNQUOTED(HAVE_LIBJPEG)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(AC_FIND_ZLIB,
|
|
[
|
|
AC_MSG_CHECKING([for libz])
|
|
AC_CACHE_VAL(ac_cv_lib_z,
|
|
[ac_save_LIBS="$LIBS"
|
|
LIBS="$all_libraries -lz $LIBSOCKET"
|
|
AC_TRY_LINK(dnl
|
|
[
|
|
#include<zlib.h>
|
|
],
|
|
[return (zlibVersion() == ZLIB_VERSION); ],
|
|
eval "ac_cv_lib_z='-lz'",
|
|
eval "ac_cv_lib_z=no")
|
|
LIBS="$ac_save_LIBS"
|
|
])dnl
|
|
if eval "test ! \"`echo $ac_cv_lib_z`\" = no"; then
|
|
dnl AC_DEFINE_UNQUOTED(HAVE_LIBZ)
|
|
LIBZ="$ac_cv_lib_z"
|
|
AC_SUBST(LIBZ)
|
|
AC_MSG_RESULT($ac_cv_lib_z)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
LIBZ=""
|
|
AC_SUBST(LIBZ)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(AC_FIND_TIFF,
|
|
[
|
|
AC_REQUIRE([AC_FIND_ZLIB])
|
|
AC_REQUIRE([AC_FIND_JPEG])
|
|
AC_MSG_CHECKING([for libtiff])
|
|
AC_CACHE_VAL(ac_cv_lib_tiff,
|
|
[ac_save_LIBS="$LIBS"
|
|
LIBS="$all_libraries -ltiff $LIBJPEG $LIBZ -lX11 $LIBSOCKET"
|
|
AC_TRY_LINK(dnl
|
|
[
|
|
#include<tiffio.h>
|
|
],
|
|
[return (TIFFOpen( "", "r") == 0); ],
|
|
eval "ac_cv_lib_tiff='-ltiff $LIBJPEG $LIBZ'",
|
|
eval "ac_cv_lib_tiff=no")
|
|
LIBS="$ac_save_LIBS"
|
|
])dnl
|
|
if eval "test ! \"`echo $ac_cv_lib_tiff`\" = no"; then
|
|
AC_DEFINE_UNQUOTED(HAVE_LIBTIFF)
|
|
LIBTIFF="$ac_cv_lib_tiff"
|
|
AC_SUBST(LIBTIFF)
|
|
AC_MSG_RESULT($ac_cv_lib_tiff)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
LIBTIFF=""
|
|
AC_SUBST(LIBTIFF)
|
|
fi
|
|
])
|
|
|
|
|
|
AC_DEFUN(AC_FIND_PNG,
|
|
[
|
|
AC_REQUIRE([AC_FIND_ZLIB])
|
|
AC_MSG_CHECKING([for libpng])
|
|
AC_CACHE_VAL(ac_cv_lib_png,
|
|
[ac_save_LIBS="$LIBS"
|
|
LIBS="$all_libraries -lpng $LIBZ -lm -lX11 $LIBSOCKET"
|
|
AC_LANG_C
|
|
AC_TRY_LINK(dnl
|
|
[
|
|
#include<png.h>
|
|
],
|
|
[
|
|
png_structp png_ptr = png_create_read_struct( // image ptr
|
|
PNG_LIBPNG_VER_STRING, 0, 0, 0 );
|
|
return( png_ptr != 0 );
|
|
],
|
|
eval "ac_cv_lib_png='-lpng $LIBZ -lm'",
|
|
eval "ac_cv_lib_png=no")
|
|
LIBS="$ac_save_LIBS"
|
|
])dnl
|
|
if eval "test ! \"`echo $ac_cv_lib_png`\" = no"; then
|
|
AC_DEFINE_UNQUOTED(HAVE_LIBPNG)
|
|
LIBPNG="$ac_cv_lib_png"
|
|
AC_SUBST(LIBPNG)
|
|
AC_MSG_RESULT($ac_cv_lib_png)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
LIBPNG=""
|
|
AC_SUBST(LIBPNG)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(AC_CHECK_GNU_EXTENSIONS,
|
|
[
|
|
AC_MSG_CHECKING(if you need GNU extensions)
|
|
AC_CACHE_VAL(ac_cv_gnu_extensions,
|
|
[
|
|
cat > conftest.c << EOF
|
|
#include <features.h>
|
|
|
|
#ifdef __GNU_LIBRARY__
|
|
yes
|
|
#endif
|
|
EOF
|
|
|
|
if (eval "$ac_cpp conftest.c") 2>&5 |
|
|
egrep "yes" >/dev/null 2>&1; then
|
|
rm -rf conftest*
|
|
ac_cv_gnu_extensions=yes
|
|
else
|
|
ac_cv_gnu_extensions=no
|
|
fi
|
|
])
|
|
|
|
AC_MSG_RESULT($ac_cv_gnu_extensions)
|
|
if test "$ac_cv_gnu_extensions" = "yes"; then
|
|
AC_DEFINE_UNQUOTED(_GNU_SOURCE)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(AC_CHECK_COMPILERS,
|
|
[
|
|
dnl this is somehow a fat lie, but prevents other macros from double checking
|
|
AC_PROVIDE([AC_PROG_CC])
|
|
AC_PROVIDE([AC_PROG_CPP])
|
|
AC_ARG_ENABLE(debug,[ --enable-debug creates debugging code [default=no]],
|
|
[
|
|
if test $enableval = "no"; dnl
|
|
then ac_use_debug_code="no"
|
|
else ac_use_debug_code="yes"
|
|
fi
|
|
], [ac_use_debug_code="no"])
|
|
|
|
AC_ARG_ENABLE(strict,[ --enable-strict compiles with strict compiler options (may not work!)],
|
|
[
|
|
if test $enableval = "no"; then
|
|
ac_use_strict_options="no"
|
|
else
|
|
ac_use_strict_options="yes"
|
|
fi
|
|
], [ac_use_strict_options="no"])
|
|
|
|
dnl this was AC_PROG_CC. I had to include it manualy, since I had to patch it
|
|
AC_MSG_CHECKING(for a C-Compiler)
|
|
dnl if there is one, print out. if not, don't matter
|
|
AC_MSG_RESULT($CC)
|
|
|
|
if test -z "$CC"; then AC_CHECK_PROG(CC, gcc, gcc) fi
|
|
if test -z "$CC"; then AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc) fi
|
|
if test -z "$CC"; then AC_CHECK_PROG(CC, xlc, xlc) fi
|
|
test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH])
|
|
|
|
AC_PROG_CC_WORKS
|
|
AC_PROG_CC_GNU
|
|
|
|
if test $ac_cv_prog_gcc = yes; then
|
|
GCC=yes
|
|
else
|
|
GCC=
|
|
fi
|
|
|
|
if test -z "$CFLAGS"; then
|
|
if test "$ac_use_debug_code" = "yes"; then
|
|
AC_PROG_CC_G
|
|
if test $ac_cv_prog_cc_g = yes; then
|
|
CFLAGS="-g"
|
|
fi
|
|
else
|
|
if test "$GCC" = "yes"; then
|
|
CFLAGS="-O2"
|
|
else
|
|
CFLAGS=""
|
|
fi
|
|
fi
|
|
|
|
if test "$GCC" = "yes"; then
|
|
CFLAGS="$CFLAGS -Wall"
|
|
|
|
if test "$ac_use_strict_options" = "yes"; then
|
|
CFLAGS="$CFLAGS -W -ansi -pedantic"
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
case "$host" in
|
|
*-*-sysv4.2uw*) CFLAGS="$CFLAGS -D_UNIXWARE";;
|
|
esac
|
|
|
|
if test -z "$LDFLAGS" && test "$ac_use_debug_code" = "no" && test "$GCC" = "yes"; then
|
|
LDFLAGS="-s"
|
|
fi
|
|
|
|
|
|
dnl this is AC_PROG_CPP. I had to include it here, since autoconf checks
|
|
dnl dependecies between AC_PROG_CPP and AC_PROG_CC (or is it automake?)
|
|
|
|
AC_MSG_CHECKING(how to run the C preprocessor)
|
|
# On Suns, sometimes $CPP names a directory.
|
|
if test -n "$CPP" && test -d "$CPP"; then
|
|
CPP=
|
|
fi
|
|
if test -z "$CPP"; then
|
|
AC_CACHE_VAL(ac_cv_prog_CPP,
|
|
[ # This must be in double quotes, not single quotes, because CPP may get
|
|
# substituted into the Makefile and "${CC-cc}" will confuse make.
|
|
CPP="${CC-cc} -E"
|
|
# On the NeXT, cc -E runs the code through the compiler's parser,
|
|
# not just through cpp.
|
|
dnl Use a header file that comes with gcc, so configuring glibc
|
|
dnl with a fresh cross-compiler works.
|
|
AC_TRY_CPP([#include <assert.h>
|
|
Syntax Error], ,
|
|
CPP="${CC-cc} -E -traditional-cpp"
|
|
AC_TRY_CPP([#include <assert.h>
|
|
Syntax Error], , CPP=/lib/cpp))
|
|
ac_cv_prog_CPP="$CPP"])dnl
|
|
CPP="$ac_cv_prog_CPP"
|
|
else
|
|
ac_cv_prog_CPP="$CPP"
|
|
fi
|
|
AC_MSG_RESULT($CPP)
|
|
AC_SUBST(CPP)dnl
|
|
|
|
|
|
AC_MSG_CHECKING(for a C++-Compiler)
|
|
dnl if there is one, print out. if not, don't matter
|
|
AC_MSG_RESULT($CXX)
|
|
|
|
if test -z "$CXX"; then AC_CHECK_PROG(CXX, g++, g++) fi
|
|
if test -z "$CXX"; then AC_CHECK_PROG(CXX, CC, CC) fi
|
|
if test -z "$CXX"; then AC_CHECK_PROG(CXX, xlC, xlC) fi
|
|
if test -z "$CXX"; then AC_CHECK_PROG(CXX, DCC, DCC) fi
|
|
test -z "$CXX" && AC_MSG_ERROR([no acceptable C++-compiler found in \$PATH])
|
|
|
|
AC_PROG_CXX_WORKS
|
|
AC_PROG_CXX_GNU
|
|
|
|
if test $ac_cv_prog_gxx = yes; then
|
|
GXX=yes
|
|
else
|
|
AC_MSG_CHECKING(whether we are using SPARC CC)
|
|
GXX=
|
|
cat > conftest.C << EOF
|
|
#ifdef __SUNPRO_CC
|
|
yes;
|
|
#endif
|
|
EOF
|
|
|
|
ac_try="$CXX -E conftest.C"
|
|
if { (eval echo configure:__online__: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } | egrep yes >/dev/null 2>&1; then
|
|
ac_cv_prog_CC=yes
|
|
else
|
|
ac_cv_prog_CC=no
|
|
fi
|
|
AC_MSG_RESULT($ac_cv_prog_CC)
|
|
fi
|
|
|
|
if test -z "$CXXFLAGS"; then
|
|
if test "$ac_use_debug_code" = "yes"; then
|
|
AC_PROG_CXX_G
|
|
if test $ac_cv_prog_cxx_g = yes; then
|
|
CXXFLAGS="-g"
|
|
fi
|
|
if test "$ac_cv_prog_CC" = "yes"; then
|
|
CXXFLAGS="$CXXFLAGS -pto"
|
|
fi
|
|
else
|
|
if test "$GXX" = "yes"; then
|
|
CXXFLAGS="-O2"
|
|
else
|
|
if test "$ac_cv_prog_CC" = "yes"; then
|
|
CXXFLAGS="-pto -O2"
|
|
else
|
|
CXXFLAGS=""
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "$GXX" = "yes"; then
|
|
CXXFLAGS="$CXXFLAGS -Wall"
|
|
|
|
if test "$ac_use_strict_options" = "yes"; then
|
|
CXXFLAGS="$CXXFLAGS -W -ansi -Wtraditional -Wpointer-arith -Wcast-qual -Wcast-align -Wwrite-strings -Woverloaded-virtual -Wbad-function-cast -Wsynth"
|
|
fi
|
|
|
|
if test "$kde_very_strict" = "yes"; then
|
|
CXXFLAGS="$CXXFLAGS -Wold-style-cast -Wshadow -Wredundant-decls -Wconversion"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
case "$host" in
|
|
*-*-sysv4.2uw*) CXXFLAGS="$CXXFLAGS -D_UNIXWARE";;
|
|
esac
|
|
|
|
])
|
|
|
|
dnl just a wrapper to clean up configure.in
|
|
AC_DEFUN(KDE_PROG_LIBTOOL,
|
|
[
|
|
AC_REQUIRE([AM_ENABLE_SHARED])
|
|
AC_REQUIRE([AM_ENABLE_STATIC])
|
|
dnl libtool is only for C, so I must force him
|
|
dnl to find the correct flags for C++
|
|
ac_save_cc=$CC
|
|
ac_save_cflags="$CFLAGS"
|
|
CC=$CXX
|
|
CFLAGS="$CXXFLAGS"
|
|
AM_PROG_LIBTOOL dnl for libraries
|
|
CC=$ac_save_cc
|
|
CFLAGS="$ac_save_cflags"
|
|
])
|
|
|
|
AC_DEFUN(KDE_DO_IT_ALL,
|
|
[
|
|
AC_PREFIX_DEFAULT(${KDEDIR:-/usr/local/kde})
|
|
KDE_PROG_LIBTOOL
|
|
AM_KDE_WITH_NLS
|
|
AC_PATH_KDE
|
|
])
|
|
|
|
AC_DEFUN(AC_CHECK_RPATH,
|
|
[
|
|
AC_MSG_CHECKING(for rpath)
|
|
AC_ARG_ENABLE(rpath,
|
|
[ --disable-rpath do not use the rpath feature of ld],
|
|
USE_RPATH=$enableval, USE_RPATH=yes)
|
|
if test -z "$KDE_RPATH" && test "$USE_RPATH" = "yes"; then
|
|
|
|
KDE_RPATH="-rpath \$(kde_libraries)"
|
|
|
|
if test -n "$qt_libraries"; then
|
|
KDE_RPATH="$KDE_RPATH -rpath \$(qt_libraries)"
|
|
fi
|
|
dnl $x_libraries is set to /usr/lib in case
|
|
if test -n "$X_LDFLAGS"; then
|
|
KDE_RPATH="$KDE_RPATH -rpath \$(x_libraries)"
|
|
fi
|
|
if test -n "$KDE_EXTRA_RPATH"; then
|
|
KDE_RPATH="$KDE_RPATH \$(KDE_EXTRA_RPATH)"
|
|
fi
|
|
fi
|
|
AC_SUBST(KDE_EXTRA_RPATH)
|
|
AC_SUBST(KDE_RPATH)
|
|
AC_MSG_RESULT($USE_RPATH)
|
|
])
|
|
|
|
dnl This is a merge of some macros out of the gettext aclocal.m4
|
|
dnl since we don't need anything, I took the things we need
|
|
AC_DEFUN(AM_KDE_WITH_NLS,
|
|
[AC_MSG_CHECKING([whether NLS is requested])
|
|
AC_LANG_CPLUSPLUS
|
|
dnl Default is enabled NLS
|
|
AC_ARG_ENABLE(nls,
|
|
[ --disable-nls do not use Native Language Support],
|
|
USE_NLS=$enableval, USE_NLS=yes)
|
|
AC_MSG_RESULT($USE_NLS)
|
|
AC_SUBST(USE_NLS)
|
|
|
|
dnl If we use NLS figure out what method
|
|
if test "$USE_NLS" = "yes"; then
|
|
AC_DEFINE(ENABLE_NLS)
|
|
|
|
AM_PATH_PROG_WITH_TEST_KDE(MSGFMT, msgfmt,
|
|
[test -n "`$ac_dir/$ac_word --version 2>&1 | grep 'GNU gettext'`"], msgfmt)
|
|
AC_PATH_PROG(GMSGFMT, gmsgfmt, $MSGFMT)
|
|
|
|
if test -z "`$MSGFMT --version 2>&1 | grep 'GNU gettext'`"; then
|
|
AC_MSG_RESULT([found msgfmt program is not GNU msgfmt; ignore it])
|
|
msgfmt=":"
|
|
fi
|
|
AC_SUBST(MSGFMT)
|
|
|
|
AM_PATH_PROG_WITH_TEST_KDE(XGETTEXT, xgettext,
|
|
[test -z "`$ac_dir/$ac_word -h 2>&1 | grep '(HELP)'`"], :)
|
|
|
|
dnl Test whether we really found GNU xgettext.
|
|
if test "$XGETTEXT" != ":"; then
|
|
dnl If it is no GNU xgettext we define it as : so that the
|
|
dnl Makefiles still can work.
|
|
if $XGETTEXT --omit-header /dev/null 2> /dev/null; then
|
|
: ;
|
|
else
|
|
AC_MSG_RESULT(
|
|
[found xgettext programs is not GNU xgettext; ignore it])
|
|
XGETTEXT=":"
|
|
fi
|
|
fi
|
|
AC_SUBST(XGETTEXT)
|
|
fi
|
|
|
|
])
|
|
|
|
# Search path for a program which passes the given test.
|
|
# Ulrich Drepper <drepper@cygnus.com>, 1996.
|
|
|
|
# serial 1
|
|
# Stephan Kulow: I appended a _KDE against name conflicts
|
|
|
|
dnl AM_PATH_PROG_WITH_TEST_KDE(VARIABLE, PROG-TO-CHECK-FOR,
|
|
dnl TEST-PERFORMED-ON-FOUND_PROGRAM [, VALUE-IF-NOT-FOUND [, PATH]])
|
|
AC_DEFUN(AM_PATH_PROG_WITH_TEST_KDE,
|
|
[# Extract the first word of "$2", so it can be a program name with args.
|
|
set dummy $2; ac_word=[$]2
|
|
AC_MSG_CHECKING([for $ac_word])
|
|
AC_CACHE_VAL(ac_cv_path_$1,
|
|
[case "[$]$1" in
|
|
/*)
|
|
ac_cv_path_$1="[$]$1" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
|
|
for ac_dir in ifelse([$5], , $PATH, [$5]); do
|
|
test -z "$ac_dir" && ac_dir=.
|
|
if test -f $ac_dir/$ac_word; then
|
|
if [$3]; then
|
|
ac_cv_path_$1="$ac_dir/$ac_word"
|
|
break
|
|
fi
|
|
fi
|
|
done
|
|
IFS="$ac_save_ifs"
|
|
dnl If no 4th arg is given, leave the cache variable unset,
|
|
dnl so AC_PATH_PROGS will keep looking.
|
|
ifelse([$4], , , [ test -z "[$]ac_cv_path_$1" && ac_cv_path_$1="$4"
|
|
])dnl
|
|
;;
|
|
esac])dnl
|
|
$1="$ac_cv_path_$1"
|
|
if test -n "[$]$1"; then
|
|
AC_MSG_RESULT([$]$1)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
AC_SUBST($1)dnl
|
|
])
|
|
|
|
|
|
dnl From Jim Meyering.
|
|
dnl FIXME: migrate into libit.
|
|
|
|
AC_DEFUN(AM_FUNC_OBSTACK,
|
|
[AC_CACHE_CHECK([for obstacks], am_cv_func_obstack,
|
|
[AC_TRY_LINK([#include "obstack.h"],
|
|
[struct obstack *mem;obstack_free(mem,(char *) 0)],
|
|
am_cv_func_obstack=yes,
|
|
am_cv_func_obstack=no)])
|
|
if test $am_cv_func_obstack = yes; then
|
|
AC_DEFINE(HAVE_OBSTACK)
|
|
else
|
|
LIBOBJS="$LIBOBJS obstack.o"
|
|
fi
|
|
])
|
|
|
|
dnl From Jim Meyering. Use this if you use the GNU error.[ch].
|
|
dnl FIXME: Migrate into libit
|
|
|
|
AC_DEFUN(AM_FUNC_ERROR_AT_LINE,
|
|
[AC_CACHE_CHECK([for error_at_line], am_cv_lib_error_at_line,
|
|
[AC_TRY_LINK([],[error_at_line(0, 0, "", 0, "");],
|
|
am_cv_lib_error_at_line=yes,
|
|
am_cv_lib_error_at_line=no)])
|
|
if test $am_cv_lib_error_at_line = no; then
|
|
LIBOBJS="$LIBOBJS error.o"
|
|
fi
|
|
AC_SUBST(LIBOBJS)dnl
|
|
])
|
|
|
|
# Macro to add for using GNU gettext.
|
|
# Ulrich Drepper <drepper@cygnus.com>, 1995.
|
|
|
|
# serial 1
|
|
# Stephan Kulow: I put a KDE in it to avoid name conflicts
|
|
|
|
AC_DEFUN(AM_KDE_GNU_GETTEXT,
|
|
[AC_REQUIRE([AC_PROG_MAKE_SET])dnl
|
|
AC_REQUIRE([AC_PROG_RANLIB])dnl
|
|
AC_REQUIRE([AC_HEADER_STDC])dnl
|
|
AC_REQUIRE([AC_C_INLINE])dnl
|
|
AC_REQUIRE([AC_TYPE_OFF_T])dnl
|
|
AC_REQUIRE([AC_TYPE_SIZE_T])dnl
|
|
AC_REQUIRE([AC_FUNC_ALLOCA])dnl
|
|
AC_REQUIRE([AC_FUNC_MMAP])dnl
|
|
AC_REQUIRE([AM_KDE_WITH_NLS])dnl
|
|
AC_CHECK_HEADERS([argz.h limits.h locale.h nl_types.h malloc.h string.h \
|
|
unistd.h values.h alloca.h])
|
|
AC_CHECK_FUNCS([getcwd munmap putenv setenv setlocale strchr strcasecmp \
|
|
__argz_count __argz_stringify __argz_next stpcpy])
|
|
|
|
AM_LC_MESSAGES
|
|
|
|
if test "x$CATOBJEXT" != "x"; then
|
|
if test "x$ALL_LINGUAS" = "x"; then
|
|
LINGUAS=
|
|
else
|
|
AC_MSG_CHECKING(for catalogs to be installed)
|
|
NEW_LINGUAS=
|
|
for lang in ${LINGUAS=$ALL_LINGUAS}; do
|
|
case "$ALL_LINGUAS" in
|
|
*$lang*) NEW_LINGUAS="$NEW_LINGUAS $lang" ;;
|
|
esac
|
|
done
|
|
LINGUAS=$NEW_LINGUAS
|
|
AC_MSG_RESULT($LINGUAS)
|
|
fi
|
|
|
|
dnl Construct list of names of catalog files to be constructed.
|
|
if test -n "$LINGUAS"; then
|
|
for lang in $LINGUAS; do CATALOGS="$CATALOGS $lang$CATOBJEXT"; done
|
|
fi
|
|
fi
|
|
|
|
])
|
|
|
|
AC_DEFUN(AC_HAVE_XPM,
|
|
[AC_REQUIRE_CPP()dnl
|
|
|
|
test -z "$XPM_LDFLAGS" && XPM_LDFLAGS=
|
|
test -z "$XPM_INCLUDE" && XPM_INCLUDE=
|
|
|
|
AC_ARG_WITH(xpm, [ --without-xpm disable color pixmap XPM tests],
|
|
xpm_test=$withval, xpm_test="yes")
|
|
if test "x$xpm_test" = xno; then
|
|
ac_cv_have_xpm=no
|
|
else
|
|
AC_MSG_CHECKING(for XPM)
|
|
AC_CACHE_VAL(ac_cv_have_xpm,
|
|
[
|
|
AC_LANG_C
|
|
ac_save_ldflags="$LDFLAGS"
|
|
ac_save_cflags="$CFLAGS"
|
|
LDFLAGS="$LDFLAGS $XPM_LDFLAGS $all_libraries -lXpm -lX11 -lXext $LIBSOCKET"
|
|
CFLAGS="$CFLAGS $X_INCLUDES"
|
|
test ! -z "$XPM_INCLUDE" && CFLAGS="-I$XPM_INCLUDE $CFLAGS"
|
|
AC_TRY_LINK([#include <X11/xpm.h>],[],
|
|
ac_cv_have_xpm="yes",ac_cv_have_xpm="no")
|
|
LDFLAGS="$ac_save_ldflags"
|
|
CFLAGS="$ac_save_cflags"
|
|
])dnl
|
|
|
|
if test "$ac_cv_have_xpm" = no; then
|
|
AC_MSG_RESULT(no)
|
|
XPM_LDFLAGS=""
|
|
XPMINC=""
|
|
$2
|
|
else
|
|
AC_DEFINE(HAVE_XPM)
|
|
if test "$XPM_LDFLAGS" = ""; then
|
|
XPMLIB="-lXpm"
|
|
else
|
|
XPMLIB="-L$XPM_LDFLAGS -lXpm"
|
|
fi
|
|
if test "$XPM_INCLUDE" = ""; then
|
|
XPMINC=""
|
|
else
|
|
XPMINC="-I$XPM_INCLUDE"
|
|
fi
|
|
AC_MSG_RESULT(yes)
|
|
$1
|
|
fi
|
|
fi
|
|
AC_SUBST(XPMINC)
|
|
AC_SUBST(XPMLIB)
|
|
])
|
|
|
|
AC_DEFUN(AC_HAVE_GL,
|
|
[AC_REQUIRE_CPP()dnl
|
|
|
|
test -z "$GL_LDFLAGS" && GL_LDFLAGS=
|
|
test -z "$GL_INCLUDE" && GL_INCLUDE=
|
|
|
|
AC_ARG_WITH(gl, [ --without-gl disable 3D GL modes],
|
|
gl_test=$withval, gl_test="yes")
|
|
if test "x$gl_test" = xno; then
|
|
ac_cv_have_gl=no
|
|
else
|
|
AC_MSG_CHECKING(for GL)
|
|
AC_CACHE_VAL(ac_cv_have_gl,
|
|
[
|
|
AC_LANG_C
|
|
ac_save_ldflags="$LDFLAGS"
|
|
ac_save_cflags="$CFLAGS"
|
|
LDFLAGS="$LDFLAGS $GL_LDFLAGS $all_libraries -lMesaGL -lMesaGLU -lX11 -lXext -lm $LIBSOCKET"
|
|
CFLAGS="$CFLAGS $X_INCLUDES"
|
|
test ! -z "$GL_INCLUDE" && CFLAGS="-I$GL_INCLUDE $CFLAGS"
|
|
AC_TRY_LINK([],[],
|
|
ac_cv_have_gl="yes",ac_cv_have_gl="no")
|
|
LDFLAGS="$ac_save_ldflags"
|
|
CFLAGS="$ac_save_cflags"
|
|
])dnl
|
|
|
|
if test "$ac_cv_have_gl" = no; then
|
|
AC_MSG_RESULT(no)
|
|
GL_LDFLAGS=""
|
|
GLINC=""
|
|
$2
|
|
else
|
|
AC_DEFINE(HAVE_GL)
|
|
if test "$GL_LDFLAGS" = ""; then
|
|
GLLIB="-lMesaGL -lMesaGLU"
|
|
else
|
|
GLLIB="-L$GL_LDFLAGS -lMesaGL -lMesaGLU"
|
|
fi
|
|
if test "$GL_INCLUDE" = ""; then
|
|
GLINC=""
|
|
else
|
|
GLINC="-I$GL_INCLUDE"
|
|
fi
|
|
AC_MSG_RESULT(yes)
|
|
$1
|
|
fi
|
|
fi
|
|
AC_SUBST(GLINC)
|
|
AC_SUBST(GLLIB)
|
|
])
|
|
|
|
dnl PAM pam
|
|
|
|
dnl Should test for PAM (Pluggable Authentication Modules)
|
|
AC_DEFUN(AC_PATH_PAM_DIRECT,
|
|
[
|
|
test -z "$pam_direct_test_library" && pam_direct_test_library=pam
|
|
test -z "$pam_direct_test_include" && pam_direct_test_include=security/pam_appl.h
|
|
|
|
for ac_dir in \
|
|
\
|
|
/usr/local/include \
|
|
/usr/include \
|
|
/usr/unsupported/include \
|
|
/opt/include \
|
|
/usr/pam/include \
|
|
/usr/local/pam/include \
|
|
/usr/lib/pam/include \
|
|
\
|
|
$extra_include \
|
|
; \
|
|
do
|
|
if test -r "$ac_dir/$pam_direct_test_include"; then
|
|
no_pam= ac_pam_includes=$ac_dir
|
|
break
|
|
fi
|
|
done
|
|
|
|
# First see if replacing the include by lib works.
|
|
for ac_dir in `echo "$ac_pam_includes" | sed s/include/lib/` \
|
|
\
|
|
/lib \
|
|
/usr/lib \
|
|
/usr/local/lib \
|
|
/usr/unsupported/lib \
|
|
/lib/security \
|
|
/usr/security/lib \
|
|
$extra_lib \
|
|
; \
|
|
do
|
|
for ac_extension in a so sl; do
|
|
if test -r $ac_dir/lib${pam_direct_test_library}.$ac_extension; then
|
|
no_pam= ac_pam_libraries=$ac_dir
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
])
|
|
|
|
AC_DEFUN(AC_PATH_PAM,
|
|
[AC_REQUIRE_CPP()dnl
|
|
|
|
AC_CHECK_LIB(pam_misc, main, [PAM_MISC_LIB="-lpam_misc"], [], [-lpam -ldl])
|
|
|
|
AC_MSG_CHECKING(for PAM)
|
|
AC_ARG_WITH(pam,
|
|
[ --with-pam[=ARG] enable support for PAM: ARG=[yes|no|service name]],
|
|
[
|
|
if test "x$withval" = "xyes"; then
|
|
no_pam=
|
|
default_pam=yes
|
|
elif test "x$withval" = "xno"; then
|
|
no_pam=yes
|
|
else
|
|
no_pam=
|
|
pam_service="$withval"
|
|
if test -z "$pam_service"; then
|
|
default_pam=yes
|
|
else
|
|
default_pam=
|
|
fi
|
|
fi
|
|
], no_pam=yes
|
|
)
|
|
|
|
if test ! "$no_pam" = yes; then
|
|
|
|
AC_CACHE_VAL(ac_cv_path_pam,
|
|
[
|
|
ac_pam_includes=NONE
|
|
ac_pam_libraries=NONE
|
|
if test -z "$pam_libraries"; then
|
|
pam_libraries=NONE
|
|
fi
|
|
if test -z "$pam_includes"; then
|
|
pam_includes=NONE
|
|
fi
|
|
|
|
AC_PATH_PAM_DIRECT
|
|
|
|
test "x$pam_includes" = xNONE && pam_includes=$ac_pam_includes
|
|
test "x$pam_libraries" = xNONE && pam_libraries=$ac_pam_libraries
|
|
|
|
if test ! "x$pam_includes" = xNONE && test ! "x$pam_libraries" = xNONE; then
|
|
ac_pam_libs="-lpam $PAM_MISC_LIB -ldl"
|
|
ac_cv_path_pam="no_pam= ac_pam_includes=$ac_pam_includes ac_pam_libraries=$ac_pam_libraries ac_pam_libs=\"$ac_pam_libs\""
|
|
else
|
|
ac_cv_path_pam="no_pam=yes"
|
|
fi
|
|
])
|
|
|
|
eval "$ac_cv_path_pam"
|
|
|
|
fi
|
|
|
|
if test "$no_pam" = yes; then
|
|
AC_MSG_RESULT(no)
|
|
else
|
|
AC_DEFINE(HAVE_PAM)
|
|
PAMLIBS="$ac_pam_libs"
|
|
test "x$pam_includes" = xNONE && pam_includes=$ac_pam_includes
|
|
test "x$pam_libraries" = xNONE && pam_libraries=$ac_pam_libraries
|
|
AC_MSG_RESULT([libraries $pam_libraries, headers $pam_includes])
|
|
if test "$default_pam" = yes; then
|
|
AC_MSG_RESULT(["default pam service name will be used"])
|
|
else
|
|
AC_DEFINE_UNQUOTED(KDE_PAM_SERVICE,"$pam_service")
|
|
AC_MSG_RESULT(["pam service name will be: " $pam_service])
|
|
fi
|
|
dnl test whether struct pam_message is const (Linux) or not (Sun)
|
|
pam_appl_h="$ac_pam_includes/security/pam_appl.h"
|
|
AC_MSG_CHECKING(for const pam_message)
|
|
AC_EGREP_HEADER([struct pam_message],
|
|
$pam_appl_h,
|
|
[ AC_EGREP_HEADER([const struct pam_message],
|
|
$pam_appl_h,
|
|
[AC_MSG_RESULT(["const: Linux-type PAM"]) ],
|
|
[AC_MSG_RESULT(["nonconst: Sun-type PAM"])
|
|
AC_DEFINE(PAM_MESSAGE_NONCONST)]
|
|
)],
|
|
[AC_MSG_RESULT(["not found - assume const, Linux-type PAM"])]
|
|
)
|
|
fi
|
|
|
|
if test "x$pam_libraries" != x && test "x$pam_libraries" != xNONE ; then
|
|
PAMLIBPATHS="-L$pam_libraries"
|
|
fi
|
|
if test "x$pam_includes" != x && test "x$pam_includes" != xNONE ; then
|
|
PAMINC="-I$pam_includes"
|
|
fi
|
|
|
|
AC_SUBST(PAMINC)
|
|
AC_SUBST(PAMLIBS)
|
|
AC_SUBST(PAMLIBPATHS)
|
|
|
|
])
|
|
|
|
AC_DEFUN(KDE_CHECK_LIBDL,
|
|
[
|
|
AC_CHECK_LIB(dl, dlopen, [
|
|
LIBDL="-ldl"
|
|
ac_cv_have_dlfcn=yes
|
|
])
|
|
|
|
AC_CHECK_LIB(dld, shl_unload, [
|
|
LIBDL="-ldld"
|
|
ac_cv_have_shload=yes
|
|
])
|
|
|
|
AC_SUBST(LIBDL)
|
|
])
|
|
|
|
AC_DEFUN(KDE_CHECK_DLOPEN,
|
|
[
|
|
KDE_CHECK_LIBDL
|
|
AC_CHECK_HEADERS(dlfcn.h dl.h)
|
|
if test "$ac_cv_header_dlfcn_h" = "no"; then
|
|
ac_cv_have_dlfcn=no
|
|
fi
|
|
|
|
if test "$ac_cv_header_dl_h" = "no"; then
|
|
ac_cv_have_shload=no
|
|
fi
|
|
|
|
enable_dlopen=no
|
|
AC_ARG_ENABLE(dlopen,
|
|
[ --disable-dlopen link staticly [default=no]] ,
|
|
[if test "$enableval" = yes; then
|
|
enable_dlopen=yes
|
|
fi],
|
|
enable_dlopen=yes)
|
|
|
|
# override the user's opinion, if we know it better ;)
|
|
if test "$ac_cv_have_dlfcn" = "no" && test "$ac_cv_have_shload" = "no"; then
|
|
enable_dlopen=no
|
|
fi
|
|
|
|
if test "$ac_cv_have_dlfcn" = "yes"; then
|
|
AC_DEFINE_UNQUOTED(HAVE_DLFCN)
|
|
fi
|
|
|
|
if test "$ac_cv_have_shload" = "yes"; then
|
|
AC_DEFINE_UNQUOTED(HAVE_SHLOAD)
|
|
fi
|
|
|
|
if test "$enable_dlopen" = no ; then
|
|
test -n "$1" && eval $1
|
|
else
|
|
test -n "$2" && eval $2
|
|
fi
|
|
|
|
])
|
|
|
|
AC_DEFUN(KDE_CHECK_DYNAMIC_LOADING,
|
|
[
|
|
KDE_CHECK_DLOPEN(libtool_enable_shared=no, libtool_enable_static=no)
|
|
KDE_PROG_LIBTOOL
|
|
AC_MSG_CHECKING([dynamic loading])
|
|
eval "`egrep '^build_libtool_libs=' libtool`"
|
|
if test "$build_libtool_libs" = "yes" && test "$enable_dlopen" = "yes"; then
|
|
dynamic_loading=yes
|
|
AC_DEFINE_UNQUOTED(HAVE_DYNAMIC_LOADING)
|
|
else
|
|
dynamic_loading=no
|
|
fi
|
|
AC_MSG_RESULT($dynamic_loading)
|
|
if test "$dynamic_loading" = "yes"; then
|
|
$1
|
|
else
|
|
$2
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(KDE_ADD_INCLUDES,
|
|
[
|
|
if test -z "$1"; then
|
|
test_include="Pix.h"
|
|
else
|
|
test_include="$1"
|
|
fi
|
|
|
|
AC_MSG_CHECKING([for libg++ ($test_include)])
|
|
|
|
AC_CACHE_VAL(kde_cv_libgpp_includes,
|
|
[
|
|
kde_cv_libgpp_includes=no
|
|
|
|
for ac_dir in \
|
|
\
|
|
/usr/include/g++ \
|
|
/usr/include \
|
|
/usr/unsupported/include \
|
|
/opt/include \
|
|
$extra_include \
|
|
; \
|
|
do
|
|
if test -r "$ac_dir/$test_include"; then
|
|
kde_cv_libgpp_includes=$ac_dir
|
|
break
|
|
fi
|
|
done
|
|
])
|
|
|
|
AC_MSG_RESULT($kde_cv_libgpp_includes)
|
|
if test "$kde_cv_libgpp_includes" != "no"; then
|
|
all_includes="-I$kde_cv_libgpp_includes $all_includes"
|
|
fi
|
|
])
|
|
])
|
|
|
|
|
|
AC_DEFUN(KDE_CHECK_MICO,
|
|
[
|
|
AC_REQUIRE([KDE_CHECK_LIBDL])
|
|
AC_MSG_CHECKING(for MICO)
|
|
AC_ARG_WITH(micodir,
|
|
[ --with-micodir=micodir where mico is installed ],
|
|
kde_micodir=$withval,
|
|
kde_micodir=/usr/local
|
|
)
|
|
AC_MSG_RESULT($kde_micodir)
|
|
if test ! -r $kde_micodir/include/CORBA.h; then
|
|
AC_MSG_ERROR([No CORBA.h found, specify another micodir])
|
|
fi
|
|
|
|
MICO_INCLUDES=-I$kde_micodir/include
|
|
AC_SUBST(MICO_INCLUDES)
|
|
MICO_LDFLAGS=-L$kde_micodir/lib
|
|
AC_SUBST(MICO_LDFLAGS)
|
|
|
|
AC_MSG_CHECKING([for MICO version])
|
|
AC_CACHE_VAL(kde_cv_mico_version,
|
|
[
|
|
AC_LANG_C
|
|
cat >conftest.$ac_ext <<EOF
|
|
#include <stdio.h>
|
|
#include <mico/version.h>
|
|
int main() {
|
|
|
|
printf("MICO_VERSION=%s\n",MICO_VERSION);
|
|
return (0);
|
|
}
|
|
EOF
|
|
ac_compile='${CC-gcc} $CFLAGS $MICO_INCLUDES conftest.$ac_ext -o conftest'
|
|
if AC_TRY_EVAL(ac_compile); then
|
|
if eval `./conftest 2>&5`; then
|
|
kde_cv_mico_version=$MICO_VERSION
|
|
else
|
|
AC_MSG_ERROR([your system is not able to execute a small application to
|
|
find MICO version! Check $kde_micodir/include/mico/version.h])
|
|
fi
|
|
else
|
|
AC_MSG_ERROR([your system is not able to compile a small application to
|
|
find MICO version! Check $kde_micodir/include/mico/version.h])
|
|
fi
|
|
])
|
|
|
|
dnl installed MICO version
|
|
mico_v_maj=`echo $kde_cv_mico_version | sed -e 's/^\(.*\)\..*\..*$/\1/'`
|
|
mico_v_mid=`echo $kde_cv_mico_version | sed -e 's/^.*\.\(.*\)\..*$/\1/'`
|
|
mico_v_min=`echo $kde_cv_mico_version | sed -e 's/^.*\..*\.\(.*\)$/\1/'`
|
|
|
|
dnl required MICO version
|
|
req_v_maj=`echo $1 | sed -e 's/^\(.*\)\..*\..*$/\1/'`
|
|
req_v_mid=`echo $1 | sed -e 's/^.*\.\(.*\)\..*$/\1/'`
|
|
req_v_min=`echo $1 | sed -e 's/^.*\..*\.\(.*\)$/\1/'`
|
|
|
|
if test "$mico_v_maj" -lt "$req_v_maj" || \
|
|
( test "$mico_v_maj" -eq "$req_v_maj" && \
|
|
test "$mico_v_mid" -lt "$req_v_mid" ) || \
|
|
( test "$mico_v_mid" -eq "$req_v_mid" && \
|
|
test "$mico_v_min" -lt "$req_v_min" )
|
|
|
|
then
|
|
AC_MSG_ERROR([found MICO version $kde_cv_mico_version but version $1 \
|
|
at least is required. You should upgrade MICO.])
|
|
else
|
|
AC_MSG_RESULT([$kde_cv_mico_version (minimum version $1, ok)])
|
|
fi
|
|
|
|
LIBMICO="-lmico$kde_cv_mico_version $LIBDL"
|
|
AC_SUBST(LIBMICO)
|
|
IDL=$kde_micodir/bin/idl
|
|
AC_SUBST(IDL)
|
|
])
|
|
|
|
|
|
AC_DEFUN(KDE_CHECK_MINI_STL,
|
|
[
|
|
AC_REQUIRE([KDE_CHECK_MICO])
|
|
|
|
AC_MSG_CHECKING(if we use mico's mini-STL)
|
|
AC_CACHE_VAL(kde_cv_have_mini_stl,
|
|
[
|
|
AC_LANG_CPLUSPLUS
|
|
kde_save_cxxflags="$CXXFLAGS"
|
|
CXXFLAGS="$CXXFLAGS $MICO_INCLUDES"
|
|
AC_TRY_COMPILE(
|
|
[
|
|
#include <mico/config.h>
|
|
],
|
|
[
|
|
#ifdef HAVE_MINI_STL
|
|
#error "nothing"
|
|
#endif
|
|
],
|
|
kde_cv_have_mini_stl=no,
|
|
kde_cv_have_mini_stl=yes)
|
|
CXXFLAGS="$kde_save_cxxflags"
|
|
])
|
|
|
|
|
|
AC_MSG_RESULT($kde_cv_have_mini_stl)
|
|
if test "$kde_cv_have_mini_stl" = "yes"; then
|
|
AC_DEFINE_UNQUOTED(HAVE_MINI_STL)
|
|
fi
|
|
])
|
|
|
|
])
|
|
|
|
|
|
AC_DEFUN(KDE_CHECK_LIBPTHREAD,
|
|
[
|
|
AC_CHECK_LIB(pthread, pthread_create, [LIBPTHREAD="-lpthread"], LIBPTHREAD= )
|
|
AC_SUBST(LIBPTHREAD)
|
|
])
|
|
|
|
AC_DEFUN(KDE_TRY_LINK_PYTHON,
|
|
[
|
|
AC_CACHE_VAL(kde_cv_try_link_python_$1,
|
|
[
|
|
kde_save_cxxflags="$CXXFLAGS"
|
|
CXXFLAGS="$CXXFLAGS $PYTHONINC"
|
|
kde_save_libs="$LIBS"
|
|
LIBS="$LIBS $LIBPYTHON $2 $LIBDL $LIBSOCKET"
|
|
kde_save_ldflags="$LDFLAGS"
|
|
LDFLAGS="$LDFLAGS $PYTHONLIB"
|
|
|
|
AC_TRY_LINK(
|
|
[
|
|
#include <Python.h>
|
|
],[
|
|
PySys_SetArgv(1, 0);
|
|
],
|
|
[kde_cv_try_link_python_$1=yes],
|
|
[kde_cv_try_link_python_$1=no]
|
|
)
|
|
CXXFLAGS="$kde_save_cxxflags"
|
|
LIBS="$kde_save_libs"
|
|
LDFLAGS="$kde_save_ldflags"
|
|
])
|
|
|
|
if test "$kde_cv_try_link_python_$1" = "yes"; then
|
|
$3
|
|
else
|
|
$4
|
|
fi
|
|
|
|
])
|
|
|
|
AC_DEFUN(KDE_CHECK_PYTHON,
|
|
[
|
|
AC_REQUIRE([KDE_CHECK_LIBDL])
|
|
AC_REQUIRE([KDE_CHECK_LIBPTHREAD])
|
|
if test -z "$1"; then
|
|
version="1.5"
|
|
else
|
|
version="$1"
|
|
fi
|
|
|
|
AC_MSG_CHECKING([for Python$version])
|
|
|
|
AC_ARG_WITH(pythondir,
|
|
[ --with-pythondir=pythondir use python installed in pythondir ],
|
|
[
|
|
ac_python_dir=$withval
|
|
], ac_python_dir=/usr/local
|
|
)
|
|
|
|
python_incdirs="$ac_python_dir/include/python$version /usr/include/python$version /usr/local/include/python$version /usr/local/include"
|
|
AC_FIND_FILE(Python.h, $python_incdirs, python_incdir)
|
|
if test ! -r $python_incdir/Python.h; then
|
|
AC_MSG_ERROR(Python.h not found.)
|
|
fi
|
|
|
|
PYTHONINC=-I$python_incdir
|
|
|
|
python_libdirs="$ac_python_dir/lib/python$version/config /usr/lib/python$version/config /usr/local/python$version/config"
|
|
AC_FIND_FILE(libpython$version.a, $python_libdirs, python_libdir)
|
|
if test ! -r $python_libdir/libpython$version.a; then
|
|
AC_MSG_ERROR(libpython$version.a not found.)
|
|
fi
|
|
|
|
PYTHONLIB=-L$python_libdir
|
|
LIBPYTHON=-lpython$version
|
|
|
|
AC_MSG_RESULT(header $python_incdir library $python_libdir)
|
|
|
|
dnl Note: this test is very weak
|
|
AC_MSG_CHECKING(if an Python application links)
|
|
KDE_TRY_LINK_PYTHON(normal, "", AC_MSG_RESULT(yes),
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_MSG_CHECKING(if Python depends on -lpthread)
|
|
KDE_TRY_LINK_PYTHON(pthread, "$LIBPTHREAD",
|
|
[
|
|
AC_MSG_RESULT(yes)
|
|
LIBPYTHON="$LIBPYTHON $LIBPTHREAD $LIBDL"
|
|
],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_MSG_CHECKING(if Python depeds on -ltcl)
|
|
KDE_TRY_LINK_PYTHON(tcl, "-ltcl",
|
|
[
|
|
AC_MSG_RESULT(yes)
|
|
LIBPYTHON="$LIBPYTHON -ltcl"
|
|
],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_MSG_WARN([it seems, Python depends on another library.
|
|
Pleae use \"make LIBPTYHON='-lpython$version -lotherlib'\" to fix this
|
|
and contact the authors to let them know about this problem])
|
|
])
|
|
])
|
|
])
|
|
|
|
AC_SUBST(PYTHONINC)
|
|
AC_SUBST(PYTHONLIB)
|
|
AC_SUBST(LIBPYTHON)
|
|
|
|
])
|
|
|
|
|
|
AC_DEFUN(KDE_CHECK_STL_SGI,
|
|
[
|
|
AC_MSG_CHECKING([if STL implementation is SGI like])
|
|
AC_CACHE_VAL(kde_cv_stl_type_sgi,
|
|
[
|
|
AC_TRY_COMPILE([
|
|
#include <string>
|
|
],[
|
|
string astring="Hallo Welt.";
|
|
astring.erase(0, 6); // now astring is "Welt"
|
|
return 0;
|
|
], kde_cv_stl_type_sgi=yes,
|
|
kde_cv_stl_type_sgi=no)
|
|
])
|
|
|
|
AC_MSG_RESULT($kde_cv_stl_type_sgi)
|
|
|
|
if test "$kde_cv_stl_type_sgi" = "yes"; then
|
|
AC_DEFINE_UNQUOTED(HAVE_SGI_STL)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(KDE_CHECK_STL_HP,
|
|
[
|
|
AC_MSG_CHECKING([if STL implementation is HP like])
|
|
AC_CACHE_VAL(kde_cv_stl_type_hp,
|
|
[
|
|
AC_TRY_COMPILE([
|
|
#include <string>
|
|
],[
|
|
string astring="Hello World";
|
|
astring.remove(0, 6); // now astring is "World"
|
|
return 0;
|
|
], kde_cv_stl_type_hp=yes,
|
|
kde_cv_stl_type_hp=no)
|
|
])
|
|
AC_MSG_RESULT($kde_cv_stl_type_hp)
|
|
|
|
if test "$kde_cv_stl_type_hp" = "yes"; then
|
|
AC_DEFINE_UNQUOTED(HAVE_HP_STL)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(KDE_CHECK_STL,
|
|
[
|
|
KDE_CHECK_STL_SGI
|
|
|
|
if test "$kde_cv_stl_type_sgi" = "no"; then
|
|
KDE_CHECK_STL_HP
|
|
|
|
if test "$kde_cv_stl_type_hp" = "no"; then
|
|
AC_MSG_ERROR("no known STL type found")
|
|
fi
|
|
fi
|
|
|
|
])
|
|
|
|
AC_DEFUN(AC_FIND_QIMGIO,
|
|
[AC_REQUIRE([AC_FIND_JPEG])
|
|
AC_MSG_CHECKING([for qimgio])
|
|
AC_CACHE_VAL(ac_cv_lib_qimgio,
|
|
[ac_save_LIBS="$LIBS"
|
|
LIBS="$all_libraries -lqimgio -lpng -lz -lqt $LIBJPEG -lX11 $LIBSOCKET"
|
|
AC_TRY_LINK(dnl
|
|
[
|
|
void qInitImageIO ();
|
|
],
|
|
[qInitImageIO();],
|
|
eval "ac_cv_lib_qimgio=yes",
|
|
eval "ac_cv_lib_qimgio=no")
|
|
LIBS="$ac_save_LIBS"
|
|
])dnl
|
|
if eval "test \"`echo $ac_cv_lib_qimgio`\" = yes"; then
|
|
LIBQIMGIO="-lqimgio -lpng -lz $LIBJPEG"
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE_UNQUOTED(HAVE_QIMGIO)
|
|
AC_SUBST(LIBQIMGIO)
|
|
else
|
|
AC_MSG_RESULT(not found)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(KDE_CHECK_ANSI,
|
|
[
|
|
AC_MSG_CHECKING([for strdup])
|
|
|
|
AC_CACHE_VAL(kde_cv_stl_type_sgi,
|
|
[
|
|
AC_LANG_CPLUSPLUS
|
|
save_CXXFLAGS="$CXXFLAGS"
|
|
if test "$GCC" = "yes"; then
|
|
CXXFLAGS="$CXXFLAGS -pedantic-errors"
|
|
fi
|
|
|
|
AC_TRY_COMPILE([
|
|
#include <string.h>
|
|
],[
|
|
char buffer[] = "Hallo";
|
|
strdup(buffer)
|
|
], kde_cv_has_strdup=yes,
|
|
kde_cv_has_strdup=no)
|
|
CXXFLAGS="$save_CXXFLAGS"
|
|
])
|
|
AC_MSG_RESULT($kde_cv_has_strdup)
|
|
|
|
if test "$kde_cv_has_strdup" = "yes"; then
|
|
AC_DEFINE_UNQUOTED(HAVE_STRDUP)
|
|
fi
|
|
|
|
])
|
|
|
|
AC_DEFUN(KDE_CHECK_INSURE,
|
|
[
|
|
AC_ARG_ENABLE(insure, [ --enable-insure use insure++ for debugging [default=no]],
|
|
[
|
|
if test $enableval = "no"; dnl
|
|
then ac_use_insure="no"
|
|
else ac_use_insure="yes"
|
|
fi
|
|
], [ac_use_insure="no"])
|
|
|
|
AC_MSG_CHECKING(if we will use Insure++ to debug)
|
|
AC_MSG_RESULT($ac_use_insure)
|
|
if test "$ac_use_insure" = "yes"; dnl
|
|
then CC="insure"; CXX="insure"; dnl CFLAGS="$CLAGS -fno-rtti -fno-exceptions "????
|
|
fi
|
|
])
|
|
|
|
dnl this is for kdm:
|
|
|
|
AC_DEFUN(AC_CHECK_KDM,
|
|
[
|
|
AC_CHECK_FUNCS(getsecretkey)
|
|
dnl checks for X server
|
|
|
|
AC_PATH_PROG(X_SERVER, X)
|
|
if test ! -z "$X_SERVER"; then
|
|
X_SERVER=`echo $X_SERVER | sed -e 's+/X$++'`
|
|
AC_DEFINE_UNQUOTED(XBINDIR,$X_SERVER)
|
|
XBINDIR=$X_SERVER
|
|
AC_SUBST(XBINDIR)
|
|
fi
|
|
|
|
dnl This one tries to find XDMDIR for config files
|
|
AC_ARG_WITH(xdmdir,
|
|
[ --with-xdmdir If the xdm config dir can't be found automaticly],
|
|
[ ac_xdmdir=$withval],
|
|
[ ac_xdmdir="no"])
|
|
|
|
AC_MSG_CHECKING([for xdm configuration dir])
|
|
if test "$ac_xdmdir" = "no"; then
|
|
rm -fr conftestdir
|
|
if mkdir conftestdir; then
|
|
cd conftestdir
|
|
cat > Imakefile <<'EOF'
|
|
acfindxdm:
|
|
@echo 'ac_xdmdir="$(XDMDIR)";'
|
|
EOF
|
|
if (xmkmf) > /dev/null 2> /dev/null && test -f Makefile; then
|
|
eval `${MAKE-make} acfindxdm 2>/dev/null 2>/dev/null | grep -v make`
|
|
fi
|
|
cd ..
|
|
rm -fr conftestdir
|
|
dnl Check if Imake was right
|
|
if test -f $ac_xdmdir/xdm-config; then
|
|
AC_MSG_RESULT($ac_xdmdir)
|
|
else
|
|
dnl Here we must do something else
|
|
dnl Maybe look for xdm-config in standard places, and
|
|
dnl if that fails use a fresh copy in $KDEDIR/config/kdm/
|
|
AC_FIND_FILE(xdm-config,/etc/X11/xdm /var/X11/xdm /usr/openwin/xdm /usr/X11R6/lib/X11/xdm,ac_xdmdir)
|
|
if test -f $ac_xdmdir/xdm-config; then
|
|
AC_MSG_RESULT($ac_xdmdir)
|
|
else
|
|
if test "${prefix}" = NONE; then
|
|
ac_xdmdir=$ac_default_prefix/config/kdm
|
|
else
|
|
ac_xdmdir=$prefix/config/kdm
|
|
fi
|
|
AC_MSG_RESULT([xdm config dir not found, installing defaults in $ac_xdmdir])
|
|
xdmconfigsubdir=xdmconfig
|
|
AC_SUBST(xdmconfigsubdir)
|
|
fi
|
|
fi
|
|
fi
|
|
else
|
|
if test -f $ac_xdmdir/xdm-config; then
|
|
AC_MSG_RESULT($ac_xdmdir)
|
|
else
|
|
|
|
AC_MSG_RESULT([xdm config dir not found, installing defaults in $ac_xdmdir])
|
|
xdmconfigsubdir=xdmconfig
|
|
AC_SUBST(xdmconfigsubdir)
|
|
fi
|
|
fi
|
|
AC_DEFINE_UNQUOTED(XDMDIR,"$ac_xdmdir")
|
|
AC_SUBST(ac_xdmdir)
|
|
|
|
AC_PATH_PAM
|
|
if test "x$no_pam" = "xyes"; then
|
|
pam_support="no"
|
|
else
|
|
pam_support="yes"
|
|
shadow_support="no" # if pam is installed, use it. We can't savely
|
|
# test, if it works *sigh*
|
|
fi
|
|
|
|
AC_ARG_WITH(shadow,
|
|
[ --with-shadow If you want shadow password support ],
|
|
[ if test "$withval" = "yes"; then
|
|
shadow_support="yes"
|
|
else
|
|
shadow_support="no"
|
|
fi
|
|
if test "$pam_support" = "yes" && test "$shadow_support=yes"; then
|
|
AC_MSG_WARN("You can not define both pam AND shadow")
|
|
fi
|
|
],
|
|
[ if test -z "$shadow_support"; then shadow_support="no"; fi ] )
|
|
|
|
if test "$pam_support" = "yes"; then
|
|
AC_CHECK_LIB(pam, main, [PASSWDLIB="-lpam -ldl"
|
|
AC_DEFINE_UNQUOTED(HAVE_PAM_LIB)],
|
|
[],-ldl)
|
|
fi
|
|
|
|
if test -z "$PASSWDLIB" && test "$shadow_support" = "yes"; then
|
|
AC_CHECK_LIB(shadow, main,
|
|
[ PASSWDLIB="-lshadow"
|
|
AC_DEFINE_UNQUOTED(HAVE_SHADOW_LIB)
|
|
])
|
|
fi
|
|
AC_SUBST(PASSWDLIB)
|
|
AC_CHECK_LIB(util, main, [LIBUTIL="-lutil"]) dnl for FreeBSD
|
|
AC_SUBST(LIBUTIL)
|
|
AC_CHECK_LIB(s, main, [LIB_LIBS="-ls"]) dnl for AIX
|
|
AC_SUBST(LIB_LIBS)
|
|
AC_CHECK_LIB(Xdmcp, main, [LIBXDMCP="-lXdmcp"], , $X_LDFLAGS -lX11) dnl for Unixware
|
|
AC_SUBST(LIBXDMCP)
|
|
|
|
if test -n "$LIBXDMCP"; then
|
|
ac_cpp_safe=$ac_cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS $X_INCLUDES'
|
|
AC_CHECK_HEADERS(X11/Xdmcp.h)
|
|
ac_cpp=$ac_cpp_safe
|
|
fi
|
|
|
|
])
|
|
# Configure paths for GTK--
|
|
# Erik Andersen 30 May 1998
|
|
# Modified by Tero Pulkkinen (added the compiler checks... I hope they work..)
|
|
# Modified by Thomas Langen 16 Jan 2000 (corrected CXXFLAGS)
|
|
|
|
dnl Test for GTKMM, and define GTKMM_CFLAGS and GTKMM_LIBS
|
|
dnl to be used as follows:
|
|
dnl AM_PATH_GTKMM([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
|
|
dnl
|
|
AC_DEFUN(AM_PATH_GTKMM,
|
|
[dnl
|
|
dnl Get the cflags and libraries from the gtkmm-config script
|
|
dnl
|
|
AC_ARG_WITH(gtkmm-prefix,[ --with-gtkmm-prefix=PREFIX
|
|
Prefix where GTK-- is installed (optional)],
|
|
gtkmm_config_prefix="$withval", gtkmm_config_prefix="")
|
|
AC_ARG_WITH(gtkmm-exec-prefix,[ --with-gtkmm-exec-prefix=PREFIX
|
|
Exec prefix where GTK-- is installed (optional)],
|
|
gtkmm_config_exec_prefix="$withval", gtkmm_config_exec_prefix="")
|
|
AC_ARG_ENABLE(gtkmmtest, [ --disable-gtkmmtest Do not try to compile and run a test GTK-- program],
|
|
, enable_gtkmmtest=yes)
|
|
|
|
if test x$gtkmm_config_exec_prefix != x ; then
|
|
gtkmm_config_args="$gtkmm_config_args --exec-prefix=$gtkmm_config_exec_prefix"
|
|
if test x${GTKMM_CONFIG+set} != xset ; then
|
|
GTKMM_CONFIG=$gtkmm_config_exec_prefix/bin/gtkmm-config
|
|
fi
|
|
fi
|
|
if test x$gtkmm_config_prefix != x ; then
|
|
gtkmm_config_args="$gtkmm_config_args --prefix=$gtkmm_config_prefix"
|
|
if test x${GTKMM_CONFIG+set} != xset ; then
|
|
GTKMM_CONFIG=$gtkmm_config_prefix/bin/gtkmm-config
|
|
fi
|
|
fi
|
|
|
|
AC_PATH_PROG(GTKMM_CONFIG, gtkmm-config, no)
|
|
min_gtkmm_version=ifelse([$1], ,0.10.0,$1)
|
|
|
|
AC_MSG_CHECKING(for GTK-- - version >= $min_gtkmm_version)
|
|
no_gtkmm=""
|
|
if test "$GTKMM_CONFIG" = "no" ; then
|
|
no_gtkmm=yes
|
|
else
|
|
AC_LANG_SAVE
|
|
AC_LANG_CPLUSPLUS
|
|
|
|
GTKMM_CFLAGS=`$GTKMM_CONFIG $gtkmm_config_args --cflags`
|
|
GTKMM_LIBS=`$GTKMM_CONFIG $gtkmm_config_args --libs`
|
|
gtkmm_config_major_version=`$GTKMM_CONFIG $gtkmm_config_args --version | \
|
|
sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'`
|
|
gtkmm_config_minor_version=`$GTKMM_CONFIG $gtkmm_config_args --version | \
|
|
sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'`
|
|
gtkmm_config_micro_version=`$GTKMM_CONFIG $gtkmm_config_args --version | \
|
|
sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`
|
|
if test "x$enable_gtkmmtest" = "xyes" ; then
|
|
ac_save_CXXFLAGS="$CXXFLAGS"
|
|
ac_save_LIBS="$LIBS"
|
|
CXXFLAGS="$CXXFLAGS $GTKMM_CFLAGS"
|
|
LIBS="$LIBS $GTKMM_LIBS"
|
|
dnl
|
|
dnl Now check if the installed GTK-- is sufficiently new. (Also sanity
|
|
dnl checks the results of gtkmm-config to some extent
|
|
dnl
|
|
rm -f conf.gtkmmtest
|
|
AC_TRY_RUN([
|
|
#include <gtk--.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
int
|
|
main ()
|
|
{
|
|
int major, minor, micro;
|
|
char *tmp_version;
|
|
|
|
system ("touch conf.gtkmmtest");
|
|
|
|
/* HP/UX 0 (%@#!) writes to sscanf strings */
|
|
tmp_version = g_strdup("$min_gtkmm_version");
|
|
if (sscanf(tmp_version, "%d.%d.%d", &major, &minor, µ) != 3) {
|
|
printf("%s, bad version string\n", "$min_gtkmm_version");
|
|
exit(1);
|
|
}
|
|
|
|
if ((gtkmm_major_version != $gtkmm_config_major_version) ||
|
|
(gtkmm_minor_version != $gtkmm_config_minor_version) ||
|
|
(gtkmm_micro_version != $gtkmm_config_micro_version))
|
|
{
|
|
printf("\n*** 'gtkmm-config --version' returned %d.%d.%d, but GTK-- (%d.%d.%d)\n",
|
|
$gtkmm_config_major_version, $gtkmm_config_minor_version, $gtkmm_config_micro_version,
|
|
gtkmm_major_version, gtkmm_minor_version, gtkmm_micro_version);
|
|
printf ("*** was found! If gtkmm-config was correct, then it is best\n");
|
|
printf ("*** to remove the old version of GTK--. You may also be able to fix the error\n");
|
|
printf("*** by modifying your LD_LIBRARY_PATH enviroment variable, or by editing\n");
|
|
printf("*** /etc/ld.so.conf. Make sure you have run ldconfig if that is\n");
|
|
printf("*** required on your system.\n");
|
|
printf("*** If gtkmm-config was wrong, set the environment variable GTKMM_CONFIG\n");
|
|
printf("*** to point to the correct copy of gtkmm-config, and remove the file config.cache\n");
|
|
printf("*** before re-running configure\n");
|
|
}
|
|
/* GTK-- does not have the GTKMM_*_VERSION constants */
|
|
/*
|
|
else if ((gtkmm_major_version != GTKMM_MAJOR_VERSION) ||
|
|
(gtkmm_minor_version != GTKMM_MINOR_VERSION) ||
|
|
(gtkmm_micro_version != GTKMM_MICRO_VERSION))
|
|
{
|
|
printf("*** GTK-- header files (version %d.%d.%d) do not match\n",
|
|
GTKMM_MAJOR_VERSION, GTKMM_MINOR_VERSION, GTKMM_MICRO_VERSION);
|
|
printf("*** library (version %d.%d.%d)\n",
|
|
gtkmm_major_version, gtkmm_minor_version, gtkmm_micro_version);
|
|
}
|
|
*/
|
|
else
|
|
{
|
|
if ((gtkmm_major_version > major) ||
|
|
((gtkmm_major_version == major) && (gtkmm_minor_version > minor)) ||
|
|
((gtkmm_major_version == major) && (gtkmm_minor_version == minor) && (gtkmm_micro_version >= micro)))
|
|
{
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
printf("\n*** An old version of GTK-- (%d.%d.%d) was found.\n",
|
|
gtkmm_major_version, gtkmm_minor_version, gtkmm_micro_version);
|
|
printf("*** You need a version of GTK-- newer than %d.%d.%d. The latest version of\n",
|
|
major, minor, micro);
|
|
printf("*** GTK-- is always available from ftp://ftp.gtk.org.\n");
|
|
printf("***\n");
|
|
printf("*** If you have already installed a sufficiently new version, this error\n");
|
|
printf("*** probably means that the wrong copy of the gtkmm-config shell script is\n");
|
|
printf("*** being found. The easiest way to fix this is to remove the old version\n");
|
|
printf("*** of GTK--, but you can also set the GTKMM_CONFIG environment to point to the\n");
|
|
printf("*** correct copy of gtkmm-config. (In this case, you will have to\n");
|
|
printf("*** modify your LD_LIBRARY_PATH enviroment variable, or edit /etc/ld.so.conf\n");
|
|
printf("*** so that the correct libraries are found at run-time))\n");
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
],, no_gtkmm=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"])
|
|
CXXFLAGS="$ac_save_CXXFLAGS"
|
|
LIBS="$ac_save_LIBS"
|
|
fi
|
|
fi
|
|
if test "x$no_gtkmm" = x ; then
|
|
AC_MSG_RESULT(yes)
|
|
ifelse([$2], , :, [$2])
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
if test "$GTKMM_CONFIG" = "no" ; then
|
|
echo "*** The gtkmm-config script installed by GTK-- could not be found"
|
|
echo "*** If GTK-- was installed in PREFIX, make sure PREFIX/bin is in"
|
|
echo "*** your path, or set the GTKMM_CONFIG environment variable to the"
|
|
echo "*** full path to gtkmm-config."
|
|
echo "*** The gtkmm-config script was not available in GTK-- versions"
|
|
echo "*** prior to 0.9.12. Perhaps you need to update your installed"
|
|
echo "*** version to 0.9.12 or later"
|
|
else
|
|
if test -f conf.gtkmmtest ; then
|
|
:
|
|
else
|
|
echo "*** Could not run GTK-- test program, checking why..."
|
|
CXXFLAGS="$CXXFLAGS $GTKMM_CFLAGS"
|
|
LIBS="$LIBS $GTKMM_LIBS"
|
|
AC_TRY_LINK([
|
|
#include <gtk--.h>
|
|
#include <stdio.h>
|
|
], [ return ((gtkmm_major_version) || (gtkmm_minor_version) || (gtkmm_micro_version)); ],
|
|
[ echo "*** The test program compiled, but did not run. This usually means"
|
|
echo "*** that the run-time linker is not finding GTK-- or finding the wrong"
|
|
echo "*** version of GTK--. If it is not finding GTK--, you'll need to set your"
|
|
echo "*** LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf to point"
|
|
echo "*** to the installed location Also, make sure you have run ldconfig if that"
|
|
echo "*** is required on your system"
|
|
echo "***"
|
|
echo "*** If you have an old version installed, it is best to remove it, although"
|
|
echo "*** you may also be able to get things to work by modifying LD_LIBRARY_PATH" ],
|
|
[ echo "*** The test program failed to compile or link. See the file config.log for the"
|
|
echo "*** exact error that occured. This usually means GTK-- was incorrectly installed"
|
|
echo "*** or that you have moved GTK-- since it was installed. In the latter case, you"
|
|
echo "*** may want to edit the gtkmm-config script: $GTKMM_CONFIG" ])
|
|
CXXFLAGS="$ac_save_CXXFLAGS"
|
|
LIBS="$ac_save_LIBS"
|
|
fi
|
|
fi
|
|
GTKMM_CFLAGS=""
|
|
GTKMM_LIBS=""
|
|
ifelse([$3], , :, [$3])
|
|
AC_LANG_RESTORE
|
|
fi
|
|
AC_SUBST(GTKMM_CFLAGS)
|
|
AC_SUBST(GTKMM_LIBS)
|
|
rm -f conf.gtkmmtest
|
|
])
|
|
|
|
# Configure paths for GNOME--
|
|
# Modified from GTK--.m4
|
|
|
|
dnl Test for GNOMEMM, and define GNOMEMM_INCLUDEDIR, GNOMEMM_LIBDIR, GNOMEMM_LIBS
|
|
dnl to be used as follows:
|
|
dnl AM_PATH_GNOMEMM([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
|
|
dnl
|
|
AC_DEFUN(AM_PATH_GNOMEMM,
|
|
[
|
|
dnl
|
|
dnl Get the cflags and libraries from the gtkmm-config script
|
|
dnl
|
|
AC_ARG_WITH(gnomemm-config-path,[ --with-gnomemm-config-path=PREFIX
|
|
Path to GNOME-- configuration file gnomemmConf.sh (optional)],
|
|
gnomemm_config_prefix="$withval", gnome_config_prefix="")
|
|
|
|
AC_MSG_CHECKING(for GNOME-- gnomemmConf.sh)
|
|
|
|
if test x$gnomemm_config_prefix != x; then
|
|
if test -r $gnomemm_config_prefix; then
|
|
source $gnomemm_config_prefix
|
|
else
|
|
no_gnomemm=yes
|
|
fi
|
|
else
|
|
if test -r /usr/lib/gnomemmConf.sh ; then
|
|
source /usr/lib/gnomemmConf.sh
|
|
elif test -r /opt/gnome/lib/gnomemmConf.sh ; then
|
|
source /opt/gnome/lib/gnomemmConf.sh
|
|
elif test -r /usr/local/lib/gnomemmConf.sh ; then
|
|
source /usr/local/lib/gnomemmConf.sh
|
|
else
|
|
no_gnomemm=yes
|
|
fi
|
|
fi
|
|
|
|
if test "x$no_gnomemm" = x ; then
|
|
AC_MSG_RESULT(yes)
|
|
ifelse([$2], , :, [$2])
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_MSG_ERROR(Cannot find GNOME-- configuration file gnomemmConf.sh)
|
|
fi
|
|
|
|
AC_SUBST(GNOMEMM_INCLUDEDIR)
|
|
AC_SUBST(GNOMEMM_LIBDIR)
|
|
AC_SUBST(GNOMEMM_LIBS)
|
|
])
|
|
|