dnl***************************************************************************
-dnl Copyright 2018-2019,2020 Thomas E. Dickey *
+dnl Copyright 2018-2020,2021 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
dnl Author: Thomas E. Dickey
dnl
-dnl $Id: aclocal.m4,v 1.167 2020/12/05 21:44:26 tom Exp $
+dnl $Id: aclocal.m4,v 1.171 2021/01/06 01:29:44 tom Exp $
dnl Macros used in NCURSES Ada95 auto-configuration script.
dnl
dnl These macros are maintained separately from NCURSES. The copyright on
AC_SUBST(ADAFLAGS)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_ADD_CFLAGS version: 14 updated: 2020/04/04 16:16:13
+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
for cf_add_cflags in $1
do
-case $cf_fix_cppflags in
+case "$cf_fix_cppflags" in
(no)
- case $cf_add_cflags in
+ case "$cf_add_cflags" in
(-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
- case $cf_add_cflags in
+ case "$cf_add_cflags" in
(-D*)
- cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-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
+ 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_add_cflags)
;;
(*)
- case $cf_add_cflags in
+ 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)
(yes)
CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
- cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
+ cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[[^"]]*"'\''//'`
test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
&& test -z "${cf_tst_cflags}" \
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_ADD_INCDIR version: 15 updated: 2018/06/20 20:23:13
+dnl CF_ADD_INCDIR version: 16 updated: 2020/12/31 20:19:42
dnl -------------
dnl Add an include-directory to $CPPFLAGS. Don't add /usr/include, since it's
dnl redundant. We don't normally need to add -I/usr/local/include for gcc,
if test -n "$1" ; then
for cf_add_incdir in $1
do
- while test $cf_add_incdir != /usr/include
+ while test "$cf_add_incdir" != /usr/include
do
- if test -d $cf_add_incdir
+ if test -d "$cf_add_incdir"
then
cf_have_incdir=no
if test -n "$CFLAGS$CPPFLAGS" ; 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%'`
+ 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
dnl $2 = variable to update (default $LIBS)
AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_ADD_LIBDIR version: 10 updated: 2015/04/18 08:56:57
+dnl CF_ADD_LIBDIR version: 11 updated: 2020/12/31 20:19:42
dnl -------------
dnl Adds to the library-path
dnl
if test -n "$1" ; then
for cf_add_libdir in $1
do
- if test $cf_add_libdir = /usr/lib ; then
+ if test "$cf_add_libdir" = /usr/lib ; then
:
- elif test -d $cf_add_libdir
+ elif test -d "$cf_add_libdir"
then
cf_have_libdir=no
if test -n "$LDFLAGS$LIBS" ; then
ifelse($2,,LIBS,[$2])="$cf_add_libs"
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_ADD_SUBDIR_PATH version: 4 updated: 2013/10/08 17:47:05
+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
[
test "x$4" != "x$5" && \
test -d "$4" && \
-ifelse([$5],NONE,,[(test -z "$5" || test x$5 = xNONE || test "x$4" != "x$5") &&]) {
+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"
+ 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
])])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_AR_FLAGS version: 7 updated: 2020/04/04 11:37:29
+dnl CF_AR_FLAGS version: 9 updated: 2021/01/01 13:31:04
dnl -----------
dnl Check for suitable "ar" (archiver) options for updating an archive.
dnl
AC_REQUIRE([CF_PROG_AR])
AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
- case $cf_cv_system_name in
+ case "$cf_cv_system_name" in
(*-msvc*)
cf_cv_ar_flags=''
cat >mk_static_lib.sh <<-EOF
fi
fi
- rm -f conftest.$ac_cv_objext
+ rm -f "conftest.$ac_cv_objext"
rm -f conftest.a
- cat >conftest.$ac_ext <<EOF
+ 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" >&AC_FD_CC
- $AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null
+ $AR $ARFLAGS "$cf_ar_flags" conftest.a "conftest.$ac_cv_objext" 2>&AC_FD_CC 1>/dev/null
if test -f conftest.a ; then
- cf_cv_ar_flags=$cf_ar_flags
+ cf_cv_ar_flags="$cf_ar_flags"
break
fi
else
break
fi
done
- rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
+ rm -f conftest.a "conftest.$ac_ext" "conftest.$ac_cv_objext"
;;
esac
])
AC_SUBST(ARFLAGS)
])
dnl ---------------------------------------------------------------------------
-dnl CF_BUILD_CC version: 8 updated: 2018/01/04 20:31:04
+dnl CF_BUILD_CC version: 9 updated: 2021/01/02 09:31:20
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
: ${BUILD_CC:='${CC}'}
- if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
+ if { test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}'; } ; then
AC_MSG_ERROR([Cross-build requires two compilers.
Use --with-build-cc to specify the native compiler.])
fi
AC_SUBST(BUILD_OBJEXT)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_CC_ENV_FLAGS version: 9 updated: 2018/07/29 18:03:26
+dnl CF_CC_ENV_FLAGS version: 10 updated: 2020/12/31 18:40:20
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
AC_DEFUN([CF_CC_ENV_FLAGS],
[
# This should have been defined by AC_PROG_CC
-: ${CC:=cc}
+: "${CC:=cc}"
AC_MSG_CHECKING(\$CFLAGS variable)
case "x$CFLAGS" in
esac
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_CFG_DEFAULTS version: 11 updated: 2015/04/17 21:13:04
+dnl CF_CFG_DEFAULTS version: 16 updated: 2021/01/04 19:33:05
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 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
AC_MSG_CHECKING(for default include-directory)
test -n "$verbose" && echo 1>&AC_FD_MSG
for cf_symbol in \
- $includedir \
- $includedir/ncurses \
- $prefix/include \
- $prefix/include/ncurses \
+ "$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 NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
+ 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 $ac_n " found " 1>&AC_FD_MSG
+ test -n "$verbose" && echo $ECHO_N " found " 1>&AC_FD_MSG
break
fi
fi
fi
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_CHECK_CACHE version: 12 updated: 2012/10/02 20:55:03
+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 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
+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
fi
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_CHECK_GNAT_VERSION version: 3 updated: 2020/05/23 19:39:36
+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
+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
;;
esac
])
dnl ---------------------------------------------------------------------------
-dnl CF_CLANG_COMPILER version: 6 updated: 2020/11/26 17:37:55
+dnl CF_CLANG_COMPILER version: 8 updated: 2021/01/01 13:31:04
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
CFLAGS="$CFLAGS $cf_clang_opt"
AC_TRY_LINK([
#include <stdio.h>],[
- printf("hello!\n");],[
+ 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
+ if test "$cf_clang_optok" = yes; then
CF_VERBOSE(adding option $cf_clang_opt)
CF_APPEND_TEXT(CFLAGS,$cf_clang_opt)
fi
fi
])
dnl ---------------------------------------------------------------------------
-dnl CF_CONST_X_STRING version: 4 updated: 2020/03/10 18:53:47
+dnl CF_CONST_X_STRING version: 6 updated: 2021/01/01 13:31:04
dnl -----------------
dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
dnl character-strings.
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 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
CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
-case $cf_cv_const_x_string in
+case "$cf_cv_const_x_string" in
(no)
CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
;;
])
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_CONST_X_STRING version: 4 updated: 2020/03/10 18:53:47
+dnl CF_CONST_X_STRING version: 6 updated: 2021/01/01 13:31:04
dnl -----------------
dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
dnl character-strings.
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 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
CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
-case $cf_cv_const_x_string in
+case "$cf_cv_const_x_string" in
(no)
CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
;;
AC_CHECK_HEADERS($cf_cv_ncurses_header)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
+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
+AC_DEFUN([CF_DIRNAME],[$1=`echo "$2" | sed -e 's%/[[^/]]*$%%'`])dnl
dnl ---------------------------------------------------------------------------
dnl CF_DISABLE_ECHO version: 13 updated: 2015/04/18 08:56:57
dnl ---------------
AC_MSG_RESULT($enable_gnat_projects)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_ENABLE_BROKEN_LINKER version: 1 updated: 2020/02/08 15:59:30
+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
[with_broken_linker=no])
AC_MSG_RESULT($with_broken_linker)
-: ${BROKEN_LINKER:=0}
+: "${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
AC_SUBST(BROKEN_LINKER)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_ENABLE_WARNINGS version: 7 updated: 2020/08/29 09:05:21
+dnl CF_ENABLE_WARNINGS version: 9 updated: 2021/01/05 19:40:50
dnl ------------------
dnl Configure-option to enable gcc warnings
dnl
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 )
+if test "$GCC" = yes || test "$GXX" = yes
then
CF_FIX_WARNINGS(CFLAGS)
CF_FIX_WARNINGS(CPPFLAGS)
AC_MSG_CHECKING(if you want to turn on gcc warnings)
CF_ARG_ENABLE(warnings,
[ --enable-warnings test: turn on gcc compiler warnings],
- [with_warnings=yes],
- [with_warnings=no])
-AC_MSG_RESULT($with_warnings)
-if test "$with_warnings" = "yes"
+ [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
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_FIND_LIBRARY version: 9 updated: 2008/03/23 14:48:54
+dnl CF_FIND_LIBRARY version: 11 updated: 2021/01/02 09:31:20
dnl ---------------
dnl Look for a non-standard library, given parameters for AC_TRY_LINK. We
dnl prefer a standard location, and use -L options only if we do not find the
dnl to use a -L option.
AC_DEFUN([CF_FIND_LIBRARY],
[
- eval 'cf_cv_have_lib_'$1'=no'
+ eval 'cf_cv_have_lib_'"$1"'=no'
cf_libdir=""
AC_CHECK_FUNC($5,
- eval 'cf_cv_have_lib_'$1'=yes',[
+ eval 'cf_cv_have_lib_'"$1"'=yes',[
cf_save_LIBS="$LIBS"
AC_MSG_CHECKING(for $5 in -l$1)
LIBS="-l$1 $LIBS"
AC_TRY_LINK([$3],[$4],
[AC_MSG_RESULT(yes)
- eval 'cf_cv_have_lib_'$1'=yes'
+ eval 'cf_cv_have_lib_'"$1"'=yes'
],
[AC_MSG_RESULT(no)
CF_LIBRARY_PATH(cf_search,$2)
LIBS="-L$cf_libdir -l$1 $cf_save_LIBS"
AC_TRY_LINK([$3],[$4],
[AC_MSG_RESULT(yes)
- eval 'cf_cv_have_lib_'$1'=yes'
+ 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
+eval 'cf_found_library="[$]cf_cv_have_lib_'"$1"\"
ifelse($6,,[
-if test $cf_found_library = no ; then
+if test "$cf_found_library" = no ; then
AC_MSG_ERROR(Cannot link $1 library)
fi
])
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_FIND_LINKAGE version: 21 updated: 2018/06/20 20:23:13
+dnl CF_FIND_LINKAGE version: 22 updated: 2020/12/31 20:19:42
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.
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
+ 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)
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
+ 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"
AC_MSG_RESULT($ADAFLAGS)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_FIX_WARNINGS version: 2 updated: 2020/08/28 15:08:28
+dnl CF_FIX_WARNINGS version: 3 updated: 2020/12/31 18:40:20
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
dnl $1 = variable name to repair
define([CF_FIX_WARNINGS],[
-if ( test "$GCC" = yes || test "$GXX" = yes )
+if test "$GCC" = yes || test "$GXX" = yes
then
case [$]$1 in
(*-Werror=*)
do
case "x$cf_temp_scan" in
(x-Werror=*)
- CF_APPEND_TEXT(EXTRA_CFLAGS,"$cf_temp_scan")
+ CF_APPEND_TEXT(EXTRA_CFLAGS,$cf_temp_scan)
;;
(*)
- CF_APPEND_TEXT(cf_temp_flags,"$cf_temp_scan")
+ CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
;;
esac
done
AC_SUBST(EXTRA_CFLAGS)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_GCC_ATTRIBUTES version: 19 updated: 2020/08/29 09:05:21
+dnl CF_GCC_ATTRIBUTES version: 23 updated: 2021/01/03 18:30:50
dnl -----------------
dnl Test for availability of useful gcc __attribute__ directives to quiet
dnl compiler warnings. Though useful, not all are supported -- and contrary
dnl to documentation, unrecognized directives cause older compilers to barf.
AC_DEFUN([CF_GCC_ATTRIBUTES],
-[
-if ( test "$GCC" = yes || test "$GXX" = yes )
+[AC_REQUIRE([AC_PROG_FGREP])dnl
+
+if test "$GCC" = yes || test "$GXX" = yes
then
cat > conftest.i <<EOF
#ifndef GCC_PRINTF
if test "$GCC" = yes
then
AC_CHECKING([for $CC __attribute__ directives])
-cat > conftest.$ac_ext <<EOF
+cat > "conftest.$ac_ext" <<EOF
#line __oline__ "${as_me:-configure}"
#include "confdefs.h"
#include "conftest.h"
cf_directive="__attribute__(($cf_attribute))"
echo "checking for $CC $cf_directive" 1>&AC_FD_CC
- case $cf_attribute in
+ case "$cf_attribute" in
(printf)
cf_printf_attribute=yes
cat >conftest.h <<EOF
if AC_TRY_EVAL(ac_compile); then
test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
cat conftest.h >>confdefs.h
- case $cf_attribute in
+ case "$cf_attribute" in
(noreturn)
AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
;;
fi
done
else
- fgrep define conftest.i >>confdefs.h
+ ${FGREP-fgrep} define conftest.i >>confdefs.h
fi
-rm -rf conftest*
+rm -rf ./conftest*
fi
])dnl
dnl ---------------------------------------------------------------------------
CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_GCC_WARNINGS version: 38 updated: 2020/08/28 15:08:28
+dnl CF_GCC_WARNINGS version: 41 updated: 2021/01/01 16:53:59
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:
[
AC_REQUIRE([CF_GCC_VERSION])
if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
-cat > conftest.$ac_ext <<EOF
+cat > "conftest.$ac_ext" <<EOF
#line __oline__ "${as_me:-configure}"
int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
EOF
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
+ case "$cf_opt" in
(Winline)
- case $GCC_VERSION in
+ case "$GCC_VERSION" in
([[34]].*)
CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
continue;;
esac
;;
(Wpointer-arith)
- case $GCC_VERSION in
+ case "$GCC_VERSION" in
([[12]].*)
CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
continue;;
done
CFLAGS="$cf_save_CFLAGS"
fi
-rm -rf conftest*
+rm -rf ./conftest*
AC_SUBST(EXTRA_CFLAGS)
])dnl
AC_SUBST(GNATPREP_OPTS)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_GNAT_GENERICS version: 6 updated: 2020/07/04 19:30:27
+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
+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
;;
AC_SUBST(cf_generic_objects)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_GNAT_PROJECTS version: 11 updated: 2020/12/05 16:42:18
+dnl CF_GNAT_PROJECTS version: 13 updated: 2021/01/02 17:09:14
dnl ----------------
dnl GNAT projects are configured with ".gpr" project files.
dnl GNAT libraries are a further development, using the project feature.
if test "$enable_gnat_projects" != no ; then
AC_MSG_CHECKING(if GNAT supports project files)
-case $cf_cv_gnat_version in
+case "$cf_cv_gnat_version" in
(3.[[0-9]]*)
;;
(*)
- case $cf_cv_system_name in
+ case "$cf_cv_system_name" in
(cygwin*|msys*)
;;
(*)
- rm -rf conftest* *~conftest*
+ rm -rf ./conftest* ./*~conftest*
if mkdir conftest.src conftest.bin conftest.lib
then
cd conftest.src
- rm -rf conftest* *~conftest*
+ rm -rf ./conftest* ./*~conftest*
cat >>library.gpr <<CF_EOF
project Library is
Kind := External ("LIB_KIND");
end conftest;
end ConfPackage;
CF_EOF
- if ( $cf_ada_make $ADAFLAGS \
+ if ( "$cf_ada_make" $ADAFLAGS \
-Plibrary.gpr \
- -XBUILD_DIR=`cd ../conftest.bin;pwd` \
- -XLIBRARY_DIR=`cd ../conftest.lib;pwd` \
- -XSOURCE_DIR=`pwd` \
+ -XBUILD_DIR="`cd ../conftest.bin;pwd`" \
+ -XLIBRARY_DIR="`cd ../conftest.lib;pwd`" \
+ -XSOURCE_DIR="`pwd`" \
-XSONAME=libConfTest.so.1 \
-XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
cf_gnat_projects=yes
then
cf_gnat_libraries=yes
fi
- rm -rf conftest* *~conftest*
+ rm -rf ./conftest* ./*~conftest*
;;
esac
;;
AC_MSG_RESULT($cf_gnat_projects)
fi # enable_gnat_projects
-if test $cf_gnat_projects = yes
+if test "$cf_gnat_projects" = yes
then
AC_MSG_CHECKING(if GNAT supports libraries)
AC_MSG_RESULT($cf_gnat_libraries)
AC_SUBST(USE_GNAT_GPRBUILD)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_GNAT_SIGINT version: 1 updated: 2011/03/27 20:07:59
+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
[cf_cv_gnat_sigint=yes],
[cf_cv_gnat_sigint=no])])
-if test $cf_cv_gnat_sigint = yes ; then
+if test "$cf_cv_gnat_sigint" = yes ; then
USE_GNAT_SIGINT=""
else
USE_GNAT_SIGINT="#"
AC_SUBST(USE_GNAT_SIGINT)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_GNAT_TRY_LINK version: 3 updated: 2011/03/19 14:47:45
+dnl CF_GNAT_TRY_LINK version: 4 updated: 2021/01/01 13:31:04
dnl ----------------
dnl Verify that a test program compiles/links with GNAT.
dnl $cf_ada_make is set to the program that compiles/links
dnl $4 is the shell command to execute if not successful
AC_DEFUN([CF_GNAT_TRY_LINK],
[
-rm -rf conftest* *~conftest*
+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>&AC_FD_CC 2>&1 ) ; then
+if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
ifelse($3,, :,[ $3])
ifelse($4,,,[else
$4])
fi
-rm -rf conftest* *~conftest*
+rm -rf ./conftest* ./*~conftest*
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_GNAT_TRY_RUN version: 5 updated: 2011/03/19 14:47:45
+dnl CF_GNAT_TRY_RUN version: 6 updated: 2021/01/01 13:31:04
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 $4 is the shell command to execute if not successful
AC_DEFUN([CF_GNAT_TRY_RUN],
[
-rm -rf conftest* *~conftest*
+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>&AC_FD_CC 2>&1 ) ; then
+if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
ifelse($3,, :,[ $3])
ifelse($4,,,[ else
ifelse($4,,,[else
$4])
fi
-rm -rf conftest* *~conftest*
+rm -rf ./conftest* ./*~conftest*
])dnl
dnl ---------------------------------------------------------------------------
dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54
fi
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_HEADER_PATH version: 13 updated: 2015/04/15 19:08:48
+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
if test -n "${CFLAGS}${CPPFLAGS}" ; then
for cf_header_path in $CPPFLAGS $CFLAGS
do
- case $cf_header_path in
+ 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)
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 -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"
+ test -d "$oldincludedir" && $1="[$]$1 $oldincludedir"
+ test -d "$oldincludedir/$2" && $1="[$]$1 $oldincludedir/$2"
}
$1="[$]$1 $cf_header_path_list"
CF_INSTALL_OPT_O
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_INSTALL_OPT_O version: 2 updated: 2015/05/15 19:45:35
+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_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'`
+ 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: 1 updated: 2018/08/18 12:19:21
+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}
+: "${INSTALL:=install}"
AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
- rm -rf conftest*
+ rm -rf ./conftest*
date >conftest.in
mkdir conftest.out
sleep 3
else
cf_cv_install_p=no
fi
- rm -rf conftest*
+ rm -rf ./conftest*
])
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_INSTALL_OPT_S version: 2 updated: 2018/08/18 12:19:21
+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_MSG_CHECKING(if you want to install stripped executables)
CF_ARG_DISABLE(stripping,
[ --disable-stripping do not strip (debug info) installed executables],
- [with_stripping=no],
- [with_stripping=yes])
-AC_MSG_RESULT($with_stripping)
+ [enable_stripping=no],
+ [enable_stripping=yes])
+AC_MSG_RESULT($enable_stripping)
-if test "$with_stripping" = yes
+if test "$enable_stripping" = yes
then
INSTALL_OPT_S="-s"
else
AC_SUBST(INSTALL_OPT_S)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_INTEL_COMPILER version: 7 updated: 2015/04/12 15:39:00
+dnl CF_INTEL_COMPILER version: 8 updated: 2021/01/01 16:53:59
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
ifelse([$2],,INTEL_COMPILER,[$2])=no
if test "$ifelse([$1],,[$1],GCC)" = yes ; then
- case $host_os in
+ 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])"
])
])
dnl ---------------------------------------------------------------------------
-dnl CF_LD_RPATH_OPT version: 8 updated: 2018/08/18 16:36:35
+dnl CF_LD_RPATH_OPT version: 9 updated: 2021/01/01 13:31:04
dnl ---------------
dnl For the given system and compiler, find the compiler flags to pass to the
dnl loader to use the "rpath" feature.
if test "x$cf_cv_enable_rpath" != xno
then
AC_MSG_CHECKING(for an rpath option)
- case $cf_cv_system_name in
+ case "$cf_cv_system_name" in
(irix*)
if test "$GCC" = yes; then
LD_RPATH_OPT="-Wl,-rpath,"
fi
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_LIBRARY_PATH version: 10 updated: 2015/04/15 19:08:48
+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
if test -n "${LDFLAGS}${LIBS}" ; then
for cf_library_path in $LDFLAGS $LIBS
do
- case $cf_library_path in
+ 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)
$1="$cf_library_path_list [$]$1"
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_LIB_PREFIX version: 13 updated: 2020/04/04 10:11:47
+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
+ case "$cf_cv_system_name" in
(OS/2*|os2*)
if test "$DFT_LWR_MODEL" = libtool; then
LIB_PREFIX='lib'
AC_SUBST(LIB_PREFIX)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_LIB_SUFFIX version: 26 updated: 2020/04/04 10:11:47
+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
$3=[$]$2
;;
(Xdebug)
- case $cf_cv_system_name in
+ case "$cf_cv_system_name" in
(*-msvc*)
$2='_g.lib'
;;
$3=[$]$2
;;
(Xprofile)
- case $cf_cv_system_name in
+ case "$cf_cv_system_name" in
(*-msvc*)
$2='_p.lib'
;;
$3=[$]$2
;;
(Xshared)
- case $cf_cv_system_name in
+ case "$cf_cv_system_name" in
(aix[[5-7]]*)
$2='.so'
$3=[$]$2
$3=[$]$2
;;
(hpux*)
- case $target in
+ case "$target" in
(ia64*)
$2='.so'
$3=[$]$2
esac
;;
(*)
- case $target in
+ case "$target" in
(*-msvc*)
$2='.lib'
;;
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_MAKEFLAGS version: 18 updated: 2018/02/21 21:26:03
+dnl CF_MAKEFLAGS version: 20 updated: 2021/01/03 19:29:49
dnl ------------
dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
dnl options to lower-levels. It's very useful for "make -n" -- if we have it.
dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
AC_DEFUN([CF_MAKEFLAGS],
-[
+[AC_REQUIRE([AC_PROG_FGREP])dnl
+
AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
cf_cv_makeflags=''
for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
all :
@ echo '.$cf_option'
CF_EOF
- cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | fgrep -v "ing directory" | sed -e 's,[[ ]]*$,,'`
+ cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | ${FGREP-fgrep} -v "ing directory" | sed -e 's,[[ ]]*$,,'`
case "$cf_result" in
(.*k|.*kw)
- cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
+ cf_result="`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`"
case "$cf_result" in
(.*CC=*) cf_cv_makeflags=
;;
AC_SUBST(MAKE_LOWER_TAGS)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_MIXEDCASE_FILENAMES version: 8 updated: 2020/11/14 10:12:15
+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_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
if test "$cross_compiling" = yes ; then
- case $target_alias in
+ case "$target_alias" in
(*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*)
cf_cv_mixedcase=no
;;
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: 10 updated: 2017/01/21 11:12:16
+dnl CF_MKSTEMP version: 11 updated: 2021/01/01 13:31:04
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).
unistd.h \
)
AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
-rm -rf conftest*
+rm -rf ./conftest*
AC_TRY_RUN([
#include <sys/types.h>
#ifdef HAVE_UNISTD_H
echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_NCURSES_ADDON version: 5 updated: 2015/04/26 18:06:58
+dnl CF_NCURSES_ADDON version: 6 updated: 2021/01/04 19:33:05
dnl ----------------
dnl Configure an ncurses add-on, built outside the ncurses tree.
AC_DEFUN([CF_NCURSES_ADDON],[
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=`cat conftest.out | sed -e "s/^.*AUTOCONF_$cf_name[[ ]][[ ]]*//"`
+ cf_result=`sed -e "s/^.*AUTOCONF_${cf_name}[[ ]][[ ]]*//" conftest.out`
eval NCURSES_$cf_name=\"$cf_result\"
# cat conftest.$ac_ext
# cat conftest.out
])
dnl ---------------------------------------------------------------------------
-dnl CF_NCURSES_CC_CHECK version: 4 updated: 2007/07/29 10:39:05
+dnl CF_NCURSES_CC_CHECK version: 5 updated: 2020/12/31 20:19:42
dnl -------------------
dnl Check if we can compile with ncurses' header file
dnl $1 is the cache variable to set
make an error
#endif
])[
-printf("%s\n", NCURSES_VERSION);
+printf("%s\\n", NCURSES_VERSION);
#else
#ifdef __NCURSES_H
-printf("old\n");
+printf("old\\n");
#else
make an error
#endif
,[$1=no])
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_NCURSES_CONFIG version: 23 updated: 2020/02/27 05:21:59
+dnl CF_NCURSES_CONFIG version: 26 updated: 2021/01/03 08:05:37
dnl -----------------
dnl Tie together the configure-script macros for ncurses, preferring these in
dnl order:
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`
+ 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".
+ # 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.
CF_ADD_LIBS($cf_pkg_libs)
AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
- [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
+ [initscr(); mousemask(0,0); tigetstr((char *)0);],
[AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
int main(void)
{ char *xx = curses_version(); return (xx == 0); }],
CF_ADD_LIBS($cf_pkg_libs)
AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
- [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
+ [initscr(); mousemask(0,0); tigetstr((char *)0);],
[AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
int main(void)
{ char *xx = curses_version(); return (xx == 0); }],
AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
dnl like CF_NCURSES_VERSION
- cf_cv_ncurses_version=`$NCURSES_CONFIG --version`
+ cf_cv_ncurses_version="`$NCURSES_CONFIG --version`"
else
fi
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_NCURSES_CPPFLAGS version: 21 updated: 2012/10/06 08:57:51
+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.
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"
+ { 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)
CF_NCURSES_VERSION
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_NCURSES_HEADER version: 4 updated: 2015/04/15 19:08:48
+dnl CF_NCURSES_HEADER version: 7 updated: 2021/01/04 19:33:05
dnl -----------------
dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
dnl variations of ncurses' installs.
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
+ test -n "$verbose" && echo "search path $cf_search"
cf_save2_CPPFLAGS="$CPPFLAGS"
for cf_incdir in $cf_search
do
CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
if test "$cf_cv_ncurses_h2" != no ; then
cf_cv_ncurses_h2=$cf_incdir/$cf_header
- test -n "$verbose" && echo $ac_n " ... found $ac_c" 1>&AC_FD_MSG
+ test -n "$verbose" && echo $ECHO_N " ... found $ECHO_C" 1>&AC_FD_MSG
break
fi
test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
])
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
+ 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)
# Set definitions to allow ifdef'ing for ncurses.h
-case $cf_cv_ncurses_header in
+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
+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])
;;
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_NCURSES_LIBS version: 17 updated: 2015/04/15 19:08:48
+dnl CF_NCURSES_LIBS version: 20 updated: 2021/01/03 08:05:37
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.
[LIBS="$cf_ncurses_SAVE"],
[cf_ncurses_LIBS="-lgpm"])])
-case $host_os in
+case "$host_os" in
(freebsd*)
# This is only necessary if you are linking against an obsolete
# version of ncurses (but it should do no harm, since it's static).
CF_ADD_LIBS($cf_ncurses_LIBS)
-if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
+if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
then
CF_ADD_LIBS(-l$cf_nculib_root)
else
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$%%"`
+ q=`echo "$LIBS" | sed -e "s%$p %%" -e "s%$p$%%"`
if test "$q" != "$LIBS" ; then
LIBS="$q"
fi
done
AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
- [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
+ [initscr(); mousemask(0,0); tigetstr((char *)0);],
[AC_MSG_RESULT(yes)],
[AC_MSG_RESULT(no)
LIBS="$cf_ncurses_SAVE"])
AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_NCURSES_VERSION version: 15 updated: 2017/05/09 19:26:10
+dnl CF_NCURSES_VERSION version: 16 updated: 2020/12/31 20:19:42
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
AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
cf_cv_ncurses_version=no
cf_tempfile=out$$
- rm -f $cf_tempfile
+ rm -f "$cf_tempfile"
AC_TRY_RUN([
#include <${cf_cv_ncurses_header:-curses.h}>
#include <stdio.h>
FILE *fp = fopen("$cf_tempfile", "w");
#ifdef NCURSES_VERSION
# ifdef NCURSES_VERSION_PATCH
- fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
+ fprintf(fp, "%s.%d\\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
# else
- fprintf(fp, "%s\n", NCURSES_VERSION);
+ fprintf(fp, "%s\\n", NCURSES_VERSION);
# endif
#else
# ifdef __NCURSES_H
- fprintf(fp, "old\n");
+ fprintf(fp, "old\\n");
# else
make an error
# endif
# This will not work if the preprocessor splits the line after the
# Autoconf token. The 'unproto' program does that.
- cat > conftest.$ac_ext <<EOF
+ cat > "conftest.$ac_ext" <<EOF
#include <${cf_cv_ncurses_header:-curses.h}>
#undef Autoconf
#ifdef NCURSES_VERSION
cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
AC_TRY_EVAL(cf_try)
if test -f conftest.out ; then
- cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%'`
+ 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
+ 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: 7 updated: 2015/04/17 21:13:04
+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],
(debug) $2='obj_g' ;;
(profile) $2='obj_p' ;;
(shared)
- case $cf_cv_system_name in
+ case "$cf_cv_system_name" in
(cygwin|msys)
$2='objects' ;;
(*)
esac
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_PATHSEP version: 7 updated: 2015/04/12 15:39:00
+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
+ case "$cf_cv_system_name" in
(os2*) PATH_SEPARATOR=';' ;;
(*) ${PATH_SEPARATOR:=':'} ;;
esac
AC_MSG_RESULT($PATH_SEPARATOR)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_PATH_SYNTAX version: 16 updated: 2015/04/18 08:56:57
+dnl CF_PATH_SYNTAX version: 18 updated: 2020/12/31 18:40:20
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
;;
(.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
;;
-(.\[$]{*prefix}*|.\[$]{*dir}*)
+(.\[$]\{*prefix\}*|.\[$]\{*dir\}*)
eval $1="[$]$1"
case ".[$]$1" in
(.NONE/*)
- $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
+ $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
;;
esac
;;
(.no|.NONE/*)
- $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
+ $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: 10 updated: 2015/04/26 18:06:58
+dnl CF_PKG_CONFIG version: 11 updated: 2021/01/01 13:31:04
dnl -------------
dnl Check for the package-config program, unless disabled by command-line.
AC_DEFUN([CF_PKG_CONFIG],
[cf_pkg_config=yes])
AC_MSG_RESULT($cf_pkg_config)
-case $cf_pkg_config in
+case "$cf_pkg_config" in
(no)
PKG_CONFIG=none
;;
CF_CC_ENV_FLAGS
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_PROG_CC_C_O version: 5 updated: 2017/01/21 11:06:25
+dnl CF_PROG_CC_C_O version: 6 updated: 2021/01/01 13:31:04
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
else
eval cf_cv_prog_$1_c_o=no
fi
-rm -rf conftest*
+rm -rf ./conftest*
])dnl
-if test $cf_cv_prog_$1_c_o = yes; then
+if test "$cf_cv_prog_$1_c_o" = yes; then
AC_MSG_RESULT([yes])
else
AC_MSG_RESULT([no])
test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_PROG_EXT version: 14 updated: 2018/06/20 20:23:13
+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
+case "$cf_cv_system_name" in
(os2*)
CFLAGS="$CFLAGS -Zmt"
CF_APPEND_TEXT(CPPFLAGS,-D__ST_MT_ERRNO__)
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: 10 updated: 2019/12/31 08:53:54
+dnl CF_PROG_GNAT version: 12 updated: 2021/01/02 17:09:14
dnl ------------
dnl Check for gnat/gnatmake/etc, ensure that the toolset is complete.
AC_DEFUN([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
+ 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
+ eval "cf_cv_VERSION_$cf_upper_prog_gnat=[$]cf_TEMP_gnat"
unset cf_TEMP_gnat
unset cf_cv_gnat_version
# gprconfig is newer than gnatmake; we can continue...
cf_ada_config="##"
else
- rm -rf conftest* *~conftest*
+ rm -rf ./conftest* ./*~conftest*
if mkdir conftest.src
then
cf_ada_config=""
for cf_gprconfig in Ada C
do
AC_MSG_CHECKING(for gprconfig name for $cf_gprconfig)
- if test $cf_gprconfig = C
+ if test "$cf_gprconfig" = C
then
for cf_gprconfig_param in \
- $cf_gprconfig,,,,GNATGCC \
- $cf_gprconfig,,,,GCC \
- $cf_gprconfig
+ "$cf_gprconfig,,,,GNATGCC" \
+ "$cf_gprconfig,,,,GCC" \
+ "$cf_gprconfig"
do
cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
test -n "$cf_gprconfig_value" && break
fi
if test -n "$cf_gprconfig_value"
then
- eval cf_ada_config_[$]cf_gprconfig=[$]cf_gprconfig_value
+ eval "cf_ada_config_[$]cf_gprconfig=[$]cf_gprconfig_value"
AC_MSG_RESULT($cf_gprconfig_value)
else
AC_MSG_RESULT(missing)
fi
done
cd ..
- rm -rf conftest* *~conftest*
+ rm -rf ./conftest* ./*~conftest*
fi
fi
if test "x$cf_ada_config" != "x#"
AC_SUBST(cf_ada_config_C)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_PROG_INSTALL version: 7 updated: 2015/04/18 08:56:57
+dnl CF_PROG_INSTALL version: 10 updated: 2021/01/04 19:33:05
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
(*)
CF_DIRNAME(cf_dir,$INSTALL)
test -z "$cf_dir" && cf_dir=.
- INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
+ INSTALL="`cd \"$cf_dir\" && pwd`"/"`echo "$INSTALL" | sed -e 's%^.*/%%'`"
;;
esac
])dnl
done
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_SHARED_OPTS version: 102 updated: 2020/08/22 18:17:19
+dnl CF_SHARED_OPTS version: 105 updated: 2021/01/02 17:09:14
dnl --------------
dnl --------------
dnl Attempt to determine the appropriate CC/LD options for creating a shared
AC_ARG_WITH(shlib-version,
[ --with-shlib-version=X Specify rel or abi version for shared libs],
[test -z "$withval" && withval=auto
- case $withval in
+ case "$withval" in
(yes)
cf_cv_shlib_version=auto
;;
then
cf_try_fPIC=yes
else
- case $cf_cv_system_name in
+ case "$cf_cv_system_name" in
(*linux*) # e.g., PGI compiler
cf_try_fPIC=yes
;;
cf_cv_shlib_version_infix=no
- case $cf_cv_system_name in
+ case "$cf_cv_system_name" in
(aix4.[3-9]*|aix[[5-7]]*)
if test "$GCC" = yes; then
CC_SHARED_OPTS='-Wl,-brtl'
LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
LDFLAGS=$cf_save_LDFLAGS])
- if test $cf_cv_ldflags_search_paths_first = yes; then
+ if test "$cf_cv_ldflags_search_paths_first" = yes; then
LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
fi
;;
# 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
+ case "$host_os" in
(osf4*)
MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
;;
for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
do
CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
- AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\n");],[break])
+ AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\\n");],[break])
done
CFLAGS="$cf_save_CFLAGS"
CC_SHARED_OPTS=$cf_shared_opts
#include <stdio.h>
int main(int argc, char *argv[[]])
{
- printf("hello\n");
+ printf("hello\\n");
return (argv[[argc-1]] == 0) ;
}
EOF
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"
+ 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)
fi
])
dnl ---------------------------------------------------------------------------
-dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
+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} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
+[$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 --------------
done
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_TERM_HEADER version: 5 updated: 2020/03/19 20:23:48
+dnl CF_TERM_HEADER version: 6 updated: 2021/01/02 09:31:20
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
+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%'`
;;
# Set definitions to allow ifdef'ing to accommodate subdirectories
-case $cf_cv_term_header in
+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
+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])
;;
AC_SUBST(MAKE_ADA_SHAREDLIB)
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_WITH_CURSES_DIR version: 3 updated: 2010/11/20 17:02:38
+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.
[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" )
+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"
fi
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_WITH_LIB_PREFIX version: 1 updated: 2012/01/21 19:28:10
+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.
[with_lib_prefix=auto])
AC_MSG_RESULT($with_lib_prefix)
-if test $with_lib_prefix = auto
+if test "$with_lib_prefix" = auto
then
CF_LIB_PREFIX($1)
-elif test $with_lib_prefix = no
+elif test "$with_lib_prefix" = no
then
LIB_PREFIX=
else
AC_SUBST($3)dnl
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_WITH_PKG_CONFIG_LIBDIR version: 10 updated: 2015/08/22 17:10:56
+dnl CF_WITH_PKG_CONFIG_LIBDIR version: 11 updated: 2021/01/01 16:16:30
dnl -------------------------
dnl Allow the choice of the pkg-config library directory to be overridden.
AC_DEFUN([CF_WITH_PKG_CONFIG_LIBDIR],[
-case $PKG_CONFIG in
+case "$PKG_CONFIG" in
(no|none|yes)
AC_MSG_CHECKING(for pkg-config library directory)
;;
for cf_config in $cf_search_path
do
CF_VERBOSE(checking $cf_config/pkgconfig)
- if test -d $cf_config/pkgconfig
+ if test -d "$cf_config/pkgconfig"
then
PKG_CONFIG_LIBDIR=$cf_config/pkgconfig
AC_MSG_CHECKING(done)
])
])dnl
dnl ---------------------------------------------------------------------------
-dnl CF_XOPEN_SOURCE version: 55 updated: 2018/12/31 20:46:17
+dnl CF_XOPEN_SOURCE version: 57 updated: 2021/01/01 16:53:59
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,
cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
cf_xopen_source=
-case $host_os in
+case "$host_os" in
(aix[[4-7]]*)
cf_xopen_source="-D_ALL_SOURCE"
;;
[cf_XOPEN_SOURCE_set=yes],
[cf_XOPEN_SOURCE_set=no])
AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
- if test $cf_XOPEN_SOURCE_set = yes
+ if test "$cf_XOPEN_SOURCE_set" = yes
then
AC_TRY_COMPILE([#include <stdlib.h>],[
#if (_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
+ if test "$cf_XOPEN_SOURCE_set_ok" = no
then
AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
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
#! /bin/sh
-# From configure.in Revision: 1.79 .
+# From configure.in Revision: 1.82 .
# Guess values for system-dependent variables and create Makefiles.
-# Generated by Autoconf 2.52.20200802.
+# Generated by Autoconf 2.52.20210105.
#
+# Copyright 2003-2020,2021 Thomas E. Dickey
# Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
# Free Software Foundation, Inc.
# This configure script is free software; the Free Software Foundation
# Support unset when possible.
if (FOO=FOO; unset FOO) >/dev/null 2>&1; then
- as_unset=unset
+ as_unset="unset"
else
- as_unset=false
+ as_unset="false"
fi
# NLS nuisances.
ac_default_prefix=/usr/local
cross_compiling=no
subdirs=
-MFLAGS= MAKEFLAGS=
+MFLAGS=
+MAKEFLAGS=
SHELL=${CONFIG_SHELL-/bin/sh}
# Maximum number of lines to put in a shell here document.
# This variable seems obsolete. It should probably be removed, and
# only ac_max_sed_lines should be used.
-: ${ac_max_here_lines=38}
+: "${ac_max_here_lines=38}"
ac_unique_file="gen/gen.c"
# Factoring default headers for most tests.
# Accept the important Cygnus configure options, so we can diagnose typos.
- case $ac_option in
+ case "$ac_option" in
-bindir | --bindir | --bindi | --bind | --bin | --bi)
ac_prev=bindir ;;
expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
{ echo "$as_me: error: invalid feature name: $ac_feature" >&2
{ (exit 1); exit 1; }; }
- ac_feature=`echo $ac_feature | sed 's/-/_/g'`
+ ac_feature=`echo "$ac_feature" | sed 's/-/_/g'`
eval "enable_$ac_feature=no" ;;
-enable-* | --enable-*)
expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
{ echo "$as_me: error: invalid feature name: $ac_feature" >&2
{ (exit 1); exit 1; }; }
- ac_feature=`echo $ac_feature | sed 's/-/_/g'`
- case $ac_option in
+ ac_feature=`echo "$ac_feature" | sed 's/-/_/g'`
+ case "$ac_option" in
*=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
*) ac_optarg=yes ;;
esac
expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
{ echo "$as_me: error: invalid package name: $ac_package" >&2
{ (exit 1); exit 1; }; }
- ac_package=`echo $ac_package| sed 's/-/_/g'`
- case $ac_option in
+ ac_package=`echo "$ac_package" | sed 's/-/_/g'`
+ case "$ac_option" in
*=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
*) ac_optarg=yes ;;
esac
expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
{ echo "$as_me: error: invalid package name: $ac_package" >&2
{ (exit 1); exit 1; }; }
- ac_package=`echo $ac_package | sed 's/-/_/g'`
+ ac_package=`echo "$ac_package" | sed 's/-/_/g'`
eval "with_$ac_package=no" ;;
--x)
{ (exit 1); exit 1; }; }
ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
eval "$ac_envvar='$ac_optarg'"
- export $ac_envvar ;;
+ export "$ac_envvar" ;;
*)
# FIXME: should be removed in autoconf 3.0.
echo "$as_me: WARNING: you should use --build, --host, --target" >&2
expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
echo "$as_me: WARNING: invalid host type: $ac_option" >&2
- : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
+ : "${build_alias=$ac_option}" "${host_alias=$ac_option}" "${target_alias=$ac_option}"
;;
esac
done
if test -n "$ac_prev"; then
- ac_option=--`echo $ac_prev | sed 's/_/-/g'`
+ ac_option=--`echo "$ac_prev" | sed 's/_/-/g'`
{ echo "$as_me: error: missing argument to $ac_option" >&2
{ (exit 1); exit 1; }; }
fi
# Be sure to have absolute paths.
for ac_var in exec_prefix prefix
do
- eval ac_val=$`echo $ac_var`
- case $ac_val in
+ eval ac_val=$`echo "$ac_var"`
+ case "$ac_val" in
[\\/$]* | ?:[\\/]* | NONE | '' ) ;;
*) { echo "$as_me: error: expected an absolute path for --$ac_var: $ac_val" >&2
{ (exit 1); exit 1; }; };;
for ac_var in bindir sbindir libexecdir datarootdir datadir sysconfdir sharedstatedir \
localstatedir libdir includedir oldincludedir infodir mandir
do
- eval ac_val=$`echo $ac_var`
- case $ac_val in
+ eval ac_val=$`echo "$ac_var"`
+ case "$ac_val" in
[\\/$]* | ?:[\\/]* ) ;;
*) { echo "$as_me: error: expected an absolute path for --$ac_var: $ac_val" >&2
{ (exit 1); exit 1; }; };;
ac_confdir=`echo "$ac_prog" | sed 's%[\\/][^\\/][^\\/]*$%%'`
test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
srcdir=$ac_confdir
- if test ! -r $srcdir/$ac_unique_file; then
+ if test ! -r "$srcdir/$ac_unique_file"; then
srcdir=..
fi
else
ac_srcdir_defaulted=no
fi
-if test ! -r $srcdir/$ac_unique_file; then
+if test ! -r "$srcdir/$ac_unique_file"; then
if test "$ac_srcdir_defaulted" = yes; then
{ echo "$as_me: error: cannot find sources in $ac_confdir or .." >&2
{ (exit 1); exit 1; }; }
--with-wrap-prefix=XXX override prefix used for public variables
Testing/development Options:
--disable-echo do not display "compiling" commands
- --enable-warnings build: turn on GCC compiler warnings
--enable-warnings test: turn on gcc compiler warnings
--enable-assertions test: turn on generation of assertion code
--enable-expanded test: generate functions for certain macros
# If there are subdirs, report their specific --help.
ac_popdir=`pwd`
for ac_subdir in : $ac_subdirs_all; do test "x$ac_subdir" = x: && continue
- cd $ac_subdir
+ cd "$ac_subdir"
# A "../" for each directory in /$ac_subdir.
- ac_dots=`echo $ac_subdir |
+ ac_dots=`echo "$ac_subdir" |
sed 's,^\./,,;s,[^/]$,&/,;s,[^/]*/,../,g'`
- case $srcdir in
+ case "$srcdir" in
.) # No --srcdir option. We are building in place.
- ac_sub_srcdir=$srcdir ;;
+ ac_sub_srcdir="$srcdir" ;;
[\\/]* | ?:[\\/]* ) # Absolute path.
- ac_sub_srcdir=$srcdir/$ac_subdir ;;
+ ac_sub_srcdir="$srcdir/$ac_subdir" ;;
*) # Relative path.
- ac_sub_srcdir=$ac_dots$srcdir/$ac_subdir ;;
+ ac_sub_srcdir="$ac_dots$srcdir/$ac_subdir" ;;
esac
# Check for guested configure; otherwise get Cygnus style configure.
- if test -f $ac_sub_srcdir/configure.gnu; then
+ if test -f "$ac_sub_srcdir/configure.gnu"; then
echo
- $SHELL $ac_sub_srcdir/configure.gnu --help=recursive
- elif test -f $ac_sub_srcdir/configure; then
+ $SHELL "$ac_sub_srcdir/configure.gnu" --help=recursive
+ elif test -f "$ac_sub_srcdir/configure"; then
echo
- $SHELL $ac_sub_srcdir/configure --help=recursive
- elif test -f $ac_sub_srcdir/configure.ac ||
- test -f $ac_sub_srcdir/configure.in; then
+ $SHELL "$ac_sub_srcdir/configure" --help=recursive
+ elif test -f "$ac_sub_srcdir/configure.ac" ||
+ test -f "$ac_sub_srcdir/configure.in"; then
echo
- $ac_configure --help
+ "$ac_configure" --help
else
echo "$as_me: WARNING: no configuration information is in $ac_subdir" >&2
fi
- cd $ac_popdir
+ cd "$ac_popdir"
done
fi
test -n "$ac_init_help" && exit 0
-if $ac_init_version; then
+if "$ac_init_version"; then
cat <<\EOF
+Copyright 2003-2020,2021 Thomas E. Dickey
Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
Free Software Foundation, Inc.
This configure script is free software; the Free Software Foundation
running configure, to aid debugging if configure makes a mistake.
It was created by $as_me, which was
-generated by GNU Autoconf 2.52.20200802. Invocation command line was
+generated by GNU Autoconf 2.52.20210105. Invocation command line was
$ $0 $@
ac_sep=
for ac_arg
do
- case $ac_arg in
+ case "$ac_arg" in
-no-create | --no-create | --no-creat | --no-crea | --no-cre \
| --no-cr | --no-c) ;;
-no-recursion | --no-recursion | --no-recursio | --no-recursi \
exit $exit_status
' 0
for ac_signal in 1 2 13 15; do
- trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
+ trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' "$ac_signal"
done
ac_signal=0
fi
for ac_site_file in $CONFIG_SITE; do
if test -r "$ac_site_file"; then
- { echo "$as_me:946: loading site script $ac_site_file" >&5
+ { echo "$as_me:948: loading site script $ac_site_file" >&5
echo "$as_me: loading site script $ac_site_file" >&6;}
cat "$ac_site_file" >&5
. "$ac_site_file"
# Some versions of bash will fail to source /dev/null (special
# files actually), so we avoid doing that.
if test -f "$cache_file"; then
- { echo "$as_me:957: loading cache $cache_file" >&5
+ { echo "$as_me:959: loading cache $cache_file" >&5
echo "$as_me: loading cache $cache_file" >&6;}
case $cache_file in
[\\/]* | ?:[\\/]* ) . $cache_file;;
esac
fi
else
- { echo "$as_me:965: creating cache $cache_file" >&5
+ { echo "$as_me:967: creating cache $cache_file" >&5
echo "$as_me: creating cache $cache_file" >&6;}
>$cache_file
fi
eval ac_new_set=\$ac_env_${ac_var}_set
eval ac_old_val="\$ac_cv_env_${ac_var}_value"
eval ac_new_val="\$ac_env_${ac_var}_value"
- case $ac_old_set,$ac_new_set in
+ case "$ac_old_set,$ac_new_set" in
set,)
- { echo "$as_me:981: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+ { echo "$as_me:983: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
ac_cache_corrupted=: ;;
,set)
- { echo "$as_me:985: error: \`$ac_var' was not set in the previous run" >&5
+ { echo "$as_me:987: error: \`$ac_var' was not set in the previous run" >&5
echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
ac_cache_corrupted=: ;;
,);;
*)
if test "x$ac_old_val" != "x$ac_new_val"; then
- { echo "$as_me:991: error: \`$ac_var' has changed since the previous run:" >&5
+ { echo "$as_me:993: error: \`$ac_var' has changed since the previous run:" >&5
echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
- { echo "$as_me:993: former value: $ac_old_val" >&5
+ { echo "$as_me:995: former value: $ac_old_val" >&5
echo "$as_me: former value: $ac_old_val" >&2;}
- { echo "$as_me:995: current value: $ac_new_val" >&5
+ { echo "$as_me:997: current value: $ac_new_val" >&5
echo "$as_me: current value: $ac_new_val" >&2;}
ac_cache_corrupted=:
fi;;
# Pass precious variables to config.status. It doesn't matter if
# we pass some twice (in addition to the command line arguments).
if test "$ac_new_set" = set; then
- case $ac_new_val in
+ case "$ac_new_val" in
*" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"`
ac_configure_args="$ac_configure_args '$ac_arg'"
esac
fi
done
-if $ac_cache_corrupted; then
- { echo "$as_me:1014: error: changes in the environment can compromise the build" >&5
+if "$ac_cache_corrupted"; then
+ { echo "$as_me:1016: error: changes in the environment can compromise the build" >&5
echo "$as_me: error: changes in the environment can compromise the build" >&2;}
- { { echo "$as_me:1016: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
+ { { echo "$as_me:1018: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
{ (exit 1); exit 1; }; }
fi
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
+ac_link='$CC -o "conftest$ac_exeext" $CFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
-ac_main_return=return
+ac_main_return="return"
case `echo "testing\c" 2>/dev/null; echo 1,2,3`,`echo -n testing 2>/dev/null; echo 1,2,3` in
- *c*,-n*) ECHO_N= ECHO_C= # newlines do not sed ;-) only broken shells would use this case anyway
- ECHO_T=' ' ;;
- *c*,* ) ECHO_N=-n ECHO_C= ECHO_T= ;;
- *) ECHO_N= ECHO_C='\c' ECHO_T= ;;
+ *c*,-n*) ECHO_N=
+ ECHO_C= # newlines do not sed ;-) only broken shells would use this case anyway
+ ECHO_T=' '
+ ;;
+ *c*,* ) ECHO_N=-n
+ ECHO_C=
+ ECHO_T=
+ ;;
+ *) ECHO_N=
+ ECHO_C='\c'
+ ECHO_T=
+ ;;
esac
echo "#! $SHELL" >conftest.sh
echo "exit 0" >>conftest.sh
chmod +x conftest.sh
-if { (echo "$as_me:1037: PATH=\".;.\"; conftest.sh") >&5
+if { (echo "$as_me:1047: PATH=\".;.\"; conftest.sh") >&5
(PATH=".;."; conftest.sh) 2>&5
ac_status=$?
- echo "$as_me:1040: \$? = $ac_status" >&5
- (exit $ac_status); }; then
+ echo "$as_me:1050: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; then
ac_path_separator=';'
else
ac_path_separator=:
ac_aux_dir=
for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
- if test -f $ac_dir/install-sh; then
+ if test -f "$ac_dir/install-sh"; then
ac_aux_dir=$ac_dir
ac_install_sh="$ac_aux_dir/install-sh -c"
break
- elif test -f $ac_dir/install.sh; then
+ elif test -f "$ac_dir/install.sh"; then
ac_aux_dir=$ac_dir
ac_install_sh="$ac_aux_dir/install.sh -c"
break
- elif test -f $ac_dir/shtool; then
+ elif test -f "$ac_dir/shtool"; then
ac_aux_dir=$ac_dir
ac_install_sh="$ac_aux_dir/shtool install -c"
break
fi
done
if test -z "$ac_aux_dir"; then
- { { echo "$as_me:1070: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
+ { { echo "$as_me:1080: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
{ (exit 1); exit 1; }; }
fi
# Make sure we can run config.sub.
$ac_config_sub sun4 >/dev/null 2>&1 ||
- { { echo "$as_me:1080: error: cannot run $ac_config_sub" >&5
+ { { echo "$as_me:1090: error: cannot run $ac_config_sub" >&5
echo "$as_me: error: cannot run $ac_config_sub" >&2;}
{ (exit 1); exit 1; }; }
-echo "$as_me:1084: checking build system type" >&5
+echo "$as_me:1094: checking build system type" >&5
echo $ECHO_N "checking build system type... $ECHO_C" >&6
if test "${ac_cv_build+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_cv_build_alias" &&
ac_cv_build_alias=`$ac_config_guess`
test -z "$ac_cv_build_alias" &&
- { { echo "$as_me:1093: error: cannot guess build type; you must specify one" >&5
+ { { echo "$as_me:1103: error: cannot guess build type; you must specify one" >&5
echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
{ (exit 1); exit 1; }; }
-ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
- { { echo "$as_me:1097: error: $ac_config_sub $ac_cv_build_alias failed." >&5
+ac_cv_build=`$ac_config_sub "$ac_cv_build_alias"` ||
+ { { echo "$as_me:1107: error: $ac_config_sub $ac_cv_build_alias failed." >&5
echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed." >&2;}
{ (exit 1); exit 1; }; }
fi
-echo "$as_me:1102: result: $ac_cv_build" >&5
+echo "$as_me:1112: result: $ac_cv_build" >&5
echo "${ECHO_T}$ac_cv_build" >&6
build=$ac_cv_build
-build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
-build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
-build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
+build_cpu=`echo "$ac_cv_build" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+build_vendor=`echo "$ac_cv_build" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+build_os=`echo "$ac_cv_build" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
-echo "$as_me:1109: checking host system type" >&5
+echo "$as_me:1119: checking host system type" >&5
echo $ECHO_N "checking host system type... $ECHO_C" >&6
if test "${ac_cv_host+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
ac_cv_host_alias=$host_alias
test -z "$ac_cv_host_alias" &&
ac_cv_host_alias=$ac_cv_build_alias
-ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
- { { echo "$as_me:1118: error: $ac_config_sub $ac_cv_host_alias failed" >&5
+ac_cv_host=`$ac_config_sub "$ac_cv_host_alias"` ||
+ { { echo "$as_me:1128: error: $ac_config_sub $ac_cv_host_alias failed" >&5
echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
{ (exit 1); exit 1; }; }
fi
-echo "$as_me:1123: result: $ac_cv_host" >&5
+echo "$as_me:1133: result: $ac_cv_host" >&5
echo "${ECHO_T}$ac_cv_host" >&6
host=$ac_cv_host
-host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
-host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
-host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
+host_cpu=`echo "$ac_cv_host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+host_vendor=`echo "$ac_cv_host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+host_os=`echo "$ac_cv_host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
-if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
- echo "$as_me:1131: checking target system type" >&5
+if test -f "$srcdir/config.guess" || test -f "$ac_aux_dir/config.guess" ; then
+ echo "$as_me:1141: checking target system type" >&5
echo $ECHO_N "checking target system type... $ECHO_C" >&6
if test "${ac_cv_target+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
ac_cv_target_alias=$target_alias
test "x$ac_cv_target_alias" = "x" &&
ac_cv_target_alias=$ac_cv_host_alias
-ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
- { { echo "$as_me:1140: error: $ac_config_sub $ac_cv_target_alias failed" >&5
+ac_cv_target=`$ac_config_sub "$ac_cv_target_alias"` ||
+ { { echo "$as_me:1150: error: $ac_config_sub $ac_cv_target_alias failed" >&5
echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
{ (exit 1); exit 1; }; }
fi
-echo "$as_me:1145: result: $ac_cv_target" >&5
+echo "$as_me:1155: result: $ac_cv_target" >&5
echo "${ECHO_T}$ac_cv_target" >&6
target=$ac_cv_target
-target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
-target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
-target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
+target_cpu=`echo "$ac_cv_target" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+target_vendor=`echo "$ac_cv_target" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+target_os=`echo "$ac_cv_target" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
# The aliases save the names the user supplied, while $host etc.
# will get canonicalized.
fi
test -z "$system_name" && system_name="$cf_cv_system_name"
-test -n "$cf_cv_system_name" && echo "$as_me:1177: result: Configuring for $cf_cv_system_name" >&5
+test -n "$cf_cv_system_name" && echo "$as_me:1187: result: Configuring for $cf_cv_system_name" >&5
echo "${ECHO_T}Configuring for $cf_cv_system_name" >&6
if test ".$system_name" != ".$cf_cv_system_name" ; then
- echo "$as_me:1181: result: Cached system name ($system_name) does not agree with actual ($cf_cv_system_name)" >&5
+ echo "$as_me:1191: result: Cached system name ($system_name) does not agree with actual ($cf_cv_system_name)" >&5
echo "${ECHO_T}Cached system name ($system_name) does not agree with actual ($cf_cv_system_name)" >&6
- { { echo "$as_me:1183: error: \"Please remove config.cache and try again.\"" >&5
+ { { echo "$as_me:1193: error: \"Please remove config.cache and try again.\"" >&5
echo "$as_me: error: \"Please remove config.cache and try again.\"" >&2;}
{ (exit 1); exit 1; }; }
fi
# Check whether --with-system-type or --without-system-type was given.
if test "${with_system_type+set}" = set; then
withval="$with_system_type"
- { echo "$as_me:1191: WARNING: overriding system type to $withval" >&5
+ { echo "$as_me:1201: WARNING: overriding system type to $withval" >&5
echo "$as_me: WARNING: overriding system type to $withval" >&2;}
cf_cv_system_name=$withval
host_os=$withval
cf_user_CFLAGS="$CFLAGS"
### Default install-location
+for ac_prog in ggrep grep
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+echo "$as_me:1216: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_GREP+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ if test -n "$GREP"; then
+ ac_cv_prog_GREP="$GREP" # Let the user override the test.
+else
+ ac_save_IFS=$IFS; IFS=$ac_path_separator
+ac_dummy="$PATH"
+for ac_dir in $ac_dummy; do
+ IFS=$ac_save_IFS
+ test -z "$ac_dir" && ac_dir=.
+ $as_executable_p "$ac_dir/$ac_word" || continue
+ac_cv_prog_GREP="$ac_prog"
+echo "$as_me:1231: found $ac_dir/$ac_word" >&5
+break
+done
+
+fi
+fi
+GREP=$ac_cv_prog_GREP
+if test -n "$GREP"; then
+ echo "$as_me:1239: result: $GREP" >&5
+echo "${ECHO_T}$GREP" >&6
+else
+ echo "$as_me:1242: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+ test -n "$GREP" && break
+done
+test -n "$GREP" || GREP=": "
+
+echo "$as_me:1250: checking for fgrep" >&5
+echo $ECHO_N "checking for fgrep... $ECHO_C" >&6
+if test "${ac_cv_path_FGREP+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
+ then ac_cv_path_FGREP="$GREP -F"
+ else
+ for ac_prog in gfgrep fgrep
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+echo "$as_me:1262: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_path_FGREP+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ case $FGREP in
+ [\\/]* | ?:[\\/]*)
+ ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
+ ;;
+ *)
+ ac_save_IFS=$IFS; IFS=$ac_path_separator
+ac_dummy="$PATH"
+for ac_dir in $ac_dummy; do
+ IFS=$ac_save_IFS
+ test -z "$ac_dir" && ac_dir=.
+ if $as_executable_p "$ac_dir/$ac_word"; then
+ ac_cv_path_FGREP="$ac_dir/$ac_word"
+ echo "$as_me:1279: found $ac_dir/$ac_word" >&5
+ break
+fi
+done
+
+ ;;
+esac
+fi
+FGREP=$ac_cv_path_FGREP
+
+if test -n "$FGREP"; then
+ echo "$as_me:1290: result: $FGREP" >&5
+echo "${ECHO_T}$FGREP" >&6
+else
+ echo "$as_me:1293: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
-echo "$as_me:1203: checking for prefix" >&5
+ test -n "$FGREP" && break
+done
+test -n "$FGREP" || FGREP=": "
+
+ test "x$ac_cv_path_FGREP" = "x:" && { { echo "$as_me:1301: error: cannot find workable fgrep" >&5
+echo "$as_me: error: cannot find workable fgrep" >&2;}
+ { (exit 1); exit 1; }; }
+ fi
+fi
+echo "$as_me:1306: result: $ac_cv_path_FGREP" >&5
+echo "${ECHO_T}$ac_cv_path_FGREP" >&6
+ FGREP="$ac_cv_path_FGREP"
+
+echo "$as_me:1310: checking for prefix" >&5
echo $ECHO_N "checking for prefix... $ECHO_C" >&6
if test "x$prefix" = "xNONE" ; then
case "$cf_cv_system_name" in
;;
esac
fi
-echo "$as_me:1215: result: $prefix" >&5
+echo "$as_me:1322: result: $prefix" >&5
echo "${ECHO_T}$prefix" >&6
if test "x$prefix" = "xNONE" ; then
-echo "$as_me:1219: checking for default include-directory" >&5
+echo "$as_me:1326: checking for default include-directory" >&5
echo $ECHO_N "checking for default include-directory... $ECHO_C" >&6
test -n "$verbose" && echo 1>&6
for cf_symbol in \
- $includedir \
- $includedir/ncurses \
- $prefix/include \
- $prefix/include/ncurses \
+ "$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 NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
+ 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 $ac_n " found " 1>&6
+ test -n "$verbose" && echo $ECHO_N " found " 1>&6
break
fi
fi
test -n "$verbose" && echo " tested $cf_dir" 1>&6
done
-echo "$as_me:1242: result: $includedir" >&5
+echo "$as_me:1349: result: $includedir" >&5
echo "${ECHO_T}$includedir" >&6
fi
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
+ac_link='$CC -o "conftest$ac_exeext" $CFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
-ac_main_return=return
+ac_main_return="return"
if test -n "$ac_tool_prefix"; then
for ac_prog in gnatgcc gcc cc
do
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
-echo "$as_me:1259: checking for $ac_word" >&5
+echo "$as_me:1366: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_CC+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
$as_executable_p "$ac_dir/$ac_word" || continue
ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
-echo "$as_me:1274: found $ac_dir/$ac_word" >&5
+echo "$as_me:1381: found $ac_dir/$ac_word" >&5
break
done
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
- echo "$as_me:1282: result: $CC" >&5
+ echo "$as_me:1389: result: $CC" >&5
echo "${ECHO_T}$CC" >&6
else
- echo "$as_me:1285: result: no" >&5
+ echo "$as_me:1392: result: no" >&5
echo "${ECHO_T}no" >&6
fi
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
-echo "$as_me:1298: checking for $ac_word" >&5
+echo "$as_me:1405: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
$as_executable_p "$ac_dir/$ac_word" || continue
ac_cv_prog_ac_ct_CC="$ac_prog"
-echo "$as_me:1313: found $ac_dir/$ac_word" >&5
+echo "$as_me:1420: found $ac_dir/$ac_word" >&5
break
done
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
- echo "$as_me:1321: result: $ac_ct_CC" >&5
+ echo "$as_me:1428: result: $ac_ct_CC" >&5
echo "${ECHO_T}$ac_ct_CC" >&6
else
- echo "$as_me:1324: result: no" >&5
+ echo "$as_me:1431: result: no" >&5
echo "${ECHO_T}no" >&6
fi
CC=$ac_ct_CC
fi
-test -z "$CC" && { { echo "$as_me:1334: error: no acceptable cc found in \$PATH" >&5
+test -z "$CC" && { { echo "$as_me:1441: error: no acceptable cc found in \$PATH" >&5
echo "$as_me: error: no acceptable cc found in \$PATH" >&2;}
{ (exit 1); exit 1; }; }
# Provide some information about the compiler.
-echo "$as_me:1339:" \
+echo "$as_me:1446:" \
"checking for C compiler version" >&5
-ac_compiler=`set X $ac_compile; echo $2`
-{ (eval echo "$as_me:1342: \"$ac_compiler --version </dev/null >&5\"") >&5
+ac_compiler=`set X $ac_compile; echo "$2"`
+{ (eval echo "$as_me:1449: \"$ac_compiler --version </dev/null >&5\"") >&5
(eval $ac_compiler --version </dev/null >&5) 2>&5
ac_status=$?
- echo "$as_me:1345: \$? = $ac_status" >&5
- (exit $ac_status); }
-{ (eval echo "$as_me:1347: \"$ac_compiler -v </dev/null >&5\"") >&5
+ echo "$as_me:1452: \$? = $ac_status" >&5
+ (exit "$ac_status"); }
+{ (eval echo "$as_me:1454: \"$ac_compiler -v </dev/null >&5\"") >&5
(eval $ac_compiler -v </dev/null >&5) 2>&5
ac_status=$?
- echo "$as_me:1350: \$? = $ac_status" >&5
- (exit $ac_status); }
-{ (eval echo "$as_me:1352: \"$ac_compiler -V </dev/null >&5\"") >&5
+ echo "$as_me:1457: \$? = $ac_status" >&5
+ (exit "$ac_status"); }
+{ (eval echo "$as_me:1459: \"$ac_compiler -V </dev/null >&5\"") >&5
(eval $ac_compiler -V </dev/null >&5) 2>&5
ac_status=$?
- echo "$as_me:1355: \$? = $ac_status" >&5
- (exit $ac_status); }
+ echo "$as_me:1462: \$? = $ac_status" >&5
+ (exit "$ac_status"); }
-cat >conftest.$ac_ext <<_ACEOF
-#line 1359 "configure"
+cat >"conftest.$ac_ext" <<_ACEOF
+#line 1466 "configure"
#include "confdefs.h"
int
# Try to create an executable without -o first, disregard a.out.
# It will help us diagnose broken compilers, and finding out an intuition
# of exeext.
-echo "$as_me:1375: checking for C compiler default output" >&5
+echo "$as_me:1482: checking for C compiler default output" >&5
echo $ECHO_N "checking for C compiler default output... $ECHO_C" >&6
-ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
-if { (eval echo "$as_me:1378: \"$ac_link_default\"") >&5
+ac_link_default=`echo "$ac_link" | sed 's/ -o *"conftest[^"]*"//'`
+if { (eval echo "$as_me:1485: \"$ac_link_default\"") >&5
(eval $ac_link_default) 2>&5
ac_status=$?
- echo "$as_me:1381: \$? = $ac_status" >&5
- (exit $ac_status); }; then
+ echo "$as_me:1488: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; then
# Find the output, starting from the most likely. This scheme is
# not robust to junk in `.', hence go to wildcards (a.*) only as a last
# resort.
done
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
-{ { echo "$as_me:1404: error: C compiler cannot create executables" >&5
+cat "conftest.$ac_ext" >&5
+{ { echo "$as_me:1511: error: C compiler cannot create executables" >&5
echo "$as_me: error: C compiler cannot create executables" >&2;}
{ (exit 77); exit 77; }; }
fi
ac_exeext=$ac_cv_exeext
-echo "$as_me:1410: result: $ac_file" >&5
+echo "$as_me:1517: result: $ac_file" >&5
echo "${ECHO_T}$ac_file" >&6
# Check the compiler produces executables we can run. If not, either
# the compiler is broken, or we cross compile.
-echo "$as_me:1415: checking whether the C compiler works" >&5
+echo "$as_me:1522: checking whether the C compiler works" >&5
echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
# FIXME: These cross compiler hacks should be removed for Autoconf 3.0
# If not cross compiling, check that we can run a simple program.
if test "$cross_compiling" != yes; then
if { ac_try='./$ac_file'
- { (eval echo "$as_me:1421: \"$ac_try\"") >&5
+ { (eval echo "$as_me:1528: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:1424: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:1531: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
cross_compiling=no
else
if test "$cross_compiling" = maybe; then
cross_compiling=yes
else
- { { echo "$as_me:1431: error: cannot run C compiled programs.
+ { { echo "$as_me:1538: error: cannot run C compiled programs.
If you meant to cross compile, use \`--host'." >&5
echo "$as_me: error: cannot run C compiled programs.
If you meant to cross compile, use \`--host'." >&2;}
fi
fi
fi
-echo "$as_me:1439: result: yes" >&5
+echo "$as_me:1546: result: yes" >&5
echo "${ECHO_T}yes" >&6
-rm -f a.out a.exe conftest$ac_cv_exeext
+rm -f a.out a.exe "conftest$ac_cv_exeext"
ac_clean_files=$ac_clean_files_save
# Check the compiler produces executables we can run. If not, either
# the compiler is broken, or we cross compile.
-echo "$as_me:1446: checking whether we are cross compiling" >&5
+echo "$as_me:1553: checking whether we are cross compiling" >&5
echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
-echo "$as_me:1448: result: $cross_compiling" >&5
+echo "$as_me:1555: result: $cross_compiling" >&5
echo "${ECHO_T}$cross_compiling" >&6
-echo "$as_me:1451: checking for executable suffix" >&5
+echo "$as_me:1558: checking for executable suffix" >&5
echo $ECHO_N "checking for executable suffix... $ECHO_C" >&6
-if { (eval echo "$as_me:1453: \"$ac_link\"") >&5
+if { (eval echo "$as_me:1560: \"$ac_link\"") >&5
(eval $ac_link) 2>&5
ac_status=$?
- echo "$as_me:1456: \$? = $ac_status" >&5
- (exit $ac_status); }; then
+ echo "$as_me:1563: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; then
# If both `conftest.exe' and `conftest' are `present' (well, observable)
# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will
# work properly (i.e., refer to `conftest.exe'), while it won't with
esac
done
else
- { { echo "$as_me:1472: error: cannot compute EXEEXT: cannot compile and link" >&5
+ { { echo "$as_me:1579: error: cannot compute EXEEXT: cannot compile and link" >&5
echo "$as_me: error: cannot compute EXEEXT: cannot compile and link" >&2;}
{ (exit 1); exit 1; }; }
fi
-rm -f conftest$ac_cv_exeext
-echo "$as_me:1478: result: $ac_cv_exeext" >&5
+rm -f "conftest$ac_cv_exeext"
+echo "$as_me:1585: result: $ac_cv_exeext" >&5
echo "${ECHO_T}$ac_cv_exeext" >&6
-rm -f conftest.$ac_ext
+rm -f "conftest.$ac_ext"
EXEEXT=$ac_cv_exeext
ac_exeext=$EXEEXT
-echo "$as_me:1484: checking for object suffix" >&5
+echo "$as_me:1591: checking for object suffix" >&5
echo $ECHO_N "checking for object suffix... $ECHO_C" >&6
if test "${ac_cv_objext+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
- cat >conftest.$ac_ext <<_ACEOF
-#line 1490 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 1597 "configure"
#include "confdefs.h"
int
}
_ACEOF
rm -f conftest.o conftest.obj
-if { (eval echo "$as_me:1502: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:1609: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:1505: \$? = $ac_status" >&5
- (exit $ac_status); }; then
+ echo "$as_me:1612: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; then
for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
case $ac_file in
*.$ac_ext | *.xcoff | *.tds | *.d | *.dbg | *.pdb | *.xSYM | *.map | *.inf ) ;;
done
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
-{ { echo "$as_me:1517: error: cannot compute OBJEXT: cannot compile" >&5
+cat "conftest.$ac_ext" >&5
+{ { echo "$as_me:1624: error: cannot compute OBJEXT: cannot compile" >&5
echo "$as_me: error: cannot compute OBJEXT: cannot compile" >&2;}
{ (exit 1); exit 1; }; }
fi
-rm -f conftest.$ac_cv_objext conftest.$ac_ext
+rm -f "conftest.$ac_cv_objext" "conftest.$ac_ext"
fi
-echo "$as_me:1524: result: $ac_cv_objext" >&5
+echo "$as_me:1631: result: $ac_cv_objext" >&5
echo "${ECHO_T}$ac_cv_objext" >&6
OBJEXT=$ac_cv_objext
ac_objext=$OBJEXT
-echo "$as_me:1528: checking whether we are using the GNU C compiler" >&5
+echo "$as_me:1635: checking whether we are using the GNU C compiler" >&5
echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
if test "${ac_cv_c_compiler_gnu+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
- cat >conftest.$ac_ext <<_ACEOF
-#line 1534 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 1641 "configure"
#include "confdefs.h"
int
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:1549: \"$ac_compile\"") >&5
+rm -f "conftest.$ac_objext"
+if { (eval echo "$as_me:1656: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:1552: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest.$ac_objext'
- { (eval echo "$as_me:1555: \"$ac_try\"") >&5
+ echo "$as_me:1659: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest.$ac_objext"'
+ { (eval echo "$as_me:1662: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:1558: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:1665: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
ac_compiler_gnu=yes
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
ac_compiler_gnu=no
fi
-rm -f conftest.$ac_objext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest.$ac_ext"
ac_cv_c_compiler_gnu=$ac_compiler_gnu
fi
-echo "$as_me:1570: result: $ac_cv_c_compiler_gnu" >&5
+echo "$as_me:1677: result: $ac_cv_c_compiler_gnu" >&5
echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
GCC=`test $ac_compiler_gnu = yes && echo yes`
ac_test_CFLAGS=${CFLAGS+set}
ac_save_CFLAGS=$CFLAGS
CFLAGS="-g"
-echo "$as_me:1576: checking whether $CC accepts -g" >&5
+echo "$as_me:1683: checking whether $CC accepts -g" >&5
echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
if test "${ac_cv_prog_cc_g+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
- cat >conftest.$ac_ext <<_ACEOF
-#line 1582 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 1689 "configure"
#include "confdefs.h"
int
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:1594: \"$ac_compile\"") >&5
+rm -f "conftest.$ac_objext"
+if { (eval echo "$as_me:1701: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:1597: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest.$ac_objext'
- { (eval echo "$as_me:1600: \"$ac_try\"") >&5
+ echo "$as_me:1704: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest.$ac_objext"'
+ { (eval echo "$as_me:1707: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:1603: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:1710: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
ac_cv_prog_cc_g=yes
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
ac_cv_prog_cc_g=no
fi
-rm -f conftest.$ac_objext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest.$ac_ext"
fi
-echo "$as_me:1613: result: $ac_cv_prog_cc_g" >&5
+echo "$as_me:1720: result: $ac_cv_prog_cc_g" >&5
echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
if test "$ac_test_CFLAGS" = set; then
CFLAGS=$ac_save_CFLAGS
# in C++ we need to declare it. In case someone uses the same compiler
# for both compiling C and C++ we need to have the C++ compiler decide
# the declaration of exit, since it's the most demanding environment.
-cat >conftest.$ac_ext <<_ACEOF
+cat >"conftest.$ac_ext" <<_ACEOF
#ifndef __cplusplus
choke me
#endif
_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:1640: \"$ac_compile\"") >&5
+rm -f "conftest.$ac_objext"
+if { (eval echo "$as_me:1747: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:1643: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest.$ac_objext'
- { (eval echo "$as_me:1646: \"$ac_try\"") >&5
+ echo "$as_me:1750: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest.$ac_objext"'
+ { (eval echo "$as_me:1753: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:1649: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:1756: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
for ac_declaration in \
''\
'#include <stdlib.h>' \
'extern "C" void exit (int);' \
'void exit (int);'
do
- cat >conftest.$ac_ext <<_ACEOF
-#line 1661 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 1768 "configure"
#include "confdefs.h"
#include <stdlib.h>
$ac_declaration
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:1674: \"$ac_compile\"") >&5
+rm -f "conftest.$ac_objext"
+if { (eval echo "$as_me:1781: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:1677: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest.$ac_objext'
- { (eval echo "$as_me:1680: \"$ac_try\"") >&5
+ echo "$as_me:1784: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest.$ac_objext"'
+ { (eval echo "$as_me:1787: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:1683: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:1790: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
:
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
continue
fi
-rm -f conftest.$ac_objext conftest.$ac_ext
- cat >conftest.$ac_ext <<_ACEOF
-#line 1693 "configure"
+rm -f "conftest.$ac_objext" "conftest.$ac_ext"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 1800 "configure"
#include "confdefs.h"
$ac_declaration
int
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:1705: \"$ac_compile\"") >&5
+rm -f "conftest.$ac_objext"
+if { (eval echo "$as_me:1812: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:1708: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest.$ac_objext'
- { (eval echo "$as_me:1711: \"$ac_try\"") >&5
+ echo "$as_me:1815: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest.$ac_objext"'
+ { (eval echo "$as_me:1818: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:1714: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:1821: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
break
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
fi
-rm -f conftest.$ac_objext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest.$ac_ext"
done
rm -rf conftest*
if test -n "$ac_declaration"; then
echo '#ifdef __cplusplus' >>confdefs.h
- echo $ac_declaration >>confdefs.h
+ echo "$ac_declaration" >>confdefs.h
echo '#endif' >>confdefs.h
fi
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
fi
-rm -f conftest.$ac_objext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest.$ac_ext"
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
+ac_link='$CC -o "conftest$ac_exeext" $CFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
-ac_main_return=return
+ac_main_return="return"
GCC_VERSION=none
if test "$GCC" = yes ; then
- echo "$as_me:1744: checking version of $CC" >&5
+ echo "$as_me:1851: checking version of $CC" >&5
echo $ECHO_N "checking version of $CC... $ECHO_C" >&6
GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC[^)]*) //' -e 's/^.*(Debian[^)]*) //' -e 's/^[^0-9.]*//' -e 's/[^0-9.].*//'`"
test -z "$GCC_VERSION" && GCC_VERSION=unknown
- echo "$as_me:1748: result: $GCC_VERSION" >&5
+ echo "$as_me:1855: result: $GCC_VERSION" >&5
echo "${ECHO_T}$GCC_VERSION" >&6
fi
INTEL_COMPILER=no
if test "$GCC" = yes ; then
- case $host_os in
+ case "$host_os" in
(linux*|gnu*)
- echo "$as_me:1757: checking if this is really Intel C compiler" >&5
+ echo "$as_me:1864: checking if this is really Intel C compiler" >&5
echo $ECHO_N "checking if this is really Intel C compiler... $ECHO_C" >&6
cf_save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -no-gcc"
- cat >conftest.$ac_ext <<_ACEOF
-#line 1762 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 1869 "configure"
#include "confdefs.h"
int
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:1779: \"$ac_compile\"") >&5
+rm -f "conftest.$ac_objext"
+if { (eval echo "$as_me:1886: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:1782: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest.$ac_objext'
- { (eval echo "$as_me:1785: \"$ac_try\"") >&5
+ echo "$as_me:1889: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest.$ac_objext"'
+ { (eval echo "$as_me:1892: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:1788: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:1895: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
INTEL_COMPILER=yes
cf_save_CFLAGS="$cf_save_CFLAGS -we147"
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
fi
-rm -f conftest.$ac_objext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest.$ac_ext"
CFLAGS="$cf_save_CFLAGS"
- echo "$as_me:1799: result: $INTEL_COMPILER" >&5
+ echo "$as_me:1906: result: $INTEL_COMPILER" >&5
echo "${ECHO_T}$INTEL_COMPILER" >&6
;;
esac
CLANG_COMPILER=no
if test "$GCC" = yes ; then
- echo "$as_me:1808: checking if this is really Clang C compiler" >&5
+ echo "$as_me:1915: checking if this is really Clang C compiler" >&5
echo $ECHO_N "checking if this is really Clang C compiler... $ECHO_C" >&6
cf_save_CFLAGS="$CFLAGS"
- cat >conftest.$ac_ext <<_ACEOF
-#line 1812 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 1919 "configure"
#include "confdefs.h"
int
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:1829: \"$ac_compile\"") >&5
+rm -f "conftest.$ac_objext"
+if { (eval echo "$as_me:1936: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:1832: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest.$ac_objext'
- { (eval echo "$as_me:1835: \"$ac_try\"") >&5
+ echo "$as_me:1939: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest.$ac_objext"'
+ { (eval echo "$as_me:1942: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:1838: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:1945: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
CLANG_COMPILER=yes
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
fi
-rm -f conftest.$ac_objext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest.$ac_ext"
CFLAGS="$cf_save_CFLAGS"
- echo "$as_me:1848: result: $CLANG_COMPILER" >&5
+ echo "$as_me:1955: result: $CLANG_COMPILER" >&5
echo "${ECHO_T}$CLANG_COMPILER" >&6
fi
if test "x$CLANG_COMPILER" = "xyes" ; then
case "$CC" in
(c[1-9][0-9]|*/c[1-9][0-9])
- { echo "$as_me:1857: WARNING: replacing broken compiler alias $CC" >&5
+ { echo "$as_me:1964: WARNING: replacing broken compiler alias $CC" >&5
echo "$as_me: WARNING: replacing broken compiler alias $CC" >&2;}
CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`"
CC=clang
;;
esac
- echo "$as_me:1864: checking version of $CC" >&5
+ echo "$as_me:1971: checking version of $CC" >&5
echo $ECHO_N "checking version of $CC... $ECHO_C" >&6
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
- echo "$as_me:1868: result: $CLANG_VERSION" >&5
+ echo "$as_me:1975: result: $CLANG_VERSION" >&5
echo "${ECHO_T}$CLANG_VERSION" >&6
for cf_clang_opt in \
-Qunused-arguments \
-Wno-error=implicit-function-declaration
do
- echo "$as_me:1875: checking if option $cf_clang_opt works" >&5
+ echo "$as_me:1982: checking if option $cf_clang_opt works" >&5
echo $ECHO_N "checking if option $cf_clang_opt works... $ECHO_C" >&6
cf_save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $cf_clang_opt"
- cat >conftest.$ac_ext <<_ACEOF
-#line 1880 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 1987 "configure"
#include "confdefs.h"
#include <stdio.h>
main (void)
{
- printf("hello!\n");
+ printf("hello!\\n");
;
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:1894: \"$ac_link\"") >&5
+rm -f "conftest.$ac_objext" "conftest$ac_exeext"
+if { (eval echo "$as_me:2001: \"$ac_link\"") >&5
(eval $ac_link) 2>&5
ac_status=$?
- echo "$as_me:1897: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest$ac_exeext'
- { (eval echo "$as_me:1900: \"$ac_try\"") >&5
+ echo "$as_me:2004: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest$ac_exeext"'
+ { (eval echo "$as_me:2007: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:1903: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:2010: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
cf_clang_optok=yes
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
cf_clang_optok=no
fi
-rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
- echo "$as_me:1914: result: $cf_clang_optok" >&5
+rm -f "conftest.$ac_objext" "conftest$ac_exeext" "conftest.$ac_ext"
+ echo "$as_me:2021: result: $cf_clang_optok" >&5
echo "${ECHO_T}$cf_clang_optok" >&6
CFLAGS="$cf_save_CFLAGS"
- if test $cf_clang_optok = yes; then
+ if test "$cf_clang_optok" = yes; then
test -n "$verbose" && echo " adding option $cf_clang_opt" 1>&6
-echo "${as_me:-configure}:1920: testing adding option $cf_clang_opt ..." 1>&5
+echo "${as_me:-configure}:2027: testing adding option $cf_clang_opt ..." 1>&5
test -n "$CFLAGS" && CFLAGS="$CFLAGS "
CFLAGS="${CFLAGS}$cf_clang_opt"
done
fi
-echo "$as_me:1929: checking for $CC option to accept ANSI C" >&5
+echo "$as_me:2036: checking for $CC option to accept ANSI C" >&5
echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
if test "${ac_cv_prog_cc_stdc+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
ac_cv_prog_cc_stdc=no
ac_save_CC=$CC
-cat >conftest.$ac_ext <<_ACEOF
-#line 1937 "configure"
+cat >"conftest.$ac_ext" <<_ACEOF
+#line 2044 "configure"
#include "confdefs.h"
#include <stdarg.h>
#include <stdio.h>
for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
do
CC="$ac_save_CC $ac_arg"
- rm -f conftest.$ac_objext
-if { (eval echo "$as_me:1986: \"$ac_compile\"") >&5
+ rm -f "conftest.$ac_objext"
+if { (eval echo "$as_me:2093: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:1989: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest.$ac_objext'
- { (eval echo "$as_me:1992: \"$ac_try\"") >&5
+ echo "$as_me:2096: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest.$ac_objext"'
+ { (eval echo "$as_me:2099: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:1995: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:2102: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
ac_cv_prog_cc_stdc=$ac_arg
break
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
fi
-rm -f conftest.$ac_objext
+rm -f "conftest.$ac_objext"
done
-rm -f conftest.$ac_ext conftest.$ac_objext
+rm -f "conftest.$ac_ext" "conftest.$ac_objext"
CC=$ac_save_CC
fi
case "x$ac_cv_prog_cc_stdc" in
x|xno)
- echo "$as_me:2012: result: none needed" >&5
+ echo "$as_me:2119: result: none needed" >&5
echo "${ECHO_T}none needed" >&6 ;;
*)
- echo "$as_me:2015: result: $ac_cv_prog_cc_stdc" >&5
+ echo "$as_me:2122: result: $ac_cv_prog_cc_stdc" >&5
echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
CC="$CC $ac_cv_prog_cc_stdc" ;;
esac
# This should have been defined by AC_PROG_CC
-: ${CC:=cc}
+: "${CC:=cc}"
-echo "$as_me:2023: checking \$CFLAGS variable" >&5
+echo "$as_me:2130: checking \$CFLAGS variable" >&5
echo $ECHO_N "checking \$CFLAGS variable... $ECHO_C" >&6
case "x$CFLAGS" in
(*-[IUD]*)
- echo "$as_me:2027: result: broken" >&5
+ echo "$as_me:2134: result: broken" >&5
echo "${ECHO_T}broken" >&6
- { echo "$as_me:2029: WARNING: your environment uses the CFLAGS variable to hold CPPFLAGS options" >&5
+ { echo "$as_me:2136: WARNING: your environment uses the CFLAGS variable to hold CPPFLAGS options" >&5
echo "$as_me: WARNING: your environment uses the CFLAGS variable to hold CPPFLAGS options" >&2;}
cf_flags="$CFLAGS"
CFLAGS=
for cf_add_cflags in $cf_arg
do
-case $cf_fix_cppflags in
+case "$cf_fix_cppflags" in
(no)
- case $cf_add_cflags in
+ case "$cf_add_cflags" in
(-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
- case $cf_add_cflags in
+ case "$cf_add_cflags" in
(-D*)
- cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-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
+ if test "$cf_fix_cppflags" = yes ; then
test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
(*$cf_add_cflags)
;;
(*)
- case $cf_add_cflags in
+ case "$cf_add_cflags" in
(-D*)
cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
- cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[^"]*"'\''//'`
+ cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[^"]*"'\''//'`
test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
&& test -z "${cf_tst_cflags}" \
done
;;
(*)
- echo "$as_me:2137: result: ok" >&5
+ echo "$as_me:2244: result: ok" >&5
echo "${ECHO_T}ok" >&6
;;
esac
-echo "$as_me:2142: checking \$CC variable" >&5
+echo "$as_me:2249: checking \$CC variable" >&5
echo $ECHO_N "checking \$CC variable... $ECHO_C" >&6
case "$CC" in
(*[\ \ ]-*)
- echo "$as_me:2146: result: broken" >&5
+ echo "$as_me:2253: result: broken" >&5
echo "${ECHO_T}broken" >&6
- { echo "$as_me:2148: WARNING: your environment uses the CC variable to hold CFLAGS/CPPFLAGS options" >&5
+ { echo "$as_me:2255: WARNING: your environment uses the CC variable to hold CFLAGS/CPPFLAGS options" >&5
echo "$as_me: WARNING: your environment uses the CC variable to hold CFLAGS/CPPFLAGS options" >&2;}
# humor him...
cf_prog=`echo "$CC" | sed -e 's/ / /g' -e 's/[ ]* / /g' -e 's/[ ]*[ ]-[^ ].*//'`
for cf_add_cflags in $cf_arg
do
-case $cf_fix_cppflags in
+case "$cf_fix_cppflags" in
(no)
- case $cf_add_cflags in
+ case "$cf_add_cflags" in
(-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
- case $cf_add_cflags in
+ case "$cf_add_cflags" in
(-D*)
- cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-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
+ if test "$cf_fix_cppflags" = yes ; then
test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
(*$cf_add_cflags)
;;
(*)
- case $cf_add_cflags in
+ case "$cf_add_cflags" in
(-D*)
cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
- cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[^"]*"'\''//'`
+ cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[^"]*"'\''//'`
test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
&& test -z "${cf_tst_cflags}" \
done
test -n "$verbose" && echo " resulting CC: '$CC'" 1>&6
-echo "${as_me:-configure}:2265: testing resulting CC: '$CC' ..." 1>&5
+echo "${as_me:-configure}:2372: testing resulting CC: '$CC' ..." 1>&5
test -n "$verbose" && echo " resulting CFLAGS: '$CFLAGS'" 1>&6
-echo "${as_me:-configure}:2269: testing resulting CFLAGS: '$CFLAGS' ..." 1>&5
+echo "${as_me:-configure}:2376: testing resulting CFLAGS: '$CFLAGS' ..." 1>&5
test -n "$verbose" && echo " resulting CPPFLAGS: '$CPPFLAGS'" 1>&6
-echo "${as_me:-configure}:2273: testing resulting CPPFLAGS: '$CPPFLAGS' ..." 1>&5
+echo "${as_me:-configure}:2380: testing resulting CPPFLAGS: '$CPPFLAGS' ..." 1>&5
;;
(*)
- echo "$as_me:2277: result: ok" >&5
+ echo "$as_me:2384: result: ok" >&5
echo "${ECHO_T}ok" >&6
;;
esac
+echo "$as_me:2389: checking for egrep" >&5
+echo $ECHO_N "checking for egrep... $ECHO_C" >&6
+if test "${ac_cv_path_EGREP+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
+ then ac_cv_path_EGREP="$GREP -E"
+ else
+ for ac_prog in gegrep egrep
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+echo "$as_me:2401: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_path_EGREP+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ case $EGREP in
+ [\\/]* | ?:[\\/]*)
+ ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
+ ;;
+ *)
+ ac_save_IFS=$IFS; IFS=$ac_path_separator
+ac_dummy="$PATH"
+for ac_dir in $ac_dummy; do
+ IFS=$ac_save_IFS
+ test -z "$ac_dir" && ac_dir=.
+ if $as_executable_p "$ac_dir/$ac_word"; then
+ ac_cv_path_EGREP="$ac_dir/$ac_word"
+ echo "$as_me:2418: found $ac_dir/$ac_word" >&5
+ break
+fi
+done
+
+ ;;
+esac
+fi
+EGREP=$ac_cv_path_EGREP
+
+if test -n "$EGREP"; then
+ echo "$as_me:2429: result: $EGREP" >&5
+echo "${ECHO_T}$EGREP" >&6
+else
+ echo "$as_me:2432: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+ test -n "$EGREP" && break
+done
+test -n "$EGREP" || EGREP=": "
+
+ test "x$ac_cv_path_EGREP" = "x:" && { { echo "$as_me:2440: error: cannot find workable egrep" >&5
+echo "$as_me: error: cannot find workable egrep" >&2;}
+ { (exit 1); exit 1; }; }
+ fi
+fi
+echo "$as_me:2445: result: $ac_cv_path_EGREP" >&5
+echo "${ECHO_T}$ac_cv_path_EGREP" >&6
+ EGREP="$ac_cv_path_EGREP"
+
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
+ac_link='$CC -o "conftest$ac_exeext" $CFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
-ac_main_return=return
-echo "$as_me:2288: checking how to run the C preprocessor" >&5
+ac_main_return="return"
+echo "$as_me:2455: checking how to run the C preprocessor" >&5
echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
# On Suns, sometimes $CPP names a directory.
if test -n "$CPP" && test -d "$CPP"; then
# with a fresh cross-compiler works.
# On the NeXT, cc -E runs the code through the compiler's parser,
# not just through cpp. "Syntax error" is here to catch this case.
- cat >conftest.$ac_ext <<_ACEOF
-#line 2309 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 2476 "configure"
#include "confdefs.h"
#include <assert.h>
Syntax error
_ACEOF
-if { (eval echo "$as_me:2314: \"$ac_cpp conftest.$ac_ext\"") >&5
- (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+if { (eval echo "$as_me:2481: \"$ac_cpp "conftest.$ac_ext"\"") >&5
+ (eval $ac_cpp "conftest.$ac_ext") 2>conftest.er1
ac_status=$?
- egrep -v '^ *\+' conftest.er1 >conftest.err
+ $EGREP -v '^ *\+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
- echo "$as_me:2320: \$? = $ac_status" >&5
- (exit $ac_status); } >/dev/null; then
+ echo "$as_me:2487: \$? = $ac_status" >&5
+ (exit "$ac_status"); } >/dev/null; then
if test -s conftest.err; then
ac_cpp_err=$ac_c_preproc_warn_flag
else
:
else
echo "$as_me: failed program was:" >&5
- cat conftest.$ac_ext >&5
+ cat "conftest.$ac_ext" >&5
# Broken: fails on valid input.
continue
fi
-rm -f conftest.err conftest.$ac_ext
+rm -f conftest.err "conftest.$ac_ext"
# OK, works on sane cases. Now check whether non-existent headers
# can be detected and how.
- cat >conftest.$ac_ext <<_ACEOF
-#line 2343 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 2510 "configure"
#include "confdefs.h"
#include <ac_nonexistent.h>
_ACEOF
-if { (eval echo "$as_me:2347: \"$ac_cpp conftest.$ac_ext\"") >&5
- (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+if { (eval echo "$as_me:2514: \"$ac_cpp "conftest.$ac_ext"\"") >&5
+ (eval $ac_cpp "conftest.$ac_ext") 2>conftest.er1
ac_status=$?
- egrep -v '^ *\+' conftest.er1 >conftest.err
+ $EGREP -v '^ *\+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
- echo "$as_me:2353: \$? = $ac_status" >&5
- (exit $ac_status); } >/dev/null; then
+ echo "$as_me:2520: \$? = $ac_status" >&5
+ (exit "$ac_status"); } >/dev/null; then
if test -s conftest.err; then
ac_cpp_err=$ac_c_preproc_warn_flag
else
continue
else
echo "$as_me: failed program was:" >&5
- cat conftest.$ac_ext >&5
+ cat "conftest.$ac_ext" >&5
# Passes both tests.
ac_preproc_ok=:
break
fi
-rm -f conftest.err conftest.$ac_ext
+rm -f conftest.err "conftest.$ac_ext"
done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-rm -f conftest.err conftest.$ac_ext
+rm -f conftest.err "conftest.$ac_ext"
if $ac_preproc_ok; then
break
fi
else
ac_cv_prog_CPP=$CPP
fi
-echo "$as_me:2390: result: $CPP" >&5
+echo "$as_me:2557: result: $CPP" >&5
echo "${ECHO_T}$CPP" >&6
ac_preproc_ok=false
for ac_c_preproc_warn_flag in '' yes
# with a fresh cross-compiler works.
# On the NeXT, cc -E runs the code through the compiler's parser,
# not just through cpp. "Syntax error" is here to catch this case.
- cat >conftest.$ac_ext <<_ACEOF
-#line 2400 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 2567 "configure"
#include "confdefs.h"
#include <assert.h>
Syntax error
_ACEOF
-if { (eval echo "$as_me:2405: \"$ac_cpp conftest.$ac_ext\"") >&5
- (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+if { (eval echo "$as_me:2572: \"$ac_cpp "conftest.$ac_ext"\"") >&5
+ (eval $ac_cpp "conftest.$ac_ext") 2>conftest.er1
ac_status=$?
- egrep -v '^ *\+' conftest.er1 >conftest.err
+ $EGREP -v '^ *\+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
- echo "$as_me:2411: \$? = $ac_status" >&5
- (exit $ac_status); } >/dev/null; then
+ echo "$as_me:2578: \$? = $ac_status" >&5
+ (exit "$ac_status"); } >/dev/null; then
if test -s conftest.err; then
ac_cpp_err=$ac_c_preproc_warn_flag
else
:
else
echo "$as_me: failed program was:" >&5
- cat conftest.$ac_ext >&5
+ cat "conftest.$ac_ext" >&5
# Broken: fails on valid input.
continue
fi
-rm -f conftest.err conftest.$ac_ext
+rm -f conftest.err "conftest.$ac_ext"
# OK, works on sane cases. Now check whether non-existent headers
# can be detected and how.
- cat >conftest.$ac_ext <<_ACEOF
-#line 2434 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 2601 "configure"
#include "confdefs.h"
#include <ac_nonexistent.h>
_ACEOF
-if { (eval echo "$as_me:2438: \"$ac_cpp conftest.$ac_ext\"") >&5
- (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+if { (eval echo "$as_me:2605: \"$ac_cpp "conftest.$ac_ext"\"") >&5
+ (eval $ac_cpp "conftest.$ac_ext") 2>conftest.er1
ac_status=$?
- egrep -v '^ *\+' conftest.er1 >conftest.err
+ $EGREP -v '^ *\+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
- echo "$as_me:2444: \$? = $ac_status" >&5
- (exit $ac_status); } >/dev/null; then
+ echo "$as_me:2611: \$? = $ac_status" >&5
+ (exit "$ac_status"); } >/dev/null; then
if test -s conftest.err; then
ac_cpp_err=$ac_c_preproc_warn_flag
else
continue
else
echo "$as_me: failed program was:" >&5
- cat conftest.$ac_ext >&5
+ cat "conftest.$ac_ext" >&5
# Passes both tests.
ac_preproc_ok=:
break
fi
-rm -f conftest.err conftest.$ac_ext
+rm -f conftest.err "conftest.$ac_ext"
done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-rm -f conftest.err conftest.$ac_ext
+rm -f conftest.err "conftest.$ac_ext"
if $ac_preproc_ok; then
:
else
- { { echo "$as_me:2472: error: C preprocessor \"$CPP\" fails sanity check" >&5
+ { { echo "$as_me:2639: error: C preprocessor \"$CPP\" fails sanity check" >&5
echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check" >&2;}
{ (exit 1); exit 1; }; }
fi
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
+ac_link='$CC -o "conftest$ac_exeext" $CFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
-ac_main_return=return
+ac_main_return="return"
if test $ac_cv_c_compiler_gnu = yes; then
- echo "$as_me:2485: checking whether $CC needs -traditional" >&5
+ echo "$as_me:2652: checking whether $CC needs -traditional" >&5
echo $ECHO_N "checking whether $CC needs -traditional... $ECHO_C" >&6
if test "${ac_cv_prog_gcc_traditional+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
ac_pattern="Autoconf.*'x'"
- cat >conftest.$ac_ext <<_ACEOF
-#line 2492 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 2659 "configure"
#include "confdefs.h"
#include <sgtty.h>
int Autoconf = TIOCGETP;
_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
- egrep "$ac_pattern" >/dev/null 2>&1; then
+ $EGREP "$ac_pattern" >/dev/null 2>&1; then
ac_cv_prog_gcc_traditional=yes
else
ac_cv_prog_gcc_traditional=no
rm -rf conftest*
if test $ac_cv_prog_gcc_traditional = no; then
- cat >conftest.$ac_ext <<_ACEOF
-#line 2507 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 2674 "configure"
#include "confdefs.h"
#include <termio.h>
int Autoconf = TCGETA;
_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
- egrep "$ac_pattern" >/dev/null 2>&1; then
+ $EGREP "$ac_pattern" >/dev/null 2>&1; then
ac_cv_prog_gcc_traditional=yes
fi
rm -rf conftest*
fi
fi
-echo "$as_me:2520: result: $ac_cv_prog_gcc_traditional" >&5
+echo "$as_me:2687: result: $ac_cv_prog_gcc_traditional" >&5
echo "${ECHO_T}$ac_cv_prog_gcc_traditional" >&6
if test $ac_cv_prog_gcc_traditional = yes; then
CC="$CC -traditional"
fi
fi
-echo "$as_me:2527: checking whether $CC understands -c and -o together" >&5
+echo "$as_me:2694: checking whether $CC understands -c and -o together" >&5
echo $ECHO_N "checking whether $CC understands -c and -o together... $ECHO_C" >&6
if test "${cf_cv_prog_CC_c_o+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
# We do the test twice because some compilers refuse to overwrite an
# existing .o file with -o, though they will create one.
ac_try='$CC $CFLAGS $CPPFLAGS -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
-if { (eval echo "$as_me:2542: \"$ac_try\"") >&5
+if { (eval echo "$as_me:2709: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:2545: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- test -f conftest2.$ac_objext && { (eval echo "$as_me:2547: \"$ac_try\"") >&5
+ echo "$as_me:2712: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ test -f conftest2.$ac_objext && { (eval echo "$as_me:2714: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:2550: \$? = $ac_status" >&5
- (exit $ac_status); };
+ echo "$as_me:2717: \$? = $ac_status" >&5
+ (exit "$ac_status"); };
then
eval cf_cv_prog_CC_c_o=yes
else
eval cf_cv_prog_CC_c_o=no
fi
-rm -rf conftest*
+rm -rf ./conftest*
fi
-if test $cf_cv_prog_CC_c_o = yes; then
- echo "$as_me:2561: result: yes" >&5
+if test "$cf_cv_prog_CC_c_o" = yes; then
+ echo "$as_me:2728: result: yes" >&5
echo "${ECHO_T}yes" >&6
else
- echo "$as_me:2564: result: no" >&5
+ echo "$as_me:2731: result: no" >&5
echo "${ECHO_T}no" >&6
fi
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
-echo "$as_me:2585: checking for $ac_word" >&5
+echo "$as_me:2752: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_AWK+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
$as_executable_p "$ac_dir/$ac_word" || continue
ac_cv_prog_AWK="$ac_prog"
-echo "$as_me:2600: found $ac_dir/$ac_word" >&5
+echo "$as_me:2767: found $ac_dir/$ac_word" >&5
break
done
fi
AWK=$ac_cv_prog_AWK
if test -n "$AWK"; then
- echo "$as_me:2608: result: $AWK" >&5
+ echo "$as_me:2775: result: $AWK" >&5
echo "${ECHO_T}$AWK" >&6
else
- echo "$as_me:2611: result: no" >&5
+ echo "$as_me:2778: result: no" >&5
echo "${ECHO_T}no" >&6
fi
test -n "$AWK" && break
done
-test -z "$AWK" && { { echo "$as_me:2618: error: No awk program found" >&5
+test -z "$AWK" && { { echo "$as_me:2785: error: No awk program found" >&5
echo "$as_me: error: No awk program found" >&2;}
{ (exit 1); exit 1; }; }
-echo "$as_me:2622: checking for egrep" >&5
+echo "$as_me:2789: checking for egrep" >&5
echo $ECHO_N "checking for egrep... $ECHO_C" >&6
if test "${ac_cv_prog_egrep+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else ac_cv_prog_egrep='egrep'
fi
fi
-echo "$as_me:2632: result: $ac_cv_prog_egrep" >&5
+echo "$as_me:2799: result: $ac_cv_prog_egrep" >&5
echo "${ECHO_T}$ac_cv_prog_egrep" >&6
EGREP=$ac_cv_prog_egrep
- test -z "$EGREP" && { { echo "$as_me:2636: error: No egrep program found" >&5
+ test -z "$EGREP" && { { echo "$as_me:2803: error: No egrep program found" >&5
echo "$as_me: error: No egrep program found" >&2;}
{ (exit 1); exit 1; }; }
# AFS /usr/afsws/bin/install, which mishandles nonexistent args
# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
# ./install, which can be erroneously created by make from ./install.sh.
-echo "$as_me:2652: checking for a BSD compatible install" >&5
+echo "$as_me:2819: checking for a BSD compatible install" >&5
echo $ECHO_N "checking for a BSD compatible install... $ECHO_C" >&6
if test -z "$INSTALL"; then
if test "${ac_cv_path_install+set}" = set; then
INSTALL=$ac_install_sh
fi
fi
-echo "$as_me:2701: result: $INSTALL" >&5
+echo "$as_me:2868: result: $INSTALL" >&5
echo "${ECHO_T}$INSTALL" >&6
# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
-echo "$as_me:2712: checking whether ln -s works" >&5
+echo "$as_me:2879: checking whether ln -s works" >&5
echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
LN_S=$as_ln_s
if test "$LN_S" = "ln -s"; then
- echo "$as_me:2716: result: yes" >&5
+ echo "$as_me:2883: result: yes" >&5
echo "${ECHO_T}yes" >&6
else
- echo "$as_me:2719: result: no, using $LN_S" >&5
+ echo "$as_me:2886: result: no, using $LN_S" >&5
echo "${ECHO_T}no, using $LN_S" >&6
fi
-echo "$as_me:2723: checking if $LN_S -f options work" >&5
+echo "$as_me:2890: checking if $LN_S -f options work" >&5
echo $ECHO_N "checking if $LN_S -f options work... $ECHO_C" >&6
rm -f conf$$.src conf$$dst
cf_prog_ln_sf=no
fi
rm -f conf$$.dst conf$$src
-echo "$as_me:2735: result: $cf_prog_ln_sf" >&5
+echo "$as_me:2902: result: $cf_prog_ln_sf" >&5
echo "${ECHO_T}$cf_prog_ln_sf" >&6
test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
# AFS /usr/afsws/bin/install, which mishandles nonexistent args
# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
# ./install, which can be erroneously created by make from ./install.sh.
-echo "$as_me:2752: checking for a BSD compatible install" >&5
+echo "$as_me:2919: checking for a BSD compatible install" >&5
echo $ECHO_N "checking for a BSD compatible install... $ECHO_C" >&6
if test -z "$INSTALL"; then
if test "${ac_cv_path_install+set}" = set; then
INSTALL=$ac_install_sh
fi
fi
-echo "$as_me:2801: result: $INSTALL" >&5
+echo "$as_me:2968: result: $INSTALL" >&5
echo "${ECHO_T}$INSTALL" >&6
# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
(/*)
;;
(*)
- cf_dir=`echo $INSTALL | sed -e 's%/[^/]*$%%'`
+ cf_dir=`echo "$INSTALL" | sed -e 's%/[^/]*$%%'`
test -z "$cf_dir" && cf_dir=.
- INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
+ INSTALL="`cd \"$cf_dir\" && pwd`"/"`echo "$INSTALL" | sed -e 's%^.*/%%'`"
;;
esac
-echo "$as_me:2822: checking if you want to install stripped executables" >&5
+echo "$as_me:2989: checking if you want to install stripped executables" >&5
echo $ECHO_N "checking if you want to install stripped executables... $ECHO_C" >&6
# Check whether --enable-stripping or --disable-stripping was given.
enableval="$enable_stripping"
test "$enableval" != no && enableval=yes
if test "$enableval" != "yes" ; then
- with_stripping=no
+ enable_stripping=no
else
- with_stripping=yes
+ enable_stripping=yes
fi
else
enableval=yes
- with_stripping=yes
+ enable_stripping=yes
fi;
-echo "$as_me:2839: result: $with_stripping" >&5
-echo "${ECHO_T}$with_stripping" >&6
+echo "$as_me:3006: result: $enable_stripping" >&5
+echo "${ECHO_T}$enable_stripping" >&6
-if test "$with_stripping" = yes
+if test "$enable_stripping" = yes
then
INSTALL_OPT_S="-s"
else
INSTALL_OPT_S=
fi
-: ${INSTALL:=install}
-echo "$as_me:2850: checking if install accepts -p option" >&5
+: "${INSTALL:=install}"
+echo "$as_me:3017: checking if install accepts -p option" >&5
echo $ECHO_N "checking if install accepts -p option... $ECHO_C" >&6
if test "${cf_cv_install_p+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
- rm -rf conftest*
+ rm -rf ./conftest*
date >conftest.in
mkdir conftest.out
sleep 3
else
cf_cv_install_p=no
fi
- rm -rf conftest*
+ rm -rf ./conftest*
fi
-echo "$as_me:2881: result: $cf_cv_install_p" >&5
+echo "$as_me:3048: result: $cf_cv_install_p" >&5
echo "${ECHO_T}$cf_cv_install_p" >&6
-echo "$as_me:2884: checking if install needs to be told about ownership" >&5
+echo "$as_me:3051: checking if install needs to be told about ownership" >&5
echo $ECHO_N "checking if install needs to be told about ownership... $ECHO_C" >&6
case `$ac_config_guess` in
(*minix)
;;
esac
-echo "$as_me:2895: result: $with_install_o" >&5
+echo "$as_me:3062: result: $with_install_o" >&5
echo "${ECHO_T}$with_install_o" >&6
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'`
+ 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
-echo "$as_me:2904: checking for long file names" >&5
+echo "$as_me:3071: checking for long file names" >&5
echo $ECHO_N "checking for long file names... $ECHO_C" >&6
if test "${ac_cv_sys_long_file_names+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
ac_tmpdirs='/tmp /var/tmp /usr/tmp'
fi
-for ac_dir in . $ac_tmpdirs `eval echo $prefix/lib $exec_prefix/lib` ; do
- test -d $ac_dir || continue
- test -w $ac_dir || continue # It is less confusing to not echo anything here.
+for ac_dir in . $ac_tmpdirs `eval echo "$prefix/lib" "$exec_prefix/lib"` ; do
+ test -d "$ac_dir" || continue
+ test -w "$ac_dir" || continue # It is less confusing to not echo anything here.
ac_xdir=$ac_dir/cf$$
- (umask 077 && mkdir $ac_xdir 2>/dev/null) || continue
+ (umask 077 && mkdir "$ac_xdir" 2>/dev/null) || continue
ac_tf1=$ac_xdir/conftest9012345
ac_tf2=$ac_xdir/conftest9012346
- (echo 1 >$ac_tf1) 2>/dev/null
- (echo 2 >$ac_tf2) 2>/dev/null
- ac_val=`cat $ac_tf1 2>/dev/null`
- if test ! -f $ac_tf1 || test "$ac_val" != 1; then
+ (echo 1 >"$ac_tf1") 2>/dev/null
+ (echo 2 >"$ac_tf2") 2>/dev/null
+ ac_val=`cat "$ac_tf1" 2>/dev/null`
+ if test ! -f "$ac_tf1" || test "$ac_val" != 1; then
ac_cv_sys_long_file_names=no
- rm -rf $ac_xdir 2>/dev/null
+ rm -rf "$ac_xdir" 2>/dev/null
break
fi
- rm -rf $ac_xdir 2>/dev/null
+ rm -rf "$ac_xdir" 2>/dev/null
done
fi
-echo "$as_me:2943: result: $ac_cv_sys_long_file_names" >&5
+echo "$as_me:3110: result: $ac_cv_sys_long_file_names" >&5
echo "${ECHO_T}$ac_cv_sys_long_file_names" >&6
-if test $ac_cv_sys_long_file_names = yes; then
+if test "$ac_cv_sys_long_file_names" = yes; then
cat >>confdefs.h <<\EOF
#define HAVE_LONG_FILE_NAMES 1
# if we find pkg-config, check if we should install the ".pc" files.
-echo "$as_me:2955: checking if you want to use pkg-config" >&5
+echo "$as_me:3122: checking if you want to use pkg-config" >&5
echo $ECHO_N "checking if you want to use pkg-config... $ECHO_C" >&6
# Check whether --with-pkg-config or --without-pkg-config was given.
else
cf_pkg_config=yes
fi;
-echo "$as_me:2965: result: $cf_pkg_config" >&5
+echo "$as_me:3132: result: $cf_pkg_config" >&5
echo "${ECHO_T}$cf_pkg_config" >&6
-case $cf_pkg_config in
+case "$cf_pkg_config" in
(no)
PKG_CONFIG=none
;;
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
-echo "$as_me:2977: checking for $ac_word" >&5
+echo "$as_me:3144: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_path_PKG_CONFIG+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
if $as_executable_p "$ac_dir/$ac_word"; then
ac_cv_path_PKG_CONFIG="$ac_dir/$ac_word"
- echo "$as_me:2994: found $ac_dir/$ac_word" >&5
+ echo "$as_me:3161: found $ac_dir/$ac_word" >&5
break
fi
done
PKG_CONFIG=$ac_cv_path_PKG_CONFIG
if test -n "$PKG_CONFIG"; then
- echo "$as_me:3005: result: $PKG_CONFIG" >&5
+ echo "$as_me:3172: result: $PKG_CONFIG" >&5
echo "${ECHO_T}$PKG_CONFIG" >&6
else
- echo "$as_me:3008: result: no" >&5
+ echo "$as_me:3175: result: no" >&5
echo "${ECHO_T}no" >&6
fi
ac_pt_PKG_CONFIG=$PKG_CONFIG
# Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
-echo "$as_me:3017: checking for $ac_word" >&5
+echo "$as_me:3184: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_path_ac_pt_PKG_CONFIG+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
if $as_executable_p "$ac_dir/$ac_word"; then
ac_cv_path_ac_pt_PKG_CONFIG="$ac_dir/$ac_word"
- echo "$as_me:3034: found $ac_dir/$ac_word" >&5
+ echo "$as_me:3201: found $ac_dir/$ac_word" >&5
break
fi
done
ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
if test -n "$ac_pt_PKG_CONFIG"; then
- echo "$as_me:3046: result: $ac_pt_PKG_CONFIG" >&5
+ echo "$as_me:3213: result: $ac_pt_PKG_CONFIG" >&5
echo "${ECHO_T}$ac_pt_PKG_CONFIG" >&6
else
- echo "$as_me:3049: result: no" >&5
+ echo "$as_me:3216: result: no" >&5
echo "${ECHO_T}no" >&6
fi
;;
(.[a-zA-Z]:[\\/]*) # OS/2 EMX
;;
-(.\${*prefix}*|.\${*dir}*)
+(.\$\{*prefix\}*|.\$\{*dir\}*)
eval PKG_CONFIG="$PKG_CONFIG"
case ".$PKG_CONFIG" in
(.NONE/*)
- PKG_CONFIG=`echo $PKG_CONFIG | sed -e s%NONE%$cf_path_syntax%`
+ PKG_CONFIG=`echo "$PKG_CONFIG" | sed -e s%NONE%$cf_path_syntax%`
;;
esac
;;
(.no|.NONE/*)
- PKG_CONFIG=`echo $PKG_CONFIG | sed -e s%NONE%$cf_path_syntax%`
+ PKG_CONFIG=`echo "$PKG_CONFIG" | sed -e s%NONE%$cf_path_syntax%`
;;
(*)
- { { echo "$as_me:3092: error: expected a pathname, not \"$PKG_CONFIG\"" >&5
+ { { echo "$as_me:3259: error: expected a pathname, not \"$PKG_CONFIG\"" >&5
echo "$as_me: error: expected a pathname, not \"$PKG_CONFIG\"" >&2;}
{ (exit 1); exit 1; }; }
;;
esac
elif test "x$cf_pkg_config" != xno ; then
- { echo "$as_me:3099: WARNING: pkg-config is not installed" >&5
+ { echo "$as_me:3266: WARNING: pkg-config is not installed" >&5
echo "$as_me: WARNING: pkg-config is not installed" >&2;}
fi
-case $PKG_CONFIG in
+case "$PKG_CONFIG" in
(no|none|yes)
- echo "$as_me:3105: checking for pkg-config library directory" >&5
+ echo "$as_me:3272: checking for pkg-config library directory" >&5
echo $ECHO_N "checking for pkg-config library directory... $ECHO_C" >&6
;;
(*)
- echo "$as_me:3109: checking for $PKG_CONFIG library directory" >&5
+ echo "$as_me:3276: checking for $PKG_CONFIG library directory" >&5
echo $ECHO_N "checking for $PKG_CONFIG library directory... $ECHO_C" >&6
;;
esac
test -n "$verbose" && echo " list..." 1>&6
-echo "${as_me:-configure}:3164: testing list... ..." 1>&5
+echo "${as_me:-configure}:3331: testing list... ..." 1>&5
for cf_config in $cf_search_path
do
test -n "$verbose" && echo " checking $cf_config/pkgconfig" 1>&6
-echo "${as_me:-configure}:3170: testing checking $cf_config/pkgconfig ..." 1>&5
+echo "${as_me:-configure}:3337: testing checking $cf_config/pkgconfig ..." 1>&5
- if test -d $cf_config/pkgconfig
+ if test -d "$cf_config/pkgconfig"
then
PKG_CONFIG_LIBDIR=$cf_config/pkgconfig
- echo "$as_me:3175: checking done" >&5
+ echo "$as_me:3342: checking done" >&5
echo $ECHO_N "checking done... $ECHO_C" >&6
break
fi
esac
if test "x$PKG_CONFIG_LIBDIR" != xno ; then
- echo "$as_me:3186: result: $PKG_CONFIG_LIBDIR" >&5
+ echo "$as_me:3353: result: $PKG_CONFIG_LIBDIR" >&5
echo "${ECHO_T}$PKG_CONFIG_LIBDIR" >&6
fi
-echo "$as_me:3190: checking if you want to build test-programs" >&5
+echo "$as_me:3357: checking if you want to build test-programs" >&5
echo $ECHO_N "checking if you want to build test-programs... $ECHO_C" >&6
# Check whether --with-tests or --without-tests was given.
else
cf_with_tests=yes
fi;
-echo "$as_me:3200: result: $cf_with_tests" >&5
+echo "$as_me:3367: result: $cf_with_tests" >&5
echo "${ECHO_T}$cf_with_tests" >&6
-echo "$as_me:3203: checking if we should assume mixed-case filenames" >&5
+echo "$as_me:3370: checking if we should assume mixed-case filenames" >&5
echo $ECHO_N "checking if we should assume mixed-case filenames... $ECHO_C" >&6
# Check whether --enable-mixed-case or --disable-mixed-case was given.
else
enable_mixedcase=auto
fi;
-echo "$as_me:3213: result: $enable_mixedcase" >&5
+echo "$as_me:3380: result: $enable_mixedcase" >&5
echo "${ECHO_T}$enable_mixedcase" >&6
if test "$enable_mixedcase" = "auto" ; then
-echo "$as_me:3217: checking if filesystem supports mixed-case filenames" >&5
+echo "$as_me:3384: checking if filesystem supports mixed-case filenames" >&5
echo $ECHO_N "checking if filesystem supports mixed-case filenames... $ECHO_C" >&6
if test "${cf_cv_mixedcase+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
if test "$cross_compiling" = yes ; then
- case $target_alias in
+ case "$target_alias" in
(*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*)
cf_cv_mixedcase=no
;;
fi
fi
-echo "$as_me:3244: result: $cf_cv_mixedcase" >&5
+echo "$as_me:3411: result: $cf_cv_mixedcase" >&5
echo "${ECHO_T}$cf_cv_mixedcase" >&6
test "$cf_cv_mixedcase" = yes &&
cat >>confdefs.h <<\EOF
fi
# do this after mixed-case option (tags/TAGS is not as important as tic).
-echo "$as_me:3262: checking whether ${MAKE-make} sets \${MAKE}" >&5
+echo "$as_me:3429: checking whether ${MAKE-make} sets \${MAKE}" >&5
echo $ECHO_N "checking whether ${MAKE-make} sets \${MAKE}... $ECHO_C" >&6
set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,./+-,__p_,'`
if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
rm -f conftest.make
fi
if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
- echo "$as_me:3282: result: yes" >&5
+ echo "$as_me:3449: result: yes" >&5
echo "${ECHO_T}yes" >&6
SET_MAKE=
else
- echo "$as_me:3286: result: no" >&5
+ echo "$as_me:3453: result: no" >&5
echo "${ECHO_T}no" >&6
SET_MAKE="MAKE=${MAKE-make}"
fi
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
-echo "$as_me:3295: checking for $ac_word" >&5
+echo "$as_me:3462: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_CTAGS+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
$as_executable_p "$ac_dir/$ac_word" || continue
ac_cv_prog_CTAGS="$ac_prog"
-echo "$as_me:3310: found $ac_dir/$ac_word" >&5
+echo "$as_me:3477: found $ac_dir/$ac_word" >&5
break
done
fi
CTAGS=$ac_cv_prog_CTAGS
if test -n "$CTAGS"; then
- echo "$as_me:3318: result: $CTAGS" >&5
+ echo "$as_me:3485: result: $CTAGS" >&5
echo "${ECHO_T}$CTAGS" >&6
else
- echo "$as_me:3321: result: no" >&5
+ echo "$as_me:3488: result: no" >&5
echo "${ECHO_T}no" >&6
fi
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
-echo "$as_me:3332: checking for $ac_word" >&5
+echo "$as_me:3499: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_ETAGS+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
$as_executable_p "$ac_dir/$ac_word" || continue
ac_cv_prog_ETAGS="$ac_prog"
-echo "$as_me:3347: found $ac_dir/$ac_word" >&5
+echo "$as_me:3514: found $ac_dir/$ac_word" >&5
break
done
fi
ETAGS=$ac_cv_prog_ETAGS
if test -n "$ETAGS"; then
- echo "$as_me:3355: result: $ETAGS" >&5
+ echo "$as_me:3522: result: $ETAGS" >&5
echo "${ECHO_T}$ETAGS" >&6
else
- echo "$as_me:3358: result: no" >&5
+ echo "$as_me:3525: result: no" >&5
echo "${ECHO_T}no" >&6
fi
# Extract the first word of "${CTAGS:-ctags}", so it can be a program name with args.
set dummy ${CTAGS:-ctags}; ac_word=$2
-echo "$as_me:3367: checking for $ac_word" >&5
+echo "$as_me:3534: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_MAKE_LOWER_TAGS+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
$as_executable_p "$ac_dir/$ac_word" || continue
ac_cv_prog_MAKE_LOWER_TAGS="yes"
-echo "$as_me:3382: found $ac_dir/$ac_word" >&5
+echo "$as_me:3549: found $ac_dir/$ac_word" >&5
break
done
fi
MAKE_LOWER_TAGS=$ac_cv_prog_MAKE_LOWER_TAGS
if test -n "$MAKE_LOWER_TAGS"; then
- echo "$as_me:3391: result: $MAKE_LOWER_TAGS" >&5
+ echo "$as_me:3558: result: $MAKE_LOWER_TAGS" >&5
echo "${ECHO_T}$MAKE_LOWER_TAGS" >&6
else
- echo "$as_me:3394: result: no" >&5
+ echo "$as_me:3561: result: no" >&5
echo "${ECHO_T}no" >&6
fi
if test "$cf_cv_mixedcase" = yes ; then
# Extract the first word of "${ETAGS:-etags}", so it can be a program name with args.
set dummy ${ETAGS:-etags}; ac_word=$2
-echo "$as_me:3401: checking for $ac_word" >&5
+echo "$as_me:3568: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_MAKE_UPPER_TAGS+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
$as_executable_p "$ac_dir/$ac_word" || continue
ac_cv_prog_MAKE_UPPER_TAGS="yes"
-echo "$as_me:3416: found $ac_dir/$ac_word" >&5
+echo "$as_me:3583: found $ac_dir/$ac_word" >&5
break
done
fi
MAKE_UPPER_TAGS=$ac_cv_prog_MAKE_UPPER_TAGS
if test -n "$MAKE_UPPER_TAGS"; then
- echo "$as_me:3425: result: $MAKE_UPPER_TAGS" >&5
+ echo "$as_me:3592: result: $MAKE_UPPER_TAGS" >&5
echo "${ECHO_T}$MAKE_UPPER_TAGS" >&6
else
- echo "$as_me:3428: result: no" >&5
+ echo "$as_me:3595: result: no" >&5
echo "${ECHO_T}no" >&6
fi
MAKE_LOWER_TAGS="#"
fi
-echo "$as_me:3448: checking for makeflags variable" >&5
+echo "$as_me:3615: checking for makeflags variable" >&5
echo $ECHO_N "checking for makeflags variable... $ECHO_C" >&6
if test "${cf_cv_makeflags+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
all :
@ echo '.$cf_option'
CF_EOF
- cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | fgrep -v "ing directory" | sed -e 's,[ ]*$,,'`
+ cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | ${FGREP-fgrep} -v "ing directory" | sed -e 's,[ ]*$,,'`
case "$cf_result" in
(.*k|.*kw)
- cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
+ cf_result="`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`"
case "$cf_result" in
(.*CC=*) cf_cv_makeflags=
;;
;;
(*)
-echo "${as_me:-configure}:3478: testing given option \"$cf_option\",no match \"$cf_result\" ..." 1>&5
+echo "${as_me:-configure}:3645: testing given option \"$cf_option\",no match \"$cf_result\" ..." 1>&5
;;
esac
rm -f cf_makeflags.tmp
fi
-echo "$as_me:3486: result: $cf_cv_makeflags" >&5
+echo "$as_me:3653: result: $cf_cv_makeflags" >&5
echo "${ECHO_T}$cf_cv_makeflags" >&6
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
set dummy ${ac_tool_prefix}ranlib; ac_word=$2
-echo "$as_me:3492: checking for $ac_word" >&5
+echo "$as_me:3659: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_RANLIB+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
$as_executable_p "$ac_dir/$ac_word" || continue
ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
-echo "$as_me:3507: found $ac_dir/$ac_word" >&5
+echo "$as_me:3674: found $ac_dir/$ac_word" >&5
break
done
fi
RANLIB=$ac_cv_prog_RANLIB
if test -n "$RANLIB"; then
- echo "$as_me:3515: result: $RANLIB" >&5
+ echo "$as_me:3682: result: $RANLIB" >&5
echo "${ECHO_T}$RANLIB" >&6
else
- echo "$as_me:3518: result: no" >&5
+ echo "$as_me:3685: result: no" >&5
echo "${ECHO_T}no" >&6
fi
ac_ct_RANLIB=$RANLIB
# Extract the first word of "ranlib", so it can be a program name with args.
set dummy ranlib; ac_word=$2
-echo "$as_me:3527: checking for $ac_word" >&5
+echo "$as_me:3694: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
$as_executable_p "$ac_dir/$ac_word" || continue
ac_cv_prog_ac_ct_RANLIB="ranlib"
-echo "$as_me:3542: found $ac_dir/$ac_word" >&5
+echo "$as_me:3709: found $ac_dir/$ac_word" >&5
break
done
fi
ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
if test -n "$ac_ct_RANLIB"; then
- echo "$as_me:3551: result: $ac_ct_RANLIB" >&5
+ echo "$as_me:3718: result: $ac_ct_RANLIB" >&5
echo "${ECHO_T}$ac_ct_RANLIB" >&6
else
- echo "$as_me:3554: result: no" >&5
+ echo "$as_me:3721: result: no" >&5
echo "${ECHO_T}no" >&6
fi
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}ld", so it can be a program name with args.
set dummy ${ac_tool_prefix}ld; ac_word=$2
-echo "$as_me:3566: checking for $ac_word" >&5
+echo "$as_me:3733: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_LD+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
$as_executable_p "$ac_dir/$ac_word" || continue
ac_cv_prog_LD="${ac_tool_prefix}ld"
-echo "$as_me:3581: found $ac_dir/$ac_word" >&5
+echo "$as_me:3748: found $ac_dir/$ac_word" >&5
break
done
fi
LD=$ac_cv_prog_LD
if test -n "$LD"; then
- echo "$as_me:3589: result: $LD" >&5
+ echo "$as_me:3756: result: $LD" >&5
echo "${ECHO_T}$LD" >&6
else
- echo "$as_me:3592: result: no" >&5
+ echo "$as_me:3759: result: no" >&5
echo "${ECHO_T}no" >&6
fi
ac_ct_LD=$LD
# Extract the first word of "ld", so it can be a program name with args.
set dummy ld; ac_word=$2
-echo "$as_me:3601: checking for $ac_word" >&5
+echo "$as_me:3768: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_ac_ct_LD+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
$as_executable_p "$ac_dir/$ac_word" || continue
ac_cv_prog_ac_ct_LD="ld"
-echo "$as_me:3616: found $ac_dir/$ac_word" >&5
+echo "$as_me:3783: found $ac_dir/$ac_word" >&5
break
done
fi
ac_ct_LD=$ac_cv_prog_ac_ct_LD
if test -n "$ac_ct_LD"; then
- echo "$as_me:3625: result: $ac_ct_LD" >&5
+ echo "$as_me:3792: result: $ac_ct_LD" >&5
echo "${ECHO_T}$ac_ct_LD" >&6
else
- echo "$as_me:3628: result: no" >&5
+ echo "$as_me:3795: result: no" >&5
echo "${ECHO_T}no" >&6
fi
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
set dummy ${ac_tool_prefix}ar; ac_word=$2
-echo "$as_me:3640: checking for $ac_word" >&5
+echo "$as_me:3807: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_AR+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
$as_executable_p "$ac_dir/$ac_word" || continue
ac_cv_prog_AR="${ac_tool_prefix}ar"
-echo "$as_me:3655: found $ac_dir/$ac_word" >&5
+echo "$as_me:3822: found $ac_dir/$ac_word" >&5
break
done
fi
AR=$ac_cv_prog_AR
if test -n "$AR"; then
- echo "$as_me:3663: result: $AR" >&5
+ echo "$as_me:3830: result: $AR" >&5
echo "${ECHO_T}$AR" >&6
else
- echo "$as_me:3666: result: no" >&5
+ echo "$as_me:3833: result: no" >&5
echo "${ECHO_T}no" >&6
fi
ac_ct_AR=$AR
# Extract the first word of "ar", so it can be a program name with args.
set dummy ar; ac_word=$2
-echo "$as_me:3675: checking for $ac_word" >&5
+echo "$as_me:3842: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
$as_executable_p "$ac_dir/$ac_word" || continue
ac_cv_prog_ac_ct_AR="ar"
-echo "$as_me:3690: found $ac_dir/$ac_word" >&5
+echo "$as_me:3857: found $ac_dir/$ac_word" >&5
break
done
fi
ac_ct_AR=$ac_cv_prog_ac_ct_AR
if test -n "$ac_ct_AR"; then
- echo "$as_me:3699: result: $ac_ct_AR" >&5
+ echo "$as_me:3866: result: $ac_ct_AR" >&5
echo "${ECHO_T}$ac_ct_AR" >&6
else
- echo "$as_me:3702: result: no" >&5
+ echo "$as_me:3869: result: no" >&5
echo "${ECHO_T}no" >&6
fi
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
set dummy ${ac_tool_prefix}ar; ac_word=$2
-echo "$as_me:3714: checking for $ac_word" >&5
+echo "$as_me:3881: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_AR+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
$as_executable_p "$ac_dir/$ac_word" || continue
ac_cv_prog_AR="${ac_tool_prefix}ar"
-echo "$as_me:3729: found $ac_dir/$ac_word" >&5
+echo "$as_me:3896: found $ac_dir/$ac_word" >&5
break
done
fi
AR=$ac_cv_prog_AR
if test -n "$AR"; then
- echo "$as_me:3737: result: $AR" >&5
+ echo "$as_me:3904: result: $AR" >&5
echo "${ECHO_T}$AR" >&6
else
- echo "$as_me:3740: result: no" >&5
+ echo "$as_me:3907: result: no" >&5
echo "${ECHO_T}no" >&6
fi
ac_ct_AR=$AR
# Extract the first word of "ar", so it can be a program name with args.
set dummy ar; ac_word=$2
-echo "$as_me:3749: checking for $ac_word" >&5
+echo "$as_me:3916: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
$as_executable_p "$ac_dir/$ac_word" || continue
ac_cv_prog_ac_ct_AR="ar"
-echo "$as_me:3764: found $ac_dir/$ac_word" >&5
+echo "$as_me:3931: found $ac_dir/$ac_word" >&5
break
done
fi
ac_ct_AR=$ac_cv_prog_ac_ct_AR
if test -n "$ac_ct_AR"; then
- echo "$as_me:3773: result: $ac_ct_AR" >&5
+ echo "$as_me:3940: result: $ac_ct_AR" >&5
echo "${ECHO_T}$ac_ct_AR" >&6
else
- echo "$as_me:3776: result: no" >&5
+ echo "$as_me:3943: result: no" >&5
echo "${ECHO_T}no" >&6
fi
AR="$ac_cv_prog_AR"
fi
-echo "$as_me:3785: checking for options to update archives" >&5
+echo "$as_me:3952: checking for options to update archives" >&5
echo $ECHO_N "checking for options to update archives... $ECHO_C" >&6
if test "${cf_cv_ar_flags+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
- case $cf_cv_system_name in
+ case "$cf_cv_system_name" in
(*-msvc*)
cf_cv_ar_flags=''
cat >mk_static_lib.sh <<-EOF
fi
fi
- rm -f conftest.$ac_cv_objext
+ rm -f "conftest.$ac_cv_objext"
rm -f conftest.a
- cat >conftest.$ac_ext <<EOF
-#line 3822 "configure"
+ cat >"conftest.$ac_ext" <<EOF
+#line 3989 "configure"
int testdata[3] = { 123, 456, 789 };
EOF
- if { (eval echo "$as_me:3825: \"$ac_compile\"") >&5
+ if { (eval echo "$as_me:3992: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:3828: \$? = $ac_status" >&5
- (exit $ac_status); } ; then
+ echo "$as_me:3995: \$? = $ac_status" >&5
+ (exit "$ac_status"); } ; then
echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&5
- $AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&5 1>/dev/null
+ $AR $ARFLAGS "$cf_ar_flags" conftest.a "conftest.$ac_cv_objext" 2>&5 1>/dev/null
if test -f conftest.a ; then
- cf_cv_ar_flags=$cf_ar_flags
+ cf_cv_ar_flags="$cf_ar_flags"
break
fi
else
test -n "$verbose" && echo " cannot compile test-program" 1>&6
-echo "${as_me:-configure}:3839: testing cannot compile test-program ..." 1>&5
+echo "${as_me:-configure}:4006: testing cannot compile test-program ..." 1>&5
break
fi
done
- rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
+ rm -f conftest.a "conftest.$ac_ext" "conftest.$ac_cv_objext"
;;
esac
fi
-echo "$as_me:3849: result: $cf_cv_ar_flags" >&5
+echo "$as_me:4016: result: $cf_cv_ar_flags" >&5
echo "${ECHO_T}$cf_cv_ar_flags" >&6
if test -n "$ARFLAGS" ; then
ARFLAGS=$cf_cv_ar_flags
fi
- echo "$as_me:3860: checking for PATH separator" >&5
+ echo "$as_me:4027: checking for PATH separator" >&5
echo $ECHO_N "checking for PATH separator... $ECHO_C" >&6
- case $cf_cv_system_name in
+ case "$cf_cv_system_name" in
(os2*) PATH_SEPARATOR=';' ;;
(*) ${PATH_SEPARATOR:=':'} ;;
esac
- echo "$as_me:3867: result: $PATH_SEPARATOR" >&5
+ echo "$as_me:4034: result: $PATH_SEPARATOR" >&5
echo "${ECHO_T}$PATH_SEPARATOR" >&6
-echo "$as_me:3870: checking if you have specified an install-prefix" >&5
+echo "$as_me:4037: checking if you have specified an install-prefix" >&5
echo $ECHO_N "checking if you have specified an install-prefix... $ECHO_C" >&6
# Check whether --with-install-prefix or --without-install-prefix was given.
;;
esac
fi;
-echo "$as_me:3883: result: $DESTDIR" >&5
+echo "$as_me:4050: result: $DESTDIR" >&5
echo "${ECHO_T}$DESTDIR" >&6
###############################################################################
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
-echo "$as_me:3911: checking for $ac_word" >&5
+echo "$as_me:4078: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_BUILD_CC+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
$as_executable_p "$ac_dir/$ac_word" || continue
ac_cv_prog_BUILD_CC="$ac_prog"
-echo "$as_me:3926: found $ac_dir/$ac_word" >&5
+echo "$as_me:4093: found $ac_dir/$ac_word" >&5
break
done
fi
BUILD_CC=$ac_cv_prog_BUILD_CC
if test -n "$BUILD_CC"; then
- echo "$as_me:3934: result: $BUILD_CC" >&5
+ echo "$as_me:4101: result: $BUILD_CC" >&5
echo "${ECHO_T}$BUILD_CC" >&6
else
- echo "$as_me:3937: result: no" >&5
+ echo "$as_me:4104: result: no" >&5
echo "${ECHO_T}no" >&6
fi
test -n "$BUILD_CC" || BUILD_CC="none"
fi;
- echo "$as_me:3946: checking for native build C compiler" >&5
+ echo "$as_me:4113: checking for native build C compiler" >&5
echo $ECHO_N "checking for native build C compiler... $ECHO_C" >&6
- echo "$as_me:3948: result: $BUILD_CC" >&5
+ echo "$as_me:4115: result: $BUILD_CC" >&5
echo "${ECHO_T}$BUILD_CC" >&6
- echo "$as_me:3951: checking for native build C preprocessor" >&5
+ echo "$as_me:4118: checking for native build C preprocessor" >&5
echo $ECHO_N "checking for native build C preprocessor... $ECHO_C" >&6
# Check whether --with-build-cpp or --without-build-cpp was given.
else
BUILD_CPP='${BUILD_CC} -E'
fi;
- echo "$as_me:3961: result: $BUILD_CPP" >&5
+ echo "$as_me:4128: result: $BUILD_CPP" >&5
echo "${ECHO_T}$BUILD_CPP" >&6
- echo "$as_me:3964: checking for native build C flags" >&5
+ echo "$as_me:4131: checking for native build C flags" >&5
echo $ECHO_N "checking for native build C flags... $ECHO_C" >&6
# Check whether --with-build-cflags or --without-build-cflags was given.
withval="$with_build_cflags"
BUILD_CFLAGS="$withval"
fi;
- echo "$as_me:3972: result: $BUILD_CFLAGS" >&5
+ echo "$as_me:4139: result: $BUILD_CFLAGS" >&5
echo "${ECHO_T}$BUILD_CFLAGS" >&6
- echo "$as_me:3975: checking for native build C preprocessor-flags" >&5
+ echo "$as_me:4142: checking for native build C preprocessor-flags" >&5
echo $ECHO_N "checking for native build C preprocessor-flags... $ECHO_C" >&6
# Check whether --with-build-cppflags or --without-build-cppflags was given.
withval="$with_build_cppflags"
BUILD_CPPFLAGS="$withval"
fi;
- echo "$as_me:3983: result: $BUILD_CPPFLAGS" >&5
+ echo "$as_me:4150: result: $BUILD_CPPFLAGS" >&5
echo "${ECHO_T}$BUILD_CPPFLAGS" >&6
- echo "$as_me:3986: checking for native build linker-flags" >&5
+ echo "$as_me:4153: checking for native build linker-flags" >&5
echo $ECHO_N "checking for native build linker-flags... $ECHO_C" >&6
# Check whether --with-build-ldflags or --without-build-ldflags was given.
withval="$with_build_ldflags"
BUILD_LDFLAGS="$withval"
fi;
- echo "$as_me:3994: result: $BUILD_LDFLAGS" >&5
+ echo "$as_me:4161: result: $BUILD_LDFLAGS" >&5
echo "${ECHO_T}$BUILD_LDFLAGS" >&6
- echo "$as_me:3997: checking for native build linker-libraries" >&5
+ echo "$as_me:4164: checking for native build linker-libraries" >&5
echo $ECHO_N "checking for native build linker-libraries... $ECHO_C" >&6
# Check whether --with-build-libs or --without-build-libs was given.
withval="$with_build_libs"
BUILD_LIBS="$withval"
fi;
- echo "$as_me:4005: result: $BUILD_LIBS" >&5
+ echo "$as_me:4172: result: $BUILD_LIBS" >&5
echo "${ECHO_T}$BUILD_LIBS" >&6
# this assumes we're on Unix.
: ${BUILD_CC:='${CC}'}
- if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
- { { echo "$as_me:4015: error: Cross-build requires two compilers.
+ if { test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}'; } ; then
+ { { echo "$as_me:4182: error: Cross-build requires two compilers.
Use --with-build-cc to specify the native compiler." >&5
echo "$as_me: error: Cross-build requires two compilers.
Use --with-build-cc to specify the native compiler." >&2;}
### shared, for example.
cf_list_models=""
-echo "$as_me:4040: checking if you want to build shared C-objects" >&5
+echo "$as_me:4207: checking if you want to build shared C-objects" >&5
echo $ECHO_N "checking if you want to build shared C-objects... $ECHO_C" >&6
# Check whether --with-shared or --without-shared was given.
else
with_shared=no
fi;
-echo "$as_me:4050: result: $with_shared" >&5
+echo "$as_me:4217: result: $with_shared" >&5
echo "${ECHO_T}$with_shared" >&6
test "$with_shared" = "yes" && cf_list_models="$cf_list_models shared"
-echo "$as_me:4054: checking for specified models" >&5
+echo "$as_me:4221: checking for specified models" >&5
echo $ECHO_N "checking for specified models... $ECHO_C" >&6
test -z "$cf_list_models" && cf_list_models=normal
-echo "$as_me:4057: result: $cf_list_models" >&5
+echo "$as_me:4224: result: $cf_list_models" >&5
echo "${ECHO_T}$cf_list_models" >&6
### Use the first model as the default, and save its suffix for use in building
### up test-applications.
-echo "$as_me:4062: checking for default model" >&5
+echo "$as_me:4229: checking for default model" >&5
echo $ECHO_N "checking for default model... $ECHO_C" >&6
DFT_LWR_MODEL=`echo "$cf_list_models" | $AWK '{print $1}'`
-echo "$as_me:4065: result: $DFT_LWR_MODEL" >&5
+echo "$as_me:4232: result: $DFT_LWR_MODEL" >&5
echo "${ECHO_T}$DFT_LWR_MODEL" >&6
DFT_UPR_MODEL=`echo "$DFT_LWR_MODEL" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
-echo "$as_me:4070: checking for specific curses-directory" >&5
+echo "$as_me:4237: checking for specific curses-directory" >&5
echo $ECHO_N "checking for specific curses-directory... $ECHO_C" >&6
# Check whether --with-curses-dir or --without-curses-dir was given.
else
cf_cv_curses_dir=no
fi;
-echo "$as_me:4080: result: $cf_cv_curses_dir" >&5
+echo "$as_me:4247: result: $cf_cv_curses_dir" >&5
echo "${ECHO_T}$cf_cv_curses_dir" >&6
-if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
+if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
then
if test "x$prefix" != xNONE; then
;;
(.[a-zA-Z]:[\\/]*) # OS/2 EMX
;;
-(.\${*prefix}*|.\${*dir}*)
+(.\$\{*prefix\}*|.\$\{*dir\}*)
eval withval="$withval"
case ".$withval" in
(.NONE/*)
- withval=`echo $withval | sed -e s%NONE%$cf_path_syntax%`
+ withval=`echo "$withval" | sed -e s%NONE%$cf_path_syntax%`
;;
esac
;;
(.no|.NONE/*)
- withval=`echo $withval | sed -e s%NONE%$cf_path_syntax%`
+ withval=`echo "$withval" | sed -e s%NONE%$cf_path_syntax%`
;;
(*)
- { { echo "$as_me:4111: error: expected a pathname, not \"$withval\"" >&5
+ { { echo "$as_me:4278: error: expected a pathname, not \"$withval\"" >&5
echo "$as_me: error: expected a pathname, not \"$withval\"" >&2;}
{ (exit 1); exit 1; }; }
;;
if test -n "$cf_cv_curses_dir/include" ; then
for cf_add_incdir in $cf_cv_curses_dir/include
do
- while test $cf_add_incdir != /usr/include
+ while test "$cf_add_incdir" != /usr/include
do
- if test -d $cf_add_incdir
+ if test -d "$cf_add_incdir"
then
cf_have_incdir=no
if test -n "$CFLAGS$CPPFLAGS" ; then
test -n "$CPPFLAGS" && CPPFLAGS="$CPPFLAGS "
CPPFLAGS="${CPPFLAGS}-I$cf_add_incdir"
- cat >conftest.$ac_ext <<_ACEOF
-#line 4147 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 4314 "configure"
#include "confdefs.h"
#include <stdio.h>
int
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:4159: \"$ac_compile\"") >&5
+rm -f "conftest.$ac_objext"
+if { (eval echo "$as_me:4326: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:4162: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest.$ac_objext'
- { (eval echo "$as_me:4165: \"$ac_try\"") >&5
+ echo "$as_me:4329: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest.$ac_objext"'
+ { (eval echo "$as_me:4332: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:4168: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:4335: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
:
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
cf_have_incdir=yes
fi
-rm -f conftest.$ac_objext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest.$ac_ext"
CPPFLAGS=$cf_save_CPPFLAGS
fi
fi
if test "$cf_have_incdir" = no ; then
test -n "$verbose" && echo " adding $cf_add_incdir to include-path" 1>&6
-echo "${as_me:-configure}:4185: testing adding $cf_add_incdir to include-path ..." 1>&5
+echo "${as_me:-configure}:4352: testing adding $cf_add_incdir to include-path ..." 1>&5
CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
- cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
+ 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
if test -n "$cf_cv_curses_dir/lib" ; then
for cf_add_libdir in $cf_cv_curses_dir/lib
do
- if test $cf_add_libdir = /usr/lib ; then
+ if test "$cf_add_libdir" = /usr/lib ; then
:
- elif test -d $cf_add_libdir
+ elif test -d "$cf_add_libdir"
then
cf_have_libdir=no
if test -n "$LDFLAGS$LIBS" ; then
if test "$cf_have_libdir" = no ; then
test -n "$verbose" && echo " adding $cf_add_libdir to library-path" 1>&6
-echo "${as_me:-configure}:4221: testing adding $cf_add_libdir to library-path ..." 1>&5
+echo "${as_me:-configure}:4388: testing adding $cf_add_libdir to library-path ..." 1>&5
LDFLAGS="-L$cf_add_libdir $LDFLAGS"
fi
cf_have_ncuconfig=no
if test "x${PKG_CONFIG:=none}" != xnone; then
- echo "$as_me:4236: checking pkg-config for $cf_ncuconfig_root" >&5
+ echo "$as_me:4403: checking pkg-config for $cf_ncuconfig_root" >&5
echo $ECHO_N "checking pkg-config for $cf_ncuconfig_root... $ECHO_C" >&6
if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
- echo "$as_me:4239: result: yes" >&5
+ echo "$as_me:4406: result: yes" >&5
echo "${ECHO_T}yes" >&6
- echo "$as_me:4242: checking if the $cf_ncuconfig_root package files work" >&5
+ echo "$as_me:4409: checking if the $cf_ncuconfig_root package files work" >&5
echo $ECHO_N "checking if the $cf_ncuconfig_root package files work... $ECHO_C" >&6
cf_have_ncuconfig=unknown
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`
+ 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
for cf_add_cflags in $cf_pkg_cflags
do
-case $cf_fix_cppflags in
+case "$cf_fix_cppflags" in
(no)
- case $cf_add_cflags in
+ case "$cf_add_cflags" in
(-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
- case $cf_add_cflags in
+ case "$cf_add_cflags" in
(-D*)
- cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-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
+ if test "$cf_fix_cppflags" = yes ; then
test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
(*$cf_add_cflags)
;;
(*)
- case $cf_add_cflags in
+ case "$cf_add_cflags" in
(-D*)
cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
- cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[^"]*"'\''//'`
+ cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[^"]*"'\''//'`
test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
&& test -z "${cf_tst_cflags}" \
done
LIBS="$cf_add_libs"
- cat >conftest.$ac_ext <<_ACEOF
-#line 4375 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 4542 "configure"
#include "confdefs.h"
#include <${cf_cv_ncurses_header:-curses.h}>
int
main (void)
{
-initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);
+initscr(); mousemask(0,0); tigetstr((char *)0);
;
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:4387: \"$ac_link\"") >&5
+rm -f "conftest.$ac_objext" "conftest$ac_exeext"
+if { (eval echo "$as_me:4554: \"$ac_link\"") >&5
(eval $ac_link) 2>&5
ac_status=$?
- echo "$as_me:4390: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest$ac_exeext'
- { (eval echo "$as_me:4393: \"$ac_try\"") >&5
+ echo "$as_me:4557: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest$ac_exeext"'
+ { (eval echo "$as_me:4560: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:4396: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:4563: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
if test "$cross_compiling" = yes; then
cf_test_ncuconfig=maybe
else
- cat >conftest.$ac_ext <<_ACEOF
-#line 4402 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 4569 "configure"
#include "confdefs.h"
#include <${cf_cv_ncurses_header:-curses.h}>
int main(void)
{ char *xx = curses_version(); return (xx == 0); }
_ACEOF
-rm -f conftest$ac_exeext
-if { (eval echo "$as_me:4409: \"$ac_link\"") >&5
+rm -f "conftest$ac_exeext"
+if { (eval echo "$as_me:4576: \"$ac_link\"") >&5
(eval $ac_link) 2>&5
ac_status=$?
- echo "$as_me:4412: \$? = $ac_status" >&5
- (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
- { (eval echo "$as_me:4414: \"$ac_try\"") >&5
+ echo "$as_me:4579: \$? = $ac_status" >&5
+ (exit "$ac_status"); } && { ac_try='"./conftest$ac_exeext"'
+ { (eval echo "$as_me:4581: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:4417: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:4584: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
cf_test_ncuconfig=yes
else
echo "$as_me: program exited with status $ac_status" >&5
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
cf_test_ncuconfig=no
fi
-rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+rm -f core ./core.* ./*.core "conftest$ac_exeext" "conftest.$ac_objext" "conftest.$ac_ext"
fi
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
cf_test_ncuconfig=no
fi
-rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest$ac_exeext" "conftest.$ac_ext"
CFLAGS="$cf_save_CFLAGS"
CPPFLAGS="$cf_save_CPPFLAGS"
for cf_add_cflags in $cf_pkg_cflags
do
-case $cf_fix_cppflags in
+case "$cf_fix_cppflags" in
(no)
- case $cf_add_cflags in
+ case "$cf_add_cflags" in
(-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
- case $cf_add_cflags in
+ case "$cf_add_cflags" in
(-D*)
- cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-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
+ if test "$cf_fix_cppflags" = yes ; then
test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
(*$cf_add_cflags)
;;
(*)
- case $cf_add_cflags in
+ case "$cf_add_cflags" in
(-D*)
cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
- cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[^"]*"'\''//'`
+ cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[^"]*"'\''//'`
test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
&& test -z "${cf_tst_cflags}" \
done
LIBS="$cf_add_libs"
- cat >conftest.$ac_ext <<_ACEOF
-#line 4563 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 4730 "configure"
#include "confdefs.h"
#include <${cf_cv_ncurses_header:-curses.h}>
int
main (void)
{
-initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);
+initscr(); mousemask(0,0); tigetstr((char *)0);
;
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:4575: \"$ac_link\"") >&5
+rm -f "conftest.$ac_objext" "conftest$ac_exeext"
+if { (eval echo "$as_me:4742: \"$ac_link\"") >&5
(eval $ac_link) 2>&5
ac_status=$?
- echo "$as_me:4578: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest$ac_exeext'
- { (eval echo "$as_me:4581: \"$ac_try\"") >&5
+ echo "$as_me:4745: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest$ac_exeext"'
+ { (eval echo "$as_me:4748: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:4584: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:4751: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
if test "$cross_compiling" = yes; then
cf_have_ncuconfig=maybe
else
- cat >conftest.$ac_ext <<_ACEOF
-#line 4590 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 4757 "configure"
#include "confdefs.h"
#include <${cf_cv_ncurses_header:-curses.h}>
int main(void)
{ char *xx = curses_version(); return (xx == 0); }
_ACEOF
-rm -f conftest$ac_exeext
-if { (eval echo "$as_me:4597: \"$ac_link\"") >&5
+rm -f "conftest$ac_exeext"
+if { (eval echo "$as_me:4764: \"$ac_link\"") >&5
(eval $ac_link) 2>&5
ac_status=$?
- echo "$as_me:4600: \$? = $ac_status" >&5
- (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
- { (eval echo "$as_me:4602: \"$ac_try\"") >&5
+ echo "$as_me:4767: \$? = $ac_status" >&5
+ (exit "$ac_status"); } && { ac_try='"./conftest$ac_exeext"'
+ { (eval echo "$as_me:4769: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:4605: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:4772: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
cf_have_ncuconfig=yes
else
echo "$as_me: program exited with status $ac_status" >&5
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
cf_have_ncuconfig=no
fi
-rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+rm -f core ./core.* ./*.core "conftest$ac_exeext" "conftest.$ac_objext" "conftest.$ac_ext"
fi
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
cf_have_ncuconfig=no
fi
-rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
- echo "$as_me:4622: result: $cf_have_ncuconfig" >&5
+rm -f "conftest.$ac_objext" "conftest$ac_exeext" "conftest.$ac_ext"
+ echo "$as_me:4789: result: $cf_have_ncuconfig" >&5
echo "${ECHO_T}$cf_have_ncuconfig" >&6
test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
if test "$cf_have_ncuconfig" != "yes"
NCURSES_CONFIG_PKG=$cf_ncuconfig_root
-echo "$as_me:4638: checking for terminfo header" >&5
+echo "$as_me:4805: checking for terminfo header" >&5
echo $ECHO_N "checking for terminfo header... $ECHO_C" >&6
if test "${cf_cv_term_header+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
-case ${cf_cv_ncurses_header} in
+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%'`
;;
for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
do
-cat >conftest.$ac_ext <<_ACEOF
-#line 4656 "configure"
+cat >"conftest.$ac_ext" <<_ACEOF
+#line 4823 "configure"
#include "confdefs.h"
#include <stdio.h>
#include <${cf_cv_ncurses_header:-curses.h}>
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:4671: \"$ac_compile\"") >&5
+rm -f "conftest.$ac_objext"
+if { (eval echo "$as_me:4838: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:4674: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest.$ac_objext'
- { (eval echo "$as_me:4677: \"$ac_try\"") >&5
+ echo "$as_me:4841: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest.$ac_objext"'
+ { (eval echo "$as_me:4844: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:4680: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:4847: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
cf_cv_term_header="$cf_test"
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
cf_cv_term_header=unknown
fi
-rm -f conftest.$ac_objext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest.$ac_ext"
test "$cf_cv_term_header" != unknown && break
done
fi
-echo "$as_me:4696: result: $cf_cv_term_header" >&5
+echo "$as_me:4863: result: $cf_cv_term_header" >&5
echo "${ECHO_T}$cf_cv_term_header" >&6
# Set definitions to allow ifdef'ing to accommodate subdirectories
-case $cf_cv_term_header in
+case "$cf_cv_term_header" in
(*term.h)
cat >>confdefs.h <<\EOF
;;
esac
-case $cf_cv_term_header in
+case "$cf_cv_term_header" in
(ncurses/term.h)
cat >>confdefs.h <<\EOF
fi
else
- echo "$as_me:4731: result: no" >&5
+ echo "$as_me:4898: result: no" >&5
echo "${ECHO_T}no" >&6
NCURSES_CONFIG_PKG=none
fi
do
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
-echo "$as_me:4747: checking for $ac_word" >&5
+echo "$as_me:4914: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_NCURSES_CONFIG+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
$as_executable_p "$ac_dir/$ac_word" || continue
ac_cv_prog_NCURSES_CONFIG="$ac_tool_prefix$ac_prog"
-echo "$as_me:4762: found $ac_dir/$ac_word" >&5
+echo "$as_me:4929: found $ac_dir/$ac_word" >&5
break
done
fi
NCURSES_CONFIG=$ac_cv_prog_NCURSES_CONFIG
if test -n "$NCURSES_CONFIG"; then
- echo "$as_me:4770: result: $NCURSES_CONFIG" >&5
+ echo "$as_me:4937: result: $NCURSES_CONFIG" >&5
echo "${ECHO_T}$NCURSES_CONFIG" >&6
else
- echo "$as_me:4773: result: no" >&5
+ echo "$as_me:4940: result: no" >&5
echo "${ECHO_T}no" >&6
fi
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
-echo "$as_me:4786: checking for $ac_word" >&5
+echo "$as_me:4953: checking for $ac_word" >&5
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
if test "${ac_cv_prog_ac_ct_NCURSES_CONFIG+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
test -z "$ac_dir" && ac_dir=.
$as_executable_p "$ac_dir/$ac_word" || continue
ac_cv_prog_ac_ct_NCURSES_CONFIG="$ac_prog"
-echo "$as_me:4801: found $ac_dir/$ac_word" >&5
+echo "$as_me:4968: found $ac_dir/$ac_word" >&5
break
done
fi
ac_ct_NCURSES_CONFIG=$ac_cv_prog_ac_ct_NCURSES_CONFIG
if test -n "$ac_ct_NCURSES_CONFIG"; then
- echo "$as_me:4809: result: $ac_ct_NCURSES_CONFIG" >&5
+ echo "$as_me:4976: result: $ac_ct_NCURSES_CONFIG" >&5
echo "${ECHO_T}$ac_ct_NCURSES_CONFIG" >&6
else
- echo "$as_me:4812: result: no" >&5
+ echo "$as_me:4979: result: no" >&5
echo "${ECHO_T}no" >&6
fi
for cf_add_cflags in `$NCURSES_CONFIG --cflags`
do
-case $cf_fix_cppflags in
+case "$cf_fix_cppflags" in
(no)
- case $cf_add_cflags in
+ case "$cf_add_cflags" in
(-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
- case $cf_add_cflags in
+ case "$cf_add_cflags" in
(-D*)
- cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-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
+ if test "$cf_fix_cppflags" = yes ; then
test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
(*$cf_add_cflags)
;;
(*)
- case $cf_add_cflags in
+ case "$cf_add_cflags" in
(-D*)
cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
- cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[^"]*"'\''//'`
+ cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[^"]*"'\''//'`
test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
&& test -z "${cf_tst_cflags}" \
# even with config script, some packages use no-override for curses.h
-echo "$as_me:4941: checking if we have identified curses headers" >&5
+echo "$as_me:5108: checking if we have identified curses headers" >&5
echo $ECHO_N "checking if we have identified curses headers... $ECHO_C" >&6
if test "${cf_cv_ncurses_header+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
ncurses.h ncurses/ncurses.h \
curses.h ncurses/curses.h
do
-cat >conftest.$ac_ext <<_ACEOF
-#line 4953 "configure"
+cat >"conftest.$ac_ext" <<_ACEOF
+#line 5120 "configure"
#include "confdefs.h"
#include <${cf_header}>
int
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:4965: \"$ac_compile\"") >&5
+rm -f "conftest.$ac_objext"
+if { (eval echo "$as_me:5132: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:4968: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest.$ac_objext'
- { (eval echo "$as_me:4971: \"$ac_try\"") >&5
+ echo "$as_me:5135: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest.$ac_objext"'
+ { (eval echo "$as_me:5138: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:4974: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:5141: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
cf_cv_ncurses_header=$cf_header; break
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
fi
-rm -f conftest.$ac_objext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest.$ac_ext"
done
fi
-echo "$as_me:4985: result: $cf_cv_ncurses_header" >&5
+echo "$as_me:5152: result: $cf_cv_ncurses_header" >&5
echo "${ECHO_T}$cf_cv_ncurses_header" >&6
if test "$cf_cv_ncurses_header" = none ; then
- { { echo "$as_me:4989: error: No curses header-files found" >&5
+ { { echo "$as_me:5156: error: No curses header-files found" >&5
echo "$as_me: error: No curses header-files found" >&2;}
{ (exit 1); exit 1; }; }
fi
for ac_header in $cf_cv_ncurses_header
do
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
-echo "$as_me:4999: checking for $ac_header" >&5
+echo "$as_me:5166: checking for $ac_header" >&5
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
if eval "test \"\${$as_ac_Header+set}\" = set"; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
- cat >conftest.$ac_ext <<_ACEOF
-#line 5005 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 5172 "configure"
#include "confdefs.h"
#include <$ac_header>
_ACEOF
-if { (eval echo "$as_me:5009: \"$ac_cpp conftest.$ac_ext\"") >&5
- (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+if { (eval echo "$as_me:5176: \"$ac_cpp "conftest.$ac_ext"\"") >&5
+ (eval $ac_cpp "conftest.$ac_ext") 2>conftest.er1
ac_status=$?
- egrep -v '^ *\+' conftest.er1 >conftest.err
+ $EGREP -v '^ *\+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
- echo "$as_me:5015: \$? = $ac_status" >&5
- (exit $ac_status); } >/dev/null; then
+ echo "$as_me:5182: \$? = $ac_status" >&5
+ (exit "$ac_status"); } >/dev/null; then
if test -s conftest.err; then
ac_cpp_err=$ac_c_preproc_warn_flag
else
eval "$as_ac_Header=yes"
else
echo "$as_me: failed program was:" >&5
- cat conftest.$ac_ext >&5
+ cat "conftest.$ac_ext" >&5
eval "$as_ac_Header=no"
fi
-rm -f conftest.err conftest.$ac_ext
+rm -f conftest.err "conftest.$ac_ext"
fi
-echo "$as_me:5034: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
-if test `eval echo '${'$as_ac_Header'}'` = yes; then
+echo "$as_me:5201: result: `eval echo '${'"$as_ac_Header"'}'`" >&5
+echo "${ECHO_T}`eval echo '${'"$as_ac_Header"'}'`" >&6
+if test "`eval echo '${'"$as_ac_Header"'}'`" = yes; then
cat >>confdefs.h <<EOF
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
EOF
#define $cf_nculib_ROOT 1
EOF
- cf_cv_ncurses_version=`$NCURSES_CONFIG --version`
+ cf_cv_ncurses_version="`$NCURSES_CONFIG --version`"
else
if test -n "$cf_cv_curses_dir/include/$cf_ncuhdr_root" ; then
for cf_add_incdir in $cf_cv_curses_dir/include/$cf_ncuhdr_root
do
- while test $cf_add_incdir != /usr/include
+ while test "$cf_add_incdir" != /usr/include
do
- if test -d $cf_add_incdir
+ if test -d "$cf_add_incdir"
then
cf_have_incdir=no
if test -n "$CFLAGS$CPPFLAGS" ; then
test -n "$CPPFLAGS" && CPPFLAGS="$CPPFLAGS "
CPPFLAGS="${CPPFLAGS}-I$cf_add_incdir"
- cat >conftest.$ac_ext <<_ACEOF
-#line 5090 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 5257 "configure"
#include "confdefs.h"
#include <stdio.h>
int
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:5102: \"$ac_compile\"") >&5
+rm -f "conftest.$ac_objext"
+if { (eval echo "$as_me:5269: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:5105: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest.$ac_objext'
- { (eval echo "$as_me:5108: \"$ac_try\"") >&5
+ echo "$as_me:5272: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest.$ac_objext"'
+ { (eval echo "$as_me:5275: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:5111: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:5278: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
:
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
cf_have_incdir=yes
fi
-rm -f conftest.$ac_objext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest.$ac_ext"
CPPFLAGS=$cf_save_CPPFLAGS
fi
fi
if test "$cf_have_incdir" = no ; then
test -n "$verbose" && echo " adding $cf_add_incdir to include-path" 1>&6
-echo "${as_me:-configure}:5128: testing adding $cf_add_incdir to include-path ..." 1>&5
+echo "${as_me:-configure}:5295: testing adding $cf_add_incdir to include-path ..." 1>&5
CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
- cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
+ 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
}
-echo "$as_me:5147: checking for $cf_ncuhdr_root header in include-path" >&5
+echo "$as_me:5314: checking for $cf_ncuhdr_root header in include-path" >&5
echo $ECHO_N "checking for $cf_ncuhdr_root header in include-path... $ECHO_C" >&6
if test "${cf_cv_ncurses_h+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
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"
+ { 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
- cat >conftest.$ac_ext <<_ACEOF
-#line 5159 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 5326 "configure"
#include "confdefs.h"
#include <$cf_header>
#ifdef NCURSES_VERSION
-printf("%s\n", NCURSES_VERSION);
+printf("%s\\n", NCURSES_VERSION);
#else
#ifdef __NCURSES_H
-printf("old\n");
+printf("old\\n");
#else
make an error
#endif
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:5183: \"$ac_compile\"") >&5
+rm -f "conftest.$ac_objext"
+if { (eval echo "$as_me:5350: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:5186: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest.$ac_objext'
- { (eval echo "$as_me:5189: \"$ac_try\"") >&5
+ echo "$as_me:5353: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest.$ac_objext"'
+ { (eval echo "$as_me:5356: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:5192: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:5359: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
cf_cv_ncurses_h=$cf_header
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
cf_cv_ncurses_h=no
fi
-rm -f conftest.$ac_objext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest.$ac_ext"
test "$cf_cv_ncurses_h" != no && break
done
fi
-echo "$as_me:5207: result: $cf_cv_ncurses_h" >&5
+echo "$as_me:5374: result: $cf_cv_ncurses_h" >&5
echo "${ECHO_T}$cf_cv_ncurses_h" >&6
if test "$cf_cv_ncurses_h" != no ; then
cf_cv_ncurses_header=$cf_cv_ncurses_h
else
-echo "$as_me:5214: checking for $cf_ncuhdr_root include-path" >&5
+echo "$as_me:5381: checking for $cf_ncuhdr_root include-path" >&5
echo $ECHO_N "checking for $cf_ncuhdr_root include-path... $ECHO_C" >&6
if test "${cf_cv_ncurses_h2+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
if test -n "${CFLAGS}${CPPFLAGS}" ; then
for cf_header_path in $CPPFLAGS $CFLAGS
do
- case $cf_header_path in
+ case "$cf_header_path" in
(-I*)
cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
test -d "$cf_header_path" && \
{
test -n "$verbose" && echo " ... testing for include-directories under $cf_header_path"
- test -d $cf_header_path/include && cf_search="$cf_search $cf_header_path/include"
- test -d $cf_header_path/include/$cf_ncuhdr_root && cf_search="$cf_search $cf_header_path/include/$cf_ncuhdr_root"
- test -d $cf_header_path/include/$cf_ncuhdr_root/include && cf_search="$cf_search $cf_header_path/include/$cf_ncuhdr_root/include"
- test -d $cf_header_path/$cf_ncuhdr_root/include && cf_search="$cf_search $cf_header_path/$cf_ncuhdr_root/include"
- test -d $cf_header_path/$cf_ncuhdr_root/include/$cf_ncuhdr_root && cf_search="$cf_search $cf_header_path/$cf_ncuhdr_root/include/$cf_ncuhdr_root"
+ test -d "$cf_header_path/include" && cf_search="$cf_search $cf_header_path/include"
+ test -d "$cf_header_path/include/$cf_ncuhdr_root" && cf_search="$cf_search $cf_header_path/include/$cf_ncuhdr_root"
+ test -d "$cf_header_path/include/$cf_ncuhdr_root/include" && cf_search="$cf_search $cf_header_path/include/$cf_ncuhdr_root/include"
+ test -d "$cf_header_path/$cf_ncuhdr_root/include" && cf_search="$cf_search $cf_header_path/$cf_ncuhdr_root/include"
+ test -d "$cf_header_path/$cf_ncuhdr_root/include/$cf_ncuhdr_root" && cf_search="$cf_search $cf_header_path/$cf_ncuhdr_root/include/$cf_ncuhdr_root"
}
cf_header_path_list="$cf_header_path_list $cf_search"
test -d "$prefix" && \
{
test -n "$verbose" && echo " ... testing for include-directories under $prefix"
- test -d $prefix/include && cf_search="$cf_search $prefix/include"
- test -d $prefix/include/$cf_ncuhdr_root && cf_search="$cf_search $prefix/include/$cf_ncuhdr_root"
- test -d $prefix/include/$cf_ncuhdr_root/include && cf_search="$cf_search $prefix/include/$cf_ncuhdr_root/include"
- test -d $prefix/$cf_ncuhdr_root/include && cf_search="$cf_search $prefix/$cf_ncuhdr_root/include"
- test -d $prefix/$cf_ncuhdr_root/include/$cf_ncuhdr_root && cf_search="$cf_search $prefix/$cf_ncuhdr_root/include/$cf_ncuhdr_root"
+ test -d "$prefix/include" && cf_search="$cf_search $prefix/include"
+ test -d "$prefix/include/$cf_ncuhdr_root" && cf_search="$cf_search $prefix/include/$cf_ncuhdr_root"
+ test -d "$prefix/include/$cf_ncuhdr_root/include" && cf_search="$cf_search $prefix/include/$cf_ncuhdr_root/include"
+ test -d "$prefix/$cf_ncuhdr_root/include" && cf_search="$cf_search $prefix/$cf_ncuhdr_root/include"
+ test -d "$prefix/$cf_ncuhdr_root/include/$cf_ncuhdr_root" && cf_search="$cf_search $prefix/$cf_ncuhdr_root/include/$cf_ncuhdr_root"
}
for cf_subdir_prefix in \
test "x$cf_subdir_prefix" != "x$prefix" && \
test -d "$cf_subdir_prefix" && \
-(test -z "$prefix" || test x$prefix = xNONE || test "x$cf_subdir_prefix" != "x$prefix") && {
+{ test -z "$prefix" || test "x$prefix" = xNONE || test "x$cf_subdir_prefix" != "x$prefix"; } && {
test -n "$verbose" && echo " ... testing for include-directories under $cf_subdir_prefix"
- test -d $cf_subdir_prefix/include && cf_search="$cf_search $cf_subdir_prefix/include"
- test -d $cf_subdir_prefix/include/$cf_ncuhdr_root && cf_search="$cf_search $cf_subdir_prefix/include/$cf_ncuhdr_root"
- test -d $cf_subdir_prefix/include/$cf_ncuhdr_root/include && cf_search="$cf_search $cf_subdir_prefix/include/$cf_ncuhdr_root/include"
- test -d $cf_subdir_prefix/$cf_ncuhdr_root/include && cf_search="$cf_search $cf_subdir_prefix/$cf_ncuhdr_root/include"
- test -d $cf_subdir_prefix/$cf_ncuhdr_root/include/$cf_ncuhdr_root && cf_search="$cf_search $cf_subdir_prefix/$cf_ncuhdr_root/include/$cf_ncuhdr_root"
+ test -d "$cf_subdir_prefix/include" && cf_search="$cf_search $cf_subdir_prefix/include"
+ test -d "$cf_subdir_prefix/include/$cf_ncuhdr_root" && cf_search="$cf_search $cf_subdir_prefix/include/$cf_ncuhdr_root"
+ test -d "$cf_subdir_prefix/include/$cf_ncuhdr_root/include" && cf_search="$cf_search $cf_subdir_prefix/include/$cf_ncuhdr_root/include"
+ test -d "$cf_subdir_prefix/$cf_ncuhdr_root/include" && cf_search="$cf_search $cf_subdir_prefix/$cf_ncuhdr_root/include"
+ test -d "$cf_subdir_prefix/$cf_ncuhdr_root/include/$cf_ncuhdr_root" && cf_search="$cf_search $cf_subdir_prefix/$cf_ncuhdr_root/include/$cf_ncuhdr_root"
}
done
test "$includedir" != NONE && \
test "$includedir" != "/usr/include" && \
test -d "$includedir" && {
- test -d $includedir && cf_search="$cf_search $includedir"
- test -d $includedir/$cf_ncuhdr_root && cf_search="$cf_search $includedir/$cf_ncuhdr_root"
+ test -d "$includedir" && cf_search="$cf_search $includedir"
+ test -d "$includedir/$cf_ncuhdr_root" && cf_search="$cf_search $includedir/$cf_ncuhdr_root"
}
test "$oldincludedir" != NONE && \
test "$oldincludedir" != "/usr/include" && \
test -d "$oldincludedir" && {
- test -d $oldincludedir && cf_search="$cf_search $oldincludedir"
- test -d $oldincludedir/$cf_ncuhdr_root && cf_search="$cf_search $oldincludedir/$cf_ncuhdr_root"
+ test -d "$oldincludedir" && cf_search="$cf_search $oldincludedir"
+ test -d "$oldincludedir/$cf_ncuhdr_root" && cf_search="$cf_search $oldincludedir/$cf_ncuhdr_root"
}
cf_search="$cf_search $cf_header_path_list"
- test -n "$verbose" && echo search path $cf_search
+ test -n "$verbose" && echo "search path $cf_search"
cf_save2_CPPFLAGS="$CPPFLAGS"
for cf_incdir in $cf_search
do
if test -n "$cf_incdir" ; then
for cf_add_incdir in $cf_incdir
do
- while test $cf_add_incdir != /usr/include
+ while test "$cf_add_incdir" != /usr/include
do
- if test -d $cf_add_incdir
+ if test -d "$cf_add_incdir"
then
cf_have_incdir=no
if test -n "$CFLAGS$CPPFLAGS" ; then
test -n "$CPPFLAGS" && CPPFLAGS="$CPPFLAGS "
CPPFLAGS="${CPPFLAGS}-I$cf_add_incdir"
- cat >conftest.$ac_ext <<_ACEOF
-#line 5335 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 5502 "configure"
#include "confdefs.h"
#include <stdio.h>
int
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:5347: \"$ac_compile\"") >&5
+rm -f "conftest.$ac_objext"
+if { (eval echo "$as_me:5514: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:5350: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest.$ac_objext'
- { (eval echo "$as_me:5353: \"$ac_try\"") >&5
+ echo "$as_me:5517: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest.$ac_objext"'
+ { (eval echo "$as_me:5520: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:5356: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:5523: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
:
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
cf_have_incdir=yes
fi
-rm -f conftest.$ac_objext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest.$ac_ext"
CPPFLAGS=$cf_save_CPPFLAGS
fi
fi
if test "$cf_have_incdir" = no ; then
test -n "$verbose" && echo " adding $cf_add_incdir to include-path" 1>&6
-echo "${as_me:-configure}:5373: testing adding $cf_add_incdir to include-path ..." 1>&5
+echo "${as_me:-configure}:5540: testing adding $cf_add_incdir to include-path ..." 1>&5
CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
- cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
+ 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
curses.h
do
- cat >conftest.$ac_ext <<_ACEOF
-#line 5396 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 5563 "configure"
#include "confdefs.h"
#include <$cf_header>
#ifdef NCURSES_VERSION
-printf("%s\n", NCURSES_VERSION);
+printf("%s\\n", NCURSES_VERSION);
#else
#ifdef __NCURSES_H
-printf("old\n");
+printf("old\\n");
#else
make an error
#endif
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:5420: \"$ac_compile\"") >&5
+rm -f "conftest.$ac_objext"
+if { (eval echo "$as_me:5587: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:5423: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest.$ac_objext'
- { (eval echo "$as_me:5426: \"$ac_try\"") >&5
+ echo "$as_me:5590: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest.$ac_objext"'
+ { (eval echo "$as_me:5593: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:5429: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:5596: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
cf_cv_ncurses_h2=$cf_header
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
cf_cv_ncurses_h2=no
fi
-rm -f conftest.$ac_objext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest.$ac_ext"
if test "$cf_cv_ncurses_h2" != no ; then
cf_cv_ncurses_h2=$cf_incdir/$cf_header
- test -n "$verbose" && echo $ac_n " ... found $ac_c" 1>&6
+ test -n "$verbose" && echo $ECHO_N " ... found $ECHO_C" 1>&6
break
fi
test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&6
CPPFLAGS="$cf_save2_CPPFLAGS"
test "$cf_cv_ncurses_h2" != no && break
done
- test "$cf_cv_ncurses_h2" = no && { { echo "$as_me:5450: error: not found" >&5
+ test "$cf_cv_ncurses_h2" = no && { { echo "$as_me:5617: error: not found" >&5
echo "$as_me: error: not found" >&2;}
{ (exit 1); exit 1; }; }
fi
-echo "$as_me:5455: result: $cf_cv_ncurses_h2" >&5
+echo "$as_me:5622: result: $cf_cv_ncurses_h2" >&5
echo "${ECHO_T}$cf_cv_ncurses_h2" >&6
- cf_1st_incdir=`echo $cf_cv_ncurses_h2 | sed -e 's%/[^/]*$%%'`
- 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
+ cf_1st_incdir=`echo "$cf_cv_ncurses_h2" | sed -e 's%/[^/]*$%%'`
+ 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
if test -n "$cf_1st_incdir" ; then
for cf_add_incdir in $cf_1st_incdir
do
- while test $cf_add_incdir != /usr/include
+ while test "$cf_add_incdir" != /usr/include
do
- if test -d $cf_add_incdir
+ if test -d "$cf_add_incdir"
then
cf_have_incdir=no
if test -n "$CFLAGS$CPPFLAGS" ; then
test -n "$CPPFLAGS" && CPPFLAGS="$CPPFLAGS "
CPPFLAGS="${CPPFLAGS}-I$cf_add_incdir"
- cat >conftest.$ac_ext <<_ACEOF
-#line 5491 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 5658 "configure"
#include "confdefs.h"
#include <stdio.h>
int
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:5503: \"$ac_compile\"") >&5
+rm -f "conftest.$ac_objext"
+if { (eval echo "$as_me:5670: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:5506: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest.$ac_objext'
- { (eval echo "$as_me:5509: \"$ac_try\"") >&5
+ echo "$as_me:5673: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest.$ac_objext"'
+ { (eval echo "$as_me:5676: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:5512: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:5679: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
:
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
cf_have_incdir=yes
fi
-rm -f conftest.$ac_objext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest.$ac_ext"
CPPFLAGS=$cf_save_CPPFLAGS
fi
fi
if test "$cf_have_incdir" = no ; then
test -n "$verbose" && echo " adding $cf_add_incdir to include-path" 1>&6
-echo "${as_me:-configure}:5529: testing adding $cf_add_incdir to include-path ..." 1>&5
+echo "${as_me:-configure}:5696: testing adding $cf_add_incdir to include-path ..." 1>&5
CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
- cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
+ 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
# Set definitions to allow ifdef'ing for ncurses.h
-case $cf_cv_ncurses_header in
+case "$cf_cv_ncurses_header" in
(*ncurses.h)
cat >>confdefs.h <<\EOF
;;
esac
-case $cf_cv_ncurses_header in
+case "$cf_cv_ncurses_header" in
(ncurses/curses.h|ncurses/ncurses.h)
cat >>confdefs.h <<\EOF
;;
esac
-echo "$as_me:5577: checking for terminfo header" >&5
+echo "$as_me:5744: checking for terminfo header" >&5
echo $ECHO_N "checking for terminfo header... $ECHO_C" >&6
if test "${cf_cv_term_header+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
-case ${cf_cv_ncurses_header} in
+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%'`
;;
for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
do
-cat >conftest.$ac_ext <<_ACEOF
-#line 5595 "configure"
+cat >"conftest.$ac_ext" <<_ACEOF
+#line 5762 "configure"
#include "confdefs.h"
#include <stdio.h>
#include <${cf_cv_ncurses_header:-curses.h}>
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:5610: \"$ac_compile\"") >&5
+rm -f "conftest.$ac_objext"
+if { (eval echo "$as_me:5777: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
- echo "$as_me:5613: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest.$ac_objext'
- { (eval echo "$as_me:5616: \"$ac_try\"") >&5
+ echo "$as_me:5780: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest.$ac_objext"'
+ { (eval echo "$as_me:5783: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:5619: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:5786: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
cf_cv_term_header="$cf_test"
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
cf_cv_term_header=unknown
fi
-rm -f conftest.$ac_objext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest.$ac_ext"
test "$cf_cv_term_header" != unknown && break
done
fi
-echo "$as_me:5635: result: $cf_cv_term_header" >&5
+echo "$as_me:5802: result: $cf_cv_term_header" >&5
echo "${ECHO_T}$cf_cv_term_header" >&6
# Set definitions to allow ifdef'ing to accommodate subdirectories
-case $cf_cv_term_header in
+case "$cf_cv_term_header" in
(*term.h)
cat >>confdefs.h <<\EOF
;;
esac
-case $cf_cv_term_header in
+case "$cf_cv_term_header" in
(ncurses/term.h)
cat >>confdefs.h <<\EOF
#define NCURSES 1
EOF
-echo "$as_me:5673: checking for ncurses version" >&5
+echo "$as_me:5840: checking for ncurses version" >&5
echo $ECHO_N "checking for ncurses version... $ECHO_C" >&6
if test "${cf_cv_ncurses_version+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
cf_cv_ncurses_version=no
cf_tempfile=out$$
- rm -f $cf_tempfile
+ rm -f "$cf_tempfile"
if test "$cross_compiling" = yes; then
# This will not work if the preprocessor splits the line after the
# Autoconf token. The 'unproto' program does that.
- cat > conftest.$ac_ext <<EOF
+ cat > "conftest.$ac_ext" <<EOF
#include <${cf_cv_ncurses_header:-curses.h}>
#undef Autoconf
#ifdef NCURSES_VERSION
#endif
EOF
cf_try="$ac_cpp conftest.$ac_ext 2>&5 | grep '^Autoconf ' >conftest.out"
- { (eval echo "$as_me:5699: \"$cf_try\"") >&5
+ { (eval echo "$as_me:5866: \"$cf_try\"") >&5
(eval $cf_try) 2>&5
ac_status=$?
- echo "$as_me:5702: \$? = $ac_status" >&5
- (exit $ac_status); }
+ echo "$as_me:5869: \$? = $ac_status" >&5
+ (exit "$ac_status"); }
if test -f conftest.out ; then
- cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[^"]*"%%' -e 's%".*%%'`
+ 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
else
- cat >conftest.$ac_ext <<_ACEOF
-#line 5712 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 5879 "configure"
#include "confdefs.h"
#include <${cf_cv_ncurses_header:-curses.h}>
FILE *fp = fopen("$cf_tempfile", "w");
#ifdef NCURSES_VERSION
# ifdef NCURSES_VERSION_PATCH
- fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
+ fprintf(fp, "%s.%d\\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
# else
- fprintf(fp, "%s\n", NCURSES_VERSION);
+ fprintf(fp, "%s\\n", NCURSES_VERSION);
# endif
#else
# ifdef __NCURSES_H
- fprintf(fp, "old\n");
+ fprintf(fp, "old\\n");
# else
make an error
# endif
${cf_cv_main_return:-return}(0);
}
_ACEOF
-rm -f conftest$ac_exeext
-if { (eval echo "$as_me:5737: \"$ac_link\"") >&5
+rm -f "conftest$ac_exeext"
+if { (eval echo "$as_me:5904: \"$ac_link\"") >&5
(eval $ac_link) 2>&5
ac_status=$?
- echo "$as_me:5740: \$? = $ac_status" >&5
- (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
- { (eval echo "$as_me:5742: \"$ac_try\"") >&5
+ echo "$as_me:5907: \$? = $ac_status" >&5
+ (exit "$ac_status"); } && { ac_try='"./conftest$ac_exeext"'
+ { (eval echo "$as_me:5909: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:5745: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:5912: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
cf_cv_ncurses_version=`cat $cf_tempfile`
else
echo "$as_me: program exited with status $ac_status" >&5
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
fi
-rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+rm -f core ./core.* ./*.core "conftest$ac_exeext" "conftest.$ac_objext" "conftest.$ac_ext"
fi
- rm -f $cf_tempfile
+ rm -f "$cf_tempfile"
fi
-echo "$as_me:5759: result: $cf_cv_ncurses_version" >&5
+echo "$as_me:5926: result: $cf_cv_ncurses_version" >&5
echo "${ECHO_T}$cf_cv_ncurses_version" >&6
test "$cf_cv_ncurses_version" = no ||
cat >>confdefs.h <<\EOF
# to link gpm.
cf_ncurses_LIBS=""
cf_ncurses_SAVE="$LIBS"
-echo "$as_me:5772: checking for Gpm_Open in -lgpm" >&5
+echo "$as_me:5939: checking for Gpm_Open in -lgpm" >&5
echo $ECHO_N "checking for Gpm_Open in -lgpm... $ECHO_C" >&6
if test "${ac_cv_lib_gpm_Gpm_Open+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
ac_check_lib_save_LIBS=$LIBS
LIBS="-lgpm $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-#line 5780 "configure"
+cat >"conftest.$ac_ext" <<_ACEOF
+#line 5947 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error. */
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:5799: \"$ac_link\"") >&5
+rm -f "conftest.$ac_objext" "conftest$ac_exeext"
+if { (eval echo "$as_me:5966: \"$ac_link\"") >&5
(eval $ac_link) 2>&5
ac_status=$?
- echo "$as_me:5802: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest$ac_exeext'
- { (eval echo "$as_me:5805: \"$ac_try\"") >&5
+ echo "$as_me:5969: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest$ac_exeext"'
+ { (eval echo "$as_me:5972: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:5808: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:5975: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
ac_cv_lib_gpm_Gpm_Open=yes
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
ac_cv_lib_gpm_Gpm_Open=no
fi
-rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest$ac_exeext" "conftest.$ac_ext"
LIBS=$ac_check_lib_save_LIBS
fi
-echo "$as_me:5819: result: $ac_cv_lib_gpm_Gpm_Open" >&5
+echo "$as_me:5986: result: $ac_cv_lib_gpm_Gpm_Open" >&5
echo "${ECHO_T}$ac_cv_lib_gpm_Gpm_Open" >&6
-if test $ac_cv_lib_gpm_Gpm_Open = yes; then
- echo "$as_me:5822: checking for initscr in -lgpm" >&5
+if test "$ac_cv_lib_gpm_Gpm_Open" = yes; then
+ echo "$as_me:5989: checking for initscr in -lgpm" >&5
echo $ECHO_N "checking for initscr in -lgpm... $ECHO_C" >&6
if test "${ac_cv_lib_gpm_initscr+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
ac_check_lib_save_LIBS=$LIBS
LIBS="-lgpm $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-#line 5830 "configure"
+cat >"conftest.$ac_ext" <<_ACEOF
+#line 5997 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error. */
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:5849: \"$ac_link\"") >&5
+rm -f "conftest.$ac_objext" "conftest$ac_exeext"
+if { (eval echo "$as_me:6016: \"$ac_link\"") >&5
(eval $ac_link) 2>&5
ac_status=$?
- echo "$as_me:5852: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest$ac_exeext'
- { (eval echo "$as_me:5855: \"$ac_try\"") >&5
+ echo "$as_me:6019: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest$ac_exeext"'
+ { (eval echo "$as_me:6022: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:5858: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:6025: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
ac_cv_lib_gpm_initscr=yes
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
ac_cv_lib_gpm_initscr=no
fi
-rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest$ac_exeext" "conftest.$ac_ext"
LIBS=$ac_check_lib_save_LIBS
fi
-echo "$as_me:5869: result: $ac_cv_lib_gpm_initscr" >&5
+echo "$as_me:6036: result: $ac_cv_lib_gpm_initscr" >&5
echo "${ECHO_T}$ac_cv_lib_gpm_initscr" >&6
-if test $ac_cv_lib_gpm_initscr = yes; then
+if test "$ac_cv_lib_gpm_initscr" = yes; then
LIBS="$cf_ncurses_SAVE"
else
cf_ncurses_LIBS="-lgpm"
fi
-case $host_os in
+case "$host_os" in
(freebsd*)
# This is only necessary if you are linking against an obsolete
# version of ncurses (but it should do no harm, since it's static).
if test "$cf_nculib_root" = ncurses ; then
- echo "$as_me:5884: checking for tgoto in -lmytinfo" >&5
+ echo "$as_me:6051: checking for tgoto in -lmytinfo" >&5
echo $ECHO_N "checking for tgoto in -lmytinfo... $ECHO_C" >&6
if test "${ac_cv_lib_mytinfo_tgoto+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
ac_check_lib_save_LIBS=$LIBS
LIBS="-lmytinfo $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-#line 5892 "configure"
+cat >"conftest.$ac_ext" <<_ACEOF
+#line 6059 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error. */
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:5911: \"$ac_link\"") >&5
+rm -f "conftest.$ac_objext" "conftest$ac_exeext"
+if { (eval echo "$as_me:6078: \"$ac_link\"") >&5
(eval $ac_link) 2>&5
ac_status=$?
- echo "$as_me:5914: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest$ac_exeext'
- { (eval echo "$as_me:5917: \"$ac_try\"") >&5
+ echo "$as_me:6081: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest$ac_exeext"'
+ { (eval echo "$as_me:6084: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:5920: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:6087: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
ac_cv_lib_mytinfo_tgoto=yes
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
ac_cv_lib_mytinfo_tgoto=no
fi
-rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest$ac_exeext" "conftest.$ac_ext"
LIBS=$ac_check_lib_save_LIBS
fi
-echo "$as_me:5931: result: $ac_cv_lib_mytinfo_tgoto" >&5
+echo "$as_me:6098: result: $ac_cv_lib_mytinfo_tgoto" >&5
echo "${ECHO_T}$ac_cv_lib_mytinfo_tgoto" >&6
-if test $ac_cv_lib_mytinfo_tgoto = yes; then
+if test "$ac_cv_lib_mytinfo_tgoto" = yes; then
cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"
fi
done
LIBS="$cf_add_libs"
-if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
+if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
then
cf_add_libs="$LIBS"
else
- eval 'cf_cv_have_lib_'$cf_nculib_root'=no'
+ eval 'cf_cv_have_lib_'"$cf_nculib_root"'=no'
cf_libdir=""
- echo "$as_me:5980: checking for initscr" >&5
+ echo "$as_me:6147: checking for initscr" >&5
echo $ECHO_N "checking for initscr... $ECHO_C" >&6
if test "${ac_cv_func_initscr+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
- cat >conftest.$ac_ext <<_ACEOF
-#line 5986 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 6153 "configure"
#include "confdefs.h"
#define initscr autoconf_temporary
#include <limits.h> /* least-intrusive standard header which defines gcc2 __stub macros */
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:6017: \"$ac_link\"") >&5
+rm -f "conftest.$ac_objext" "conftest$ac_exeext"
+if { (eval echo "$as_me:6184: \"$ac_link\"") >&5
(eval $ac_link) 2>&5
ac_status=$?
- echo "$as_me:6020: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest$ac_exeext'
- { (eval echo "$as_me:6023: \"$ac_try\"") >&5
+ echo "$as_me:6187: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest$ac_exeext"'
+ { (eval echo "$as_me:6190: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:6026: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:6193: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
ac_cv_func_initscr=yes
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
ac_cv_func_initscr=no
fi
-rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest$ac_exeext" "conftest.$ac_ext"
fi
-echo "$as_me:6036: result: $ac_cv_func_initscr" >&5
+echo "$as_me:6203: result: $ac_cv_func_initscr" >&5
echo "${ECHO_T}$ac_cv_func_initscr" >&6
-if test $ac_cv_func_initscr = yes; then
- eval 'cf_cv_have_lib_'$cf_nculib_root'=yes'
+if test "$ac_cv_func_initscr" = yes; then
+ eval 'cf_cv_have_lib_'"$cf_nculib_root"'=yes'
else
cf_save_LIBS="$LIBS"
- echo "$as_me:6043: checking for initscr in -l$cf_nculib_root" >&5
+ echo "$as_me:6210: checking for initscr in -l$cf_nculib_root" >&5
echo $ECHO_N "checking for initscr in -l$cf_nculib_root... $ECHO_C" >&6
LIBS="-l$cf_nculib_root $LIBS"
- cat >conftest.$ac_ext <<_ACEOF
-#line 6047 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 6214 "configure"
#include "confdefs.h"
#include <${cf_cv_ncurses_header:-curses.h}>
int
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:6059: \"$ac_link\"") >&5
+rm -f "conftest.$ac_objext" "conftest$ac_exeext"
+if { (eval echo "$as_me:6226: \"$ac_link\"") >&5
(eval $ac_link) 2>&5
ac_status=$?
- echo "$as_me:6062: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest$ac_exeext'
- { (eval echo "$as_me:6065: \"$ac_try\"") >&5
+ echo "$as_me:6229: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest$ac_exeext"'
+ { (eval echo "$as_me:6232: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:6068: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
- echo "$as_me:6070: result: yes" >&5
+ echo "$as_me:6235: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
+ echo "$as_me:6237: result: yes" >&5
echo "${ECHO_T}yes" >&6
- eval 'cf_cv_have_lib_'$cf_nculib_root'=yes'
+ eval 'cf_cv_have_lib_'"$cf_nculib_root"'=yes'
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
-echo "$as_me:6077: result: no" >&5
+cat "conftest.$ac_ext" >&5
+echo "$as_me:6244: result: no" >&5
echo "${ECHO_T}no" >&6
cf_search=
if test -n "${LDFLAGS}${LIBS}" ; then
for cf_library_path in $LDFLAGS $LIBS
do
- case $cf_library_path in
+ case "$cf_library_path" in
(-L*)
cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
test -d "$cf_library_path" && \
{
test -n "$verbose" && echo " ... testing for lib-directories under $cf_library_path"
- test -d $cf_library_path/lib && cf_search="$cf_search $cf_library_path/lib"
- test -d $cf_library_path/lib/$cf_nculib_root && cf_search="$cf_search $cf_library_path/lib/$cf_nculib_root"
- test -d $cf_library_path/lib/$cf_nculib_root/lib && cf_search="$cf_search $cf_library_path/lib/$cf_nculib_root/lib"
- test -d $cf_library_path/$cf_nculib_root/lib && cf_search="$cf_search $cf_library_path/$cf_nculib_root/lib"
- test -d $cf_library_path/$cf_nculib_root/lib/$cf_nculib_root && cf_search="$cf_search $cf_library_path/$cf_nculib_root/lib/$cf_nculib_root"
+ test -d "$cf_library_path/lib" && cf_search="$cf_search $cf_library_path/lib"
+ test -d "$cf_library_path/lib/$cf_nculib_root" && cf_search="$cf_search $cf_library_path/lib/$cf_nculib_root"
+ test -d "$cf_library_path/lib/$cf_nculib_root/lib" && cf_search="$cf_search $cf_library_path/lib/$cf_nculib_root/lib"
+ test -d "$cf_library_path/$cf_nculib_root/lib" && cf_search="$cf_search $cf_library_path/$cf_nculib_root/lib"
+ test -d "$cf_library_path/$cf_nculib_root/lib/$cf_nculib_root" && cf_search="$cf_search $cf_library_path/$cf_nculib_root/lib/$cf_nculib_root"
}
cf_library_path_list="$cf_library_path_list $cf_search"
test -d "$prefix" && \
{
test -n "$verbose" && echo " ... testing for lib-directories under $prefix"
- test -d $prefix/lib && cf_search="$cf_search $prefix/lib"
- test -d $prefix/lib/$cf_nculib_root && cf_search="$cf_search $prefix/lib/$cf_nculib_root"
- test -d $prefix/lib/$cf_nculib_root/lib && cf_search="$cf_search $prefix/lib/$cf_nculib_root/lib"
- test -d $prefix/$cf_nculib_root/lib && cf_search="$cf_search $prefix/$cf_nculib_root/lib"
- test -d $prefix/$cf_nculib_root/lib/$cf_nculib_root && cf_search="$cf_search $prefix/$cf_nculib_root/lib/$cf_nculib_root"
+ test -d "$prefix/lib" && cf_search="$cf_search $prefix/lib"
+ test -d "$prefix/lib/$cf_nculib_root" && cf_search="$cf_search $prefix/lib/$cf_nculib_root"
+ test -d "$prefix/lib/$cf_nculib_root/lib" && cf_search="$cf_search $prefix/lib/$cf_nculib_root/lib"
+ test -d "$prefix/$cf_nculib_root/lib" && cf_search="$cf_search $prefix/$cf_nculib_root/lib"
+ test -d "$prefix/$cf_nculib_root/lib/$cf_nculib_root" && cf_search="$cf_search $prefix/$cf_nculib_root/lib/$cf_nculib_root"
}
for cf_subdir_prefix in \
test "x$cf_subdir_prefix" != "x$prefix" && \
test -d "$cf_subdir_prefix" && \
-(test -z "$prefix" || test x$prefix = xNONE || test "x$cf_subdir_prefix" != "x$prefix") && {
+{ test -z "$prefix" || test "x$prefix" = xNONE || test "x$cf_subdir_prefix" != "x$prefix"; } && {
test -n "$verbose" && echo " ... testing for lib-directories under $cf_subdir_prefix"
- test -d $cf_subdir_prefix/lib && cf_search="$cf_search $cf_subdir_prefix/lib"
- test -d $cf_subdir_prefix/lib/$cf_nculib_root && cf_search="$cf_search $cf_subdir_prefix/lib/$cf_nculib_root"
- test -d $cf_subdir_prefix/lib/$cf_nculib_root/lib && cf_search="$cf_search $cf_subdir_prefix/lib/$cf_nculib_root/lib"
- test -d $cf_subdir_prefix/$cf_nculib_root/lib && cf_search="$cf_search $cf_subdir_prefix/$cf_nculib_root/lib"
- test -d $cf_subdir_prefix/$cf_nculib_root/lib/$cf_nculib_root && cf_search="$cf_search $cf_subdir_prefix/$cf_nculib_root/lib/$cf_nculib_root"
+ test -d "$cf_subdir_prefix/lib" && cf_search="$cf_search $cf_subdir_prefix/lib"
+ test -d "$cf_subdir_prefix/lib/$cf_nculib_root" && cf_search="$cf_search $cf_subdir_prefix/lib/$cf_nculib_root"
+ test -d "$cf_subdir_prefix/lib/$cf_nculib_root/lib" && cf_search="$cf_search $cf_subdir_prefix/lib/$cf_nculib_root/lib"
+ test -d "$cf_subdir_prefix/$cf_nculib_root/lib" && cf_search="$cf_search $cf_subdir_prefix/$cf_nculib_root/lib"
+ test -d "$cf_subdir_prefix/$cf_nculib_root/lib/$cf_nculib_root" && cf_search="$cf_search $cf_subdir_prefix/$cf_nculib_root/lib/$cf_nculib_root"
}
done
for cf_libdir in $cf_search
do
- echo "$as_me:6145: checking for -l$cf_nculib_root in $cf_libdir" >&5
+ echo "$as_me:6312: checking for -l$cf_nculib_root in $cf_libdir" >&5
echo $ECHO_N "checking for -l$cf_nculib_root in $cf_libdir... $ECHO_C" >&6
LIBS="-L$cf_libdir -l$cf_nculib_root $cf_save_LIBS"
- cat >conftest.$ac_ext <<_ACEOF
-#line 6149 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 6316 "configure"
#include "confdefs.h"
#include <${cf_cv_ncurses_header:-curses.h}>
int
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:6161: \"$ac_link\"") >&5
+rm -f "conftest.$ac_objext" "conftest$ac_exeext"
+if { (eval echo "$as_me:6328: \"$ac_link\"") >&5
(eval $ac_link) 2>&5
ac_status=$?
- echo "$as_me:6164: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest$ac_exeext'
- { (eval echo "$as_me:6167: \"$ac_try\"") >&5
+ echo "$as_me:6331: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest$ac_exeext"'
+ { (eval echo "$as_me:6334: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:6170: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
- echo "$as_me:6172: result: yes" >&5
+ echo "$as_me:6337: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
+ echo "$as_me:6339: result: yes" >&5
echo "${ECHO_T}yes" >&6
- eval 'cf_cv_have_lib_'$cf_nculib_root'=yes'
+ eval 'cf_cv_have_lib_'"$cf_nculib_root"'=yes'
break
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
-echo "$as_me:6179: result: no" >&5
+cat "conftest.$ac_ext" >&5
+echo "$as_me:6346: result: no" >&5
echo "${ECHO_T}no" >&6
LIBS="$cf_save_LIBS"
fi
-rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest$ac_exeext" "conftest.$ac_ext"
done
fi
-rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest$ac_exeext" "conftest.$ac_ext"
fi
-eval 'cf_found_library=$cf_cv_have_lib_'$cf_nculib_root
+eval 'cf_found_library="$cf_cv_have_lib_'"$cf_nculib_root"\"
-if test $cf_found_library = no ; then
- { { echo "$as_me:6194: error: Cannot link $cf_nculib_root library" >&5
+if test "$cf_found_library" = no ; then
+ { { echo "$as_me:6361: error: Cannot link $cf_nculib_root library" >&5
echo "$as_me: error: Cannot link $cf_nculib_root library" >&2;}
{ (exit 1); exit 1; }; }
fi
fi
if test -n "$cf_ncurses_LIBS" ; then
- echo "$as_me:6202: checking if we can link $cf_nculib_root without $cf_ncurses_LIBS" >&5
+ echo "$as_me:6369: checking if we can link $cf_nculib_root without $cf_ncurses_LIBS" >&5
echo $ECHO_N "checking if we can link $cf_nculib_root without $cf_ncurses_LIBS... $ECHO_C" >&6
cf_ncurses_SAVE="$LIBS"
for p in $cf_ncurses_LIBS ; do
- q=`echo $LIBS | sed -e "s%$p %%" -e "s%$p$%%"`
+ q=`echo "$LIBS" | sed -e "s%$p %%" -e "s%$p$%%"`
if test "$q" != "$LIBS" ; then
LIBS="$q"
fi
done
- cat >conftest.$ac_ext <<_ACEOF
-#line 6212 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 6379 "configure"
#include "confdefs.h"
#include <${cf_cv_ncurses_header:-curses.h}>
int
main (void)
{
-initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);
+initscr(); mousemask(0,0); tigetstr((char *)0);
;
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:6224: \"$ac_link\"") >&5
+rm -f "conftest.$ac_objext" "conftest$ac_exeext"
+if { (eval echo "$as_me:6391: \"$ac_link\"") >&5
(eval $ac_link) 2>&5
ac_status=$?
- echo "$as_me:6227: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest$ac_exeext'
- { (eval echo "$as_me:6230: \"$ac_try\"") >&5
+ echo "$as_me:6394: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest$ac_exeext"'
+ { (eval echo "$as_me:6397: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:6233: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
- echo "$as_me:6235: result: yes" >&5
+ echo "$as_me:6400: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
+ echo "$as_me:6402: result: yes" >&5
echo "${ECHO_T}yes" >&6
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
-echo "$as_me:6240: result: no" >&5
+cat "conftest.$ac_ext" >&5
+echo "$as_me:6407: result: no" >&5
echo "${ECHO_T}no" >&6
LIBS="$cf_ncurses_SAVE"
fi
-rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
+rm -f "conftest.$ac_objext" "conftest$ac_exeext" "conftest.$ac_ext"
fi
cf_nculib_ROOT=`echo "HAVE_LIB$cf_nculib_root" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
NCURSES_CONFIG=none
fi
-echo "$as_me:6258: checking if you want wide-character code" >&5
+echo "$as_me:6425: checking if you want wide-character code" >&5
echo $ECHO_N "checking if you want wide-character code... $ECHO_C" >&6
# Check whether --enable-widec or --disable-widec was given.
else
with_widec=no
fi;
-echo "$as_me:6268: result: $with_widec" >&5
+echo "$as_me:6435: result: $with_widec" >&5
echo "${ECHO_T}$with_widec" >&6
if test "$with_widec" = yes ; then
-echo "$as_me:6272: checking for multibyte character support" >&5
+echo "$as_me:6439: checking for multibyte character support" >&5
echo $ECHO_N "checking for multibyte character support... $ECHO_C" >&6
if test "${cf_cv_utf8_lib+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
cf_save_LIBS="$LIBS"
- cat >conftest.$ac_ext <<_ACEOF
-#line 6280 "configure"
+ cat >"conftest.$ac_ext" <<_ACEOF
+#line 6447 "configure"
#include "confdefs.h"
#include <stdlib.h>
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:6293: \"$ac_link\"") >&5
+rm -f "conftest.$ac_objext" "conftest$ac_exeext"
+if { (eval echo "$as_me:6460: \"$ac_link\"") >&5
(eval $ac_link) 2>&5
ac_status=$?
- echo "$as_me:6296: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest$ac_exeext'
- { (eval echo "$as_me:6299: \"$ac_try\"") >&5
+ echo "$as_me:6463: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest$ac_exeext"'
+ { (eval echo "$as_me:6466: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:6302: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:6469: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
cf_cv_utf8_lib=yes
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
# If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
# will be set on completion of the AC_TRY_LINK below.
cf_cv_header_path_utf8=
cf_cv_library_path_utf8=
-echo "${as_me:-configure}:6314: testing Starting FIND_LINKAGE(utf8,) ..." 1>&5
+echo "${as_me:-configure}:6481: testing Starting FIND_LINKAGE(utf8,) ..." 1>&5
cf_save_LIBS="$LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-#line 6319 "configure"
+cat >"conftest.$ac_ext" <<_ACEOF
+#line 6486 "configure"
#include "confdefs.h"
#include <libutf8.h>
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:6332: \"$ac_link\"") >&5
+rm -f "conftest.$ac_objext" "conftest$ac_exeext"
+if { (eval echo "$as_me:6499: \"$ac_link\"") >&5
(eval $ac_link) 2>&5
ac_status=$?
- echo "$as_me:6335: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest$ac_exeext'
- { (eval echo "$as_me:6338: \"$ac_try\"") >&5
+ echo "$as_me:6502: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest$ac_exeext"'
+ { (eval echo "$as_me:6505: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:6341: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:6508: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
cf_cv_find_linkage_utf8=yes
cf_cv_header_path_utf8=/usr/include
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
LIBS="-lutf8 $cf_save_LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-#line 6355 "configure"
+cat >"conftest.$ac_ext" <<_ACEOF
+#line 6522 "configure"
#include "confdefs.h"
#include <libutf8.h>
return 0;
}
_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:6368: \"$ac_link\"") >&5
+rm -f "conftest.$ac_objext" "conftest$ac_exeext"
+if { (eval echo "$as_me:6535: \"$ac_link\"") >&5
(eval $ac_link) 2>&5
ac_status=$?
- echo "$as_me:6371: \$? = $ac_status" >&5
- (exit $ac_status); } &&
- { ac_try='test -s conftest$ac_exeext'
- { (eval echo "$as_me:6374: \"$ac_try\"") >&5
+ echo "$as_me:6538: \$? = $ac_status" >&5
+ (exit "$ac_status"); } &&
+ { ac_try='test -s "conftest$ac_exeext"'
+ { (eval echo "$as_me:6541: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
- echo "$as_me:6377: \$? = $ac_status" >&5
- (exit $ac_status); }; }; then
+ echo "$as_me:6544: \$? = $ac_status" >&5
+ (exit "$ac_status"); }; }; then
cf_cv_find_linkage_utf8=yes
cf_cv_header_path_utf8=/usr/include
else
echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
+cat "conftest.$ac_ext" >&5
cf_cv_find_linkage_utf8=no
LIBS="$cf_save_LIBS"
test -n "$verbose" && echo " find linkage for utf8 library" 1>&6
-echo "${as_me:-configure}:6394: testing find linkage for utf8 library ..." 1>&5
+echo "${as_me:-configure}:6561: testing find linkage for utf8 library ..." 1>&5
-echo "${as_me:-configure}:6396: testing Searching for headers in FIND_LINKAGE(utf8,) ..." 1>&5
+echo "${as_me:-configure}:6563: testing Searching for headers in FIND_LINKAGE(utf8,) ..." 1>&5
cf_save_CPPFLAGS="$CPPFLAGS"
cf_test_CPPFLAGS="$CPPFLAGS"
if test -n "${CFLAGS}${CPPFLAGS}" ; then
for cf_header_path in $CPPFLAGS $CFLAGS
do
- case $cf_header_path in
+ case "$cf_header_path" in
(-I*)
cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
test -d "$cf_header_path" && \
{
test -n "$verbose" && echo " ... testing for include-directories under $cf_header_path"
- test -d $cf_header_path/include && cf_search="$cf_search $cf_header_path/include"
- test -d $cf_header_path/include/utf8 && cf_search="$cf_search $cf_header_path/include/utf8"
- test -d $cf_header_path/include/utf8/include && cf_search="$cf_search $cf_header_path/include/utf8/include"
- test -d $cf_header_path/utf8/include && cf_search="$cf_search $cf_header_path/utf8/include"
- test -d $cf_header_path/utf8/include/utf8 && cf_search="$cf_search $cf_header_path/utf8/include/utf8"
+ test -d "$cf_header_path/include" && cf_search="$cf_search $cf_header_path/include"
+ test -d "$cf_header_path/include/utf8" && cf_search="$cf_search $cf_header_path/include/utf8"
+ test -d "$cf_header_path/include/utf8/include" && cf_search="$cf_search $cf_header_path/include/utf8/include"
+ test -d "$cf_header_path/utf8/include" && cf_search="$cf_search $cf_header_path/utf8/include"
+ test -d "$cf_header_path/utf8/include/utf8" && cf_search="$cf_search $cf_header_path/utf8/include/utf8"
}
cf_header_path_list="$cf_header_path_list $cf_search"
test -d "$prefix" && \
{
test -n "$verbose" && echo " ... testing for include-directories under $prefix"
- test -d $prefix/include && cf_search="$cf_search $prefix/include"
- test -d $prefix/include/utf8 && cf_search="$cf_search $prefix/include/utf8"
- test -d $prefix/include/utf8/include && cf_search="$cf_search $prefix/include/utf8/include"
- test -d $prefix/utf8/include && cf_search="$cf_search $prefix/utf8/include"
- test -d $prefix/utf8/include/utf8 && cf_search="$cf_search $prefix/utf8/include/utf8"
+ test -d "$prefix/include" && cf_search="$cf_search $prefix/include"
+ test -d "$prefix/include/utf8" && cf_search="$cf_search $prefix/include/utf8"
+ test -d "$prefix/include/utf8/include" && cf_search="$cf_search $prefix/include/utf8/include"
+ test -d "$prefix/utf8/include" && cf_search="$cf_search $prefix/utf8/include"
+ test -d "$prefix/utf8/include/utf8" && cf_search="$cf_search $prefix/utf8/include/utf8"
}
for cf_subdir_prefix in \
test "x$cf_subdir_prefix" != "x$prefix" && \
test -d "$cf_subdir_prefix" && \
-(test -z "$prefix" || test x$prefix = xNONE || test "x$cf_subdir_prefix" != "x$prefix") && {
+{ test -z "$prefix" || test "x$prefix" = xNONE || test "x$cf_subdir_prefix" != "x$prefix"; } && {
test -n "$verbose" && echo " ... testing for include-directories under $cf_subdir_prefix"
- test -d $cf_subdir_prefix/include && cf_search="$cf_search $cf_subdir_prefix/include"
- test -d $cf_subdir_prefix/include/utf8 && cf_search="$cf_search $cf_subdir_prefix/include/utf8"
- test -d $cf_subdir_prefix/include/utf8/include && cf_search="$cf_search $cf_subdir_prefix/include/utf8/include"
- test -d $cf_subdir_prefix/utf8/include && cf_search="$cf_search $cf_subdir_prefix/utf8/include"
- test -d $cf_subdir_prefix/utf8/include/utf8 && cf_search="$cf_search $cf_subdir_prefix/utf8/include/utf8"
+ test -d "$cf_subdir_prefix/include" && cf_search="$cf_search $cf_subdir_prefix/include"
+ test -d "$cf_subdir_prefix/include/utf8" && cf_search="$cf_search $cf_subdir_prefix/include/utf8"
+ test -d "$cf_subdir_prefix/include/utf8/include" && cf_search="$cf_search $cf_subdir_prefix/include/utf8/include"
+ test -d "$cf_subdir_prefix/utf8/include" && cf_search="$cf_search $cf_subdir_prefix/utf8/include"
+ test -d "$cf_subdir_prefix/utf8/include/utf8" && cf_search="$cf_search $cf_subdir_prefix/utf8/include/utf8"
}
done
test "$includedir" != NONE && \
test "$includedir" != "/usr/include" && \
test -d "$includedir" && {
- test -d $includedir && cf_search="$cf