mirror of
https://github.com/ThomasDickey/ncurses-snapshots.git
synced 2026-01-26 11:04:35 +00:00
5571 lines
168 KiB
Plaintext
5571 lines
168 KiB
Plaintext
dnl***************************************************************************
|
|
dnl Copyright 2018-2024,2025 Thomas E. Dickey *
|
|
dnl Copyright 2010-2017,2018 Free Software Foundation, Inc. *
|
|
dnl *
|
|
dnl Permission is hereby granted, free of charge, to any person obtaining a *
|
|
dnl copy of this software and associated documentation files (the *
|
|
dnl "Software"), to deal in the Software without restriction, including *
|
|
dnl without limitation the rights to use, copy, modify, merge, publish, *
|
|
dnl distribute, distribute with modifications, sublicense, and/or sell *
|
|
dnl copies of the Software, and to permit persons to whom the Software is *
|
|
dnl furnished to do so, subject to the following conditions: *
|
|
dnl *
|
|
dnl The above copyright notice and this permission notice shall be included *
|
|
dnl in all copies or substantial portions of the Software. *
|
|
dnl *
|
|
dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS *
|
|
dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF *
|
|
dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. *
|
|
dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
|
|
dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
|
|
dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR *
|
|
dnl THE USE OR OTHER 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 *
|
|
dnl sale, use or other dealings in this Software without prior written *
|
|
dnl authorization. *
|
|
dnl***************************************************************************
|
|
dnl
|
|
dnl Author: Thomas E. Dickey
|
|
dnl
|
|
dnl $Id: aclocal.m4,v 1.242 2025/12/27 18:03:23 tom Exp $
|
|
dnl Macros used in NCURSES Ada95 auto-configuration script.
|
|
dnl
|
|
dnl These macros are maintained separately from NCURSES. The copyright on
|
|
dnl this file applies to the aggregation of macros and does not affect use of
|
|
dnl these macros in other applications.
|
|
dnl
|
|
dnl See these pages for additional information:
|
|
dnl https://invisible-island.net/autoconf/
|
|
dnl https://invisible-island.net/autoconf/my-autoconf.html
|
|
dnl
|
|
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_ADA_INCLUDE_DIRS version: 8 updated: 2013/10/14 04:24:07
|
|
dnl -------------------
|
|
dnl Construct the list of include-options for the C programs in the Ada95
|
|
dnl binding.
|
|
AC_DEFUN([CF_ADA_INCLUDE_DIRS],
|
|
[
|
|
ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
|
|
if test "$srcdir" != "."; then
|
|
ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
|
|
fi
|
|
if test "$GCC" != yes; then
|
|
ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
|
|
elif test "$includedir" != "/usr/include"; then
|
|
if test "$includedir" = '${prefix}/include' ; then
|
|
if test x$prefix != x/usr ; then
|
|
ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
|
|
fi
|
|
else
|
|
ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
|
|
fi
|
|
fi
|
|
AC_SUBST(ACPPFLAGS)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
|
|
dnl ---------------
|
|
dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
|
|
AC_DEFUN([CF_ADD_ADAFLAGS],[
|
|
ADAFLAGS="$ADAFLAGS $1"
|
|
AC_SUBST(ADAFLAGS)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_ADD_CFLAGS version: 15 updated: 2020/12/31 10:54:15
|
|
dnl -------------
|
|
dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
|
|
dnl $1 = flags to add
|
|
dnl $2 = 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_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
|
|
continue
|
|
elif test "${cf_tst_cflags}" = "\"'" ; then
|
|
CF_APPEND_TEXT(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_APPEND_TEXT(cf_new_cppflags,$cf_add_cflags)
|
|
;;
|
|
esac
|
|
;;
|
|
(*)
|
|
CF_APPEND_TEXT(cf_new_cflags,$cf_add_cflags)
|
|
;;
|
|
esac
|
|
;;
|
|
(yes)
|
|
CF_APPEND_TEXT(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)])
|
|
CF_APPEND_TEXT(CFLAGS,$cf_new_cflags)
|
|
fi
|
|
|
|
if test -n "$cf_new_cppflags" ; then
|
|
ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
|
|
CF_APPEND_TEXT(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)])
|
|
CF_APPEND_TEXT(EXTRA_CPPFLAGS,$cf_new_extra_cppflags)
|
|
fi
|
|
|
|
AC_SUBST(EXTRA_CPPFLAGS)
|
|
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_ADD_INCDIR version: 18 updated: 2025/12/22 04:16:14
|
|
dnl -------------
|
|
dnl Add an include-directory to $CPPFLAGS. Don't add /usr/include, since it is
|
|
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
|
|
CF_APPEND_TEXT(CPPFLAGS,-I$cf_add_incdir)
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#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: 11 updated: 2020/12/31 20:19:42
|
|
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: 3 updated: 2019/11/02 16:47:33
|
|
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="[$]ifelse($2,,LIBS,[$2])"
|
|
# reverse order
|
|
cf_add_0lib=
|
|
for cf_add_1lib in $1; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done
|
|
# filter duplicates
|
|
for cf_add_1lib in $cf_add_0lib; 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_1lib $cf_add_libs"
|
|
done
|
|
ifelse($2,,LIBS,[$2])="$cf_add_libs"
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_ADD_SUBDIR_PATH version: 5 updated: 2020/12/31 20:19:42
|
|
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_APPEND_CFLAGS version: 3 updated: 2021/09/05 17:25:40
|
|
dnl ----------------
|
|
dnl Use CF_ADD_CFLAGS after first checking for potential redefinitions.
|
|
dnl $1 = flags to add
|
|
dnl $2 = if given makes this macro verbose.
|
|
define([CF_APPEND_CFLAGS],
|
|
[
|
|
for cf_add_cflags in $1
|
|
do
|
|
case "x$cf_add_cflags" in
|
|
(x-[[DU]]*)
|
|
CF_REMOVE_CFLAGS($cf_add_cflags,CFLAGS,[$2])
|
|
CF_REMOVE_CFLAGS($cf_add_cflags,CPPFLAGS,[$2])
|
|
;;
|
|
esac
|
|
CF_ADD_CFLAGS([$cf_add_cflags],[$2])
|
|
done
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_APPEND_TEXT version: 1 updated: 2017/02/25 18:58:55
|
|
dnl --------------
|
|
dnl use this macro for appending text without introducing an extra blank at
|
|
dnl the beginning
|
|
define([CF_APPEND_TEXT],
|
|
[
|
|
test -n "[$]$1" && $1="[$]$1 "
|
|
$1="[$]{$1}$2"
|
|
])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_ENABLE version: 3 updated: 1999/03/30 17:24:31
|
|
dnl -------------
|
|
dnl Allow user to enable a normally-off option.
|
|
AC_DEFUN([CF_ARG_ENABLE],
|
|
[CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_ARG_OPTION version: 6 updated: 2025/08/05 04:09:09
|
|
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 to 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_AR_FLAGS version: 10 updated: 2025/12/14 20:07:31
|
|
dnl -----------
|
|
dnl Check for suitable "ar" (archiver) options for updating an archive.
|
|
dnl
|
|
dnl In particular, handle some obsolete cases where the "-" might be omitted,
|
|
dnl as well as a workaround for breakage of make's archive rules by the GNU
|
|
dnl binutils "ar" program.
|
|
AC_DEFUN([CF_AR_FLAGS],[
|
|
AC_REQUIRE([CF_PROG_AR])
|
|
|
|
AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
|
|
case "$cf_cv_system_name" in
|
|
(*-msvc*)
|
|
cf_cv_ar_flags=''
|
|
cat >mk_static_lib.sh <<-EOF
|
|
#!$SHELL
|
|
MSVC_BIN="[$]AR"
|
|
out="\[$]1"
|
|
shift
|
|
exec \[$]MSVC_BIN -out:"\[$]out" \[$]@
|
|
EOF
|
|
chmod +x mk_static_lib.sh
|
|
AR=`pwd`/mk_static_lib.sh
|
|
;;
|
|
(*)
|
|
cf_cv_ar_flags=unknown
|
|
for cf_ar_flags in -curvU -curv curv -crv crv -cqv cqv -rv rv
|
|
do
|
|
|
|
# check if $ARFLAGS already contains this choice
|
|
if test "x$ARFLAGS" != "x" ; then
|
|
cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
|
|
if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
|
|
cf_cv_ar_flags=
|
|
break
|
|
fi
|
|
fi
|
|
|
|
rm -f "conftest.$ac_cv_objext"
|
|
rm -f conftest.a
|
|
|
|
cat >"conftest.$ac_ext" <<EOF
|
|
#line __oline__ "configure"
|
|
int testdata[[3]] = { 123, 456, 789 };
|
|
EOF
|
|
if AC_TRY_EVAL(ac_compile) ; then
|
|
echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AS_MESSAGE_LOG_FD
|
|
$AR $ARFLAGS "$cf_ar_flags" conftest.a "conftest.$ac_cv_objext" 2>&AS_MESSAGE_LOG_FD 1>/dev/null
|
|
if test -f conftest.a ; then
|
|
cf_cv_ar_flags="$cf_ar_flags"
|
|
break
|
|
fi
|
|
else
|
|
CF_VERBOSE(cannot compile test-program)
|
|
break
|
|
fi
|
|
done
|
|
rm -f conftest.a "conftest.$ac_ext" "conftest.$ac_cv_objext"
|
|
;;
|
|
esac
|
|
])
|
|
|
|
if test -n "$ARFLAGS" ; then
|
|
if test -n "$cf_cv_ar_flags" ; then
|
|
ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
|
|
fi
|
|
else
|
|
ARFLAGS=$cf_cv_ar_flags
|
|
fi
|
|
|
|
AC_SUBST(ARFLAGS)
|
|
])
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_BUILD_CC version: 14 updated: 2024/12/14 11:58:01
|
|
dnl -----------
|
|
dnl If we're cross-compiling, allow the user to override the tools and their
|
|
dnl options. The configure script is oriented toward identifying the host
|
|
dnl compiler, etc., but we need a build compiler to generate parts of the
|
|
dnl source.
|
|
dnl
|
|
dnl $1 = default for $CPPFLAGS
|
|
dnl $2 = default for $LIBS
|
|
AC_DEFUN([CF_BUILD_CC],[
|
|
CF_ACVERSION_CHECK(2.52,,
|
|
[AC_REQUIRE([CF_PROG_EXT])])
|
|
if test "$cross_compiling" = yes ; then
|
|
|
|
# defaults that we might want to override
|
|
: ${BUILD_CFLAGS:=''}
|
|
: ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
|
|
: ${BUILD_LDFLAGS:=''}
|
|
: ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
|
|
: ${BUILD_EXEEXT:='$x'}
|
|
: ${BUILD_OBJEXT:='o'}
|
|
|
|
AC_ARG_WITH(build-cc,
|
|
[ --with-build-cc=XXX the build C compiler ($BUILD_CC)],
|
|
[BUILD_CC="$withval"],
|
|
[AC_CHECK_PROGS(BUILD_CC, [gcc clang c99 c89 cc cl],none)])
|
|
AC_MSG_CHECKING(for native build C compiler)
|
|
AC_MSG_RESULT($BUILD_CC)
|
|
|
|
AC_MSG_CHECKING(for native build C preprocessor)
|
|
AC_ARG_WITH(build-cpp,
|
|
[ --with-build-cpp=XXX the build C preprocessor ($BUILD_CPP)],
|
|
[BUILD_CPP="$withval"],
|
|
[BUILD_CPP='${BUILD_CC} -E'])
|
|
AC_MSG_RESULT($BUILD_CPP)
|
|
|
|
AC_MSG_CHECKING(for native build C flags)
|
|
AC_ARG_WITH(build-cflags,
|
|
[ --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
|
|
[BUILD_CFLAGS="$withval"])
|
|
AC_MSG_RESULT($BUILD_CFLAGS)
|
|
|
|
AC_MSG_CHECKING(for native build C preprocessor-flags)
|
|
AC_ARG_WITH(build-cppflags,
|
|
[ --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
|
|
[BUILD_CPPFLAGS="$withval"])
|
|
AC_MSG_RESULT($BUILD_CPPFLAGS)
|
|
|
|
AC_MSG_CHECKING(for native build linker-flags)
|
|
AC_ARG_WITH(build-ldflags,
|
|
[ --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
|
|
[BUILD_LDFLAGS="$withval"])
|
|
AC_MSG_RESULT($BUILD_LDFLAGS)
|
|
|
|
AC_MSG_CHECKING(for native build linker-libraries)
|
|
AC_ARG_WITH(build-libs,
|
|
[ --with-build-libs=XXX the build libraries (${BUILD_LIBS})],
|
|
[BUILD_LIBS="$withval"])
|
|
AC_MSG_RESULT($BUILD_LIBS)
|
|
|
|
# this assumes we're on Unix.
|
|
BUILD_EXEEXT=
|
|
BUILD_OBJEXT=o
|
|
|
|
: ${BUILD_CC:='${CC}'}
|
|
|
|
AC_MSG_CHECKING(if the build-compiler "$BUILD_CC" works)
|
|
|
|
cf_save_crossed=$cross_compiling
|
|
cf_save_ac_link=$ac_link
|
|
cross_compiling=no
|
|
cf_build_cppflags=$BUILD_CPPFLAGS
|
|
test "$cf_build_cppflags" = "#" && cf_build_cppflags=
|
|
ac_link='$BUILD_CC -o "conftest$ac_exeext" $BUILD_CFLAGS $cf_build_cppflags $BUILD_LDFLAGS "conftest.$ac_ext" $BUILD_LIBS >&AS_MESSAGE_LOG_FD'
|
|
|
|
AC_TRY_RUN([#include <stdio.h>
|
|
int main(int argc, char *argv[])
|
|
{
|
|
${cf_cv_main_return:-return}(argc < 0 || argv == (void*)0 || argv[0] == (void*)0);
|
|
}
|
|
],
|
|
cf_ok_build_cc=yes,
|
|
cf_ok_build_cc=no,
|
|
cf_ok_build_cc=unknown)
|
|
|
|
cross_compiling=$cf_save_crossed
|
|
ac_link=$cf_save_ac_link
|
|
|
|
AC_MSG_RESULT($cf_ok_build_cc)
|
|
|
|
if test "$cf_ok_build_cc" != yes
|
|
then
|
|
AC_MSG_ERROR([Cross-build requires two compilers.
|
|
Use --with-build-cc to specify the native compiler.])
|
|
fi
|
|
|
|
else
|
|
: ${BUILD_CC:='${CC}'}
|
|
: ${BUILD_CPP:='${CPP}'}
|
|
: ${BUILD_CFLAGS:='${CFLAGS}'}
|
|
: ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
|
|
: ${BUILD_LDFLAGS:='${LDFLAGS}'}
|
|
: ${BUILD_LIBS:='${LIBS}'}
|
|
: ${BUILD_EXEEXT:='$x'}
|
|
: ${BUILD_OBJEXT:='o'}
|
|
fi
|
|
|
|
AC_SUBST(BUILD_CC)
|
|
AC_SUBST(BUILD_CPP)
|
|
AC_SUBST(BUILD_CFLAGS)
|
|
AC_SUBST(BUILD_CPPFLAGS)
|
|
AC_SUBST(BUILD_LDFLAGS)
|
|
AC_SUBST(BUILD_LIBS)
|
|
AC_SUBST(BUILD_EXEEXT)
|
|
AC_SUBST(BUILD_OBJEXT)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_C11_NORETURN version: 5 updated: 2025/12/14 17:40:20
|
|
dnl ---------------
|
|
AC_DEFUN([CF_C11_NORETURN],
|
|
[
|
|
AC_MSG_CHECKING(if you want to use C11 _Noreturn feature)
|
|
CF_ARG_ENABLE(stdnoreturn,
|
|
[ --enable-stdnoreturn enable C11 _Noreturn feature for diagnostics],
|
|
[enable_stdnoreturn=yes],
|
|
[enable_stdnoreturn=no])
|
|
AC_MSG_RESULT($enable_stdnoreturn)
|
|
|
|
if test $enable_stdnoreturn = yes; then
|
|
AC_CACHE_CHECK([for C11 _Noreturn feature], cf_cv_c11_noreturn,
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
|
|
$ac_includes_default
|
|
#include <stdnoreturn.h>
|
|
static _Noreturn void giveup(void) { exit(0); }
|
|
],
|
|
[if (feof(stdin)) giveup()])],
|
|
cf_cv_c11_noreturn=yes,
|
|
cf_cv_c11_noreturn=no)
|
|
])
|
|
else
|
|
cf_cv_c11_noreturn=no,
|
|
fi
|
|
|
|
if test "$cf_cv_c11_noreturn" = yes; then
|
|
AC_DEFINE(HAVE_STDNORETURN_H, 1,[Define if <stdnoreturn.h> header is available and working])
|
|
AC_DEFINE_UNQUOTED(STDC_NORETURN,_Noreturn,[Define if C11 _Noreturn keyword is supported])
|
|
HAVE_STDNORETURN_H=1
|
|
else
|
|
HAVE_STDNORETURN_H=0
|
|
fi
|
|
|
|
AC_SUBST(HAVE_STDNORETURN_H)
|
|
AC_SUBST(STDC_NORETURN)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_CC_ENV_FLAGS version: 11 updated: 2023/02/20 11:15:46
|
|
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(\$CFLAGS variable)
|
|
case "x$CFLAGS" in
|
|
(*-[[IUD]]*)
|
|
AC_MSG_RESULT(broken)
|
|
AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
|
|
cf_flags="$CFLAGS"
|
|
CFLAGS=
|
|
for cf_arg in $cf_flags
|
|
do
|
|
CF_ADD_CFLAGS($cf_arg)
|
|
done
|
|
;;
|
|
(*)
|
|
AC_MSG_RESULT(ok)
|
|
;;
|
|
esac
|
|
|
|
AC_MSG_CHECKING(\$CC variable)
|
|
case "$CC" in
|
|
(*[[\ \ ]]-*)
|
|
AC_MSG_RESULT(broken)
|
|
AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
|
|
# humor him...
|
|
cf_prog=`echo "$CC" | sed -e 's/ / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
|
|
cf_flags=`echo "$CC" | sed -e "s%^$cf_prog%%"`
|
|
CC="$cf_prog"
|
|
for cf_arg in $cf_flags
|
|
do
|
|
case "x$cf_arg" in
|
|
(x-[[IUDfgOW]]*)
|
|
CF_ADD_CFLAGS($cf_arg)
|
|
;;
|
|
(*)
|
|
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_CFG_DEFAULTS version: 17 updated: 2025/12/24 12:27:29
|
|
dnl ---------------
|
|
dnl Determine the default configuration into which we'll install ncurses. This
|
|
dnl can be overridden by the user's command-line options. There's two items to
|
|
dnl look for:
|
|
dnl 1. the prefix (e.g., /usr)
|
|
dnl 2. the header files (e.g., /usr/include/ncurses)
|
|
dnl We'll look for a previous installation of ncurses and use the same defaults.
|
|
dnl
|
|
dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
|
|
dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
|
|
dnl programs from a vendor's.
|
|
AC_DEFUN([CF_CFG_DEFAULTS],
|
|
[AC_REQUIRE([AC_PROG_FGREP])dnl
|
|
|
|
AC_MSG_CHECKING(for prefix)
|
|
if test "x$prefix" = "xNONE" ; then
|
|
case "$cf_cv_system_name" in
|
|
# non-vendor systems don't have a conflict
|
|
(openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
|
|
prefix=/usr
|
|
;;
|
|
(*) prefix=$ac_default_prefix
|
|
;;
|
|
esac
|
|
fi
|
|
AC_MSG_RESULT($prefix)
|
|
|
|
if test "x$prefix" = "xNONE" ; then
|
|
AC_MSG_CHECKING(for default include-directory)
|
|
test -n "$verbose" && echo 1>&AS_MESSAGE_FD
|
|
for cf_symbol in \
|
|
"$includedir" \
|
|
"$includedir/ncurses" \
|
|
"$prefix/include" \
|
|
"$prefix/include/ncurses" \
|
|
/usr/local/include \
|
|
/usr/local/include/ncurses \
|
|
/usr/include \
|
|
/usr/include/ncurses
|
|
do
|
|
cf_dir=`eval echo "$cf_symbol"`
|
|
if test -f "$cf_dir/curses.h" ; then
|
|
if ( ${FGREP-fgrep} NCURSES_VERSION "$cf_dir/curses.h" >/dev/null 2>&1 ) ; then
|
|
includedir="$cf_symbol"
|
|
test -n "$verbose" && echo $ECHO_N " found " 1>&AS_MESSAGE_FD
|
|
break
|
|
fi
|
|
fi
|
|
test -n "$verbose" && echo " tested $cf_dir" 1>&AS_MESSAGE_FD
|
|
done
|
|
AC_MSG_RESULT($includedir)
|
|
fi
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_CHECK_CACHE version: 13 updated: 2020/12/31 10:54:15
|
|
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_GNAT_VERSION version: 4 updated: 2021/01/01 13:31:04
|
|
dnl ---------------------
|
|
AC_DEFUN([CF_CHECK_GNAT_VERSION],
|
|
[
|
|
AC_REQUIRE([CF_GNAT_VERSION])
|
|
case "$cf_cv_gnat_version" in
|
|
(3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
|
|
cf_cv_prog_gnat_correct=yes
|
|
;;
|
|
(*)
|
|
AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
|
|
cf_cv_prog_gnat_correct=no
|
|
;;
|
|
esac
|
|
])
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_CHECK_LIBSSP version: 2 updated: 2025/12/24 12:27:29
|
|
dnl ---------------
|
|
dnl Check if libssp is needed, e.g., to work around misconfigured libraries
|
|
dnl used in cross-compiling to MinGW.
|
|
AC_DEFUN([CF_CHECK_LIBSSP],[
|
|
AC_CACHE_CHECK(if ssp library is needed,cf_cv_need_libssp,[
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([
|
|
#include <sys/types.h>
|
|
#include <dirent.h>
|
|
],[
|
|
DIR *dp = opendir(".");
|
|
])],cf_cv_need_libssp=no,[
|
|
cf_save_LIBS="$LIBS"
|
|
LIBS="$LIBS -lssp"
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([
|
|
#include <sys/types.h>
|
|
#include <dirent.h>
|
|
],[
|
|
DIR *dp = opendir(".");
|
|
])],cf_cv_need_libssp=yes,
|
|
cf_cv_need_libssp=maybe)
|
|
LIBS="$cf_save_LIBS"
|
|
])dnl
|
|
])
|
|
|
|
if test "x$cf_cv_need_libssp" = xyes
|
|
then
|
|
CF_ADD_LIB(ssp)
|
|
fi
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_CLANG_COMPILER version: 11 updated: 2025/12/14 17:46:02
|
|
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])"
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[
|
|
#ifdef __clang__
|
|
#else
|
|
#error __clang__ is not defined
|
|
#endif
|
|
])],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
|
|
],[])
|
|
ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
|
|
AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
|
|
fi
|
|
|
|
CLANG_VERSION=none
|
|
|
|
if test "x$ifelse([$2],,CLANG_COMPILER,[$2])" = "xyes" ; then
|
|
case "$CC" in
|
|
(c[[1-9]][[0-9]]|*/c[[1-9]][[0-9]])
|
|
AC_MSG_WARN(replacing broken compiler alias $CC)
|
|
CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`"
|
|
CC=clang
|
|
;;
|
|
esac
|
|
|
|
AC_MSG_CHECKING(version of $CC)
|
|
CLANG_VERSION="`$CC --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(CLANG[[^)]]*) //' -e 's/^.*(Debian[[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
|
|
test -z "$CLANG_VERSION" && CLANG_VERSION=unknown
|
|
AC_MSG_RESULT($CLANG_VERSION)
|
|
|
|
for cf_clang_opt in \
|
|
-Qunused-arguments \
|
|
-Wno-error=implicit-function-declaration
|
|
do
|
|
AC_MSG_CHECKING(if option $cf_clang_opt works)
|
|
cf_save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS $cf_clang_opt"
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([
|
|
#include <stdio.h>],[
|
|
printf("hello!\\n");])],[
|
|
cf_clang_optok=yes],[
|
|
cf_clang_optok=no])
|
|
AC_MSG_RESULT($cf_clang_optok)
|
|
CFLAGS="$cf_save_CFLAGS"
|
|
if test "$cf_clang_optok" = yes; then
|
|
CF_VERBOSE(adding option $cf_clang_opt)
|
|
CF_APPEND_TEXT(CFLAGS,$cf_clang_opt)
|
|
fi
|
|
done
|
|
fi
|
|
])
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_CONST_X_STRING version: 10 updated: 2025/12/14 17:40:20
|
|
dnl -----------------
|
|
dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
|
|
dnl character-strings.
|
|
dnl
|
|
dnl It is ambiguous because the specification accommodated the pre-ANSI
|
|
dnl compilers bundled by more than one vendor in lieu of providing a standard C
|
|
dnl compiler other than by costly add-ons. Because of this, the specification
|
|
dnl did not take into account the use of const for telling the compiler that
|
|
dnl string literals would be in readonly memory.
|
|
dnl
|
|
dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
|
|
dnl let the compiler decide how to represent Xt's strings which were #define'd.
|
|
dnl That does not solve the problem of using the block of Xt's strings which
|
|
dnl are compiled into the library (and is less efficient than one might want).
|
|
dnl
|
|
dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
|
|
dnl when compiling the library and compiling using the library, to tell the
|
|
dnl compiler that String is const.
|
|
AC_DEFUN([CF_CONST_X_STRING],
|
|
[
|
|
AC_REQUIRE([AC_PATH_XTRA])
|
|
|
|
CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
|
|
[
|
|
$ac_includes_default
|
|
#include <X11/Intrinsic.h>
|
|
],
|
|
[String foo = malloc(1); free((void*)foo)])],[
|
|
|
|
AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
|
|
[
|
|
#undef _CONST_X_STRING
|
|
#define _CONST_X_STRING /* X11R7.8 (perhaps) */
|
|
#undef XTSTRINGDEFINES /* X11R5 and later */
|
|
$ac_includes_default
|
|
#include <X11/Intrinsic.h>
|
|
],[String foo = malloc(1); *foo = 0])],[
|
|
cf_cv_const_x_string=no
|
|
],[
|
|
cf_cv_const_x_string=yes
|
|
])
|
|
])
|
|
|
|
CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
|
|
|
|
case "$cf_cv_const_x_string" in
|
|
(no)
|
|
CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
|
|
;;
|
|
(*)
|
|
CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
|
|
;;
|
|
esac
|
|
|
|
])
|
|
])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: 14 updated: 2021/01/02 09:31:20
|
|
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
|
|
])
|
|
if test "$cf_cv_curses_incdir" != no
|
|
then
|
|
CF_APPEND_TEXT(CPPFLAGS,$cf_cv_curses_incdir)
|
|
fi
|
|
|
|
CF_CURSES_HEADER
|
|
CF_TERM_HEADER
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_CURSES_HEADER version: 7 updated: 2025/12/22 04:16:14
|
|
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_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <${cf_header}>],
|
|
[initscr(); endwin()])],
|
|
[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: 46 updated: 2025/12/22 04:16: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_LINK_IFELSE([AC_LANG_PROGRAM([#include <${cf_cv_ncurses_header:-curses.h}>],
|
|
[initscr(); endwin()])],
|
|
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)
|
|
CF_APPEND_TEXT(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,[
|
|
: "${cf_nculib_root:=$cf_term_lib}"
|
|
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
|
|
LIBS="-l$cf_curs_lib $cf_save_LIBS"
|
|
if test "$cf_term_lib" = unknown || test "$cf_term_lib" = "$cf_curs_lib" ; then
|
|
AC_MSG_CHECKING(if we can link with $cf_curs_lib library)
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <${cf_cv_ncurses_header:-curses.h}>],
|
|
[initscr()])],
|
|
[cf_result=yes],
|
|
[cf_result=no])
|
|
AC_MSG_RESULT($cf_result)
|
|
test "$cf_result" = yes && break
|
|
elif test "$cf_curs_lib" = "$cf_term_lib" ; then
|
|
cf_result=no
|
|
elif test "$cf_term_lib" != predefined ; then
|
|
AC_MSG_CHECKING(if we need both $cf_curs_lib and $cf_term_lib libraries)
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <${cf_cv_ncurses_header:-curses.h}>],
|
|
[initscr(); endwin();])],
|
|
[cf_result=no],
|
|
[
|
|
LIBS="-l$cf_curs_lib -l$cf_term_lib $cf_save_LIBS"
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <${cf_cv_ncurses_header:-curses.h}>],
|
|
[initscr()])],
|
|
[cf_result=yes],
|
|
[cf_result=error])
|
|
])
|
|
AC_MSG_RESULT($cf_result)
|
|
test "$cf_result" != error && break
|
|
fi
|
|
done
|
|
fi
|
|
test "$cf_curs_lib" = unknown && AC_MSG_ERROR(no curses library found)
|
|
fi
|
|
fi
|
|
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_DIRNAME version: 5 updated: 2020/12/31 20:19:42
|
|
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: 14 updated: 2021/09/04 06:35:04
|
|
dnl ---------------
|
|
dnl You can always use "make -n" to see the actual options, but it is 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_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
|
|
dnl ------------------------
|
|
AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
|
|
AC_MSG_CHECKING(if we want to use GNAT projects)
|
|
CF_ARG_DISABLE(gnat-projects,
|
|
[ --disable-gnat-projects test: disable GNAT projects even if usable],
|
|
[enable_gnat_projects=no],
|
|
[enable_gnat_projects=yes])
|
|
AC_MSG_RESULT($enable_gnat_projects)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_ENABLE_BROKEN_LINKER version: 2 updated: 2021/01/02 17:09:14
|
|
dnl -----------------------
|
|
dnl Some linkers cannot reference a data-only object. Cygwin used to be one.
|
|
dnl This usually follows CF_LINK_DATAONLY, but is not required in case we need
|
|
dnl an unconditional feature.
|
|
AC_DEFUN([CF_ENABLE_BROKEN_LINKER],[
|
|
|
|
AC_MSG_CHECKING(if you want broken-linker support code)
|
|
AC_ARG_ENABLE(broken_linker,
|
|
[ --enable-broken_linker compile with broken-linker support code],
|
|
[with_broken_linker=$enableval],
|
|
[with_broken_linker=no])
|
|
AC_MSG_RESULT($with_broken_linker)
|
|
|
|
: "${BROKEN_LINKER:=0}"
|
|
if test "x$with_broken_linker" = xyes ; then
|
|
AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules])
|
|
BROKEN_LINKER=1
|
|
fi
|
|
AC_SUBST(BROKEN_LINKER)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_ENABLE_WARNINGS version: 9 updated: 2021/01/05 19:40:50
|
|
dnl ------------------
|
|
dnl Configure-option to enable gcc warnings
|
|
dnl
|
|
dnl $1 = extra options to add, if supported
|
|
dnl $2 = option for checking attributes. By default, this is done when
|
|
dnl warnings are enabled. For other values:
|
|
dnl yes: always do this, e.g., to use in generated library-headers
|
|
dnl no: never do this
|
|
AC_DEFUN([CF_ENABLE_WARNINGS],[
|
|
if test "$GCC" = yes || test "$GXX" = yes
|
|
then
|
|
CF_FIX_WARNINGS(CFLAGS)
|
|
CF_FIX_WARNINGS(CPPFLAGS)
|
|
CF_FIX_WARNINGS(LDFLAGS)
|
|
AC_MSG_CHECKING(if you want to turn on gcc warnings)
|
|
CF_ARG_ENABLE(warnings,
|
|
[ --enable-warnings test: turn on gcc compiler warnings],
|
|
[enable_warnings=yes],
|
|
[enable_warnings=no])
|
|
AC_MSG_RESULT($enable_warnings)
|
|
if test "$enable_warnings" = "yes"
|
|
then
|
|
ifelse($2,,[CF_GCC_ATTRIBUTES])
|
|
CF_GCC_WARNINGS($1)
|
|
fi
|
|
ifelse($2,yes,[CF_GCC_ATTRIBUTES])
|
|
fi
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_FIND_LIBRARY version: 13 updated: 2025/12/22 04:16:14
|
|
dnl ---------------
|
|
dnl Look for a non-standard library, given parameters for AC_LINK_IFELSE. 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_LINK_IFELSE([AC_LANG_PROGRAM([$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_LINK_IFELSE([AC_LANG_PROGRAM([$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: 23 updated: 2025/12/22 04:16:14
|
|
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_LINK_IFELSE below.
|
|
cf_cv_header_path_$3=
|
|
cf_cv_library_path_$3=
|
|
|
|
CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
|
|
|
|
cf_save_LIBS="$LIBS"
|
|
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([$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_LINK_IFELSE([AC_LANG_PROGRAM([$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"
|
|
CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([$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_LINK_IFELSE([AC_LANG_PROGRAM([$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_LINK_IFELSE([AC_LANG_PROGRAM([$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_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04
|
|
dnl -----------------
|
|
dnl make ADAFLAGS consistent with CFLAGS
|
|
AC_DEFUN([CF_FIXUP_ADAFLAGS],[
|
|
AC_MSG_CHECKING(optimization options for ADAFLAGS)
|
|
case "$CFLAGS" in
|
|
(*-g*)
|
|
CF_ADD_ADAFLAGS(-g)
|
|
;;
|
|
esac
|
|
case "$CFLAGS" in
|
|
(*-O*)
|
|
cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[ ]].*//'`
|
|
CF_ADD_ADAFLAGS($cf_O_flag)
|
|
;;
|
|
esac
|
|
AC_MSG_RESULT($ADAFLAGS)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_FIX_WARNINGS version: 4 updated: 2021/12/16 18:22:31
|
|
dnl ---------------
|
|
dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc. Any of gcc's
|
|
dnl "-Werror" flags can interfere with configure-checks. Those go into
|
|
dnl EXTRA_CFLAGS.
|
|
dnl
|
|
dnl $1 = variable name to repair
|
|
define([CF_FIX_WARNINGS],[
|
|
if test "$GCC" = yes || test "$GXX" = yes
|
|
then
|
|
case [$]$1 in
|
|
(*-Werror=*)
|
|
cf_temp_flags=
|
|
for cf_temp_scan in [$]$1
|
|
do
|
|
case "x$cf_temp_scan" in
|
|
(x-Werror=format*)
|
|
CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
|
|
;;
|
|
(x-Werror=*)
|
|
CF_APPEND_TEXT(EXTRA_CFLAGS,$cf_temp_scan)
|
|
;;
|
|
(*)
|
|
CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
|
|
;;
|
|
esac
|
|
done
|
|
if test "x[$]$1" != "x$cf_temp_flags"
|
|
then
|
|
CF_VERBOSE(repairing $1: [$]$1)
|
|
$1="$cf_temp_flags"
|
|
CF_VERBOSE(... fixed [$]$1)
|
|
CF_VERBOSE(... extra $EXTRA_CFLAGS)
|
|
fi
|
|
;;
|
|
esac
|
|
fi
|
|
AC_SUBST(EXTRA_CFLAGS)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_FUNC_GETTIME version: 4 updated: 2025/12/23 18:53:34
|
|
dnl ---------------
|
|
dnl Check for gettimeofday or clock_gettime. In 2023, the former is still more
|
|
dnl widely supported, but "deprecated" (2008), so we will use the latter if it
|
|
dnl is available, to reduce compiler warnings.
|
|
AC_DEFUN([CF_FUNC_GETTIME],[
|
|
cf_save_libs="$LIBS"
|
|
AC_CHECK_FUNC(clock_gettime,
|
|
cf_cv_test_clock_gettime=yes,
|
|
AC_CHECK_LIB(rt, clock_gettime,
|
|
[LIBS="-lrt $LIBS"
|
|
cf_cv_test_clock_gettime=yes],
|
|
cf_cv_test_clock_gettime=no))
|
|
|
|
if test "$cf_cv_test_clock_gettime" = yes ; then
|
|
AC_CACHE_CHECK(if clock_gettime links,cf_cv_func_clock_gettime,[
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([
|
|
$ac_includes_default
|
|
#include <time.h>
|
|
],
|
|
[struct timespec ts;
|
|
int rc = clock_gettime(CLOCK_REALTIME, &ts)
|
|
+ clock_gettime(CLOCK_MONOTONIC, &ts);
|
|
(void) rc; (void)ts])],
|
|
[cf_cv_func_clock_gettime=yes],
|
|
[cf_cv_func_clock_gettime=no])
|
|
])
|
|
else
|
|
cf_cv_func_clock_gettime=no
|
|
fi
|
|
|
|
if test "$cf_cv_func_clock_gettime" = yes
|
|
then
|
|
AC_DEFINE(HAVE_CLOCK_GETTIME,1,[Define to 1 if we have clock_gettime function])
|
|
else
|
|
AC_CHECK_FUNC(gettimeofday,
|
|
AC_DEFINE(HAVE_GETTIMEOFDAY,1,[Define to 1 if we have gettimeofday function]),[
|
|
|
|
AC_CHECK_LIB(bsd, gettimeofday,
|
|
AC_DEFINE(HAVE_GETTIMEOFDAY,1,[Define to 1 if we have gettimeofday function])
|
|
CF_ADD_LIB(bsd))])dnl CLIX: bzero, select, gettimeofday
|
|
fi
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_GCC_ATTRIBUTES version: 28 updated: 2025/12/25 18:43:31
|
|
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],
|
|
[AC_REQUIRE([AC_PROG_FGREP])dnl
|
|
AC_REQUIRE([CF_C11_NORETURN])dnl
|
|
|
|
if test "$GCC" = yes || test "$GXX" = 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_MSG_CHECKING([for $CC __attribute__ directives])
|
|
test -n "$verbose" && AC_MSG_RESULT()
|
|
cat > "conftest.$ac_ext" <<EOF
|
|
#line __oline__ "${as_me:-configure}"
|
|
#include <stdio.h>
|
|
#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 GCC_NORETURN void oops(char *,...) GCC_PRINTFLIKE(1,2);
|
|
extern GCC_NORETURN void foo(void);
|
|
int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; 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>&AS_MESSAGE_LOG_FD
|
|
|
|
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-fgrep} define conftest.i >>confdefs.h
|
|
fi
|
|
rm -rf ./conftest*
|
|
fi
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_GCC_VERSION version: 9 updated: 2023/03/05 14:30:13
|
|
dnl --------------
|
|
dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
|
|
dnl compatible), attempt to determine if icc/clang is actually used.
|
|
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/^[[^(]]*([[^)]][[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
|
|
test -z "$GCC_VERSION" && GCC_VERSION=unknown
|
|
AC_MSG_RESULT($GCC_VERSION)
|
|
fi
|
|
CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
|
|
CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_GCC_WARNINGS version: 45 updated: 2025/12/24 09:07:25
|
|
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 -Winline (usually not worthwhile)
|
|
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])
|
|
if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
|
|
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_MSG_CHECKING([for $CC warning options])
|
|
test -n "$verbose" && AC_MSG_RESULT()
|
|
cf_save_CFLAGS="$CFLAGS"
|
|
EXTRA_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 && test "$GCC_VERSION" != "unknown"
|
|
then
|
|
AC_MSG_CHECKING([for $CC warning options])
|
|
test -n "$verbose" && AC_MSG_RESULT()
|
|
cf_save_CFLAGS="$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 Wno-inline $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
|
|
(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_GLOB_FULLPATH version: 2 updated: 2024/08/03 12:34:02
|
|
dnl ----------------
|
|
dnl Use this in case-statements to check for pathname syntax, i.e., absolute
|
|
dnl pathnames. The "x" is assumed since we provide an alternate form for DOS.
|
|
AC_DEFUN([CF_GLOB_FULLPATH],[
|
|
AC_REQUIRE([CF_WITH_SYSTYPE])dnl
|
|
case "$cf_cv_system_name" in
|
|
(cygwin*|msys*|mingw32*|mingw64|os2*)
|
|
GLOB_FULLPATH_POSIX='/*'
|
|
GLOB_FULLPATH_OTHER='[[a-zA-Z]]:[[\\/]]*'
|
|
;;
|
|
(*)
|
|
GLOB_FULLPATH_POSIX='/*'
|
|
GLOB_FULLPATH_OTHER=$GLOB_FULLPATH_POSIX
|
|
;;
|
|
esac
|
|
AC_SUBST(GLOB_FULLPATH_POSIX)
|
|
AC_SUBST(GLOB_FULLPATH_OTHER)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
|
|
dnl -----------------
|
|
AC_DEFUN([CF_GNATPREP_OPT_T],[
|
|
AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
|
|
cf_cv_gnatprep_opt_t=no
|
|
gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
|
|
])
|
|
test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
|
|
AC_SUBST(GNATPREP_OPTS)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_GNAT_GENERICS version: 7 updated: 2021/01/01 13:31:04
|
|
dnl ----------------
|
|
AC_DEFUN([CF_GNAT_GENERICS],
|
|
[
|
|
AC_REQUIRE([CF_GNAT_VERSION])
|
|
|
|
AC_MSG_CHECKING(if GNAT supports generics)
|
|
case "$cf_cv_gnat_version" in
|
|
(3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
|
|
cf_gnat_generics=yes
|
|
;;
|
|
(*)
|
|
cf_gnat_generics=no
|
|
;;
|
|
esac
|
|
AC_MSG_RESULT($cf_gnat_generics)
|
|
|
|
if test "$cf_gnat_generics" = yes
|
|
then
|
|
cf_compile_generics=generics
|
|
cf_generic_objects="\${GENOBJS}"
|
|
else
|
|
cf_compile_generics=
|
|
cf_generic_objects=
|
|
fi
|
|
|
|
AC_SUBST(cf_compile_generics)
|
|
AC_SUBST(cf_generic_objects)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_GNAT_PROJECTS version: 14 updated: 2025/12/24 12:27:29
|
|
dnl ----------------
|
|
dnl GNAT projects are configured with ".gpr" project files.
|
|
dnl GNAT libraries are a further development, using the project feature.
|
|
AC_DEFUN([CF_GNAT_PROJECTS],
|
|
[
|
|
AC_REQUIRE([CF_GNAT_VERSION])
|
|
AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
|
|
|
|
cf_gnat_libraries=no
|
|
cf_gnat_projects=no
|
|
|
|
if test "$enable_gnat_projects" != no ; then
|
|
AC_MSG_CHECKING(if GNAT supports project files)
|
|
case "$cf_cv_gnat_version" in
|
|
(3.[[0-9]]*)
|
|
;;
|
|
(*)
|
|
case "$cf_cv_system_name" in
|
|
(cygwin*|msys*)
|
|
;;
|
|
(*)
|
|
rm -rf ./conftest* ./*~conftest*
|
|
if mkdir conftest.src conftest.bin conftest.lib
|
|
then
|
|
cd conftest.src
|
|
rm -rf ./conftest* ./*~conftest*
|
|
cat >>library.gpr <<CF_EOF
|
|
project Library is
|
|
Kind := External ("LIB_KIND");
|
|
for Library_Name use "ConfTest";
|
|
for Object_Dir use ".";
|
|
for Library_ALI_Dir use External("LIBRARY_DIR");
|
|
for Library_Version use External ("SONAME");
|
|
for Library_Kind use Kind;
|
|
for Library_Dir use External("BUILD_DIR");
|
|
Source_Dir := External ("SOURCE_DIR");
|
|
for Source_Dirs use (Source_Dir);
|
|
end Library;
|
|
CF_EOF
|
|
cat >>confpackage.ads <<CF_EOF
|
|
package ConfPackage is
|
|
procedure conftest;
|
|
end ConfPackage;
|
|
CF_EOF
|
|
cat >>confpackage.adb <<CF_EOF
|
|
with Text_IO;
|
|
package body ConfPackage is
|
|
procedure conftest is
|
|
begin
|
|
Text_IO.Put ("Hello World");
|
|
Text_IO.New_Line;
|
|
end conftest;
|
|
end ConfPackage;
|
|
CF_EOF
|
|
if ( "$cf_ada_make" $ADAFLAGS \
|
|
-Plibrary.gpr \
|
|
-XBUILD_DIR="`cd ../conftest.bin;pwd`" \
|
|
-XLIBRARY_DIR="`cd ../conftest.lib;pwd`" \
|
|
-XSOURCE_DIR="`pwd`" \
|
|
-XSONAME=libConfTest.so.1 \
|
|
-XLIB_KIND=static 1>&AS_MESSAGE_LOG_FD 2>&1 ) ; then
|
|
cf_gnat_projects=yes
|
|
fi
|
|
cd ..
|
|
fi
|
|
if test -f conftest.lib/confpackage.ali
|
|
then
|
|
cf_gnat_libraries=yes
|
|
fi
|
|
rm -rf ./conftest* ./*~conftest*
|
|
;;
|
|
esac
|
|
;;
|
|
esac
|
|
AC_MSG_RESULT($cf_gnat_projects)
|
|
fi # enable_gnat_projects
|
|
|
|
if test "$cf_gnat_projects" = yes
|
|
then
|
|
AC_MSG_CHECKING(if GNAT supports libraries)
|
|
AC_MSG_RESULT($cf_gnat_libraries)
|
|
fi
|
|
|
|
USE_OLD_MAKERULES=""
|
|
USE_GNAT_PROJECTS="#"
|
|
USE_GNAT_MAKE_GPR="#"
|
|
USE_GNAT_GPRBUILD="#"
|
|
|
|
if test "$cf_gnat_projects" = yes
|
|
then
|
|
USE_OLD_MAKERULES="#"
|
|
USE_GNAT_PROJECTS=""
|
|
if test "$cf_cv_VERSION_GPRBUILD" != no
|
|
then
|
|
USE_GNAT_GPRBUILD=""
|
|
elif test "$cf_cv_VERSION_GNATMAKE" != no
|
|
then
|
|
USE_GNAT_MAKE_GPR=""
|
|
else
|
|
AC_MSG_WARN(use old makefile rules since tools are missing)
|
|
fi
|
|
fi
|
|
|
|
if test "$cf_gnat_libraries" = yes
|
|
then
|
|
USE_GNAT_LIBRARIES=""
|
|
else
|
|
USE_GNAT_LIBRARIES="#"
|
|
fi
|
|
|
|
AC_SUBST(USE_OLD_MAKERULES)
|
|
AC_SUBST(USE_GNAT_PROJECTS)
|
|
AC_SUBST(USE_GNAT_LIBRARIES)
|
|
AC_SUBST(USE_GNAT_MAKE_GPR)
|
|
AC_SUBST(USE_GNAT_GPRBUILD)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_GNAT_SIGINT version: 2 updated: 2021/01/01 13:31:04
|
|
dnl --------------
|
|
dnl Check if gnat supports SIGINT, and presumably tasking. For the latter, it
|
|
dnl is noted that gnat may compile a tasking unit even for configurations which
|
|
dnl fail at runtime.
|
|
AC_DEFUN([CF_GNAT_SIGINT],[
|
|
AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
|
|
CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
|
|
|
|
package ConfTest is
|
|
|
|
pragma Warnings (Off); -- the next pragma exists since 3.11p
|
|
pragma Unreserve_All_Interrupts;
|
|
pragma Warnings (On);
|
|
|
|
protected Process is
|
|
procedure Stop;
|
|
function Continue return Boolean;
|
|
pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
|
|
private
|
|
Done : Boolean := False;
|
|
end Process;
|
|
|
|
end ConfTest;],
|
|
[package body ConfTest is
|
|
protected body Process is
|
|
procedure Stop is
|
|
begin
|
|
Done := True;
|
|
end Stop;
|
|
function Continue return Boolean is
|
|
begin
|
|
return not Done;
|
|
end Continue;
|
|
end Process;
|
|
end ConfTest;],
|
|
[cf_cv_gnat_sigint=yes],
|
|
[cf_cv_gnat_sigint=no])])
|
|
|
|
if test "$cf_cv_gnat_sigint" = yes ; then
|
|
USE_GNAT_SIGINT=""
|
|
else
|
|
USE_GNAT_SIGINT="#"
|
|
fi
|
|
AC_SUBST(USE_GNAT_SIGINT)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_GNAT_TRY_LINK version: 5 updated: 2025/12/24 12:27:29
|
|
dnl ----------------
|
|
dnl Verify that a test program compiles/links with GNAT.
|
|
dnl $cf_ada_make is set to the program that compiles/links
|
|
dnl $ADAFLAGS may be set to the GNAT flags.
|
|
dnl
|
|
dnl $1 is the text of the spec
|
|
dnl $2 is the text of the body
|
|
dnl $3 is the shell command to execute if successful
|
|
dnl $4 is the shell command to execute if not successful
|
|
AC_DEFUN([CF_GNAT_TRY_LINK],
|
|
[
|
|
rm -rf ./conftest* ./*~conftest*
|
|
cat >>conftest.ads <<CF_EOF
|
|
$1
|
|
CF_EOF
|
|
cat >>conftest.adb <<CF_EOF
|
|
$2
|
|
CF_EOF
|
|
if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AS_MESSAGE_LOG_FD 2>&1 ) ; then
|
|
ifelse($3,, :,[ $3])
|
|
ifelse($4,,,[else
|
|
$4])
|
|
fi
|
|
rm -rf ./conftest* ./*~conftest*
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_GNAT_TRY_RUN version: 7 updated: 2025/12/24 12:27:29
|
|
dnl ---------------
|
|
dnl Verify that a test program compiles and runs with GNAT
|
|
dnl $cf_ada_make is set to the program that compiles/links
|
|
dnl $ADAFLAGS may be set to the GNAT flags.
|
|
dnl
|
|
dnl $1 is the text of the spec
|
|
dnl $2 is the text of the body
|
|
dnl $3 is the shell command to execute if successful
|
|
dnl $4 is the shell command to execute if not successful
|
|
AC_DEFUN([CF_GNAT_TRY_RUN],
|
|
[
|
|
rm -rf ./conftest* ./*~conftest*
|
|
cat >>conftest.ads <<CF_EOF
|
|
$1
|
|
CF_EOF
|
|
cat >>conftest.adb <<CF_EOF
|
|
$2
|
|
CF_EOF
|
|
if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AS_MESSAGE_LOG_FD 2>&1 ) ; then
|
|
if ( ./conftest 1>&AS_MESSAGE_LOG_FD 2>&1 ) ; then
|
|
ifelse($3,, :,[ $3])
|
|
ifelse($4,,,[ else
|
|
$4])
|
|
fi
|
|
ifelse($4,,,[else
|
|
$4])
|
|
fi
|
|
rm -rf ./conftest* ./*~conftest*
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54
|
|
dnl ---------------
|
|
dnl $1 = cache variable to update
|
|
dnl $2 = program name
|
|
dnl Verify version of GNAT or related tool
|
|
AC_DEFUN([CF_GNAT_VERSION],
|
|
[
|
|
AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[
|
|
cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \
|
|
grep '[[0-9]].[[0-9]][[0-9]]*' |\
|
|
sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
|
|
])
|
|
test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no
|
|
ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version])
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_GNU_SOURCE version: 11 updated: 2025/12/14 17:40:20
|
|
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...
|
|
dnl
|
|
dnl Parameters:
|
|
dnl $1 is the nominal value for _XOPEN_SOURCE
|
|
AC_DEFUN([CF_GNU_SOURCE],
|
|
[
|
|
cf_gnu_xopen_source=ifelse($1,,500,$1)
|
|
|
|
AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>],[
|
|
#if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
|
|
return 0;
|
|
#elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
|
|
return 0;
|
|
#else
|
|
# error not GNU C library
|
|
#endif])],
|
|
[cf_cv_gnu_library=yes],
|
|
[cf_cv_gnu_library=no])
|
|
])
|
|
|
|
if test x$cf_cv_gnu_library = xyes; then
|
|
|
|
# With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
|
|
# was changed to help a little. newlib incorporated the change about 4
|
|
# years later.
|
|
AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
|
|
cf_save="$CPPFLAGS"
|
|
CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>],[
|
|
#if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
|
|
return 0;
|
|
#elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
|
|
return 0;
|
|
#else
|
|
# error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
|
|
#endif])],
|
|
[cf_cv_gnu_library_219=yes],
|
|
[cf_cv_gnu_library_219=no])
|
|
CPPFLAGS="$cf_save"
|
|
])
|
|
|
|
if test "x$cf_cv_gnu_library_219" = xyes; then
|
|
cf_save="$CPPFLAGS"
|
|
AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
|
|
CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
|
|
#include <limits.h>
|
|
#include <sys/types.h>
|
|
],[
|
|
#if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
|
|
return 0;
|
|
#else
|
|
# error GNU C library is too old
|
|
#endif])],
|
|
[cf_cv_gnu_dftsrc_219=yes],
|
|
[cf_cv_gnu_dftsrc_219=no])
|
|
])
|
|
test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
|
|
else
|
|
cf_cv_gnu_dftsrc_219=maybe
|
|
fi
|
|
|
|
if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
|
|
|
|
AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>],[
|
|
#ifndef _XOPEN_SOURCE
|
|
#error expected _XOPEN_SOURCE to be defined
|
|
#endif])],
|
|
[cf_cv_gnu_source=no],
|
|
[cf_save="$CPPFLAGS"
|
|
CF_ADD_CFLAGS(-D_GNU_SOURCE)
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>],[
|
|
#ifdef _XOPEN_SOURCE
|
|
#error expected _XOPEN_SOURCE to be undefined
|
|
#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,[
|
|
CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>],[
|
|
#ifdef _DEFAULT_SOURCE
|
|
#error expected _DEFAULT_SOURCE to be undefined
|
|
#endif])],
|
|
[cf_cv_default_source=no],
|
|
[cf_cv_default_source=yes])
|
|
])
|
|
if test "$cf_cv_default_source" = yes
|
|
then
|
|
CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_HEADER_PATH version: 15 updated: 2021/01/01 13:31:04
|
|
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_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
|
|
dnl ---------------
|
|
dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
|
|
AC_DEFUN([CF_HELP_MESSAGE],
|
|
[CF_ACVERSION_CHECK(2.53,[],[
|
|
AC_DIVERT_HELP($1)])dnl
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
|
|
dnl ---------------
|
|
dnl Construct the list of include-options according to whether we're building
|
|
dnl in the source directory or using '--srcdir=DIR' option.
|
|
AC_DEFUN([CF_INCLUDE_DIRS],
|
|
[
|
|
if test "$srcdir" != "."; then
|
|
CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
|
|
fi
|
|
CPPFLAGS="-I../include $CPPFLAGS"
|
|
if test "$srcdir" != "."; then
|
|
CPPFLAGS="-I\${srcdir} $CPPFLAGS"
|
|
fi
|
|
CPPFLAGS="-I. $CPPFLAGS"
|
|
AC_SUBST(CPPFLAGS)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_INSTALL_OPTS version: 3 updated: 2023/06/03 15:17:30
|
|
dnl ---------------
|
|
dnl prompt for/fill-in useful install-program options
|
|
AC_DEFUN([CF_INSTALL_OPTS],
|
|
[
|
|
CF_INSTALL_OPT_S
|
|
CF_INSTALL_OPT_P
|
|
CF_INSTALL_OPT_O
|
|
CF_INSTALL_OPT_STRIP_PROG
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_INSTALL_OPT_O version: 3 updated: 2020/12/31 20:19:42
|
|
dnl ----------------
|
|
dnl Almost all "install" programs default to the current user's ownership.
|
|
dnl Almost - MINIX is an exception.
|
|
AC_DEFUN([CF_INSTALL_OPT_O],
|
|
[
|
|
AC_MSG_CHECKING(if install needs to be told about ownership)
|
|
case `$ac_config_guess` in
|
|
(*minix)
|
|
with_install_o=yes
|
|
;;
|
|
(*)
|
|
with_install_o=no
|
|
;;
|
|
esac
|
|
|
|
AC_MSG_RESULT($with_install_o)
|
|
if test "x$with_install_o" = xyes
|
|
then
|
|
INSTALL_OPT_O="`id root|sed -e 's/uid=[[0-9]]*(/ -o /' -e 's/gid=[[0-9]]*(/ -g /' -e 's/ [[^=[:space:]]][[^=[:space:]]]*=.*/ /' -e 's/)//g'`"
|
|
else
|
|
INSTALL_OPT_O=
|
|
fi
|
|
|
|
AC_SUBST(INSTALL_OPT_O)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_INSTALL_OPT_P version: 3 updated: 2021/01/01 13:31:04
|
|
dnl ----------------
|
|
dnl Some install-programs accept a "-p" option to preserve file modification
|
|
dnl timestamps. That can be useful as an install option, as well as a way to
|
|
dnl avoid the need for ranlib after copying a static archive.
|
|
AC_DEFUN([CF_INSTALL_OPT_P],
|
|
[
|
|
: "${INSTALL:=install}"
|
|
AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
|
|
rm -rf ./conftest*
|
|
date >conftest.in
|
|
mkdir conftest.out
|
|
sleep 3
|
|
if $INSTALL -p conftest.in conftest.out 2>/dev/null
|
|
then
|
|
if test -f conftest.out/conftest.in
|
|
then
|
|
test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
|
|
test conftest.out/conftest.in -nt conftest.in 2>conftest.err
|
|
if test -s conftest.err
|
|
then
|
|
cf_cv_install_p=no
|
|
else
|
|
cf_cv_install_p=yes
|
|
fi
|
|
else
|
|
cf_cv_install_p=no
|
|
fi
|
|
else
|
|
cf_cv_install_p=no
|
|
fi
|
|
rm -rf ./conftest*
|
|
])
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_INSTALL_OPT_S version: 3 updated: 2021/01/05 19:23:48
|
|
dnl ----------------
|
|
dnl By default, we should strip executables which are installed, but leave the
|
|
dnl ability to suppress that for unit-testing.
|
|
AC_DEFUN([CF_INSTALL_OPT_S],
|
|
[
|
|
AC_MSG_CHECKING(if you want to install stripped executables)
|
|
CF_ARG_DISABLE(stripping,
|
|
[ --disable-stripping do not strip (debug info) installed executables],
|
|
[enable_stripping=no],
|
|
[enable_stripping=yes])
|
|
AC_MSG_RESULT($enable_stripping)
|
|
|
|
if test "$enable_stripping" = yes
|
|
then
|
|
INSTALL_OPT_S="-s"
|
|
else
|
|
INSTALL_OPT_S=
|
|
fi
|
|
AC_SUBST(INSTALL_OPT_S)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_INSTALL_OPT_STRIP_PROG version: 1 updated: 2023/06/03 15:17:30
|
|
dnl -------------------------
|
|
dnl Provide an option for overriding the strip program used in install "-s"
|
|
dnl
|
|
dnl coreutils install provides a --strip-program option
|
|
dnl FreeBSD uses STRIPBIN environment variable, while NetBSD and OpenBSD use
|
|
dnl STRIP environment variable. Other versions of install do not support this.
|
|
AC_DEFUN([CF_INSTALL_OPT_STRIP_PROG],
|
|
[
|
|
AC_REQUIRE([CF_INSTALL_OPT_S])
|
|
if test -n "$INSTALL_OPT_S"
|
|
then
|
|
AC_MSG_CHECKING(if you want to specify strip-program)
|
|
AC_ARG_WITH(strip-program,
|
|
[ --with-strip-program=XX specify program to use when stripping in install],
|
|
[with_strip_program=$withval],
|
|
[with_strip_program=no])
|
|
AC_MSG_RESULT($with_strip_program)
|
|
if test "$with_strip_program" != no
|
|
then
|
|
AC_MSG_CHECKING(if strip-program is supported with this installer)
|
|
cf_install_program=`echo "$INSTALL" | sed -e 's%[[ ]]*[[ ]]-.%%'`
|
|
check_install_strip=no
|
|
if test -f "$cf_install_program"
|
|
then
|
|
check_install_version=`"$cf_install_program" --version 2>/dev/null | head -n 1 | grep coreutils`
|
|
if test -n "$check_install_version"
|
|
then
|
|
check_install_strip="option"
|
|
else
|
|
for check_strip_variable in STRIPBIN STRIP
|
|
do
|
|
if strings "$cf_install_program" | grep "^$check_strip_variable[$]" >/dev/null
|
|
then
|
|
check_install_strip="environ"
|
|
break
|
|
fi
|
|
done
|
|
fi
|
|
fi
|
|
AC_MSG_RESULT($check_install_strip)
|
|
case "$check_install_strip" in
|
|
(no)
|
|
AC_MSG_WARN($cf_install_program does not support strip program option)
|
|
with_strip_program=no
|
|
;;
|
|
(environ)
|
|
cat >install.tmp <<-CF_EOF
|
|
#! $SHELL
|
|
STRIPBIN="$with_strip_program" \\
|
|
STRIP="$with_strip_program" \\
|
|
$INSTALL "[$]@"
|
|
CF_EOF
|
|
INSTALL="`pwd`/install.tmp"
|
|
chmod +x "$INSTALL"
|
|
CF_VERBOSE(created $INSTALL)
|
|
;;
|
|
(option)
|
|
INSTALL_OPT_S="$INSTALL_OPT_S --strip-program=\"$with_strip_program\""
|
|
;;
|
|
esac
|
|
fi
|
|
fi
|
|
AC_SUBST(INSTALL_OPT_S)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_INSTALL_PREFIX version: 2 updated: 2025/10/18 11:14:21
|
|
dnl -----------------
|
|
dnl Special option for use by system-builders: the install-prefix is used to
|
|
dnl adjust the location into which the actual install is done, so that an
|
|
dnl archive can be built without modifying the host system's configuration.
|
|
AC_DEFUN([CF_INSTALL_PREFIX],[
|
|
AC_MSG_CHECKING(for an installation directory prefix)
|
|
AC_ARG_WITH(install-prefix,
|
|
[ --with-install-prefix=DESTDIR use DESTDIR as installation directory prefix],
|
|
[case "x$withval" in
|
|
(xyes|xno)
|
|
;;
|
|
(*) DESTDIR="$withval"
|
|
;;
|
|
esac])
|
|
AC_MSG_RESULT([${DESTDIR:-(none)}])
|
|
AC_SUBST(DESTDIR)
|
|
|
|
SET_DESTDIR=
|
|
test -n "$DESTDIR" && SET_DESTDIR="DESTDIR=$DESTDIR"
|
|
AC_SUBST(SET_DESTDIR)
|
|
|
|
AC_MSG_CHECKING(if installation directory prefix should be merged)
|
|
CF_ARG_ENABLE(install-prefix,
|
|
[ --enable-install-prefix merge DESTDIR with installation prefix],
|
|
cf_install_prefix=yes,
|
|
cf_install_prefix=no)
|
|
AC_MSG_RESULT($cf_install_prefix)
|
|
|
|
if test "$cf_install_prefix" = yes ; then
|
|
MERGE_PREFIX=':$(prefix)%=%'
|
|
else
|
|
MERGE_PREFIX=''
|
|
fi
|
|
|
|
AC_SUBST(MERGE_PREFIX)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_INTEL_COMPILER version: 10 updated: 2025/12/14 17:40:20
|
|
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_COMPILE_IFELSE([AC_LANG_PROGRAM([],[
|
|
#ifdef __INTEL_COMPILER
|
|
#else
|
|
#error __INTEL_COMPILER is not defined
|
|
#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_LARGEFILE version: 14 updated: 2025/12/22 04:16:14
|
|
dnl ------------
|
|
dnl Add checks for large file support.
|
|
AC_DEFUN([CF_LARGEFILE],[
|
|
ifdef([AC_FUNC_FSEEKO],[
|
|
AC_SYS_LARGEFILE
|
|
if test "$enable_largefile" != no ; then
|
|
AC_FUNC_FSEEKO
|
|
|
|
# Normally we would collect these definitions in the config.h,
|
|
# but (like _XOPEN_SOURCE), some environments rely on having these
|
|
# defined before any of the system headers are included. Another
|
|
# case comes up with C++, e.g., on AIX the compiler compiles the
|
|
# header files by themselves before looking at the body files it is
|
|
# told to compile. For ncurses, those header files do not include
|
|
# the config.h
|
|
if test "$ac_cv_sys_large_files" != no
|
|
then
|
|
CF_APPEND_TEXT(CPPFLAGS,-D_LARGE_FILES)
|
|
fi
|
|
if test "$ac_cv_sys_largefile_source" != no
|
|
then
|
|
CF_APPEND_TEXT(CPPFLAGS,-D_LARGEFILE_SOURCE)
|
|
fi
|
|
if test "$ac_cv_sys_file_offset_bits" != no
|
|
then
|
|
CF_APPEND_TEXT(CPPFLAGS,-D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits)
|
|
fi
|
|
|
|
AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
|
|
#pragma GCC diagnostic error "-Wincompatible-pointer-types"
|
|
#include <sys/types.h>
|
|
#include <dirent.h>
|
|
|
|
#ifndef __REDIRECT
|
|
/* if transitional largefile support is setup, this is true */
|
|
extern struct dirent64 * readdir(DIR *);
|
|
#endif
|
|
],[
|
|
DIR *dp = opendir(".");
|
|
struct dirent64 *x = readdir(dp);
|
|
struct dirent *y = readdir(dp);
|
|
int z = x - y;
|
|
(void)z;
|
|
])],
|
|
[cf_cv_struct_dirent64=yes],
|
|
[cf_cv_struct_dirent64=no])
|
|
])
|
|
test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64])
|
|
fi
|
|
])
|
|
])
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_LD_RPATH_OPT version: 10 updated: 2025/12/15 04:04:20
|
|
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=
|
|
if test "x$cf_cv_enable_rpath" != xno
|
|
then
|
|
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_LINK_IFELSE([AC_LANG_PROGRAM([], [])], 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
|
|
fi
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_LIBRARY_PATH version: 11 updated: 2021/01/01 13:31:04
|
|
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_LIB_PREFIX version: 14 updated: 2021/01/01 13:31:04
|
|
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
|
|
;;
|
|
(*-msvc*)
|
|
LIB_PREFIX=''
|
|
;;
|
|
(*) LIB_PREFIX='lib'
|
|
;;
|
|
esac
|
|
ifelse($1,,,[$1=$LIB_PREFIX])
|
|
AC_SUBST(LIB_PREFIX)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_LIB_SUFFIX version: 28 updated: 2021/01/01 16:53:59
|
|
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)
|
|
case "$cf_cv_system_name" in
|
|
(*-msvc*)
|
|
$2='_g.lib'
|
|
;;
|
|
(*)
|
|
$2='_g.a'
|
|
;;
|
|
esac
|
|
$3=[$]$2
|
|
;;
|
|
(Xprofile)
|
|
case "$cf_cv_system_name" in
|
|
(*-msvc*)
|
|
$2='_p.lib'
|
|
;;
|
|
(*)
|
|
$2='_p.a'
|
|
;;
|
|
esac
|
|
$3=[$]$2
|
|
;;
|
|
(Xshared)
|
|
case "$cf_cv_system_name" in
|
|
(aix[[5-7]]*)
|
|
$2='.so'
|
|
$3=[$]$2
|
|
;;
|
|
(*-msvc*)
|
|
$2='.dll'
|
|
$3='.dll.lib'
|
|
;;
|
|
(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
|
|
;;
|
|
(*)
|
|
case "$target" in
|
|
(*-msvc*)
|
|
$2='.lib'
|
|
;;
|
|
(*)
|
|
$2='.a'
|
|
;;
|
|
esac
|
|
$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_LIB_TYPE version: 5 updated: 2015/04/17 21:13:04
|
|
dnl -----------
|
|
dnl Compute the string to append to -library from the given model name
|
|
dnl $1 = model name
|
|
dnl $2 = variable to set
|
|
dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
|
|
AC_DEFUN([CF_LIB_TYPE],
|
|
[
|
|
case $1 in
|
|
(libtool) $2='' ;;
|
|
(normal) $2='' ;;
|
|
(debug) $2='_g' ;;
|
|
(profile) $2='_p' ;;
|
|
(shared) $2='' ;;
|
|
esac
|
|
test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_LINK_DATAONLY version: 17 updated: 2025/12/24 12:27:29
|
|
dnl ----------------
|
|
dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
|
|
dnl only data (i.e., no functions), for example NeXT. On those systems we'll
|
|
dnl have to provide wrappers for global tables to ensure they're linked
|
|
dnl properly.
|
|
AC_DEFUN([CF_LINK_DATAONLY],
|
|
[
|
|
AC_MSG_CHECKING([if data-only library module links])
|
|
AC_CACHE_VAL(cf_cv_link_dataonly,[
|
|
rm -f conftest.a
|
|
cat >conftest.$ac_ext <<EOF
|
|
#line __oline__ "configure"
|
|
int testdata[[3]] = { 123, 456, 789 };
|
|
EOF
|
|
if AC_TRY_EVAL(ac_compile) ; then
|
|
mv conftest.$OBJEXT data.$OBJEXT && \
|
|
( $AR $ARFLAGS conftest.a data.$OBJEXT ) 2>&AS_MESSAGE_LOG_FD 1>/dev/null
|
|
fi
|
|
rm -f conftest.$ac_ext data.$OBJEXT
|
|
cat >conftest.$ac_ext <<EOF
|
|
#line __oline__ "configure"
|
|
extern int testfunc(void);
|
|
#if defined(NeXT)
|
|
int testfunc(void)
|
|
{
|
|
${cf_cv_main_return:-return}(1); /* I'm told this linker is broken */
|
|
}
|
|
#else
|
|
extern int testdata[[3]];
|
|
int testfunc(void)
|
|
{
|
|
return testdata[[0]] == 123
|
|
&& testdata[[1]] == 456
|
|
&& testdata[[2]] == 789;
|
|
}
|
|
#endif
|
|
EOF
|
|
if AC_TRY_EVAL(ac_compile); then
|
|
mv conftest.$OBJEXT func.$OBJEXT && \
|
|
( $AR $ARFLAGS conftest.a func.$OBJEXT ) 2>&AS_MESSAGE_LOG_FD 1>/dev/null
|
|
fi
|
|
rm -f conftest.$ac_ext func.$OBJEXT
|
|
( eval $RANLIB conftest.a ) 2>&AS_MESSAGE_LOG_FD >/dev/null
|
|
cf_saveLIBS="$LIBS"
|
|
LIBS="conftest.a $LIBS"
|
|
AC_TRY_RUN([
|
|
extern int testfunc(void);
|
|
int main(void)
|
|
{
|
|
${cf_cv_main_return:-return} (!testfunc());
|
|
}
|
|
],
|
|
[cf_cv_link_dataonly=yes],
|
|
[cf_cv_link_dataonly=no],
|
|
[cf_cv_link_dataonly=unknown])
|
|
LIBS="$cf_saveLIBS"
|
|
])
|
|
AC_MSG_RESULT($cf_cv_link_dataonly)
|
|
|
|
if test "$cf_cv_link_dataonly" = no ; then
|
|
AC_DEFINE(BROKEN_LINKER,1,[if data-only library module does not link])
|
|
BROKEN_LINKER=1
|
|
fi
|
|
AC_SUBST(BROKEN_LINKER)
|
|
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_MAKE_PHONY version: 5 updated: 2025/12/27 13:03:23
|
|
dnl -------------
|
|
dnl Check if the make-program handles a ".PHONY" target, e.g,. a target which
|
|
dnl acts as a placeholder.
|
|
dnl
|
|
dnl The ".PHONY" feature was proposed in 2011 here
|
|
dnl https://www.austingroupbugs.net/view.php?id=523
|
|
dnl and is scheduled for release in P1003.1 Issue 8 (late 2022).
|
|
dnl
|
|
dnl This is not supported by SVr4 make (or SunOS 4, 4.3SD, etc), but works with
|
|
dnl a few others (i.e., GNU make and the non-POSIX "BSD" make):
|
|
dnl
|
|
dnl + This is a GNU make feature (since April 1988, but in turn from binutils,
|
|
dnl date unspecified).
|
|
dnl
|
|
dnl + It was adopted in NetBSD make in June 1995.
|
|
dnl
|
|
dnl + The other BSD make programs are derived from the NetBSD make (and for
|
|
dnl that reason are not actually different "implementations").
|
|
dnl
|
|
dnl + Some features of NetBSD make were actually adapted from pmake, which
|
|
dnl began as a modified GNU make starting in 1993.
|
|
dnl
|
|
dnl + Version 3.8 of the dmake program in January 1992 also implemented this
|
|
dnl GNU make extension, but is less well known than the BSD make.
|
|
AC_DEFUN([CF_MAKE_PHONY],[
|
|
AC_CACHE_CHECK(for ".PHONY" make-support, cf_cv_make_PHONY,[
|
|
rm -rf conftest*
|
|
(
|
|
mkdir conftest || exit 1
|
|
cd conftest
|
|
cat >makefile <<'CF_EOF'
|
|
.PHONY: always
|
|
DATA=0
|
|
always: always.out
|
|
@echo "** making [$]@ [$](DATA)"
|
|
once: once.out
|
|
@echo "** making [$]@ [$](DATA)"
|
|
always.out:
|
|
@echo "** making [$]@ [$](DATA)"
|
|
echo [$](DATA) > [$]@
|
|
once.out:
|
|
@echo "** making [$]@ [$](DATA)"
|
|
echo [$](DATA) > [$]@
|
|
CF_EOF
|
|
for cf_data in 1 2 3
|
|
do
|
|
${MAKE:-make} always DATA=$cf_data
|
|
${MAKE:-make} once DATA=$cf_data
|
|
${MAKE:-make} -t always once
|
|
if test -f always ; then
|
|
echo "no (case 1)" > ../conftest.tmp
|
|
elif test ! -f always.out ; then
|
|
echo "no (case 2)" > ../conftest.tmp
|
|
elif test ! -f once.out ; then
|
|
echo "no (case 3)" > ../conftest.tmp
|
|
elif ! cmp -s always.out once.out ; then
|
|
echo "no (case 4)" > ../conftest.tmp
|
|
diff always.out once.out
|
|
else
|
|
cf_check="`cat always.out`"
|
|
if test "x$cf_check" != "x$cf_data" ; then
|
|
echo "no (case 5)" > ../conftest.tmp
|
|
else
|
|
echo yes > ../conftest.tmp
|
|
rm -f ./*.out
|
|
continue
|
|
fi
|
|
fi
|
|
break
|
|
done
|
|
) >&AS_MESSAGE_LOG_FD 2>&1
|
|
cf_cv_make_PHONY="`cat conftest.tmp`"
|
|
rm -rf conftest*
|
|
])
|
|
MAKE_NO_PHONY="#"
|
|
MAKE_PHONY="#"
|
|
test "x$cf_cv_make_PHONY" = xyes && MAKE_PHONY=
|
|
test "x$cf_cv_make_PHONY" != xyes && MAKE_NO_PHONY=
|
|
AC_SUBST(MAKE_NO_PHONY)
|
|
AC_SUBST(MAKE_PHONY)
|
|
])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: 9 updated: 2021/01/01 16:53:59
|
|
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*|darwin*)
|
|
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_MKSTEMP version: 14 updated: 2025/12/14 18:08:20
|
|
dnl ----------
|
|
dnl Check for a working mkstemp. This creates two files, checks that they are
|
|
dnl successfully created and distinct (AmigaOS apparently fails on the last).
|
|
AC_DEFUN([CF_MKSTEMP],[
|
|
AC_CHECK_HEADERS( \
|
|
unistd.h \
|
|
)
|
|
AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
|
|
rm -rf ./conftest*
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([[
|
|
$ac_includes_default
|
|
|
|
int main(void)
|
|
{
|
|
static char tmpl[] = "conftestXXXXXX";
|
|
char name[2][80];
|
|
int n;
|
|
int result = 0;
|
|
int fd;
|
|
struct stat sb;
|
|
|
|
umask(077);
|
|
for (n = 0; n < 2; ++n) {
|
|
strcpy(name[n], tmpl);
|
|
if ((fd = mkstemp(name[n])) >= 0) {
|
|
if (!strcmp(name[n], tmpl)
|
|
|| stat(name[n], &sb) != 0
|
|
|| (sb.st_mode & S_IFMT) != S_IFREG
|
|
|| (sb.st_mode & 077) != 0) {
|
|
result = 1;
|
|
}
|
|
close(fd);
|
|
}
|
|
}
|
|
if (result == 0
|
|
&& !strcmp(name[0], name[1]))
|
|
result = 1;
|
|
${cf_cv_main_return:-return}(result);
|
|
}
|
|
]])],[cf_cv_func_mkstemp=yes
|
|
],[cf_cv_func_mkstemp=no
|
|
],[cf_cv_func_mkstemp=maybe])
|
|
])
|
|
if test "x$cf_cv_func_mkstemp" = xmaybe ; then
|
|
AC_CHECK_FUNC(mkstemp)
|
|
fi
|
|
if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
|
|
AC_DEFINE(HAVE_MKSTEMP,1,[Define to 1 if mkstemp() is available and working.])
|
|
fi
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_MSG_LOG version: 6 updated: 2025/12/14 17:51:46
|
|
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>&AS_MESSAGE_LOG_FD
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_NCURSES_ADDON version: 9 updated: 2025/12/24 13:30:00
|
|
dnl ----------------
|
|
dnl Configure an ncurses add-on, built outside the ncurses tree.
|
|
AC_DEFUN([CF_NCURSES_ADDON],[
|
|
AC_REQUIRE([CF_NCURSES_CONFIG])
|
|
|
|
AC_PROVIDE([CF_SUBST_NCURSES_VERSION])
|
|
|
|
AC_MSG_CHECKING(for specified curses library type)
|
|
AC_ARG_WITH(screen,
|
|
[ --with-screen=XXX use specified curses-libraries],
|
|
[cf_cv_screen=$withval],
|
|
[cf_cv_screen=ncurses])
|
|
|
|
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)
|
|
;;
|
|
(*)
|
|
AC_MSG_ERROR(unexpected screen-value: $cf_cv_screen)
|
|
;;
|
|
esac
|
|
|
|
AC_SUBST(cf_cv_screen)
|
|
|
|
if test "$NCURSES_CONFIG_PKG" != none ; then
|
|
cf_version=`$PKG_CONFIG --modversion $NCURSES_CONFIG_PKG 2>/dev/null`
|
|
|
|
NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
|
|
NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
|
|
NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
|
|
|
|
cf_cv_abi_version=`$PKG_CONFIG --variable=abi_version $NCURSES_CONFIG_PKG 2>/dev/null`
|
|
if test -z "$cf_cv_abi_version"
|
|
then
|
|
cf_cv_abi_version=`$PKG_CONFIG --variable=major_version $NCURSES_CONFIG_PKG 2>/dev/null`
|
|
fi
|
|
|
|
elif test "$NCURSES_CONFIG" != none ; then
|
|
|
|
cf_version=`$NCURSES_CONFIG --version 2>/dev/null`
|
|
|
|
NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
|
|
NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
|
|
NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
|
|
|
|
# ABI version is not available from headers
|
|
cf_cv_abi_version=`$NCURSES_CONFIG --abi-version 2>/dev/null`
|
|
|
|
else
|
|
|
|
for cf_name in MAJOR MINOR PATCH
|
|
do
|
|
cat >conftest.$ac_ext <<CF_EOF
|
|
#include <${cf_cv_ncurses_header:-curses.h}>
|
|
AUTOCONF_$cf_name NCURSES_VERSION_$cf_name
|
|
CF_EOF
|
|
cf_try="$ac_cpp conftest.$ac_ext 2>&5 | fgrep AUTOCONF_$cf_name >conftest.out"
|
|
AC_TRY_EVAL(cf_try)
|
|
if test -f conftest.out ; then
|
|
cf_result=`sed -e "s/^.*AUTOCONF_${cf_name}[[ ]][[ ]]*//" conftest.out`
|
|
eval NCURSES_$cf_name=\"$cf_result\"
|
|
# cat conftest.$ac_ext
|
|
# cat conftest.out
|
|
fi
|
|
done
|
|
|
|
cf_cv_abi_version=${NCURSES_MAJOR}
|
|
|
|
fi
|
|
|
|
cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
|
|
|
|
dnl Show the computed version, for logging
|
|
cf_cv_timestamp=`date`
|
|
|
|
AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
|
|
|
|
dnl We need these values in the generated headers
|
|
AC_SUBST(NCURSES_MAJOR)
|
|
AC_SUBST(NCURSES_MINOR)
|
|
AC_SUBST(NCURSES_PATCH)
|
|
|
|
dnl We need these values in the generated makefiles
|
|
AC_SUBST(cf_cv_rel_version)
|
|
AC_SUBST(cf_cv_abi_version)
|
|
|
|
AC_CACHE_CHECK(if KEY_RESIZE is supported,cf_cv_curses_resizes,[
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <${cf_cv_ncurses_header:-curses.h}>],
|
|
[int key = KEY_RESIZE; (void)key])],
|
|
cf_cv_curses_resizes=yes,
|
|
cf_cv_curses_resizes=no)])
|
|
cf_cv_enable_sigwinch=0
|
|
test "$cf_cv_curses_resizes" = yes && cf_cv_enable_sigwinch=1
|
|
AC_SUBST(cf_cv_enable_sigwinch)
|
|
])
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_NCURSES_CC_CHECK version: 7 updated: 2025/12/22 04:16:14
|
|
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_COMPILE_IFELSE([AC_LANG_PROGRAM([
|
|
]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
|
|
#error WACS_BSSB is not defined
|
|
#endif
|
|
])[
|
|
printf("%s\\n", NCURSES_VERSION);
|
|
#else
|
|
#ifdef __NCURSES_H
|
|
printf("old\\n");
|
|
#else
|
|
#error __NCURSES_H is not defined
|
|
#endif
|
|
#endif
|
|
])]dnl
|
|
,[$1=$2]
|
|
,[$1=no])
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_NCURSES_CONFIG version: 30 updated: 2025/12/22 04:16:14
|
|
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_CFLAGS="$CFLAGS"
|
|
cf_save_CPPFLAGS="$CPPFLAGS"
|
|
cf_save_LIBS="$LIBS"
|
|
|
|
cf_pkg_cflags="`$PKG_CONFIG --cflags $cf_ncuconfig_root`"
|
|
cf_pkg_libs="`$PKG_CONFIG --libs $cf_ncuconfig_root`"
|
|
|
|
# while -W for passing linker flags is prevalent, it is not "standard".
|
|
# At least one wrapper for c89/c99 (in Apple's xcode) has its own
|
|
# incompatible _and_ non-standard -W option which gives an error. Work
|
|
# around that pitfall.
|
|
case "x${CC}@@${cf_pkg_libs}@${cf_pkg_cflags}" in
|
|
(x*c[[89]]9@@*-W*)
|
|
CF_ADD_CFLAGS($cf_pkg_cflags)
|
|
CF_ADD_LIBS($cf_pkg_libs)
|
|
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <${cf_cv_ncurses_header:-curses.h}>],
|
|
[initscr(); mousemask(0,0); tigetstr((char *)0);])],
|
|
[AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
|
|
int main(void)
|
|
{ const char *xx = curses_version(); return (xx == 0); }],
|
|
[cf_test_ncuconfig=yes],
|
|
[cf_test_ncuconfig=no],
|
|
[cf_test_ncuconfig=maybe])],
|
|
[cf_test_ncuconfig=no])
|
|
|
|
CFLAGS="$cf_save_CFLAGS"
|
|
CPPFLAGS="$cf_save_CPPFLAGS"
|
|
LIBS="$cf_save_LIBS"
|
|
|
|
if test "x$cf_test_ncuconfig" != xyes; then
|
|
cf_temp=`echo "x$cf_pkg_cflags" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
|
|
cf_pkg_cflags="$cf_temp"
|
|
cf_temp=`echo "x$cf_pkg_libs" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
|
|
cf_pkg_libs="$cf_temp"
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
CF_REQUIRE_PKG($cf_ncuconfig_root)
|
|
CF_APPEND_CFLAGS($cf_pkg_cflags)
|
|
CF_ADD_LIBS($cf_pkg_libs)
|
|
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <${cf_cv_ncurses_header:-curses.h}>],
|
|
[initscr(); mousemask(0,0); tigetstr((char *)0);])],
|
|
[AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
|
|
int main(void)
|
|
{ const 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
|
|
CF_TERM_HEADER
|
|
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
|
|
cf_ncurses_config="${cf_ncuconfig_root}${NCURSES_CONFIG_SUFFIX}-config"; echo "Looking for ${cf_ncurses_config}"
|
|
|
|
CF_ACVERSION_CHECK(2.52,
|
|
[AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
|
|
[AC_PATH_PROGS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
|
|
|
|
if test "$NCURSES_CONFIG" != none ; then
|
|
|
|
CF_APPEND_CFLAGS(`$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: 22 updated: 2021/01/02 09:31:20
|
|
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: 8 updated: 2025/12/22 04:16:14
|
|
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 $ECHO_N " ... found $ECHO_C" 1>&AS_MESSAGE_FD
|
|
break
|
|
fi
|
|
test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&AS_MESSAGE_FD
|
|
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: 22 updated: 2025/12/22 04:16:14
|
|
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 is 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_LINK_IFELSE([AC_LANG_PROGRAM([#include <${cf_cv_ncurses_header:-curses.h}>],
|
|
[initscr(); mousemask(0,0); tigetstr((char *)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_VERSION version: 19 updated: 2025/12/22 04:16:14
|
|
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([
|
|
$ac_includes_default
|
|
|
|
#include <${cf_cv_ncurses_header:-curses.h}>
|
|
|
|
int main(void)
|
|
{
|
|
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
|
|
#error expected ncurses header to define __NCURSES_H
|
|
# 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>&AS_MESSAGE_LOG_FD | grep '^Autoconf ' >conftest.out"
|
|
AC_TRY_EVAL(cf_try)
|
|
if test -f conftest.out ; then
|
|
cf_out=`sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%' conftest.out`
|
|
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_OBJ_SUBDIR version: 8 updated: 2021/01/01 13:31:04
|
|
dnl -------------
|
|
dnl Compute the object-directory name from the given model name
|
|
AC_DEFUN([CF_OBJ_SUBDIR],
|
|
[
|
|
case $1 in
|
|
(libtool) $2='obj_lo' ;;
|
|
(normal) $2='objects' ;;
|
|
(debug) $2='obj_g' ;;
|
|
(profile) $2='obj_p' ;;
|
|
(shared)
|
|
case "$cf_cv_system_name" in
|
|
(cygwin|msys)
|
|
$2='objects' ;;
|
|
(*)
|
|
$2='obj_s' ;;
|
|
esac
|
|
esac
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_PATHSEP version: 8 updated: 2021/01/01 13:31:04
|
|
dnl ----------
|
|
dnl Provide a value for the $PATH and similar separator (or amend the value
|
|
dnl as provided in autoconf 2.5x).
|
|
AC_DEFUN([CF_PATHSEP],
|
|
[
|
|
AC_MSG_CHECKING(for PATH separator)
|
|
case "$cf_cv_system_name" in
|
|
(os2*) PATH_SEPARATOR=';' ;;
|
|
(*) ${PATH_SEPARATOR:=':'} ;;
|
|
esac
|
|
ifelse([$1],,,[$1=$PATH_SEPARATOR])
|
|
AC_SUBST(PATH_SEPARATOR)
|
|
AC_MSG_RESULT($PATH_SEPARATOR)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_PATH_SYNTAX version: 20 updated: 2025/12/16 04:09:03
|
|
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],[
|
|
AC_REQUIRE([CF_GLOB_FULLPATH])dnl
|
|
|
|
if test "x$prefix" != xNONE; then
|
|
cf_path_syntax="$prefix"
|
|
else
|
|
cf_path_syntax="$ac_default_prefix"
|
|
fi
|
|
|
|
case "x[$]$1" in
|
|
(x\[$]\(*\)*|x\'*\'*)
|
|
;;
|
|
(x.|x$GLOB_FULLPATH_POSIX|x$GLOB_FULLPATH_OTHER)
|
|
;;
|
|
(x\[$]\{*prefix\}*|x\[$]\{*dir\}*)
|
|
eval $1="[$]$1"
|
|
case "x[$]$1" in
|
|
(xNONE/*)
|
|
$1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
|
|
;;
|
|
esac
|
|
;;
|
|
(xno|xNONE/*)
|
|
$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_PKG_CONFIG version: 13 updated: 2023/10/28 11:59:01
|
|
dnl -------------
|
|
dnl Check for the package-config program, unless disabled by command-line.
|
|
dnl
|
|
dnl Sets $PKG_CONFIG to the pathname of the pkg-config program.
|
|
AC_DEFUN([CF_PKG_CONFIG],
|
|
[
|
|
AC_MSG_CHECKING(if you want to use pkg-config)
|
|
AC_ARG_WITH(pkg-config,
|
|
[[ --with-pkg-config[=CMD] enable/disable use of pkg-config and its name CMD]],
|
|
[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: 13 updated: 2025/12/14 17:40:20
|
|
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],
|
|
[AC_REQUIRE([CF_POSIX_VISIBLE])dnl
|
|
|
|
if test "$cf_cv_posix_visible" = no; then
|
|
|
|
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_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>],[
|
|
#ifndef _POSIX_C_SOURCE
|
|
#error _POSIX_C_SOURCE is not defined
|
|
#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_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>],[
|
|
#ifdef _POSIX_SOURCE
|
|
#error _POSIX_SOURCE is defined
|
|
#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_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
|
|
CF_MSG_LOG(if the second compile does not leave our definition intact error)
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>],[
|
|
#ifndef _POSIX_C_SOURCE
|
|
#error _POSIX_C_SOURCE is not defined
|
|
#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
|
|
|
|
fi # cf_cv_posix_visible
|
|
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_POSIX_VISIBLE version: 2 updated: 2025/12/14 17:40:20
|
|
dnl ----------------
|
|
dnl POSIX documents test-macros which an application may set before any system
|
|
dnl headers are included to make features available.
|
|
dnl
|
|
dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
|
|
dnl diverged from POSIX in 2002 by setting symbols which make all of the most
|
|
dnl recent features visible in the system header files unless the application
|
|
dnl overrides the corresponding test-macros. Doing that introduces portability
|
|
dnl problems.
|
|
dnl
|
|
dnl This macro makes a special check for the symbols used for this, to avoid a
|
|
dnl conflicting definition.
|
|
AC_DEFUN([CF_POSIX_VISIBLE],
|
|
[
|
|
AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <stdio.h>],[
|
|
#if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
|
|
&& defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
|
|
&& defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
|
|
&& defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
|
|
#error conflicting symbols found
|
|
#endif
|
|
])],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
|
|
])
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
|
|
dnl ----------
|
|
dnl Check for archiver "ar".
|
|
AC_DEFUN([CF_PROG_AR],[
|
|
AC_CHECK_TOOL(AR, ar, ar)
|
|
])
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
|
|
dnl -----------
|
|
dnl Check for awk, ensure that the check found something.
|
|
AC_DEFUN([CF_PROG_AWK],
|
|
[
|
|
AC_PROG_AWK
|
|
test -z "$AWK" && AC_MSG_ERROR(No awk program found)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
|
|
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],[
|
|
CF_ACVERSION_CHECK(2.53,
|
|
[AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
|
|
AC_REQUIRE([AC_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_CC_C_O version: 7 updated: 2025/12/24 12:27:29
|
|
dnl --------------
|
|
dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
|
|
dnl the output file can be renamed, and allows for a shell variable that can
|
|
dnl be used later. The parameter is either CC or CXX. The result is the
|
|
dnl cache variable:
|
|
dnl $cf_cv_prog_CC_c_o
|
|
dnl $cf_cv_prog_CXX_c_o
|
|
dnl
|
|
dnl $1 = compiler
|
|
dnl $2 = compiler options, if any
|
|
AC_DEFUN([CF_PROG_CC_C_O],
|
|
[AC_REQUIRE([AC_PROG_CC])dnl
|
|
AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
|
|
AC_CACHE_VAL(cf_cv_prog_$1_c_o,
|
|
[
|
|
cat > conftest.$ac_ext <<CF_EOF
|
|
int main(void)
|
|
{
|
|
${cf_cv_main_return:-return}(0);
|
|
}
|
|
CF_EOF
|
|
# We do the test twice because some compilers refuse to overwrite an
|
|
# existing .o file with -o, though they will create one.
|
|
ac_try='[$]$1 $2 -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD'
|
|
if AC_TRY_EVAL(ac_try) &&
|
|
test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
|
|
then
|
|
eval cf_cv_prog_$1_c_o=yes
|
|
else
|
|
eval cf_cv_prog_$1_c_o=no
|
|
fi
|
|
rm -rf ./conftest*
|
|
])dnl
|
|
if test "$cf_cv_prog_$1_c_o" = yes; then
|
|
AC_MSG_RESULT([yes])
|
|
else
|
|
AC_MSG_RESULT([no])
|
|
fi
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_PROG_EGREP version: 2 updated: 2015/04/18 08:56:57
|
|
dnl -------------
|
|
dnl AC_PROG_EGREP was introduced in autoconf 2.53.
|
|
dnl This macro adds a check to ensure the script found something.
|
|
AC_DEFUN([CF_PROG_EGREP],
|
|
[AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
|
|
[if echo a | (grep -E '(a|b)') >/dev/null 2>&1
|
|
then ac_cv_prog_egrep='grep -E'
|
|
else ac_cv_prog_egrep='egrep'
|
|
fi])
|
|
EGREP=$ac_cv_prog_egrep
|
|
AC_SUBST([EGREP])
|
|
test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_PROG_EXT version: 15 updated: 2021/01/02 09:31:20
|
|
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"
|
|
CF_APPEND_TEXT(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_GNAT version: 13 updated: 2025/12/24 12:27:29
|
|
dnl ------------
|
|
dnl Check for gnat/gnatmake/etc, ensure that the toolset is complete.
|
|
AC_DEFUN([CF_PROG_GNAT],[
|
|
for cf_prog_gnat in gnat gnatmake gprconfig gprbuild
|
|
do
|
|
CF_UPPER(cf_upper_prog_gnat,${cf_prog_gnat})
|
|
|
|
unset ac_cv_path_cf_TEMP_gnat
|
|
unset cf_TEMP_gnat
|
|
AC_PATH_PROG(cf_TEMP_gnat,$cf_prog_gnat,no)
|
|
eval "cf_cv_PATH_$cf_upper_prog_gnat=[$]ac_cv_path_cf_TEMP_gnat"
|
|
|
|
if test "x$cf_TEMP_gnat" != xno; then
|
|
unset cf_cv_gnat_version
|
|
unset cf_TEMP_gnat
|
|
CF_GNAT_VERSION(cf_TEMP_gnat,$cf_prog_gnat)
|
|
fi
|
|
eval "cf_cv_VERSION_$cf_upper_prog_gnat=[$]cf_TEMP_gnat"
|
|
|
|
unset cf_TEMP_gnat
|
|
unset cf_cv_gnat_version
|
|
unset ac_cv_path_cf_TEMP_gnat
|
|
done
|
|
|
|
if test "x$cf_cv_VERSION_GNATMAKE" = "xno"; then
|
|
cf_ada_make=
|
|
cf_cv_prog_gnat_correct=no
|
|
else
|
|
cf_ada_make=gnatmake
|
|
if test "x$cf_cv_VERSION_GPRCONFIG" = "xno"; then
|
|
# gprconfig is newer than gnatmake; we can continue...
|
|
cf_ada_config="##"
|
|
else
|
|
rm -rf ./conftest* ./*~conftest*
|
|
if mkdir conftest.src
|
|
then
|
|
cf_ada_config=""
|
|
cd conftest.src
|
|
for cf_gprconfig in Ada C
|
|
do
|
|
AC_MSG_CHECKING(for gprconfig name for $cf_gprconfig)
|
|
if test "$cf_gprconfig" = C
|
|
then
|
|
for cf_gprconfig_param in \
|
|
"$cf_gprconfig,,,,GNATGCC" \
|
|
"$cf_gprconfig,,,,GCC" \
|
|
"$cf_gprconfig"
|
|
do
|
|
cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AS_MESSAGE_LOG_FD | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
|
|
test -n "$cf_gprconfig_value" && break
|
|
done
|
|
else
|
|
cf_gprconfig_param=$cf_gprconfig
|
|
cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AS_MESSAGE_LOG_FD | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
|
|
fi
|
|
if test -n "$cf_gprconfig_value"
|
|
then
|
|
eval "cf_ada_config_[$]cf_gprconfig=[$]cf_gprconfig_value"
|
|
AC_MSG_RESULT($cf_gprconfig_value)
|
|
else
|
|
AC_MSG_RESULT(missing)
|
|
cf_ada_config="#"
|
|
break
|
|
fi
|
|
done
|
|
cd ..
|
|
rm -rf ./conftest* ./*~conftest*
|
|
fi
|
|
fi
|
|
if test "x$cf_ada_config" != "x#"
|
|
then
|
|
CF_GNAT_VERSION
|
|
CF_CHECK_GNAT_VERSION
|
|
AC_CHECK_PROG(M4_exists, m4, yes, no)
|
|
if test "$ac_cv_prog_M4_exists" = no; then
|
|
cf_cv_prog_gnat_correct=no
|
|
AC_MSG_WARN(Ada95 binding required program m4 not found. Ada95 binding disabled)
|
|
fi
|
|
if test "$cf_cv_prog_gnat_correct" = yes; then
|
|
AC_MSG_CHECKING(if GNAT works)
|
|
CF_GNAT_TRY_RUN([procedure conftest;],
|
|
[with Text_IO;
|
|
with GNAT.OS_Lib;
|
|
procedure conftest is
|
|
begin
|
|
Text_IO.Put ("Hello World");
|
|
Text_IO.New_Line;
|
|
GNAT.OS_Lib.OS_Exit (0);
|
|
end conftest;],
|
|
[cf_cv_prog_gnat_correct=yes],
|
|
[cf_cv_prog_gnat_correct=no])
|
|
AC_MSG_RESULT($cf_cv_prog_gnat_correct)
|
|
fi
|
|
else
|
|
cf_cv_prog_gnat_correct=no
|
|
fi
|
|
fi
|
|
|
|
AC_SUBST(cf_ada_make)
|
|
AC_SUBST(cf_ada_config)
|
|
AC_SUBST(cf_ada_config_Ada)
|
|
AC_SUBST(cf_ada_config_C)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_PROG_INSTALL version: 13 updated: 2025/10/21 16:28:49
|
|
dnl ---------------
|
|
dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the
|
|
dnl misc/tabset install won't work properly. Usually this happens only when
|
|
dnl using the fallback mkinstalldirs script
|
|
AC_DEFUN([CF_PROG_INSTALL],
|
|
[AC_PROG_INSTALL
|
|
AC_REQUIRE([CF_GLOB_FULLPATH])dnl
|
|
if test "x$INSTALL" = "x./install-sh -c"; then
|
|
if test -f /usr/sbin/install ; then
|
|
case "$host_os" in
|
|
(linux*gnu*|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin|msys|mingw*|linux*uclibc)
|
|
INSTALL=/usr/sbin/install
|
|
;;
|
|
esac
|
|
fi
|
|
fi
|
|
case x$INSTALL in
|
|
(x$GLOB_FULLPATH_POSIX|x$GLOB_FULLPATH_OTHER)
|
|
;;
|
|
(*)
|
|
CF_DIRNAME(cf_dir,$INSTALL)
|
|
test -z "$cf_dir" && cf_dir=.
|
|
INSTALL="`cd \"$cf_dir\" && pwd`"/"`echo "$INSTALL" | sed -e 's%^.*/%%'`"
|
|
;;
|
|
esac
|
|
])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_CFLAGS version: 3 updated: 2021/09/05 17:25:40
|
|
dnl ----------------
|
|
dnl Remove a given option from CFLAGS/CPPFLAGS
|
|
dnl $1 = option to remove
|
|
dnl $2 = variable to update
|
|
dnl $3 = nonempty to allow verbose message
|
|
define([CF_REMOVE_CFLAGS],
|
|
[
|
|
cf_tmp_cflag=`echo "x$1" | sed -e 's/^.//' -e 's/=.*//'`
|
|
while true
|
|
do
|
|
cf_old_cflag=`echo "x[$]$2" | sed -e 's/^.//' -e 's/[[ ]][[ ]]*-/ -/g' -e "s%$cf_tmp_cflag\\(=[[^ ]][[^ ]]*\\)\?%%" -e 's/^[[ ]]*//' -e 's%[[ ]][[ ]]*-D% -D%g' -e 's%[[ ]][[ ]]*-I% -I%g'`
|
|
test "[$]$2" != "$cf_old_cflag" || break
|
|
ifelse([$3],,,[CF_VERBOSE(removing old option $1 from $2)])
|
|
$2="$cf_old_cflag"
|
|
done
|
|
])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_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
|
|
dnl -------------
|
|
dnl Remove the given library from the symbol
|
|
dnl
|
|
dnl $1 = target (which could be the same as the source variable)
|
|
dnl $2 = source (including '$')
|
|
dnl $3 = library to remove
|
|
define([CF_REMOVE_LIB],
|
|
[
|
|
# remove $3 library from $2
|
|
$1=`echo "$2" | sed -e 's/-l$3[[ ]]//g' -e 's/-l$3[$]//'`
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_REQUIRE_PKG version: 1 updated: 2025/01/10 19:55:54
|
|
dnl --------------
|
|
dnl Update $REQUIRE_PKG, which lists the known required packages for this
|
|
dnl program.
|
|
dnl
|
|
dnl $1 = package(s) to require, e.g., in the generated ".pc" file
|
|
define([CF_REQUIRE_PKG],
|
|
[
|
|
for cf_required in $1
|
|
do
|
|
# check for duplicates
|
|
for cf_require_pkg in $REQUIRE_PKG
|
|
do
|
|
if test "$cf_required" = "$cf_require_pkg"
|
|
then
|
|
cf_required=
|
|
break
|
|
fi
|
|
done
|
|
test -n "$cf_required" && REQUIRE_PKG="$REQUIRE_PKG $cf_required"
|
|
done
|
|
AC_SUBST(REQUIRE_PKG)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45
|
|
dnl ---------------------
|
|
dnl Restore flags saved in CF_SAVE_XTRA_FLAGS
|
|
dnl $1 = name of current macro
|
|
define([CF_RESTORE_XTRA_FLAGS],
|
|
[
|
|
LIBS="$cf_save_LIBS_$1"
|
|
CFLAGS="$cf_save_CFLAGS_$1"
|
|
CPPFLAGS="$cf_save_CPPFLAGS_$1"
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44
|
|
dnl ------------------
|
|
dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers
|
|
dnl and libraries which do not update those variables.
|
|
dnl
|
|
dnl $1 = name of current macro
|
|
define([CF_SAVE_XTRA_FLAGS],
|
|
[
|
|
cf_save_LIBS_$1="$LIBS"
|
|
cf_save_CFLAGS_$1="$CFLAGS"
|
|
cf_save_CPPFLAGS_$1="$CPPFLAGS"
|
|
LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}"
|
|
for cf_X_CFLAGS in $X_CFLAGS
|
|
do
|
|
case "x$cf_X_CFLAGS" in
|
|
x-[[IUD]]*)
|
|
CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS"
|
|
;;
|
|
*)
|
|
CFLAGS="$CFLAGS $cf_X_CFLAGS"
|
|
;;
|
|
esac
|
|
done
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_SHARED_OPTS version: 114 updated: 2025/12/15 04:04:20
|
|
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 is 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(whether to use release or ABI version in shared library file names)
|
|
AC_ARG_WITH(shlib-version,
|
|
[[ --with-shlib-version[={rel|abi}] use release or ABI version in shared library file names]],
|
|
[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=
|
|
|
|
cf_try_fPIC=no
|
|
if test "$GCC" = yes
|
|
then
|
|
cf_try_fPIC=yes
|
|
else
|
|
case "$cf_cv_system_name" in
|
|
(*linux*) # e.g., PGI compiler
|
|
cf_try_fPIC=yes
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
if test "$cf_try_fPIC" = 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_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <stdio.h>],[int x = 1; (void)x])],[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} ${LDFLAGS} ${CFLAGS} -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} ${LDFLAGS} ${CFLAGS} -G -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
|
|
fi
|
|
;;
|
|
(beos*)
|
|
MK_SHARED_LIB='${CC} ${LDFLAGS} ${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 \[$]* ${LDFLAGS} -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 \[$]* ${LDFLAGS} -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} ${LDFLAGS} ${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_LINK_IFELSE([AC_LANG_PROGRAM([], [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
|
|
;;
|
|
(haiku*)
|
|
CF_SHARED_SONAME
|
|
MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
|
|
;;
|
|
(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} ${LDFLAGS} -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} ${LDFLAGS} +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} ${LDFLAGS} ${CFLAGS} -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} ${LDFLAGS} ${CFLAGS} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
|
|
else
|
|
MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,`basename $[@]` -o $[@]'
|
|
fi
|
|
cf_cv_rm_so_locs=yes
|
|
;;
|
|
(linux*|gnu*|k*bsd*-gnu)
|
|
if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; 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} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
|
|
;;
|
|
(mingw*msvc*)
|
|
cf_cv_shlib_version=msvcdll
|
|
cf_cv_shlib_version_infix=msvcdll
|
|
shlibdir=$bindir
|
|
MAKE_DLLS=
|
|
if test "$DFT_LWR_MODEL" = "shared" ; then
|
|
LOCAL_LDFLAGS="-link -dll"
|
|
LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
|
|
EXTRA_LDFLAGS="-link -dll $EXTRA_LDFLAGS"
|
|
fi
|
|
CC_SHARED_OPTS=
|
|
MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ ${LD} [$]{CFLAGS}'
|
|
RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.lib"
|
|
cat >mk_shared_lib.sh <<-CF_EOF
|
|
#!$SHELL
|
|
SHARED_LIB=\[$]1
|
|
IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.lib/'\`
|
|
shift
|
|
my_ld=\[$]1
|
|
shift
|
|
cat <<-EOF
|
|
Linking shared library
|
|
** SHARED LIB \$SHARED_LIB
|
|
** IMPORT_LIB \$IMPORT_LIB
|
|
EOF
|
|
args=\$(echo \[$]* | sed -E "s#-l(\w*)#\1.dll.lib#g" | sed -E "s#-L(\w*)#-LIBPATH:\1#g")
|
|
exec \$my_ld -DLL -IMPLIB:"\${IMPORT_LIB}" -OUT:"\${SHARED_LIB}" ${LDFLAGS} \$args
|
|
mv "\${IMPORT_LIB}" "\${IMPORT_LIB}"
|
|
CF_EOF
|
|
chmod +x mk_shared_lib.sh
|
|
cat >mk_prog.sh <<-CF_EOF
|
|
#!$SHELL
|
|
shift
|
|
# Ignore first argument (compiler) and use LD (link.exe) unconditionally
|
|
LD="[$]LD"
|
|
clopts=()
|
|
ldopts=("/subsystem:console")
|
|
libs=()
|
|
isdll=0
|
|
while test \[$]# -gt 0; do
|
|
case "\[$]1" in
|
|
-link)
|
|
# ignore -link argument
|
|
;;
|
|
-M[[TD]] | -M[[TD]]d)
|
|
# ignore runtime-library option
|
|
;;
|
|
-dll)
|
|
isdll=1
|
|
;;
|
|
-W* | -w*)
|
|
# ignore warnings
|
|
;;
|
|
-D*)
|
|
clopts+=("\[$]1")
|
|
;;
|
|
-I*)
|
|
clopts+=("\[$]1")
|
|
;;
|
|
-l*)
|
|
libs+=("\`echo \"\[$]1\" | sed \"s/^-l//\"\`")
|
|
;;
|
|
-L*)
|
|
ldopts+=("\`echo \"\[$]1\" | sed \"s/^-L/-LIBPATH:/\"\`")
|
|
;;
|
|
*.obj | *.$OBJEXT)
|
|
ldopts+=("\[$]1")
|
|
;;
|
|
-Wl,*)
|
|
for linkarg in \`echo '\[$]1' | sed -e 's/-Wl,//' -e 's/,/ /'\`; do
|
|
ldopts+=("\[$]{linkarg}")
|
|
done
|
|
;;
|
|
*.lib)
|
|
ldopts+=("\[$]1")
|
|
;;
|
|
-o)
|
|
shift
|
|
ldopts+=("-out:\[$]1")
|
|
;;
|
|
*)
|
|
clopts+=("\[$]1")
|
|
ldopts+=("\[$]1")
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
if [[ "\$isdll" -ne 0 ]]; then
|
|
for lib in \[$]{libs[[*]]}; do
|
|
ldopts+=("\[$]lib.dll.lib")
|
|
done
|
|
else
|
|
for lib in \[$]{libs[[*]]}; do
|
|
ldopts+=("\[$]lib.lib")
|
|
done
|
|
fi
|
|
cat <<-EOF
|
|
Creating program
|
|
** ld options: "\[$]{ldopts[[@]]}"
|
|
EOF
|
|
exec \[$]LD \[$]{ldopts[[@]]}
|
|
CF_EOF
|
|
chmod +x mk_prog.sh
|
|
LINK_PROGS="$SHELL ${rel_builddir}/mk_prog.sh"
|
|
LINK_TESTS="$SHELL ${rel_builddir}/mk_prog.sh"
|
|
;;
|
|
(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 \[$]* ${LDFLAGS} -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" && test -n "$LD_RPATH_OPT" ; 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} ${LDFLAGS} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
|
|
;;
|
|
(nskJ*)
|
|
CC_SHARED_OPTS=
|
|
MK_SHARED_LIB='${LD} -Wshared -Weld=-export_all -o $[@]'
|
|
;;
|
|
(nskL*)
|
|
CC_SHARED_OPTS=
|
|
MK_SHARED_LIB='${LD} -Wshared -Wxld=-export_all -o $[@]'
|
|
;;
|
|
(nto-qnx*|openbsd*|freebsd[[12]].*)
|
|
CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
|
|
MK_SHARED_LIB='${LD} ${LDFLAGS} -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} ${LDFLAGS} ${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} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
|
|
else
|
|
MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -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} ${LDFLAGS} -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" && test -n "$LD_RPATH_OPT" ; 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} ${LDFLAGS} -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} ${LDFLAGS} -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_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <stdio.h>],[printf("Hello\\n");])],[break])
|
|
done
|
|
CFLAGS="$cf_save_CFLAGS"
|
|
CC_SHARED_OPTS=$cf_shared_opts
|
|
MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dy -G -Wl,-h,'$cf_cv_shared_soname' -o $[@]'
|
|
else
|
|
MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -dy -G -Wl,-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} ${LDFLAGS} -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]] == NULL) ;
|
|
}
|
|
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_STRIP_G_OPT version: 4 updated: 2021/01/02 09:31:20
|
|
dnl --------------
|
|
dnl Remove "-g" option from the compiler options
|
|
AC_DEFUN([CF_STRIP_G_OPT],
|
|
[$1=`echo "${$1}" | CF__SED_TRIMBLANKS(-e 's%-g %%' -e 's%-g$%%')`])dnl
|
|
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: 7 updated: 2025/12/22 04:16:14
|
|
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_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <stdio.h>
|
|
#include <${cf_cv_ncurses_header:-curses.h}>
|
|
#include <$cf_test>
|
|
],[int x = auto_left_margin; (void)x])],[
|
|
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_TRY_XOPEN_SOURCE version: 5 updated: 2025/12/14 17:40:20
|
|
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_COMPILE_IFELSE([AC_LANG_PROGRAM(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY)],
|
|
[cf_cv_xopen_source=no],
|
|
[cf_save="$CPPFLAGS"
|
|
CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE)
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY)],
|
|
[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_APPEND_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: 12 updated: 2025/12/22 04:16:14
|
|
dnl -----------
|
|
dnl Check for multibyte support, and if not found, utf8 compatibility library
|
|
AC_DEFUN([CF_UTF8_LIB],
|
|
[
|
|
AC_CHECK_HEADERS(wchar.h)
|
|
AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
|
|
cf_save_LIBS="$LIBS"
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([
|
|
$ac_includes_default
|
|
#ifdef HAVE_WCHAR_H
|
|
#include <wchar.h>
|
|
#endif
|
|
],[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: 4 updated: 2025/12/14 17:51:46
|
|
dnl ----------
|
|
dnl Use AC_VERBOSE w/o the warnings
|
|
AC_DEFUN([CF_VERBOSE],
|
|
[test -n "$verbose" && echo " $1" 1>&AS_MESSAGE_FD
|
|
CF_MSG_LOG([$1])
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_WEAK_SYMBOLS version: 2 updated: 2025/12/24 12:27:29
|
|
dnl ---------------
|
|
dnl Check for compiler-support for weak symbols.
|
|
dnl This works with "recent" gcc.
|
|
AC_DEFUN([CF_WEAK_SYMBOLS],[
|
|
AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
|
|
#include <stdio.h>],
|
|
[
|
|
#if defined(__GNUC__)
|
|
# if defined __USE_ISOC99
|
|
# define _cat_pragma(exp) _Pragma(#exp)
|
|
# define _weak_pragma(exp) _cat_pragma(weak name)
|
|
# else
|
|
# define _weak_pragma(exp)
|
|
# endif
|
|
# define _declare(name) __extension__ extern __typeof__(name) name
|
|
# define weak_symbol(name) _weak_pragma(name) _declare(name) __attribute__((weak))
|
|
#endif
|
|
|
|
weak_symbol(fopen);
|
|
])],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
|
|
])
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_WITH_ADA version: 2 updated: 2024/11/09 18:07:29
|
|
dnl -----------
|
|
dnl Check for the Ada compiler (unless requested to not do this), which causes
|
|
dnl a further check for a C compiler which can work with the Ada compiler.
|
|
AC_DEFUN([CF_WITH_ADA],[
|
|
AC_ARG_WITH(ada,
|
|
[ --without-ada suppress check for Ada compiler],
|
|
[cf_with_ada=$withval],
|
|
[cf_with_ada=yes])
|
|
|
|
cf_prog_cc="gcc cc"
|
|
if test "x$cf_with_ada" = xyes
|
|
then
|
|
CF_PROG_GNAT
|
|
if test "x$cf_cv_prog_gnat_correct" = xyes; then
|
|
# gcc's developers chose to deprecate gnatgcc before making gprconfig
|
|
# work. They replaced gnatgcc in gcc 13 with a script which spits out
|
|
# a warning offering advice which could never work.
|
|
#
|
|
# Here is a workaround.
|
|
AC_PATH_PROG(cf_cv_path_gnatgcc,gnatgcc,no)
|
|
if test "$cf_cv_path_gnatgcc" != no
|
|
then
|
|
AC_MSG_CHECKING(for improvement)
|
|
cf_file_gnatgcc=`file -L "$cf_cv_path_gnatgcc" 2>/dev/null`
|
|
case "x$cf_file_gnatgcc" in
|
|
(*script*)
|
|
cf_cv_path_gnatgcc=`sh -x "$cf_cv_path_gnatgcc" --version 2>&1 | grep -w exec | sed -e 's/^[[ ]]*+[[ ]]*//' -e 's/exec[[ ]]//' -e 's/ .*//'`
|
|
;;
|
|
(*)
|
|
cf_cv_path_gnatgcc=no
|
|
;;
|
|
esac
|
|
AC_MSG_RESULT($cf_cv_path_gnatgcc)
|
|
test "$cf_cv_path_gnatgcc" = no && cf_cv_path_gnatgcc=gnatgcc
|
|
cf_prog_cc="$cf_cv_path_gnatgcc $cf_prog_cc"
|
|
fi
|
|
fi
|
|
fi
|
|
case "$cf_prog_cc" in
|
|
(*/*)
|
|
CC="$cf_prog_cc"
|
|
AC_SUBST(CC)
|
|
;;
|
|
(*)
|
|
CF_PROG_CC($cf_prog_cc)
|
|
;;
|
|
esac
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_WITH_ADA_COMPILER version: 3 updated: 2023/10/28 11:59:01
|
|
dnl --------------------
|
|
dnl Command-line option to specify the Ada95 compiler.
|
|
AC_DEFUN([CF_WITH_ADA_COMPILER],[
|
|
AC_MSG_CHECKING(for Ada95 compiler)
|
|
AC_ARG_WITH(ada-compiler,
|
|
[[ --with-ada-compiler[=CMD] use CMD as Ada95 compiler (default: gnatmake)]],
|
|
[cf_ada_compiler=$withval],
|
|
[cf_ada_compiler=gnatmake])
|
|
AC_SUBST(cf_ada_compiler)
|
|
AC_MSG_RESULT($cf_ada_compiler)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_WITH_ADA_INCLUDE version: 3 updated: 2023/10/28 11:59:01
|
|
dnl -------------------
|
|
dnl Command-line option to specify where Ada includes will install.
|
|
AC_DEFUN([CF_WITH_ADA_INCLUDE],[
|
|
AC_MSG_CHECKING(for Ada95 include directory)
|
|
CF_WITH_PATH(ada-include,
|
|
[ --with-ada-include=DIR find Ada95 includes in DIR],
|
|
ADA_INCLUDE,
|
|
PREFIX/share/ada/adainclude,
|
|
[$]prefix/share/ada/adainclude)
|
|
AC_SUBST(ADA_INCLUDE)
|
|
AC_MSG_RESULT($ADA_INCLUDE)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_WITH_ADA_LIBNAME version: 3 updated: 2023/11/22 20:48:30
|
|
dnl -------------------
|
|
dnl CF_WITH_ADA_LIBNAME
|
|
dnl -------------------
|
|
dnl Command-line option to specify how to name the resulting Ada library.
|
|
dnl $1 = default value
|
|
AC_DEFUN([CF_WITH_ADA_LIBNAME],[
|
|
AC_MSG_CHECKING(for Ada95 curses library name)
|
|
AC_ARG_WITH(ada-libname,
|
|
[[ --with-ada-libname[=XXX] use XXX as Ada95 library name]],
|
|
ADA_LIBNAME=[$]withval,
|
|
ADA_LIBNAME=$1)
|
|
case "x$ADA_LIBNAME" in
|
|
(x|xyes|xno)
|
|
ADA_LIBNAME=$1
|
|
;;
|
|
esac
|
|
AC_SUBST(ADA_LIBNAME)
|
|
AC_MSG_RESULT($ADA_LIBNAME)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_WITH_ADA_OBJECTS version: 3 updated: 2023/10/28 11:59:01
|
|
dnl -------------------
|
|
dnl Command-line option to specify where Ada objects will install.
|
|
AC_DEFUN([CF_WITH_ADA_OBJECTS],[
|
|
AC_MSG_CHECKING(for Ada95 object directory)
|
|
CF_WITH_PATH(ada-objects,
|
|
[ --with-ada-objects=DIR find Ada95 objects in DIR],
|
|
ADA_OBJECTS,
|
|
PREFIX/lib/ada/adalib,
|
|
[$]prefix/lib/ada/adalib)
|
|
AC_SUBST(ADA_OBJECTS)
|
|
AC_MSG_RESULT($ADA_OBJECTS)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_WITH_ADA_SHAREDLIB version: 6 updated: 2023/10/28 11:59:01
|
|
dnl ---------------------
|
|
dnl Command-line option to specify if an Ada95 shared library should be built,
|
|
dnl and optionally what its soname should be.
|
|
AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
|
|
AC_REQUIRE([CF_GNAT_PROJECTS])
|
|
AC_MSG_CHECKING(whether to build an Ada95 shared library)
|
|
AC_ARG_WITH(ada-sharedlib,
|
|
[ --with-ada-sharedlib build Ada95 shared library; requires GNAT project support],
|
|
[with_ada_sharedlib=$withval],
|
|
[with_ada_sharedlib=no])
|
|
cf_ada_sharedlib_warn=no
|
|
|
|
if test "x$with_ada_sharedlib" != xno
|
|
then
|
|
if test "x$cf_gnat_projects" != xyes
|
|
then
|
|
with_ada_sharedlib=no
|
|
cf_ada_sharedlib_warn=yes
|
|
fi
|
|
fi
|
|
|
|
AC_MSG_RESULT($with_ada_sharedlib)
|
|
if test "x$cf_ada_sharedlib_warn" != xno
|
|
then
|
|
AC_MSG_WARN(disabling Ada95 shared library since GNAT projects are not supported)
|
|
fi
|
|
|
|
ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
|
|
MAKE_ADA_SHAREDLIB="#"
|
|
|
|
if test "x$with_ada_sharedlib" != xno
|
|
then
|
|
MAKE_ADA_SHAREDLIB=
|
|
if test "x$with_ada_sharedlib" != xyes
|
|
then
|
|
ADA_SHAREDLIB="$with_ada_sharedlib"
|
|
fi
|
|
fi
|
|
|
|
AC_SUBST(ADA_SHAREDLIB)
|
|
AC_SUBST(MAKE_ADA_SHAREDLIB)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_WITH_CURSES_DIR version: 4 updated: 2021/01/02 19:22:58
|
|
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_LIB_PREFIX version: 2 updated: 2021/01/01 16:53:59
|
|
dnl ------------------
|
|
dnl Allow the library-prefix to be overridden. OS/2 EMX originally had no
|
|
dnl "lib" prefix, e.g., because it used the dll naming convention.
|
|
dnl
|
|
dnl $1 = variable to set
|
|
AC_DEFUN([CF_WITH_LIB_PREFIX],
|
|
[
|
|
AC_MSG_CHECKING(if you want to have a library-prefix)
|
|
AC_ARG_WITH(lib-prefix,
|
|
[ --with-lib-prefix override library-prefix],
|
|
[with_lib_prefix=$withval],
|
|
[with_lib_prefix=auto])
|
|
AC_MSG_RESULT($with_lib_prefix)
|
|
|
|
if test "$with_lib_prefix" = auto
|
|
then
|
|
CF_LIB_PREFIX($1)
|
|
elif test "$with_lib_prefix" = no
|
|
then
|
|
LIB_PREFIX=
|
|
else
|
|
LIB_PREFIX=$with_lib_prefix
|
|
fi
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_WITH_PATH version: 12 updated: 2021/09/04 06:35:04
|
|
dnl ------------
|
|
dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
|
|
dnl defaulting to yes/no.
|
|
dnl
|
|
dnl $1 = option name
|
|
dnl $2 = help-text
|
|
dnl $3 = environment variable to set
|
|
dnl $4 = default value, shown in the help-message, must be a constant
|
|
dnl $5 = default value, if it is an expression & cannot be in the help-message
|
|
dnl
|
|
AC_DEFUN([CF_WITH_PATH],
|
|
[AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
|
|
ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
|
|
if ifelse([$5],,true,[test -n "$5"]) ; then
|
|
CF_PATH_SYNTAX(withval)
|
|
fi
|
|
eval $3="$withval"
|
|
AC_SUBST($3)dnl
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_WITH_PKG_CONFIG_LIBDIR version: 25 updated: 2024/08/03 13:34:29
|
|
dnl -------------------------
|
|
dnl Allow the choice of the pkg-config library directory to be overridden.
|
|
dnl
|
|
dnl pkg-config uses a search-list built from these colon-separated lists of
|
|
dnl directories:
|
|
dnl a) $PKG_CONFIG_PATH (tested first, added if set)
|
|
dnl b) $PKG_CONFIG_LIBDIR (tested second, added if set)
|
|
dnl c) builtin-list (added if $PKG_CONFIG_LIBDIR is not set)
|
|
dnl
|
|
dnl pkgconf (used with some systems such as FreeBSD in place of pkg-config)
|
|
dnl optionally ignores $PKG_CONFIG_LIBDIR. Very old versions of pkg-config,
|
|
dnl e.g., Solaris 10 also do not recognize $PKG_CONFIG_LIBDIR.
|
|
AC_DEFUN([CF_WITH_PKG_CONFIG_LIBDIR],[
|
|
AC_REQUIRE([CF_GLOB_FULLPATH])dnl
|
|
|
|
case "$PKG_CONFIG" in
|
|
(no|none|yes)
|
|
AC_MSG_CHECKING(for pkg-config library directory)
|
|
;;
|
|
(*)
|
|
AC_MSG_CHECKING(for $PKG_CONFIG library directory)
|
|
;;
|
|
esac
|
|
|
|
# if $PKG_CONFIG_LIBDIR is set, try to use that
|
|
if test -n "$PKG_CONFIG_PATH"; then
|
|
cf_search_path=`echo "$PKG_CONFIG_PATH" | sed -e 's/:/ /g' -e 's,^[[ ]]*,,' -e 's,[[ ]]*$,,'`
|
|
elif test -n "$PKG_CONFIG_LIBDIR"; then
|
|
cf_search_path=`echo "$PKG_CONFIG_LIBDIR" | sed -e 's/:/ /g' -e 's,^[[ ]]*,,' -e 's,[[ ]]*$,,'`
|
|
else
|
|
cf_search_path=auto
|
|
fi
|
|
|
|
# if the option is used, let that override. otherwise default to "libdir"
|
|
AC_ARG_WITH(pkg-config-libdir,
|
|
[[ --with-pkg-config-libdir[=XXX] use given directory for installing pc-files]],
|
|
[cf_search_path=$withval],
|
|
[test "x$PKG_CONFIG" != xnone && test -z "$cf_search_path" && cf_search_path=libdir])
|
|
|
|
case "x$cf_search_path" in
|
|
(xlibdir)
|
|
PKG_CONFIG_LIBDIR='${libdir}/pkgconfig'
|
|
AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
|
|
cf_search_path=
|
|
;;
|
|
(x)
|
|
;;
|
|
(x$GLOB_FULLPATH_POSIX\ *|x$GLOB_FULLPATH_OTHER\ *)
|
|
PKG_CONFIG_LIBDIR=
|
|
;;
|
|
(x$GLOB_FULLPATH_POSIX|x$GLOB_FULLPATH_OTHER)
|
|
PKG_CONFIG_LIBDIR="$cf_search_path"
|
|
AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
|
|
cf_search_path=
|
|
;;
|
|
(xyes|xauto)
|
|
AC_MSG_RESULT(auto)
|
|
cf_search_path=
|
|
# Look for the library directory using the same prefix as the executable
|
|
AC_MSG_CHECKING(for search-list)
|
|
if test "x$PKG_CONFIG" != xnone
|
|
then
|
|
# works for pkg-config since version 0.24 (2009)
|
|
# works for pkgconf since version 0.8.3 (2012)
|
|
for cf_pkg_program in \
|
|
`echo "$PKG_CONFIG" | sed -e 's,^.*/,,'` \
|
|
pkg-config \
|
|
pkgconf
|
|
do
|
|
cf_raw_search_path=`"$PKG_CONFIG" --variable=pc_path "$cf_pkg_program" 2>/dev/null`
|
|
case "$cf_raw_search_path" in
|
|
(*\\*)
|
|
cf_search_path=`echo "$cf_raw_search_path" | tr ';' ' ' | tr '\' '/'`
|
|
;;
|
|
(*/*)
|
|
cf_search_path=`echo "$cf_raw_search_path" | tr : ' '`
|
|
;;
|
|
esac
|
|
test -n "$cf_search_path" && break
|
|
done
|
|
|
|
# works for pkg-config since import in 2005 of original 2001 HP code.
|
|
test -z "$cf_search_path" && \
|
|
cf_search_path=`
|
|
"$PKG_CONFIG" --debug --exists no-such-package 2>&1 | $AWK "\
|
|
/^Scanning directory (#[1-9][0-9]* )?'.*'$/{ \
|
|
sub(\"^[[^']]*'\",\"\"); \
|
|
sub(\"'.*\",\"\"); \
|
|
printf \" %s\", \\[$]0; } \
|
|
{ next; } \
|
|
"`
|
|
fi
|
|
|
|
AC_MSG_RESULT($cf_search_path)
|
|
;;
|
|
(*)
|
|
AC_MSG_ERROR(Unexpected option value: $cf_search_path)
|
|
;;
|
|
esac
|
|
|
|
if test -n "$cf_search_path"
|
|
then
|
|
AC_MSG_CHECKING(for first directory)
|
|
cf_pkg_config_path=none
|
|
for cf_config in $cf_search_path
|
|
do
|
|
if test -d "$cf_config"
|
|
then
|
|
cf_pkg_config_path=$cf_config
|
|
break
|
|
fi
|
|
done
|
|
AC_MSG_RESULT($cf_pkg_config_path)
|
|
|
|
if test "x$cf_pkg_config_path" != xnone ; then
|
|
# limit this to the first directory found
|
|
PKG_CONFIG_LIBDIR="$cf_pkg_config_path"
|
|
fi
|
|
|
|
if test -z "$PKG_CONFIG_LIBDIR" && test -n "$cf_search_path"
|
|
then
|
|
AC_MSG_CHECKING(for workaround)
|
|
if test "$prefix" = "NONE" ; then
|
|
cf_prefix="$ac_default_prefix"
|
|
else
|
|
cf_prefix="$prefix"
|
|
fi
|
|
eval cf_libdir=$libdir
|
|
cf_libdir=`echo "$cf_libdir" | sed -e "s,^NONE,$cf_prefix,"`
|
|
cf_backup=
|
|
for cf_config in $cf_search_path
|
|
do
|
|
case $cf_config in
|
|
$cf_libdir/pkgconfig)
|
|
PKG_CONFIG_LIBDIR=$cf_libdir/pkgconfig
|
|
break
|
|
;;
|
|
*)
|
|
test -z "$cf_backup" && cf_backup=$cf_config
|
|
;;
|
|
esac
|
|
done
|
|
test -z "$PKG_CONFIG_LIBDIR" && PKG_CONFIG_LIBDIR=$cf_backup
|
|
AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
|
|
fi
|
|
fi
|
|
|
|
AC_SUBST(PKG_CONFIG_LIBDIR)
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_WITH_PTHREAD version: 8 updated: 2025/12/24 12:27:29
|
|
dnl ---------------
|
|
dnl Check for POSIX thread library.
|
|
AC_DEFUN([CF_WITH_PTHREAD],
|
|
[
|
|
AC_MSG_CHECKING(if you want to link with the pthread library)
|
|
AC_ARG_WITH(pthread,
|
|
[ --with-pthread use POSIX thread library],
|
|
[with_pthread=$withval],
|
|
[with_pthread=no])
|
|
AC_MSG_RESULT($with_pthread)
|
|
|
|
if test "$with_pthread" != no ; then
|
|
AC_CHECK_HEADER(pthread.h,[
|
|
AC_DEFINE(HAVE_PTHREADS_H,1,[Define to 1 if we have pthreads.h header])
|
|
|
|
for cf_lib_pthread in pthread c_r
|
|
do
|
|
AC_MSG_CHECKING(if we can link with the $cf_lib_pthread library)
|
|
cf_save_LIBS="$LIBS"
|
|
CF_ADD_LIB($cf_lib_pthread)
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([
|
|
#include <pthread.h>
|
|
],[
|
|
int rc = pthread_create(0,0,0,0);
|
|
int r2 = pthread_mutexattr_settype(0, 0);
|
|
])],[with_pthread=yes],[with_pthread=no])
|
|
LIBS="$cf_save_LIBS"
|
|
AC_MSG_RESULT($with_pthread)
|
|
test "$with_pthread" = yes && break
|
|
done
|
|
|
|
if test "$with_pthread" = yes ; then
|
|
CF_ADD_LIB($cf_lib_pthread)
|
|
AC_DEFINE(HAVE_LIBPTHREADS,1,[Define to 1 if we have pthreads library])
|
|
else
|
|
AC_MSG_ERROR(Cannot link with pthread library)
|
|
fi
|
|
])
|
|
fi
|
|
])
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_WITH_SYSTYPE version: 2 updated: 2025/12/14 18:08:20
|
|
dnl ---------------
|
|
dnl For testing, override the derived host system-type which is used to decide
|
|
dnl things such as the linker commands used to build shared libraries. This is
|
|
dnl normally chosen automatically based on the type of system which you are
|
|
dnl building on. We use it for testing the configure script.
|
|
dnl
|
|
dnl This is different from the --host option: it is used only for testing parts
|
|
dnl of the configure script which would not be reachable with --host since that
|
|
dnl relies on the build environment being real, rather than mocked up.
|
|
AC_DEFUN([CF_WITH_SYSTYPE],[
|
|
CF_CHECK_CACHE([AC_CANONICAL_TARGET])
|
|
AC_ARG_WITH(system-type,
|
|
[ --with-system-type=XXX test: override derived host system-type],
|
|
[AC_MSG_WARN(overriding system type to $withval)
|
|
cf_cv_system_name=$withval
|
|
host_os=$withval
|
|
])
|
|
])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF_XOPEN_SOURCE version: 71 updated: 2025/12/14 17:40:20
|
|
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
|
|
dnl
|
|
dnl The default case prefers _XOPEN_SOURCE over _POSIX_C_SOURCE if the
|
|
dnl implementation predefines it, because X/Open and most implementations agree
|
|
dnl that the latter is a legacy or "aligned" value.
|
|
dnl
|
|
dnl Because _XOPEN_SOURCE is preferred, if defining _POSIX_C_SOURCE turns
|
|
dnl that off, then refrain from setting _POSIX_C_SOURCE explicitly.
|
|
dnl
|
|
dnl References:
|
|
dnl https://pubs.opengroup.org/onlinepubs/007904975/functions/xsh_chap02_02.html
|
|
dnl https://docs.oracle.com/cd/E19253-01/816-5175/standards-5/index.html
|
|
dnl https://www.gnu.org/software/libc/manual/html_node/Feature-Test-Macros.html
|
|
AC_DEFUN([CF_XOPEN_SOURCE],[
|
|
AC_REQUIRE([AC_CANONICAL_HOST])
|
|
AC_REQUIRE([CF_POSIX_VISIBLE])
|
|
|
|
if test "$cf_cv_posix_visible" = no; then
|
|
|
|
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"
|
|
;;
|
|
(darwin[[0-8]].*)
|
|
cf_xopen_source="-D_APPLE_C_SOURCE"
|
|
;;
|
|
(darwin*)
|
|
cf_xopen_source="-D_DARWIN_C_SOURCE"
|
|
cf_XOPEN_SOURCE=
|
|
;;
|
|
(freebsd*|dragonfly*|midnightbsd*)
|
|
# 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*gnu*|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin|msys|mingw*|linux*uclibc)
|
|
CF_GNU_SOURCE($cf_XOPEN_SOURCE)
|
|
;;
|
|
linux*musl)
|
|
cf_xopen_source="-D_BSD_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[[6-9]]*)
|
|
# OpenBSD 6.x has broken locale support, both compile-time and runtime.
|
|
# see https://www.mail-archive.com/bugs@openbsd.org/msg13200.html
|
|
# Abusing the conformance level is a workaround.
|
|
AC_MSG_WARN(this system does not provide usable locale support)
|
|
cf_xopen_source="-D_BSD_SOURCE"
|
|
cf_XOPEN_SOURCE=700
|
|
;;
|
|
(openbsd[[4-5]]*)
|
|
# 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_save_xopen_cppflags="$CPPFLAGS"
|
|
CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
|
|
# Some of these niche implementations use copy/paste, double-check...
|
|
if test "$cf_cv_xopen_source" = no ; then
|
|
CF_VERBOSE(checking if _POSIX_C_SOURCE interferes with _XOPEN_SOURCE)
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY)],,[
|
|
AC_MSG_WARN(_POSIX_C_SOURCE definition is not usable)
|
|
CPPFLAGS="$cf_save_xopen_cppflags"])
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
if test -n "$cf_xopen_source" ; then
|
|
CF_APPEND_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_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <stdlib.h>],[
|
|
#ifndef _XOPEN_SOURCE
|
|
#error _XOPEN_SOURCE is not defined
|
|
#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_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <stdlib.h>],[
|
|
#if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
|
|
#error (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
|
|
#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
|
|
fi # cf_cv_posix_visible
|
|
])
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF__SED_TRIMBLANKS version: 1 updated: 2021/01/02 09:31:20
|
|
dnl ------------------
|
|
dnl Trim something using sed, then trim extra whitespace
|
|
dnl $1 = extra parameters, e.g., in CF_STRIP_G_OPT
|
|
define([CF__SED_TRIMBLANKS],[sed ifelse($1,,,[$1] )-e 's%[[ ]]% %g' -e 's% [[ ]]*% %g' -e 's%^ %%' -e 's% [$]%%'])dnl
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF__XOPEN_SOURCE_BODY version: 2 updated: 2023/02/18 17:41:25
|
|
dnl ---------------------
|
|
dnl body of test when test-compiling for _XOPEN_SOURCE check
|
|
define([CF__XOPEN_SOURCE_BODY],
|
|
[
|
|
#ifndef _XOPEN_SOURCE
|
|
#error _XOPEN_SOURCE is not defined
|
|
#endif
|
|
])
|
|
dnl ---------------------------------------------------------------------------
|
|
dnl CF__XOPEN_SOURCE_HEAD version: 2 updated: 2023/02/18 17:41:25
|
|
dnl ---------------------
|
|
dnl headers to include when test-compiling for _XOPEN_SOURCE check
|
|
define([CF__XOPEN_SOURCE_HEAD],
|
|
[
|
|
$ac_includes_default
|
|
])
|