X-Git-Url: http://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=aclocal.m4;h=490bbed7a557880b4445caef528f5532bacd17a3;hp=efaa3949c2195223706f4e6737b84bb7c3cf6fd0;hb=b1f61d9f3aa244512045a6b02e759825d7049d34;hpb=3a9b6a3bf0269231bef7de74757a910dedd04e0c diff --git a/aclocal.m4 b/aclocal.m4 index efaa3949..490bbed7 100644 --- a/aclocal.m4 +++ b/aclocal.m4 @@ -1,29 +1,41 @@ -dnl***************************************************************************** -dnl Copyright 1996,1997 by Thomas E. Dickey * -dnl All Rights Reserved. * -dnl * -dnl Permission to use, copy, modify, and distribute this software and its * -dnl documentation for any purpose and without fee is hereby granted, provided * -dnl that the above copyright notice appear in all copies and that both that * -dnl copyright notice and this permission notice appear in supporting * -dnl documentation, and that the name of the above listed copyright holder(s) * -dnl not be used in advertising or publicity pertaining to distribution of the * -dnl software without specific, written prior permission. THE ABOVE LISTED * -dnl COPYRIGHT HOLDER(S) DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * -dnl INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * -dnl EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY * -dnl SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER * -dnl RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF * -dnl CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * -dnl CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * -dnl***************************************************************************** -dnl $Id: aclocal.m4,v 1.60 1997/05/10 15:56:16 tom Exp $ +dnl*************************************************************************** +dnl Copyright (c) 1998-2000 Free Software Foundation, Inc. * +dnl * +dnl Permission is hereby granted, free of charge, to any person obtaining a * +dnl copy of this software and associated documentation files (the * +dnl "Software"), to deal in the Software without restriction, including * +dnl without limitation the rights to use, copy, modify, merge, publish, * +dnl distribute, distribute with modifications, sublicense, and/or sell * +dnl copies of the Software, and to permit persons to whom the Software is * +dnl furnished to do so, subject to the following conditions: * +dnl * +dnl The above copyright notice and this permission notice shall be included * +dnl in all copies or substantial portions of the Software. * +dnl * +dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * +dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * +dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * +dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * +dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * +dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * +dnl THE USE OR OTHER DEALINGS IN THE SOFTWARE. * +dnl * +dnl Except as contained in this notice, the name(s) of the above copyright * +dnl holders shall not be used in advertising or otherwise to promote the * +dnl sale, use or other dealings in this Software without prior written * +dnl authorization. * +dnl*************************************************************************** +dnl +dnl Author: Thomas E. Dickey 1996,1997,1998 +dnl +dnl $Id: aclocal.m4,v 1.214 2000/07/07 15:11:34 tom Exp $ dnl Macros used in NCURSES auto-configuration script. dnl dnl --------------------------------------------------------------------------- +dnl --------------------------------------------------------------------------- dnl Construct the list of include-options for the C programs in the Ada95 dnl binding. -AC_DEFUN([NC_ADA_INCLUDE_DIRS], +AC_DEFUN([CF_ADA_INCLUDE_DIRS], [ ACPPFLAGS="$ACPPFLAGS -I. -I../../include" if test "$srcdir" != "."; then @@ -43,21 +55,90 @@ fi AC_SUBST(ACPPFLAGS) ])dnl dnl --------------------------------------------------------------------------- +dnl This is adapted from the macros 'fp_PROG_CC_STDC' and 'fp_C_PROTOTYPES' +dnl in the sharutils 4.2 distribution. +AC_DEFUN([CF_ANSI_CC_CHECK], +[ +AC_MSG_CHECKING(for ${CC-cc} option to accept ANSI C) +AC_CACHE_VAL(cf_cv_ansi_cc,[ +cf_cv_ansi_cc=no +cf_save_CFLAGS="$CFLAGS" +# Don't try gcc -ansi; that turns off useful extensions and +# breaks some systems' header files. +# AIX -qlanglvl=ansi +# Ultrix and OSF/1 -std1 +# HP-UX -Aa -D_HPUX_SOURCE +# SVR4 -Xc +# UnixWare 1.2 (cannot use -Xc, since ANSI/POSIX clashes) +for cf_arg in "-DCC_HAS_PROTOS" \ + "" \ + -qlanglvl=ansi \ + -std1 \ + -Ae \ + "-Aa -D_HPUX_SOURCE" \ + -Xc +do + CFLAGS="$cf_save_CFLAGS $cf_arg" + AC_TRY_COMPILE( +[ +#ifndef CC_HAS_PROTOS +#if !defined(__STDC__) || (__STDC__ != 1) +choke me +#endif +#endif +],[ + int test (int i, double x); + struct s1 {int (*f) (int a);}; + struct s2 {int (*f) (double a);};], + [cf_cv_ansi_cc="$cf_arg"; break]) +done +CFLAGS="$cf_save_CFLAGS" +]) +AC_MSG_RESULT($cf_cv_ansi_cc) + +if test "$cf_cv_ansi_cc" != "no"; then +if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then + CFLAGS="$CFLAGS $cf_cv_ansi_cc" +else + AC_DEFINE(CC_HAS_PROTOS) +fi +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl For programs that must use an ANSI compiler, obtain compiler options that +dnl will make it recognize prototypes. We'll do preprocessor checks in other +dnl macros, since tools such as unproto can fake prototypes, but only part of +dnl the preprocessor. +AC_DEFUN([CF_ANSI_CC_REQD], +[AC_REQUIRE([CF_ANSI_CC_CHECK]) +if test "$cf_cv_ansi_cc" = "no"; then + AC_ERROR( +[Your compiler does not appear to recognize prototypes. +You have the following choices: + a. adjust your compiler options + b. get an up-to-date compiler + c. use a wrapper such as unproto]) +fi +])dnl +dnl --------------------------------------------------------------------------- dnl Test if 'bool' is a builtin type in the configured C++ compiler. Some dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc dnl 2.6.3 does, in anticipation of the ANSI C++ standard. dnl dnl Treat the configuration-variable specially here, since we're directly dnl substituting its value (i.e., 1/0). -AC_DEFUN([NC_BOOL_DECL], +AC_DEFUN([CF_BOOL_DECL], [ -AC_MSG_CHECKING([for builtin c++ bool type]) -AC_CACHE_VAL(nc_cv_builtin_bool,[ - AC_TRY_COMPILE([],[bool x = false], - [nc_cv_builtin_bool=1], - [nc_cv_builtin_bool=0]) +AC_MSG_CHECKING([for builtin ifelse(AC_LANG,[C],$CC,$CXX) bool type]) +AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[ + AC_TRY_COMPILE([ +#include +#include +],[bool x = false], + [ifelse($1,,cf_cv_builtin_bool,[$1])=1], + [ifelse($1,,cf_cv_builtin_bool,[$1])=0]) ]) -if test $nc_cv_builtin_bool = 1 +if test $ifelse($1,,cf_cv_builtin_bool,[$1]) = 1 then AC_MSG_RESULT(yes) else AC_MSG_RESULT(no) fi @@ -65,22 +146,28 @@ fi dnl --------------------------------------------------------------------------- dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type). dnl Don't bother looking for bool.h, since it's been deprecated. -AC_DEFUN([NC_BOOL_SIZE], +AC_DEFUN([CF_BOOL_SIZE], [ -AC_MSG_CHECKING([for size of c++ bool]) -AC_CACHE_VAL(nc_cv_type_of_bool,[ - rm -f nc_test.out +AC_MSG_CHECKING([for size of ifelse(AC_LANG,[C],$CC,$CXX) bool]) +AC_CACHE_VAL(cf_cv_type_of_bool,[ + rm -f cf_test.out AC_TRY_RUN([ #include #include -#if HAVE_BUILTIN_H +#if HAVE_GXX_BUILTIN_H +#include +#elif HAVE_GPP_BUILTIN_H +#include +#elif HAVE_BUILTIN_H #include #endif main() { - FILE *fp = fopen("nc_test.out", "w"); + FILE *fp = fopen("cf_test.out", "w"); if (fp != 0) { - bool x = false; + bool x = true; + if ((bool)(-x) >= 0) + fputs("unsigned ", fp); if (sizeof(x) == sizeof(int)) fputs("int", fp); else if (sizeof(x) == sizeof(char)) fputs("char", fp); else if (sizeof(x) == sizeof(short))fputs("short",fp); @@ -90,15 +177,15 @@ main() exit(0); } ], - [nc_cv_type_of_bool=`cat nc_test.out`], - [nc_cv_type_of_bool=unknown], - [nc_cv_type_of_bool=unknown]) + [cf_cv_type_of_bool=`cat cf_test.out`], + [cf_cv_type_of_bool=unknown], + [cf_cv_type_of_bool=unknown]) ]) - rm -f nc_test.out -AC_MSG_RESULT($nc_cv_type_of_bool) -if test $nc_cv_type_of_bool = unknown ; then + rm -f cf_test.out +AC_MSG_RESULT($cf_cv_type_of_bool) +if test "$cf_cv_type_of_bool" = unknown ; then AC_MSG_WARN(Assuming unsigned for type of bool) - nc_cv_type_of_bool=unsigned + cf_cv_type_of_bool=unsigned fi ])dnl dnl --------------------------------------------------------------------------- @@ -112,22 +199,25 @@ dnl dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's dnl programs from a vendor's. -AC_DEFUN([NC_CFG_DEFAULTS], +AC_DEFUN([CF_CFG_DEFAULTS], [ AC_MSG_CHECKING(for prefix) if test "x$prefix" = "xNONE" ; then - case "$nc_cv_systype" in + case "$cf_cv_system_name" in # non-vendor systems don't have a conflict - NetBSD|FreeBSD|Linux) prefix=/usr + openbsd*|netbsd*|freebsd*|linux*) + prefix=/usr ;; *) prefix=$ac_default_prefix ;; esac fi AC_MSG_RESULT($prefix) + +if test "x$prefix" = "xNONE" ; then AC_MSG_CHECKING(for default include-directory) -test -n "$verbose" && echo 1>&6 -for nc_symbol in \ +test -n "$verbose" && echo 1>&AC_FD_MSG +for cf_symbol in \ $includedir \ $includedir/ncurses \ $prefix/include \ @@ -137,76 +227,277 @@ for nc_symbol in \ /usr/include \ /usr/include/ncurses do - nc_dir=`eval echo $nc_symbol` - if test -f $nc_dir/curses.h ; then - if ( fgrep NCURSES_VERSION $nc_dir/curses.h 2>&1 >/dev/null ) ; then - includedir="$nc_symbol" - test -n "$verbose" && echo $ac_n " found " 1>&6 + 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 + includedir="$cf_symbol" + test -n "$verbose" && echo $ac_n " found " 1>&AC_FD_MSG break fi fi - test -n "$verbose" && echo " tested $nc_dir" 1>&6 + test -n "$verbose" && echo " tested $cf_dir" 1>&AC_FD_MSG done AC_MSG_RESULT($includedir) +fi ])dnl dnl --------------------------------------------------------------------------- -dnl If we're trying to use g++, test if libg++ is installed (a rather common -dnl problem :-). If we have the compiler but no library, we'll be able to -dnl configure, but won't be able to build the c++ demo program. -AC_DEFUN([NC_CXX_LIBRARY], -[ -nc_cxx_library=unknown -if test $ac_cv_prog_gxx = yes; then - AC_MSG_CHECKING([for libg++]) - nc_save="$LIBS" - LIBS="$LIBS -lg++ -lm" - AC_TRY_LINK([ -#include +dnl Check if the terminal-capability database functions are available. If not, +dnl ncurses has a much-reduced version. +AC_DEFUN([CF_CGETENT],[ +AC_MSG_CHECKING(for terminal-capability database functions) +AC_CACHE_VAL(cf_cv_cgetent,[ +AC_TRY_LINK([ +#include ],[ + char temp[128]; + char *buf = temp; + char *db_array = temp; + cgetent(&buf, /* int *, */ &db_array, "vt100"); + cgetcap(buf, "tc", '='); + cgetmatch(buf, "tc"); ], - [float foo=abs(1.0)], - [nc_cxx_library=yes - CXXLIBS="$CXXLIBS -lg++ -lm"], - [nc_cxx_library=no]) - LIBS="$nc_save" - AC_MSG_RESULT($nc_cxx_library) + [cf_cv_cgetent=yes], + [cf_cv_cgetent=no]) +]) +AC_MSG_RESULT($cf_cv_cgetent) +test $cf_cv_cgetent = yes && AC_DEFINE(HAVE_BSD_CGETENT) +])dnl +dnl --------------------------------------------------------------------------- +dnl Check if we're accidentally using a cache from a different machine. +dnl Derive the system name, as a check for reusing the autoconf cache. +dnl +dnl If we've packaged config.guess and config.sub, run that (since it does a +dnl better job than uname). +AC_DEFUN([CF_CHECK_CACHE], +[ +if test -f $srcdir/config.guess ; then + AC_CANONICAL_HOST + system_name="$host_os" +else + system_name="`(uname -s -r) 2>/dev/null`" + if test -z "$system_name" ; then + system_name="`(hostname) 2>/dev/null`" + fi +fi +test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name") +AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"]) + +test -z "$system_name" && system_name="$cf_cv_system_name" +test -n "$cf_cv_system_name" && AC_MSG_RESULT("Configuring for $cf_cv_system_name") + +if test ".$system_name" != ".$cf_cv_system_name" ; then + AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name)) + AC_ERROR("Please remove config.cache and try again.") +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl Check for data that is usually declared in or , e.g., +dnl the 'errno' variable. Define a DECL_xxx symbol if we must declare it +dnl ourselves. +dnl +dnl (I would use AC_CACHE_CHECK here, but it will not work when called in a +dnl loop from CF_SYS_ERRLIST). +dnl +dnl $1 = the name to check +AC_DEFUN([CF_CHECK_ERRNO], +[ +AC_MSG_CHECKING(if external $1 is declared) +AC_CACHE_VAL(cf_cv_dcl_$1,[ + AC_TRY_COMPILE([ +#ifdef HAVE_STDLIB_H +#include +#endif +#include +#include +#include ], + [long x = (long) $1], + [eval 'cf_cv_dcl_'$1'=yes'], + [eval 'cf_cv_dcl_'$1'=no']) +]) + +eval 'cf_result=$cf_cv_dcl_'$1 +AC_MSG_RESULT($cf_result) + +if test "$cf_result" = no ; then + eval 'cf_result=DECL_'$1 + CF_UPPER(cf_result,$cf_result) + AC_DEFINE_UNQUOTED($cf_result) fi + +# It's possible (for near-UNIX clones) that the data doesn't exist +CF_CHECK_EXTERN_DATA($1,int) +])dnl +dnl --------------------------------------------------------------------------- +dnl Check for existence of external data in the current set of libraries. If +dnl we can modify it, it's real enough. +dnl $1 = the name to check +dnl $2 = its type +AC_DEFUN([CF_CHECK_EXTERN_DATA], +[ +AC_MSG_CHECKING(if external $1 exists) +AC_CACHE_VAL(cf_cv_have_$1,[ + AC_TRY_LINK([ +#undef $1 +extern $2 $1; +], + [$1 = 2], + [eval 'cf_cv_have_'$1'=yes'], + [eval 'cf_cv_have_'$1'=no'])]) + +eval 'cf_result=$cf_cv_have_'$1 +AC_MSG_RESULT($cf_result) + +if test "$cf_result" = yes ; then + eval 'cf_result=HAVE_'$1 + CF_UPPER(cf_result,$cf_result) + AC_DEFINE_UNQUOTED($cf_result) +fi + +])dnl +dnl --------------------------------------------------------------------------- +dnl Check if the C++ compiler accepts duplicate parameter initialization. This +dnl is a late feature for the standard and is not in some recent compilers +dnl (1999/9/11). +AC_DEFUN([CF_CPP_PARAM_INIT], +[ +if test -n "$CXX" ; then +AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[ + AC_LANG_CPLUSPLUS + AC_TRY_RUN([ +class TEST { +private: + int value; +public: + TEST(int x = 1); + ~TEST(); +}; + +TEST::TEST(int x = 1) // some compilers do not like second initializer +{ + value = x; +} +void main() { } +], + [cf_cv_cpp_param_init=yes], + [cf_cv_cpp_param_init=no], + [cf_cv_cpp_param_init=unknown]) +]) +fi +test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT) ])dnl dnl --------------------------------------------------------------------------- -AC_DEFUN([NC_DIRS_TO_MAKE], +AC_DEFUN([CF_DIRS_TO_MAKE], [ DIRS_TO_MAKE="lib" -for nc_item in $nc_list_models +for cf_item in $cf_list_models do - NC_OBJ_SUBDIR($nc_item,nc_subdir) - DIRS_TO_MAKE="$DIRS_TO_MAKE $nc_subdir" + CF_OBJ_SUBDIR($cf_item,cf_subdir) + DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir" done -for nc_dir in $DIRS_TO_MAKE +for cf_dir in $DIRS_TO_MAKE do - test ! -d $nc_dir && mkdir $nc_dir + test ! -d $cf_dir && mkdir $cf_dir done AC_SUBST(DIRS_TO_MAKE) ])dnl dnl --------------------------------------------------------------------------- -dnl -AC_DEFUN([NC_ERRNO], +dnl Check if 'errno' is declared in +AC_DEFUN([CF_ERRNO], [ -AC_MSG_CHECKING([for errno external decl]) -AC_CACHE_VAL(nc_cv_extern_errno,[ - AC_TRY_COMPILE([ -#include ], - [int x = errno], - [nc_cv_extern_errno=yes], - [nc_cv_extern_errno=no]) - ]) -AC_MSG_RESULT($nc_cv_extern_errno) -test $nc_cv_extern_errno = yes && AC_DEFINE(HAVE_EXTERN_ERRNO) +CF_CHECK_ERRNO(errno) +])dnl +dnl --------------------------------------------------------------------------- +dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between +dnl math.h and builtin.h, only for ncurses +AC_DEFUN([CF_ETIP_DEFINES], +[ +AC_MSG_CHECKING(for special defines needed for etip.h) +cf_save_CXXFLAGS="$CXXFLAGS" +cf_result="none" +for cf_math in "" MATH_H +do +for cf_excp in "" MATH_EXCEPTION +do + CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu" + test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}" + test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}" +AC_TRY_COMPILE([ +#include +],[],[ + test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math}) + test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp}) + cf_result="$cf_math $cf_excp" + break +],[]) +done +done +AC_MSG_RESULT($cf_result) +CXXFLAGS="$cf_save_CXXFLAGS" +]) +dnl --------------------------------------------------------------------------- +dnl Check for memmove, or a bcopy that can handle overlapping copy. If neither +dnl is found, add our own version of memmove to the list of objects. +AC_DEFUN([CF_FUNC_MEMMOVE], +[ +AC_CHECK_FUNC(memmove,,[ +AC_CHECK_FUNC(bcopy,[ + AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[ + AC_TRY_RUN([ +int main() { + static char data[] = "abcdefghijklmnopqrstuwwxyz"; + char temp[40]; + bcopy(data, temp, sizeof(data)); + bcopy(temp+10, temp, 15); + bcopy(temp+5, temp+15, 10); + exit (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz")); +} + ], + [cf_cv_good_bcopy=yes], + [cf_cv_good_bcopy=no], + [cf_cv_good_bcopy=unknown]) + ]) + ],[cf_cv_good_bcopy=no]) + if test $cf_cv_good_bcopy = yes ; then + AC_DEFINE(USE_OK_BCOPY) + else + AC_DEFINE(USE_MY_MEMMOVE) + fi +])])dnl +dnl --------------------------------------------------------------------------- +dnl See if the poll function really works. Some platforms have poll(), but +dnl it does not work for terminals or files. +AC_DEFUN([CF_FUNC_POLL],[ +AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[ +AC_TRY_RUN([ +#include +#ifdef HAVE_POLL_H +#include +#else +#include +#endif +int main() { + struct pollfd myfds; + int ret; + + myfds.fd = 0; + myfds.events = POLLIN; + + ret = poll(&myfds, 1, 100); + exit(ret != 0); +}], + [cf_cv_working_poll=yes], + [cf_cv_working_poll=no], + [cf_cv_working_poll=unknown])]) +test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL) ])dnl 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([NC_GCC_ATTRIBUTES], -[cat > conftest.i < conftest.i < conftest.$ac_ext <&AC_FD_CC - case $nc_attribute in + CF_UPPER(CF_ATTRIBUTE,$cf_attribute) + cf_directive="__attribute__(($cf_attribute))" + echo "checking for $CC $cf_directive" 1>&AC_FD_CC + case $cf_attribute in scanf|printf) cat >conftest.h <conftest.h <>confdefs.h # else # sed -e 's/__attr.*/\/*nothing*\//' conftest.h >>confdefs.h @@ -273,7 +564,7 @@ else fgrep define conftest.i >>confdefs.h fi rm -rf conftest* - +fi ])dnl dnl --------------------------------------------------------------------------- dnl Check if the compiler supports useful warning options. There's a few that @@ -282,23 +573,25 @@ dnl dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x) dnl -Wredundant-decls (system headers make this too noisy) dnl -Wtraditional (combines too many unrelated messages, only a few useful) +dnl -Wwrite-strings (too noisy, but should review occasionally) +dnl -pedantic dnl -AC_DEFUN([NC_GCC_WARNINGS], -[nc_warn_CFLAGS="" +AC_DEFUN([CF_GCC_WARNINGS], +[ if test -n "$GCC" then changequote(,)dnl cat > conftest.$ac_ext <>conftest.ads <>conftest.adb <&AC_FD_CC 2>&1 ) ; then + if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then +ifelse($3,, :,[ $3]) +ifelse($4,,,[ else + $4]) + fi +ifelse($4,,,[else + $4]) fi +rm -f conftest* ])dnl dnl --------------------------------------------------------------------------- dnl Verify Version of GNAT. -AC_DEFUN([NC_GNAT_VERSION], +AC_DEFUN([CF_GNAT_VERSION], [ changequote(<<, >>)dnl -nc_cv_gnat_version=`$nc_ada_make -v 2>&1 | grep '[0-9].[0-9][0-9]*' |\ +cf_cv_gnat_version=`$cf_ada_make -v 2>&1 | grep '[0-9].[0-9][0-9]*' |\ sed -e 's/[^0-9 \.]//g' | $AWK '{print $<<1>>;}'` -case $nc_cv_gnat_version in - 3.0[5-9]|3.[1-9]*|[4-9].*) - ac_cv_prog_gnat_correct=yes +case $cf_cv_gnat_version in + 3.1[1-9]*|3.[2-9]*|[4-9].*) + cf_cv_prog_gnat_correct=yes ;; - *) echo Unsupported GNAT version $nc_cv_gnat_version. Disabling Ada95 binding. - ac_cv_prog_gnat_correct=no + *) echo Unsupported GNAT version $cf_cv_gnat_version. Required is 3.11 or better. Disabling Ada95 binding. + cf_cv_prog_gnat_correct=no ;; esac +case $cf_cv_gnat_version in + 3.1*|[4-9].*) + cf_compile_generics=generics + cf_generic_objects="\$(GENOBJS)" + ;; + *) cf_compile_generics= + cf_generic_objects= + ;; +esac changequote([, ])dnl ]) dnl --------------------------------------------------------------------------- +dnl If we're trying to use g++, test if libg++ is installed (a rather common +dnl problem :-). If we have the compiler but no library, we'll be able to +dnl configure, but won't be able to build the c++ demo program. +AC_DEFUN([CF_GPP_LIBRARY], +[ +cf_cxx_library=unknown +case $cf_cv_system_name in #(vi +os2*) #(vi + cf_gpp_libname=gpp + ;; +*) + cf_gpp_libname=g++ + ;; +esac +if test $ac_cv_prog_gxx = yes; then + AC_MSG_CHECKING([for lib$cf_gpp_libname]) + cf_save="$LIBS" + LIBS="$LIBS -l$cf_gpp_libname" + AC_TRY_LINK([ +#include <$cf_gpp_libname/builtin.h> + ], + [two_arg_error_handler_t foo2 = lib_error_handler], + [cf_cxx_library=yes + CXXLIBS="$CXXLIBS -l$cf_gpp_libname" + if test "$cf_gpp_libname" = cpp ; then + AC_DEFINE(HAVE_GPP_BUILTIN_H) + else + AC_DEFINE(HAVE_GXX_BUILTIN_H) + fi], + [AC_TRY_LINK([ +#include + ], + [two_arg_error_handler_t foo2 = lib_error_handler], + [cf_cxx_library=yes + CXXLIBS="$CXXLIBS -l$cf_gpp_libname" + AC_DEFINE(HAVE_BUILTIN_H)], + [cf_cxx_library=no])]) + LIBS="$cf_save" + AC_MSG_RESULT($cf_cxx_library) +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl Insert text into the help-message, for readability, from AC_ARG_WITH. +AC_DEFUN([CF_HELP_MESSAGE], +[AC_DIVERT_HELP([$1])dnl +])dnl +dnl --------------------------------------------------------------------------- dnl Construct the list of include-options according to whether we're building dnl in the source directory or using '--srcdir=DIR' option. If we're building dnl with gcc, don't append the includedir if it happens to be /usr/include, dnl since that usually breaks gcc's shadow-includes. -AC_DEFUN([NC_INCLUDE_DIRS], +AC_DEFUN([CF_INCLUDE_DIRS], [ CPPFLAGS="$CPPFLAGS -I. -I../include" if test "$srcdir" != "."; then @@ -362,6 +736,31 @@ fi AC_SUBST(CPPFLAGS) ])dnl dnl --------------------------------------------------------------------------- +dnl Check if we have either a function or macro for 'isascii()'. +AC_DEFUN([CF_ISASCII], +[ +AC_MSG_CHECKING(for isascii) +AC_CACHE_VAL(cf_cv_have_isascii,[ + AC_TRY_LINK([#include ],[int x = isascii(' ')], + [cf_cv_have_isascii=yes], + [cf_cv_have_isascii=no]) +])dnl +AC_MSG_RESULT($cf_cv_have_isascii) +test $cf_cv_have_isascii = yes && AC_DEFINE(HAVE_ISASCII) +])dnl +dnl --------------------------------------------------------------------------- +dnl Compute the library-prefix for the given host system +dnl $1 = variable to set +AC_DEFUN([CF_LIB_PREFIX], +[ + case $cf_cv_system_name in + os2) LIB_PREFIX='' ;; + *) LIB_PREFIX='lib' ;; + esac +ifelse($1,,,[$1=$LIB_PREFIX]) + AC_SUBST(LIB_PREFIX) +])dnl +dnl --------------------------------------------------------------------------- dnl Append definitions and rules for the given models to the subdirectory dnl Makefiles, and the recursion rule for the top-level Makefile. If the dnl subdirectory is a library-source directory, modify the LIBRARIES list in @@ -373,114 +772,166 @@ dnl one: dnl lib.so -> dnl lib.so. -> dnl lib.so.. -AC_DEFUN([NC_LIB_RULES], +AC_DEFUN([CF_LIB_RULES], [ -AC_REQUIRE([NC_SYSTYPE]) -AC_REQUIRE([NC_VERSION]) -for nc_dir in $SRC_SUBDIRS +CF_LIB_PREFIX(cf_prefix) +AC_REQUIRE([CF_SUBST_NCURSES_VERSION]) +for cf_dir in $SRC_SUBDIRS do - if test -f $srcdir/$nc_dir/modules; then + if test -f $srcdir/$cf_dir/modules; then - nc_libs_to_make= - for nc_item in $NC_LIST_MODELS + cf_libs_to_make= + for cf_item in $CF_LIST_MODELS do - NC_LIB_SUFFIX($nc_item,nc_suffix) - nc_libs_to_make="$nc_libs_to_make ../lib/lib${nc_dir}${nc_suffix}" + CF_LIB_SUFFIX($cf_item,cf_suffix) + if test $cf_item = shared ; then + if test $cf_cv_do_symlinks = yes ; then + case "$cf_cv_shlib_version" in #(vi + rel) cf_suffix="$cf_suffix"'.$(REL_VERSION)' ;; #(vi + abi) cf_suffix="$cf_suffix"'.$(ABI_VERSION)' ;; + esac + fi + fi + cf_libs_to_make="$cf_libs_to_make ../lib/${cf_prefix}${cf_dir}${cf_suffix}" done - sed -e "s@\@LIBS_TO_MAKE\@@$nc_libs_to_make@" \ - $nc_dir/Makefile >$nc_dir/Makefile.out - mv $nc_dir/Makefile.out $nc_dir/Makefile + if test $cf_dir = ncurses ; then + case "$LIB_SUBSETS" in #(vi + termlib+*) #(vi + ;; + *) #(vi + cf_item=`echo $cf_libs_to_make |sed -e s/$LIB_NAME/$TINFO_NAME/g` + cf_libs_to_make="$cf_item $cf_libs_to_make" + ;; + esac + fi + + sed -e "s@\@LIBS_TO_MAKE\@@$cf_libs_to_make@" \ + $cf_dir/Makefile >$cf_dir/Makefile.out + mv $cf_dir/Makefile.out $cf_dir/Makefile $AWK -f $srcdir/mk-0th.awk \ - name=$nc_dir \ - $srcdir/$nc_dir/modules >>$nc_dir/Makefile + name=$cf_dir \ + $srcdir/$cf_dir/modules >>$cf_dir/Makefile - for nc_item in $NC_LIST_MODELS + for cf_item in $CF_LIST_MODELS do - echo 'Appending rules for '$nc_item' model ('$nc_dir')' - NC_UPPERCASE($nc_item,NC_ITEM) - NC_LIB_SUFFIX($nc_item,nc_suffix) - NC_OBJ_SUBDIR($nc_item,nc_subdir) + echo 'Appending rules for '$cf_item' model ('$cf_dir')' + CF_UPPER(CF_ITEM,$cf_item) + CF_LIB_SUFFIX($cf_item,cf_suffix) + CF_OBJ_SUBDIR($cf_item,cf_subdir) # These dependencies really are for development, not # builds, but they are useful in porting, too. - nc_depend="../include/ncurses_cfg.h" + cf_depend="../include/ncurses_cfg.h" if test "$srcdir" = "."; then - nc_reldir="." + cf_reldir="." else - nc_reldir="\$(srcdir)" + cf_reldir="\$(srcdir)" fi - if test -f $srcdir/$nc_dir/$nc_dir.priv.h; then - nc_depend="$nc_depend $nc_reldir/$nc_dir.priv.h" - elif test -f $srcdir/$nc_dir/curses.priv.h; then - nc_depend="$nc_depend $nc_reldir/curses.priv.h" + + if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then + cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h" + elif test -f $srcdir/$cf_dir/curses.priv.h; then + cf_depend="$cf_depend $cf_reldir/curses.priv.h" fi + + for cf_subset in $LIB_SUBSETS + do $AWK -f $srcdir/mk-1st.awk \ - name=$nc_dir \ - MODEL=$NC_ITEM \ - model=$nc_subdir \ - suffix=$nc_suffix \ - DoLinks=$nc_cv_do_symlinks \ - rmSoLocs=$nc_cv_rm_so_locs \ + name=$cf_dir \ + traces=$LIB_TRACING \ + MODEL=$CF_ITEM \ + model=$cf_subdir \ + prefix=$cf_prefix \ + suffix=$cf_suffix \ + subset=$cf_subset \ + ShlibVer=$cf_cv_shlib_version \ + DoLinks=$cf_cv_do_symlinks \ + rmSoLocs=$cf_cv_rm_so_locs \ + ldconfig="$LDCONFIG" \ overwrite=$WITH_OVERWRITE \ - depend="$nc_depend" \ - $srcdir/$nc_dir/modules >>$nc_dir/Makefile - test $nc_dir = ncurses && WITH_OVERWRITE=no + depend="$cf_depend" \ + target="$target" \ + $srcdir/$cf_dir/modules >>$cf_dir/Makefile + test $cf_dir = ncurses && WITH_OVERWRITE=no $AWK -f $srcdir/mk-2nd.awk \ - name=$nc_dir \ - MODEL=$NC_ITEM \ - model=$nc_subdir \ + name=$cf_dir \ + traces=$LIB_TRACING \ + MODEL=$CF_ITEM \ + model=$cf_subdir \ + subset=$cf_subset \ srcdir=$srcdir \ echo=$WITH_ECHO \ - $srcdir/$nc_dir/modules >>$nc_dir/Makefile + $srcdir/$cf_dir/modules >>$cf_dir/Makefile + done done fi - echo ' cd '$nc_dir'; $(MAKE) $(NC_MFLAGS) [$]@' >>Makefile + echo ' cd '$cf_dir' && $(MAKE) $(CF_MFLAGS) [$]@' >>Makefile done -for nc_dir in $SRC_SUBDIRS +for cf_dir in $SRC_SUBDIRS do - if test -f $srcdir/$nc_dir/modules; then + if test -f $cf_dir/Makefile ; then + case "$cf_dir" in + Ada95) #(vi + echo 'libs \' >> Makefile + echo 'install.libs \' >> Makefile + echo 'uninstall.libs ::' >> Makefile + echo ' cd '$cf_dir' && $(MAKE) $(CF_MFLAGS) [$]@' >> Makefile + ;; + esac + fi + + if test -f $srcdir/$cf_dir/modules; then echo >> Makefile - if test -f $srcdir/$nc_dir/headers; then -cat >> Makefile <> Makefile <> Makefile fi -cat >> Makefile <> Makefile <> Makefile <> Makefile <> Makefile <> Makefile <headers.sh <headers.sh </<\$END\/\$NAME>/" >> ../headers.sed - done - fi - rm -f \$TMP - sed -f ../headers.sed \$SRC > \$TMP - eval \$PRG \$TMP \$DST - rm -f \$TMP + TMPSRC=\${TMPDIR-/tmp}/\`basename \$SRC\`\$\$ + TMPSED=\${TMPDIR-/tmp}/headers.sed\$\$ + END=\`basename \$DST\` + for i in \`cat \$REF/../*/headers |fgrep -v "#"\` + do + NAME=\`basename \$i\` + echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED + done + rm -f \$TMPSRC + sed -f \$TMPSED \$SRC > \$TMPSRC + eval \$PRG \$TMPSRC \$DST/\$SRC + rm -f \$TMPSRC \$TMPSED ;; *) eval \$PRG \$SRC \$DST ;; esac -NC_EOF +CF_EOF chmod 0755 headers.sh -for nc_dir in $SRC_SUBDIRS +for cf_dir in $SRC_SUBDIRS do - if test -f $srcdir/$nc_dir/headers; then - cat >>$nc_dir/Makefile <>$cf_dir/Makefile <>$nc_dir/Makefile + test -n "$j" && echo " $j \\" >>$cf_dir/Makefile j=$i done - echo " $j" >>$nc_dir/Makefile - for i in `cat $srcdir/$nc_dir/headers |fgrep -v "#"` + echo " $j" >>$cf_dir/Makefile + for i in `cat $srcdir/$cf_dir/headers |fgrep -v "#"` do - echo " @ ../headers.sh \$(INSTALL_DATA) \$(INSTALL_PREFIX)\$(includedir) \$(srcdir) $i" >>$nc_dir/Makefile + echo " @ (cd \$(INSTALL_PREFIX)\$(includedir) && rm -f `basename $i`) ; ../headers.sh \$(INSTALL_DATA) \$(INSTALL_PREFIX)\$(includedir) \$(srcdir) $i" >>$cf_dir/Makefile + test $i = curses.h && echo " @ (cd \$(INSTALL_PREFIX)\$(includedir) && rm -f ncurses.h && \$(LN_S) curses.h ncurses.h)" >>$cf_dir/Makefile + done + + cat >>$cf_dir/Makefile <>$cf_dir/Makefile + test $i = curses.h && echo " -@ (cd \$(INSTALL_PREFIX)\$(includedir) && rm -f ncurses.h)" >>$cf_dir/Makefile done fi done ])dnl dnl --------------------------------------------------------------------------- -dnl Compute the library-suffix from the given model name -AC_DEFUN([NC_LIB_SUFFIX], +dnl Compute the library file-suffix from the given model name +dnl $1 = model name +dnl $2 = variable to set +dnl The variable $LIB_SUFFIX, if set, prepends the variable to set. +AC_DEFUN([CF_LIB_SUFFIX], [ - AC_REQUIRE([NC_SYSTYPE]) - AC_REQUIRE([NC_VERSION]) + AC_REQUIRE([CF_SUBST_NCURSES_VERSION]) case $1 in normal) $2='.a' ;; debug) $2='_g.a' ;; profile) $2='_p.a' ;; shared) - case $nc_cv_systype in - NetBSD|FreeBSD) - $2='.so.$(ABI_VERSION)' ;; - HP_UX) $2='.sl' ;; + case $cf_cv_system_name in + hpux*) $2='.sl' ;; *) $2='.so' ;; esac esac + test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}" ])dnl dnl --------------------------------------------------------------------------- dnl Compute the string to append to -library from the given model name -AC_DEFUN([NC_LIB_TYPE], +dnl $1 = model name +dnl $2 = variable to set +dnl The variable $LIB_SUFFIX, if set, prepends the variable to set. +AC_DEFUN([CF_LIB_TYPE], [ case $1 in normal) $2='' ;; @@ -586,16 +1054,17 @@ AC_DEFUN([NC_LIB_TYPE], profile) $2='_p' ;; shared) $2='' ;; esac + test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}" ])dnl dnl --------------------------------------------------------------------------- dnl Some systems have a non-ANSI linker that doesn't pull in modules that have dnl only data (i.e., no functions), for example NeXT. On those systems we'll dnl have to provide wrappers for global tables to ensure they're linked dnl properly. -AC_DEFUN([NC_LINK_DATAONLY], +AC_DEFUN([CF_LINK_DATAONLY], [ AC_MSG_CHECKING([if data-only library module links]) -AC_CACHE_VAL(nc_cv_link_dataonly,[ +AC_CACHE_VAL(cf_cv_link_dataonly,[ rm -f conftest.a changequote(,)dnl cat >conftest.$ac_ext <&5 >/dev/null - nc_saveLIBS="$LIBS" + cf_saveLIBS="$LIBS" LIBS="conftest.a $LIBS" AC_TRY_RUN([ int main() @@ -639,191 +1108,408 @@ EOF exit (!testfunc()); } ], - [nc_cv_link_dataonly=yes], - [nc_cv_link_dataonly=no], - [nc_cv_link_dataonly=unknown]) - LIBS="$nc_saveLIBS" + [cf_cv_link_dataonly=yes], + [cf_cv_link_dataonly=no], + [cf_cv_link_dataonly=unknown]) + LIBS="$cf_saveLIBS" ]) -AC_MSG_RESULT($nc_cv_link_dataonly) -test $nc_cv_link_dataonly = no && AC_DEFINE(BROKEN_LINKER) +AC_MSG_RESULT($cf_cv_link_dataonly) +test $cf_cv_link_dataonly = no && AC_DEFINE(BROKEN_LINKER) +])dnl +dnl --------------------------------------------------------------------------- +dnl Most Unix systems have both link and symlink, a few don't have symlink. +dnl A few non-Unix systems implement symlink, but not link. +dnl A few non-systems implement neither (or have nonfunctional versions). +AC_DEFUN([CF_LINK_FUNCS], +[ +AC_CHECK_FUNCS( \ + remove \ + unlink ) + +if test "$ac_cv_prog_cc_cross" = yes ; then + AC_CHECK_FUNCS( \ + link \ + symlink ) +else + AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[ + cf_cv_link_funcs= + for cf_func in link symlink ; do + AC_TRY_RUN([ +#include +#include +#ifdef HAVE_UNISTD_H +#include +#endif +int main() +{ + int fail = 0; + char *src = "config.log"; + char *dst = "conftest.chk"; + struct stat src_sb; + struct stat dst_sb; + + stat(src, &src_sb); + fail = ($cf_func("config.log", "conftest.chk") < 0) + || (stat(dst, &dst_sb) < 0) + || (dst_sb.st_mtime != src_sb.st_mtime); +#ifdef HAVE_UNLINK + unlink(dst); +#else + remove(dst); +#endif + exit (fail); +} + ],[ + cf_cv_link_funcs="$cf_cv_link_funcs $cf_func" + eval 'ac_cv_func_'$cf_func'=yes' + CF_UPPER(cf_FUNC,$cf_func) + AC_DEFINE_UNQUOTED(HAVE_$cf_FUNC)],[ + eval 'ac_cv_func_'$cf_func'=no'],[ + eval 'ac_cv_func_'$cf_func'=error']) + done + test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no + ]) +fi ])dnl 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 :-) -AC_DEFUN([NC_MAKEFLAGS], +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_MSG_CHECKING([for makeflags variable]) -AC_CACHE_VAL(nc_cv_makeflags,[ - nc_cv_makeflags='' - for nc_option in '$(MFLAGS)' '-$(MAKEFLAGS)' +AC_CACHE_VAL(cf_cv_makeflags,[ + cf_cv_makeflags='' + for cf_option in '-$(MAKEFLAGS)' '$(MFLAGS)' do - cat >ncurses.tmp <cf_makeflags.tmp </dev/null` - if test "$nc_result" != "." - then - nc_cv_makeflags=$nc_option + @ echo '.$cf_option' +CF_EOF + cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null` + case "$cf_result" in + .*k) + cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null` + case "$cf_result" in + .*CC=*) cf_cv_makeflags= + ;; + *) cf_cv_makeflags=$cf_option + ;; + esac break - fi + ;; + *) echo no match "$cf_result" + ;; + esac done - rm -f ncurses.tmp - ]) -AC_MSG_RESULT($nc_cv_makeflags) -AC_SUBST(nc_cv_makeflags) + rm -f cf_makeflags.tmp]) +AC_MSG_RESULT($cf_cv_makeflags) +AC_SUBST(cf_cv_makeflags) ])dnl dnl --------------------------------------------------------------------------- -dnl Try to determine if the man-pages on the system are compressed, and if -dnl so, what format is used. Use this information to construct a script that -dnl will install man-pages. -AC_DEFUN([NC_MAN_PAGES], -[AC_MSG_CHECKING(format of man-pages) +dnl Option to allow user to override automatic configuration of manpage format. +dnl There are several special cases. +AC_DEFUN([CF_MANPAGE_FORMAT], +[ AC_MSG_CHECKING(format of man-pages) + +AC_ARG_WITH(manpage-format, + [ --with-manpage-format specify manpage-format: gzip/compress/BSDI/normal and + optionally formatted, e.g., gzip,formatted], + [cf_manpage_form=$withval], + [cf_manpage_form=unknown]) + +case ".$cf_manpage_form" in +.gzip|.compress|.BSDI|.normal|.formatted) # (vi + ;; +.unknown|.) # (vi if test -z "$MANPATH" ; then MANPATH="/usr/man:/usr/share/man" fi # look for the 'date' man-page (it's most likely to be installed!) IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" - nc_form=unknown - for nc_dir in $MANPATH; do - test -z "$nc_dir" && nc_dir=/usr/man - nc_rename="" - nc_format=no + cf_manpage_form=unknown + for cf_dir in $MANPATH; do + test -z "$cf_dir" && cf_dir=/usr/man changequote({{,}})dnl - for nc_name in $nc_dir/*/date.[01]* $nc_dir/*/date + for cf_name in $cf_dir/*/date.[01]* $cf_dir/*/date changequote([,])dnl do - nc_test=`echo $nc_name | sed -e 's/*//'` - if test "x$nc_test" = "x$nc_name" ; then - case "$nc_name" in - *.gz) nc_form=gzip; nc_name=`basename $nc_name .gz`;; - *.Z) nc_form=compress; nc_name=`basename $nc_name .Z`;; - *.0) nc_form=BSDI; nc_format=yes;; - *) nc_form=cat;; + cf_test=`echo $cf_name | sed -e 's/*//'` + if test "x$cf_test" = "x$cf_name" ; then + case "$cf_name" in + *.gz) cf_manpage_form=gzip;; + *.Z) cf_manpage_form=compress;; + *.0) cf_manpage_form=BSDI,formatted;; + *) cf_manpage_form=normal;; esac break fi done - if test "$nc_form" != "unknown" ; then + if test "$cf_manpage_form" != "unknown" ; then break fi done IFS="$ac_save_ifs" - if test "$prefix" = "NONE" ; then - nc_prefix="$ac_default_prefix" + ;; +.*) # (vi + AC_MSG_WARN(Unexpected manpage-format) + ;; +esac + +AC_MSG_RESULT($cf_manpage_form) +])dnl +dnl --------------------------------------------------------------------------- +dnl The Debian people have their own naming convention for manpages. This +dnl option lets us override the name of the file containing renaming, or +dnl disable it altogether. +AC_DEFUN([CF_MANPAGE_RENAMES], +[ +AC_MSG_CHECKING(for manpage renaming) + +AC_ARG_WITH(manpage-renames, + [ --with-manpage-renames specify manpage-renaming], + [cf_manpage_renames=$withval], + [cf_manpage_renames=yes]) + +case ".$cf_manpage_renames" in #(vi +.no) #(vi + ;; +.|.yes) + # Debian 'man' program? + if test -f /etc/debian_version ; then + cf_manpage_renames=`cd $srcdir && pwd`/man/man_db.renames else - nc_prefix="$prefix" + cf_manpage_renames=no fi + ;; +esac - # Debian 'man' program? - test -f /etc/debian_version && \ - nc_rename=`cd $srcdir;pwd`/man/man_db.renames +if test "$cf_manpage_renames" != no ; then + if test ! -f $cf_manpage_renames ; then + AC_MSG_ERROR(not a filename: $cf_manpage_renames) + fi test ! -d man && mkdir man # Construct a sed-script to perform renaming within man-pages - if test -n "$nc_rename" ; then - fgrep -v \# $nc_rename | \ - sed -e 's/^/s\//' \ - -e 's/\./\\./' \ - -e 's/ / /g' \ - -e 's/[ ]\+/\//' \ - -e s/\$/\\\/g/ >man/edit_man.sed + if test -n "$cf_manpage_renames" ; then + test ! -d man && mkdir man + $srcdir/man/make_sed.sh $cf_manpage_renames >man/edit_man.sed fi - if test $nc_format = yes ; then - nc_subdir='$mandir/cat' +fi + +AC_MSG_RESULT($cf_manpage_renames) +])dnl +dnl --------------------------------------------------------------------------- +dnl Some people expect each tool to make all aliases for manpages in the +dnl man-directory. This accommodates the older, less-capable implementations +dnl of 'man', and is optional. +AC_DEFUN([CF_MANPAGE_SYMLINKS], +[ +AC_MSG_CHECKING(for manpage symlinks) + +AC_ARG_WITH(manpage-symlinks, + [ --with-manpage-symlinks specify manpage-symlinks], + [cf_manpage_symlinks=$withval], + [cf_manpage_symlinks=yes]) + +AC_MSG_RESULT($cf_manpage_symlinks) +])dnl +dnl --------------------------------------------------------------------------- +dnl Try to determine if the man-pages on the system are compressed, and if +dnl so, what format is used. Use this information to construct a script that +dnl will install man-pages. +AC_DEFUN([CF_MAN_PAGES], +[ +CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:) +CF_MANPAGE_FORMAT +CF_MANPAGE_RENAMES +CF_MANPAGE_SYMLINKS + + if test "$prefix" = "NONE" ; then + cf_prefix="$ac_default_prefix" else - nc_subdir='$mandir/man' + cf_prefix="$prefix" fi -cat >man/edit_man.sh <man/edit_man.sh <>man/edit_man.sh <>man/edit_man.sh <>man/edit_man.sh <\$TMP -NC_EOF +CF_EOF else -cat >>man/edit_man.sh <>man/edit_man.sh <\$TMP -NC_EOF + target="$cf_subdir\$section/\$target" + test \$verb = installing && sed -e "s,@DATADIR@,\$datadir," < \$i | sed -f edit_man.sed >\$TMP +CF_EOF fi -if test $nc_format = yes ; then -cat >>man/edit_man.sh <>man/edit_man.sh <\$TMP.out mv \$TMP.out \$TMP -NC_EOF +CF_EOF fi -case "$nc_form" in -compress) -cat >>man/edit_man.sh <>man/edit_man.sh <>man/edit_man.sh <>man/edit_man.sh <>man/edit_man.sh <>man/edit_man.sh <>man/edit_man.sh <>man/edit_man.sh < + #include + ], + [double x = rand(); printf("result = %g\n", ]ifelse($2,,sin(x),$2)[)], + [cf_cv_need_libm=no], + [cf_cv_need_libm=yes])]) +if test "$cf_cv_need_libm" = yes +then +ifelse($1,,[ + LIBS="$LIBS -lm" +],[$1=-lm]) +fi +]) +dnl --------------------------------------------------------------------------- dnl Compute the object-directory name from the given model name -AC_DEFUN([NC_OBJ_SUBDIR], +AC_DEFUN([CF_OBJ_SUBDIR], [ case $1 in normal) $2='objects' ;; @@ -833,387 +1519,856 @@ AC_DEFUN([NC_OBJ_SUBDIR], esac ])dnl dnl --------------------------------------------------------------------------- +dnl Check the argument to see that it looks like a pathname. Rewrite it if it +dnl begins with one of the prefix/exec_prefix variables, and then again if the +dnl result begins with 'NONE'. This is necessary to workaround autoconf's +dnl delayed evaluation of those symbols. +AC_DEFUN([CF_PATH_SYNTAX],[ +case ".[$]$1" in #(vi +./*) #(vi + ;; +.[a-zA-Z]:[\\/]*) #(vi OS/2 EMX + ;; +.\[$]{*prefix}*) #(vi + eval $1="[$]$1" + case ".[$]$1" in #(vi + .NONE/*) + $1=`echo [$]$1 | sed -e s@NONE@$ac_default_prefix@` + ;; + esac + ;; #(vi +.NONE/*) + $1=`echo [$]$1 | sed -e s@NONE@$ac_default_prefix@` + ;; +*) + AC_ERROR(expected a pathname) + ;; +esac +])dnl +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]) +PROG_EXT= +case $cf_cv_system_name in +os2*) + # We make sure -Zexe is not used -- it would interfere with @PROG_EXT@ + CFLAGS="$CFLAGS -Zmt -D__ST_MT_ERRNO__" + CXXFLAGS="$CXXFLAGS -Zmt -D__ST_MT_ERRNO__" + LDFLAGS=`echo "$LDFLAGS -Zmt -Zcrtdll" | sed "s/-Zexe//g"` + PROG_EXT=".exe" + ;; +cygwin*) + PROG_EXT=".exe" + ;; +esac +AC_SUBST(PROG_EXT) +])dnl +dnl --------------------------------------------------------------------------- dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the dnl misc/tabset install won't work properly. Usually this happens only when dnl using the fallback mkinstalldirs script -AC_DEFUN([NC_PROG_INSTALL], +AC_DEFUN([CF_PROG_INSTALL], [AC_PROG_INSTALL case $INSTALL in /*) ;; *) changequote({{,}})dnl - nc_dir=`echo $INSTALL|sed -e 's%/[^/]*$%%'` - test -z "$nc_dir" && nc_dir=. + cf_dir=`echo $INSTALL|sed -e 's%/[^/]*$%%'` + test -z "$cf_dir" && cf_dir=. changequote([,])dnl - INSTALL=`cd $nc_dir;pwd`/`echo $INSTALL | sed -e 's:^.*/::'` + INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's:^.*/::'` ;; esac ])dnl dnl --------------------------------------------------------------------------- dnl Attempt to determine if we've got one of the flavors of regular-expression dnl code that we can support. -AC_DEFUN([NC_REGEX], +AC_DEFUN([CF_REGEX], [ AC_MSG_CHECKING([for regular-expression headers]) -AC_CACHE_VAL(nc_cv_regex,[ +AC_CACHE_VAL(cf_cv_regex,[ AC_TRY_LINK([#include #include ],[ regex_t *p; int x = regcomp(p, "", 0); int y = regexec(p, "", 0, 0, 0); regfree(p); - ],[nc_cv_regex="regex.h"],[ + ],[cf_cv_regex="regex.h"],[ AC_TRY_LINK([#include ],[ char *p = compile("", "", "", 0); int x = step("", ""); - ],[nc_cv_regex="regexp.h"],[ + ],[cf_cv_regex="regexp.h"],[ + cf_save_LIBS="$LIBS" + LIBS="-lgen $LIBS" AC_TRY_LINK([#include ],[ char *p = compile("", "", ""); int x = step("", ""); - ],[nc_cv_regex="regexpr.h"])])]) + ],[cf_cv_regex="regexpr.h"],[LIBS="$cf_save_LIBS"])])]) ]) -AC_MSG_RESULT($nc_cv_regex) -case $nc_cv_regex in - regex.h) AC_DEFINE(HAVE_REGEX_H) ;; - regexp.h) AC_DEFINE(HAVE_REGEXP_H) ;; - regexpr.h) AC_DEFINE(HAVE_REGEXPR_H) ;; +AC_MSG_RESULT($cf_cv_regex) +case $cf_cv_regex in + regex.h) AC_DEFINE(HAVE_REGEX_H_FUNCS) ;; + regexp.h) AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;; + regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;; esac ])dnl dnl --------------------------------------------------------------------------- dnl Attempt to determine the appropriate CC/LD options for creating a shared dnl library. dnl -dnl Note: $(LOCAL_LDFLAGS) is used to link executables that will run within the +dnl Note: $(LOCAL_LDFLAGS) is used to link executables that will run within the dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib dnl We avoid compiling-in a ../lib path for the shared library since that can dnl lead to unexpected results at runtime. dnl $(LOCAL_LDFLAGS2) has the same intention but assumes that the shared libraries dnl are compiled in ../../lib dnl -dnl The variable 'nc_cv_do_symlinks' is used to control whether we configure +dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure dnl to install symbolic links to the rel/abi versions of shared libraries. dnl +dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi +dnl version when making symbolic links. +dnl dnl Some loaders leave 'so_locations' lying around. It's nice to clean up. -AC_DEFUN([NC_SHARED_OPTS], +AC_DEFUN([CF_SHARED_OPTS], [ - AC_REQUIRE([NC_SYSTYPE]) - AC_REQUIRE([NC_VERSION]) + AC_REQUIRE([CF_SUBST_NCURSES_VERSION]) LOCAL_LDFLAGS= LOCAL_LDFLAGS2= + LD_SHARED_OPTS= + INSTALL_LIB="-m 644" - nc_cv_do_symlinks=no - nc_cv_rm_so_locs=no + cf_cv_do_symlinks=no - case $nc_cv_systype in - HP_UX) + AC_MSG_CHECKING(if release/abi version should be used for shared libs) + AC_ARG_WITH(shlib-version, + [ --with-shlib-version=X Specify rel or abi version for shared libs], + [test -z "$withval" && withval=auto + case $withval in #(vi + yes) #(vi + cf_cv_shlib_version=auto + ;; + rel|abi|auto|no) #(vi + cf_cv_shlib_version=$withval + ;; + *) + AC_ERROR([option value must be one of: rel, abi, auto or no]) + ;; + esac + ],[cf_cv_shlib_version=auto]) + AC_MSG_RESULT($cf_cv_shlib_version) + + cf_cv_rm_so_locs=no + + # Some less-capable ports of gcc support only -fpic + CC_SHARED_OPTS= + if test -n "$GCC" + then + AC_MSG_CHECKING(which $CC option to use) + cf_save_CFLAGS="$CFLAGS" + for CC_SHARED_OPTS in -fPIC -fpic '' + do + CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS" + AC_TRY_COMPILE([#include ],[int x = 1],[break],[]) + done + AC_MSG_RESULT($CC_SHARED_OPTS) + CFLAGS="$cf_save_CFLAGS" + fi + + case $cf_cv_system_name in + beos*) + MK_SHARED_LIB='$(CC) -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0' + ;; + hpux10.*) # (tested with gcc 2.7.2 -- I don't have c89) - if test "${CC}" = "gcc"; then - CC_SHARED_OPTS='-fPIC' + if test -n "$GCC"; then + LD_SHARED_OPTS='-Xlinker +b -Xlinker $(libdir)' else CC_SHARED_OPTS='+Z' + LD_SHARED_OPTS='-Wl,+b,$(libdir)' fi - MK_SHARED_LIB='$(LD) -b -o $[@]' + MK_SHARED_LIB='$(LD) +b $(libdir) -b +h `basename $[@]` -o $[@]' + # HP-UX shared libraries must be executable, and should be + # readonly to exploit a quirk in the memory manager. + INSTALL_LIB="-m 555" + cf_cv_do_symlinks=reverse ;; - IRIX*) - # tested with IRIX 5.2 and 'cc'. - if test "${CC}" = "gcc"; then - CC_SHARED_OPTS='-fPIC' + hpux*) + # (tested with gcc 2.7.2 -- I don't have c89) + if test -n "$GCC"; then + LD_SHARED_OPTS='-Xlinker +b -Xlinker $(libdir)' else + CC_SHARED_OPTS='+Z' + LD_SHARED_OPTS='-Wl,+b,$(libdir)' + fi + MK_SHARED_LIB='$(LD) +b $(libdir) -b -o $[@]' + # HP-UX shared libraries must be executable, and should be + # readonly to exploit a quirk in the memory manager. + INSTALL_LIB="-m 555" + ;; + irix*) + # tested with IRIX 5.2 and 'cc'. + if test -z "$GCC"; then CC_SHARED_OPTS='-KPIC' fi MK_SHARED_LIB='$(LD) -shared -rdata_shared -soname `basename $[@]` -o $[@]' - nc_cv_rm_so_locs=yes + cf_cv_rm_so_locs=yes ;; - Linux) - # tested with Linux 1.2.8 and gcc 2.7.0 (ELF) - CC_SHARED_OPTS='-fPIC' - MK_SHARED_LIB='gcc -o $[@].$(REL_VERSION) -shared -Wl,-soname,`basename $[@].$(ABI_VERSION)`,-stats' + linux*|gnu*) + # tested with Linux 2.0.29 and gcc 2.7.2 (ELF) + test $cf_cv_ld_rpath = yes && cf_ld_rpath_opt="-Wl,-rpath," if test $DFT_LWR_MODEL = "shared" ; then LOCAL_LDFLAGS='-Wl,-rpath,../lib' LOCAL_LDFLAGS2='-Wl,-rpath,../../lib' fi - nc_cv_do_symlinks=yes + test $cf_cv_shlib_version = auto && cf_cv_shlib_version=rel + MK_SHARED_LIB='$(CC) -shared -Wl,-soname,`basename $[@] .$(REL_VERSION)`.$(ABI_VERSION),-stats,-lc -o $[@]' + ;; + openbsd2*) + CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC" + MK_SHARED_LIB='$(LD) -Bshareable -soname,`basename $[@].$(ABI_VERSION)` -o $[@]' ;; - NetBSD|FreeBSD) - CC_SHARED_OPTS='-fpic -DPIC' + openbsd*|freebsd*) + CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC" MK_SHARED_LIB='$(LD) -Bshareable -o $[@]' + test $cf_cv_shlib_version = auto && cf_cv_shlib_version=rel + ;; + netbsd*) + CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC" + test $cf_cv_ld_rpath = yes && cf_ld_rpath_opt="-Wl,-rpath," + if test $DFT_LWR_MODEL = "shared" && test $cf_cv_ld_rpath = yes ; then + LOCAL_LDFLAGS='-Wl,-rpath,../lib' + LOCAL_LDFLAGS2='-Wl,-rpath,../../lib' + EXTRA_LDFLAGS="-Wl,-rpath,\$(libdir) $EXTRA_LDFLAGS" + MK_SHARED_LIB='$(CC) -shared -Wl,-soname,`basename $[@] .$(REL_VERSION)`.$(ABI_VERSION) -o $[@]' + if test $cf_cv_shlib_version = auto; then + if test ! -f /usr/libexec/ld.elf_so; then + cf_cv_shlib_version=rel + fi + fi + else + MK_SHARED_LIB='$(LD) -Bshareable -o $[@]' + fi ;; - OSF1|MLS+) + osf*|mls+*) # tested with OSF/1 V3.2 and 'cc' # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't # link with shared libs). - CC_SHARED_OPTS='' - MK_SHARED_LIB='$(LD) -o $[@].$(REL_VERSION) -shared -soname `basename $[@].$(ABI_VERSION)`' + MK_SHARED_LIB='$(LD) -set_version $(REL_VERSION):$(ABI_VERSION) -expect_unresolved "*" -shared -soname `basename $[@]`' + test $cf_cv_ld_rpath = yes && cf_ld_rpath_opt="-rpath" + case $host_os in + osf4*) + MK_SHARED_LIB="${MK_SHARED_LIB} -msym" + ;; + esac + MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]' if test $DFT_LWR_MODEL = "shared" ; then LOCAL_LDFLAGS='-Wl,-rpath,../lib' LOCAL_LDFLAGS2='-Wl,-rpath,../../lib' fi - nc_cv_do_symlinks=yes - nc_cv_rm_so_locs=yes + cf_cv_rm_so_locs=yes + ;; + sco3.2v5*) # (also uw2* and UW7) hops 13-Apr-98 + # tested with osr5.0.5 + if test $ac_cv_prog_gcc != yes; then + CC_SHARED_OPTS='-belf -KPIC' + fi + MK_SHARED_LIB='$(LD) -dy -G -h `basename $[@] .$(REL_VERSION)`.$(ABI_VERSION) -o [$]@' + if test $cf_cv_ld_rpath = yes ; then + # only way is to set LD_RUN_PATH but no switch for it + RUN_PATH=$libdir + fi + test $cf_cv_shlib_version = auto && cf_cv_shlib_version=rel + LINK_PROGS='LD_RUN_PATH=$(libdir)' + LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib' ;; - SunOS) + sunos4*) # tested with SunOS 4.1.1 and gcc 2.7.0 - # tested with SunOS 5.3 (solaris 2.3) and gcc 2.7.0 - if test $ac_cv_prog_gcc = yes; then - CC_SHARED_OPTS='-fpic' - else + if test $ac_cv_prog_gcc != yes; then CC_SHARED_OPTS='-KPIC' fi - case `uname -r` in - 4.*) - MK_SHARED_LIB='$(LD) -assert pure-text -o $[@].$(REL_VERSION)' - ;; - 5.*) - MK_SHARED_LIB='$(LD) -d y -G -h `basename $[@].$(ABI_VERSION)` -o $[@].$(REL_VERSION)' - ;; - esac - nc_cv_do_symlinks=yes + MK_SHARED_LIB='$(LD) -assert pure-text -o $[@]' + test $cf_cv_shlib_version = auto && cf_cv_shlib_version=rel + ;; + solaris2*) + # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2 + if test $ac_cv_prog_gcc != yes; then + CC_SHARED_OPTS='-KPIC' + fi + MK_SHARED_LIB='$(LD) -dy -G -h `basename $[@] .$(REL_VERSION)`.$(ABI_VERSION) -o $[@]' + if test $cf_cv_ld_rpath = yes ; then + cf_ld_rpath_opt="-R" + EXTRA_LDFLAGS="-R ../lib:\$(libdir) $EXTRA_LDFLAGS" + fi + test $cf_cv_shlib_version = auto && cf_cv_shlib_version=rel ;; - UNIX_SV) - # tested with UnixWare 1.1.2 - CC_SHARED_OPTS='-KPIC' - MK_SHARED_LIB='$(LD) -d y -G -o $[@]' + sysv5uw7*|unix_sv*) + # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc) + if test $ac_cv_prog_gcc != yes; then + CC_SHARED_OPTS='-KPIC' + fi + MK_SHARED_LIB='$(LD) -d y -G -o [$]@' ;; *) CC_SHARED_OPTS='unknown' MK_SHARED_LIB='echo unknown' ;; esac + + # This works if the last tokens in $MK_SHARED_LIB are the -o target. + case "$cf_cv_shlib_version" in #(vi + rel|abi) + case "$MK_SHARED_LIB" in #(vi + *'-o $[@]') + test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes + ;; + *) + AC_MSG_WARN(ignored --with-shlib-version) + ;; + esac + ;; + esac + + if test -n "$cf_ld_rpath_opt" ; then + AC_MSG_CHECKING(if we need a space after rpath option) + cf_save_LIBS="$LIBS" + LIBS="$LIBS ${cf_ld_rpath_opt}/usr/lib" + AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes) + LIBS="$cf_save_LIBS" + AC_MSG_RESULT($cf_rpath_space) + test $cf_rpath_space = yes && cf_ld_rpath_opt="$cf_ld_rpath_opt " + MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\$(libdir)" + fi + AC_SUBST(CC_SHARED_OPTS) + AC_SUBST(LD_SHARED_OPTS) AC_SUBST(MK_SHARED_LIB) + AC_SUBST(LINK_PROGS) + AC_SUBST(LINK_TESTS) + AC_SUBST(EXTRA_LDFLAGS) AC_SUBST(LOCAL_LDFLAGS) AC_SUBST(LOCAL_LDFLAGS2) + AC_SUBST(INSTALL_LIB) ])dnl dnl --------------------------------------------------------------------------- -dnl Check for datatype 'speed_t', which is normally declared via either -dnl sys/types.h or termios.h -AC_DEFUN([NC_SPEED_TYPE], +dnl Check for definitions & structures needed for window size-changing +dnl FIXME: check that this works with "snake" (HP-UX 10.x) +AC_DEFUN([CF_SIZECHANGE], [ -AC_MSG_CHECKING([for speed_t]) -AC_CACHE_VAL(nc_cv_type_speed_t,[ - AC_TRY_COMPILE([ -#include +AC_MSG_CHECKING([declaration of size-change]) +AC_CACHE_VAL(cf_cv_sizechange,[ + cf_cv_sizechange=unknown + cf_save_CFLAGS="$CFLAGS" + +for cf_opts in "" "NEED_PTEM_H" +do + + CFLAGS="$cf_save_CFLAGS" + test -n "$cf_opts" && CFLAGS="$CFLAGS -D$cf_opts" + AC_TRY_COMPILE([#include #if HAVE_TERMIOS_H #include -#endif], - [speed_t x = 0], - [nc_cv_type_speed_t=yes], - [nc_cv_type_speed_t=no]) +#else +#if HAVE_TERMIO_H +#include +#endif +#endif +#if NEED_PTEM_H +/* This is a workaround for SCO: they neglected to define struct winsize in + * termios.h -- it's only in termio.h and ptem.h + */ +#include +#include +#endif +#if !defined(sun) || !defined(HAVE_TERMIOS_H) +#include +#endif +],[ +#ifdef TIOCGSIZE + struct ttysize win; /* FIXME: what system is this? */ + int y = win.ts_lines; + int x = win.ts_cols; +#else +#ifdef TIOCGWINSZ + struct winsize win; + int y = win.ws_row; + int x = win.ws_col; +#else + no TIOCGSIZE or TIOCGWINSZ +#endif /* TIOCGWINSZ */ +#endif /* TIOCGSIZE */ + ], + [cf_cv_sizechange=yes], + [cf_cv_sizechange=no]) + + CFLAGS="$cf_save_CFLAGS" + if test "$cf_cv_sizechange" = yes ; then + echo "size-change succeeded ($cf_opts)" >&AC_FD_CC + test -n "$cf_opts" && AC_DEFINE_UNQUOTED($cf_opts) + break + fi +done ]) -AC_MSG_RESULT($nc_cv_type_speed_t) -test $nc_cv_type_speed_t != yes && AC_DEFINE(speed_t,unsigned) +AC_MSG_RESULT($cf_cv_sizechange) +test $cf_cv_sizechange != no && AC_DEFINE(HAVE_SIZECHANGE) +])dnl +dnl --------------------------------------------------------------------------- +dnl Check for datatype 'speed_t', which is normally declared via either +dnl sys/types.h or termios.h +AC_DEFUN([CF_SPEED_TYPE], +[ +AC_MSG_CHECKING(for speed_t) +OSPEED_INCLUDES= +AC_TRY_COMPILE([#include ], + [speed_t some_variable = 0], + [OSPEED_TYPE=speed_t], + [OSPEED_TYPE=unsigned]) +AC_TRY_COMPILE([#include ], + [speed_t some_variable = 0], + [OSPEED_TYPE=speed_t + OSPEED_INCLUDES="#include "],[]) +AC_SUBST(OSPEED_TYPE) +AC_SUBST(OSPEED_INCLUDES) +if test "$OSPEED_TYPE" = "unsigned" ; then + AC_MSG_RESULT(no) + AC_DEFINE(speed_t,unsigned) +else + AC_MSG_RESULT(yes) +fi ])dnl dnl --------------------------------------------------------------------------- dnl For each parameter, test if the source-directory exists, and if it contains -dnl a 'modules' file. If so, add to the list $nc_cv_src_modules which we'll -dnl use in NC_LIB_RULES. +dnl a 'modules' file. If so, add to the list $cf_cv_src_modules which we'll +dnl use in CF_LIB_RULES. dnl dnl This uses the configured value to make the lists SRC_SUBDIRS and dnl SUB_MAKEFILES which are used in the makefile-generation scheme. -AC_DEFUN([NC_SRC_MODULES], +AC_DEFUN([CF_SRC_MODULES], [ AC_MSG_CHECKING(for src modules) -TEST_DEPS="${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX}" -TEST_ARGS="-l${LIB_NAME}${DFT_ARG_SUFFIX}" -nc_cv_src_modules= -for nc_dir in $1 + +# dependencies and linker-arguments for test-programs +TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS" +TEST_ARGS="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARGS" + +# dependencies and linker-arguments for utility-programs +PROG_ARGS="$TEST_ARGS" + +cf_cv_src_modules= +for cf_dir in $1 do - if test -f $srcdir/$nc_dir/modules; then - if test -z "$nc_cv_src_modules"; then - nc_cv_src_modules=$nc_dir + if test -f $srcdir/$cf_dir/modules; then + + # We may/may not have tack in the distribution, though the + # makefile is. + if test $cf_dir = tack ; then + if test ! -f $srcdir/${cf_dir}/${cf_dir}.h; then + continue + fi + fi + + if test -z "$cf_cv_src_modules"; then + cf_cv_src_modules=$cf_dir else - nc_cv_src_modules="$nc_cv_src_modules $nc_dir" + cf_cv_src_modules="$cf_cv_src_modules $cf_dir" fi + # Make the ncurses_cfg.h file record the library interface files as # well. These are header files that are the same name as their # directory. Ncurses is the only library that does not follow # that pattern. - if test -f $srcdir/${nc_dir}/${nc_dir}.h; then - NC_UPPERCASE($nc_dir,nc_have_include) - AC_DEFINE_UNQUOTED(HAVE_${nc_have_include}_H) - AC_DEFINE_UNQUOTED(HAVE_LIB${nc_have_include}) - TEST_DEPS="${LIB_PREFIX}${nc_dir}${DFT_DEP_SUFFIX} $TEST_DEPS" - TEST_ARGS="-l${nc_dir}${DFT_ARG_SUFFIX} $TEST_ARGS" + if test $cf_dir = tack ; then + continue + elif test -f $srcdir/${cf_dir}/${cf_dir}.h; then + CF_UPPER(cf_have_include,$cf_dir) + AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H) + AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include}) + TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEPS" + TEST_ARGS="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARGS" fi fi done -AC_MSG_RESULT($nc_cv_src_modules) -TEST_ARGS="-L${LIB_DIR} $TEST_ARGS" +AC_MSG_RESULT($cf_cv_src_modules) +TEST_ARGS="-L${LIB_DIR} -L\$(libdir) $TEST_ARGS" AC_SUBST(TEST_DEPS) AC_SUBST(TEST_ARGS) +PROG_ARGS="-L${LIB_DIR} -L\$(libdir) $PROG_ARGS" +AC_SUBST(PROG_ARGS) + SRC_SUBDIRS="man include" -for nc_dir in $nc_cv_src_modules +for cf_dir in $cf_cv_src_modules do - SRC_SUBDIRS="$SRC_SUBDIRS $nc_dir" + SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir" done SRC_SUBDIRS="$SRC_SUBDIRS misc test" -test $nc_cxx_library != no && SRC_SUBDIRS="$SRC_SUBDIRS c++" +test $cf_with_cxx_binding != no && SRC_SUBDIRS="$SRC_SUBDIRS c++" ADA_SUBDIRS= -if test "$ac_cv_prog_gnat_correct" = yes && test -d $srcdir/Ada95; then +if test "$cf_cv_prog_gnat_correct" = yes && test -f $srcdir/Ada95/Makefile.in; then SRC_SUBDIRS="$SRC_SUBDIRS Ada95" - ADA_SUBDIRS="gen ada_include samples" + ADA_SUBDIRS="gen src samples" fi SUB_MAKEFILES= -for nc_dir in $SRC_SUBDIRS +for cf_dir in $SRC_SUBDIRS do - SUB_MAKEFILES="$SUB_MAKEFILES $nc_dir/Makefile" + SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile" done if test -n "$ADA_SUBDIRS"; then - for nc_dir in $ADA_SUBDIRS - do - SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$nc_dir/Makefile" + for cf_dir in $ADA_SUBDIRS + do + SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile" done AC_SUBST(ADA_SUBDIRS) fi ])dnl dnl --------------------------------------------------------------------------- +dnl Check for -lstdc++, which is GNU's standard C++ library. +AC_DEFUN([CF_STDCPP_LIBRARY], +[ +if test -n "$GXX" ; then +case $cf_cv_system_name in #(vi +os2*) #(vi + cf_stdcpp_libname=stdcpp + ;; +*) + cf_stdcpp_libname=stdc++ + ;; +esac +AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[ + cf_save="$LIBS" + LIBS="$LIBS -l$cf_stdcpp_libname" +AC_TRY_LINK([ +#include ],[ +char buf[80]; +strstreambuf foo(buf, sizeof(buf)) +], + [cf_cv_libstdcpp=yes], + [cf_cv_libstdcpp=no]) + LIBS="$cf_save" +]) +test $cf_cv_libstdcpp = yes && CXXLIBS="$CXXLIBS -l$cf_stdcpp_libname" +fi +])dnl +dnl --------------------------------------------------------------------------- dnl Remove "-g" option from the compiler options -AC_DEFUN([NC_STRIP_G_OPT], +AC_DEFUN([CF_STRIP_G_OPT], [$1=`echo ${$1} | sed -e 's/-g //' -e 's/-g$//'`])dnl dnl --------------------------------------------------------------------------- +dnl Check if we need _POSIX_SOURCE defined to use struct sigaction. We'll only +dnl do this if we've found the sigaction function. +dnl +dnl If needed, define SVR4_ACTION. +AC_DEFUN([CF_STRUCT_SIGACTION],[ +if test $ac_cv_func_sigaction = yes; then +AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE) +AC_TRY_COMPILE([ +#include +#include ], + [struct sigaction act], + [sigact_bad=no], + [ +AC_TRY_COMPILE([ +#define _POSIX_SOURCE +#include +#include ], + [struct sigaction act], + [sigact_bad=yes + AC_DEFINE(SVR4_ACTION)], + [sigact_bad=unknown])]) +AC_MSG_RESULT($sigact_bad) +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl Some machines require _POSIX_SOURCE to completely define struct termios. +dnl If so, define SVR4_TERMIO +AC_DEFUN([CF_STRUCT_TERMIOS],[ +if test $ac_cv_header_termios_h = yes ; then + case "$CFLAGS" in + *-D_POSIX_SOURCE*) + termios_bad=dunno ;; + *) termios_bad=maybe ;; + esac + if test $termios_bad = maybe ; then + AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE) + AC_TRY_COMPILE([#include ], + [struct termios foo; int x = foo.c_iflag], + termios_bad=no, [ + AC_TRY_COMPILE([ +#define _POSIX_SOURCE +#include ], + [struct termios foo; int x = foo.c_iflag], + termios_bad=unknown, + termios_bad=yes AC_DEFINE(SVR4_TERMIO)) + ]) + AC_MSG_RESULT($termios_bad) + fi +fi +])dnl +dnl --------------------------------------------------------------------------- dnl Shorthand macro for substituting things that the user may override dnl with an environment variable. dnl dnl $1 = long/descriptive name dnl $2 = environment variable dnl $3 = default value -AC_DEFUN([NC_SUBST], -[AC_CACHE_VAL(nc_cv_subst_$2,[ +AC_DEFUN([CF_SUBST], +[AC_CACHE_VAL(cf_cv_subst_$2,[ AC_MSG_CHECKING(for $1 (symbol $2)) test -z "[$]$2" && $2=$3 AC_MSG_RESULT([$]$2) AC_SUBST($2) -nc_cv_subst_$2=[$]$2]) -$2=${nc_cv_subst_$2} -])dnl -dnl --------------------------------------------------------------------------- -dnl Check for declarion of sys_errlist in one of stdio.h and errno.h. -dnl Declaration of sys_errlist on BSD4.4 interferes with our declaration. -dnl Reported by Keith Bostic. -AC_DEFUN([NC_SYS_ERRLIST], -[ -AC_MSG_CHECKING([declaration of sys_errlist]) -AC_CACHE_VAL(nc_cv_dcl_sys_errlist,[ - AC_TRY_COMPILE([ -#include -#include -#include ], - [ char *c = (char *) *sys_errlist; ], - [nc_cv_dcl_sys_errlist=yes], - [nc_cv_dcl_sys_errlist=no]) - ]) -AC_MSG_RESULT($nc_cv_dcl_sys_errlist) -test $nc_cv_dcl_sys_errlist = yes && AC_DEFINE(HAVE_EXTERN_SYS_ERRLIST) +cf_cv_subst_$2=[$]$2]) +$2=${cf_cv_subst_$2} ])dnl dnl --------------------------------------------------------------------------- -dnl Derive the system-type (our main clue to the method of building shared -dnl libraries). -AC_DEFUN([NC_SYSTYPE], +dnl Get the version-number for use in shared-library naming, etc. +AC_DEFUN([CF_SUBST_NCURSES_VERSION], [ -AC_CACHE_VAL(nc_cv_systype,[ changequote(,)dnl -nc_cv_systype="`(uname -s || hostname || echo unknown) 2>/dev/null |sed -e s'/[:\/.-]/_/'g | sed 1q`" +NCURSES_MAJOR="`egrep '^NCURSES_MAJOR[ ]*=' $srcdir/dist.mk | sed -e 's/^[^0-9]*//'`" +NCURSES_MINOR="`egrep '^NCURSES_MINOR[ ]*=' $srcdir/dist.mk | sed -e 's/^[^0-9]*//'`" +NCURSES_PATCH="`egrep '^NCURSES_PATCH[ ]*=' $srcdir/dist.mk | sed -e 's/^[^0-9]*//'`" changequote([,])dnl -if test -z "$nc_cv_systype"; then nc_cv_systype=unknown;fi -]) -AC_MSG_RESULT(System type is $nc_cv_systype) +cf_cv_abi_version=${NCURSES_MAJOR} +cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR} +dnl Show the computed version, for logging +AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version (`date`)) +dnl We need these values in the generated headers +AC_SUBST(NCURSES_MAJOR) +AC_SUBST(NCURSES_MINOR) +AC_SUBST(NCURSES_PATCH) +dnl We need these values in the generated makefiles +AC_SUBST(cf_cv_rel_version) +AC_SUBST(cf_cv_abi_version) +AC_SUBST(cf_cv_cc_bool_type) +AC_SUBST(cf_cv_builtin_bool) +AC_SUBST(cf_cv_type_of_bool)dnl ])dnl dnl --------------------------------------------------------------------------- -dnl On some systems ioctl(fd, TIOCGWINSZ, &size) will always return {0,0} until -dnl ioctl(fd, TIOCSWINSZ, &size) is called to explicitly set the size of the -dnl screen. -dnl -dnl Attempt to determine if we're on such a system by running a test-program. -dnl This won't work, of course, if the configure script is run in batch mode, -dnl since we've got to have access to the terminal. -dnl -dnl 1996/4/26 - Converted this into a simple test for able-to-compile, since -dnl we're reminded that _nc_get_screensize() does the same functional test. -AC_DEFUN([NC_TIOCGWINSZ], +dnl Check if we can include with ; this breaks on +dnl older SCO configurations. +AC_DEFUN([CF_SYS_TIME_SELECT], [ -AC_MSG_CHECKING([for working TIOCGWINSZ]) -AC_CACHE_VAL(nc_cv_use_tiocgwinsz,[ - AC_TRY_RUN([ -#if HAVE_TERMIOS_H -#include +AC_MSG_CHECKING(if sys/time.h works with sys/select.h) +AC_CACHE_VAL(cf_cv_sys_time_select,[ +AC_TRY_COMPILE([ +#include +#if HAVE_SYS_TIME_H +#include #endif -#if SYSTEM_LOOKS_LIKE_SCO -/* they neglected to define struct winsize in termios.h -- it's only - in termio.h */ -#include -#include +#if HAVE_SYS_SELECT_H +#include #endif -#if !defined(sun) || !defined(HAVE_TERMIOS_H) -#include +],[],[cf_cv_sys_time_select=yes], + [cf_cv_sys_time_select=no]) + ]) +AC_MSG_RESULT($cf_cv_sys_time_select) +test $cf_cv_sys_time_select = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT) +])dnl +dnl --------------------------------------------------------------------------- +dnl Determine the type we should use for chtype (and attr_t, which is treated +dnl as the same thing). We want around 32 bits, so on most machines want a +dnl long, but on newer 64-bit machines, probably want an int. If we're using +dnl wide characters, we have to have a type compatible with that, as well. +AC_DEFUN([CF_TYPEOF_CHTYPE], +[ +AC_REQUIRE([CF_UNSIGNED_LITERALS]) +AC_MSG_CHECKING([for type of chtype]) +AC_CACHE_VAL(cf_cv_typeof_chtype,[ + AC_TRY_RUN([ +#if USE_WIDEC_SUPPORT +#include /* we want wchar_t */ +#define WANT_BITS 39 +#else +#define WANT_BITS 31 #endif +#include int main() { - static struct winsize size; - int fd; - for (fd = 0; fd <= 2; fd++) { /* try in/out/err in case redirected */ - if (ioctl(0, TIOCGWINSZ, &size) == 0 - && size.ws_row > 0 - && size.ws_col > 0) - exit(0); + FILE *fp = fopen("cf_test.out", "w"); + if (fp != 0) { + char *result = "long"; +#if USE_WIDEC_SUPPORT + /* + * If wchar_t is smaller than a long, it must be an int or a + * short. We prefer not to use a short anyway. + */ + if (sizeof(unsigned long) > sizeof(wchar_t)) + result = "int"; +#endif + if (sizeof(unsigned long) > sizeof(unsigned int)) { + int n; + unsigned int x; + for (n = 0; n < WANT_BITS; n++) { + unsigned int y = (x >> n); + if (y != 1 || x == 0) { + x = 0; + break; + } + } + /* + * If x is nonzero, an int is big enough for the bits + * that we want. + */ + result = (x != 0) ? "int" : "long"; + } + fputs(result, fp); + fclose(fp); } - exit(0); /* in either case, it compiles & links ... */ + exit(0); } ], - [nc_cv_use_tiocgwinsz=yes], - [nc_cv_use_tiocgwinsz=no], - [nc_cv_use_tiocgwinsz=unknown]) + [cf_cv_typeof_chtype=`cat cf_test.out`], + [cf_cv_typeof_chtype=long], + [cf_cv_typeof_chtype=long]) + rm -f cf_test.out ]) -AC_MSG_RESULT($nc_cv_use_tiocgwinsz) -test $nc_cv_use_tiocgwinsz != yes && AC_DEFINE(BROKEN_TIOCGWINSZ) +AC_MSG_RESULT($cf_cv_typeof_chtype) + +AC_SUBST(cf_cv_typeof_chtype) +AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype) + +cf_cv_1UL="1" +test "$cf_cv_unsigned_literals" = yes && cf_cv_1UL="${cf_cv_1UL}U" +test "$cf_cv_typeof_chtype" = long && cf_cv_1UL="${cf_cv_1UL}L" +AC_SUBST(cf_cv_1UL) + ])dnl dnl --------------------------------------------------------------------------- dnl -AC_DEFUN([NC_TYPE_SIGACTION], +AC_DEFUN([CF_TYPE_SIGACTION], [ AC_MSG_CHECKING([for type sigaction_t]) -AC_CACHE_VAL(nc_cv_type_sigaction,[ +AC_CACHE_VAL(cf_cv_type_sigaction,[ AC_TRY_COMPILE([ #include ], [sigaction_t x], - [nc_cv_type_sigaction=yes], - [nc_cv_type_sigaction=no]) + [cf_cv_type_sigaction=yes], + [cf_cv_type_sigaction=no])]) +AC_MSG_RESULT($cf_cv_type_sigaction) +test $cf_cv_type_sigaction = yes && AC_DEFINE(HAVE_TYPE_SIGACTION) +])dnl +dnl --------------------------------------------------------------------------- +dnl Test if the compiler supports 'U' and 'L' suffixes. Only old compilers +dnl won't, but they're still there. +AC_DEFUN([CF_UNSIGNED_LITERALS], +[ +AC_MSG_CHECKING([if unsigned literals are legal]) +AC_CACHE_VAL(cf_cv_unsigned_literals,[ + AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1], + [cf_cv_unsigned_literals=yes], + [cf_cv_unsigned_literals=no]) ]) -AC_MSG_RESULT($nc_cv_type_sigaction) -test $nc_cv_type_sigaction = yes && AC_DEFINE(HAVE_TYPE_SIGACTION) -]) +AC_MSG_RESULT($cf_cv_unsigned_literals) +])dnl dnl --------------------------------------------------------------------------- -dnl Make an uppercase version of a given name -AC_DEFUN([NC_UPPERCASE], +dnl Make an uppercase version of a variable +dnl $1=uppercase($2) +AC_DEFUN([CF_UPPER], [ changequote(,)dnl -$2=`echo $1 |tr '[a-z]' '[A-Z]'` +$1=`echo $2 | tr '[a-z]' '[A-Z]'` changequote([,])dnl ])dnl dnl --------------------------------------------------------------------------- -dnl Get the version-number for use in shared-library naming, etc. -AC_DEFUN([NC_VERSION], +dnl Compute the shift-mask that we'll use for wide-character indices. We use +dnl all but the index portion of chtype for storing attributes. +AC_DEFUN([CF_WIDEC_SHIFT], [ -changequote(,)dnl -NCURSES_MAJOR="`egrep '^NCURSES_MAJOR[ ]*=' $srcdir/dist.mk | sed -e 's/^[^0-9]*//'`" -NCURSES_MINOR="`egrep '^NCURSES_MINOR[ ]*=' $srcdir/dist.mk | sed -e 's/^[^0-9]*//'`" -NCURSES_PATCH="`egrep '^NCURSES_PATCH[ ]*=' $srcdir/dist.mk | sed -e 's/^[^0-9]*//'`" -changequote([,])dnl -nc_cv_abi_version=${NCURSES_MAJOR} -nc_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR} -dnl Show the computed version, for logging -AC_MSG_RESULT(Configuring NCURSES $nc_cv_rel_version ABI $nc_cv_abi_version (`date`)) -dnl We need these values in the generated headers -AC_SUBST(NCURSES_MAJOR) -AC_SUBST(NCURSES_MINOR) -AC_SUBST(NCURSES_PATCH) -dnl We need these values in the generated makefiles -AC_SUBST(nc_cv_rel_version) -AC_SUBST(nc_cv_abi_version) -AC_SUBST(nc_cv_builtin_bool) -AC_SUBST(nc_cv_type_of_bool) +AC_REQUIRE([CF_TYPEOF_CHTYPE]) +AC_MSG_CHECKING([for number of bits in chtype]) +AC_CACHE_VAL(cf_cv_shift_limit,[ + AC_TRY_RUN([ +#include +int main() +{ + FILE *fp = fopen("cf_test.out", "w"); + if (fp != 0) { + int n; + unsigned TYPEOF_CHTYPE x = 1L; + for (n = 0; ; n++) { + unsigned long y = (x >> n); + if (y != 1 || x == 0) + break; + x <<= 1; + } + fprintf(fp, "%d", n); + fclose(fp); + } + exit(0); +} + ], + [cf_cv_shift_limit=`cat cf_test.out`], + [cf_cv_shift_limit=32], + [cf_cv_shift_limit=32]) + rm -f cf_test.out + ]) +AC_MSG_RESULT($cf_cv_shift_limit) +AC_SUBST(cf_cv_shift_limit) + +AC_MSG_CHECKING([for width of character-index]) +AC_CACHE_VAL(cf_cv_widec_shift,[ +if test ".$with_widec" = ".yes" ; then + cf_attrs_width=39 + if ( expr $cf_cv_shift_limit \> $cf_attrs_width >/dev/null ) + then + cf_cv_widec_shift=`expr 16 + $cf_cv_shift_limit - $cf_attrs_width` + else + cf_cv_widec_shift=16 + fi +else + cf_cv_widec_shift=8 +fi +]) +AC_MSG_RESULT($cf_cv_widec_shift) +AC_SUBST(cf_cv_widec_shift) +])dnl +dnl --------------------------------------------------------------------------- +dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just +dnl defaulting to yes/no. +dnl +dnl $1 = option name +dnl $2 = help-text +dnl $3 = environment variable to set +dnl $4 = default value, shown in the help-message, must be a constant +dnl $5 = default value, if it's an expression & cannot be in the help-message +dnl +AC_DEFUN([CF_WITH_PATH], +[AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),, +ifelse($4,,[withval="${$3}"],[withval="${$3-ifelse($5,,$4,$5)}"]))dnl +CF_PATH_SYNTAX(withval) +eval $3="$withval" +AC_SUBST($3)dnl +])dnl +dnl --------------------------------------------------------------------------- +dnl Process an option specifying a list of colon-separated paths. +dnl +dnl $1 = option name +dnl $2 = help-text +dnl $3 = environment variable to set +dnl $4 = default value, shown in the help-message, must be a constant +dnl $5 = default value, if it's an expression & cannot be in the help-message +dnl +AC_DEFUN([CF_WITH_PATHLIST],[ +AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),, +ifelse($4,,[withval="${$3}"],[withval="${$3-ifelse($5,,$4,$5)}"]))dnl + +IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" +cf_dst_path= +for cf_src_path in $withval +do + CF_PATH_SYNTAX(cf_src_path) + test -n "$cf_dst_path" && cf_dst_path="${cf_dst_path}:" + cf_dst_path="${cf_dst_path}${cf_src_path}" +done +IFS="$ac_save_ifs" + +eval $3="$cf_dst_path" +AC_SUBST($3)dnl ])dnl