4950 lines
145 KiB
Plaintext
4950 lines
145 KiB
Plaintext
|
dnl $Id: aclocal.m4,v 1.98 2016/11/20 15:18:17 tom Exp $
|
||
|
|
dnl macros used for CDK configure script
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl Copyright 1999-2015,2016 Thomas E. Dickey
|
||
|
|
dnl
|
||
|
|
dnl Permission is hereby granted, free of charge, to any person obtaining a
|
||
|
|
dnl copy of this software and associated documentation files (the "Software"),
|
||
|
|
dnl to deal in the Software without restriction, including without limitation
|
||
|
|
dnl the rights to use, copy, modify, merge, publish, distribute, distribute
|
||
|
|
dnl with modifications, sublicense, and/or sell copies of the Software, and to
|
||
|
|
dnl permit persons to whom the Software is furnished to do so, subject to the
|
||
|
|
dnl following conditions:
|
||
|
|
dnl
|
||
|
|
dnl The above copyright notice and this permission notice shall be included in
|
||
|
|
dnl all copies or substantial portions of the Software.
|
||
|
|
dnl
|
||
|
|
dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
|
|
dnl IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
|
|
dnl FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||
|
|
dnl THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
|
|
dnl LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||
|
|
dnl FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||
|
|
dnl DEALINGS IN THE SOFTWARE.
|
||
|
|
dnl
|
||
|
|
dnl Except as contained in this notice, the name(s) of the above copyright
|
||
|
|
dnl holders shall not be used in advertising or otherwise to promote the sale,
|
||
|
|
dnl use or other dealings in this Software without prior written
|
||
|
|
dnl authorization.
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49
|
||
|
|
dnl ------------------
|
||
|
|
dnl Conditionally generate script according to whether we're using a given autoconf.
|
||
|
|
dnl
|
||
|
|
dnl $1 = version to compare against
|
||
|
|
dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
|
||
|
|
dnl $3 = code to use if AC_ACVERSION is older than $1.
|
||
|
|
define([CF_ACVERSION_CHECK],
|
||
|
|
[
|
||
|
|
ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
|
||
|
|
ifdef([m4_version_compare],
|
||
|
|
[m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
|
||
|
|
[CF_ACVERSION_COMPARE(
|
||
|
|
AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
|
||
|
|
AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
|
||
|
|
dnl --------------------
|
||
|
|
dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
|
||
|
|
dnl MAJOR2, MINOR2, TERNARY2,
|
||
|
|
dnl PRINTABLE2, not FOUND, FOUND)
|
||
|
|
define([CF_ACVERSION_COMPARE],
|
||
|
|
[ifelse(builtin([eval], [$2 < $5]), 1,
|
||
|
|
[ifelse([$8], , ,[$8])],
|
||
|
|
[ifelse([$9], , ,[$9])])])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_ADD_CFLAGS version: 12 updated: 2015/04/12 15:39:00
|
||
|
|
dnl -------------
|
||
|
|
dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
|
||
|
|
dnl The second parameter if given makes this macro verbose.
|
||
|
|
dnl
|
||
|
|
dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
|
||
|
|
dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
|
||
|
|
dnl confused by the quotes (which require backslashes to keep them usable).
|
||
|
|
AC_DEFUN([CF_ADD_CFLAGS],
|
||
|
|
[
|
||
|
|
cf_fix_cppflags=no
|
||
|
|
cf_new_cflags=
|
||
|
|
cf_new_cppflags=
|
||
|
|
cf_new_extra_cppflags=
|
||
|
|
|
||
|
|
for cf_add_cflags in $1
|
||
|
|
do
|
||
|
|
case $cf_fix_cppflags in
|
||
|
|
(no)
|
||
|
|
case $cf_add_cflags in
|
||
|
|
(-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
|
||
|
|
case $cf_add_cflags in
|
||
|
|
(-D*)
|
||
|
|
cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
|
||
|
|
|
||
|
|
test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
|
||
|
|
&& test -z "${cf_tst_cflags}" \
|
||
|
|
&& cf_fix_cppflags=yes
|
||
|
|
|
||
|
|
if test $cf_fix_cppflags = yes ; then
|
||
|
|
cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
|
||
|
|
continue
|
||
|
|
elif test "${cf_tst_cflags}" = "\"'" ; then
|
||
|
|
cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
|
||
|
|
continue
|
||
|
|
fi
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
case "$CPPFLAGS" in
|
||
|
|
(*$cf_add_cflags)
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
case $cf_add_cflags in
|
||
|
|
(-D*)
|
||
|
|
cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
|
||
|
|
CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
cf_new_cflags="$cf_new_cflags $cf_add_cflags"
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
;;
|
||
|
|
(yes)
|
||
|
|
cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
|
||
|
|
|
||
|
|
cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
|
||
|
|
|
||
|
|
test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
|
||
|
|
&& test -z "${cf_tst_cflags}" \
|
||
|
|
&& cf_fix_cppflags=no
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
done
|
||
|
|
|
||
|
|
if test -n "$cf_new_cflags" ; then
|
||
|
|
ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
|
||
|
|
CFLAGS="$CFLAGS $cf_new_cflags"
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test -n "$cf_new_cppflags" ; then
|
||
|
|
ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
|
||
|
|
CPPFLAGS="$CPPFLAGS $cf_new_cppflags"
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test -n "$cf_new_extra_cppflags" ; then
|
||
|
|
ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
|
||
|
|
EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
|
||
|
|
fi
|
||
|
|
|
||
|
|
AC_SUBST(EXTRA_CPPFLAGS)
|
||
|
|
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_ADD_INCDIR version: 14 updated: 2015/05/25 20:53:04
|
||
|
|
dnl -------------
|
||
|
|
dnl Add an include-directory to $CPPFLAGS. Don't add /usr/include, since it's
|
||
|
|
dnl redundant. We don't normally need to add -I/usr/local/include for gcc,
|
||
|
|
dnl but old versions (and some misinstalled ones) need that. To make things
|
||
|
|
dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
|
||
|
|
dnl the include-path).
|
||
|
|
AC_DEFUN([CF_ADD_INCDIR],
|
||
|
|
[
|
||
|
|
if test -n "$1" ; then
|
||
|
|
for cf_add_incdir in $1
|
||
|
|
do
|
||
|
|
while test $cf_add_incdir != /usr/include
|
||
|
|
do
|
||
|
|
if test -d $cf_add_incdir
|
||
|
|
then
|
||
|
|
cf_have_incdir=no
|
||
|
|
if test -n "$CFLAGS$CPPFLAGS" ; then
|
||
|
|
# a loop is needed to ensure we can add subdirs of existing dirs
|
||
|
|
for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
|
||
|
|
if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
|
||
|
|
cf_have_incdir=yes; break
|
||
|
|
fi
|
||
|
|
done
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$cf_have_incdir" = no ; then
|
||
|
|
if test "$cf_add_incdir" = /usr/local/include ; then
|
||
|
|
if test "$GCC" = yes
|
||
|
|
then
|
||
|
|
cf_save_CPPFLAGS=$CPPFLAGS
|
||
|
|
CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
|
||
|
|
AC_TRY_COMPILE([#include <stdio.h>],
|
||
|
|
[printf("Hello")],
|
||
|
|
[],
|
||
|
|
[cf_have_incdir=yes])
|
||
|
|
CPPFLAGS=$cf_save_CPPFLAGS
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$cf_have_incdir" = no ; then
|
||
|
|
CF_VERBOSE(adding $cf_add_incdir to include-path)
|
||
|
|
ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
|
||
|
|
|
||
|
|
cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
|
||
|
|
test "$cf_top_incdir" = "$cf_add_incdir" && break
|
||
|
|
cf_add_incdir="$cf_top_incdir"
|
||
|
|
else
|
||
|
|
break
|
||
|
|
fi
|
||
|
|
else
|
||
|
|
break
|
||
|
|
fi
|
||
|
|
done
|
||
|
|
done
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
|
||
|
|
dnl ----------
|
||
|
|
dnl Add a library, used to enforce consistency.
|
||
|
|
dnl
|
||
|
|
dnl $1 = library to add, without the "-l"
|
||
|
|
dnl $2 = variable to update (default $LIBS)
|
||
|
|
AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_ADD_LIBDIR version: 10 updated: 2015/04/18 08:56:57
|
||
|
|
dnl -------------
|
||
|
|
dnl Adds to the library-path
|
||
|
|
dnl
|
||
|
|
dnl Some machines have trouble with multiple -L options.
|
||
|
|
dnl
|
||
|
|
dnl $1 is the (list of) directory(s) to add
|
||
|
|
dnl $2 is the optional name of the variable to update (default LDFLAGS)
|
||
|
|
dnl
|
||
|
|
AC_DEFUN([CF_ADD_LIBDIR],
|
||
|
|
[
|
||
|
|
if test -n "$1" ; then
|
||
|
|
for cf_add_libdir in $1
|
||
|
|
do
|
||
|
|
if test $cf_add_libdir = /usr/lib ; then
|
||
|
|
:
|
||
|
|
elif test -d $cf_add_libdir
|
||
|
|
then
|
||
|
|
cf_have_libdir=no
|
||
|
|
if test -n "$LDFLAGS$LIBS" ; then
|
||
|
|
# a loop is needed to ensure we can add subdirs of existing dirs
|
||
|
|
for cf_test_libdir in $LDFLAGS $LIBS ; do
|
||
|
|
if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
|
||
|
|
cf_have_libdir=yes; break
|
||
|
|
fi
|
||
|
|
done
|
||
|
|
fi
|
||
|
|
if test "$cf_have_libdir" = no ; then
|
||
|
|
CF_VERBOSE(adding $cf_add_libdir to library-path)
|
||
|
|
ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
done
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_ADD_LIBS version: 2 updated: 2014/07/13 14:33:27
|
||
|
|
dnl -----------
|
||
|
|
dnl Add one or more libraries, used to enforce consistency. Libraries are
|
||
|
|
dnl prepended to an existing list, since their dependencies are assumed to
|
||
|
|
dnl already exist in the list.
|
||
|
|
dnl
|
||
|
|
dnl $1 = libraries to add, with the "-l", etc.
|
||
|
|
dnl $2 = variable to update (default $LIBS)
|
||
|
|
AC_DEFUN([CF_ADD_LIBS],[
|
||
|
|
cf_add_libs="$1"
|
||
|
|
# Filter out duplicates - this happens with badly-designed ".pc" files...
|
||
|
|
for cf_add_1lib in [$]ifelse($2,,LIBS,[$2])
|
||
|
|
do
|
||
|
|
for cf_add_2lib in $cf_add_libs
|
||
|
|
do
|
||
|
|
if test "x$cf_add_1lib" = "x$cf_add_2lib"
|
||
|
|
then
|
||
|
|
cf_add_1lib=
|
||
|
|
break
|
||
|
|
fi
|
||
|
|
done
|
||
|
|
test -n "$cf_add_1lib" && cf_add_libs="$cf_add_libs $cf_add_1lib"
|
||
|
|
done
|
||
|
|
ifelse($2,,LIBS,[$2])="$cf_add_libs"
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_ADD_LIB_AFTER version: 3 updated: 2013/07/09 21:27:22
|
||
|
|
dnl ----------------
|
||
|
|
dnl Add a given library after another, e.g., following the one it satisfies a
|
||
|
|
dnl dependency for.
|
||
|
|
dnl
|
||
|
|
dnl $1 = the first library
|
||
|
|
dnl $2 = its dependency
|
||
|
|
AC_DEFUN([CF_ADD_LIB_AFTER],[
|
||
|
|
CF_VERBOSE(...before $LIBS)
|
||
|
|
LIBS=`echo "$LIBS" | sed -e "s/[[ ]][[ ]]*/ /g" -e "s%$1 %$1 $2 %" -e 's% % %g'`
|
||
|
|
CF_VERBOSE(...after $LIBS)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_ADD_SUBDIR_PATH version: 4 updated: 2013/10/08 17:47:05
|
||
|
|
dnl ------------------
|
||
|
|
dnl Append to a search-list for a nonstandard header/lib-file
|
||
|
|
dnl $1 = the variable to return as result
|
||
|
|
dnl $2 = the package name
|
||
|
|
dnl $3 = the subdirectory, e.g., bin, include or lib
|
||
|
|
dnl $4 = the directory under which we will test for subdirectories
|
||
|
|
dnl $5 = a directory that we do not want $4 to match
|
||
|
|
AC_DEFUN([CF_ADD_SUBDIR_PATH],
|
||
|
|
[
|
||
|
|
test "x$4" != "x$5" && \
|
||
|
|
test -d "$4" && \
|
||
|
|
ifelse([$5],NONE,,[(test -z "$5" || test x$5 = xNONE || test "x$4" != "x$5") &&]) {
|
||
|
|
test -n "$verbose" && echo " ... testing for $3-directories under $4"
|
||
|
|
test -d $4/$3 && $1="[$]$1 $4/$3"
|
||
|
|
test -d $4/$3/$2 && $1="[$]$1 $4/$3/$2"
|
||
|
|
test -d $4/$3/$2/$3 && $1="[$]$1 $4/$3/$2/$3"
|
||
|
|
test -d $4/$2/$3 && $1="[$]$1 $4/$2/$3"
|
||
|
|
test -d $4/$2/$3/$2 && $1="[$]$1 $4/$2/$3/$2"
|
||
|
|
}
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_ANSI_CC_CHECK version: 13 updated: 2012/10/06 11:17:15
|
||
|
|
dnl ----------------
|
||
|
|
dnl This was originally adapted from the macros 'fp_PROG_CC_STDC' and
|
||
|
|
dnl 'fp_C_PROTOTYPES' in the sharutils 4.2 distribution.
|
||
|
|
AC_DEFUN([CF_ANSI_CC_CHECK],
|
||
|
|
[
|
||
|
|
CF_CC_ENV_FLAGS
|
||
|
|
|
||
|
|
AC_CACHE_CHECK(for ${CC:-cc} option to accept ANSI C, cf_cv_ansi_cc,[
|
||
|
|
cf_cv_ansi_cc=no
|
||
|
|
cf_save_CFLAGS="$CFLAGS"
|
||
|
|
cf_save_CPPFLAGS="$CPPFLAGS"
|
||
|
|
# Don't try gcc -ansi; that turns off useful extensions and
|
||
|
|
# breaks some systems' header files.
|
||
|
|
# AIX -qlanglvl=ansi
|
||
|
|
# Ultrix and OSF/1 -std1
|
||
|
|
# HP-UX -Aa -D_HPUX_SOURCE
|
||
|
|
# SVR4 -Xc
|
||
|
|
# UnixWare 1.2 (cannot use -Xc, since ANSI/POSIX clashes)
|
||
|
|
for cf_arg in "-DCC_HAS_PROTOS" \
|
||
|
|
"" \
|
||
|
|
-qlanglvl=ansi \
|
||
|
|
-std1 \
|
||
|
|
-Ae \
|
||
|
|
"-Aa -D_HPUX_SOURCE" \
|
||
|
|
-Xc
|
||
|
|
do
|
||
|
|
CF_ADD_CFLAGS($cf_arg)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#ifndef CC_HAS_PROTOS
|
||
|
|
#if !defined(__STDC__) || (__STDC__ != 1)
|
||
|
|
choke me
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
],[
|
||
|
|
int test (int i, double x);
|
||
|
|
struct s1 {int (*f) (int a);};
|
||
|
|
struct s2 {int (*f) (double a);};],
|
||
|
|
[cf_cv_ansi_cc="$cf_arg"; break])
|
||
|
|
done
|
||
|
|
CFLAGS="$cf_save_CFLAGS"
|
||
|
|
CPPFLAGS="$cf_save_CPPFLAGS"
|
||
|
|
])
|
||
|
|
|
||
|
|
if test "$cf_cv_ansi_cc" != "no"; then
|
||
|
|
if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then
|
||
|
|
CF_ADD_CFLAGS($cf_cv_ansi_cc)
|
||
|
|
else
|
||
|
|
AC_DEFINE(CC_HAS_PROTOS,1,[Define to 1 if C compiler supports prototypes])
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_ANSI_CC_REQD version: 4 updated: 2008/03/23 14:48:54
|
||
|
|
dnl ---------------
|
||
|
|
dnl For programs that must use an ANSI compiler, obtain compiler options that
|
||
|
|
dnl will make it recognize prototypes. We'll do preprocessor checks in other
|
||
|
|
dnl macros, since tools such as unproto can fake prototypes, but only part of
|
||
|
|
dnl the preprocessor.
|
||
|
|
AC_DEFUN([CF_ANSI_CC_REQD],
|
||
|
|
[AC_REQUIRE([CF_ANSI_CC_CHECK])
|
||
|
|
if test "$cf_cv_ansi_cc" = "no"; then
|
||
|
|
AC_MSG_ERROR(
|
||
|
|
[Your compiler does not appear to recognize prototypes.
|
||
|
|
You have the following choices:
|
||
|
|
a. adjust your compiler options
|
||
|
|
b. get an up-to-date compiler
|
||
|
|
c. use a wrapper such as unproto])
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
|
||
|
|
dnl --------------
|
||
|
|
dnl Allow user to disable a normally-on option.
|
||
|
|
AC_DEFUN([CF_ARG_DISABLE],
|
||
|
|
[CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_ARG_OPTION version: 5 updated: 2015/05/10 19:52:14
|
||
|
|
dnl -------------
|
||
|
|
dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
|
||
|
|
dnl values.
|
||
|
|
dnl
|
||
|
|
dnl Parameters:
|
||
|
|
dnl $1 = option name
|
||
|
|
dnl $2 = help-string
|
||
|
|
dnl $3 = action to perform if option is not default
|
||
|
|
dnl $4 = action if perform if option is default
|
||
|
|
dnl $5 = default option value (either 'yes' or 'no')
|
||
|
|
AC_DEFUN([CF_ARG_OPTION],
|
||
|
|
[AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
|
||
|
|
if test "$enableval" != "$5" ; then
|
||
|
|
ifelse([$3],,[ :]dnl
|
||
|
|
,[ $3]) ifelse([$4],,,[
|
||
|
|
else
|
||
|
|
$4])
|
||
|
|
fi],[enableval=$5 ifelse([$4],,,[
|
||
|
|
$4
|
||
|
|
])dnl
|
||
|
|
])])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_CC_ENV_FLAGS version: 6 updated: 2016/08/29 20:57:00
|
||
|
|
dnl ---------------
|
||
|
|
dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
|
||
|
|
dnl into CC. This will not help with broken scripts that wrap the compiler
|
||
|
|
dnl with options, but eliminates a more common category of user confusion.
|
||
|
|
dnl
|
||
|
|
dnl In particular, it addresses the problem of being able to run the C
|
||
|
|
dnl preprocessor in a consistent manner.
|
||
|
|
dnl
|
||
|
|
dnl Caveat: this also disallows blanks in the pathname for the compiler, but
|
||
|
|
dnl the nuisance of having inconsistent settings for compiler and preprocessor
|
||
|
|
dnl outweighs that limitation.
|
||
|
|
AC_DEFUN([CF_CC_ENV_FLAGS],
|
||
|
|
[
|
||
|
|
# This should have been defined by AC_PROG_CC
|
||
|
|
: ${CC:=cc}
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(\$CC variable)
|
||
|
|
case "$CC" in
|
||
|
|
(*[[\ \ ]]-*)
|
||
|
|
AC_MSG_RESULT(broken)
|
||
|
|
AC_MSG_WARN(your environment misuses the CC variable to hold CFLAGS/CPPFLAGS options)
|
||
|
|
# humor him...
|
||
|
|
cf_flags=`echo "$CC" | sed -e 's/^.*[[ ]]\(-[[^ ]]\)/\1/'`
|
||
|
|
CC=`echo "$CC " | sed -e 's/[[ ]]-[[^ ]].*$//' -e 's/[[ ]]*$//'`
|
||
|
|
for cf_arg in $cf_flags
|
||
|
|
do
|
||
|
|
case "x$cf_arg" in
|
||
|
|
(x-[[IUDfgOW]]*)
|
||
|
|
CF_ADD_CFLAGS($cf_flags)
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
CC="$CC $cf_arg"
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
done
|
||
|
|
CF_VERBOSE(resulting CC: '$CC')
|
||
|
|
CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
|
||
|
|
CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
AC_MSG_RESULT(ok)
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_CHECK_CACHE version: 12 updated: 2012/10/02 20:55:03
|
||
|
|
dnl --------------
|
||
|
|
dnl Check if we're accidentally using a cache from a different machine.
|
||
|
|
dnl Derive the system name, as a check for reusing the autoconf cache.
|
||
|
|
dnl
|
||
|
|
dnl If we've packaged config.guess and config.sub, run that (since it does a
|
||
|
|
dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
|
||
|
|
dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
|
||
|
|
dnl which is useful in cross-compiles.
|
||
|
|
dnl
|
||
|
|
dnl Note: we would use $ac_config_sub, but that is one of the places where
|
||
|
|
dnl autoconf 2.5x broke compatibility with autoconf 2.13
|
||
|
|
AC_DEFUN([CF_CHECK_CACHE],
|
||
|
|
[
|
||
|
|
if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
|
||
|
|
ifelse([$1],,[AC_CANONICAL_HOST],[$1])
|
||
|
|
system_name="$host_os"
|
||
|
|
else
|
||
|
|
system_name="`(uname -s -r) 2>/dev/null`"
|
||
|
|
if test -z "$system_name" ; then
|
||
|
|
system_name="`(hostname) 2>/dev/null`"
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
|
||
|
|
AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
|
||
|
|
|
||
|
|
test -z "$system_name" && system_name="$cf_cv_system_name"
|
||
|
|
test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
|
||
|
|
|
||
|
|
if test ".$system_name" != ".$cf_cv_system_name" ; then
|
||
|
|
AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
|
||
|
|
AC_MSG_ERROR("Please remove config.cache and try again.")
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_CHECK_CFLAGS version: 3 updated: 2014/07/22 05:32:57
|
||
|
|
dnl ---------------
|
||
|
|
dnl Conditionally add to $CFLAGS and $CPPFLAGS values which are derived from
|
||
|
|
dnl a build-configuration such as imake. These have the pitfall that they
|
||
|
|
dnl often contain compiler-specific options which we cannot use, mixed with
|
||
|
|
dnl preprocessor options that we usually can.
|
||
|
|
AC_DEFUN([CF_CHECK_CFLAGS],
|
||
|
|
[
|
||
|
|
CF_VERBOSE(checking additions to CFLAGS)
|
||
|
|
cf_check_cflags="$CFLAGS"
|
||
|
|
cf_check_cppflags="$CPPFLAGS"
|
||
|
|
CF_ADD_CFLAGS($1,yes)
|
||
|
|
if test "x$cf_check_cflags" != "x$CFLAGS" ; then
|
||
|
|
AC_TRY_LINK([#include <stdio.h>],[printf("Hello world");],,
|
||
|
|
[CF_VERBOSE(test-compile failed. Undoing change to \$CFLAGS)
|
||
|
|
if test "x$cf_check_cppflags" != "x$CPPFLAGS" ; then
|
||
|
|
CF_VERBOSE(but keeping change to \$CPPFLAGS)
|
||
|
|
fi
|
||
|
|
CFLAGS="$cf_check_flags"])
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_CHECK_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09
|
||
|
|
dnl ------------------------
|
||
|
|
dnl Show the version of libtool
|
||
|
|
dnl
|
||
|
|
dnl Save the version in a cache variable - this is not entirely a good thing,
|
||
|
|
dnl but the version string from libtool is very ugly, and for bug reports it
|
||
|
|
dnl might be useful to have the original string.
|
||
|
|
AC_DEFUN([CF_CHECK_LIBTOOL_VERSION],[
|
||
|
|
if test -n "$LIBTOOL" && test "$LIBTOOL" != none
|
||
|
|
then
|
||
|
|
AC_MSG_CHECKING(version of $LIBTOOL)
|
||
|
|
CF_LIBTOOL_VERSION
|
||
|
|
AC_MSG_RESULT($cf_cv_libtool_version)
|
||
|
|
if test -z "$cf_cv_libtool_version" ; then
|
||
|
|
AC_MSG_ERROR(This is not GNU libtool)
|
||
|
|
fi
|
||
|
|
else
|
||
|
|
AC_MSG_ERROR(GNU libtool has not been found)
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_CLANG_COMPILER version: 2 updated: 2013/11/19 19:23:35
|
||
|
|
dnl -----------------
|
||
|
|
dnl Check if the given compiler is really clang. clang's C driver defines
|
||
|
|
dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
|
||
|
|
dnl not ignore some gcc options.
|
||
|
|
dnl
|
||
|
|
dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
|
||
|
|
dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
|
||
|
|
dnl the wrappers for gcc and g++ warnings.
|
||
|
|
dnl
|
||
|
|
dnl $1 = GCC (default) or GXX
|
||
|
|
dnl $2 = CLANG_COMPILER (default)
|
||
|
|
dnl $3 = CFLAGS (default) or CXXFLAGS
|
||
|
|
AC_DEFUN([CF_CLANG_COMPILER],[
|
||
|
|
ifelse([$2],,CLANG_COMPILER,[$2])=no
|
||
|
|
|
||
|
|
if test "$ifelse([$1],,[$1],GCC)" = yes ; then
|
||
|
|
AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
|
||
|
|
cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
|
||
|
|
ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -Qunused-arguments"
|
||
|
|
AC_TRY_COMPILE([],[
|
||
|
|
#ifdef __clang__
|
||
|
|
#else
|
||
|
|
make an error
|
||
|
|
#endif
|
||
|
|
],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
|
||
|
|
cf_save_CFLAGS="$cf_save_CFLAGS -Qunused-arguments"
|
||
|
|
],[])
|
||
|
|
ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
|
||
|
|
AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
|
||
|
|
fi
|
||
|
|
])
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_CURSES_CHTYPE version: 8 updated: 2012/10/06 08:57:51
|
||
|
|
dnl ----------------
|
||
|
|
dnl Test if curses defines 'chtype' (usually a 'long' type for SysV curses).
|
||
|
|
AC_DEFUN([CF_CURSES_CHTYPE],
|
||
|
|
[
|
||
|
|
AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
|
||
|
|
AC_CACHE_CHECK(for chtype typedef,cf_cv_chtype_decl,[
|
||
|
|
AC_TRY_COMPILE([#include <${cf_cv_ncurses_header:-curses.h}>],
|
||
|
|
[chtype foo],
|
||
|
|
[cf_cv_chtype_decl=yes],
|
||
|
|
[cf_cv_chtype_decl=no])])
|
||
|
|
if test $cf_cv_chtype_decl = yes ; then
|
||
|
|
AC_DEFINE(HAVE_TYPE_CHTYPE,1,[Define to 1 if chtype is declared])
|
||
|
|
AC_CACHE_CHECK(if chtype is scalar or struct,cf_cv_chtype_type,[
|
||
|
|
AC_TRY_COMPILE([#include <${cf_cv_ncurses_header:-curses.h}>],
|
||
|
|
[chtype foo; long x = foo],
|
||
|
|
[cf_cv_chtype_type=scalar],
|
||
|
|
[cf_cv_chtype_type=struct])])
|
||
|
|
if test $cf_cv_chtype_type = scalar ; then
|
||
|
|
AC_DEFINE(TYPE_CHTYPE_IS_SCALAR,1,[Define to 1 if chtype is a scaler/integer])
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_CURSES_CONFIG version: 2 updated: 2006/10/29 11:06:27
|
||
|
|
dnl ----------------
|
||
|
|
dnl Tie together the configure-script macros for curses. It may be ncurses,
|
||
|
|
dnl but unless asked, we do not make a special search for ncurses. However,
|
||
|
|
dnl still check for the ncurses version number, for use in other macros.
|
||
|
|
AC_DEFUN([CF_CURSES_CONFIG],
|
||
|
|
[
|
||
|
|
CF_CURSES_CPPFLAGS
|
||
|
|
CF_NCURSES_VERSION
|
||
|
|
CF_CURSES_LIBS
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_CURSES_CPPFLAGS version: 12 updated: 2015/04/15 19:08:48
|
||
|
|
dnl ------------------
|
||
|
|
dnl Look for the curses headers.
|
||
|
|
AC_DEFUN([CF_CURSES_CPPFLAGS],[
|
||
|
|
|
||
|
|
AC_CACHE_CHECK(for extra include directories,cf_cv_curses_incdir,[
|
||
|
|
cf_cv_curses_incdir=no
|
||
|
|
case $host_os in
|
||
|
|
(hpux10.*)
|
||
|
|
if test "x$cf_cv_screen" = "xcurses_colr"
|
||
|
|
then
|
||
|
|
test -d /usr/include/curses_colr && \
|
||
|
|
cf_cv_curses_incdir="-I/usr/include/curses_colr"
|
||
|
|
fi
|
||
|
|
;;
|
||
|
|
(sunos3*|sunos4*)
|
||
|
|
if test "x$cf_cv_screen" = "xcurses_5lib"
|
||
|
|
then
|
||
|
|
test -d /usr/5lib && \
|
||
|
|
test -d /usr/5include && \
|
||
|
|
cf_cv_curses_incdir="-I/usr/5include"
|
||
|
|
fi
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
])
|
||
|
|
test "$cf_cv_curses_incdir" != no && CPPFLAGS="$CPPFLAGS $cf_cv_curses_incdir"
|
||
|
|
|
||
|
|
CF_CURSES_HEADER
|
||
|
|
CF_TERM_HEADER
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_CURSES_FUNCS version: 18 updated: 2014/07/19 18:44:41
|
||
|
|
dnl ---------------
|
||
|
|
dnl Curses-functions are a little complicated, since a lot of them are macros.
|
||
|
|
AC_DEFUN([CF_CURSES_FUNCS],
|
||
|
|
[
|
||
|
|
AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
|
||
|
|
AC_REQUIRE([CF_XOPEN_CURSES])
|
||
|
|
AC_REQUIRE([CF_CURSES_TERM_H])
|
||
|
|
AC_REQUIRE([CF_CURSES_UNCTRL_H])
|
||
|
|
for cf_func in $1
|
||
|
|
do
|
||
|
|
CF_UPPER(cf_tr_func,$cf_func)
|
||
|
|
AC_MSG_CHECKING(for ${cf_func})
|
||
|
|
CF_MSG_LOG(${cf_func})
|
||
|
|
AC_CACHE_VAL(cf_cv_func_$cf_func,[
|
||
|
|
eval cf_result='$ac_cv_func_'$cf_func
|
||
|
|
if test ".$cf_result" != ".no"; then
|
||
|
|
AC_TRY_LINK(CF__CURSES_HEAD,
|
||
|
|
[
|
||
|
|
#ifndef ${cf_func}
|
||
|
|
long foo = (long)(&${cf_func});
|
||
|
|
fprintf(stderr, "testing linkage of $cf_func:%p\n", foo);
|
||
|
|
if (foo + 1234 > 5678)
|
||
|
|
${cf_cv_main_return:-return}(foo);
|
||
|
|
#endif
|
||
|
|
],
|
||
|
|
[cf_result=yes],
|
||
|
|
[cf_result=no])
|
||
|
|
fi
|
||
|
|
eval 'cf_cv_func_'$cf_func'=$cf_result'
|
||
|
|
])
|
||
|
|
# use the computed/retrieved cache-value:
|
||
|
|
eval 'cf_result=$cf_cv_func_'$cf_func
|
||
|
|
AC_MSG_RESULT($cf_result)
|
||
|
|
if test $cf_result != no; then
|
||
|
|
AC_DEFINE_UNQUOTED(HAVE_${cf_tr_func})
|
||
|
|
fi
|
||
|
|
done
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_CURSES_HEADER version: 5 updated: 2015/04/23 20:35:30
|
||
|
|
dnl ----------------
|
||
|
|
dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
|
||
|
|
dnl variations of ncurses' installs.
|
||
|
|
dnl
|
||
|
|
dnl $1 = ncurses when looking for ncurses, or is empty
|
||
|
|
AC_DEFUN([CF_CURSES_HEADER],[
|
||
|
|
AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[
|
||
|
|
cf_cv_ncurses_header=none
|
||
|
|
for cf_header in \
|
||
|
|
ncurses.h ifelse($1,,,[$1/ncurses.h]) \
|
||
|
|
curses.h ifelse($1,,,[$1/curses.h]) ifelse($1,,[ncurses/ncurses.h ncurses/curses.h])
|
||
|
|
do
|
||
|
|
AC_TRY_COMPILE([#include <${cf_header}>],
|
||
|
|
[initscr(); tgoto("?", 0,0)],
|
||
|
|
[cf_cv_ncurses_header=$cf_header; break],[])
|
||
|
|
done
|
||
|
|
])
|
||
|
|
|
||
|
|
if test "$cf_cv_ncurses_header" = none ; then
|
||
|
|
AC_MSG_ERROR(No curses header-files found)
|
||
|
|
fi
|
||
|
|
|
||
|
|
# cheat, to get the right #define's for HAVE_NCURSES_H, etc.
|
||
|
|
AC_CHECK_HEADERS($cf_cv_ncurses_header)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_CURSES_LIBS version: 39 updated: 2015/05/10 19:52:14
|
||
|
|
dnl --------------
|
||
|
|
dnl Look for the curses libraries. Older curses implementations may require
|
||
|
|
dnl termcap/termlib to be linked as well. Call CF_CURSES_CPPFLAGS first.
|
||
|
|
AC_DEFUN([CF_CURSES_LIBS],[
|
||
|
|
|
||
|
|
AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
|
||
|
|
AC_MSG_CHECKING(if we have identified curses libraries)
|
||
|
|
AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
|
||
|
|
[initscr(); tgoto("?", 0,0)],
|
||
|
|
cf_result=yes,
|
||
|
|
cf_result=no)
|
||
|
|
AC_MSG_RESULT($cf_result)
|
||
|
|
|
||
|
|
if test "$cf_result" = no ; then
|
||
|
|
case $host_os in
|
||
|
|
(freebsd*)
|
||
|
|
AC_CHECK_LIB(mytinfo,tgoto,[CF_ADD_LIBS(-lmytinfo)])
|
||
|
|
;;
|
||
|
|
(hpux10.*)
|
||
|
|
# Looking at HPUX 10.20, the Hcurses library is the oldest (1997), cur_colr
|
||
|
|
# next (1998), and xcurses "newer" (2000). There is no header file for
|
||
|
|
# Hcurses; the subdirectory curses_colr has the headers (curses.h and
|
||
|
|
# term.h) for cur_colr
|
||
|
|
if test "x$cf_cv_screen" = "xcurses_colr"
|
||
|
|
then
|
||
|
|
AC_CHECK_LIB(cur_colr,initscr,[
|
||
|
|
CF_ADD_LIBS(-lcur_colr)
|
||
|
|
ac_cv_func_initscr=yes
|
||
|
|
],[
|
||
|
|
AC_CHECK_LIB(Hcurses,initscr,[
|
||
|
|
# HP's header uses __HP_CURSES, but user claims _HP_CURSES.
|
||
|
|
CF_ADD_LIBS(-lHcurses)
|
||
|
|
CPPFLAGS="$CPPFLAGS -D__HP_CURSES -D_HP_CURSES"
|
||
|
|
ac_cv_func_initscr=yes
|
||
|
|
])])
|
||
|
|
fi
|
||
|
|
;;
|
||
|
|
(linux*)
|
||
|
|
case `arch 2>/dev/null` in
|
||
|
|
(x86_64)
|
||
|
|
if test -d /lib64
|
||
|
|
then
|
||
|
|
CF_ADD_LIBDIR(/lib64)
|
||
|
|
else
|
||
|
|
CF_ADD_LIBDIR(/lib)
|
||
|
|
fi
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
CF_ADD_LIBDIR(/lib)
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
;;
|
||
|
|
(sunos3*|sunos4*)
|
||
|
|
if test "x$cf_cv_screen" = "xcurses_5lib"
|
||
|
|
then
|
||
|
|
if test -d /usr/5lib ; then
|
||
|
|
CF_ADD_LIBDIR(/usr/5lib)
|
||
|
|
CF_ADD_LIBS(-lcurses -ltermcap)
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
ac_cv_func_initscr=yes
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
if test ".$ac_cv_func_initscr" != .yes ; then
|
||
|
|
cf_save_LIBS="$LIBS"
|
||
|
|
|
||
|
|
if test ".${cf_cv_ncurses_version:-no}" != .no
|
||
|
|
then
|
||
|
|
cf_check_list="ncurses curses cursesX"
|
||
|
|
else
|
||
|
|
cf_check_list="cursesX curses ncurses"
|
||
|
|
fi
|
||
|
|
|
||
|
|
# Check for library containing tgoto. Do this before curses library
|
||
|
|
# because it may be needed to link the test-case for initscr.
|
||
|
|
if test "x$cf_term_lib" = x
|
||
|
|
then
|
||
|
|
AC_CHECK_FUNC(tgoto,[cf_term_lib=predefined],[
|
||
|
|
for cf_term_lib in $cf_check_list otermcap termcap tinfo termlib unknown
|
||
|
|
do
|
||
|
|
AC_CHECK_LIB($cf_term_lib,tgoto,[break])
|
||
|
|
done
|
||
|
|
])
|
||
|
|
fi
|
||
|
|
|
||
|
|
# Check for library containing initscr
|
||
|
|
test "$cf_term_lib" != predefined && test "$cf_term_lib" != unknown && LIBS="-l$cf_term_lib $cf_save_LIBS"
|
||
|
|
if test "x$cf_curs_lib" = x
|
||
|
|
then
|
||
|
|
for cf_curs_lib in $cf_check_list xcurses jcurses pdcurses unknown
|
||
|
|
do
|
||
|
|
AC_CHECK_LIB($cf_curs_lib,initscr,[break])
|
||
|
|
done
|
||
|
|
fi
|
||
|
|
test $cf_curs_lib = unknown && AC_MSG_ERROR(no curses library found)
|
||
|
|
|
||
|
|
LIBS="-l$cf_curs_lib $cf_save_LIBS"
|
||
|
|
if test "$cf_term_lib" = unknown ; then
|
||
|
|
AC_MSG_CHECKING(if we can link with $cf_curs_lib library)
|
||
|
|
AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
|
||
|
|
[initscr()],
|
||
|
|
[cf_result=yes],
|
||
|
|
[cf_result=no])
|
||
|
|
AC_MSG_RESULT($cf_result)
|
||
|
|
test $cf_result = no && AC_MSG_ERROR(Cannot link curses library)
|
||
|
|
elif test "$cf_curs_lib" = "$cf_term_lib" ; then
|
||
|
|
:
|
||
|
|
elif test "$cf_term_lib" != predefined ; then
|
||
|
|
AC_MSG_CHECKING(if we need both $cf_curs_lib and $cf_term_lib libraries)
|
||
|
|
AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
|
||
|
|
[initscr(); tgoto((char *)0, 0, 0);],
|
||
|
|
[cf_result=no],
|
||
|
|
[
|
||
|
|
LIBS="-l$cf_curs_lib -l$cf_term_lib $cf_save_LIBS"
|
||
|
|
AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
|
||
|
|
[initscr()],
|
||
|
|
[cf_result=yes],
|
||
|
|
[cf_result=error])
|
||
|
|
])
|
||
|
|
AC_MSG_RESULT($cf_result)
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_CURSES_SETBEGYX version: 3 updated: 2013/06/15 11:12:27
|
||
|
|
dnl ------------------
|
||
|
|
dnl See if we can define a function to set a window's beginning y/x coordinates.
|
||
|
|
AC_DEFUN([CF_CURSES_SETBEGYX],[
|
||
|
|
AC_MSG_CHECKING(how to define setbegyx)
|
||
|
|
cf_result=ERR
|
||
|
|
for cf_check in \
|
||
|
|
'((win)->_begy = (y), (win)->_begx = (x), OK)'
|
||
|
|
do
|
||
|
|
AC_TRY_COMPILE([
|
||
|
|
#include <${cf_cv_ncurses_header:-curses.h}>
|
||
|
|
],[
|
||
|
|
WINDOW *win = 0;
|
||
|
|
#define setbegyx(win,y,x) $cf_check
|
||
|
|
setbegyx(win, 2, 3);
|
||
|
|
],[cf_result=$cf_check; break])
|
||
|
|
done
|
||
|
|
AC_MSG_RESULT("$cf_result")
|
||
|
|
AC_DEFINE_UNQUOTED(setbegyx(win,y,x),$cf_result,[Define to function for setting window's y/x coordinates])
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_CURSES_TERM_H version: 11 updated: 2015/04/15 19:08:48
|
||
|
|
dnl ----------------
|
||
|
|
dnl SVr4 curses should have term.h as well (where it puts the definitions of
|
||
|
|
dnl the low-level interface). This may not be true in old/broken implementations,
|
||
|
|
dnl as well as in misconfigured systems (e.g., gcc configured for Solaris 2.4
|
||
|
|
dnl running with Solaris 2.5.1).
|
||
|
|
AC_DEFUN([CF_CURSES_TERM_H],
|
||
|
|
[
|
||
|
|
AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
|
||
|
|
|
||
|
|
AC_CACHE_CHECK(for term.h, cf_cv_term_header,[
|
||
|
|
|
||
|
|
# If we found <ncurses/curses.h>, look for <ncurses/term.h>, but always look
|
||
|
|
# for <term.h> if we do not find the variant.
|
||
|
|
|
||
|
|
cf_header_list="term.h ncurses/term.h ncursesw/term.h"
|
||
|
|
|
||
|
|
case ${cf_cv_ncurses_header:-curses.h} in
|
||
|
|
(*/*)
|
||
|
|
cf_header_item=`echo ${cf_cv_ncurses_header:-curses.h} | sed -e 's%\..*%%' -e 's%/.*%/%'`term.h
|
||
|
|
cf_header_list="$cf_header_item $cf_header_list"
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
for cf_header in $cf_header_list
|
||
|
|
do
|
||
|
|
AC_TRY_COMPILE([
|
||
|
|
#include <${cf_cv_ncurses_header:-curses.h}>
|
||
|
|
#include <${cf_header}>],
|
||
|
|
[WINDOW *x],
|
||
|
|
[cf_cv_term_header=$cf_header
|
||
|
|
break],
|
||
|
|
[cf_cv_term_header=no])
|
||
|
|
done
|
||
|
|
|
||
|
|
case $cf_cv_term_header in
|
||
|
|
(no)
|
||
|
|
# If curses is ncurses, some packagers still mess it up by trying to make
|
||
|
|
# us use GNU termcap. This handles the most common case.
|
||
|
|
for cf_header in ncurses/term.h ncursesw/term.h
|
||
|
|
do
|
||
|
|
AC_TRY_COMPILE([
|
||
|
|
#include <${cf_cv_ncurses_header:-curses.h}>
|
||
|
|
#ifdef NCURSES_VERSION
|
||
|
|
#include <${cf_header}>
|
||
|
|
#else
|
||
|
|
make an error
|
||
|
|
#endif],
|
||
|
|
[WINDOW *x],
|
||
|
|
[cf_cv_term_header=$cf_header
|
||
|
|
break],
|
||
|
|
[cf_cv_term_header=no])
|
||
|
|
done
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
])
|
||
|
|
|
||
|
|
case $cf_cv_term_header in
|
||
|
|
(term.h)
|
||
|
|
AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
|
||
|
|
;;
|
||
|
|
(ncurses/term.h)
|
||
|
|
AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
|
||
|
|
;;
|
||
|
|
(ncursesw/term.h)
|
||
|
|
AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_CURSES_UNCTRL_H version: 4 updated: 2015/04/15 19:08:48
|
||
|
|
dnl ------------------
|
||
|
|
dnl Any X/Open curses implementation must have unctrl.h, but ncurses packages
|
||
|
|
dnl may put it in a subdirectory (along with ncurses' other headers, of
|
||
|
|
dnl course). Packages which put the headers in inconsistent locations are
|
||
|
|
dnl broken).
|
||
|
|
AC_DEFUN([CF_CURSES_UNCTRL_H],
|
||
|
|
[
|
||
|
|
AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
|
||
|
|
|
||
|
|
AC_CACHE_CHECK(for unctrl.h, cf_cv_unctrl_header,[
|
||
|
|
|
||
|
|
# If we found <ncurses/curses.h>, look for <ncurses/unctrl.h>, but always look
|
||
|
|
# for <unctrl.h> if we do not find the variant.
|
||
|
|
|
||
|
|
cf_header_list="unctrl.h ncurses/unctrl.h ncursesw/unctrl.h"
|
||
|
|
|
||
|
|
case ${cf_cv_ncurses_header:-curses.h} in
|
||
|
|
(*/*)
|
||
|
|
cf_header_item=`echo ${cf_cv_ncurses_header:-curses.h} | sed -e 's%\..*%%' -e 's%/.*%/%'`unctrl.h
|
||
|
|
cf_header_list="$cf_header_item $cf_header_list"
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
for cf_header in $cf_header_list
|
||
|
|
do
|
||
|
|
AC_TRY_COMPILE([
|
||
|
|
#include <${cf_cv_ncurses_header:-curses.h}>
|
||
|
|
#include <${cf_header}>],
|
||
|
|
[WINDOW *x],
|
||
|
|
[cf_cv_unctrl_header=$cf_header
|
||
|
|
break],
|
||
|
|
[cf_cv_unctrl_header=no])
|
||
|
|
done
|
||
|
|
])
|
||
|
|
|
||
|
|
case $cf_cv_unctrl_header in
|
||
|
|
(no)
|
||
|
|
AC_MSG_WARN(unctrl.h header not found)
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
case $cf_cv_unctrl_header in
|
||
|
|
(unctrl.h)
|
||
|
|
AC_DEFINE(HAVE_UNCTRL_H,1,[Define to 1 if we have unctrl.h])
|
||
|
|
;;
|
||
|
|
(ncurses/unctrl.h)
|
||
|
|
AC_DEFINE(HAVE_NCURSES_UNCTRL_H,1,[Define to 1 if we have ncurses/unctrl.h])
|
||
|
|
;;
|
||
|
|
(ncursesw/unctrl.h)
|
||
|
|
AC_DEFINE(HAVE_NCURSESW_UNCTRL_H,1,[Define to 1 if we have ncursesw/unctrl.h])
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
|
||
|
|
dnl ----------
|
||
|
|
dnl "dirname" is not portable, so we fake it with a shell script.
|
||
|
|
AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_DISABLE_ECHO version: 13 updated: 2015/04/18 08:56:57
|
||
|
|
dnl ---------------
|
||
|
|
dnl You can always use "make -n" to see the actual options, but it's hard to
|
||
|
|
dnl pick out/analyze warning messages when the compile-line is long.
|
||
|
|
dnl
|
||
|
|
dnl Sets:
|
||
|
|
dnl ECHO_LT - symbol to control if libtool is verbose
|
||
|
|
dnl ECHO_LD - symbol to prefix "cc -o" lines
|
||
|
|
dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
|
||
|
|
dnl SHOW_CC - symbol to put before explicit "cc -c" lines
|
||
|
|
dnl ECHO_CC - symbol to put before any "cc" line
|
||
|
|
dnl
|
||
|
|
AC_DEFUN([CF_DISABLE_ECHO],[
|
||
|
|
AC_MSG_CHECKING(if you want to see long compiling messages)
|
||
|
|
CF_ARG_DISABLE(echo,
|
||
|
|
[ --disable-echo do not display "compiling" commands],
|
||
|
|
[
|
||
|
|
ECHO_LT='--silent'
|
||
|
|
ECHO_LD='@echo linking [$]@;'
|
||
|
|
RULE_CC='@echo compiling [$]<'
|
||
|
|
SHOW_CC='@echo compiling [$]@'
|
||
|
|
ECHO_CC='@'
|
||
|
|
],[
|
||
|
|
ECHO_LT=''
|
||
|
|
ECHO_LD=''
|
||
|
|
RULE_CC=''
|
||
|
|
SHOW_CC=''
|
||
|
|
ECHO_CC=''
|
||
|
|
])
|
||
|
|
AC_MSG_RESULT($enableval)
|
||
|
|
AC_SUBST(ECHO_LT)
|
||
|
|
AC_SUBST(ECHO_LD)
|
||
|
|
AC_SUBST(RULE_CC)
|
||
|
|
AC_SUBST(SHOW_CC)
|
||
|
|
AC_SUBST(ECHO_CC)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_DISABLE_LEAKS version: 7 updated: 2012/10/02 20:55:03
|
||
|
|
dnl ----------------
|
||
|
|
dnl Combine no-leak checks with the libraries or tools that are used for the
|
||
|
|
dnl checks.
|
||
|
|
AC_DEFUN([CF_DISABLE_LEAKS],[
|
||
|
|
|
||
|
|
AC_REQUIRE([CF_WITH_DMALLOC])
|
||
|
|
AC_REQUIRE([CF_WITH_DBMALLOC])
|
||
|
|
AC_REQUIRE([CF_WITH_VALGRIND])
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(if you want to perform memory-leak testing)
|
||
|
|
AC_ARG_ENABLE(leaks,
|
||
|
|
[ --disable-leaks test: free permanent memory, analyze leaks],
|
||
|
|
[if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi],
|
||
|
|
: ${with_no_leaks:=no})
|
||
|
|
AC_MSG_RESULT($with_no_leaks)
|
||
|
|
|
||
|
|
if test "$with_no_leaks" = yes ; then
|
||
|
|
AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
|
||
|
|
AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_DISABLE_LIBTOOL_VERSION version: 3 updated: 2015/04/17 21:13:04
|
||
|
|
dnl --------------------------
|
||
|
|
dnl Check if we should use the libtool 1.5 feature "-version-number" instead of
|
||
|
|
dnl the older "-version-info" feature. The newer feature allows us to use
|
||
|
|
dnl version numbering on shared libraries which make them compatible with
|
||
|
|
dnl various systems.
|
||
|
|
AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION],
|
||
|
|
[
|
||
|
|
AC_MSG_CHECKING(if libtool -version-number should be used)
|
||
|
|
CF_ARG_DISABLE(libtool-version,
|
||
|
|
[ --disable-libtool-version enable to use libtool's incompatible naming scheme],
|
||
|
|
[cf_libtool_version=no],
|
||
|
|
[cf_libtool_version=yes])
|
||
|
|
AC_MSG_RESULT($cf_libtool_version)
|
||
|
|
|
||
|
|
if test "$cf_libtool_version" = yes ; then
|
||
|
|
LIBTOOL_VERSION="-version-number"
|
||
|
|
else
|
||
|
|
LIBTOOL_VERSION="-version-info"
|
||
|
|
case "x$VERSION" in
|
||
|
|
(x)
|
||
|
|
AC_MSG_WARN(VERSION was not set)
|
||
|
|
;;
|
||
|
|
(x*.*.*)
|
||
|
|
ABI_VERSION="$VERSION"
|
||
|
|
CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
|
||
|
|
;;
|
||
|
|
(x*:*:*)
|
||
|
|
ABI_VERSION=`echo "$VERSION" | sed -e 's/:/./g'`
|
||
|
|
CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
AC_MSG_WARN(unexpected VERSION value: $VERSION)
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
fi
|
||
|
|
|
||
|
|
AC_SUBST(ABI_VERSION)
|
||
|
|
AC_SUBST(LIBTOOL_VERSION)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_DISABLE_RPATH_HACK version: 2 updated: 2011/02/13 13:31:33
|
||
|
|
dnl ---------------------
|
||
|
|
dnl The rpath-hack makes it simpler to build programs, particularly with the
|
||
|
|
dnl *BSD ports which may have essential libraries in unusual places. But it
|
||
|
|
dnl can interfere with building an executable for the base system. Use this
|
||
|
|
dnl option in that case.
|
||
|
|
AC_DEFUN([CF_DISABLE_RPATH_HACK],
|
||
|
|
[
|
||
|
|
AC_MSG_CHECKING(if rpath-hack should be disabled)
|
||
|
|
CF_ARG_DISABLE(rpath-hack,
|
||
|
|
[ --disable-rpath-hack don't add rpath options for additional libraries],
|
||
|
|
[cf_disable_rpath_hack=yes],
|
||
|
|
[cf_disable_rpath_hack=no])
|
||
|
|
AC_MSG_RESULT($cf_disable_rpath_hack)
|
||
|
|
if test "$cf_disable_rpath_hack" = no ; then
|
||
|
|
CF_RPATH_HACK
|
||
|
|
fi
|
||
|
|
])
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
|
||
|
|
dnl ---------------
|
||
|
|
dnl Check if the rpath option should be used, setting cache variable
|
||
|
|
dnl cf_cv_enable_rpath if so.
|
||
|
|
AC_DEFUN([CF_ENABLE_RPATH],
|
||
|
|
[
|
||
|
|
AC_MSG_CHECKING(if rpath option should be used)
|
||
|
|
AC_ARG_ENABLE(rpath,
|
||
|
|
[ --enable-rpath use rpath option when generating shared libraries],
|
||
|
|
[cf_cv_enable_rpath=$enableval],
|
||
|
|
[cf_cv_enable_rpath=no])
|
||
|
|
AC_MSG_RESULT($cf_cv_enable_rpath)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_FIND_LIBRARY version: 9 updated: 2008/03/23 14:48:54
|
||
|
|
dnl ---------------
|
||
|
|
dnl Look for a non-standard library, given parameters for AC_TRY_LINK. We
|
||
|
|
dnl prefer a standard location, and use -L options only if we do not find the
|
||
|
|
dnl library in the standard library location(s).
|
||
|
|
dnl $1 = library name
|
||
|
|
dnl $2 = library class, usually the same as library name
|
||
|
|
dnl $3 = includes
|
||
|
|
dnl $4 = code fragment to compile/link
|
||
|
|
dnl $5 = corresponding function-name
|
||
|
|
dnl $6 = flag, nonnull if failure should not cause an error-exit
|
||
|
|
dnl
|
||
|
|
dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had
|
||
|
|
dnl to use a -L option.
|
||
|
|
AC_DEFUN([CF_FIND_LIBRARY],
|
||
|
|
[
|
||
|
|
eval 'cf_cv_have_lib_'$1'=no'
|
||
|
|
cf_libdir=""
|
||
|
|
AC_CHECK_FUNC($5,
|
||
|
|
eval 'cf_cv_have_lib_'$1'=yes',[
|
||
|
|
cf_save_LIBS="$LIBS"
|
||
|
|
AC_MSG_CHECKING(for $5 in -l$1)
|
||
|
|
LIBS="-l$1 $LIBS"
|
||
|
|
AC_TRY_LINK([$3],[$4],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
eval 'cf_cv_have_lib_'$1'=yes'
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
CF_LIBRARY_PATH(cf_search,$2)
|
||
|
|
for cf_libdir in $cf_search
|
||
|
|
do
|
||
|
|
AC_MSG_CHECKING(for -l$1 in $cf_libdir)
|
||
|
|
LIBS="-L$cf_libdir -l$1 $cf_save_LIBS"
|
||
|
|
AC_TRY_LINK([$3],[$4],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
eval 'cf_cv_have_lib_'$1'=yes'
|
||
|
|
break],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
LIBS="$cf_save_LIBS"])
|
||
|
|
done
|
||
|
|
])
|
||
|
|
])
|
||
|
|
eval 'cf_found_library=[$]cf_cv_have_lib_'$1
|
||
|
|
ifelse($6,,[
|
||
|
|
if test $cf_found_library = no ; then
|
||
|
|
AC_MSG_ERROR(Cannot link $1 library)
|
||
|
|
fi
|
||
|
|
])
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_FIND_LINKAGE version: 20 updated: 2015/04/18 08:56:57
|
||
|
|
dnl ---------------
|
||
|
|
dnl Find a library (specifically the linkage used in the code fragment),
|
||
|
|
dnl searching for it if it is not already in the library path.
|
||
|
|
dnl See also CF_ADD_SEARCHPATH.
|
||
|
|
dnl
|
||
|
|
dnl Parameters (4-on are optional):
|
||
|
|
dnl $1 = headers for library entrypoint
|
||
|
|
dnl $2 = code fragment for library entrypoint
|
||
|
|
dnl $3 = the library name without the "-l" option or ".so" suffix.
|
||
|
|
dnl $4 = action to perform if successful (default: update CPPFLAGS, etc)
|
||
|
|
dnl $5 = action to perform if not successful
|
||
|
|
dnl $6 = module name, if not the same as the library name
|
||
|
|
dnl $7 = extra libraries
|
||
|
|
dnl
|
||
|
|
dnl Sets these variables:
|
||
|
|
dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
|
||
|
|
dnl $cf_cv_header_path_$3 - include-directory if needed
|
||
|
|
dnl $cf_cv_library_path_$3 - library-directory if needed
|
||
|
|
dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
|
||
|
|
AC_DEFUN([CF_FIND_LINKAGE],[
|
||
|
|
|
||
|
|
# If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
|
||
|
|
# will be set on completion of the AC_TRY_LINK below.
|
||
|
|
cf_cv_header_path_$3=
|
||
|
|
cf_cv_library_path_$3=
|
||
|
|
|
||
|
|
CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
|
||
|
|
|
||
|
|
cf_save_LIBS="$LIBS"
|
||
|
|
|
||
|
|
AC_TRY_LINK([$1],[$2],[
|
||
|
|
cf_cv_find_linkage_$3=yes
|
||
|
|
cf_cv_header_path_$3=/usr/include
|
||
|
|
cf_cv_library_path_$3=/usr/lib
|
||
|
|
],[
|
||
|
|
|
||
|
|
LIBS="-l$3 $7 $cf_save_LIBS"
|
||
|
|
|
||
|
|
AC_TRY_LINK([$1],[$2],[
|
||
|
|
cf_cv_find_linkage_$3=yes
|
||
|
|
cf_cv_header_path_$3=/usr/include
|
||
|
|
cf_cv_library_path_$3=/usr/lib
|
||
|
|
cf_cv_library_file_$3="-l$3"
|
||
|
|
],[
|
||
|
|
cf_cv_find_linkage_$3=no
|
||
|
|
LIBS="$cf_save_LIBS"
|
||
|
|
|
||
|
|
CF_VERBOSE(find linkage for $3 library)
|
||
|
|
CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
|
||
|
|
|
||
|
|
cf_save_CPPFLAGS="$CPPFLAGS"
|
||
|
|
cf_test_CPPFLAGS="$CPPFLAGS"
|
||
|
|
|
||
|
|
CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
|
||
|
|
for cf_cv_header_path_$3 in $cf_search
|
||
|
|
do
|
||
|
|
if test -d $cf_cv_header_path_$3 ; then
|
||
|
|
CF_VERBOSE(... testing $cf_cv_header_path_$3)
|
||
|
|
CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
|
||
|
|
AC_TRY_COMPILE([$1],[$2],[
|
||
|
|
CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
|
||
|
|
cf_cv_find_linkage_$3=maybe
|
||
|
|
cf_test_CPPFLAGS="$CPPFLAGS"
|
||
|
|
break],[
|
||
|
|
CPPFLAGS="$cf_save_CPPFLAGS"
|
||
|
|
])
|
||
|
|
fi
|
||
|
|
done
|
||
|
|
|
||
|
|
if test "$cf_cv_find_linkage_$3" = maybe ; then
|
||
|
|
|
||
|
|
CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
|
||
|
|
|
||
|
|
cf_save_LIBS="$LIBS"
|
||
|
|
cf_save_LDFLAGS="$LDFLAGS"
|
||
|
|
|
||
|
|
ifelse([$6],,,[
|
||
|
|
CPPFLAGS="$cf_test_CPPFLAGS"
|
||
|
|
LIBS="-l$3 $7 $cf_save_LIBS"
|
||
|
|
AC_TRY_LINK([$1],[$2],[
|
||
|
|
CF_VERBOSE(... found $3 library in system)
|
||
|
|
cf_cv_find_linkage_$3=yes])
|
||
|
|
CPPFLAGS="$cf_save_CPPFLAGS"
|
||
|
|
LIBS="$cf_save_LIBS"
|
||
|
|
])
|
||
|
|
|
||
|
|
if test "$cf_cv_find_linkage_$3" != yes ; then
|
||
|
|
CF_LIBRARY_PATH(cf_search,$3)
|
||
|
|
for cf_cv_library_path_$3 in $cf_search
|
||
|
|
do
|
||
|
|
if test -d $cf_cv_library_path_$3 ; then
|
||
|
|
CF_VERBOSE(... testing $cf_cv_library_path_$3)
|
||
|
|
CPPFLAGS="$cf_test_CPPFLAGS"
|
||
|
|
LIBS="-l$3 $7 $cf_save_LIBS"
|
||
|
|
LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
|
||
|
|
AC_TRY_LINK([$1],[$2],[
|
||
|
|
CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
|
||
|
|
cf_cv_find_linkage_$3=yes
|
||
|
|
cf_cv_library_file_$3="-l$3"
|
||
|
|
break],[
|
||
|
|
CPPFLAGS="$cf_save_CPPFLAGS"
|
||
|
|
LIBS="$cf_save_LIBS"
|
||
|
|
LDFLAGS="$cf_save_LDFLAGS"
|
||
|
|
])
|
||
|
|
fi
|
||
|
|
done
|
||
|
|
CPPFLAGS="$cf_save_CPPFLAGS"
|
||
|
|
LDFLAGS="$cf_save_LDFLAGS"
|
||
|
|
fi
|
||
|
|
|
||
|
|
else
|
||
|
|
cf_cv_find_linkage_$3=no
|
||
|
|
fi
|
||
|
|
],$7)
|
||
|
|
])
|
||
|
|
|
||
|
|
LIBS="$cf_save_LIBS"
|
||
|
|
|
||
|
|
if test "$cf_cv_find_linkage_$3" = yes ; then
|
||
|
|
ifelse([$4],,[
|
||
|
|
CF_ADD_INCDIR($cf_cv_header_path_$3)
|
||
|
|
CF_ADD_LIBDIR($cf_cv_library_path_$3)
|
||
|
|
CF_ADD_LIB($3)
|
||
|
|
],[$4])
|
||
|
|
else
|
||
|
|
ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_FORGET_TOOL version: 1 updated: 2013/04/06 18:03:09
|
||
|
|
dnl --------------
|
||
|
|
dnl Forget that we saw the given tool.
|
||
|
|
AC_DEFUN([CF_FORGET_TOOL],[
|
||
|
|
unset ac_cv_prog_ac_ct_$1
|
||
|
|
unset ac_ct_$1
|
||
|
|
unset $1
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_FUNC_LSTAT version: 3 updated: 2012/11/08 20:57:52
|
||
|
|
dnl -------------
|
||
|
|
dnl A conventional existence-check for 'lstat' won't work with the Linux
|
||
|
|
dnl version of gcc 2.7.0, since the symbol is defined only within <sys/stat.h>
|
||
|
|
dnl as an inline function.
|
||
|
|
dnl
|
||
|
|
dnl So much for portability.
|
||
|
|
AC_DEFUN([CF_FUNC_LSTAT],
|
||
|
|
[
|
||
|
|
AC_MSG_CHECKING(for lstat)
|
||
|
|
AC_CACHE_VAL(ac_cv_func_lstat,[
|
||
|
|
AC_TRY_LINK([
|
||
|
|
#include <sys/types.h>
|
||
|
|
#include <sys/stat.h>],
|
||
|
|
[lstat(".", (struct stat *)0)],
|
||
|
|
[ac_cv_func_lstat=yes],
|
||
|
|
[ac_cv_func_lstat=no])
|
||
|
|
])
|
||
|
|
AC_MSG_RESULT($ac_cv_func_lstat )
|
||
|
|
if test $ac_cv_func_lstat = yes; then
|
||
|
|
AC_DEFINE(HAVE_LSTAT,1,[Define to 1 if we have lstat])
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_GCC_ATTRIBUTES version: 17 updated: 2015/04/12 15:39:00
|
||
|
|
dnl -----------------
|
||
|
|
dnl Test for availability of useful gcc __attribute__ directives to quiet
|
||
|
|
dnl compiler warnings. Though useful, not all are supported -- and contrary
|
||
|
|
dnl to documentation, unrecognized directives cause older compilers to barf.
|
||
|
|
AC_DEFUN([CF_GCC_ATTRIBUTES],
|
||
|
|
[
|
||
|
|
if test "$GCC" = yes
|
||
|
|
then
|
||
|
|
cat > conftest.i <<EOF
|
||
|
|
#ifndef GCC_PRINTF
|
||
|
|
#define GCC_PRINTF 0
|
||
|
|
#endif
|
||
|
|
#ifndef GCC_SCANF
|
||
|
|
#define GCC_SCANF 0
|
||
|
|
#endif
|
||
|
|
#ifndef GCC_NORETURN
|
||
|
|
#define GCC_NORETURN /* nothing */
|
||
|
|
#endif
|
||
|
|
#ifndef GCC_UNUSED
|
||
|
|
#define GCC_UNUSED /* nothing */
|
||
|
|
#endif
|
||
|
|
EOF
|
||
|
|
if test "$GCC" = yes
|
||
|
|
then
|
||
|
|
AC_CHECKING([for $CC __attribute__ directives])
|
||
|
|
cat > conftest.$ac_ext <<EOF
|
||
|
|
#line __oline__ "${as_me:-configure}"
|
||
|
|
#include "confdefs.h"
|
||
|
|
#include "conftest.h"
|
||
|
|
#include "conftest.i"
|
||
|
|
#if GCC_PRINTF
|
||
|
|
#define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
|
||
|
|
#else
|
||
|
|
#define GCC_PRINTFLIKE(fmt,var) /*nothing*/
|
||
|
|
#endif
|
||
|
|
#if GCC_SCANF
|
||
|
|
#define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
|
||
|
|
#else
|
||
|
|
#define GCC_SCANFLIKE(fmt,var) /*nothing*/
|
||
|
|
#endif
|
||
|
|
extern void wow(char *,...) GCC_SCANFLIKE(1,2);
|
||
|
|
extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
|
||
|
|
extern void foo(void) GCC_NORETURN;
|
||
|
|
int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
|
||
|
|
EOF
|
||
|
|
cf_printf_attribute=no
|
||
|
|
cf_scanf_attribute=no
|
||
|
|
for cf_attribute in scanf printf unused noreturn
|
||
|
|
do
|
||
|
|
CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
|
||
|
|
cf_directive="__attribute__(($cf_attribute))"
|
||
|
|
echo "checking for $CC $cf_directive" 1>&AC_FD_CC
|
||
|
|
|
||
|
|
case $cf_attribute in
|
||
|
|
(printf)
|
||
|
|
cf_printf_attribute=yes
|
||
|
|
cat >conftest.h <<EOF
|
||
|
|
#define GCC_$cf_ATTRIBUTE 1
|
||
|
|
EOF
|
||
|
|
;;
|
||
|
|
(scanf)
|
||
|
|
cf_scanf_attribute=yes
|
||
|
|
cat >conftest.h <<EOF
|
||
|
|
#define GCC_$cf_ATTRIBUTE 1
|
||
|
|
EOF
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
cat >conftest.h <<EOF
|
||
|
|
#define GCC_$cf_ATTRIBUTE $cf_directive
|
||
|
|
EOF
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
if AC_TRY_EVAL(ac_compile); then
|
||
|
|
test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
|
||
|
|
cat conftest.h >>confdefs.h
|
||
|
|
case $cf_attribute in
|
||
|
|
(noreturn)
|
||
|
|
AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
|
||
|
|
;;
|
||
|
|
(printf)
|
||
|
|
cf_value='/* nothing */'
|
||
|
|
if test "$cf_printf_attribute" != no ; then
|
||
|
|
cf_value='__attribute__((format(printf,fmt,var)))'
|
||
|
|
AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
|
||
|
|
fi
|
||
|
|
AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
|
||
|
|
;;
|
||
|
|
(scanf)
|
||
|
|
cf_value='/* nothing */'
|
||
|
|
if test "$cf_scanf_attribute" != no ; then
|
||
|
|
cf_value='__attribute__((format(scanf,fmt,var)))'
|
||
|
|
AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
|
||
|
|
fi
|
||
|
|
AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
|
||
|
|
;;
|
||
|
|
(unused)
|
||
|
|
AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
fi
|
||
|
|
done
|
||
|
|
else
|
||
|
|
fgrep define conftest.i >>confdefs.h
|
||
|
|
fi
|
||
|
|
rm -rf conftest*
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_GCC_VERSION version: 7 updated: 2012/10/18 06:46:33
|
||
|
|
dnl --------------
|
||
|
|
dnl Find version of gcc
|
||
|
|
AC_DEFUN([CF_GCC_VERSION],[
|
||
|
|
AC_REQUIRE([AC_PROG_CC])
|
||
|
|
GCC_VERSION=none
|
||
|
|
if test "$GCC" = yes ; then
|
||
|
|
AC_MSG_CHECKING(version of $CC)
|
||
|
|
GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC[[^)]]*) //' -e 's/^.*(Debian[[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
|
||
|
|
test -z "$GCC_VERSION" && GCC_VERSION=unknown
|
||
|
|
AC_MSG_RESULT($GCC_VERSION)
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_GCC_WARNINGS version: 32 updated: 2015/04/12 15:39:00
|
||
|
|
dnl ---------------
|
||
|
|
dnl Check if the compiler supports useful warning options. There's a few that
|
||
|
|
dnl we don't use, simply because they're too noisy:
|
||
|
|
dnl
|
||
|
|
dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
|
||
|
|
dnl -Wredundant-decls (system headers make this too noisy)
|
||
|
|
dnl -Wtraditional (combines too many unrelated messages, only a few useful)
|
||
|
|
dnl -Wwrite-strings (too noisy, but should review occasionally). This
|
||
|
|
dnl is enabled for ncurses using "--enable-const".
|
||
|
|
dnl -pedantic
|
||
|
|
dnl
|
||
|
|
dnl Parameter:
|
||
|
|
dnl $1 is an optional list of gcc warning flags that a particular
|
||
|
|
dnl application might want to use, e.g., "no-unused" for
|
||
|
|
dnl -Wno-unused
|
||
|
|
dnl Special:
|
||
|
|
dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
|
||
|
|
dnl
|
||
|
|
AC_DEFUN([CF_GCC_WARNINGS],
|
||
|
|
[
|
||
|
|
AC_REQUIRE([CF_GCC_VERSION])
|
||
|
|
CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
|
||
|
|
CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
|
||
|
|
|
||
|
|
cat > conftest.$ac_ext <<EOF
|
||
|
|
#line __oline__ "${as_me:-configure}"
|
||
|
|
int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
|
||
|
|
EOF
|
||
|
|
|
||
|
|
if test "$INTEL_COMPILER" = yes
|
||
|
|
then
|
||
|
|
# The "-wdXXX" options suppress warnings:
|
||
|
|
# remark #1419: external declaration in primary source file
|
||
|
|
# remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
|
||
|
|
# remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
|
||
|
|
# remark #193: zero used for undefined preprocessing identifier
|
||
|
|
# remark #593: variable "curs_sb_left_arrow" was set but never used
|
||
|
|
# remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
|
||
|
|
# remark #869: parameter "tw" was never referenced
|
||
|
|
# remark #981: operands are evaluated in unspecified order
|
||
|
|
# warning #279: controlling expression is constant
|
||
|
|
|
||
|
|
AC_CHECKING([for $CC warning options])
|
||
|
|
cf_save_CFLAGS="$CFLAGS"
|
||
|
|
EXTRA_CFLAGS="-Wall"
|
||
|
|
for cf_opt in \
|
||
|
|
wd1419 \
|
||
|
|
wd1683 \
|
||
|
|
wd1684 \
|
||
|
|
wd193 \
|
||
|
|
wd593 \
|
||
|
|
wd279 \
|
||
|
|
wd810 \
|
||
|
|
wd869 \
|
||
|
|
wd981
|
||
|
|
do
|
||
|
|
CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
|
||
|
|
if AC_TRY_EVAL(ac_compile); then
|
||
|
|
test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
|
||
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
|
||
|
|
fi
|
||
|
|
done
|
||
|
|
CFLAGS="$cf_save_CFLAGS"
|
||
|
|
|
||
|
|
elif test "$GCC" = yes
|
||
|
|
then
|
||
|
|
AC_CHECKING([for $CC warning options])
|
||
|
|
cf_save_CFLAGS="$CFLAGS"
|
||
|
|
EXTRA_CFLAGS=
|
||
|
|
cf_warn_CONST=""
|
||
|
|
test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
|
||
|
|
cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
|
||
|
|
test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
|
||
|
|
for cf_opt in W Wall \
|
||
|
|
Wbad-function-cast \
|
||
|
|
Wcast-align \
|
||
|
|
Wcast-qual \
|
||
|
|
Wdeclaration-after-statement \
|
||
|
|
Wextra \
|
||
|
|
Winline \
|
||
|
|
Wmissing-declarations \
|
||
|
|
Wmissing-prototypes \
|
||
|
|
Wnested-externs \
|
||
|
|
Wpointer-arith \
|
||
|
|
Wshadow \
|
||
|
|
Wstrict-prototypes \
|
||
|
|
Wundef $cf_gcc_warnings $cf_warn_CONST $1
|
||
|
|
do
|
||
|
|
CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
|
||
|
|
if AC_TRY_EVAL(ac_compile); then
|
||
|
|
test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
|
||
|
|
case $cf_opt in
|
||
|
|
(Wcast-qual)
|
||
|
|
CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
|
||
|
|
;;
|
||
|
|
(Winline)
|
||
|
|
case $GCC_VERSION in
|
||
|
|
([[34]].*)
|
||
|
|
CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
|
||
|
|
continue;;
|
||
|
|
esac
|
||
|
|
;;
|
||
|
|
(Wpointer-arith)
|
||
|
|
case $GCC_VERSION in
|
||
|
|
([[12]].*)
|
||
|
|
CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
|
||
|
|
continue;;
|
||
|
|
esac
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
|
||
|
|
fi
|
||
|
|
done
|
||
|
|
CFLAGS="$cf_save_CFLAGS"
|
||
|
|
fi
|
||
|
|
rm -rf conftest*
|
||
|
|
|
||
|
|
AC_SUBST(EXTRA_CFLAGS)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_GETOPT_HEADER version: 6 updated: 2014/07/22 14:45:54
|
||
|
|
dnl ----------------
|
||
|
|
dnl Check for getopt's variables which are commonly defined in stdlib.h,
|
||
|
|
dnl unistd.h or (nonstandard) in getopt.h
|
||
|
|
AC_DEFUN([CF_GETOPT_HEADER],
|
||
|
|
[
|
||
|
|
AC_HAVE_HEADERS(unistd.h getopt.h)
|
||
|
|
AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
|
||
|
|
cf_cv_getopt_header=none
|
||
|
|
for cf_header in stdio.h stdlib.h unistd.h getopt.h
|
||
|
|
do
|
||
|
|
AC_TRY_COMPILE([
|
||
|
|
#include <$cf_header>],
|
||
|
|
[int x = optind; char *y = optarg],
|
||
|
|
[cf_cv_getopt_header=$cf_header
|
||
|
|
break])
|
||
|
|
done
|
||
|
|
])
|
||
|
|
if test $cf_cv_getopt_header != none ; then
|
||
|
|
AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
|
||
|
|
fi
|
||
|
|
if test $cf_cv_getopt_header = getopt.h ; then
|
||
|
|
AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_GNU_SOURCE version: 7 updated: 2016/08/05 05:15:37
|
||
|
|
dnl -------------
|
||
|
|
dnl Check if we must define _GNU_SOURCE to get a reasonable value for
|
||
|
|
dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
|
||
|
|
dnl (or misfeature) of glibc2, which breaks portability of many applications,
|
||
|
|
dnl since it is interwoven with GNU extensions.
|
||
|
|
dnl
|
||
|
|
dnl Well, yes we could work around it...
|
||
|
|
AC_DEFUN([CF_GNU_SOURCE],
|
||
|
|
[
|
||
|
|
AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
|
||
|
|
AC_TRY_COMPILE([#include <sys/types.h>],[
|
||
|
|
#ifndef _XOPEN_SOURCE
|
||
|
|
make an error
|
||
|
|
#endif],
|
||
|
|
[cf_cv_gnu_source=no],
|
||
|
|
[cf_save="$CPPFLAGS"
|
||
|
|
CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
|
||
|
|
AC_TRY_COMPILE([#include <sys/types.h>],[
|
||
|
|
#ifdef _XOPEN_SOURCE
|
||
|
|
make an error
|
||
|
|
#endif],
|
||
|
|
[cf_cv_gnu_source=no],
|
||
|
|
[cf_cv_gnu_source=yes])
|
||
|
|
CPPFLAGS="$cf_save"
|
||
|
|
])
|
||
|
|
])
|
||
|
|
|
||
|
|
if test "$cf_cv_gnu_source" = yes
|
||
|
|
then
|
||
|
|
AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
|
||
|
|
CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
|
||
|
|
AC_TRY_COMPILE([#include <sys/types.h>],[
|
||
|
|
#ifdef _DEFAULT_SOURCE
|
||
|
|
make an error
|
||
|
|
#endif],
|
||
|
|
[cf_cv_default_source=no],
|
||
|
|
[cf_cv_default_source=yes])
|
||
|
|
])
|
||
|
|
test "$cf_cv_default_source" = yes && CPPFLAGS="$CPPFLAGS -D_DEFAULT_SOURCE"
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_HEADER_PATH version: 13 updated: 2015/04/15 19:08:48
|
||
|
|
dnl --------------
|
||
|
|
dnl Construct a search-list of directories for a nonstandard header-file
|
||
|
|
dnl
|
||
|
|
dnl Parameters
|
||
|
|
dnl $1 = the variable to return as result
|
||
|
|
dnl $2 = the package name
|
||
|
|
AC_DEFUN([CF_HEADER_PATH],
|
||
|
|
[
|
||
|
|
$1=
|
||
|
|
|
||
|
|
# collect the current set of include-directories from compiler flags
|
||
|
|
cf_header_path_list=""
|
||
|
|
if test -n "${CFLAGS}${CPPFLAGS}" ; then
|
||
|
|
for cf_header_path in $CPPFLAGS $CFLAGS
|
||
|
|
do
|
||
|
|
case $cf_header_path in
|
||
|
|
(-I*)
|
||
|
|
cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
|
||
|
|
CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
|
||
|
|
cf_header_path_list="$cf_header_path_list [$]$1"
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
done
|
||
|
|
fi
|
||
|
|
|
||
|
|
# add the variations for the package we are looking for
|
||
|
|
CF_SUBDIR_PATH($1,$2,include)
|
||
|
|
|
||
|
|
test "$includedir" != NONE && \
|
||
|
|
test "$includedir" != "/usr/include" && \
|
||
|
|
test -d "$includedir" && {
|
||
|
|
test -d $includedir && $1="[$]$1 $includedir"
|
||
|
|
test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
|
||
|
|
}
|
||
|
|
|
||
|
|
test "$oldincludedir" != NONE && \
|
||
|
|
test "$oldincludedir" != "/usr/include" && \
|
||
|
|
test -d "$oldincludedir" && {
|
||
|
|
test -d $oldincludedir && $1="[$]$1 $oldincludedir"
|
||
|
|
test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
|
||
|
|
}
|
||
|
|
|
||
|
|
$1="[$]$1 $cf_header_path_list"
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_INTEL_COMPILER version: 7 updated: 2015/04/12 15:39:00
|
||
|
|
dnl -----------------
|
||
|
|
dnl Check if the given compiler is really the Intel compiler for Linux. It
|
||
|
|
dnl tries to imitate gcc, but does not return an error when it finds a mismatch
|
||
|
|
dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
|
||
|
|
dnl
|
||
|
|
dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
|
||
|
|
dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
|
||
|
|
dnl the wrappers for gcc and g++ warnings.
|
||
|
|
dnl
|
||
|
|
dnl $1 = GCC (default) or GXX
|
||
|
|
dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
|
||
|
|
dnl $3 = CFLAGS (default) or CXXFLAGS
|
||
|
|
AC_DEFUN([CF_INTEL_COMPILER],[
|
||
|
|
AC_REQUIRE([AC_CANONICAL_HOST])
|
||
|
|
ifelse([$2],,INTEL_COMPILER,[$2])=no
|
||
|
|
|
||
|
|
if test "$ifelse([$1],,[$1],GCC)" = yes ; then
|
||
|
|
case $host_os in
|
||
|
|
(linux*|gnu*)
|
||
|
|
AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
|
||
|
|
cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
|
||
|
|
ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
|
||
|
|
AC_TRY_COMPILE([],[
|
||
|
|
#ifdef __INTEL_COMPILER
|
||
|
|
#else
|
||
|
|
make an error
|
||
|
|
#endif
|
||
|
|
],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
|
||
|
|
cf_save_CFLAGS="$cf_save_CFLAGS -we147"
|
||
|
|
],[])
|
||
|
|
ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
|
||
|
|
AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_LD_RPATH_OPT version: 7 updated: 2016/02/20 18:01:19
|
||
|
|
dnl ---------------
|
||
|
|
dnl For the given system and compiler, find the compiler flags to pass to the
|
||
|
|
dnl loader to use the "rpath" feature.
|
||
|
|
AC_DEFUN([CF_LD_RPATH_OPT],
|
||
|
|
[
|
||
|
|
AC_REQUIRE([CF_CHECK_CACHE])
|
||
|
|
|
||
|
|
LD_RPATH_OPT=
|
||
|
|
AC_MSG_CHECKING(for an rpath option)
|
||
|
|
case $cf_cv_system_name in
|
||
|
|
(irix*)
|
||
|
|
if test "$GCC" = yes; then
|
||
|
|
LD_RPATH_OPT="-Wl,-rpath,"
|
||
|
|
else
|
||
|
|
LD_RPATH_OPT="-rpath "
|
||
|
|
fi
|
||
|
|
;;
|
||
|
|
(linux*|gnu*|k*bsd*-gnu|freebsd*)
|
||
|
|
LD_RPATH_OPT="-Wl,-rpath,"
|
||
|
|
;;
|
||
|
|
(openbsd[[2-9]].*|mirbsd*)
|
||
|
|
LD_RPATH_OPT="-Wl,-rpath,"
|
||
|
|
;;
|
||
|
|
(dragonfly*)
|
||
|
|
LD_RPATH_OPT="-rpath "
|
||
|
|
;;
|
||
|
|
(netbsd*)
|
||
|
|
LD_RPATH_OPT="-Wl,-rpath,"
|
||
|
|
;;
|
||
|
|
(osf*|mls+*)
|
||
|
|
LD_RPATH_OPT="-rpath "
|
||
|
|
;;
|
||
|
|
(solaris2*)
|
||
|
|
LD_RPATH_OPT="-R"
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
AC_MSG_RESULT($LD_RPATH_OPT)
|
||
|
|
|
||
|
|
case "x$LD_RPATH_OPT" in
|
||
|
|
(x-R*)
|
||
|
|
AC_MSG_CHECKING(if we need a space after rpath option)
|
||
|
|
cf_save_LIBS="$LIBS"
|
||
|
|
CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
|
||
|
|
AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
|
||
|
|
LIBS="$cf_save_LIBS"
|
||
|
|
AC_MSG_RESULT($cf_rpath_space)
|
||
|
|
test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_LIBRARY_PATH version: 10 updated: 2015/04/15 19:08:48
|
||
|
|
dnl ---------------
|
||
|
|
dnl Construct a search-list of directories for a nonstandard library-file
|
||
|
|
dnl
|
||
|
|
dnl Parameters
|
||
|
|
dnl $1 = the variable to return as result
|
||
|
|
dnl $2 = the package name
|
||
|
|
AC_DEFUN([CF_LIBRARY_PATH],
|
||
|
|
[
|
||
|
|
$1=
|
||
|
|
cf_library_path_list=""
|
||
|
|
if test -n "${LDFLAGS}${LIBS}" ; then
|
||
|
|
for cf_library_path in $LDFLAGS $LIBS
|
||
|
|
do
|
||
|
|
case $cf_library_path in
|
||
|
|
(-L*)
|
||
|
|
cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
|
||
|
|
CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
|
||
|
|
cf_library_path_list="$cf_library_path_list [$]$1"
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
done
|
||
|
|
fi
|
||
|
|
|
||
|
|
CF_SUBDIR_PATH($1,$2,lib)
|
||
|
|
|
||
|
|
$1="$cf_library_path_list [$]$1"
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09
|
||
|
|
dnl ------------------
|
||
|
|
AC_DEFUN([CF_LIBTOOL_VERSION],[
|
||
|
|
if test -n "$LIBTOOL" && test "$LIBTOOL" != none
|
||
|
|
then
|
||
|
|
cf_cv_libtool_version=`$LIBTOOL --version 2>&1 | sed -e '/^$/d' |sed -e '2,$d' -e 's/([[^)]]*)//g' -e 's/^[[^1-9]]*//' -e 's/[[^0-9.]].*//'`
|
||
|
|
else
|
||
|
|
cf_cv_libtool_version=
|
||
|
|
fi
|
||
|
|
test -z "$cf_cv_libtool_version" && unset cf_cv_libtool_version
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_LIB_PREFIX version: 12 updated: 2015/10/17 19:03:33
|
||
|
|
dnl -------------
|
||
|
|
dnl Compute the library-prefix for the given host system
|
||
|
|
dnl $1 = variable to set
|
||
|
|
define([CF_LIB_PREFIX],
|
||
|
|
[
|
||
|
|
case $cf_cv_system_name in
|
||
|
|
(OS/2*|os2*)
|
||
|
|
if test "$DFT_LWR_MODEL" = libtool; then
|
||
|
|
LIB_PREFIX='lib'
|
||
|
|
else
|
||
|
|
LIB_PREFIX=''
|
||
|
|
fi
|
||
|
|
;;
|
||
|
|
(*) LIB_PREFIX='lib'
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
ifelse($1,,,[$1=$LIB_PREFIX])
|
||
|
|
AC_SUBST(LIB_PREFIX)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_LIB_SUFFIX version: 25 updated: 2015/04/17 21:13:04
|
||
|
|
dnl -------------
|
||
|
|
dnl Compute the library file-suffix from the given model name
|
||
|
|
dnl $1 = model name
|
||
|
|
dnl $2 = variable to set (the nominal library suffix)
|
||
|
|
dnl $3 = dependency variable to set (actual filename)
|
||
|
|
dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
|
||
|
|
AC_DEFUN([CF_LIB_SUFFIX],
|
||
|
|
[
|
||
|
|
case X$1 in
|
||
|
|
(Xlibtool)
|
||
|
|
$2='.la'
|
||
|
|
$3=[$]$2
|
||
|
|
;;
|
||
|
|
(Xdebug)
|
||
|
|
$2='_g.a'
|
||
|
|
$3=[$]$2
|
||
|
|
;;
|
||
|
|
(Xprofile)
|
||
|
|
$2='_p.a'
|
||
|
|
$3=[$]$2
|
||
|
|
;;
|
||
|
|
(Xshared)
|
||
|
|
case $cf_cv_system_name in
|
||
|
|
(aix[[5-7]]*)
|
||
|
|
$2='.so'
|
||
|
|
$3=[$]$2
|
||
|
|
;;
|
||
|
|
(cygwin*|msys*|mingw*)
|
||
|
|
$2='.dll'
|
||
|
|
$3='.dll.a'
|
||
|
|
;;
|
||
|
|
(darwin*)
|
||
|
|
$2='.dylib'
|
||
|
|
$3=[$]$2
|
||
|
|
;;
|
||
|
|
(hpux*)
|
||
|
|
case $target in
|
||
|
|
(ia64*)
|
||
|
|
$2='.so'
|
||
|
|
$3=[$]$2
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
$2='.sl'
|
||
|
|
$3=[$]$2
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
$2='.so'
|
||
|
|
$3=[$]$2
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
$2='.a'
|
||
|
|
$3=[$]$2
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
if test -n "${LIB_SUFFIX}${EXTRA_SUFFIX}"
|
||
|
|
then
|
||
|
|
$2="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$2}"
|
||
|
|
$3="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$3}"
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_LOCALE version: 5 updated: 2012/10/06 11:17:15
|
||
|
|
dnl ---------
|
||
|
|
dnl Check if we have setlocale() and its header, <locale.h>
|
||
|
|
dnl The optional parameter $1 tells what to do if we do have locale support.
|
||
|
|
AC_DEFUN([CF_LOCALE],
|
||
|
|
[
|
||
|
|
AC_MSG_CHECKING(for setlocale())
|
||
|
|
AC_CACHE_VAL(cf_cv_locale,[
|
||
|
|
AC_TRY_LINK([#include <locale.h>],
|
||
|
|
[setlocale(LC_ALL, "")],
|
||
|
|
[cf_cv_locale=yes],
|
||
|
|
[cf_cv_locale=no])
|
||
|
|
])
|
||
|
|
AC_MSG_RESULT($cf_cv_locale)
|
||
|
|
test $cf_cv_locale = yes && { ifelse($1,,AC_DEFINE(LOCALE,1,[Define to 1 if we have locale support]),[$1]) }
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_MAKEFLAGS version: 17 updated: 2015/08/05 20:44:28
|
||
|
|
dnl ------------
|
||
|
|
dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
|
||
|
|
dnl options to lower-levels. It's very useful for "make -n" -- if we have it.
|
||
|
|
dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
|
||
|
|
dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
|
||
|
|
AC_DEFUN([CF_MAKEFLAGS],
|
||
|
|
[
|
||
|
|
AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
|
||
|
|
cf_cv_makeflags=''
|
||
|
|
for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
|
||
|
|
do
|
||
|
|
cat >cf_makeflags.tmp <<CF_EOF
|
||
|
|
SHELL = $SHELL
|
||
|
|
all :
|
||
|
|
@ echo '.$cf_option'
|
||
|
|
CF_EOF
|
||
|
|
cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | fgrep -v "ing directory" | sed -e 's,[[ ]]*$,,'`
|
||
|
|
case "$cf_result" in
|
||
|
|
(.*k|.*kw)
|
||
|
|
cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
|
||
|
|
case "$cf_result" in
|
||
|
|
(.*CC=*) cf_cv_makeflags=
|
||
|
|
;;
|
||
|
|
(*) cf_cv_makeflags=$cf_option
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
break
|
||
|
|
;;
|
||
|
|
(.-) ;;
|
||
|
|
(*) echo "given option \"$cf_option\", no match \"$cf_result\""
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
done
|
||
|
|
rm -f cf_makeflags.tmp
|
||
|
|
])
|
||
|
|
|
||
|
|
AC_SUBST(cf_cv_makeflags)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
|
||
|
|
dnl ------------
|
||
|
|
dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have
|
||
|
|
dnl a monocase filesystem.
|
||
|
|
AC_DEFUN([CF_MAKE_TAGS],[
|
||
|
|
AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
|
||
|
|
|
||
|
|
AC_CHECK_PROGS(CTAGS, exctags ctags)
|
||
|
|
AC_CHECK_PROGS(ETAGS, exetags etags)
|
||
|
|
|
||
|
|
AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
|
||
|
|
|
||
|
|
if test "$cf_cv_mixedcase" = yes ; then
|
||
|
|
AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
|
||
|
|
else
|
||
|
|
MAKE_UPPER_TAGS=no
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$MAKE_UPPER_TAGS" = yes ; then
|
||
|
|
MAKE_UPPER_TAGS=
|
||
|
|
else
|
||
|
|
MAKE_UPPER_TAGS="#"
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$MAKE_LOWER_TAGS" = yes ; then
|
||
|
|
MAKE_LOWER_TAGS=
|
||
|
|
else
|
||
|
|
MAKE_LOWER_TAGS="#"
|
||
|
|
fi
|
||
|
|
|
||
|
|
AC_SUBST(CTAGS)
|
||
|
|
AC_SUBST(ETAGS)
|
||
|
|
|
||
|
|
AC_SUBST(MAKE_UPPER_TAGS)
|
||
|
|
AC_SUBST(MAKE_LOWER_TAGS)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_MIXEDCASE_FILENAMES version: 7 updated: 2015/04/12 15:39:00
|
||
|
|
dnl ----------------------
|
||
|
|
dnl Check if the file-system supports mixed-case filenames. If we're able to
|
||
|
|
dnl create a lowercase name and see it as uppercase, it doesn't support that.
|
||
|
|
AC_DEFUN([CF_MIXEDCASE_FILENAMES],
|
||
|
|
[
|
||
|
|
AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
|
||
|
|
if test "$cross_compiling" = yes ; then
|
||
|
|
case $target_alias in
|
||
|
|
(*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*)
|
||
|
|
cf_cv_mixedcase=no
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
cf_cv_mixedcase=yes
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
else
|
||
|
|
rm -f conftest CONFTEST
|
||
|
|
echo test >conftest
|
||
|
|
if test -f CONFTEST ; then
|
||
|
|
cf_cv_mixedcase=no
|
||
|
|
else
|
||
|
|
cf_cv_mixedcase=yes
|
||
|
|
fi
|
||
|
|
rm -f conftest CONFTEST
|
||
|
|
fi
|
||
|
|
])
|
||
|
|
test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
|
||
|
|
dnl ----------
|
||
|
|
dnl Write a debug message to config.log, along with the line number in the
|
||
|
|
dnl configure script.
|
||
|
|
AC_DEFUN([CF_MSG_LOG],[
|
||
|
|
echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_NCURSES_CC_CHECK version: 4 updated: 2007/07/29 10:39:05
|
||
|
|
dnl -------------------
|
||
|
|
dnl Check if we can compile with ncurses' header file
|
||
|
|
dnl $1 is the cache variable to set
|
||
|
|
dnl $2 is the header-file to include
|
||
|
|
dnl $3 is the root name (ncurses or ncursesw)
|
||
|
|
AC_DEFUN([CF_NCURSES_CC_CHECK],[
|
||
|
|
AC_TRY_COMPILE([
|
||
|
|
]ifelse($3,ncursesw,[
|
||
|
|
#define _XOPEN_SOURCE_EXTENDED
|
||
|
|
#undef HAVE_LIBUTF8_H /* in case we used CF_UTF8_LIB */
|
||
|
|
#define HAVE_LIBUTF8_H /* to force ncurses' header file to use cchar_t */
|
||
|
|
])[
|
||
|
|
#include <$2>],[
|
||
|
|
#ifdef NCURSES_VERSION
|
||
|
|
]ifelse($3,ncursesw,[
|
||
|
|
#ifndef WACS_BSSB
|
||
|
|
make an error
|
||
|
|
#endif
|
||
|
|
])[
|
||
|
|
printf("%s\n", NCURSES_VERSION);
|
||
|
|
#else
|
||
|
|
#ifdef __NCURSES_H
|
||
|
|
printf("old\n");
|
||
|
|
#else
|
||
|
|
make an error
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
]
|
||
|
|
,[$1=$2]
|
||
|
|
,[$1=no])
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_NCURSES_CONFIG version: 17 updated: 2015/07/07 04:22:07
|
||
|
|
dnl -----------------
|
||
|
|
dnl Tie together the configure-script macros for ncurses, preferring these in
|
||
|
|
dnl order:
|
||
|
|
dnl a) ".pc" files for pkg-config, using $NCURSES_CONFIG_PKG
|
||
|
|
dnl b) the "-config" script from ncurses, using $NCURSES_CONFIG
|
||
|
|
dnl c) just plain libraries
|
||
|
|
dnl
|
||
|
|
dnl $1 is the root library name (default: "ncurses")
|
||
|
|
AC_DEFUN([CF_NCURSES_CONFIG],[
|
||
|
|
AC_REQUIRE([CF_PKG_CONFIG])
|
||
|
|
cf_ncuconfig_root=ifelse($1,,ncurses,$1)
|
||
|
|
cf_have_ncuconfig=no
|
||
|
|
|
||
|
|
if test "x${PKG_CONFIG:=none}" != xnone; then
|
||
|
|
AC_MSG_CHECKING(pkg-config for $cf_ncuconfig_root)
|
||
|
|
if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
|
||
|
|
AC_MSG_RESULT(yes)
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(if the $cf_ncuconfig_root package files work)
|
||
|
|
cf_have_ncuconfig=unknown
|
||
|
|
|
||
|
|
cf_save_CPPFLAGS="$CPPFLAGS"
|
||
|
|
cf_save_LIBS="$LIBS"
|
||
|
|
|
||
|
|
CPPFLAGS="$CPPFLAGS `$PKG_CONFIG --cflags $cf_ncuconfig_root`"
|
||
|
|
CF_ADD_LIBS(`$PKG_CONFIG --libs $cf_ncuconfig_root`)
|
||
|
|
|
||
|
|
AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
|
||
|
|
[initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
|
||
|
|
[AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
|
||
|
|
int main(void)
|
||
|
|
{ char *xx = curses_version(); return (xx == 0); }],
|
||
|
|
[cf_have_ncuconfig=yes],
|
||
|
|
[cf_have_ncuconfig=no],
|
||
|
|
[cf_have_ncuconfig=maybe])],
|
||
|
|
[cf_have_ncuconfig=no])
|
||
|
|
AC_MSG_RESULT($cf_have_ncuconfig)
|
||
|
|
test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
|
||
|
|
if test "$cf_have_ncuconfig" != "yes"
|
||
|
|
then
|
||
|
|
CPPFLAGS="$cf_save_CPPFLAGS"
|
||
|
|
LIBS="$cf_save_LIBS"
|
||
|
|
NCURSES_CONFIG_PKG=none
|
||
|
|
else
|
||
|
|
AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
|
||
|
|
NCURSES_CONFIG_PKG=$cf_ncuconfig_root
|
||
|
|
fi
|
||
|
|
|
||
|
|
else
|
||
|
|
AC_MSG_RESULT(no)
|
||
|
|
NCURSES_CONFIG_PKG=none
|
||
|
|
fi
|
||
|
|
else
|
||
|
|
NCURSES_CONFIG_PKG=none
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "x$cf_have_ncuconfig" = "xno"; then
|
||
|
|
echo "Looking for ${cf_ncuconfig_root}-config"
|
||
|
|
|
||
|
|
CF_ACVERSION_CHECK(2.52,
|
||
|
|
[AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncuconfig_root}-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
|
||
|
|
[AC_PATH_PROGS(NCURSES_CONFIG, ${cf_ncuconfig_root}-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
|
||
|
|
|
||
|
|
if test "$NCURSES_CONFIG" != none ; then
|
||
|
|
|
||
|
|
CPPFLAGS="$CPPFLAGS `$NCURSES_CONFIG --cflags`"
|
||
|
|
CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
|
||
|
|
|
||
|
|
# even with config script, some packages use no-override for curses.h
|
||
|
|
CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
|
||
|
|
|
||
|
|
dnl like CF_NCURSES_CPPFLAGS
|
||
|
|
AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
|
||
|
|
|
||
|
|
dnl like CF_NCURSES_LIBS
|
||
|
|
CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
|
||
|
|
AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
|
||
|
|
|
||
|
|
dnl like CF_NCURSES_VERSION
|
||
|
|
cf_cv_ncurses_version=`$NCURSES_CONFIG --version`
|
||
|
|
|
||
|
|
else
|
||
|
|
|
||
|
|
CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
|
||
|
|
CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
|
||
|
|
|
||
|
|
fi
|
||
|
|
else
|
||
|
|
NCURSES_CONFIG=none
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_NCURSES_CPPFLAGS version: 21 updated: 2012/10/06 08:57:51
|
||
|
|
dnl -------------------
|
||
|
|
dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
|
||
|
|
dnl the CPPFLAGS variable so we can include its header.
|
||
|
|
dnl
|
||
|
|
dnl The header files may be installed as either curses.h, or ncurses.h (would
|
||
|
|
dnl be obsolete, except that some packagers prefer this name to distinguish it
|
||
|
|
dnl from a "native" curses implementation). If not installed for overwrite,
|
||
|
|
dnl the curses.h file would be in an ncurses subdirectory (e.g.,
|
||
|
|
dnl /usr/include/ncurses), but someone may have installed overwriting the
|
||
|
|
dnl vendor's curses. Only very old versions (pre-1.9.2d, the first autoconf'd
|
||
|
|
dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
|
||
|
|
dnl the header.
|
||
|
|
dnl
|
||
|
|
dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
|
||
|
|
dnl is already in the include-path, don't even bother with this, since we cannot
|
||
|
|
dnl easily determine which file it is. In this case, it has to be <curses.h>.
|
||
|
|
dnl
|
||
|
|
dnl The optional parameter gives the root name of the library, in case it is
|
||
|
|
dnl not installed as the default curses library. That is how the
|
||
|
|
dnl wide-character version of ncurses is installed.
|
||
|
|
AC_DEFUN([CF_NCURSES_CPPFLAGS],
|
||
|
|
[AC_REQUIRE([CF_WITH_CURSES_DIR])
|
||
|
|
|
||
|
|
AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
|
||
|
|
cf_ncuhdr_root=ifelse($1,,ncurses,$1)
|
||
|
|
|
||
|
|
test -n "$cf_cv_curses_dir" && \
|
||
|
|
test "$cf_cv_curses_dir" != "no" && { \
|
||
|
|
CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
|
||
|
|
}
|
||
|
|
|
||
|
|
AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
|
||
|
|
cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
|
||
|
|
( test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw ) && cf_header_list="$cf_header_list curses.h ncurses.h"
|
||
|
|
for cf_header in $cf_header_list
|
||
|
|
do
|
||
|
|
CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
|
||
|
|
test "$cf_cv_ncurses_h" != no && break
|
||
|
|
done
|
||
|
|
])
|
||
|
|
|
||
|
|
CF_NCURSES_HEADER
|
||
|
|
CF_TERM_HEADER
|
||
|
|
|
||
|
|
# some applications need this, but should check for NCURSES_VERSION
|
||
|
|
AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
|
||
|
|
|
||
|
|
CF_NCURSES_VERSION
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_NCURSES_HEADER version: 4 updated: 2015/04/15 19:08:48
|
||
|
|
dnl -----------------
|
||
|
|
dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
|
||
|
|
dnl variations of ncurses' installs.
|
||
|
|
dnl
|
||
|
|
dnl See also CF_CURSES_HEADER, which sets the same cache variable.
|
||
|
|
AC_DEFUN([CF_NCURSES_HEADER],[
|
||
|
|
|
||
|
|
if test "$cf_cv_ncurses_h" != no ; then
|
||
|
|
cf_cv_ncurses_header=$cf_cv_ncurses_h
|
||
|
|
else
|
||
|
|
|
||
|
|
AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
|
||
|
|
test -n "$verbose" && echo
|
||
|
|
CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
|
||
|
|
test -n "$verbose" && echo search path $cf_search
|
||
|
|
cf_save2_CPPFLAGS="$CPPFLAGS"
|
||
|
|
for cf_incdir in $cf_search
|
||
|
|
do
|
||
|
|
CF_ADD_INCDIR($cf_incdir)
|
||
|
|
for cf_header in \
|
||
|
|
ncurses.h \
|
||
|
|
curses.h
|
||
|
|
do
|
||
|
|
CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
|
||
|
|
if test "$cf_cv_ncurses_h2" != no ; then
|
||
|
|
cf_cv_ncurses_h2=$cf_incdir/$cf_header
|
||
|
|
test -n "$verbose" && echo $ac_n " ... found $ac_c" 1>&AC_FD_MSG
|
||
|
|
break
|
||
|
|
fi
|
||
|
|
test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
|
||
|
|
done
|
||
|
|
CPPFLAGS="$cf_save2_CPPFLAGS"
|
||
|
|
test "$cf_cv_ncurses_h2" != no && break
|
||
|
|
done
|
||
|
|
test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
|
||
|
|
])
|
||
|
|
|
||
|
|
CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
|
||
|
|
cf_cv_ncurses_header=`basename $cf_cv_ncurses_h2`
|
||
|
|
if test `basename $cf_1st_incdir` = $cf_ncuhdr_root ; then
|
||
|
|
cf_cv_ncurses_header=$cf_ncuhdr_root/$cf_cv_ncurses_header
|
||
|
|
fi
|
||
|
|
CF_ADD_INCDIR($cf_1st_incdir)
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
# Set definitions to allow ifdef'ing for ncurses.h
|
||
|
|
|
||
|
|
case $cf_cv_ncurses_header in
|
||
|
|
(*ncurses.h)
|
||
|
|
AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
case $cf_cv_ncurses_header in
|
||
|
|
(ncurses/curses.h|ncurses/ncurses.h)
|
||
|
|
AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
|
||
|
|
;;
|
||
|
|
(ncursesw/curses.h|ncursesw/ncurses.h)
|
||
|
|
AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_NCURSES_LIBS version: 17 updated: 2015/04/15 19:08:48
|
||
|
|
dnl ---------------
|
||
|
|
dnl Look for the ncurses library. This is a little complicated on Linux,
|
||
|
|
dnl because it may be linked with the gpm (general purpose mouse) library.
|
||
|
|
dnl Some distributions have gpm linked with (bsd) curses, which makes it
|
||
|
|
dnl unusable with ncurses. However, we don't want to link with gpm unless
|
||
|
|
dnl ncurses has a dependency, since gpm is normally set up as a shared library,
|
||
|
|
dnl and the linker will record a dependency.
|
||
|
|
dnl
|
||
|
|
dnl The optional parameter gives the root name of the library, in case it is
|
||
|
|
dnl not installed as the default curses library. That is how the
|
||
|
|
dnl wide-character version of ncurses is installed.
|
||
|
|
AC_DEFUN([CF_NCURSES_LIBS],
|
||
|
|
[AC_REQUIRE([CF_NCURSES_CPPFLAGS])
|
||
|
|
|
||
|
|
cf_nculib_root=ifelse($1,,ncurses,$1)
|
||
|
|
# This works, except for the special case where we find gpm, but
|
||
|
|
# ncurses is in a nonstandard location via $LIBS, and we really want
|
||
|
|
# to link gpm.
|
||
|
|
cf_ncurses_LIBS=""
|
||
|
|
cf_ncurses_SAVE="$LIBS"
|
||
|
|
AC_CHECK_LIB(gpm,Gpm_Open,
|
||
|
|
[AC_CHECK_LIB(gpm,initscr,
|
||
|
|
[LIBS="$cf_ncurses_SAVE"],
|
||
|
|
[cf_ncurses_LIBS="-lgpm"])])
|
||
|
|
|
||
|
|
case $host_os in
|
||
|
|
(freebsd*)
|
||
|
|
# This is only necessary if you are linking against an obsolete
|
||
|
|
# version of ncurses (but it should do no harm, since it's static).
|
||
|
|
if test "$cf_nculib_root" = ncurses ; then
|
||
|
|
AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
|
||
|
|
fi
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
CF_ADD_LIBS($cf_ncurses_LIBS)
|
||
|
|
|
||
|
|
if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
|
||
|
|
then
|
||
|
|
CF_ADD_LIBS(-l$cf_nculib_root)
|
||
|
|
else
|
||
|
|
CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
|
||
|
|
[#include <${cf_cv_ncurses_header:-curses.h}>],
|
||
|
|
[initscr()],
|
||
|
|
initscr)
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test -n "$cf_ncurses_LIBS" ; then
|
||
|
|
AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
|
||
|
|
cf_ncurses_SAVE="$LIBS"
|
||
|
|
for p in $cf_ncurses_LIBS ; do
|
||
|
|
q=`echo $LIBS | sed -e "s%$p %%" -e "s%$p$%%"`
|
||
|
|
if test "$q" != "$LIBS" ; then
|
||
|
|
LIBS="$q"
|
||
|
|
fi
|
||
|
|
done
|
||
|
|
AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
|
||
|
|
[initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
|
||
|
|
[AC_MSG_RESULT(yes)],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
LIBS="$cf_ncurses_SAVE"])
|
||
|
|
fi
|
||
|
|
|
||
|
|
CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
|
||
|
|
AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_NCURSES_PTHREADS version: 2 updated: 2016/04/22 05:07:41
|
||
|
|
dnl -------------------
|
||
|
|
dnl Use this followup check to ensure that we link with pthreads if ncurses
|
||
|
|
dnl uses it.
|
||
|
|
AC_DEFUN([CF_NCURSES_PTHREADS],[
|
||
|
|
: ${cf_nculib_root:=ifelse($1,,ncurses,$1)}
|
||
|
|
AC_CHECK_LIB($cf_nculib_root,_nc_init_pthreads,
|
||
|
|
cf_cv_ncurses_pthreads=yes,
|
||
|
|
cf_cv_ncurses_pthreads=no)
|
||
|
|
if test "$cf_cv_ncurses_pthreads" = yes
|
||
|
|
then
|
||
|
|
CF_ADD_LIBS(-lpthread)
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_NCURSES_VERSION version: 14 updated: 2012/10/06 08:57:51
|
||
|
|
dnl ------------------
|
||
|
|
dnl Check for the version of ncurses, to aid in reporting bugs, etc.
|
||
|
|
dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS. We don't use
|
||
|
|
dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
|
||
|
|
AC_DEFUN([CF_NCURSES_VERSION],
|
||
|
|
[
|
||
|
|
AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
|
||
|
|
AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
|
||
|
|
cf_cv_ncurses_version=no
|
||
|
|
cf_tempfile=out$$
|
||
|
|
rm -f $cf_tempfile
|
||
|
|
AC_TRY_RUN([
|
||
|
|
#include <${cf_cv_ncurses_header:-curses.h}>
|
||
|
|
#include <stdio.h>
|
||
|
|
int main()
|
||
|
|
{
|
||
|
|
FILE *fp = fopen("$cf_tempfile", "w");
|
||
|
|
#ifdef NCURSES_VERSION
|
||
|
|
# ifdef NCURSES_VERSION_PATCH
|
||
|
|
fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
|
||
|
|
# else
|
||
|
|
fprintf(fp, "%s\n", NCURSES_VERSION);
|
||
|
|
# endif
|
||
|
|
#else
|
||
|
|
# ifdef __NCURSES_H
|
||
|
|
fprintf(fp, "old\n");
|
||
|
|
# else
|
||
|
|
make an error
|
||
|
|
# endif
|
||
|
|
#endif
|
||
|
|
${cf_cv_main_return:-return}(0);
|
||
|
|
}],[
|
||
|
|
cf_cv_ncurses_version=`cat $cf_tempfile`],,[
|
||
|
|
|
||
|
|
# This will not work if the preprocessor splits the line after the
|
||
|
|
# Autoconf token. The 'unproto' program does that.
|
||
|
|
cat > conftest.$ac_ext <<EOF
|
||
|
|
#include <${cf_cv_ncurses_header:-curses.h}>
|
||
|
|
#undef Autoconf
|
||
|
|
#ifdef NCURSES_VERSION
|
||
|
|
Autoconf NCURSES_VERSION
|
||
|
|
#else
|
||
|
|
#ifdef __NCURSES_H
|
||
|
|
Autoconf "old"
|
||
|
|
#endif
|
||
|
|
;
|
||
|
|
#endif
|
||
|
|
EOF
|
||
|
|
cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
|
||
|
|
AC_TRY_EVAL(cf_try)
|
||
|
|
if test -f conftest.out ; then
|
||
|
|
cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%'`
|
||
|
|
test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
|
||
|
|
rm -f conftest.out
|
||
|
|
fi
|
||
|
|
])
|
||
|
|
rm -f $cf_tempfile
|
||
|
|
])
|
||
|
|
test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_NO_LEAKS_OPTION version: 6 updated: 2015/04/12 15:39:00
|
||
|
|
dnl ------------------
|
||
|
|
dnl see CF_WITH_NO_LEAKS
|
||
|
|
AC_DEFUN([CF_NO_LEAKS_OPTION],[
|
||
|
|
AC_MSG_CHECKING(if you want to use $1 for testing)
|
||
|
|
AC_ARG_WITH($1,
|
||
|
|
[$2],
|
||
|
|
[AC_DEFINE_UNQUOTED($3,1,"Define to 1 if you want to use $1 for testing.")ifelse([$4],,[
|
||
|
|
$4
|
||
|
|
])
|
||
|
|
: ${with_cflags:=-g}
|
||
|
|
: ${with_no_leaks:=yes}
|
||
|
|
with_$1=yes],
|
||
|
|
[with_$1=])
|
||
|
|
AC_MSG_RESULT(${with_$1:-no})
|
||
|
|
|
||
|
|
case .$with_cflags in
|
||
|
|
(.*-g*)
|
||
|
|
case .$CFLAGS in
|
||
|
|
(.*-g*)
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
CF_ADD_CFLAGS([-g])
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_NUMBER_SYNTAX version: 2 updated: 2015/04/17 21:13:04
|
||
|
|
dnl ----------------
|
||
|
|
dnl Check if the given variable is a number. If not, report an error.
|
||
|
|
dnl $1 is the variable
|
||
|
|
dnl $2 is the message
|
||
|
|
AC_DEFUN([CF_NUMBER_SYNTAX],[
|
||
|
|
if test -n "$1" ; then
|
||
|
|
case $1 in
|
||
|
|
([[0-9]]*)
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
AC_MSG_ERROR($2 is not a number: $1)
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
else
|
||
|
|
AC_MSG_ERROR($2 value is empty)
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_PATH_SYNTAX version: 16 updated: 2015/04/18 08:56:57
|
||
|
|
dnl --------------
|
||
|
|
dnl Check the argument to see that it looks like a pathname. Rewrite it if it
|
||
|
|
dnl begins with one of the prefix/exec_prefix variables, and then again if the
|
||
|
|
dnl result begins with 'NONE'. This is necessary to work around autoconf's
|
||
|
|
dnl delayed evaluation of those symbols.
|
||
|
|
AC_DEFUN([CF_PATH_SYNTAX],[
|
||
|
|
if test "x$prefix" != xNONE; then
|
||
|
|
cf_path_syntax="$prefix"
|
||
|
|
else
|
||
|
|
cf_path_syntax="$ac_default_prefix"
|
||
|
|
fi
|
||
|
|
|
||
|
|
case ".[$]$1" in
|
||
|
|
(.\[$]\(*\)*|.\'*\'*)
|
||
|
|
;;
|
||
|
|
(..|./*|.\\*)
|
||
|
|
;;
|
||
|
|
(.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
|
||
|
|
;;
|
||
|
|
(.\[$]{*prefix}*|.\[$]{*dir}*)
|
||
|
|
eval $1="[$]$1"
|
||
|
|
case ".[$]$1" in
|
||
|
|
(.NONE/*)
|
||
|
|
$1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
;;
|
||
|
|
(.no|.NONE/*)
|
||
|
|
$1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_PDCURSES_X11 version: 13 updated: 2012/10/06 16:39:58
|
||
|
|
dnl ---------------
|
||
|
|
dnl Configure for PDCurses' X11 library
|
||
|
|
AC_DEFUN([CF_PDCURSES_X11],[
|
||
|
|
AC_REQUIRE([CF_X_ATHENA])
|
||
|
|
|
||
|
|
CF_ACVERSION_CHECK(2.52,
|
||
|
|
[AC_CHECK_TOOLS(XCURSES_CONFIG, xcurses-config, none)],
|
||
|
|
[AC_PATH_PROGS(XCURSES_CONFIG, xcurses-config, none)])
|
||
|
|
|
||
|
|
if test "$XCURSES_CONFIG" != none ; then
|
||
|
|
|
||
|
|
CPPFLAGS="$CPPFLAGS `$XCURSES_CONFIG --cflags`"
|
||
|
|
CF_ADD_LIBS(`$XCURSES_CONFIG --libs`)
|
||
|
|
|
||
|
|
cf_cv_lib_XCurses=yes
|
||
|
|
|
||
|
|
else
|
||
|
|
|
||
|
|
LDFLAGS="$LDFLAGS $X_LIBS"
|
||
|
|
CF_CHECK_CFLAGS($X_CFLAGS)
|
||
|
|
AC_CHECK_LIB(X11,XOpenDisplay,
|
||
|
|
[CF_ADD_LIBS(-lX11)],,
|
||
|
|
[$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])
|
||
|
|
AC_CACHE_CHECK(for XCurses library,cf_cv_lib_XCurses,[
|
||
|
|
CF_ADD_LIBS(-lXCurses)
|
||
|
|
AC_TRY_LINK([
|
||
|
|
#include <xcurses.h>
|
||
|
|
char *XCursesProgramName = "test";
|
||
|
|
],[XCursesExit();],
|
||
|
|
[cf_cv_lib_XCurses=yes],
|
||
|
|
[cf_cv_lib_XCurses=no])
|
||
|
|
])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test $cf_cv_lib_XCurses = yes ; then
|
||
|
|
AC_DEFINE(UNIX,1,[Define to 1 if using PDCurses on Unix])
|
||
|
|
AC_DEFINE(XCURSES,1,[Define to 1 if using PDCurses on Unix])
|
||
|
|
AC_CHECK_HEADER(xcurses.h, AC_DEFINE(HAVE_XCURSES,1,[Define to 1 if using PDCurses on Unix]))
|
||
|
|
else
|
||
|
|
AC_MSG_ERROR(Cannot link with XCurses)
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_PKG_CONFIG version: 10 updated: 2015/04/26 18:06:58
|
||
|
|
dnl -------------
|
||
|
|
dnl Check for the package-config program, unless disabled by command-line.
|
||
|
|
AC_DEFUN([CF_PKG_CONFIG],
|
||
|
|
[
|
||
|
|
AC_MSG_CHECKING(if you want to use pkg-config)
|
||
|
|
AC_ARG_WITH(pkg-config,
|
||
|
|
[ --with-pkg-config{=path} enable/disable use of pkg-config],
|
||
|
|
[cf_pkg_config=$withval],
|
||
|
|
[cf_pkg_config=yes])
|
||
|
|
AC_MSG_RESULT($cf_pkg_config)
|
||
|
|
|
||
|
|
case $cf_pkg_config in
|
||
|
|
(no)
|
||
|
|
PKG_CONFIG=none
|
||
|
|
;;
|
||
|
|
(yes)
|
||
|
|
CF_ACVERSION_CHECK(2.52,
|
||
|
|
[AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
|
||
|
|
[AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
PKG_CONFIG=$withval
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
test -z "$PKG_CONFIG" && PKG_CONFIG=none
|
||
|
|
if test "$PKG_CONFIG" != none ; then
|
||
|
|
CF_PATH_SYNTAX(PKG_CONFIG)
|
||
|
|
elif test "x$cf_pkg_config" != xno ; then
|
||
|
|
AC_MSG_WARN(pkg-config is not installed)
|
||
|
|
fi
|
||
|
|
|
||
|
|
AC_SUBST(PKG_CONFIG)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_POSIX_C_SOURCE version: 9 updated: 2015/04/12 15:39:00
|
||
|
|
dnl -----------------
|
||
|
|
dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
|
||
|
|
dnl
|
||
|
|
dnl POSIX.1-1990 _POSIX_SOURCE
|
||
|
|
dnl POSIX.1-1990 and _POSIX_SOURCE and
|
||
|
|
dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2
|
||
|
|
dnl Bindings Option
|
||
|
|
dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L
|
||
|
|
dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L
|
||
|
|
dnl X/Open 2000 _POSIX_C_SOURCE=200112L
|
||
|
|
dnl
|
||
|
|
dnl Parameters:
|
||
|
|
dnl $1 is the nominal value for _POSIX_C_SOURCE
|
||
|
|
AC_DEFUN([CF_POSIX_C_SOURCE],
|
||
|
|
[
|
||
|
|
cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
|
||
|
|
|
||
|
|
cf_save_CFLAGS="$CFLAGS"
|
||
|
|
cf_save_CPPFLAGS="$CPPFLAGS"
|
||
|
|
|
||
|
|
CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
|
||
|
|
CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
|
||
|
|
|
||
|
|
AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
|
||
|
|
CF_MSG_LOG(if the symbol is already defined go no further)
|
||
|
|
AC_TRY_COMPILE([#include <sys/types.h>],[
|
||
|
|
#ifndef _POSIX_C_SOURCE
|
||
|
|
make an error
|
||
|
|
#endif],
|
||
|
|
[cf_cv_posix_c_source=no],
|
||
|
|
[cf_want_posix_source=no
|
||
|
|
case .$cf_POSIX_C_SOURCE in
|
||
|
|
(.[[12]]??*)
|
||
|
|
cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
|
||
|
|
;;
|
||
|
|
(.2)
|
||
|
|
cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
|
||
|
|
cf_want_posix_source=yes
|
||
|
|
;;
|
||
|
|
(.*)
|
||
|
|
cf_want_posix_source=yes
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
if test "$cf_want_posix_source" = yes ; then
|
||
|
|
AC_TRY_COMPILE([#include <sys/types.h>],[
|
||
|
|
#ifdef _POSIX_SOURCE
|
||
|
|
make an error
|
||
|
|
#endif],[],
|
||
|
|
cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
|
||
|
|
fi
|
||
|
|
CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
|
||
|
|
CFLAGS="$cf_trim_CFLAGS"
|
||
|
|
CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
|
||
|
|
CF_MSG_LOG(if the second compile does not leave our definition intact error)
|
||
|
|
AC_TRY_COMPILE([#include <sys/types.h>],[
|
||
|
|
#ifndef _POSIX_C_SOURCE
|
||
|
|
make an error
|
||
|
|
#endif],,
|
||
|
|
[cf_cv_posix_c_source=no])
|
||
|
|
CFLAGS="$cf_save_CFLAGS"
|
||
|
|
CPPFLAGS="$cf_save_CPPFLAGS"
|
||
|
|
])
|
||
|
|
])
|
||
|
|
|
||
|
|
if test "$cf_cv_posix_c_source" != no ; then
|
||
|
|
CFLAGS="$cf_trim_CFLAGS"
|
||
|
|
CPPFLAGS="$cf_trim_CPPFLAGS"
|
||
|
|
CF_ADD_CFLAGS($cf_cv_posix_c_source)
|
||
|
|
fi
|
||
|
|
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_PROG_CC version: 4 updated: 2014/07/12 18:57:58
|
||
|
|
dnl ----------
|
||
|
|
dnl standard check for CC, plus followup sanity checks
|
||
|
|
dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
|
||
|
|
AC_DEFUN([CF_PROG_CC],[
|
||
|
|
ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
|
||
|
|
CF_GCC_VERSION
|
||
|
|
CF_ACVERSION_CHECK(2.52,
|
||
|
|
[AC_PROG_CC_STDC],
|
||
|
|
[CF_ANSI_CC_REQD])
|
||
|
|
CF_CC_ENV_FLAGS
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_PROG_EXT version: 13 updated: 2015/04/18 09:03:58
|
||
|
|
dnl -----------
|
||
|
|
dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
|
||
|
|
AC_DEFUN([CF_PROG_EXT],
|
||
|
|
[
|
||
|
|
AC_REQUIRE([CF_CHECK_CACHE])
|
||
|
|
case $cf_cv_system_name in
|
||
|
|
(os2*)
|
||
|
|
CFLAGS="$CFLAGS -Zmt"
|
||
|
|
CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
|
||
|
|
CXXFLAGS="$CXXFLAGS -Zmt"
|
||
|
|
# autoconf's macro sets -Zexe and suffix both, which conflict:w
|
||
|
|
LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
|
||
|
|
ac_cv_exeext=.exe
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
AC_EXEEXT
|
||
|
|
AC_OBJEXT
|
||
|
|
|
||
|
|
PROG_EXT="$EXEEXT"
|
||
|
|
AC_SUBST(PROG_EXT)
|
||
|
|
test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT",[Define to the program extension (normally blank)])
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_PROG_LINT version: 3 updated: 2016/05/22 15:25:54
|
||
|
|
dnl ------------
|
||
|
|
AC_DEFUN([CF_PROG_LINT],
|
||
|
|
[
|
||
|
|
AC_CHECK_PROGS(LINT, lint cppcheck splint)
|
||
|
|
AC_SUBST(LINT_OPTS)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
|
||
|
|
dnl ------------
|
||
|
|
dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
|
||
|
|
dnl option if it is supported.
|
||
|
|
AC_DEFUN([CF_PROG_LN_S],[
|
||
|
|
AC_PROG_LN_S
|
||
|
|
AC_MSG_CHECKING(if $LN_S -f options work)
|
||
|
|
|
||
|
|
rm -f conf$$.src conf$$dst
|
||
|
|
echo >conf$$.dst
|
||
|
|
echo first >conf$$.src
|
||
|
|
if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
|
||
|
|
cf_prog_ln_sf=yes
|
||
|
|
else
|
||
|
|
cf_prog_ln_sf=no
|
||
|
|
fi
|
||
|
|
rm -f conf$$.dst conf$$src
|
||
|
|
AC_MSG_RESULT($cf_prog_ln_sf)
|
||
|
|
|
||
|
|
test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
|
||
|
|
dnl ----------------
|
||
|
|
dnl Remove all -U and -D options that refer to the given symbol from a list
|
||
|
|
dnl of C compiler options. This works around the problem that not all
|
||
|
|
dnl compilers process -U and -D options from left-to-right, so a -U option
|
||
|
|
dnl cannot be used to cancel the effect of a preceding -D option.
|
||
|
|
dnl
|
||
|
|
dnl $1 = target (which could be the same as the source variable)
|
||
|
|
dnl $2 = source (including '$')
|
||
|
|
dnl $3 = symbol to remove
|
||
|
|
define([CF_REMOVE_DEFINE],
|
||
|
|
[
|
||
|
|
$1=`echo "$2" | \
|
||
|
|
sed -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[[ ]]/ /g' \
|
||
|
|
-e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[$]//g'`
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_RPATH_HACK version: 11 updated: 2013/09/01 13:02:00
|
||
|
|
dnl -------------
|
||
|
|
AC_DEFUN([CF_RPATH_HACK],
|
||
|
|
[
|
||
|
|
AC_REQUIRE([CF_LD_RPATH_OPT])
|
||
|
|
AC_MSG_CHECKING(for updated LDFLAGS)
|
||
|
|
if test -n "$LD_RPATH_OPT" ; then
|
||
|
|
AC_MSG_RESULT(maybe)
|
||
|
|
|
||
|
|
AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
|
||
|
|
cf_rpath_list="/usr/lib /lib"
|
||
|
|
if test "$cf_ldd_prog" != no
|
||
|
|
then
|
||
|
|
cf_rpath_oops=
|
||
|
|
|
||
|
|
AC_TRY_LINK([#include <stdio.h>],
|
||
|
|
[printf("Hello");],
|
||
|
|
[cf_rpath_oops=`$cf_ldd_prog conftest$ac_exeext | fgrep ' not found' | sed -e 's% =>.*$%%' |sort | uniq`
|
||
|
|
cf_rpath_list=`$cf_ldd_prog conftest$ac_exeext | fgrep / | sed -e 's%^.*[[ ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort | uniq`])
|
||
|
|
|
||
|
|
# If we passed the link-test, but get a "not found" on a given library,
|
||
|
|
# this could be due to inept reconfiguration of gcc to make it only
|
||
|
|
# partly honor /usr/local/lib (or whatever). Sometimes this behavior
|
||
|
|
# is intentional, e.g., installing gcc in /usr/bin and suppressing the
|
||
|
|
# /usr/local libraries.
|
||
|
|
if test -n "$cf_rpath_oops"
|
||
|
|
then
|
||
|
|
for cf_rpath_src in $cf_rpath_oops
|
||
|
|
do
|
||
|
|
for cf_rpath_dir in \
|
||
|
|
/usr/local \
|
||
|
|
/usr/pkg \
|
||
|
|
/opt/sfw
|
||
|
|
do
|
||
|
|
if test -f $cf_rpath_dir/lib/$cf_rpath_src
|
||
|
|
then
|
||
|
|
CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
|
||
|
|
LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
|
||
|
|
break
|
||
|
|
fi
|
||
|
|
done
|
||
|
|
done
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
|
||
|
|
CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
|
||
|
|
|
||
|
|
CF_RPATH_HACK_2(LDFLAGS)
|
||
|
|
CF_RPATH_HACK_2(LIBS)
|
||
|
|
|
||
|
|
CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
|
||
|
|
else
|
||
|
|
AC_MSG_RESULT(no)
|
||
|
|
fi
|
||
|
|
AC_SUBST(EXTRA_LDFLAGS)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_RPATH_HACK_2 version: 7 updated: 2015/04/12 15:39:00
|
||
|
|
dnl ---------------
|
||
|
|
dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
|
||
|
|
dnl EXTRA_LDFLAGS for each -L option found.
|
||
|
|
dnl
|
||
|
|
dnl $cf_rpath_list contains a list of directories to ignore.
|
||
|
|
dnl
|
||
|
|
dnl $1 = variable name to update. The LDFLAGS variable should be the only one,
|
||
|
|
dnl but LIBS often has misplaced -L options.
|
||
|
|
AC_DEFUN([CF_RPATH_HACK_2],
|
||
|
|
[
|
||
|
|
CF_VERBOSE(...checking $1 [$]$1)
|
||
|
|
|
||
|
|
cf_rpath_dst=
|
||
|
|
for cf_rpath_src in [$]$1
|
||
|
|
do
|
||
|
|
case $cf_rpath_src in
|
||
|
|
(-L*)
|
||
|
|
|
||
|
|
# check if this refers to a directory which we will ignore
|
||
|
|
cf_rpath_skip=no
|
||
|
|
if test -n "$cf_rpath_list"
|
||
|
|
then
|
||
|
|
for cf_rpath_item in $cf_rpath_list
|
||
|
|
do
|
||
|
|
if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
|
||
|
|
then
|
||
|
|
cf_rpath_skip=yes
|
||
|
|
break
|
||
|
|
fi
|
||
|
|
done
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$cf_rpath_skip" = no
|
||
|
|
then
|
||
|
|
# transform the option
|
||
|
|
if test "$LD_RPATH_OPT" = "-R " ; then
|
||
|
|
cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
|
||
|
|
else
|
||
|
|
cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
|
||
|
|
fi
|
||
|
|
|
||
|
|
# if we have not already added this, add it now
|
||
|
|
cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
|
||
|
|
if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
|
||
|
|
then
|
||
|
|
CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
|
||
|
|
EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
|
||
|
|
done
|
||
|
|
$1=$cf_rpath_dst
|
||
|
|
|
||
|
|
CF_VERBOSE(...checked $1 [$]$1)
|
||
|
|
AC_SUBST(EXTRA_LDFLAGS)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_SHARED_OPTS version: 89 updated: 2015/08/15 18:38:59
|
||
|
|
dnl --------------
|
||
|
|
dnl --------------
|
||
|
|
dnl Attempt to determine the appropriate CC/LD options for creating a shared
|
||
|
|
dnl library.
|
||
|
|
dnl
|
||
|
|
dnl Notes:
|
||
|
|
dnl a) ${LOCAL_LDFLAGS} is used to link executables that will run within
|
||
|
|
dnl the build-tree, i.e., by making use of the libraries that are compiled in
|
||
|
|
dnl $rel_builddir/lib We avoid compiling-in a $rel_builddir/lib path for the
|
||
|
|
dnl shared library since that can lead to unexpected results at runtime.
|
||
|
|
dnl b) ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared
|
||
|
|
dnl libraries are compiled in ../../lib
|
||
|
|
dnl
|
||
|
|
dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
|
||
|
|
dnl to install symbolic links to the rel/abi versions of shared libraries.
|
||
|
|
dnl
|
||
|
|
dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
|
||
|
|
dnl version when making symbolic links.
|
||
|
|
dnl
|
||
|
|
dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
|
||
|
|
dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
|
||
|
|
dnl (ex: libncurses.so.<ver>).
|
||
|
|
dnl
|
||
|
|
dnl Some loaders leave 'so_locations' lying around. It's nice to clean up.
|
||
|
|
AC_DEFUN([CF_SHARED_OPTS],
|
||
|
|
[
|
||
|
|
AC_REQUIRE([CF_LD_RPATH_OPT])
|
||
|
|
RM_SHARED_OPTS=
|
||
|
|
LOCAL_LDFLAGS=
|
||
|
|
LOCAL_LDFLAGS2=
|
||
|
|
LD_SHARED_OPTS=
|
||
|
|
INSTALL_LIB="-m 644"
|
||
|
|
: ${rel_builddir:=.}
|
||
|
|
|
||
|
|
shlibdir=$libdir
|
||
|
|
AC_SUBST(shlibdir)
|
||
|
|
|
||
|
|
MAKE_DLLS="#"
|
||
|
|
AC_SUBST(MAKE_DLLS)
|
||
|
|
|
||
|
|
cf_cv_do_symlinks=no
|
||
|
|
cf_ld_rpath_opt=
|
||
|
|
test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(if release/abi version should be used for shared libs)
|
||
|
|
AC_ARG_WITH(shlib-version,
|
||
|
|
[ --with-shlib-version=X Specify rel or abi version for shared libs],
|
||
|
|
[test -z "$withval" && withval=auto
|
||
|
|
case $withval in
|
||
|
|
(yes)
|
||
|
|
cf_cv_shlib_version=auto
|
||
|
|
;;
|
||
|
|
(rel|abi|auto)
|
||
|
|
cf_cv_shlib_version=$withval
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
AC_MSG_RESULT($withval)
|
||
|
|
AC_MSG_ERROR([option value must be one of: rel, abi, or auto])
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
],[cf_cv_shlib_version=auto])
|
||
|
|
AC_MSG_RESULT($cf_cv_shlib_version)
|
||
|
|
|
||
|
|
cf_cv_rm_so_locs=no
|
||
|
|
cf_try_cflags=
|
||
|
|
|
||
|
|
# Some less-capable ports of gcc support only -fpic
|
||
|
|
CC_SHARED_OPTS=
|
||
|
|
if test "$GCC" = yes
|
||
|
|
then
|
||
|
|
AC_MSG_CHECKING(which $CC option to use)
|
||
|
|
cf_save_CFLAGS="$CFLAGS"
|
||
|
|
for CC_SHARED_OPTS in -fPIC -fpic ''
|
||
|
|
do
|
||
|
|
CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
|
||
|
|
AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
|
||
|
|
done
|
||
|
|
AC_MSG_RESULT($CC_SHARED_OPTS)
|
||
|
|
CFLAGS="$cf_save_CFLAGS"
|
||
|
|
fi
|
||
|
|
|
||
|
|
cf_cv_shlib_version_infix=no
|
||
|
|
|
||
|
|
case $cf_cv_system_name in
|
||
|
|
(aix4.[3-9]*|aix[[5-7]]*)
|
||
|
|
if test "$GCC" = yes; then
|
||
|
|
CC_SHARED_OPTS='-Wl,-brtl'
|
||
|
|
MK_SHARED_LIB='${CC} -shared -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
|
||
|
|
else
|
||
|
|
CC_SHARED_OPTS='-brtl'
|
||
|
|
# as well as '-qpic=large -G' or perhaps "-bM:SRE -bnoentry -bexpall"
|
||
|
|
MK_SHARED_LIB='${CC} -G -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
|
||
|
|
fi
|
||
|
|
;;
|
||
|
|
(beos*)
|
||
|
|
MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
|
||
|
|
;;
|
||
|
|
(cygwin*)
|
||
|
|
CC_SHARED_OPTS=
|
||
|
|
MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
|
||
|
|
RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
|
||
|
|
cf_cv_shlib_version=cygdll
|
||
|
|
cf_cv_shlib_version_infix=cygdll
|
||
|
|
shlibdir=$bindir
|
||
|
|
MAKE_DLLS=
|
||
|
|
cat >mk_shared_lib.sh <<-CF_EOF
|
||
|
|
#!$SHELL
|
||
|
|
SHARED_LIB=\[$]1
|
||
|
|
IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
|
||
|
|
shift
|
||
|
|
cat <<-EOF
|
||
|
|
Linking shared library
|
||
|
|
** SHARED_LIB \[$]SHARED_LIB
|
||
|
|
** IMPORT_LIB \[$]IMPORT_LIB
|
||
|
|
EOF
|
||
|
|
exec \[$]* -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
|
||
|
|
CF_EOF
|
||
|
|
chmod +x mk_shared_lib.sh
|
||
|
|
;;
|
||
|
|
(msys*)
|
||
|
|
CC_SHARED_OPTS=
|
||
|
|
MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
|
||
|
|
RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
|
||
|
|
cf_cv_shlib_version=msysdll
|
||
|
|
cf_cv_shlib_version_infix=msysdll
|
||
|
|
shlibdir=$bindir
|
||
|
|
MAKE_DLLS=
|
||
|
|
cat >mk_shared_lib.sh <<-CF_EOF
|
||
|
|
#!$SHELL
|
||
|
|
SHARED_LIB=\[$]1
|
||
|
|
IMPORT_LIB=\`echo "\[$]1" | sed -e 's/msys-/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
|
||
|
|
shift
|
||
|
|
cat <<-EOF
|
||
|
|
Linking shared library
|
||
|
|
** SHARED_LIB \[$]SHARED_LIB
|
||
|
|
** IMPORT_LIB \[$]IMPORT_LIB
|
||
|
|
EOF
|
||
|
|
exec \[$]* -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
|
||
|
|
CF_EOF
|
||
|
|
chmod +x mk_shared_lib.sh
|
||
|
|
;;
|
||
|
|
(darwin*)
|
||
|
|
cf_try_cflags="no-cpp-precomp"
|
||
|
|
CC_SHARED_OPTS="-dynamic"
|
||
|
|
MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
|
||
|
|
test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
|
||
|
|
cf_cv_shlib_version_infix=yes
|
||
|
|
AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
|
||
|
|
cf_save_LDFLAGS=$LDFLAGS
|
||
|
|
LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
|
||
|
|
AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
|
||
|
|
LDFLAGS=$cf_save_LDFLAGS])
|
||
|
|
if test $cf_cv_ldflags_search_paths_first = yes; then
|
||
|
|
LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
|
||
|
|
fi
|
||
|
|
;;
|
||
|
|
(hpux[[7-8]]*)
|
||
|
|
# HP-UX 8.07 ld lacks "+b" option used for libdir search-list
|
||
|
|
if test "$GCC" != yes; then
|
||
|
|
CC_SHARED_OPTS='+Z'
|
||
|
|
fi
|
||
|
|
MK_SHARED_LIB='${LD} -b -o $[@]'
|
||
|
|
INSTALL_LIB="-m 555"
|
||
|
|
;;
|
||
|
|
(hpux*)
|
||
|
|
# (tested with gcc 2.7.2 -- I don't have c89)
|
||
|
|
if test "$GCC" = yes; then
|
||
|
|
LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
|
||
|
|
else
|
||
|
|
CC_SHARED_OPTS='+Z'
|
||
|
|
LD_SHARED_OPTS='-Wl,+b,${libdir}'
|
||
|
|
fi
|
||
|
|
MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
|
||
|
|
# HP-UX shared libraries must be executable, and should be
|
||
|
|
# readonly to exploit a quirk in the memory manager.
|
||
|
|
INSTALL_LIB="-m 555"
|
||
|
|
;;
|
||
|
|
(interix*)
|
||
|
|
test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
|
||
|
|
if test "$cf_cv_shlib_version" = rel; then
|
||
|
|
cf_shared_soname='`basename $@ .${REL_VERSION}`.${ABI_VERSION}'
|
||
|
|
else
|
||
|
|
cf_shared_soname='`basename $@`'
|
||
|
|
fi
|
||
|
|
CC_SHARED_OPTS=
|
||
|
|
MK_SHARED_LIB='${CC} -shared -Wl,-rpath,${RPATH_LIST} -Wl,-h,'$cf_shared_soname' -o $@'
|
||
|
|
;;
|
||
|
|
(irix*)
|
||
|
|
if test "$cf_cv_enable_rpath" = yes ; then
|
||
|
|
EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
|
||
|
|
fi
|
||
|
|
# tested with IRIX 5.2 and 'cc'.
|
||
|
|
if test "$GCC" != yes; then
|
||
|
|
CC_SHARED_OPTS='-KPIC'
|
||
|
|
MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
|
||
|
|
else
|
||
|
|
MK_SHARED_LIB='${CC} -shared -Wl,-soname,`basename $[@]` -o $[@]'
|
||
|
|
fi
|
||
|
|
cf_cv_rm_so_locs=yes
|
||
|
|
;;
|
||
|
|
(linux*|gnu*|k*bsd*-gnu)
|
||
|
|
if test "$DFT_LWR_MODEL" = "shared" ; then
|
||
|
|
LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
|
||
|
|
LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
|
||
|
|
fi
|
||
|
|
if test "$cf_cv_enable_rpath" = yes ; then
|
||
|
|
EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
|
||
|
|
fi
|
||
|
|
CF_SHARED_SONAME
|
||
|
|
MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
|
||
|
|
;;
|
||
|
|
(mingw*)
|
||
|
|
cf_cv_shlib_version=mingw
|
||
|
|
cf_cv_shlib_version_infix=mingw
|
||
|
|
shlibdir=$bindir
|
||
|
|
MAKE_DLLS=
|
||
|
|
if test "$DFT_LWR_MODEL" = "shared" ; then
|
||
|
|
LOCAL_LDFLAGS="-Wl,--enable-auto-import"
|
||
|
|
LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
|
||
|
|
EXTRA_LDFLAGS="-Wl,--enable-auto-import $EXTRA_LDFLAGS"
|
||
|
|
fi
|
||
|
|
CC_SHARED_OPTS=
|
||
|
|
MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
|
||
|
|
RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
|
||
|
|
cat >mk_shared_lib.sh <<-CF_EOF
|
||
|
|
#!$SHELL
|
||
|
|
SHARED_LIB=\[$]1
|
||
|
|
IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
|
||
|
|
shift
|
||
|
|
cat <<-EOF
|
||
|
|
Linking shared library
|
||
|
|
** SHARED_LIB \[$]SHARED_LIB
|
||
|
|
** IMPORT_LIB \[$]IMPORT_LIB
|
||
|
|
EOF
|
||
|
|
exec \[$]* -shared -Wl,--enable-auto-import,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
|
||
|
|
CF_EOF
|
||
|
|
chmod +x mk_shared_lib.sh
|
||
|
|
;;
|
||
|
|
(openbsd[[2-9]].*|mirbsd*)
|
||
|
|
if test "$DFT_LWR_MODEL" = "shared" ; then
|
||
|
|
LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
|
||
|
|
LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
|
||
|
|
fi
|
||
|
|
if test "$cf_cv_enable_rpath" = yes ; then
|
||
|
|
EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
|
||
|
|
fi
|
||
|
|
CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
|
||
|
|
CF_SHARED_SONAME
|
||
|
|
MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
|
||
|
|
;;
|
||
|
|
(nto-qnx*|openbsd*|freebsd[[12]].*)
|
||
|
|
CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
|
||
|
|
MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
|
||
|
|
test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
|
||
|
|
;;
|
||
|
|
(dragonfly*|freebsd*)
|
||
|
|
CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
|
||
|
|
if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
|
||
|
|
LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
|
||
|
|
LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${RPATH_LIST} $LOCAL_LDFLAGS"
|
||
|
|
EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
|
||
|
|
fi
|
||
|
|
CF_SHARED_SONAME
|
||
|
|
MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
|
||
|
|
;;
|
||
|
|
(netbsd*)
|
||
|
|
CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
|
||
|
|
if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
|
||
|
|
LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
|
||
|
|
LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
|
||
|
|
EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
|
||
|
|
if test "$cf_cv_shlib_version" = auto; then
|
||
|
|
if test -f /usr/libexec/ld.elf_so; then
|
||
|
|
cf_cv_shlib_version=abi
|
||
|
|
else
|
||
|
|
cf_cv_shlib_version=rel
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
CF_SHARED_SONAME
|
||
|
|
MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
|
||
|
|
else
|
||
|
|
MK_SHARED_LIB='${CC} -Wl,-shared -Wl,-Bshareable -o $[@]'
|
||
|
|
fi
|
||
|
|
;;
|
||
|
|
(osf*|mls+*)
|
||
|
|
# tested with OSF/1 V3.2 and 'cc'
|
||
|
|
# tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
|
||
|
|
# link with shared libs).
|
||
|
|
MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
|
||
|
|
case $host_os in
|
||
|
|
(osf4*)
|
||
|
|
MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
|
||
|
|
if test "$DFT_LWR_MODEL" = "shared" ; then
|
||
|
|
LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
|
||
|
|
LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
|
||
|
|
fi
|
||
|
|
cf_cv_rm_so_locs=yes
|
||
|
|
;;
|
||
|
|
(sco3.2v5*) # also uw2* and UW7: hops 13-Apr-98
|
||
|
|
# tested with osr5.0.5
|
||
|
|
if test "$GCC" != yes; then
|
||
|
|
CC_SHARED_OPTS='-belf -KPIC'
|
||
|
|
fi
|
||
|
|
MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
|
||
|
|
if test "$cf_cv_enable_rpath" = yes ; then
|
||
|
|
# only way is to set LD_RUN_PATH but no switch for it
|
||
|
|
RUN_PATH=$libdir
|
||
|
|
fi
|
||
|
|
test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
|
||
|
|
LINK_PROGS='LD_RUN_PATH=${libdir}'
|
||
|
|
LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
|
||
|
|
;;
|
||
|
|
(sunos4*)
|
||
|
|
# tested with SunOS 4.1.1 and gcc 2.7.0
|
||
|
|
if test "$GCC" != yes; then
|
||
|
|
CC_SHARED_OPTS='-KPIC'
|
||
|
|
fi
|
||
|
|
MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
|
||
|
|
test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
|
||
|
|
;;
|
||
|
|
(solaris2*)
|
||
|
|
# tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
|
||
|
|
# tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
|
||
|
|
if test "$DFT_LWR_MODEL" = "shared" ; then
|
||
|
|
LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
|
||
|
|
LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
|
||
|
|
fi
|
||
|
|
if test "$cf_cv_enable_rpath" = yes ; then
|
||
|
|
EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
|
||
|
|
fi
|
||
|
|
CF_SHARED_SONAME
|
||
|
|
if test "$GCC" != yes; then
|
||
|
|
cf_save_CFLAGS="$CFLAGS"
|
||
|
|
for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
|
||
|
|
do
|
||
|
|
CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
|
||
|
|
AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\n");],[break])
|
||
|
|
done
|
||
|
|
CFLAGS="$cf_save_CFLAGS"
|
||
|
|
CC_SHARED_OPTS=$cf_shared_opts
|
||
|
|
MK_SHARED_LIB='${CC} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
|
||
|
|
else
|
||
|
|
MK_SHARED_LIB='${CC} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
|
||
|
|
fi
|
||
|
|
;;
|
||
|
|
(sysv5uw7*|unix_sv*)
|
||
|
|
# tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
|
||
|
|
if test "$GCC" != yes; then
|
||
|
|
CC_SHARED_OPTS='-KPIC'
|
||
|
|
fi
|
||
|
|
MK_SHARED_LIB='${LD} -d y -G -o [$]@'
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
CC_SHARED_OPTS='unknown'
|
||
|
|
MK_SHARED_LIB='echo unknown'
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
# This works if the last tokens in $MK_SHARED_LIB are the -o target.
|
||
|
|
case "$cf_cv_shlib_version" in
|
||
|
|
(rel|abi)
|
||
|
|
case "$MK_SHARED_LIB" in
|
||
|
|
(*'-o $[@]')
|
||
|
|
test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
AC_MSG_WARN(ignored --with-shlib-version)
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
if test -n "$cf_try_cflags"
|
||
|
|
then
|
||
|
|
cat > conftest.$ac_ext <<EOF
|
||
|
|
#line __oline__ "${as_me:-configure}"
|
||
|
|
#include <stdio.h>
|
||
|
|
int main(int argc, char *argv[[]])
|
||
|
|
{
|
||
|
|
printf("hello\n");
|
||
|
|
return (argv[[argc-1]] == 0) ;
|
||
|
|
}
|
||
|
|
EOF
|
||
|
|
cf_save_CFLAGS="$CFLAGS"
|
||
|
|
for cf_opt in $cf_try_cflags
|
||
|
|
do
|
||
|
|
CFLAGS="$cf_save_CFLAGS -$cf_opt"
|
||
|
|
AC_MSG_CHECKING(if CFLAGS option -$cf_opt works)
|
||
|
|
if AC_TRY_EVAL(ac_compile); then
|
||
|
|
AC_MSG_RESULT(yes)
|
||
|
|
cf_save_CFLAGS="$CFLAGS"
|
||
|
|
else
|
||
|
|
AC_MSG_RESULT(no)
|
||
|
|
fi
|
||
|
|
done
|
||
|
|
CFLAGS="$cf_save_CFLAGS"
|
||
|
|
fi
|
||
|
|
|
||
|
|
|
||
|
|
# RPATH_LIST is a colon-separated list of directories
|
||
|
|
test -n "$cf_ld_rpath_opt" && MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${RPATH_LIST}"
|
||
|
|
test -z "$RPATH_LIST" && RPATH_LIST="\${libdir}"
|
||
|
|
|
||
|
|
test $cf_cv_rm_so_locs = yes && RM_SHARED_OPTS="$RM_SHARED_OPTS so_locations"
|
||
|
|
|
||
|
|
CF_VERBOSE(CC_SHARED_OPTS: $CC_SHARED_OPTS)
|
||
|
|
CF_VERBOSE(MK_SHARED_LIB: $MK_SHARED_LIB)
|
||
|
|
|
||
|
|
AC_SUBST(CC_SHARED_OPTS)
|
||
|
|
AC_SUBST(LD_RPATH_OPT)
|
||
|
|
AC_SUBST(LD_SHARED_OPTS)
|
||
|
|
AC_SUBST(MK_SHARED_LIB)
|
||
|
|
AC_SUBST(RM_SHARED_OPTS)
|
||
|
|
|
||
|
|
AC_SUBST(LINK_PROGS)
|
||
|
|
AC_SUBST(LINK_TESTS)
|
||
|
|
|
||
|
|
AC_SUBST(EXTRA_LDFLAGS)
|
||
|
|
AC_SUBST(LOCAL_LDFLAGS)
|
||
|
|
AC_SUBST(LOCAL_LDFLAGS2)
|
||
|
|
|
||
|
|
AC_SUBST(INSTALL_LIB)
|
||
|
|
AC_SUBST(RPATH_LIST)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
|
||
|
|
dnl ----------------
|
||
|
|
dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
|
||
|
|
dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
|
||
|
|
dnl option.
|
||
|
|
dnl
|
||
|
|
dnl $1 is the default that should be used for "$cf_cv_shlib_version".
|
||
|
|
dnl If missing, use "rel".
|
||
|
|
define([CF_SHARED_SONAME],
|
||
|
|
[
|
||
|
|
test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
|
||
|
|
if test "$cf_cv_shlib_version" = rel; then
|
||
|
|
cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
|
||
|
|
else
|
||
|
|
cf_cv_shared_soname='`basename $[@]`'
|
||
|
|
fi
|
||
|
|
])
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
|
||
|
|
dnl --------------
|
||
|
|
dnl Construct a search-list for a nonstandard header/lib-file
|
||
|
|
dnl $1 = the variable to return as result
|
||
|
|
dnl $2 = the package name
|
||
|
|
dnl $3 = the subdirectory, e.g., bin, include or lib
|
||
|
|
AC_DEFUN([CF_SUBDIR_PATH],
|
||
|
|
[
|
||
|
|
$1=
|
||
|
|
|
||
|
|
CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
|
||
|
|
|
||
|
|
for cf_subdir_prefix in \
|
||
|
|
/usr \
|
||
|
|
/usr/local \
|
||
|
|
/usr/pkg \
|
||
|
|
/opt \
|
||
|
|
/opt/local \
|
||
|
|
[$]HOME
|
||
|
|
do
|
||
|
|
CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
|
||
|
|
done
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_TERM_HEADER version: 4 updated: 2015/04/15 19:08:48
|
||
|
|
dnl --------------
|
||
|
|
dnl Look for term.h, which is part of X/Open curses. It defines the interface
|
||
|
|
dnl to terminfo database. Usually it is in the same include-path as curses.h,
|
||
|
|
dnl but some packagers change this, breaking various applications.
|
||
|
|
AC_DEFUN([CF_TERM_HEADER],[
|
||
|
|
AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
|
||
|
|
case ${cf_cv_ncurses_header} in
|
||
|
|
(*/ncurses.h|*/ncursesw.h)
|
||
|
|
cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
cf_term_header=term.h
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
|
||
|
|
do
|
||
|
|
AC_TRY_COMPILE([#include <stdio.h>
|
||
|
|
#include <${cf_cv_ncurses_header:-curses.h}>
|
||
|
|
#include <$cf_test>
|
||
|
|
],[int x = auto_left_margin],[
|
||
|
|
cf_cv_term_header="$cf_test"],[
|
||
|
|
cf_cv_term_header=unknown
|
||
|
|
])
|
||
|
|
test "$cf_cv_term_header" != unknown && break
|
||
|
|
done
|
||
|
|
])
|
||
|
|
|
||
|
|
# Set definitions to allow ifdef'ing to accommodate subdirectories
|
||
|
|
|
||
|
|
case $cf_cv_term_header in
|
||
|
|
(*term.h)
|
||
|
|
AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
case $cf_cv_term_header in
|
||
|
|
(ncurses/term.h)
|
||
|
|
AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
|
||
|
|
;;
|
||
|
|
(ncursesw/term.h)
|
||
|
|
AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
|
||
|
|
dnl ---------------
|
||
|
|
dnl Define a top_builddir symbol, for applications that need an absolute path.
|
||
|
|
AC_DEFUN([CF_TOP_BUILDDIR],
|
||
|
|
[
|
||
|
|
top_builddir=ifelse($1,,`pwd`,$1)
|
||
|
|
AC_SUBST(top_builddir)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_TRIM_X_LIBS version: 3 updated: 2015/04/12 15:39:00
|
||
|
|
dnl --------------
|
||
|
|
dnl Trim extra base X libraries added as a workaround for inconsistent library
|
||
|
|
dnl dependencies returned by "new" pkg-config files.
|
||
|
|
AC_DEFUN([CF_TRIM_X_LIBS],[
|
||
|
|
for cf_trim_lib in Xmu Xt X11
|
||
|
|
do
|
||
|
|
case "$LIBS" in
|
||
|
|
(*-l$cf_trim_lib\ *-l$cf_trim_lib*)
|
||
|
|
LIBS=`echo "$LIBS " | sed -e 's/ / /g' -e 's%-l'"$cf_trim_lib"' %%' -e 's/ $//'`
|
||
|
|
CF_VERBOSE(..trimmed $LIBS)
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
done
|
||
|
|
])
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_TRY_PKG_CONFIG version: 5 updated: 2013/07/06 21:27:06
|
||
|
|
dnl -----------------
|
||
|
|
dnl This is a simple wrapper to use for pkg-config, for libraries which may be
|
||
|
|
dnl available in that form.
|
||
|
|
dnl
|
||
|
|
dnl $1 = package name
|
||
|
|
dnl $2 = extra logic to use, if any, after updating CFLAGS and LIBS
|
||
|
|
dnl $3 = logic to use if pkg-config does not have the package
|
||
|
|
AC_DEFUN([CF_TRY_PKG_CONFIG],[
|
||
|
|
AC_REQUIRE([CF_PKG_CONFIG])
|
||
|
|
|
||
|
|
if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists $1; then
|
||
|
|
CF_VERBOSE(found package $1)
|
||
|
|
cf_pkgconfig_incs="`$PKG_CONFIG --cflags $1 2>/dev/null`"
|
||
|
|
cf_pkgconfig_libs="`$PKG_CONFIG --libs $1 2>/dev/null`"
|
||
|
|
CF_VERBOSE(package $1 CFLAGS: $cf_pkgconfig_incs)
|
||
|
|
CF_VERBOSE(package $1 LIBS: $cf_pkgconfig_libs)
|
||
|
|
CF_ADD_CFLAGS($cf_pkgconfig_incs)
|
||
|
|
CF_ADD_LIBS($cf_pkgconfig_libs)
|
||
|
|
ifelse([$2],,:,[$2])
|
||
|
|
else
|
||
|
|
cf_pkgconfig_incs=
|
||
|
|
cf_pkgconfig_libs=
|
||
|
|
ifelse([$3],,:,[$3])
|
||
|
|
fi
|
||
|
|
])
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_TRY_XOPEN_SOURCE version: 1 updated: 2011/10/30 17:09:50
|
||
|
|
dnl -------------------
|
||
|
|
dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
|
||
|
|
dnl can define it successfully.
|
||
|
|
AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
|
||
|
|
AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
|
||
|
|
AC_TRY_COMPILE([
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <string.h>
|
||
|
|
#include <sys/types.h>
|
||
|
|
],[
|
||
|
|
#ifndef _XOPEN_SOURCE
|
||
|
|
make an error
|
||
|
|
#endif],
|
||
|
|
[cf_cv_xopen_source=no],
|
||
|
|
[cf_save="$CPPFLAGS"
|
||
|
|
CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
|
||
|
|
AC_TRY_COMPILE([
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <string.h>
|
||
|
|
#include <sys/types.h>
|
||
|
|
],[
|
||
|
|
#ifdef _XOPEN_SOURCE
|
||
|
|
make an error
|
||
|
|
#endif],
|
||
|
|
[cf_cv_xopen_source=no],
|
||
|
|
[cf_cv_xopen_source=$cf_XOPEN_SOURCE])
|
||
|
|
CPPFLAGS="$cf_save"
|
||
|
|
])
|
||
|
|
])
|
||
|
|
|
||
|
|
if test "$cf_cv_xopen_source" != no ; then
|
||
|
|
CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
|
||
|
|
CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
|
||
|
|
cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
|
||
|
|
CF_ADD_CFLAGS($cf_temp_xopen_source)
|
||
|
|
fi
|
||
|
|
])
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
|
||
|
|
dnl --------
|
||
|
|
dnl Make an uppercase version of a variable
|
||
|
|
dnl $1=uppercase($2)
|
||
|
|
AC_DEFUN([CF_UPPER],
|
||
|
|
[
|
||
|
|
$1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_UTF8_LIB version: 8 updated: 2012/10/06 08:57:51
|
||
|
|
dnl -----------
|
||
|
|
dnl Check for multibyte support, and if not found, utf8 compatibility library
|
||
|
|
AC_DEFUN([CF_UTF8_LIB],
|
||
|
|
[
|
||
|
|
AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
|
||
|
|
cf_save_LIBS="$LIBS"
|
||
|
|
AC_TRY_LINK([
|
||
|
|
#include <stdlib.h>],[putwc(0,0);],
|
||
|
|
[cf_cv_utf8_lib=yes],
|
||
|
|
[CF_FIND_LINKAGE([
|
||
|
|
#include <libutf8.h>],[putwc(0,0);],utf8,
|
||
|
|
[cf_cv_utf8_lib=add-on],
|
||
|
|
[cf_cv_utf8_lib=no])
|
||
|
|
])])
|
||
|
|
|
||
|
|
# HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
|
||
|
|
# ncurses/ncursesw:
|
||
|
|
if test "$cf_cv_utf8_lib" = "add-on" ; then
|
||
|
|
AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
|
||
|
|
CF_ADD_INCDIR($cf_cv_header_path_utf8)
|
||
|
|
CF_ADD_LIBDIR($cf_cv_library_path_utf8)
|
||
|
|
CF_ADD_LIBS($cf_cv_library_file_utf8)
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
|
||
|
|
dnl ----------
|
||
|
|
dnl Use AC_VERBOSE w/o the warnings
|
||
|
|
AC_DEFUN([CF_VERBOSE],
|
||
|
|
[test -n "$verbose" && echo " $1" 1>&AC_FD_MSG
|
||
|
|
CF_MSG_LOG([$1])
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_VERSION_INFO version: 7 updated: 2015/04/17 21:13:04
|
||
|
|
dnl ---------------
|
||
|
|
dnl Define several useful symbols derived from the VERSION file. A separate
|
||
|
|
dnl file is preferred to embedding the version numbers in various scripts.
|
||
|
|
dnl (automake is a textbook-example of why the latter is a bad idea, but there
|
||
|
|
dnl are others).
|
||
|
|
dnl
|
||
|
|
dnl The file contents are:
|
||
|
|
dnl libtool-version release-version patch-version
|
||
|
|
dnl or
|
||
|
|
dnl release-version
|
||
|
|
dnl where
|
||
|
|
dnl libtool-version (see ?) consists of 3 integers separated by '.'
|
||
|
|
dnl release-version consists of a major version and minor version
|
||
|
|
dnl separated by '.', optionally followed by a patch-version
|
||
|
|
dnl separated by '-'. The minor version need not be an
|
||
|
|
dnl integer (but it is preferred).
|
||
|
|
dnl patch-version is an integer in the form yyyymmdd, so ifdef's and
|
||
|
|
dnl scripts can easily compare versions.
|
||
|
|
dnl
|
||
|
|
dnl If libtool is used, the first form is required, since CF_WITH_LIBTOOL
|
||
|
|
dnl simply extracts the first field using 'cut -f1'.
|
||
|
|
dnl
|
||
|
|
dnl Optional parameters:
|
||
|
|
dnl $1 = internal name for package
|
||
|
|
dnl $2 = external name for package
|
||
|
|
AC_DEFUN([CF_VERSION_INFO],
|
||
|
|
[
|
||
|
|
if test -f $srcdir/VERSION ; then
|
||
|
|
AC_MSG_CHECKING(for package version)
|
||
|
|
|
||
|
|
# if there are not enough fields, cut returns the last one...
|
||
|
|
cf_field1=`sed -e '2,$d' $srcdir/VERSION|cut -f1`
|
||
|
|
cf_field2=`sed -e '2,$d' $srcdir/VERSION|cut -f2`
|
||
|
|
cf_field3=`sed -e '2,$d' $srcdir/VERSION|cut -f3`
|
||
|
|
|
||
|
|
# this is how CF_BUNDLED_INTL uses $VERSION:
|
||
|
|
VERSION="$cf_field1"
|
||
|
|
|
||
|
|
VERSION_MAJOR=`echo "$cf_field2" | sed -e 's/\..*//'`
|
||
|
|
test -z "$VERSION_MAJOR" && AC_MSG_ERROR(missing major-version)
|
||
|
|
|
||
|
|
VERSION_MINOR=`echo "$cf_field2" | sed -e 's/^[[^.]]*\.//' -e 's/-.*//'`
|
||
|
|
test -z "$VERSION_MINOR" && AC_MSG_ERROR(missing minor-version)
|
||
|
|
|
||
|
|
AC_MSG_RESULT(${VERSION_MAJOR}.${VERSION_MINOR})
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for package patch date)
|
||
|
|
VERSION_PATCH=`echo "$cf_field3" | sed -e 's/^[[^-]]*-//'`
|
||
|
|
case .$VERSION_PATCH in
|
||
|
|
(.)
|
||
|
|
AC_MSG_ERROR(missing patch-date $VERSION_PATCH)
|
||
|
|
;;
|
||
|
|
(.[[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]])
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
AC_MSG_ERROR(illegal patch-date $VERSION_PATCH)
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
AC_MSG_RESULT($VERSION_PATCH)
|
||
|
|
else
|
||
|
|
AC_MSG_ERROR(did not find $srcdir/VERSION)
|
||
|
|
fi
|
||
|
|
|
||
|
|
# show the actual data that we have for versions:
|
||
|
|
CF_VERBOSE(ABI VERSION $VERSION)
|
||
|
|
CF_VERBOSE(VERSION_MAJOR $VERSION_MAJOR)
|
||
|
|
CF_VERBOSE(VERSION_MINOR $VERSION_MINOR)
|
||
|
|
CF_VERBOSE(VERSION_PATCH $VERSION_PATCH)
|
||
|
|
|
||
|
|
AC_SUBST(VERSION)
|
||
|
|
AC_SUBST(VERSION_MAJOR)
|
||
|
|
AC_SUBST(VERSION_MINOR)
|
||
|
|
AC_SUBST(VERSION_PATCH)
|
||
|
|
|
||
|
|
dnl if a package name is given, define its corresponding version info. We
|
||
|
|
dnl need the package name to ensure that the defined symbols are unique.
|
||
|
|
ifelse($1,,,[
|
||
|
|
cf_PACKAGE=$1
|
||
|
|
PACKAGE=ifelse($2,,$1,$2)
|
||
|
|
AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE",[Define to the package-name])
|
||
|
|
AC_SUBST(PACKAGE)
|
||
|
|
CF_UPPER(cf_PACKAGE,$cf_PACKAGE)
|
||
|
|
AC_DEFINE_UNQUOTED(${cf_PACKAGE}_VERSION,"${VERSION_MAJOR}.${VERSION_MINOR}")
|
||
|
|
AC_DEFINE_UNQUOTED(${cf_PACKAGE}_PATCHDATE,${VERSION_PATCH})
|
||
|
|
])
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_WITH_ABI_VERSION version: 3 updated: 2015/06/06 16:10:11
|
||
|
|
dnl -------------------
|
||
|
|
dnl Allow library's ABI to be overridden. Generally this happens when a
|
||
|
|
dnl packager has incremented the ABI past that used in the original package,
|
||
|
|
dnl and wishes to keep doing this.
|
||
|
|
dnl
|
||
|
|
dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
|
||
|
|
dnl symbol.
|
||
|
|
AC_DEFUN([CF_WITH_ABI_VERSION],[
|
||
|
|
test -z "$cf_cv_abi_version" && cf_cv_abi_version=0
|
||
|
|
AC_ARG_WITH(abi-version,
|
||
|
|
[ --with-abi-version=XXX override derived ABI version],[
|
||
|
|
if test "x$cf_cv_abi_version" != "x$withval"
|
||
|
|
then
|
||
|
|
AC_MSG_WARN(overriding ABI version $cf_cv_abi_version to $withval)
|
||
|
|
case $cf_cv_rel_version in
|
||
|
|
(5.*)
|
||
|
|
cf_cv_rel_version=$withval.0
|
||
|
|
;;
|
||
|
|
(6.*)
|
||
|
|
cf_cv_rel_version=$withval.9 # FIXME: should be 10 as of 6.0 release
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
fi
|
||
|
|
cf_cv_abi_version=$withval])
|
||
|
|
CF_NUMBER_SYNTAX($cf_cv_abi_version,ABI version)
|
||
|
|
ifelse($1,,,[
|
||
|
|
$1_ABI=$cf_cv_abi_version
|
||
|
|
])
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_WITH_CURSES_DIR version: 3 updated: 2010/11/20 17:02:38
|
||
|
|
dnl ------------------
|
||
|
|
dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
|
||
|
|
dnl libraries.
|
||
|
|
AC_DEFUN([CF_WITH_CURSES_DIR],[
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for specific curses-directory)
|
||
|
|
AC_ARG_WITH(curses-dir,
|
||
|
|
[ --with-curses-dir=DIR directory in which (n)curses is installed],
|
||
|
|
[cf_cv_curses_dir=$withval],
|
||
|
|
[cf_cv_curses_dir=no])
|
||
|
|
AC_MSG_RESULT($cf_cv_curses_dir)
|
||
|
|
|
||
|
|
if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
|
||
|
|
then
|
||
|
|
CF_PATH_SYNTAX(withval)
|
||
|
|
if test -d "$cf_cv_curses_dir"
|
||
|
|
then
|
||
|
|
CF_ADD_INCDIR($cf_cv_curses_dir/include)
|
||
|
|
CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
|
||
|
|
dnl ----------------
|
||
|
|
dnl Configure-option for dbmalloc. The optional parameter is used to override
|
||
|
|
dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
|
||
|
|
AC_DEFUN([CF_WITH_DBMALLOC],[
|
||
|
|
CF_NO_LEAKS_OPTION(dbmalloc,
|
||
|
|
[ --with-dbmalloc test: use Conor Cahill's dbmalloc library],
|
||
|
|
[USE_DBMALLOC])
|
||
|
|
|
||
|
|
if test "$with_dbmalloc" = yes ; then
|
||
|
|
AC_CHECK_HEADER(dbmalloc.h,
|
||
|
|
[AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
|
||
|
|
dnl ---------------
|
||
|
|
dnl Configure-option for dmalloc. The optional parameter is used to override
|
||
|
|
dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
|
||
|
|
AC_DEFUN([CF_WITH_DMALLOC],[
|
||
|
|
CF_NO_LEAKS_OPTION(dmalloc,
|
||
|
|
[ --with-dmalloc test: use Gray Watson's dmalloc library],
|
||
|
|
[USE_DMALLOC])
|
||
|
|
|
||
|
|
if test "$with_dmalloc" = yes ; then
|
||
|
|
AC_CHECK_HEADER(dmalloc.h,
|
||
|
|
[AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_WITH_EXPORT_SYMS version: 3 updated: 2014/12/20 19:16:08
|
||
|
|
dnl -------------------
|
||
|
|
dnl Use this with libtool to specify the list of symbols that may be exported.
|
||
|
|
dnl The input file contains one symbol per line; comments work with "#".
|
||
|
|
dnl
|
||
|
|
dnl $1 = basename of the ".sym" file (default $PACKAGE)
|
||
|
|
AC_DEFUN([CF_WITH_EXPORT_SYMS],
|
||
|
|
[
|
||
|
|
AC_MSG_CHECKING(if exported-symbols file should be used)
|
||
|
|
AC_ARG_WITH(export-syms,
|
||
|
|
[ --with-export-syms=XXX limit exported symbols using libtool],
|
||
|
|
[with_export_syms=$withval],
|
||
|
|
[with_export_syms=no])
|
||
|
|
if test "x$with_export_syms" = xyes
|
||
|
|
then
|
||
|
|
with_export_syms='${top_srcdir}/package/ifelse($1,,${PACKAGE},[$1]).sym'
|
||
|
|
AC_SUBST(PACKAGE)
|
||
|
|
fi
|
||
|
|
AC_MSG_RESULT($with_export_syms)
|
||
|
|
if test "x$with_export_syms" != xno
|
||
|
|
then
|
||
|
|
EXPORT_SYMS="-export-symbols $with_export_syms"
|
||
|
|
AC_SUBST(EXPORT_SYMS)
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_WITH_LIBTOOL version: 33 updated: 2015/10/17 19:03:33
|
||
|
|
dnl ---------------
|
||
|
|
dnl Provide a configure option to incorporate libtool. Define several useful
|
||
|
|
dnl symbols for the makefile rules.
|
||
|
|
dnl
|
||
|
|
dnl The reference to AC_PROG_LIBTOOL does not normally work, since it uses
|
||
|
|
dnl macros from libtool.m4 which is in the aclocal directory of automake.
|
||
|
|
dnl Following is a simple script which turns on the AC_PROG_LIBTOOL macro.
|
||
|
|
dnl But that still does not work properly since the macro is expanded outside
|
||
|
|
dnl the CF_WITH_LIBTOOL macro:
|
||
|
|
dnl
|
||
|
|
dnl #!/bin/sh
|
||
|
|
dnl ACLOCAL=`aclocal --print-ac-dir`
|
||
|
|
dnl if test -z "$ACLOCAL" ; then
|
||
|
|
dnl echo cannot find aclocal directory
|
||
|
|
dnl exit 1
|
||
|
|
dnl elif test ! -f $ACLOCAL/libtool.m4 ; then
|
||
|
|
dnl echo cannot find libtool.m4 file
|
||
|
|
dnl exit 1
|
||
|
|
dnl fi
|
||
|
|
dnl
|
||
|
|
dnl LOCAL=aclocal.m4
|
||
|
|
dnl ORIG=aclocal.m4.orig
|
||
|
|
dnl
|
||
|
|
dnl trap "mv $ORIG $LOCAL" 0 1 2 5 15
|
||
|
|
dnl rm -f $ORIG
|
||
|
|
dnl mv $LOCAL $ORIG
|
||
|
|
dnl
|
||
|
|
dnl # sed the LIBTOOL= assignment to omit the current directory?
|
||
|
|
dnl sed -e 's/^LIBTOOL=.*/LIBTOOL=${LIBTOOL:-libtool}/' $ACLOCAL/libtool.m4 >>$LOCAL
|
||
|
|
dnl cat $ORIG >>$LOCAL
|
||
|
|
dnl
|
||
|
|
dnl autoconf-257 $*
|
||
|
|
dnl
|
||
|
|
AC_DEFUN([CF_WITH_LIBTOOL],
|
||
|
|
[
|
||
|
|
AC_REQUIRE([CF_DISABLE_LIBTOOL_VERSION])
|
||
|
|
ifdef([AC_PROG_LIBTOOL],,[
|
||
|
|
LIBTOOL=
|
||
|
|
])
|
||
|
|
# common library maintenance symbols that are convenient for libtool scripts:
|
||
|
|
LIB_CREATE='${AR} -cr'
|
||
|
|
LIB_OBJECT='${OBJECTS}'
|
||
|
|
LIB_SUFFIX=.a
|
||
|
|
LIB_PREP="$RANLIB"
|
||
|
|
|
||
|
|
# symbols used to prop libtool up to enable it to determine what it should be
|
||
|
|
# doing:
|
||
|
|
LIB_CLEAN=
|
||
|
|
LIB_COMPILE=
|
||
|
|
LIB_LINK='${CC}'
|
||
|
|
LIB_INSTALL=
|
||
|
|
LIB_UNINSTALL=
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(if you want to build libraries with libtool)
|
||
|
|
AC_ARG_WITH(libtool,
|
||
|
|
[ --with-libtool generate libraries with libtool],
|
||
|
|
[with_libtool=$withval],
|
||
|
|
[with_libtool=no])
|
||
|
|
AC_MSG_RESULT($with_libtool)
|
||
|
|
if test "$with_libtool" != "no"; then
|
||
|
|
ifdef([AC_PROG_LIBTOOL],[
|
||
|
|
# missing_content_AC_PROG_LIBTOOL{{
|
||
|
|
AC_PROG_LIBTOOL
|
||
|
|
# missing_content_AC_PROG_LIBTOOL}}
|
||
|
|
],[
|
||
|
|
if test "$with_libtool" != "yes" ; then
|
||
|
|
CF_PATH_SYNTAX(with_libtool)
|
||
|
|
LIBTOOL=$with_libtool
|
||
|
|
else
|
||
|
|
AC_CHECK_TOOLS(LIBTOOL,[libtool glibtool],none)
|
||
|
|
CF_LIBTOOL_VERSION
|
||
|
|
if test -z "$cf_cv_libtool_version" && test "$LIBTOOL" = libtool
|
||
|
|
then
|
||
|
|
CF_FORGET_TOOL(LIBTOOL)
|
||
|
|
AC_CHECK_TOOLS(LIBTOOL,[glibtool],none)
|
||
|
|
CF_LIBTOOL_VERSION
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
if test -z "$LIBTOOL" ; then
|
||
|
|
AC_MSG_ERROR(Cannot find libtool)
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
LIB_CREATE='${LIBTOOL} --mode=link ${CC} -rpath ${DESTDIR}${libdir} ${LIBTOOL_VERSION} `cut -f1 ${top_srcdir}/VERSION` ${LIBTOOL_OPTS} ${LT_UNDEF} $(LIBS) -o'
|
||
|
|
LIB_OBJECT='${OBJECTS:.o=.lo}'
|
||
|
|
LIB_SUFFIX=.la
|
||
|
|
LIB_CLEAN='${LIBTOOL} --mode=clean'
|
||
|
|
LIB_COMPILE='${LIBTOOL} --mode=compile'
|
||
|
|
LIB_LINK='${LIBTOOL} --mode=link ${CC} ${LIBTOOL_OPTS}'
|
||
|
|
LIB_INSTALL='${LIBTOOL} --mode=install'
|
||
|
|
LIB_UNINSTALL='${LIBTOOL} --mode=uninstall'
|
||
|
|
LIB_PREP=:
|
||
|
|
|
||
|
|
CF_CHECK_LIBTOOL_VERSION
|
||
|
|
|
||
|
|
# special hack to add -no-undefined (which libtool should do for itself)
|
||
|
|
LT_UNDEF=
|
||
|
|
case "$cf_cv_system_name" in
|
||
|
|
(cygwin*|msys*|mingw32*|os2*|uwin*|aix[[4-7]])
|
||
|
|
LT_UNDEF=-no-undefined
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
AC_SUBST([LT_UNDEF])
|
||
|
|
|
||
|
|
# special hack to add --tag option for C++ compiler
|
||
|
|
case $cf_cv_libtool_version in
|
||
|
|
(1.[[5-9]]*|[[2-9]].[[0-9.a-z]]*)
|
||
|
|
LIBTOOL_CXX="$LIBTOOL --tag=CXX"
|
||
|
|
LIBTOOL="$LIBTOOL --tag=CC"
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
LIBTOOL_CXX="$LIBTOOL"
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
else
|
||
|
|
LIBTOOL=""
|
||
|
|
LIBTOOL_CXX=""
|
||
|
|
fi
|
||
|
|
|
||
|
|
test -z "$LIBTOOL" && ECHO_LT=
|
||
|
|
|
||
|
|
AC_SUBST(LIBTOOL)
|
||
|
|
AC_SUBST(LIBTOOL_CXX)
|
||
|
|
AC_SUBST(LIBTOOL_OPTS)
|
||
|
|
|
||
|
|
AC_SUBST(LIB_CREATE)
|
||
|
|
AC_SUBST(LIB_OBJECT)
|
||
|
|
AC_SUBST(LIB_SUFFIX)
|
||
|
|
AC_SUBST(LIB_PREP)
|
||
|
|
|
||
|
|
AC_SUBST(LIB_CLEAN)
|
||
|
|
AC_SUBST(LIB_COMPILE)
|
||
|
|
AC_SUBST(LIB_LINK)
|
||
|
|
AC_SUBST(LIB_INSTALL)
|
||
|
|
AC_SUBST(LIB_UNINSTALL)
|
||
|
|
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_WITH_LIBTOOL_OPTS version: 4 updated: 2015/04/17 21:13:04
|
||
|
|
dnl --------------------
|
||
|
|
dnl Allow user to pass additional libtool options into the library creation
|
||
|
|
dnl and link steps. The main use for this is to do something like
|
||
|
|
dnl ./configure --with-libtool-opts=-static
|
||
|
|
dnl to get the same behavior as automake-flavored
|
||
|
|
dnl ./configure --enable-static
|
||
|
|
AC_DEFUN([CF_WITH_LIBTOOL_OPTS],[
|
||
|
|
AC_MSG_CHECKING(for additional libtool options)
|
||
|
|
AC_ARG_WITH(libtool-opts,
|
||
|
|
[ --with-libtool-opts=XXX specify additional libtool options],
|
||
|
|
[with_libtool_opts=$withval],
|
||
|
|
[with_libtool_opts=no])
|
||
|
|
AC_MSG_RESULT($with_libtool_opts)
|
||
|
|
|
||
|
|
case .$with_libtool_opts in
|
||
|
|
(.yes|.no|.)
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
LIBTOOL_OPTS="$LIBTOOL_OPTS $with_libtool_opts"
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
AC_SUBST(LIBTOOL_OPTS)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_WITH_NCURSES_ETC version: 5 updated: 2016/02/20 19:23:20
|
||
|
|
dnl -------------------
|
||
|
|
dnl Use this macro for programs which use any variant of "curses", e.g.,
|
||
|
|
dnl "ncurses", and "PDCurses". Programs that can use curses and some unrelated
|
||
|
|
dnl library (such as slang) should use a "--with-screen=XXX" option.
|
||
|
|
dnl
|
||
|
|
dnl This does not use AC_DEFUN, because that would tell autoconf to run each
|
||
|
|
dnl of the macros inside this one - before this macro.
|
||
|
|
define([CF_WITH_NCURSES_ETC],[
|
||
|
|
CF_WITH_CURSES_DIR
|
||
|
|
|
||
|
|
cf_cv_screen=curses
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for specified curses library type)
|
||
|
|
AC_ARG_WITH(screen,
|
||
|
|
[ --with-screen=XXX use specified curses-libraries],
|
||
|
|
[cf_cv_screen=$withval],[
|
||
|
|
|
||
|
|
AC_ARG_WITH(ncursesw,
|
||
|
|
[ --with-ncursesw use wide ncurses-libraries],
|
||
|
|
[cf_cv_screen=ncursesw],[
|
||
|
|
|
||
|
|
AC_ARG_WITH(ncurses,
|
||
|
|
[ --with-ncurses use ncurses-libraries],
|
||
|
|
[cf_cv_screen=ncurses],[
|
||
|
|
|
||
|
|
AC_ARG_WITH(pdcurses,
|
||
|
|
[ --with-pdcurses compile/link with pdcurses X11 library],
|
||
|
|
[cf_cv_screen=pdcurses],[
|
||
|
|
|
||
|
|
AC_ARG_WITH(curses-colr,
|
||
|
|
[ --with-curses-colr compile/link with HPUX 10.x color-curses],
|
||
|
|
[cf_cv_screen=curses_colr],[
|
||
|
|
|
||
|
|
AC_ARG_WITH(curses-5lib,
|
||
|
|
[ --with-curses-5lib compile/link with SunOS 5lib curses],
|
||
|
|
[cf_cv_screen=curses_5lib])])])])])])
|
||
|
|
|
||
|
|
AC_MSG_RESULT($cf_cv_screen)
|
||
|
|
|
||
|
|
case $cf_cv_screen in
|
||
|
|
(curses|curses_*)
|
||
|
|
CF_CURSES_CONFIG
|
||
|
|
;;
|
||
|
|
(ncursesw*)
|
||
|
|
CF_UTF8_LIB
|
||
|
|
CF_NCURSES_CONFIG($cf_cv_screen)
|
||
|
|
;;
|
||
|
|
(ncurses*)
|
||
|
|
CF_NCURSES_CONFIG($cf_cv_screen)
|
||
|
|
;;
|
||
|
|
(pdcurses)
|
||
|
|
CF_PDCURSES_X11
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
AC_MSG_ERROR(unexpected screen-value: $cf_cv_screen)
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
CF_NCURSES_PTHREADS($cf_cv_screen)
|
||
|
|
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_WITH_NC_ALLOC_H version: 4 updated: 2008/11/01 12:44:02
|
||
|
|
dnl ------------------
|
||
|
|
dnl Applications that use ncurses can provide better leak-checking if they
|
||
|
|
dnl call ncurses' functions to free its memory on exit. That is normally not
|
||
|
|
dnl configured (--disable-leaks), but is useful in a debugging library.
|
||
|
|
dnl
|
||
|
|
dnl Use this after checking for ncurses/ncursesw libraries.
|
||
|
|
AC_DEFUN([CF_WITH_NC_ALLOC_H],
|
||
|
|
[
|
||
|
|
AC_REQUIRE([CF_DISABLE_LEAKS])
|
||
|
|
|
||
|
|
case $LIBS in #(vi
|
||
|
|
*ncurses*)
|
||
|
|
|
||
|
|
if test "$with_no_leaks" = yes ; then
|
||
|
|
AC_CHECK_HEADER(nc_alloc.h)
|
||
|
|
AC_CHECK_FUNCS(_nc_free_and_exit)
|
||
|
|
fi
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_WITH_REL_VERSION version: 1 updated: 2003/09/20 18:12:49
|
||
|
|
dnl -------------------
|
||
|
|
dnl Allow library's release-version to be overridden. Generally this happens when a
|
||
|
|
dnl packager has incremented the release-version past that used in the original package,
|
||
|
|
dnl and wishes to keep doing this.
|
||
|
|
dnl
|
||
|
|
dnl $1 is the package name, if any, to derive corresponding {package}_MAJOR
|
||
|
|
dnl and {package}_MINOR symbols
|
||
|
|
dnl symbol.
|
||
|
|
AC_DEFUN([CF_WITH_REL_VERSION],[
|
||
|
|
test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0
|
||
|
|
AC_ARG_WITH(rel-version,
|
||
|
|
[ --with-rel-version=XXX override derived release version],
|
||
|
|
[AC_MSG_WARN(overriding release version $cf_cv_rel_version to $withval)
|
||
|
|
cf_cv_rel_version=$withval])
|
||
|
|
ifelse($1,,[
|
||
|
|
CF_NUMBER_SYNTAX($cf_cv_rel_version,Release version)
|
||
|
|
],[
|
||
|
|
$1_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'`
|
||
|
|
$1_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[[^.]]*//' -e 's/^\.//' -e 's/\..*//'`
|
||
|
|
CF_NUMBER_SYNTAX([$]$1_MAJOR,Release major-version)
|
||
|
|
CF_NUMBER_SYNTAX([$]$1_MINOR,Release minor-version)
|
||
|
|
])
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_WITH_SHARED_OR_LIBTOOL version: 7 updated: 2014/11/02 16:11:49
|
||
|
|
dnl -------------------------
|
||
|
|
dnl Provide shared libraries using either autoconf macros (--with-shared) or
|
||
|
|
dnl using the external libtool script (--with-libtool).
|
||
|
|
dnl
|
||
|
|
dnl $1 = program name (all caps preferred)
|
||
|
|
dnl $1 = release version
|
||
|
|
dnl $2 = ABI version
|
||
|
|
define([CF_WITH_SHARED_OR_LIBTOOL],[
|
||
|
|
|
||
|
|
REL_VERSION=$2
|
||
|
|
ABI_VERSION=$3
|
||
|
|
cf_cv_rel_version=$REL_VERSION
|
||
|
|
AC_SUBST(ABI_VERSION)
|
||
|
|
AC_SUBST(REL_VERSION)
|
||
|
|
|
||
|
|
CF_WITH_REL_VERSION($1)
|
||
|
|
CF_WITH_ABI_VERSION
|
||
|
|
|
||
|
|
LIB_MODEL=static
|
||
|
|
DFT_LWR_MODEL=$LIB_MODEL
|
||
|
|
LIBTOOL_MAKE="#"
|
||
|
|
|
||
|
|
# use to comment-out makefile lines
|
||
|
|
MAKE_NORMAL=
|
||
|
|
MAKE_STATIC=
|
||
|
|
MAKE_SHARED="#"
|
||
|
|
MAKE_DLLS="#"
|
||
|
|
|
||
|
|
shlibdir=$libdir
|
||
|
|
AC_SUBST(shlibdir)
|
||
|
|
|
||
|
|
CF_WITH_LIBTOOL
|
||
|
|
|
||
|
|
LIB_CREATE="$LIB_CREATE \[$]@"
|
||
|
|
|
||
|
|
if test "$with_libtool" = "yes" ; then
|
||
|
|
OBJEXT="lo"
|
||
|
|
LIB_MODEL=libtool
|
||
|
|
DFT_LWR_MODEL=$LIB_MODEL
|
||
|
|
LIBTOOL_MAKE=
|
||
|
|
CF_WITH_LIBTOOL_OPTS
|
||
|
|
CF_WITH_EXPORT_SYMS
|
||
|
|
MAKE_NORMAL="#"
|
||
|
|
MAKE_STATIC="#"
|
||
|
|
MAKE_SHARED=
|
||
|
|
else
|
||
|
|
AC_MSG_CHECKING(if you want to build shared libraries)
|
||
|
|
AC_ARG_WITH(shared,
|
||
|
|
[ --with-shared generate shared-libraries],
|
||
|
|
[with_shared=$withval],
|
||
|
|
[with_shared=no])
|
||
|
|
AC_MSG_RESULT($with_shared)
|
||
|
|
if test "$with_shared" = "yes" ; then
|
||
|
|
LIB_MODEL=shared
|
||
|
|
DFT_LWR_MODEL=$LIB_MODEL
|
||
|
|
CF_SHARED_OPTS
|
||
|
|
CF_WITH_VERSIONED_SYMS
|
||
|
|
LIB_PREP=:
|
||
|
|
LIB_CREATE="[$]MK_SHARED_LIB"
|
||
|
|
CFLAGS="$CFLAGS $CC_SHARED_OPTS"
|
||
|
|
MAKE_NORMAL="#"
|
||
|
|
MAKE_STATIC="#"
|
||
|
|
MAKE_SHARED=
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
|
||
|
|
LIB_SUFFIX=
|
||
|
|
CF_LIB_SUFFIX($LIB_MODEL, DFT_LIB_SUFFIX, DFT_DEP_SUFFIX)
|
||
|
|
LIB_SUFFIX=$DFT_LIB_SUFFIX
|
||
|
|
|
||
|
|
AC_SUBST(DFT_LWR_MODEL)
|
||
|
|
AC_SUBST(DFT_LIB_SUFFIX)
|
||
|
|
AC_SUBST(DFT_DEP_SUFFIX)
|
||
|
|
AC_SUBST(LIB_MODEL)
|
||
|
|
|
||
|
|
AC_SUBST(LIBTOOL_MAKE)
|
||
|
|
|
||
|
|
AC_SUBST(MAKE_DLLS)
|
||
|
|
AC_SUBST(MAKE_NORMAL)
|
||
|
|
AC_SUBST(MAKE_SHARED)
|
||
|
|
AC_SUBST(MAKE_STATIC)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
|
||
|
|
dnl ----------------
|
||
|
|
AC_DEFUN([CF_WITH_VALGRIND],[
|
||
|
|
CF_NO_LEAKS_OPTION(valgrind,
|
||
|
|
[ --with-valgrind test: use valgrind],
|
||
|
|
[USE_VALGRIND])
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_WITH_VERSIONED_SYMS version: 7 updated: 2015/10/24 20:50:26
|
||
|
|
dnl ----------------------
|
||
|
|
dnl Use this when building shared library with ELF, to markup symbols with the
|
||
|
|
dnl version identifier from the given input file. Generally that identifier is
|
||
|
|
dnl the same as the SONAME at which the symbol was first introduced.
|
||
|
|
dnl
|
||
|
|
dnl $1 = basename of the ".map" file (default $PACKAGE)
|
||
|
|
AC_DEFUN([CF_WITH_VERSIONED_SYMS],
|
||
|
|
[
|
||
|
|
AC_MSG_CHECKING(if versioned-symbols file should be used)
|
||
|
|
AC_ARG_WITH(versioned-syms,
|
||
|
|
[ --with-versioned-syms=X markup versioned symbols using ld],
|
||
|
|
[with_versioned_syms=$withval],
|
||
|
|
[with_versioned_syms=no])
|
||
|
|
if test "x$with_versioned_syms" = xyes
|
||
|
|
then
|
||
|
|
with_versioned_syms='${top_srcdir}/package/ifelse($1,,${PACKAGE},[$1]).map'
|
||
|
|
AC_SUBST(PACKAGE)
|
||
|
|
fi
|
||
|
|
AC_MSG_RESULT($with_versioned_syms)
|
||
|
|
|
||
|
|
RESULTING_SYMS=
|
||
|
|
VERSIONED_SYMS=
|
||
|
|
WILDCARD_SYMS=
|
||
|
|
|
||
|
|
if test "x$with_versioned_syms" != xno
|
||
|
|
then
|
||
|
|
RESULTING_SYMS=$with_versioned_syms
|
||
|
|
case "x$MK_SHARED_LIB" in
|
||
|
|
(*-Wl,*)
|
||
|
|
VERSIONED_SYMS="-Wl,--version-script,\${RESULTING_SYMS}"
|
||
|
|
MK_SHARED_LIB=`echo "$MK_SHARED_LIB" | sed -e "s%-Wl,%\\[$]{VERSIONED_SYMS} -Wl,%"`
|
||
|
|
CF_VERBOSE(MK_SHARED_LIB: $MK_SHARED_LIB)
|
||
|
|
;;
|
||
|
|
(*-dy\ *)
|
||
|
|
VERSIONED_SYMS="-Wl,-M,\${RESULTING_SYMS}"
|
||
|
|
MK_SHARED_LIB=`echo "$MK_SHARED_LIB" | sed -e "s%-dy%\\[$]{VERSIONED_SYMS} -dy%"`
|
||
|
|
CF_VERBOSE(MK_SHARED_LIB: $MK_SHARED_LIB)
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
AC_MSG_WARN(this system does not support versioned-symbols)
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
# Linux ld can selectively override scope, e.g., of symbols beginning with
|
||
|
|
# "_" by first declaring some as global, and then using a wildcard to
|
||
|
|
# declare the others as local. Some other loaders cannot do this. Check
|
||
|
|
# by constructing a (very) simple shared library and inspecting its
|
||
|
|
# symbols.
|
||
|
|
if test "x$VERSIONED_SYMS" != "x"
|
||
|
|
then
|
||
|
|
AC_MSG_CHECKING(if wildcards can be used to selectively omit symbols)
|
||
|
|
WILDCARD_SYMS=no
|
||
|
|
|
||
|
|
# make sources
|
||
|
|
rm -f conftest.*
|
||
|
|
|
||
|
|
cat >conftest.ver <<EOF
|
||
|
|
module_1.0 {
|
||
|
|
global:
|
||
|
|
globalf1;
|
||
|
|
local:
|
||
|
|
localf1;
|
||
|
|
};
|
||
|
|
module_2.0 {
|
||
|
|
global:
|
||
|
|
globalf2;
|
||
|
|
local:
|
||
|
|
localf2;
|
||
|
|
_*;
|
||
|
|
} module_1.0;
|
||
|
|
submodule_1.0 {
|
||
|
|
global:
|
||
|
|
subglobalf1;
|
||
|
|
_ismissing;
|
||
|
|
local:
|
||
|
|
sublocalf1;
|
||
|
|
};
|
||
|
|
submodule_2.0 {
|
||
|
|
global:
|
||
|
|
subglobalf2;
|
||
|
|
local:
|
||
|
|
sublocalf2;
|
||
|
|
_*;
|
||
|
|
} submodule_1.0;
|
||
|
|
EOF
|
||
|
|
cat >conftest.$ac_ext <<EOF
|
||
|
|
#line __oline__ "configure"
|
||
|
|
int _ismissing(void) { return 1; }
|
||
|
|
int _localf1(void) { return 1; }
|
||
|
|
int _localf2(void) { return 2; }
|
||
|
|
int globalf1(void) { return 1; }
|
||
|
|
int globalf2(void) { return 2; }
|
||
|
|
int _sublocalf1(void) { return 1; }
|
||
|
|
int _sublocalf2(void) { return 2; }
|
||
|
|
int subglobalf1(void) { return 1; }
|
||
|
|
int subglobalf2(void) { return 2; }
|
||
|
|
EOF
|
||
|
|
cat >conftest.mk <<EOF
|
||
|
|
CC=${CC}
|
||
|
|
CFLAGS=${CFLAGS}
|
||
|
|
CPPFLAGS=${CPPFLAGS}
|
||
|
|
LDFLAGS=${LDFLAGS}
|
||
|
|
LIBS=${LIBS}
|
||
|
|
VERSIONED_SYMS=${VERSIONED_SYMS}
|
||
|
|
RESULTING_SYMS=conftest.ver
|
||
|
|
MK_SHARED_LIB=${MK_SHARED_LIB}
|
||
|
|
conftest.so: conftest.$ac_cv_objext
|
||
|
|
\$(MK_SHARED_LIB) conftest.$ac_cv_objext
|
||
|
|
EOF
|
||
|
|
|
||
|
|
# compile source, make library
|
||
|
|
if make -f conftest.mk 2>&AC_FD_CC >/dev/null
|
||
|
|
then
|
||
|
|
# test for missing symbol in either Data or Text section
|
||
|
|
cf_missing=`nm -P conftest.so 2>&AC_FD_CC |fgrep _ismissing | egrep '[[ ]][[DT]][[ ]]'`
|
||
|
|
test -n "$cf_missing" && WILDCARD_SYMS=yes
|
||
|
|
fi
|
||
|
|
AC_MSG_RESULT($WILDCARD_SYMS)
|
||
|
|
rm -f conftest.*
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
AC_SUBST(RESULTING_SYMS)
|
||
|
|
AC_SUBST(VERSIONED_SYMS)
|
||
|
|
AC_SUBST(WILDCARD_SYMS)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_WITH_WARNINGS version: 5 updated: 2004/07/23 14:40:34
|
||
|
|
dnl ----------------
|
||
|
|
dnl Combine the checks for gcc features into a configure-script option
|
||
|
|
dnl
|
||
|
|
dnl Parameters:
|
||
|
|
dnl $1 - see CF_GCC_WARNINGS
|
||
|
|
AC_DEFUN([CF_WITH_WARNINGS],
|
||
|
|
[
|
||
|
|
if ( test "$GCC" = yes || test "$GXX" = yes )
|
||
|
|
then
|
||
|
|
AC_MSG_CHECKING(if you want to check for gcc warnings)
|
||
|
|
AC_ARG_WITH(warnings,
|
||
|
|
[ --with-warnings test: turn on gcc warnings],
|
||
|
|
[cf_opt_with_warnings=$withval],
|
||
|
|
[cf_opt_with_warnings=no])
|
||
|
|
AC_MSG_RESULT($cf_opt_with_warnings)
|
||
|
|
if test "$cf_opt_with_warnings" != no ; then
|
||
|
|
CF_GCC_ATTRIBUTES
|
||
|
|
CF_GCC_WARNINGS([$1])
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_XOPEN_CURSES version: 13 updated: 2015/12/12 20:59:52
|
||
|
|
dnl ---------------
|
||
|
|
dnl Test if we should define X/Open source for curses, needed on Digital Unix
|
||
|
|
dnl 4.x, to see the extended functions, but breaks on IRIX 6.x.
|
||
|
|
dnl
|
||
|
|
dnl The getbegyx() check is needed for HPUX, which omits legacy macros such
|
||
|
|
dnl as getbegy(). The latter is better design, but the former is standard.
|
||
|
|
AC_DEFUN([CF_XOPEN_CURSES],
|
||
|
|
[
|
||
|
|
AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
|
||
|
|
AC_CACHE_CHECK(definition to turn on extended curses functions,cf_cv_need_xopen_extension,[
|
||
|
|
cf_cv_need_xopen_extension=unknown
|
||
|
|
AC_TRY_LINK([
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <${cf_cv_ncurses_header:-curses.h}>],[
|
||
|
|
#if defined(NCURSES_VERSION_PATCH)
|
||
|
|
#if (NCURSES_VERSION_PATCH < 20100501) && (NCURSES_VERSION_PATCH >= 20100403)
|
||
|
|
make an error
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#ifdef NCURSES_VERSION
|
||
|
|
cchar_t check;
|
||
|
|
int check2 = curs_set((int)sizeof(check));
|
||
|
|
#endif
|
||
|
|
long x = winnstr(stdscr, "", 0);
|
||
|
|
int x1, y1;
|
||
|
|
getbegyx(stdscr, y1, x1)],
|
||
|
|
[cf_cv_need_xopen_extension=none],
|
||
|
|
[
|
||
|
|
for cf_try_xopen_extension in _XOPEN_SOURCE_EXTENDED NCURSES_WIDECHAR
|
||
|
|
do
|
||
|
|
AC_TRY_LINK([
|
||
|
|
#define $cf_try_xopen_extension 1
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <${cf_cv_ncurses_header:-curses.h}>],[
|
||
|
|
#ifdef NCURSES_VERSION
|
||
|
|
cchar_t check;
|
||
|
|
int check2 = curs_set((int)sizeof(check));
|
||
|
|
#endif
|
||
|
|
long x = winnstr(stdscr, "", 0);
|
||
|
|
int x1, y1;
|
||
|
|
getbegyx(stdscr, y1, x1)],
|
||
|
|
[cf_cv_need_xopen_extension=$cf_try_xopen_extension; break])
|
||
|
|
done
|
||
|
|
])
|
||
|
|
])
|
||
|
|
|
||
|
|
case $cf_cv_need_xopen_extension in
|
||
|
|
(*_*)
|
||
|
|
CPPFLAGS="$CPPFLAGS -D$cf_cv_need_xopen_extension"
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_XOPEN_SOURCE version: 52 updated: 2016/08/27 12:21:42
|
||
|
|
dnl ---------------
|
||
|
|
dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
|
||
|
|
dnl or adapt to the vendor's definitions to get equivalent functionality,
|
||
|
|
dnl without losing the common non-POSIX features.
|
||
|
|
dnl
|
||
|
|
dnl Parameters:
|
||
|
|
dnl $1 is the nominal value for _XOPEN_SOURCE
|
||
|
|
dnl $2 is the nominal value for _POSIX_C_SOURCE
|
||
|
|
AC_DEFUN([CF_XOPEN_SOURCE],[
|
||
|
|
AC_REQUIRE([AC_CANONICAL_HOST])
|
||
|
|
|
||
|
|
cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
|
||
|
|
cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
|
||
|
|
cf_xopen_source=
|
||
|
|
|
||
|
|
case $host_os in
|
||
|
|
(aix[[4-7]]*)
|
||
|
|
cf_xopen_source="-D_ALL_SOURCE"
|
||
|
|
;;
|
||
|
|
(msys)
|
||
|
|
cf_XOPEN_SOURCE=600
|
||
|
|
;;
|
||
|
|
(darwin[[0-8]].*)
|
||
|
|
cf_xopen_source="-D_APPLE_C_SOURCE"
|
||
|
|
;;
|
||
|
|
(darwin*)
|
||
|
|
cf_xopen_source="-D_DARWIN_C_SOURCE"
|
||
|
|
cf_XOPEN_SOURCE=
|
||
|
|
;;
|
||
|
|
(freebsd*|dragonfly*)
|
||
|
|
# 5.x headers associate
|
||
|
|
# _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
|
||
|
|
# _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
|
||
|
|
cf_POSIX_C_SOURCE=200112L
|
||
|
|
cf_XOPEN_SOURCE=600
|
||
|
|
cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
|
||
|
|
;;
|
||
|
|
(hpux11*)
|
||
|
|
cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
|
||
|
|
;;
|
||
|
|
(hpux*)
|
||
|
|
cf_xopen_source="-D_HPUX_SOURCE"
|
||
|
|
;;
|
||
|
|
(irix[[56]].*)
|
||
|
|
cf_xopen_source="-D_SGI_SOURCE"
|
||
|
|
cf_XOPEN_SOURCE=
|
||
|
|
;;
|
||
|
|
(linux*|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin)
|
||
|
|
CF_GNU_SOURCE
|
||
|
|
;;
|
||
|
|
(minix*)
|
||
|
|
cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
|
||
|
|
;;
|
||
|
|
(mirbsd*)
|
||
|
|
# setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
|
||
|
|
cf_XOPEN_SOURCE=
|
||
|
|
CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
|
||
|
|
;;
|
||
|
|
(netbsd*)
|
||
|
|
cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
|
||
|
|
;;
|
||
|
|
(openbsd[[4-9]]*)
|
||
|
|
# setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
|
||
|
|
cf_xopen_source="-D_BSD_SOURCE"
|
||
|
|
cf_XOPEN_SOURCE=600
|
||
|
|
;;
|
||
|
|
(openbsd*)
|
||
|
|
# setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
|
||
|
|
;;
|
||
|
|
(osf[[45]]*)
|
||
|
|
cf_xopen_source="-D_OSF_SOURCE"
|
||
|
|
;;
|
||
|
|
(nto-qnx*)
|
||
|
|
cf_xopen_source="-D_QNX_SOURCE"
|
||
|
|
;;
|
||
|
|
(sco*)
|
||
|
|
# setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
|
||
|
|
;;
|
||
|
|
(solaris2.*)
|
||
|
|
cf_xopen_source="-D__EXTENSIONS__"
|
||
|
|
cf_cv_xopen_source=broken
|
||
|
|
;;
|
||
|
|
(sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
|
||
|
|
cf_XOPEN_SOURCE=
|
||
|
|
cf_POSIX_C_SOURCE=
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
CF_TRY_XOPEN_SOURCE
|
||
|
|
CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
if test -n "$cf_xopen_source" ; then
|
||
|
|
CF_ADD_CFLAGS($cf_xopen_source,true)
|
||
|
|
fi
|
||
|
|
|
||
|
|
dnl In anything but the default case, we may have system-specific setting
|
||
|
|
dnl which is still not guaranteed to provide all of the entrypoints that
|
||
|
|
dnl _XOPEN_SOURCE would yield.
|
||
|
|
if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
|
||
|
|
AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
|
||
|
|
AC_TRY_COMPILE([#include <stdlib.h>],[
|
||
|
|
#ifndef _XOPEN_SOURCE
|
||
|
|
make an error
|
||
|
|
#endif],
|
||
|
|
[cf_XOPEN_SOURCE_set=yes],
|
||
|
|
[cf_XOPEN_SOURCE_set=no])
|
||
|
|
AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
|
||
|
|
if test $cf_XOPEN_SOURCE_set = yes
|
||
|
|
then
|
||
|
|
AC_TRY_COMPILE([#include <stdlib.h>],[
|
||
|
|
#if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
|
||
|
|
make an error
|
||
|
|
#endif],
|
||
|
|
[cf_XOPEN_SOURCE_set_ok=yes],
|
||
|
|
[cf_XOPEN_SOURCE_set_ok=no])
|
||
|
|
if test $cf_XOPEN_SOURCE_set_ok = no
|
||
|
|
then
|
||
|
|
AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
|
||
|
|
fi
|
||
|
|
else
|
||
|
|
CF_TRY_XOPEN_SOURCE
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
])
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_X_ATHENA version: 23 updated: 2015/04/12 15:39:00
|
||
|
|
dnl -----------
|
||
|
|
dnl Check for Xaw (Athena) libraries
|
||
|
|
dnl
|
||
|
|
dnl Sets $cf_x_athena according to the flavor of Xaw which is used.
|
||
|
|
AC_DEFUN([CF_X_ATHENA],
|
||
|
|
[
|
||
|
|
cf_x_athena=${cf_x_athena:-Xaw}
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(if you want to link with Xaw 3d library)
|
||
|
|
withval=
|
||
|
|
AC_ARG_WITH(Xaw3d,
|
||
|
|
[ --with-Xaw3d link with Xaw 3d library])
|
||
|
|
if test "$withval" = yes ; then
|
||
|
|
cf_x_athena=Xaw3d
|
||
|
|
AC_MSG_RESULT(yes)
|
||
|
|
else
|
||
|
|
AC_MSG_RESULT(no)
|
||
|
|
fi
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(if you want to link with Xaw 3d xft library)
|
||
|
|
withval=
|
||
|
|
AC_ARG_WITH(Xaw3dxft,
|
||
|
|
[ --with-Xaw3dxft link with Xaw 3d xft library])
|
||
|
|
if test "$withval" = yes ; then
|
||
|
|
cf_x_athena=Xaw3dxft
|
||
|
|
AC_MSG_RESULT(yes)
|
||
|
|
else
|
||
|
|
AC_MSG_RESULT(no)
|
||
|
|
fi
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(if you want to link with neXT Athena library)
|
||
|
|
withval=
|
||
|
|
AC_ARG_WITH(neXtaw,
|
||
|
|
[ --with-neXtaw link with neXT Athena library])
|
||
|
|
if test "$withval" = yes ; then
|
||
|
|
cf_x_athena=neXtaw
|
||
|
|
AC_MSG_RESULT(yes)
|
||
|
|
else
|
||
|
|
AC_MSG_RESULT(no)
|
||
|
|
fi
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(if you want to link with Athena-Plus library)
|
||
|
|
withval=
|
||
|
|
AC_ARG_WITH(XawPlus,
|
||
|
|
[ --with-XawPlus link with Athena-Plus library])
|
||
|
|
if test "$withval" = yes ; then
|
||
|
|
cf_x_athena=XawPlus
|
||
|
|
AC_MSG_RESULT(yes)
|
||
|
|
else
|
||
|
|
AC_MSG_RESULT(no)
|
||
|
|
fi
|
||
|
|
|
||
|
|
cf_x_athena_lib=""
|
||
|
|
|
||
|
|
if test "$PKG_CONFIG" != none ; then
|
||
|
|
cf_athena_list=
|
||
|
|
test "$cf_x_athena" = Xaw && cf_athena_list="xaw8 xaw7 xaw6"
|
||
|
|
for cf_athena_pkg in \
|
||
|
|
$cf_athena_list \
|
||
|
|
${cf_x_athena} \
|
||
|
|
${cf_x_athena}-devel \
|
||
|
|
lib${cf_x_athena} \
|
||
|
|
lib${cf_x_athena}-devel
|
||
|
|
do
|
||
|
|
CF_TRY_PKG_CONFIG($cf_athena_pkg,[
|
||
|
|
cf_x_athena_lib="$cf_pkgconfig_libs"
|
||
|
|
CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
|
||
|
|
AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
|
||
|
|
|
||
|
|
CF_TRIM_X_LIBS
|
||
|
|
|
||
|
|
AC_CACHE_CHECK(for usable $cf_x_athena/Xmu package,cf_cv_xaw_compat,[
|
||
|
|
AC_TRY_LINK([
|
||
|
|
#include <X11/Xmu/CharSet.h>
|
||
|
|
],[
|
||
|
|
int check = XmuCompareISOLatin1("big", "small")
|
||
|
|
],[cf_cv_xaw_compat=yes],[cf_cv_xaw_compat=no])])
|
||
|
|
|
||
|
|
if test "$cf_cv_xaw_compat" = no
|
||
|
|
then
|
||
|
|
# workaround for broken ".pc" files...
|
||
|
|
case "$cf_x_athena_lib" in
|
||
|
|
(*-lXmu*)
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
CF_VERBOSE(work around broken package)
|
||
|
|
cf_save_xmu="$LIBS"
|
||
|
|
cf_first_lib=`echo "$cf_save_xmu" | sed -e 's/^[ ][ ]*//' -e 's/ .*//'`
|
||
|
|
CF_TRY_PKG_CONFIG(xmu,[
|
||
|
|
LIBS="$cf_save_xmu"
|
||
|
|
CF_ADD_LIB_AFTER($cf_first_lib,$cf_pkgconfig_libs)
|
||
|
|
],[
|
||
|
|
CF_ADD_LIB_AFTER($cf_first_lib,-lXmu)
|
||
|
|
])
|
||
|
|
CF_TRIM_X_LIBS
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
fi
|
||
|
|
|
||
|
|
break])
|
||
|
|
done
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test -z "$cf_x_athena_lib" ; then
|
||
|
|
CF_X_EXT
|
||
|
|
CF_X_TOOLKIT
|
||
|
|
CF_X_ATHENA_CPPFLAGS($cf_x_athena)
|
||
|
|
CF_X_ATHENA_LIBS($cf_x_athena)
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_X_ATHENA_CPPFLAGS version: 5 updated: 2010/05/26 17:35:30
|
||
|
|
dnl --------------------
|
||
|
|
dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
|
||
|
|
dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
|
||
|
|
AC_DEFUN([CF_X_ATHENA_CPPFLAGS],
|
||
|
|
[
|
||
|
|
cf_x_athena_root=ifelse([$1],,Xaw,[$1])
|
||
|
|
cf_x_athena_inc=""
|
||
|
|
|
||
|
|
for cf_path in default \
|
||
|
|
/usr/contrib/X11R6 \
|
||
|
|
/usr/contrib/X11R5 \
|
||
|
|
/usr/lib/X11R5 \
|
||
|
|
/usr/local
|
||
|
|
do
|
||
|
|
if test -z "$cf_x_athena_inc" ; then
|
||
|
|
cf_save="$CPPFLAGS"
|
||
|
|
cf_test=X11/$cf_x_athena_root/SimpleMenu.h
|
||
|
|
if test $cf_path != default ; then
|
||
|
|
CPPFLAGS="$cf_save -I$cf_path/include"
|
||
|
|
AC_MSG_CHECKING(for $cf_test in $cf_path)
|
||
|
|
else
|
||
|
|
AC_MSG_CHECKING(for $cf_test)
|
||
|
|
fi
|
||
|
|
AC_TRY_COMPILE([
|
||
|
|
#include <X11/Intrinsic.h>
|
||
|
|
#include <$cf_test>],[],
|
||
|
|
[cf_result=yes],
|
||
|
|
[cf_result=no])
|
||
|
|
AC_MSG_RESULT($cf_result)
|
||
|
|
if test "$cf_result" = yes ; then
|
||
|
|
cf_x_athena_inc=$cf_path
|
||
|
|
break
|
||
|
|
else
|
||
|
|
CPPFLAGS="$cf_save"
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
done
|
||
|
|
|
||
|
|
if test -z "$cf_x_athena_inc" ; then
|
||
|
|
AC_MSG_WARN(
|
||
|
|
[Unable to successfully find Athena header files with test program])
|
||
|
|
elif test "$cf_x_athena_inc" != default ; then
|
||
|
|
CPPFLAGS="$CPPFLAGS -I$cf_x_athena_inc"
|
||
|
|
fi
|
||
|
|
])
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_X_ATHENA_LIBS version: 12 updated: 2011/07/17 19:55:02
|
||
|
|
dnl ----------------
|
||
|
|
dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
|
||
|
|
dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
|
||
|
|
AC_DEFUN([CF_X_ATHENA_LIBS],
|
||
|
|
[AC_REQUIRE([CF_X_TOOLKIT])
|
||
|
|
cf_x_athena_root=ifelse([$1],,Xaw,[$1])
|
||
|
|
cf_x_athena_lib=""
|
||
|
|
|
||
|
|
for cf_path in default \
|
||
|
|
/usr/contrib/X11R6 \
|
||
|
|
/usr/contrib/X11R5 \
|
||
|
|
/usr/lib/X11R5 \
|
||
|
|
/usr/local
|
||
|
|
do
|
||
|
|
for cf_lib in \
|
||
|
|
${cf_x_athena_root} \
|
||
|
|
${cf_x_athena_root}7 \
|
||
|
|
${cf_x_athena_root}6
|
||
|
|
do
|
||
|
|
for cf_libs in \
|
||
|
|
"-l$cf_lib -lXmu" \
|
||
|
|
"-l$cf_lib -lXpm -lXmu" \
|
||
|
|
"-l${cf_lib}_s -lXmu_s"
|
||
|
|
do
|
||
|
|
if test -z "$cf_x_athena_lib" ; then
|
||
|
|
cf_save="$LIBS"
|
||
|
|
cf_test=XawSimpleMenuAddGlobalActions
|
||
|
|
if test $cf_path != default ; then
|
||
|
|
CF_ADD_LIBS(-L$cf_path/lib $cf_libs)
|
||
|
|
AC_MSG_CHECKING(for $cf_libs in $cf_path)
|
||
|
|
else
|
||
|
|
CF_ADD_LIBS($cf_libs)
|
||
|
|
AC_MSG_CHECKING(for $cf_test in $cf_libs)
|
||
|
|
fi
|
||
|
|
AC_TRY_LINK([
|
||
|
|
#include <X11/Intrinsic.h>
|
||
|
|
#include <X11/$cf_x_athena_root/SimpleMenu.h>
|
||
|
|
],[
|
||
|
|
$cf_test((XtAppContext) 0)],
|
||
|
|
[cf_result=yes],
|
||
|
|
[cf_result=no])
|
||
|
|
AC_MSG_RESULT($cf_result)
|
||
|
|
if test "$cf_result" = yes ; then
|
||
|
|
cf_x_athena_lib="$cf_libs"
|
||
|
|
break
|
||
|
|
fi
|
||
|
|
LIBS="$cf_save"
|
||
|
|
fi
|
||
|
|
done # cf_libs
|
||
|
|
test -n "$cf_x_athena_lib" && break
|
||
|
|
done # cf_lib
|
||
|
|
done
|
||
|
|
|
||
|
|
if test -z "$cf_x_athena_lib" ; then
|
||
|
|
AC_MSG_ERROR(
|
||
|
|
[Unable to successfully link Athena library (-l$cf_x_athena_root) with test program])
|
||
|
|
fi
|
||
|
|
|
||
|
|
CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
|
||
|
|
AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
|
||
|
|
])
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_X_EXT version: 3 updated: 2010/06/02 05:03:05
|
||
|
|
dnl --------
|
||
|
|
AC_DEFUN([CF_X_EXT],[
|
||
|
|
CF_TRY_PKG_CONFIG(Xext,,[
|
||
|
|
AC_CHECK_LIB(Xext,XextCreateExtension,
|
||
|
|
[CF_ADD_LIB(Xext)])])
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF_X_TOOLKIT version: 23 updated: 2015/04/12 15:39:00
|
||
|
|
dnl ------------
|
||
|
|
dnl Check for X Toolkit libraries
|
||
|
|
AC_DEFUN([CF_X_TOOLKIT],
|
||
|
|
[
|
||
|
|
AC_REQUIRE([AC_PATH_XTRA])
|
||
|
|
AC_REQUIRE([CF_CHECK_CACHE])
|
||
|
|
|
||
|
|
# OSX is schizoid about who owns /usr/X11 (old) versus /opt/X11 (new), and (and
|
||
|
|
# in some cases has installed dummy files in the former, other cases replaced
|
||
|
|
# it with a link to the new location). This complicates the configure script.
|
||
|
|
# Check for that pitfall, and recover using pkg-config
|
||
|
|
#
|
||
|
|
# If none of these are set, the configuration is almost certainly broken.
|
||
|
|
if test -z "${X_CFLAGS}${X_PRE_LIBS}${X_LIBS}${X_EXTRA_LIBS}"
|
||
|
|
then
|
||
|
|
CF_TRY_PKG_CONFIG(x11,,[AC_MSG_WARN(unable to find X11 library)])
|
||
|
|
CF_TRY_PKG_CONFIG(ice,,[AC_MSG_WARN(unable to find ICE library)])
|
||
|
|
CF_TRY_PKG_CONFIG(sm,,[AC_MSG_WARN(unable to find SM library)])
|
||
|
|
CF_TRY_PKG_CONFIG(xt,,[AC_MSG_WARN(unable to find Xt library)])
|
||
|
|
fi
|
||
|
|
|
||
|
|
cf_have_X_LIBS=no
|
||
|
|
|
||
|
|
CF_TRY_PKG_CONFIG(xt,[
|
||
|
|
|
||
|
|
case "x$LIBS" in
|
||
|
|
(*-lX11*)
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
# we have an "xt" package, but it may omit Xt's dependency on X11
|
||
|
|
AC_CACHE_CHECK(for usable X dependency,cf_cv_xt_x11_compat,[
|
||
|
|
AC_TRY_LINK([
|
||
|
|
#include <X11/Xlib.h>
|
||
|
|
],[
|
||
|
|
int rc1 = XDrawLine((Display*) 0, (Drawable) 0, (GC) 0, 0, 0, 0, 0);
|
||
|
|
int rc2 = XClearWindow((Display*) 0, (Window) 0);
|
||
|
|
int rc3 = XMoveWindow((Display*) 0, (Window) 0, 0, 0);
|
||
|
|
int rc4 = XMoveResizeWindow((Display*)0, (Window)0, 0, 0, 0, 0);
|
||
|
|
],[cf_cv_xt_x11_compat=yes],[cf_cv_xt_x11_compat=no])])
|
||
|
|
if test "$cf_cv_xt_x11_compat" = no
|
||
|
|
then
|
||
|
|
CF_VERBOSE(work around broken X11 dependency)
|
||
|
|
# 2010/11/19 - good enough until a working Xt on Xcb is delivered.
|
||
|
|
CF_TRY_PKG_CONFIG(x11,,[CF_ADD_LIB_AFTER(-lXt,-lX11)])
|
||
|
|
fi
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
AC_CACHE_CHECK(for usable X Toolkit package,cf_cv_xt_ice_compat,[
|
||
|
|
AC_TRY_LINK([
|
||
|
|
#include <X11/Shell.h>
|
||
|
|
],[int num = IceConnectionNumber(0)
|
||
|
|
],[cf_cv_xt_ice_compat=yes],[cf_cv_xt_ice_compat=no])])
|
||
|
|
|
||
|
|
if test "$cf_cv_xt_ice_compat" = no
|
||
|
|
then
|
||
|
|
# workaround for broken ".pc" files used for X Toolkit.
|
||
|
|
case "x$X_PRE_LIBS" in
|
||
|
|
(*-lICE*)
|
||
|
|
case "x$LIBS" in
|
||
|
|
(*-lICE*)
|
||
|
|
;;
|
||
|
|
(*)
|
||
|
|
CF_VERBOSE(work around broken ICE dependency)
|
||
|
|
CF_TRY_PKG_CONFIG(ice,
|
||
|
|
[CF_TRY_PKG_CONFIG(sm)],
|
||
|
|
[CF_ADD_LIB_AFTER(-lXt,$X_PRE_LIBS)])
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
fi
|
||
|
|
|
||
|
|
cf_have_X_LIBS=yes
|
||
|
|
],[
|
||
|
|
|
||
|
|
LDFLAGS="$X_LIBS $LDFLAGS"
|
||
|
|
CF_CHECK_CFLAGS($X_CFLAGS)
|
||
|
|
|
||
|
|
AC_CHECK_FUNC(XOpenDisplay,,[
|
||
|
|
AC_CHECK_LIB(X11,XOpenDisplay,
|
||
|
|
[CF_ADD_LIB(X11)],,
|
||
|
|
[$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])])
|
||
|
|
|
||
|
|
AC_CHECK_FUNC(XtAppInitialize,,[
|
||
|
|
AC_CHECK_LIB(Xt, XtAppInitialize,
|
||
|
|
[AC_DEFINE(HAVE_LIBXT,1,[Define to 1 if we can compile with the Xt library])
|
||
|
|
cf_have_X_LIBS=Xt
|
||
|
|
LIBS="-lXt $X_PRE_LIBS $LIBS $X_EXTRA_LIBS"],,
|
||
|
|
[$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])])
|
||
|
|
])
|
||
|
|
|
||
|
|
if test $cf_have_X_LIBS = no ; then
|
||
|
|
AC_MSG_WARN(
|
||
|
|
[Unable to successfully link X Toolkit library (-lXt) with
|
||
|
|
test program. You will have to check and add the proper libraries by hand
|
||
|
|
to makefile.])
|
||
|
|
fi
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF__ADD_SHLIB_RULES version: 6 updated: 2016/04/21 21:07:50
|
||
|
|
dnl -------------------
|
||
|
|
dnl Append rules for creating, installing, uninstalling and cleaning library.
|
||
|
|
dnl In particular, this is needed for shared libraries since there are symbolic
|
||
|
|
dnl links which depend on configuration choices.
|
||
|
|
dnl
|
||
|
|
dnl The logic is controlled by these cache variables:
|
||
|
|
dnl $cf_cv_do_symlinks
|
||
|
|
dnl $cf_cv_shlib_version
|
||
|
|
dnl
|
||
|
|
dnl The macro uses variables set by CF__DEFINE_SHLIB_VARS
|
||
|
|
dnl
|
||
|
|
dnl $1 = makefile to append to
|
||
|
|
dnl $2 = model (static, shared, libtool)
|
||
|
|
dnl $3 = objects (dependencies)
|
||
|
|
dnl $4 = additional libraries needed to link the shared library
|
||
|
|
define([CF__ADD_SHLIB_RULES],[
|
||
|
|
|
||
|
|
CF__DEFINE_LIB_TARGET
|
||
|
|
|
||
|
|
case x$2 in
|
||
|
|
(xlibtool|xshared)
|
||
|
|
cf_libdeps="ifelse($4,,,[$4])"
|
||
|
|
;;
|
||
|
|
(x*)
|
||
|
|
cf_libdeps=
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
|
||
|
|
cat >>$1 <<CF_EOF
|
||
|
|
|
||
|
|
# generated by CF__ADD_SHLIB_RULES
|
||
|
|
# libmodel: $2
|
||
|
|
# symlinks: $cf_cv_do_symlinks
|
||
|
|
# shlibver: $cf_cv_shlib_version
|
||
|
|
|
||
|
|
CF_EOF
|
||
|
|
|
||
|
|
cat >>$1 <<CF_EOF
|
||
|
|
$cf_libname :: \\
|
||
|
|
CF_EOF
|
||
|
|
|
||
|
|
cat >>$1 <<CF_EOF
|
||
|
|
$3
|
||
|
|
@echo linking \[$]@
|
||
|
|
\$(LIBTOOL_CREATE) $3 $cf_libdeps
|
||
|
|
CF_EOF
|
||
|
|
|
||
|
|
if test "x$cf_cv_do_symlinks" = xyes
|
||
|
|
then
|
||
|
|
cat >>$1 <<CF_EOF
|
||
|
|
\$(LN_S) $cf_libname $cf_liblink
|
||
|
|
\$(LN_S) $cf_liblink $cf_libroot
|
||
|
|
CF_EOF
|
||
|
|
fi
|
||
|
|
|
||
|
|
cat >>$1 <<CF_EOF
|
||
|
|
|
||
|
|
install \\
|
||
|
|
install.libs :: \$(DESTDIR)\$(libdir)/$cf_libname
|
||
|
|
|
||
|
|
\$(DESTDIR)\$(libdir)/$cf_libname :: \\
|
||
|
|
\$(DESTDIR)\$(libdir) \\
|
||
|
|
$3
|
||
|
|
@echo linking \[$]@
|
||
|
|
\$(LIBTOOL_CREATE) $3 $cf_libdeps
|
||
|
|
CF_EOF
|
||
|
|
|
||
|
|
if test "x$cf_cv_do_symlinks" = xyes
|
||
|
|
then
|
||
|
|
cat >>$1 <<CF_EOF
|
||
|
|
cd \$(DESTDIR)\$(libdir) && (\$(LN_S) $cf_libname $cf_liblink; \$(LN_S) $cf_liblink $cf_libroot; )
|
||
|
|
CF_EOF
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test x$2 = xshared
|
||
|
|
then
|
||
|
|
cat >>$1 <<CF_EOF
|
||
|
|
- \$(SHELL) -c "if test -z "\$(DESTDIR)" ; then /sbin/ldconfig; fi"
|
||
|
|
CF_EOF
|
||
|
|
fi
|
||
|
|
|
||
|
|
cat >>$1 <<CF_EOF
|
||
|
|
|
||
|
|
uninstall \\
|
||
|
|
uninstall.libs ::
|
||
|
|
@echo uninstalling \$(DESTDIR)\$(libdir)/$cf_libname
|
||
|
|
CF_EOF
|
||
|
|
|
||
|
|
if test "x$cf_cv_do_symlinks" = xyes
|
||
|
|
then
|
||
|
|
cat >>$1 <<CF_EOF
|
||
|
|
-rm -f \$(DESTDIR)\$(libdir)/$cf_libroot
|
||
|
|
-rm -f \$(DESTDIR)\$(libdir)/$cf_liblink
|
||
|
|
CF_EOF
|
||
|
|
fi
|
||
|
|
|
||
|
|
cat >>$1 <<CF_EOF
|
||
|
|
-rm -f \$(DESTDIR)\$(libdir)/$cf_libname
|
||
|
|
|
||
|
|
clean \\
|
||
|
|
clean.libs ::
|
||
|
|
CF_EOF
|
||
|
|
|
||
|
|
if test "x$cf_cv_do_symlinks" = xyes
|
||
|
|
then
|
||
|
|
cat >>$1 <<CF_EOF
|
||
|
|
-rm -f $cf_libroot
|
||
|
|
-rm -f $cf_liblink
|
||
|
|
CF_EOF
|
||
|
|
fi
|
||
|
|
|
||
|
|
cat >>$1 <<CF_EOF
|
||
|
|
-rm -f $cf_libname
|
||
|
|
|
||
|
|
mostlyclean::
|
||
|
|
-rm -f $3
|
||
|
|
# end generated by CF__ADD_SHLIB_RULES
|
||
|
|
CF_EOF
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF__CURSES_HEAD version: 2 updated: 2010/10/23 15:54:49
|
||
|
|
dnl ---------------
|
||
|
|
dnl Define a reusable chunk which includes <curses.h> and <term.h> when they
|
||
|
|
dnl are both available.
|
||
|
|
define([CF__CURSES_HEAD],[
|
||
|
|
#ifdef HAVE_XCURSES
|
||
|
|
#include <xcurses.h>
|
||
|
|
char * XCursesProgramName = "test";
|
||
|
|
#else
|
||
|
|
#include <${cf_cv_ncurses_header:-curses.h}>
|
||
|
|
#if defined(NCURSES_VERSION) && defined(HAVE_NCURSESW_TERM_H)
|
||
|
|
#include <ncursesw/term.h>
|
||
|
|
#elif defined(NCURSES_VERSION) && defined(HAVE_NCURSES_TERM_H)
|
||
|
|
#include <ncurses/term.h>
|
||
|
|
#elif defined(HAVE_TERM_H)
|
||
|
|
#include <term.h>
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
])
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF__DEFINE_LIB_TARGET version: 2 updated: 2015/05/10 19:52:14
|
||
|
|
dnl ---------------------
|
||
|
|
define([CF__DEFINE_LIB_TARGET],[
|
||
|
|
cf_libname=\${LIB_BASENAME}
|
||
|
|
cf_liblink=$cf_libname
|
||
|
|
cf_libroot=$cf_libname
|
||
|
|
|
||
|
|
if test "x$cf_cv_do_symlinks" = xyes
|
||
|
|
then
|
||
|
|
case "x$cf_cv_shlib_version" in
|
||
|
|
(xrel)
|
||
|
|
cf_liblink="\${LIB_ABI_NAME}"
|
||
|
|
cf_libname="\${LIB_REL_NAME}"
|
||
|
|
;;
|
||
|
|
(xabi)
|
||
|
|
cf_liblink="\${LIB_REL_NAME}"
|
||
|
|
cf_libname="\${LIB_ABI_NAME}"
|
||
|
|
;;
|
||
|
|
esac
|
||
|
|
fi
|
||
|
|
LIB_TARGET=$cf_libname
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF__DEFINE_SHLIB_VARS version: 4 updated: 2015/09/28 17:49:10
|
||
|
|
dnl ---------------------
|
||
|
|
dnl Substitute makefile variables useful for CF__ADD_SHLIB_RULES.
|
||
|
|
dnl
|
||
|
|
dnl The substitution requires these variables:
|
||
|
|
dnl LIB_PREFIX - "lib"
|
||
|
|
dnl LIB_ROOTNAME - "foo"
|
||
|
|
dnl LIB_SUFFIX - ".so"
|
||
|
|
dnl REL_VERSION - "5.0"
|
||
|
|
dnl ABI_VERSION - "4.2.4"
|
||
|
|
define([CF__DEFINE_SHLIB_VARS],[
|
||
|
|
CF__DEFINE_LIB_TARGET
|
||
|
|
SET_SHLIB_VARS="# begin CF__DEFINE_SHLIB_VARS\\
|
||
|
|
LIB_BASENAME = \${LIB_PREFIX}\${LIB_ROOTNAME}\${LIB_SUFFIX}\\
|
||
|
|
LIB_REL_NAME = \${LIB_BASENAME}.\${REL_VERSION}\\
|
||
|
|
LIB_ABI_NAME = \${LIB_BASENAME}.\${ABI_VERSION}\\
|
||
|
|
LIB_TARGET = $LIB_TARGET\\
|
||
|
|
RM_SHARED_OPTS = $RM_SHARED_OPTS\\
|
||
|
|
# end CF__DEFINE_SHLIB_VARS"
|
||
|
|
AC_SUBST(SET_SHLIB_VARS)
|
||
|
|
AC_SUBST(LIB_TARGET)
|
||
|
|
])dnl
|
||
|
|
dnl ---------------------------------------------------------------------------
|
||
|
|
dnl CF__INIT_SHLIB_RULES version: 2 updated: 2013/07/27 17:38:32
|
||
|
|
dnl --------------------
|
||
|
|
dnl The third parameter to AC_OUTPUT, used to pass variables needed for
|
||
|
|
dnl CF__ADD_SHLIB_RULES.
|
||
|
|
define([CF__INIT_SHLIB_RULES],[
|
||
|
|
ABI_VERSION="$ABI_VERSION"
|
||
|
|
REL_VERSION="$REL_VERSION"
|
||
|
|
LIB_MODEL="$LIB_MODEL"
|
||
|
|
LIB_PREFIX="$LIB_PREFIX"
|
||
|
|
LIB_ROOTNAME="$LIB_ROOTNAME"
|
||
|
|
DFT_DEP_SUFFIX="$DFT_DEP_SUFFIX"
|
||
|
|
RM_SHARED_OPTS="$RM_SHARED_OPTS"
|
||
|
|
cf_cv_do_symlinks="$cf_cv_do_symlinks"
|
||
|
|
cf_cv_shlib_version="$cf_cv_shlib_version"
|
||
|
|
])
|