X-Git-Url: http://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=test%2Faclocal.m4;h=d147f0c9dd94cb513a9f48440b671d83e5b76753;hp=47928a057bf1751ba11232d18655f9d0e8a1d683;hb=b35ecb17e0406b48556609207aa52e9fee15cec6;hpb=a8987e73ec254703634802b4f7ee30d3a485524d diff --git a/test/aclocal.m4 b/test/aclocal.m4 index 47928a05..d147f0c9 100644 --- a/test/aclocal.m4 +++ b/test/aclocal.m4 @@ -1,45 +1,370 @@ -dnl $Id: aclocal.m4,v 1.6 2003/10/19 00:09:23 tom Exp $ +dnl*************************************************************************** +dnl Copyright (c) 2003-2009,2010 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 $Id: aclocal.m4,v 1.41 2010/10/23 20:21:12 tom Exp $ +dnl +dnl Author: Thomas E. Dickey +dnl +dnl Macros used in NCURSES test programs auto-configuration script. +dnl +dnl These macros are maintained separately from NCURSES. The copyright on +dnl this file applies to the aggregation of macros and does not affect use of +dnl these macros in other applications. +dnl +dnl See http://invisible-island.net/autoconf/ for additional information. +dnl dnl --------------------------------------------------------------------------- dnl --------------------------------------------------------------------------- -dnl CF_ADD_INCDIR version: 4 updated: 2002/12/21 14:25:52 +dnl CF_ADD_CFLAGS version: 10 updated: 2010/05/26 05:38:42 +dnl ------------- +dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS +dnl The second parameter if given makes this macro verbose. +dnl +dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS, +dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily +dnl confused by the quotes (which require backslashes to keep them usable). +AC_DEFUN([CF_ADD_CFLAGS], +[ +cf_fix_cppflags=no +cf_new_cflags= +cf_new_cppflags= +cf_new_extra_cppflags= + +for cf_add_cflags in $1 +do +case $cf_fix_cppflags in +no) + case $cf_add_cflags in #(vi + -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi + case $cf_add_cflags in + -D*) + cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'` + + test "${cf_add_cflags}" != "${cf_tst_cflags}" \ + && test -z "${cf_tst_cflags}" \ + && cf_fix_cppflags=yes + + if test $cf_fix_cppflags = yes ; then + cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" + continue + elif test "${cf_tst_cflags}" = "\"'" ; then + cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" + continue + fi + ;; + esac + case "$CPPFLAGS" in + *$cf_add_cflags) #(vi + ;; + *) #(vi + case $cf_add_cflags in #(vi + -D*) + cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'` + CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags) + ;; + esac + cf_new_cppflags="$cf_new_cppflags $cf_add_cflags" + ;; + esac + ;; + *) + cf_new_cflags="$cf_new_cflags $cf_add_cflags" + ;; + esac + ;; +yes) + cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" + + cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'` + + test "${cf_add_cflags}" != "${cf_tst_cflags}" \ + && test -z "${cf_tst_cflags}" \ + && cf_fix_cppflags=no + ;; +esac +done + +if test -n "$cf_new_cflags" ; then + ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)]) + CFLAGS="$CFLAGS $cf_new_cflags" +fi + +if test -n "$cf_new_cppflags" ; then + ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)]) + CPPFLAGS="$CPPFLAGS $cf_new_cppflags" +fi + +if test -n "$cf_new_extra_cppflags" ; then + ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)]) + EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS" +fi + +AC_SUBST(EXTRA_CPPFLAGS) + +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_ADD_INCDIR version: 13 updated: 2010/05/26 16:44:57 dnl ------------- dnl Add an include-directory to $CPPFLAGS. Don't add /usr/include, since it's dnl redundant. We don't normally need to add -I/usr/local/include for gcc, dnl but old versions (and some misinstalled ones) need that. To make things -dnl worse, gcc 3.x gives error messages if -I/usr/local/include is added to +dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to dnl the include-path). AC_DEFUN([CF_ADD_INCDIR], [ -for cf_add_incdir in $1 -do - while true +if test -n "$1" ; then + for cf_add_incdir in $1 + do + while test $cf_add_incdir != /usr/include do - case $cf_add_incdir in - /usr/include) # (vi - ;; - /usr/local/include) # (vi + if test -d $cf_add_incdir + then + cf_have_incdir=no + if test -n "$CFLAGS$CPPFLAGS" ; then + # a loop is needed to ensure we can add subdirs of existing dirs + for cf_test_incdir in $CFLAGS $CPPFLAGS ; do + if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then + cf_have_incdir=yes; break + fi + done + fi + + if test "$cf_have_incdir" = no ; then + if test "$cf_add_incdir" = /usr/local/include ; then if test "$GCC" = yes then - cf_save_CPPFLAGS="$CPPFLAGS" - CPPFLAGS="$CPPFLAGS -I$cf_add_incdir" - AC_TRY_COMPILE([#include ], - [printf("Hello")], - [], - [CPPFLAGS="$cf_save_CPPFLAGS"]) + cf_save_CPPFLAGS=$CPPFLAGS + CPPFLAGS="$CPPFLAGS -I$cf_add_incdir" + AC_TRY_COMPILE([#include ], + [printf("Hello")], + [], + [cf_have_incdir=yes]) + CPPFLAGS=$cf_save_CPPFLAGS fi - ;; - *) # (vi - CPPFLAGS="$CPPFLAGS -I$cf_add_incdir" - ;; - esac - 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" + fi + fi + + if test "$cf_have_incdir" = no ; then + CF_VERBOSE(adding $cf_add_incdir to include-path) + ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir" + + cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'` + test "$cf_top_incdir" = "$cf_add_incdir" && break + cf_add_incdir="$cf_top_incdir" + else + break + fi + fi done + done +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05 +dnl ---------- +dnl Add a library, used to enforce consistency. +dnl +dnl $1 = library to add, without the "-l" +dnl $2 = variable to update (default $LIBS) +AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl +dnl --------------------------------------------------------------------------- +dnl CF_ADD_LIBDIR version: 9 updated: 2010/05/26 16:44:57 +dnl ------------- +dnl Adds to the library-path +dnl +dnl Some machines have trouble with multiple -L options. +dnl +dnl $1 is the (list of) directory(s) to add +dnl $2 is the optional name of the variable to update (default LDFLAGS) +dnl +AC_DEFUN([CF_ADD_LIBDIR], +[ +if test -n "$1" ; then + for cf_add_libdir in $1 + do + if test $cf_add_libdir = /usr/lib ; then + : + elif test -d $cf_add_libdir + then + cf_have_libdir=no + if test -n "$LDFLAGS$LIBS" ; then + # a loop is needed to ensure we can add subdirs of existing dirs + for cf_test_libdir in $LDFLAGS $LIBS ; do + if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then + cf_have_libdir=yes; break + fi + done + fi + if test "$cf_have_libdir" = no ; then + CF_VERBOSE(adding $cf_add_libdir to library-path) + ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])" + fi + fi + done +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_ADD_LIBS version: 1 updated: 2010/06/02 05:03:05 +dnl ----------- +dnl Add one or more libraries, used to enforce consistency. +dnl +dnl $1 = libraries to add, with the "-l", etc. +dnl $2 = variable to update (default $LIBS) +AC_DEFUN([CF_ADD_LIBS],[ifelse($2,,LIBS,[$2])="$1 [$]ifelse($2,,LIBS,[$2])"])dnl +dnl --------------------------------------------------------------------------- +dnl CF_ADD_SUBDIR_PATH version: 3 updated: 2010/07/03 20:58:12 +dnl ------------------ +dnl Append to a search-list for a nonstandard header/lib-file +dnl $1 = the variable to return as result +dnl $2 = the package name +dnl $3 = the subdirectory, e.g., bin, include or lib +dnl $4 = the directory under which we will test for subdirectories +dnl $5 = a directory that we do not want $4 to match +AC_DEFUN([CF_ADD_SUBDIR_PATH], +[ +test "$4" != "$5" && \ +test -d "$4" && \ +ifelse([$5],NONE,,[(test $5 = NONE || test "$4" != "$5") &&]) { + test -n "$verbose" && echo " ... testing for $3-directories under $4" + test -d $4/$3 && $1="[$]$1 $4/$3" + test -d $4/$3/$2 && $1="[$]$1 $4/$3/$2" + test -d $4/$3/$2/$3 && $1="[$]$1 $4/$3/$2/$3" + test -d $4/$2/$3 && $1="[$]$1 $4/$2/$3" + test -d $4/$2/$3/$2 && $1="[$]$1 $4/$2/$3/$2" +} +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_ANSI_CC_CHECK version: 10 updated: 2010/10/23 15:52:32 +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_CACHE_CHECK(for ${CC:-cc} option to accept ANSI C, cf_cv_ansi_cc,[ +cf_cv_ansi_cc=no +cf_save_CFLAGS="$CFLAGS" +cf_save_CPPFLAGS="$CPPFLAGS" +# Don't try gcc -ansi; that turns off useful extensions and +# breaks some systems' header files. +# AIX -qlanglvl=ansi +# Ultrix and OSF/1 -std1 +# HP-UX -Aa -D_HPUX_SOURCE +# SVR4 -Xc +# UnixWare 1.2 (cannot use -Xc, since ANSI/POSIX clashes) +for cf_arg in "-DCC_HAS_PROTOS" \ + "" \ + -qlanglvl=ansi \ + -std1 \ + -Ae \ + "-Aa -D_HPUX_SOURCE" \ + -Xc +do + CF_ADD_CFLAGS($cf_arg) + AC_TRY_COMPILE( +[ +#ifndef CC_HAS_PROTOS +#if !defined(__STDC__) || (__STDC__ != 1) +choke me +#endif +#endif +],[ + int test (int i, double x); + struct s1 {int (*f) (int a);}; + struct s2 {int (*f) (double a);};], + [cf_cv_ansi_cc="$cf_arg"; break]) done +CFLAGS="$cf_save_CFLAGS" +CPPFLAGS="$cf_save_CPPFLAGS" +]) + +if test "$cf_cv_ansi_cc" != "no"; then +if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then + CF_ADD_CFLAGS($cf_cv_ansi_cc) +else + AC_DEFINE(CC_HAS_PROTOS) +fi +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_ANSI_CC_REQD version: 4 updated: 2008/03/23 14:48:54 +dnl --------------- +dnl For programs that must use an ANSI compiler, obtain compiler options that +dnl will make it recognize prototypes. We'll do preprocessor checks in other +dnl macros, since tools such as unproto can fake prototypes, but only part of +dnl the preprocessor. +AC_DEFUN([CF_ANSI_CC_REQD], +[AC_REQUIRE([CF_ANSI_CC_CHECK]) +if test "$cf_cv_ansi_cc" = "no"; then + AC_MSG_ERROR( +[Your compiler does not appear to recognize prototypes. +You have the following choices: + a. adjust your compiler options + b. get an up-to-date compiler + c. use a wrapper such as unproto]) +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31 +dnl -------------- +dnl Allow user to disable a normally-on option. +AC_DEFUN([CF_ARG_DISABLE], +[CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl +dnl --------------------------------------------------------------------------- +dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31 +dnl ------------- +dnl Allow user to enable a normally-off option. +AC_DEFUN([CF_ARG_ENABLE], +[CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl +dnl --------------------------------------------------------------------------- +dnl CF_ARG_OPTION version: 4 updated: 2010/05/26 05:38:42 +dnl ------------- +dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus +dnl values. +dnl +dnl Parameters: +dnl $1 = option name +dnl $2 = help-string +dnl $3 = action to perform if option is not default +dnl $4 = action if perform if option is default +dnl $5 = default option value (either 'yes' or 'no') +AC_DEFUN([CF_ARG_OPTION], +[AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes) + if test "$enableval" != "$5" ; then +ifelse([$3],,[ :]dnl +,[ $3]) ifelse([$4],,,[ + else + $4]) + fi],[enableval=$5 ifelse([$4],,,[ + $4 ])dnl + ])])dnl dnl --------------------------------------------------------------------------- -dnl CF_CHECK_CACHE version: 7 updated: 2001/12/19 00:50:10 +dnl CF_CHECK_CACHE version: 11 updated: 2008/03/23 14:45:59 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. @@ -48,9 +373,12 @@ dnl If we've packaged config.guess and config.sub, run that (since it does a dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM dnl which is useful in cross-compiles. +dnl +dnl Note: we would use $ac_config_sub, but that is one of the places where +dnl autoconf 2.5x broke compatibility with autoconf 2.13 AC_DEFUN([CF_CHECK_CACHE], [ -if test -f $srcdir/config.guess ; 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 @@ -67,21 +395,44 @@ 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.") + AC_MSG_ERROR("Please remove config.cache and try again.") fi ])dnl dnl --------------------------------------------------------------------------- -dnl CF_CURSES_ACS_MAP version: 3 updated: 2003/05/17 22:19:02 +dnl CF_CHECK_CFLAGS version: 2 updated: 2001/12/30 19:09:58 +dnl --------------- +dnl Conditionally add to $CFLAGS and $CPPFLAGS values which are derived from +dnl a build-configuration such as imake. These have the pitfall that they +dnl often contain compiler-specific options which we cannot use, mixed with +dnl preprocessor options that we usually can. +AC_DEFUN([CF_CHECK_CFLAGS], +[ +CF_VERBOSE(checking additions to CFLAGS) +cf_check_cflags="$CFLAGS" +cf_check_cppflags="$CPPFLAGS" +CF_ADD_CFLAGS($1,yes) +if test "$cf_check_cflags" != "$CFLAGS" ; then +AC_TRY_LINK([#include ],[printf("Hello world");],, + [CF_VERBOSE(test-compile failed. Undoing change to \$CFLAGS) + if test "$cf_check_cppflags" != "$CPPFLAGS" ; then + CF_VERBOSE(but keeping change to \$CPPFLAGS) + fi + CFLAGS="$cf_check_flags"]) +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_CURSES_ACS_MAP version: 6 updated: 2010/10/23 15:54:49 dnl ----------------- dnl Check for likely values of acs_map[]: AC_DEFUN([CF_CURSES_ACS_MAP], [ +AC_REQUIRE([CF_NCURSES_WRAP_PREFIX])dnl AC_CACHE_CHECK(for alternate character set array, cf_cv_curses_acs_map,[ cf_cv_curses_acs_map=unknown -for name in acs_map _acs_map __acs_map _nc_acs_map +for name in acs_map _acs_map __acs_map ${NCURSES_WRAP_PREFIX}acs_map do AC_TRY_LINK([ -#include <${cf_cv_ncurses_header-curses.h}> +#include <${cf_cv_ncurses_header:-curses.h}> ],[ $name['k'] = ACS_PLUS ],[cf_cv_curses_acs_map=$name; break]) @@ -91,17 +442,48 @@ done test "$cf_cv_curses_acs_map" != unknown && AC_DEFINE_UNQUOTED(CURSES_ACS_ARRAY,$cf_cv_curses_acs_map) ]) dnl --------------------------------------------------------------------------- -dnl CF_CURSES_CHECK_TYPE version: 2 updated: 2003/03/01 23:40:33 +dnl CF_CURSES_CHECK_DATA version: 3 updated: 2010/10/23 15:54:49 +dnl -------------------- +dnl Check if curses.h defines the given data/variable. +dnl Use this after CF_NCURSES_CONFIG or CF_CURSES_CONFIG. +AC_DEFUN([CF_CURSES_CHECK_DATA], +[ +AC_MSG_CHECKING(for data $1 declaration in ${cf_cv_ncurses_header:-curses.h}) +AC_TRY_COMPILE(CF__CURSES_HEAD,[ +void *foo = &($1) +],cf_result=yes,cf_result=no) +AC_MSG_RESULT($cf_result) +if test $cf_result = yes ; then + CF_UPPER(cf_result,have_curses_data_$1) + AC_DEFINE_UNQUOTED($cf_result) +else + AC_MSG_CHECKING(for data $1 in library) + AC_TRY_LINK(CF__CURSES_HEAD +[extern char $1;],[ + do { + void *foo = &($1); + ${cf_cv_main_return:-return}(foo == 0); + } while (0) +],[cf_result=yes],[cf_result=no]) + AC_MSG_RESULT($cf_result) + if test $cf_result = yes ; then + CF_UPPER(cf_result,decl_curses_data_$1) + AC_DEFINE_UNQUOTED($cf_result) + fi +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_CURSES_CHECK_TYPE version: 3 updated: 2010/10/23 15:54:49 dnl -------------------- dnl Check if curses.h defines the given type AC_DEFUN([CF_CURSES_CHECK_TYPE], [ -AC_MSG_CHECKING(for type $1 in ${cf_cv_ncurses_header-curses.h}) +AC_MSG_CHECKING(for type $1 in ${cf_cv_ncurses_header:-curses.h}) AC_TRY_COMPILE([ #ifndef _XOPEN_SOURCE_EXTENDED #define _XOPEN_SOURCE_EXTENDED #endif -#include <${cf_cv_ncurses_header-curses.h}>],[ +#include <${cf_cv_ncurses_header:-curses.h}>],[ $1 foo ],cf_result=yes,cf_result=no) AC_MSG_RESULT($cf_result) @@ -113,7 +495,19 @@ else fi ])dnl dnl --------------------------------------------------------------------------- -dnl CF_CURSES_CPPFLAGS version: 7 updated: 2003/06/06 00:48:41 +dnl CF_CURSES_CONFIG version: 2 updated: 2006/10/29 11:06:27 +dnl ---------------- +dnl Tie together the configure-script macros for curses. It may be ncurses, +dnl but unless asked, we do not make a special search for ncurses. However, +dnl still check for the ncurses version number, for use in other macros. +AC_DEFUN([CF_CURSES_CONFIG], +[ +CF_CURSES_CPPFLAGS +CF_NCURSES_VERSION +CF_CURSES_LIBS +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_CURSES_CPPFLAGS version: 10 updated: 2009/01/06 19:34:11 dnl ------------------ dnl Look for the curses headers. AC_DEFUN([CF_CURSES_CPPFLAGS],[ @@ -121,7 +515,7 @@ AC_DEFUN([CF_CURSES_CPPFLAGS],[ AC_CACHE_CHECK(for extra include directories,cf_cv_curses_incdir,[ cf_cv_curses_incdir=no case $host_os in #(vi -hpux10.*|hpux11.*) #(vi +hpux10.*) #(vi test -d /usr/include/curses_colr && \ cf_cv_curses_incdir="-I/usr/include/curses_colr" ;; @@ -132,15 +526,63 @@ sunos3*|sunos4*) ;; esac ]) -test "$cf_cv_curses_incdir" != no && CPPFLAGS="$cf_cv_curses_incdir $CPPFLAGS" +test "$cf_cv_curses_incdir" != no && CPPFLAGS="$CPPFLAGS $cf_cv_curses_incdir" +CF_CURSES_HEADER +CF_TERM_HEADER +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_CURSES_FUNCS version: 15 updated: 2010/10/23 15:52:32 +dnl --------------- +dnl Curses-functions are a little complicated, since a lot of them are macros. +AC_DEFUN([CF_CURSES_FUNCS], +[ +AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl +AC_REQUIRE([CF_XOPEN_CURSES]) +AC_REQUIRE([CF_CURSES_TERM_H]) +for cf_func in $1 +do + CF_UPPER(cf_tr_func,$cf_func) + AC_MSG_CHECKING(for ${cf_func}) + CF_MSG_LOG(${cf_func}) + AC_CACHE_VAL(cf_cv_func_$cf_func,[ + eval cf_result='$ac_cv_func_'$cf_func + if test ".$cf_result" != ".no"; then + AC_TRY_LINK(CF__CURSES_HEAD, + [ +#ifndef ${cf_func} +long foo = (long)(&${cf_func}); +${cf_cv_main_return:-return}(foo == 0); +#endif + ], + [cf_result=yes], + [cf_result=no]) + fi + eval 'cf_cv_func_'$cf_func'=$cf_result' + ]) + # use the computed/retrieved cache-value: + eval 'cf_result=$cf_cv_func_'$cf_func + AC_MSG_RESULT($cf_result) + if test $cf_result != no; then + AC_DEFINE_UNQUOTED(HAVE_${cf_tr_func}) + fi +done +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_CURSES_HEADER version: 2 updated: 2010/04/28 06:02:16 +dnl ---------------- +dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common +dnl variations of ncurses' installs. +dnl +dnl $1 = ncurses when looking for ncurses, or is empty +AC_DEFUN([CF_CURSES_HEADER],[ AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[ cf_cv_ncurses_header=none -for cf_header in \ +for cf_header in ifelse($1,,,[ \ + $1/curses.h \ + $1/ncurses.h]) \ curses.h \ - ncurses.h \ - ncurses/curses.h \ - ncurses/ncurses.h + ncurses.h ifelse($1,,[ncurses/curses.h ncurses/ncurses.h]) do AC_TRY_COMPILE([#include <${cf_header}>], [initscr(); tgoto("?", 0,0)], @@ -154,109 +596,173 @@ fi # cheat, to get the right #define's for HAVE_NCURSES_H, etc. AC_CHECK_HEADERS($cf_cv_ncurses_header) - ])dnl dnl --------------------------------------------------------------------------- -dnl CF_CURSES_LIBS version: 22 updated: 2002/10/27 18:21:42 +dnl CF_CURSES_LIBS version: 31 updated: 2010/10/23 15:54:49 dnl -------------- dnl Look for the curses libraries. Older curses implementations may require dnl termcap/termlib to be linked as well. Call CF_CURSES_CPPFLAGS first. AC_DEFUN([CF_CURSES_LIBS],[ +AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl AC_MSG_CHECKING(if we have identified curses libraries) -AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], - [initscr(); tgoto("?", 0,0)], - cf_result=yes, - cf_result=no) +AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>], + [initscr(); tgoto("?", 0,0)], + cf_result=yes, + cf_result=no) AC_MSG_RESULT($cf_result) if test "$cf_result" = no ; then case $host_os in #(vi freebsd*) #(vi - AC_CHECK_LIB(mytinfo,tgoto,[LIBS="-lmytinfo $LIBS"]) - ;; -hpux10.*|hpux11.*) #(vi - AC_CHECK_LIB(cur_colr,initscr,[ - LIBS="-lcur_colr $LIBS" - ac_cv_func_initscr=yes - ],[ - AC_CHECK_LIB(Hcurses,initscr,[ - # HP's header uses __HP_CURSES, but user claims _HP_CURSES. - LIBS="-lHcurses $LIBS" - CPPFLAGS="-D__HP_CURSES -D_HP_CURSES $CPPFLAGS" - ac_cv_func_initscr=yes - ])]) - ;; + AC_CHECK_LIB(mytinfo,tgoto,[CF_ADD_LIBS(-lmytinfo)]) + ;; +hpux10.*) #(vi + AC_CHECK_LIB(cur_colr,initscr,[ + CF_ADD_LIBS(-lcur_colr) + ac_cv_func_initscr=yes + ],[ + AC_CHECK_LIB(Hcurses,initscr,[ + # HP's header uses __HP_CURSES, but user claims _HP_CURSES. + CF_ADD_LIBS(-lHcurses) + CPPFLAGS="$CPPFLAGS -D__HP_CURSES -D_HP_CURSES" + ac_cv_func_initscr=yes + ])]) + ;; linux*) # Suse Linux does not follow /usr/lib convention - LIBS="$LIBS -L/lib" - ;; + CF_ADD_LIBDIR(/lib) + ;; sunos3*|sunos4*) - test -d /usr/5lib && \ - LIBS="$LIBS -L/usr/5lib -lcurses -ltermcap" - ac_cv_func_initscr=yes - ;; + if test -d /usr/5lib ; then + CF_ADD_LIBDIR(/usr/5lib) + CF_ADD_LIBS(-lcurses -ltermcap) + fi + ac_cv_func_initscr=yes + ;; esac if test ".$ac_cv_func_initscr" != .yes ; then - cf_save_LIBS="$LIBS" - cf_term_lib="" - cf_curs_lib="" + cf_save_LIBS="$LIBS" + cf_term_lib="" + cf_curs_lib="" - if test ".${cf_cv_ncurses_version-no}" != .no - then - cf_check_list="ncurses curses cursesX" - else - cf_check_list="cursesX curses ncurses" - fi + if test ".${cf_cv_ncurses_version:-no}" != .no + then + cf_check_list="ncurses curses cursesX" + else + cf_check_list="cursesX curses ncurses" + fi - # Check for library containing tgoto. Do this before curses library - # because it may be needed to link the test-case for initscr. - AC_CHECK_FUNC(tgoto,[cf_term_lib=predefined],[ - for cf_term_lib in $cf_check_list termcap termlib unknown - do - AC_CHECK_LIB($cf_term_lib,tgoto,[break]) - done - ]) + # Check for library containing tgoto. Do this before curses library + # because it may be needed to link the test-case for initscr. + AC_CHECK_FUNC(tgoto,[cf_term_lib=predefined],[ + for cf_term_lib in $cf_check_list termcap termlib unknown + do + AC_CHECK_LIB($cf_term_lib,tgoto,[break]) + done + ]) - # Check for library containing initscr - test "$cf_term_lib" != predefined && test "$cf_term_lib" != unknown && LIBS="-l$cf_term_lib $cf_save_LIBS" - for cf_curs_lib in $cf_check_list xcurses jcurses unknown - do - AC_CHECK_LIB($cf_curs_lib,initscr,[break]) - done - test $cf_curs_lib = unknown && AC_ERROR(no curses library found) + # Check for library containing initscr + test "$cf_term_lib" != predefined && test "$cf_term_lib" != unknown && LIBS="-l$cf_term_lib $cf_save_LIBS" + for cf_curs_lib in $cf_check_list xcurses jcurses pdcurses unknown + do + AC_CHECK_LIB($cf_curs_lib,initscr,[break]) + done + test $cf_curs_lib = unknown && AC_MSG_ERROR(no curses library found) - LIBS="-l$cf_curs_lib $cf_save_LIBS" - if test "$cf_term_lib" = unknown ; then - AC_MSG_CHECKING(if we can link with $cf_curs_lib library) - AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], - [initscr()], - [cf_result=yes], - [cf_result=no]) - AC_MSG_RESULT($cf_result) - test $cf_result = no && AC_ERROR(Cannot link curses library) - elif test "$cf_curs_lib" = "$cf_term_lib" ; then - : - elif test "$cf_term_lib" != predefined ; then - AC_MSG_CHECKING(if we need both $cf_curs_lib and $cf_term_lib libraries) - AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], - [initscr(); tgoto((char *)0, 0, 0);], - [cf_result=no], - [ - LIBS="-l$cf_curs_lib -l$cf_term_lib $cf_save_LIBS" - AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], - [initscr()], - [cf_result=yes], - [cf_result=error]) - ]) - AC_MSG_RESULT($cf_result) - fi + LIBS="-l$cf_curs_lib $cf_save_LIBS" + if test "$cf_term_lib" = unknown ; then + AC_MSG_CHECKING(if we can link with $cf_curs_lib library) + AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>], + [initscr()], + [cf_result=yes], + [cf_result=no]) + AC_MSG_RESULT($cf_result) + test $cf_result = no && AC_MSG_ERROR(Cannot link curses library) + elif test "$cf_curs_lib" = "$cf_term_lib" ; then + : + elif test "$cf_term_lib" != predefined ; then + AC_MSG_CHECKING(if we need both $cf_curs_lib and $cf_term_lib libraries) + AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>], + [initscr(); tgoto((char *)0, 0, 0);], + [cf_result=no], + [ + LIBS="-l$cf_curs_lib -l$cf_term_lib $cf_save_LIBS" + AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>], + [initscr()], + [cf_result=yes], + [cf_result=error]) + ]) + AC_MSG_RESULT($cf_result) + fi fi fi ])dnl dnl --------------------------------------------------------------------------- -dnl CF_CURSES_WACS_MAP version: 3 updated: 2003/05/17 22:19:02 +dnl CF_CURSES_TERM_H version: 8 updated: 2010/10/23 15:54:49 +dnl ---------------- +dnl SVr4 curses should have term.h as well (where it puts the definitions of +dnl the low-level interface). This may not be true in old/broken implementations, +dnl as well as in misconfigured systems (e.g., gcc configured for Solaris 2.4 +dnl running with Solaris 2.5.1). +AC_DEFUN([CF_CURSES_TERM_H], +[ +AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl + +AC_CACHE_CHECK(for term.h, cf_cv_term_header,[ + +# If we found , look for , but always look +# for if we do not find the variant. +for cf_header in \ + `echo ${cf_cv_ncurses_header:-curses.h} | sed -e 's%/.*%/%'`term.h \ + term.h +do + AC_TRY_COMPILE([ +#include <${cf_cv_ncurses_header:-curses.h}> +#include <${cf_header}>], + [WINDOW *x], + [cf_cv_term_header=$cf_header + break], + [cf_cv_term_header=no]) +done + +case $cf_cv_term_header in #(vi +no) + # If curses is ncurses, some packagers still mess it up by trying to make + # us use GNU termcap. This handles the most common case. + for cf_header in ncurses/term.h ncursesw/term.h + do + AC_TRY_COMPILE([ +#include <${cf_cv_ncurses_header:-curses.h}> +#ifdef NCURSES_VERSION +#include <${cf_header}> +#else +make an error +#endif], + [WINDOW *x], + [cf_cv_term_header=$cf_header + break], + [cf_cv_term_header=no]) + done + ;; +esac +]) + +case $cf_cv_term_header in #(vi +term.h) #(vi + AC_DEFINE(HAVE_TERM_H) + ;; +ncurses/term.h) #(vi + AC_DEFINE(HAVE_NCURSES_TERM_H) + ;; +ncursesw/term.h) + AC_DEFINE(HAVE_NCURSESW_TERM_H) + ;; +esac +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_CURSES_WACS_MAP version: 4 updated: 2010/10/23 15:54:49 dnl ------------------ dnl Check for likely values of wacs_map[]: AC_DEFUN([CF_CURSES_WACS_MAP], @@ -269,7 +775,7 @@ AC_CACHE_CHECK(for wide alternate character set array, cf_cv_curses_wacs_map,[ #ifndef _XOPEN_SOURCE_EXTENDED #define _XOPEN_SOURCE_EXTENDED #endif -#include <${cf_cv_ncurses_header-curses.h}>], +#include <${cf_cv_ncurses_header:-curses.h}>], [$name['k'] = *WACS_PLUS], [cf_cv_curses_wacs_map=$name break]) @@ -281,7 +787,64 @@ dnl ---------- dnl "dirname" is not portable, so we fake it with a shell script. AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl dnl --------------------------------------------------------------------------- -dnl CF_FIND_LIBRARY version: 7 updated: 2000/04/13 21:38:04 +dnl CF_DISABLE_ECHO version: 11 updated: 2009/12/13 13:16:57 +dnl --------------- +dnl You can always use "make -n" to see the actual options, but it's hard to +dnl pick out/analyze warning messages when the compile-line is long. +dnl +dnl Sets: +dnl ECHO_LT - symbol to control if libtool is verbose +dnl ECHO_LD - symbol to prefix "cc -o" lines +dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o) +dnl SHOW_CC - symbol to put before explicit "cc -c" lines +dnl ECHO_CC - symbol to put before any "cc" line +dnl +AC_DEFUN([CF_DISABLE_ECHO],[ +AC_MSG_CHECKING(if you want to see long compiling messages) +CF_ARG_DISABLE(echo, + [ --disable-echo display "compiling" commands], + [ + ECHO_LT='--silent' + ECHO_LD='@echo linking [$]@;' + RULE_CC='@echo compiling [$]<' + SHOW_CC='@echo compiling [$]@' + ECHO_CC='@' +],[ + ECHO_LT='' + ECHO_LD='' + RULE_CC='' + SHOW_CC='' + ECHO_CC='' +]) +AC_MSG_RESULT($enableval) +AC_SUBST(ECHO_LT) +AC_SUBST(ECHO_LD) +AC_SUBST(RULE_CC) +AC_SUBST(SHOW_CC) +AC_SUBST(ECHO_CC) +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_ENABLE_WARNINGS version: 4 updated: 2009/07/26 17:53:03 +dnl ------------------ +dnl Configure-option to enable gcc warnings +AC_DEFUN([CF_ENABLE_WARNINGS],[ +if ( test "$GCC" = yes || test "$GXX" = yes ) +then +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" +then + CF_GCC_ATTRIBUTES + CF_GCC_WARNINGS +fi +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_FIND_LIBRARY version: 9 updated: 2008/03/23 14:48:54 dnl --------------- dnl Look for a non-standard library, given parameters for AC_TRY_LINK. We dnl prefer a standard location, and use -L options only if we do not find the @@ -291,7 +854,7 @@ dnl $2 = library class, usually the same as library name dnl $3 = includes dnl $4 = code fragment to compile/link dnl $5 = corresponding function-name -dnl $6 = flag, nonnull if failure causes an error-exit +dnl $6 = flag, nonnull if failure should not cause an error-exit dnl dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had dnl to use a -L option. @@ -326,12 +889,142 @@ AC_DEFUN([CF_FIND_LIBRARY], eval 'cf_found_library=[$]cf_cv_have_lib_'$1 ifelse($6,,[ if test $cf_found_library = no ; then - AC_ERROR(Cannot link $1 library) + AC_MSG_ERROR(Cannot link $1 library) fi ]) ])dnl dnl --------------------------------------------------------------------------- -dnl CF_FUNC_CURSES_VERSION version: 3 updated: 2003/05/17 22:19:02 +dnl CF_FIND_LINKAGE version: 19 updated: 2010/05/29 16:31:02 +dnl --------------- +dnl Find a library (specifically the linkage used in the code fragment), +dnl searching for it if it is not already in the library path. +dnl See also CF_ADD_SEARCHPATH. +dnl +dnl Parameters (4-on are optional): +dnl $1 = headers for library entrypoint +dnl $2 = code fragment for library entrypoint +dnl $3 = the library name without the "-l" option or ".so" suffix. +dnl $4 = action to perform if successful (default: update CPPFLAGS, etc) +dnl $5 = action to perform if not successful +dnl $6 = module name, if not the same as the library name +dnl $7 = extra libraries +dnl +dnl Sets these variables: +dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found +dnl $cf_cv_header_path_$3 - include-directory if needed +dnl $cf_cv_library_path_$3 - library-directory if needed +dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3 +AC_DEFUN([CF_FIND_LINKAGE],[ + +# If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these +# will be set on completion of the AC_TRY_LINK below. +cf_cv_header_path_$3= +cf_cv_library_path_$3= + +CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)]) + +cf_save_LIBS="$LIBS" + +AC_TRY_LINK([$1],[$2],[ + cf_cv_find_linkage_$3=yes + cf_cv_header_path_$3=/usr/include + cf_cv_library_path_$3=/usr/lib +],[ + +LIBS="-l$3 $7 $cf_save_LIBS" + +AC_TRY_LINK([$1],[$2],[ + cf_cv_find_linkage_$3=yes + cf_cv_header_path_$3=/usr/include + cf_cv_library_path_$3=/usr/lib + cf_cv_library_file_$3="-l$3" +],[ + cf_cv_find_linkage_$3=no + LIBS="$cf_save_LIBS" + + CF_VERBOSE(find linkage for $3 library) + CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)]) + + cf_save_CPPFLAGS="$CPPFLAGS" + cf_test_CPPFLAGS="$CPPFLAGS" + + CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6])) + for cf_cv_header_path_$3 in $cf_search + do + if test -d $cf_cv_header_path_$3 ; then + CF_VERBOSE(... testing $cf_cv_header_path_$3) + CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3" + AC_TRY_COMPILE([$1],[$2],[ + CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3) + cf_cv_find_linkage_$3=maybe + cf_test_CPPFLAGS="$CPPFLAGS" + break],[ + CPPFLAGS="$cf_save_CPPFLAGS" + ]) + fi + done + + if test "$cf_cv_find_linkage_$3" = maybe ; then + + CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)]) + + cf_save_LIBS="$LIBS" + cf_save_LDFLAGS="$LDFLAGS" + + ifelse([$6],,,[ + CPPFLAGS="$cf_test_CPPFLAGS" + LIBS="-l$3 $7 $cf_save_LIBS" + AC_TRY_LINK([$1],[$2],[ + CF_VERBOSE(... found $3 library in system) + cf_cv_find_linkage_$3=yes]) + CPPFLAGS="$cf_save_CPPFLAGS" + LIBS="$cf_save_LIBS" + ]) + + if test "$cf_cv_find_linkage_$3" != yes ; then + CF_LIBRARY_PATH(cf_search,$3) + for cf_cv_library_path_$3 in $cf_search + do + if test -d $cf_cv_library_path_$3 ; then + CF_VERBOSE(... testing $cf_cv_library_path_$3) + CPPFLAGS="$cf_test_CPPFLAGS" + LIBS="-l$3 $7 $cf_save_LIBS" + LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3" + AC_TRY_LINK([$1],[$2],[ + CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3) + cf_cv_find_linkage_$3=yes + cf_cv_library_file_$3="-l$3" + break],[ + CPPFLAGS="$cf_save_CPPFLAGS" + LIBS="$cf_save_LIBS" + LDFLAGS="$cf_save_LDFLAGS" + ]) + fi + done + CPPFLAGS="$cf_save_CPPFLAGS" + LDFLAGS="$cf_save_LDFLAGS" + fi + + else + cf_cv_find_linkage_$3=no + fi + ],$7) +]) + +LIBS="$cf_save_LIBS" + +if test "$cf_cv_find_linkage_$3" = yes ; then +ifelse([$4],,[ + CF_ADD_INCDIR($cf_cv_header_path_$3) + CF_ADD_LIBDIR($cf_cv_library_path_$3) + CF_ADD_LIB($3) +],[$4]) +else +ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5]) +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_FUNC_CURSES_VERSION version: 5 updated: 2010/10/23 15:54:49 dnl ---------------------- dnl Solaris has a data item 'curses_version', which confuses AC_CHECK_FUNCS. dnl It's a character string "SVR4", not documented. @@ -339,12 +1032,12 @@ AC_DEFUN([CF_FUNC_CURSES_VERSION], [ AC_CACHE_CHECK(for function curses_version, cf_cv_func_curses_version,[ AC_TRY_RUN([ -#include <${cf_cv_ncurses_header-curses.h}> +#include <${cf_cv_ncurses_header:-curses.h}> int main() { char temp[1024]; sprintf(temp, "%s\n", curses_version()); - exit(0); + ${cf_cv_main_return:-return}(0); }] ,[cf_cv_func_curses_version=yes] ,[cf_cv_func_curses_version=no] @@ -353,41 +1046,298 @@ rm -f core]) test "$cf_cv_func_curses_version" = yes && AC_DEFINE(HAVE_CURSES_VERSION) ]) dnl --------------------------------------------------------------------------- -dnl CF_GNU_SOURCE version: 3 updated: 2000/10/29 23:30:53 -dnl ------------- -dnl Check if we must define _GNU_SOURCE to get a reasonable value for -dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect -dnl (or misfeature) of glibc2, which breaks portability of many applications, -dnl since it is interwoven with GNU extensions. -dnl -dnl Well, yes we could work around it... -AC_DEFUN([CF_GNU_SOURCE], +dnl CF_GCC_ATTRIBUTES version: 14 updated: 2010/10/23 15:52:32 +dnl ----------------- +dnl Test for availability of useful gcc __attribute__ directives to quiet +dnl compiler warnings. Though useful, not all are supported -- and contrary +dnl to documentation, unrecognized directives cause older compilers to barf. +AC_DEFUN([CF_GCC_ATTRIBUTES], [ -AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[ -AC_TRY_COMPILE([#include ],[ -#ifndef _XOPEN_SOURCE -make an error -#endif], - [cf_cv_gnu_source=no], - [cf_save="$CPPFLAGS" - CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE" - AC_TRY_COMPILE([#include ],[ -#ifdef _XOPEN_SOURCE -make an error -#endif], - [cf_cv_gnu_source=no], - [cf_cv_gnu_source=yes]) - CPPFLAGS="$cf_save" - ]) -]) -test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE" -])dnl +if test "$GCC" = yes +then +cat > conftest.i < conftest.$ac_ext <&AC_FD_CC + + case $cf_attribute in #(vi + printf) #(vi + cf_printf_attribute=yes + cat >conftest.h <conftest.h <conftest.h <>confdefs.h + case $cf_attribute in #(vi + printf) #(vi + if test "$cf_printf_attribute" = no ; then + cat >>confdefs.h <>confdefs.h <>confdefs.h <>confdefs.h <>confdefs.h +fi +rm -rf conftest* +fi +])dnl dnl --------------------------------------------------------------------------- -dnl CF_HEADER_PATH version: 8 updated: 2002/11/10 14:46:59 +dnl CF_GCC_VERSION version: 5 updated: 2010/04/24 11:02:31 dnl -------------- -dnl Construct a search-list for a nonstandard header-file +dnl Find version of gcc +AC_DEFUN([CF_GCC_VERSION],[ +AC_REQUIRE([AC_PROG_CC]) +GCC_VERSION=none +if test "$GCC" = yes ; then + AC_MSG_CHECKING(version of $CC) + GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`" + test -z "$GCC_VERSION" && GCC_VERSION=unknown + AC_MSG_RESULT($GCC_VERSION) +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_GCC_WARNINGS version: 27 updated: 2010/10/23 15:52:32 +dnl --------------- +dnl Check if the compiler supports useful warning options. There's a few that +dnl we don't use, simply because they're too noisy: +dnl +dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x) +dnl -Wredundant-decls (system headers make this too noisy) +dnl -Wtraditional (combines too many unrelated messages, only a few useful) +dnl -Wwrite-strings (too noisy, but should review occasionally). This +dnl is enabled for ncurses using "--enable-const". +dnl -pedantic +dnl +dnl Parameter: +dnl $1 is an optional list of gcc warning flags that a particular +dnl application might want to use, e.g., "no-unused" for +dnl -Wno-unused +dnl Special: +dnl If $with_ext_const is "yes", add a check for -Wwrite-strings +dnl +AC_DEFUN([CF_GCC_WARNINGS], +[ +AC_REQUIRE([CF_GCC_VERSION]) +CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS) + +cat > conftest.$ac_ext <],[ +#ifndef _XOPEN_SOURCE +make an error +#endif], + [cf_cv_gnu_source=no], + [cf_save="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE" + AC_TRY_COMPILE([#include ],[ +#ifdef _XOPEN_SOURCE +make an error +#endif], + [cf_cv_gnu_source=no], + [cf_cv_gnu_source=yes]) + CPPFLAGS="$cf_save" + ]) +]) +test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE" +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_HEADER_PATH version: 12 updated: 2010/05/05 05:22:40 +dnl -------------- +dnl Construct a search-list of directories for a nonstandard header-file +dnl +dnl Parameters +dnl $1 = the variable to return as result +dnl $2 = the package name AC_DEFUN([CF_HEADER_PATH], -[CF_SUBDIR_PATH($1,$2,include) +[ +$1= + +# collect the current set of include-directories from compiler flags +cf_header_path_list="" +if test -n "${CFLAGS}${CPPFLAGS}" ; then + for cf_header_path in $CPPFLAGS $CFLAGS + do + case $cf_header_path in #(vi + -I*) + cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'` + CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE) + cf_header_path_list="$cf_header_path_list [$]$1" + ;; + esac + done +fi + +# add the variations for the package we are looking for +CF_SUBDIR_PATH($1,$2,include) + test "$includedir" != NONE && \ test "$includedir" != "/usr/include" && \ test -d "$includedir" && { @@ -402,6 +1352,7 @@ test -d "$oldincludedir" && { test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2" } +$1="[$]$1 $cf_header_path_list" ])dnl dnl --------------------------------------------------------------------------- dnl CF_INHERIT_SCRIPT version: 2 updated: 2003/03/01 23:50:42 @@ -412,13 +1363,179 @@ AC_DEFUN([CF_INHERIT_SCRIPT], test -f $1 || ( test -f ../$1 && cp ../$1 ./ ) ])dnl dnl --------------------------------------------------------------------------- -dnl CF_LIBRARY_PATH version: 7 updated: 2002/11/10 14:46:59 +dnl CF_INTEL_COMPILER version: 4 updated: 2010/05/26 05:38:42 +dnl ----------------- +dnl Check if the given compiler is really the Intel compiler for Linux. It +dnl tries to imitate gcc, but does not return an error when it finds a mismatch +dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK. +dnl +dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to +dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from +dnl the wrappers for gcc and g++ warnings. +dnl +dnl $1 = GCC (default) or GXX +dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS +dnl $3 = CFLAGS (default) or CXXFLAGS +AC_DEFUN([CF_INTEL_COMPILER],[ +ifelse([$2],,INTEL_COMPILER,[$2])=no + +if test "$ifelse([$1],,[$1],GCC)" = yes ; then + case $host_os in + linux*|gnu*) + AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler) + cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])" + ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc" + AC_TRY_COMPILE([],[ +#ifdef __INTEL_COMPILER +#else +make an error +#endif +],[ifelse([$2],,INTEL_COMPILER,[$2])=yes +cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc" +],[]) + ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS" + AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2])) + ;; + esac +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_LIBRARY_PATH version: 9 updated: 2010/03/28 12:52:50 dnl --------------- -dnl Construct a search-list for a nonstandard library-file +dnl Construct a search-list of directories for a nonstandard library-file +dnl +dnl Parameters +dnl $1 = the variable to return as result +dnl $2 = the package name AC_DEFUN([CF_LIBRARY_PATH], -[CF_SUBDIR_PATH($1,$2,lib)])dnl +[ +$1= +cf_library_path_list="" +if test -n "${LDFLAGS}${LIBS}" ; then + for cf_library_path in $LDFLAGS $LIBS + do + case $cf_library_path in #(vi + -L*) + cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'` + CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE) + cf_library_path_list="$cf_library_path_list [$]$1" + ;; + esac + done +fi + +CF_SUBDIR_PATH($1,$2,lib) + +$1="$cf_library_path_list [$]$1" +])dnl dnl --------------------------------------------------------------------------- -dnl CF_NCURSES_CC_CHECK version: 3 updated: 2003/01/12 18:59:28 +dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32 +dnl ------------ +dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have +dnl a monocase filesystem. +AC_DEFUN([CF_MAKE_TAGS],[ +AC_REQUIRE([CF_MIXEDCASE_FILENAMES]) + +AC_CHECK_PROGS(CTAGS, exctags ctags) +AC_CHECK_PROGS(ETAGS, exetags etags) + +AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no) + +if test "$cf_cv_mixedcase" = yes ; then + AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no) +else + MAKE_UPPER_TAGS=no +fi + +if test "$MAKE_UPPER_TAGS" = yes ; then + MAKE_UPPER_TAGS= +else + MAKE_UPPER_TAGS="#" +fi + +if test "$MAKE_LOWER_TAGS" = yes ; then + MAKE_LOWER_TAGS= +else + MAKE_LOWER_TAGS="#" +fi + +AC_SUBST(CTAGS) +AC_SUBST(ETAGS) + +AC_SUBST(MAKE_UPPER_TAGS) +AC_SUBST(MAKE_LOWER_TAGS) +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_MIN_GETCCHAR version: 3 updated: 2010/10/23 15:54:49 +dnl --------------- +dnl CF_MIN_GETCCHAR +dnl Check whether getcchar's return value counts the trailing null in a wchar_t +dnl string, or not. X/Open says it does, but Tru64 and Solaris do not do this. +AC_DEFUN([CF_MIN_GETCCHAR],[ +AC_CACHE_CHECK(if getcchar counts trailing null,cf_cv_min_getcchar,[ +AC_TRY_RUN([ +#include +#include +#include <${cf_cv_ncurses_header:-curses.h}> + +int main() +{ + wchar_t data[2]; + cchar_t temp[2]; + int count; + data[0] = L'\0'; + setcchar(temp, data, 0, 0, (void *)0); + count = getcchar(temp, (wchar_t *)0, (attr_t *)0, (short *)0, (void *)0); + ${cf_cv_main_return:-return}(count != 0); +}], + [cf_cv_min_getcchar=no], + [cf_cv_min_getcchar=yes], + [cf_cv_min_getcchar=yes]) +]) +if test "$cf_cv_min_getcchar" = yes ; then + AC_DEFINE(MIN_GETCCHAR,1) +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55 +dnl ---------------------- +dnl Check if the file-system supports mixed-case filenames. If we're able to +dnl create a lowercase name and see it as uppercase, it doesn't support that. +AC_DEFUN([CF_MIXEDCASE_FILENAMES], +[ +AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[ +if test "$cross_compiling" = yes ; then + case $target_alias in #(vi + *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi + cf_cv_mixedcase=no + ;; + *) + cf_cv_mixedcase=yes + ;; + esac +else + rm -f conftest CONFTEST + echo test >conftest + if test -f CONFTEST ; then + cf_cv_mixedcase=no + else + cf_cv_mixedcase=yes + fi + rm -f conftest CONFTEST +fi +]) +test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES) +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32 +dnl ---------- +dnl Write a debug message to config.log, along with the line number in the +dnl configure script. +AC_DEFUN([CF_MSG_LOG],[ +echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_NCURSES_CC_CHECK version: 4 updated: 2007/07/29 10:39:05 dnl ------------------- dnl Check if we can compile with ncurses' header file dnl $1 is the cache variable to set @@ -447,11 +1564,51 @@ printf("old\n"); #endif #endif ] - ,[$1=$cf_header] + ,[$1=$2] ,[$1=no]) ])dnl dnl --------------------------------------------------------------------------- -dnl CF_NCURSES_CPPFLAGS version: 16 updated: 2002/12/29 18:30:46 +dnl CF_NCURSES_CONFIG version: 8 updated: 2010/07/08 05:17:30 +dnl ----------------- +dnl Tie together the configure-script macros for ncurses. +dnl Prefer the "-config" script from ncurses 6.x, to simplify analysis. +dnl Allow that to be overridden using the $NCURSES_CONFIG environment variable. +dnl +dnl $1 is the root library name (default: "ncurses") +AC_DEFUN([CF_NCURSES_CONFIG], +[ +cf_ncuconfig_root=ifelse($1,,ncurses,$1) + +echo "Looking for ${cf_ncuconfig_root}-config" +AC_PATH_PROGS(NCURSES_CONFIG,${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config,none) + +if test "$NCURSES_CONFIG" != none ; then + +CPPFLAGS="$CPPFLAGS `$NCURSES_CONFIG --cflags`" +CF_ADD_LIBS(`$NCURSES_CONFIG --libs`) + +# even with config script, some packages use no-override for curses.h +CF_CURSES_HEADER(ifelse($1,,ncurses,$1)) + +dnl like CF_NCURSES_CPPFLAGS +AC_DEFINE(NCURSES) + +dnl like CF_NCURSES_LIBS +CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root) +AC_DEFINE_UNQUOTED($cf_nculib_ROOT) + +dnl like CF_NCURSES_VERSION +cf_cv_ncurses_version=`$NCURSES_CONFIG --version` + +else + +CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1)) +CF_NCURSES_LIBS(ifelse($1,,ncurses,$1)) + +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_NCURSES_CPPFLAGS version: 19 updated: 2007/07/29 13:35: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. @@ -475,11 +1632,13 @@ dnl wide-character version of ncurses is installed. AC_DEFUN([CF_NCURSES_CPPFLAGS], [AC_REQUIRE([CF_WITH_CURSES_DIR]) +AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl cf_ncuhdr_root=ifelse($1,,ncurses,$1) test -n "$cf_cv_curses_dir" && \ -test "$cf_cv_curses_dir" != "no" && \ -CPPFLAGS="-I$cf_cv_curses_dir/include -I$cf_cv_curses_dir/include/$cf_ncuhdr_root $CPPFLAGS" +test "$cf_cv_curses_dir" != "no" && { \ + CF_ADD_INCDIR($cf_cv_curses_dir/include $cf_cv_curses_dir/include/$cf_ncuhdr_root) +} AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[ cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h" @@ -491,9 +1650,62 @@ AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[ done ]) +CF_NCURSES_HEADER +CF_TERM_HEADER + +# some applications need this, but should check for NCURSES_VERSION +AC_DEFINE(NCURSES) + +CF_NCURSES_VERSION +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_NCURSES_EXT_FUNCS version: 2 updated: 2010/10/23 15:54:49 +dnl -------------------- +dnl Since 2007/11/17, ncurses has defined NCURSES_EXT_FUNCS; earlier versions +dnl may provide these functions. Define the symbol if it is not defined, and +dnl if it is valid. +AC_DEFUN([CF_NCURSES_EXT_FUNCS], +[ +AC_CACHE_CHECK(for ncurses extended functions,cf_cv_ncurses_ext_funcs,[ +AC_TRY_COMPILE([ +#include <${cf_cv_ncurses_header:-curses.h}>], +[ +int x = NCURSES_EXT_FUNCS +],[cf_cv_ncurses_ext_funcs=defined],[ +AC_TRY_LINK([ +#include <${cf_cv_ncurses_header:-curses.h}>], +[ + (void) assume_default_colors (0, 0); + (void) curses_version (); + (void) define_key (0, 0); + (void) is_term_resized (0, 0); + (void) key_defined (0); + (void) keybound (0, 0); + (void) keyok (0, 0); + (void) resize_term (0, 0); + (void) resizeterm (0, 0); + (void) use_default_colors (); + (void) use_extended_names (0); + (void) wresize (0, 0, 0);], + [cf_cv_ncurses_ext_funcs=yes], + [cf_cv_ncurses_ext_funcs=no]) +]) +]) +test "$cf_cv_ncurses_ext_funcs" == yes && AC_DEFINE(NCURSES_EXT_FUNCS) +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_NCURSES_HEADER version: 2 updated: 2008/03/23 14:48:54 +dnl ----------------- +dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common +dnl variations of ncurses' installs. +dnl +dnl See also CF_CURSES_HEADER, which sets the same cache variable. +AC_DEFUN([CF_NCURSES_HEADER],[ + if test "$cf_cv_ncurses_h" != no ; then cf_cv_ncurses_header=$cf_cv_ncurses_h else + AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[ test -n "$verbose" && echo CF_HEADER_PATH(cf_search,$cf_ncuhdr_root) @@ -517,7 +1729,7 @@ AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[ CPPFLAGS="$cf_save2_CPPFLAGS" test "$cf_cv_ncurses_h2" != no && break done - test "$cf_cv_ncurses_h2" = no && AC_ERROR(not found) + test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found) ]) CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2) @@ -529,7 +1741,7 @@ AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[ fi -AC_DEFINE(NCURSES) +# Set definitions to allow ifdef'ing for ncurses.h case $cf_cv_ncurses_header in # (vi *ncurses.h) @@ -546,10 +1758,9 @@ ncursesw/curses.h|ncursesw/ncurses.h) ;; esac -CF_NCURSES_VERSION ])dnl dnl --------------------------------------------------------------------------- -dnl CF_NCURSES_LIBS version: 11 updated: 2002/12/22 14:22:25 +dnl CF_NCURSES_LIBS version: 15 updated: 2010/10/23 15:54:49 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. @@ -579,18 +1790,21 @@ case $host_os in #(vi 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). - AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"]) + if test "$cf_nculib_root" = ncurses ; then + AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"]) + fi ;; esac -LIBS="$cf_ncurses_LIBS $LIBS" +CF_ADD_LIBS($cf_ncurses_LIBS) if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" ) then - LIBS="-L$cf_cv_curses_dir/lib -l$cf_nculib_root $LIBS" + CF_ADD_LIBDIR($cf_cv_curses_dir/lib) + CF_ADD_LIBS(-l$cf_nculib_root) else CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root, - [#include <${cf_cv_ncurses_header-curses.h}>], + [#include <${cf_cv_ncurses_header:-curses.h}>], [initscr()], initscr) fi @@ -604,7 +1818,7 @@ if test -n "$cf_ncurses_LIBS" ; then LIBS="$q" fi done - AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], + AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>], [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);], [AC_MSG_RESULT(yes)], [AC_MSG_RESULT(no) @@ -615,19 +1829,20 @@ CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root) AC_DEFINE_UNQUOTED($cf_nculib_ROOT) ])dnl dnl --------------------------------------------------------------------------- -dnl CF_NCURSES_VERSION version: 10 updated: 2002/10/27 18:21:42 +dnl CF_NCURSES_VERSION version: 13 updated: 2010/10/23 15:54:49 dnl ------------------ dnl Check for the version of ncurses, to aid in reporting bugs, etc. dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS. We don't use dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi. AC_DEFUN([CF_NCURSES_VERSION], [ +AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[ cf_cv_ncurses_version=no cf_tempfile=out$$ rm -f $cf_tempfile AC_TRY_RUN([ -#include <${cf_cv_ncurses_header-curses.h}> +#include <${cf_cv_ncurses_header:-curses.h}> #include int main() { @@ -645,14 +1860,14 @@ int main() make an error # endif #endif - exit(0); + ${cf_cv_main_return:-return}(0); }],[ cf_cv_ncurses_version=`cat $cf_tempfile`],,[ # This will not work if the preprocessor splits the line after the # Autoconf token. The 'unproto' program does that. cat > conftest.$ac_ext < +#include <${cf_cv_ncurses_header:-curses.h}> #undef Autoconf #ifdef NCURSES_VERSION Autoconf NCURSES_VERSION @@ -676,13 +1891,35 @@ EOF test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES) ])dnl dnl --------------------------------------------------------------------------- -dnl CF_PATH_SYNTAX version: 9 updated: 2002/09/17 23:03:38 +dnl CF_NCURSES_WRAP_PREFIX version: 1 updated: 2009/03/28 16:08:10 +dnl ---------------------- +dnl Check for ncurses "wrap-prefix" used for public variables which have been +dnl wrapped with a function to help with concurrency control. +AC_DEFUN([CF_NCURSES_WRAP_PREFIX], +[ +AC_MSG_CHECKING(for ncurses wrap-prefix) +AC_ARG_WITH(ncurses-wrap-prefix, + [ --with-ncurses-wrap-prefix naming-prefix for ncurses wrapped-variables], + [NCURSES_WRAP_PREFIX=$withval], + [NCURSES_WRAP_PREFIX=_nc_]) +AC_MSG_RESULT($NCURSES_WRAP_PREFIX) + +AC_SUBST(NCURSES_WRAP_PREFIX) +]) +dnl --------------------------------------------------------------------------- +dnl CF_PATH_SYNTAX version: 13 updated: 2010/05/26 05:38:42 dnl -------------- dnl Check the argument to see that it looks like a pathname. Rewrite it if it dnl begins with one of the prefix/exec_prefix variables, and then again if the dnl result begins with 'NONE'. This is necessary to work around autoconf's dnl delayed evaluation of those symbols. AC_DEFUN([CF_PATH_SYNTAX],[ +if test "x$prefix" != xNONE; then + cf_path_syntax="$prefix" +else + cf_path_syntax="$ac_default_prefix" +fi + case ".[$]$1" in #(vi .\[$]\(*\)*|.\'*\'*) #(vi ;; @@ -694,114 +1931,283 @@ case ".[$]$1" in #(vi eval $1="[$]$1" case ".[$]$1" in #(vi .NONE/*) - $1=`echo [$]$1 | sed -e s%NONE%$ac_default_prefix%` + $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%` ;; esac ;; #(vi -.NONE/*) - $1=`echo [$]$1 | sed -e s%NONE%$ac_default_prefix%` +.no|.NONE/*) + $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%` ;; *) - ifelse($2,,[AC_ERROR([expected a pathname, not \"[$]$1\"])],$2) + ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2) ;; esac ])dnl dnl --------------------------------------------------------------------------- -dnl CF_PREDEFINE version: 1 updated: 2003/07/26 17:53:56 -dnl ------------ -dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles. +dnl CF_PDCURSES_X11 version: 10 updated: 2010/06/20 09:24:28 +dnl --------------- +dnl Configure for PDCurses' X11 library +AC_DEFUN([CF_PDCURSES_X11],[ +AC_REQUIRE([CF_X_ATHENA]) + +AC_PATH_PROGS(XCURSES_CONFIG,xcurses-config,none) + +if test "$XCURSES_CONFIG" != none ; then + +CPPFLAGS="$CPPFLAGS `$XCURSES_CONFIG --cflags`" +CF_ADD_LIBS(`$XCURSES_CONFIG --libs`) + +cf_cv_lib_XCurses=yes + +else + +LDFLAGS="$LDFLAGS $X_LIBS" +CF_CHECK_CFLAGS($X_CFLAGS) +AC_CHECK_LIB(X11,XOpenDisplay, + [CF_ADD_LIBS(-lX11)],, + [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS]) +AC_CACHE_CHECK(for XCurses library,cf_cv_lib_XCurses,[ +CF_ADD_LIBS(-lXCurses) +AC_TRY_LINK([ +#include +char *XCursesProgramName = "test"; +],[XCursesExit();], +[cf_cv_lib_XCurses=yes], +[cf_cv_lib_XCurses=no]) +]) + +fi + +if test $cf_cv_lib_XCurses = yes ; then + AC_DEFINE(UNIX) + AC_DEFINE(XCURSES) + AC_DEFINE(HAVE_XCURSES) +else + AC_MSG_ERROR(Cannot link with XCurses) +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_PKG_CONFIG version: 3 updated: 2009/01/25 10:55:09 +dnl ------------- +dnl Check for the package-config program, unless disabled by command-line. +AC_DEFUN([CF_PKG_CONFIG], +[ +AC_MSG_CHECKING(if you want to use pkg-config) +AC_ARG_WITH(pkg-config, + [ --with-pkg-config{=path} enable/disable use of pkg-config], + [cf_pkg_config=$withval], + [cf_pkg_config=yes]) +AC_MSG_RESULT($cf_pkg_config) + +case $cf_pkg_config in #(vi +no) #(vi + PKG_CONFIG=none + ;; +yes) #(vi + AC_PATH_PROG(PKG_CONFIG, pkg-config, none) + ;; +*) + PKG_CONFIG=$withval + ;; +esac + +test -z "$PKG_CONFIG" && PKG_CONFIG=none +if test "$PKG_CONFIG" != none ; then + CF_PATH_SYNTAX(PKG_CONFIG) +fi + +AC_SUBST(PKG_CONFIG) +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_POSIX_C_SOURCE version: 8 updated: 2010/05/26 05:38:42 +dnl ----------------- +dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed. dnl -dnl $1 = symbol to test -dnl $2 = value (if any) to use for a predefinition -AC_DEFUN([CF_PREDEFINE], +dnl POSIX.1-1990 _POSIX_SOURCE +dnl POSIX.1-1990 and _POSIX_SOURCE and +dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2 +dnl Bindings Option +dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L +dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L +dnl X/Open 2000 _POSIX_C_SOURCE=200112L +dnl +dnl Parameters: +dnl $1 is the nominal value for _POSIX_C_SOURCE +AC_DEFUN([CF_POSIX_C_SOURCE], [ -AC_MSG_CHECKING(if we must define $1) -AC_TRY_COMPILE([#include -],[ -#ifndef $1 -make an error -#endif],[cf_result=no],[cf_result=yes]) -AC_MSG_RESULT($cf_result) +cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1]) -if test "$cf_result" = yes ; then - CPPFLAGS="$CPPFLAGS ifelse($2,,-D$1,[-D$1=$2])" -elif test "x$2" != "x" ; then - AC_MSG_CHECKING(checking for compatible value versus $2) - AC_TRY_COMPILE([#include -],[ -#if $1-$2 < 0 +cf_save_CFLAGS="$CFLAGS" +cf_save_CPPFLAGS="$CPPFLAGS" + +CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE) +CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE) + +AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[ + CF_MSG_LOG(if the symbol is already defined go no further) + AC_TRY_COMPILE([#include ],[ +#ifndef _POSIX_C_SOURCE make an error -#endif],[cf_result=yes],[cf_result=no]) - AC_MSG_RESULT($cf_result) - if test "$cf_result" = no ; then - # perhaps we can override it - try... - CPPFLAGS="$CPPFLAGS -D$1=$2" - fi +#endif], + [cf_cv_posix_c_source=no], + [cf_want_posix_source=no + case .$cf_POSIX_C_SOURCE in #(vi + .[[12]]??*) #(vi + cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE" + ;; + .2) #(vi + cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE" + cf_want_posix_source=yes + ;; + .*) + cf_want_posix_source=yes + ;; + esac + if test "$cf_want_posix_source" = yes ; then + AC_TRY_COMPILE([#include ],[ +#ifdef _POSIX_SOURCE +make an error +#endif],[], + cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE") + fi + CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE) + CFLAGS="$cf_trim_CFLAGS" + CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source" + CF_MSG_LOG(if the second compile does not leave our definition intact error) + AC_TRY_COMPILE([#include ],[ +#ifndef _POSIX_C_SOURCE +make an error +#endif],, + [cf_cv_posix_c_source=no]) + CFLAGS="$cf_save_CFLAGS" + CPPFLAGS="$cf_save_CPPFLAGS" + ]) +]) + +if test "$cf_cv_posix_c_source" != no ; then + CFLAGS="$cf_trim_CFLAGS" + CPPFLAGS="$cf_trim_CPPFLAGS" + CF_ADD_CFLAGS($cf_cv_posix_c_source) fi + +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08 +dnl ------------ +dnl Append definitions and rules for the given programs to the subdirectory +dnl Makefiles, and the recursion rule for the top-level Makefile. +dnl +dnl parameters +dnl $1 = script to run +dnl $2 = list of subdirectories +dnl +dnl variables +dnl $AWK +AC_DEFUN([CF_PRG_RULES], +[ +for cf_dir in $2 +do + if test ! -d $srcdir/$cf_dir; then + continue + elif test -f $srcdir/$cf_dir/programs; then + $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile + fi +done + +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30 +dnl -------------- +dnl Check if C (preprocessor) -U and -D options are processed in the order +dnl given rather than by type of option. Some compilers insist on apply all +dnl of the -U options after all of the -D options. Others allow mixing them, +dnl and may predefine symbols that conflict with those we define. +AC_DEFUN([CF_PROG_CC_U_D], +[ +AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[ + cf_save_CPPFLAGS="$CPPFLAGS" + CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS" + AC_TRY_COMPILE([],[ +#ifndef U_D_OPTIONS +make an undefined-error +#endif +#ifdef D_U_OPTIONS +make a defined-error +#endif + ],[ + cf_cv_cc_u_d_options=yes],[ + cf_cv_cc_u_d_options=no]) + CPPFLAGS="$cf_save_CPPFLAGS" +]) +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50 +dnl ---------------- +dnl Remove all -U and -D options that refer to the given symbol from a list +dnl of C compiler options. This works around the problem that not all +dnl compilers process -U and -D options from left-to-right, so a -U option +dnl cannot be used to cancel the effect of a preceding -D option. +dnl +dnl $1 = target (which could be the same as the source variable) +dnl $2 = source (including '$') +dnl $3 = symbol to remove +define([CF_REMOVE_DEFINE], +[ +$1=`echo "$2" | \ + sed -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[[ ]]/ /g' \ + -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[$]//g'` +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_SIG_ATOMIC_T version: 2 updated: 2005/09/18 17:27:12 +dnl --------------- +dnl signal handler, but there are some gcc depedencies in that recommendation. +dnl Try anyway. +AC_DEFUN([CF_SIG_ATOMIC_T], +[ +AC_MSG_CHECKING(for signal global datatype) +AC_CACHE_VAL(cf_cv_sig_atomic_t,[ + for cf_type in \ + "volatile sig_atomic_t" \ + "sig_atomic_t" \ + "int" + do + AC_TRY_COMPILE([ +#include +#include +#include + +extern $cf_type x; +$cf_type x; +static void handler(int sig) +{ + x = 5; +}], + [signal(SIGINT, handler); + x = 1], + [cf_cv_sig_atomic_t=$cf_type], + [cf_cv_sig_atomic_t=no]) + test "$cf_cv_sig_atomic_t" != no && break + done + ]) +AC_MSG_RESULT($cf_cv_sig_atomic_t) +test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t) ])dnl dnl --------------------------------------------------------------------------- -dnl CF_SUBDIR_PATH version: 3 updated: 2002/12/29 18:30:46 +dnl CF_SUBDIR_PATH version: 6 updated: 2010/04/21 06:20:50 dnl -------------- dnl Construct a search-list for a nonstandard header/lib-file dnl $1 = the variable to return as result dnl $2 = the package name dnl $3 = the subdirectory, e.g., bin, include or lib AC_DEFUN([CF_SUBDIR_PATH], -[$1="" - -test -d [$]HOME && { - test -n "$verbose" && echo " ... testing $3-directories under [$]HOME" - test -d [$]HOME/$3 && $1="[$]$1 [$]HOME/$3" - test -d [$]HOME/$3/$2 && $1="[$]$1 [$]HOME/$3/$2" - test -d [$]HOME/$3/$2/$3 && $1="[$]$1 [$]HOME/$3/$2/$3" -} - -# For other stuff under the home directory, it should be sufficient to put -# a symbolic link for $HOME/$2 to the actual package location: -test -d [$]HOME/$2 && { - test -n "$verbose" && echo " ... testing $3-directories under [$]HOME/$2" - test -d [$]HOME/$2/$3 && $1="[$]$1 [$]HOME/$2/$3" - test -d [$]HOME/$2/$3/$2 && $1="[$]$1 [$]HOME/$2/$3/$2" -} - -test "$prefix" != /usr/local && \ -test -d /usr/local && { - test -n "$verbose" && echo " ... testing $3-directories under /usr/local" - test -d /usr/local/$3 && $1="[$]$1 /usr/local/$3" - test -d /usr/local/$3/$2 && $1="[$]$1 /usr/local/$3/$2" - test -d /usr/local/$3/$2/$3 && $1="[$]$1 /usr/local/$3/$2/$3" - test -d /usr/local/$2/$3 && $1="[$]$1 /usr/local/$2/$3" - test -d /usr/local/$2/$3/$2 && $1="[$]$1 /usr/local/$2/$3/$2" -} - -test "$prefix" != NONE && \ -test -d $prefix && { - test -n "$verbose" && echo " ... testing $3-directories under $prefix" - test -d $prefix/$3 && $1="[$]$1 $prefix/$3" - test -d $prefix/$3/$2 && $1="[$]$1 $prefix/$3/$2" - test -d $prefix/$3/$2/$3 && $1="[$]$1 $prefix/$3/$2/$3" - test -d $prefix/$2/$3 && $1="[$]$1 $prefix/$2/$3" - test -d $prefix/$2/$3/$2 && $1="[$]$1 $prefix/$2/$3/$2" -} - -test "$prefix" != /opt && \ -test -d /opt && { - test -n "$verbose" && echo " ... testing $3-directories under /opt" - test -d /opt/$3 && $1="[$]$1 /opt/$3" - test -d /opt/$3/$2 && $1="[$]$1 /opt/$3/$2" - test -d /opt/$3/$2/$3 && $1="[$]$1 /opt/$3/$2/$3" - test -d /opt/$2/$3 && $1="[$]$1 /opt/$2/$3" - test -d /opt/$2/$3/$2 && $1="[$]$1 /opt/$2/$3/$2" -} +[ +$1= -test "$prefix" != /usr && \ -test -d /usr && { - test -n "$verbose" && echo " ... testing $3-directories under /usr" - test -d /usr/$3 && $1="[$]$1 /usr/$3" - test -d /usr/$3/$2 && $1="[$]$1 /usr/$3/$2" - test -d /usr/$3/$2/$3 && $1="[$]$1 /usr/$3/$2/$3" - test -d /usr/$2/$3 && $1="[$]$1 /usr/$2/$3" -} +CF_ADD_SUBDIR_PATH($1,$2,$3,/usr,$prefix) +CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE) +CF_ADD_SUBDIR_PATH($1,$2,$3,/usr/local,$prefix) +CF_ADD_SUBDIR_PATH($1,$2,$3,/opt,$prefix) +CF_ADD_SUBDIR_PATH($1,$2,$3,[$]HOME,$prefix) ])dnl dnl --------------------------------------------------------------------------- dnl CF_SYS_TIME_SELECT version: 4 updated: 2000/10/04 09:18:40 @@ -827,6 +2233,78 @@ AC_MSG_RESULT($cf_cv_sys_time_select) test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT) ])dnl dnl --------------------------------------------------------------------------- +dnl CF_TERM_HEADER version: 2 updated: 2010/10/23 15:54:49 +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 #(vi +*/ncurses.h|*/ncursesw.h) #(vi + cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'` + ;; +*) + cf_term_header=term.h + ;; +esac + +for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h" +do +AC_TRY_COMPILE([#include +#include <${cf_cv_ncurses_header:-curses.h}> +#include <$cf_test> +],[int x = auto_left_margin],[ + cf_cv_term_header="$cf_test"],[ + cf_cv_term_header=unknown + ]) + test "$cf_cv_term_header" != unknown && break +done +]) + +# Set definitions to allow ifdef'ing to accommodate subdirectories + +case $cf_cv_term_header in # (vi +*term.h) + AC_DEFINE(HAVE_TERM_H) + ;; +esac + +case $cf_cv_term_header in # (vi +ncurses/term.h) #(vi + AC_DEFINE(HAVE_NCURSES_TERM_H) + ;; +ncursesw/term.h) + AC_DEFINE(HAVE_NCURSESW_TERM_H) + ;; +esac +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_TRY_PKG_CONFIG version: 4 updated: 2010/06/14 17:42:30 +dnl ----------------- +dnl This is a simple wrapper to use for pkg-config, for libraries which may be +dnl available in that form. +dnl +dnl $1 = package name +dnl $2 = extra logic to use, if any, after updating CFLAGS and LIBS +dnl $3 = logic to use if pkg-config does not have the package +AC_DEFUN([CF_TRY_PKG_CONFIG],[ +AC_REQUIRE([CF_PKG_CONFIG]) + +if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists $1; then + CF_VERBOSE(found package $1) + cf_pkgconfig_incs="`$PKG_CONFIG --cflags $1 2>/dev/null`" + cf_pkgconfig_libs="`$PKG_CONFIG --libs $1 2>/dev/null`" + CF_VERBOSE(package $1 CFLAGS: $cf_pkgconfig_incs) + CF_VERBOSE(package $1 LIBS: $cf_pkgconfig_libs) + CF_ADD_CFLAGS($cf_pkgconfig_incs) + CF_ADD_LIBS($cf_pkgconfig_libs) + ifelse([$2],,:,[$2]) +else + ifelse([$3],,:,[$3]) +fi +]) +dnl --------------------------------------------------------------------------- dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59 dnl -------- dnl Make an uppercase version of a variable @@ -836,7 +2314,7 @@ AC_DEFUN([CF_UPPER], $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%` ])dnl dnl --------------------------------------------------------------------------- -dnl CF_UTF8_LIB version: 4 updated: 2003/03/01 18:36:42 +dnl CF_UTF8_LIB version: 7 updated: 2010/06/20 09:24:28 dnl ----------- dnl Check for multibyte support, and if not found, utf8 compatibility library AC_DEFUN([CF_UTF8_LIB], @@ -846,22 +2324,80 @@ AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[ AC_TRY_LINK([ #include ],[putwc(0,0);], [cf_cv_utf8_lib=yes], - [LIBS="-lutf8 $LIBS" - AC_TRY_LINK([ -#include ],[putwc(0,0);], + [CF_FIND_LINKAGE([ +#include ],[putwc(0,0);],utf8, [cf_cv_utf8_lib=add-on], [cf_cv_utf8_lib=no]) - LIBS="$cf_save_LIBS" ])]) # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between # ncurses/ncursesw: if test "$cf_cv_utf8_lib" = "add-on" ; then AC_DEFINE(HAVE_LIBUTF8_H) - LIBS="-lutf8 $LIBS" + CF_ADD_INCDIR($cf_cv_header_path_utf8) + CF_ADD_LIBDIR($cf_cv_library_path_utf8) + CF_ADD_LIBS($cf_cv_library_file_utf8) fi ])dnl dnl --------------------------------------------------------------------------- +dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12 +dnl ---------- +dnl Use AC_VERBOSE w/o the warnings +AC_DEFUN([CF_VERBOSE], +[test -n "$verbose" && echo " $1" 1>&AC_FD_MSG +CF_MSG_LOG([$1]) +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_WCHAR_TYPE version: 3 updated: 2010/05/26 16:44:57 +dnl ------------- +dnl Check if type wide-character type $1 is declared, and if so, which header +dnl file is needed. The second parameter is used to set a shell variable when +dnl the type is not found. The first parameter sets a shell variable for the +dnl opposite sense. +AC_DEFUN([CF_WCHAR_TYPE], +[ +# This is needed on Tru64 5.0 to declare $1 +AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[ +AC_TRY_COMPILE([ +#include +#include +#include +#ifdef HAVE_LIBUTF8_H +#include +#endif], + [$1 state], + [cf_cv_$1=no], + [AC_TRY_COMPILE([ +#include +#include +#include +#include +#ifdef HAVE_LIBUTF8_H +#include +#endif], + [$1 value], + [cf_cv_$1=yes], + [cf_cv_$1=unknown])])]) + +if test "$cf_cv_$1" = yes ; then + AC_DEFINE(NEED_WCHAR_H) + NEED_WCHAR_H=1 +fi + +ifelse([$2],,,[ +# if we do not find $1 in either place, use substitution to provide a fallback. +if test "$cf_cv_$1" = unknown ; then + $2=1 +fi +]) +ifelse($3,,,[ +# if we find $1 in either place, use substitution to provide a fallback. +if test "$cf_cv_$1" != unknown ; then + $3=1 +fi +]) +])dnl +dnl --------------------------------------------------------------------------- dnl CF_WITH_CURSES_DIR version: 2 updated: 2002/11/10 14:46:59 dnl ------------------ dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses @@ -873,3 +2409,397 @@ AC_ARG_WITH(curses-dir, cf_cv_curses_dir=$withval], [cf_cv_curses_dir=no]) ])dnl +dnl --------------------------------------------------------------------------- +dnl CF_XOPEN_CURSES version: 10 updated: 2010/10/23 15:54:49 +dnl --------------- +dnl Test if we should define X/Open source for curses, needed on Digital Unix +dnl 4.x, to see the extended functions, but breaks on IRIX 6.x. +dnl +dnl The getbegyx() check is needed for HPUX, which omits legacy macros such +dnl as getbegy(). The latter is better design, but the former is standard. +AC_DEFUN([CF_XOPEN_CURSES], +[ +AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl +AC_CACHE_CHECK(if we must define _XOPEN_SOURCE_EXTENDED,cf_cv_need_xopen_extension,[ +AC_TRY_LINK([ +#include +#include <${cf_cv_ncurses_header:-curses.h}>],[ +#if defined(NCURSES_VERSION_PATCH) +if (NCURSES_VERSION_PATCH < 20100501) && (NCURSES_VERSION_PATCH >= 20100403) + make an error +#endif +#endif + long x = winnstr(stdscr, "", 0); + int x1, y1; + getbegyx(stdscr, y1, x1)], + [cf_cv_need_xopen_extension=no], + [AC_TRY_LINK([ +#define _XOPEN_SOURCE_EXTENDED +#include +#include <${cf_cv_ncurses_header:-curses.h}>],[ +#ifdef NCURSES_VERSION + cchar_t check; + int check2 = curs_set((int)sizeof(check)); +#endif + long x = winnstr(stdscr, "", 0); + int x1, y1; + getbegyx(stdscr, y1, x1)], + [cf_cv_need_xopen_extension=yes], + [cf_cv_need_xopen_extension=unknown])])]) +test $cf_cv_need_xopen_extension = yes && CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE_EXTENDED" +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_XOPEN_SOURCE version: 34 updated: 2010/05/26 05:38:42 +dnl --------------- +dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions, +dnl or adapt to the vendor's definitions to get equivalent functionality, +dnl without losing the common non-POSIX features. +dnl +dnl Parameters: +dnl $1 is the nominal value for _XOPEN_SOURCE +dnl $2 is the nominal value for _POSIX_C_SOURCE +AC_DEFUN([CF_XOPEN_SOURCE],[ + +cf_XOPEN_SOURCE=ifelse([$1],,500,[$1]) +cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2]) +cf_xopen_source= + +case $host_os in #(vi +aix[[456]]*) #(vi + cf_xopen_source="-D_ALL_SOURCE" + ;; +darwin[[0-8]].*) #(vi + cf_xopen_source="-D_APPLE_C_SOURCE" + ;; +darwin*) #(vi + cf_xopen_source="-D_DARWIN_C_SOURCE" + ;; +freebsd*|dragonfly*) #(vi + # 5.x headers associate + # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L + # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L + cf_POSIX_C_SOURCE=200112L + cf_XOPEN_SOURCE=600 + cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE" + ;; +hpux11*) #(vi + cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500" + ;; +hpux*) #(vi + cf_xopen_source="-D_HPUX_SOURCE" + ;; +irix[[56]].*) #(vi + cf_xopen_source="-D_SGI_SOURCE" + ;; +linux*|gnu*|mint*|k*bsd*-gnu) #(vi + CF_GNU_SOURCE + ;; +mirbsd*) #(vi + # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks + ;; +netbsd*) #(vi + # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw + ;; +openbsd*) #(vi + # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw + ;; +osf[[45]]*) #(vi + cf_xopen_source="-D_OSF_SOURCE" + ;; +nto-qnx*) #(vi + cf_xopen_source="-D_QNX_SOURCE" + ;; +sco*) #(vi + # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer + ;; +solaris2.1[[0-9]]) #(vi + cf_xopen_source="-D__EXTENSIONS__ -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE" + ;; +solaris2.[[1-9]]) #(vi + cf_xopen_source="-D__EXTENSIONS__" + ;; +*) + AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[ + AC_TRY_COMPILE([#include ],[ +#ifndef _XOPEN_SOURCE +make an error +#endif], + [cf_cv_xopen_source=no], + [cf_save="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE" + AC_TRY_COMPILE([#include ],[ +#ifdef _XOPEN_SOURCE +make an error +#endif], + [cf_cv_xopen_source=no], + [cf_cv_xopen_source=$cf_XOPEN_SOURCE]) + CPPFLAGS="$cf_save" + ]) +]) + if test "$cf_cv_xopen_source" != no ; then + CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE) + CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE) + cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source" + CF_ADD_CFLAGS($cf_temp_xopen_source) + fi + CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE) + ;; +esac + +if test -n "$cf_xopen_source" ; then + CF_ADD_CFLAGS($cf_xopen_source) +fi +]) +dnl --------------------------------------------------------------------------- +dnl CF_X_ATHENA version: 17 updated: 2010/10/23 15:52:32 +dnl ----------- +dnl Check for Xaw (Athena) libraries +dnl +dnl Sets $cf_x_athena according to the flavor of Xaw which is used. +AC_DEFUN([CF_X_ATHENA], +[ +cf_x_athena=${cf_x_athena:-Xaw} + +AC_MSG_CHECKING(if you want to link with Xaw 3d library) +withval= +AC_ARG_WITH(Xaw3d, + [ --with-Xaw3d link with Xaw 3d library]) +if test "$withval" = yes ; then + cf_x_athena=Xaw3d + AC_MSG_RESULT(yes) +else + AC_MSG_RESULT(no) +fi + +AC_MSG_CHECKING(if you want to link with neXT Athena library) +withval= +AC_ARG_WITH(neXtaw, + [ --with-neXtaw link with neXT Athena library]) +if test "$withval" = yes ; then + cf_x_athena=neXtaw + AC_MSG_RESULT(yes) +else + AC_MSG_RESULT(no) +fi + +AC_MSG_CHECKING(if you want to link with Athena-Plus library) +withval= +AC_ARG_WITH(XawPlus, + [ --with-XawPlus link with Athena-Plus library]) +if test "$withval" = yes ; then + cf_x_athena=XawPlus + AC_MSG_RESULT(yes) +else + AC_MSG_RESULT(no) +fi + +cf_x_athena_lib="" + +if test "$PKG_CONFIG" != none ; then + cf_athena_list= + test "$cf_x_athena" = Xaw && cf_athena_list="xaw8 xaw7 xaw6" + for cf_athena_pkg in \ + $cf_athena_list \ + ${cf_x_athena} \ + ${cf_x_athena}-devel \ + lib${cf_x_athena} \ + lib${cf_x_athena}-devel + do + CF_TRY_PKG_CONFIG($cf_athena_pkg,[ + cf_x_athena_lib="$cf_pkgconfig_libs" + CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena) + AC_DEFINE_UNQUOTED($cf_x_athena_LIBS) + break]) + done +fi + +if test -z "$cf_x_athena_lib" ; then + CF_X_EXT + CF_X_TOOLKIT + CF_X_ATHENA_CPPFLAGS($cf_x_athena) + CF_X_ATHENA_LIBS($cf_x_athena) +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_X_ATHENA_CPPFLAGS version: 5 updated: 2010/05/26 17:35:30 +dnl -------------------- +dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of +dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw. +AC_DEFUN([CF_X_ATHENA_CPPFLAGS], +[ +cf_x_athena_root=ifelse([$1],,Xaw,[$1]) +cf_x_athena_inc="" + +for cf_path in default \ + /usr/contrib/X11R6 \ + /usr/contrib/X11R5 \ + /usr/lib/X11R5 \ + /usr/local +do + if test -z "$cf_x_athena_inc" ; then + cf_save="$CPPFLAGS" + cf_test=X11/$cf_x_athena_root/SimpleMenu.h + if test $cf_path != default ; then + CPPFLAGS="$cf_save -I$cf_path/include" + AC_MSG_CHECKING(for $cf_test in $cf_path) + else + AC_MSG_CHECKING(for $cf_test) + fi + AC_TRY_COMPILE([ +#include +#include <$cf_test>],[], + [cf_result=yes], + [cf_result=no]) + AC_MSG_RESULT($cf_result) + if test "$cf_result" = yes ; then + cf_x_athena_inc=$cf_path + break + else + CPPFLAGS="$cf_save" + fi + fi +done + +if test -z "$cf_x_athena_inc" ; then + AC_MSG_WARN( +[Unable to successfully find Athena header files with test program]) +elif test "$cf_x_athena_inc" != default ; then + CPPFLAGS="$CPPFLAGS -I$cf_x_athena_inc" +fi +]) +dnl --------------------------------------------------------------------------- +dnl CF_X_ATHENA_LIBS version: 9 updated: 2010/06/02 05:03:05 +dnl ---------------- +dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of +dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw. +AC_DEFUN([CF_X_ATHENA_LIBS], +[AC_REQUIRE([CF_X_TOOLKIT]) +cf_x_athena_root=ifelse([$1],,Xaw,[$1]) +cf_x_athena_lib="" + +for cf_path in default \ + /usr/contrib/X11R6 \ + /usr/contrib/X11R5 \ + /usr/lib/X11R5 \ + /usr/local +do + for cf_lib in \ + "-l$cf_x_athena_root -lXmu" \ + "-l$cf_x_athena_root -lXpm -lXmu" \ + "-l${cf_x_athena_root}_s -lXmu_s" + do + if test -z "$cf_x_athena_lib" ; then + cf_save="$LIBS" + cf_test=XawSimpleMenuAddGlobalActions + if test $cf_path != default ; then + CF_ADD_LIBS(-L$cf_path/lib $cf_lib) + AC_MSG_CHECKING(for $cf_lib in $cf_path) + else + CF_ADD_LIBS($cf_lib) + AC_MSG_CHECKING(for $cf_test in $cf_lib) + fi + AC_TRY_LINK([],[$cf_test()], + [cf_result=yes], + [cf_result=no]) + AC_MSG_RESULT($cf_result) + if test "$cf_result" = yes ; then + cf_x_athena_lib="$cf_lib" + break + fi + LIBS="$cf_save" + fi + done +done + +if test -z "$cf_x_athena_lib" ; then + AC_MSG_ERROR( +[Unable to successfully link Athena library (-l$cf_x_athena_root) with test program]) +fi + +CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena) +AC_DEFINE_UNQUOTED($cf_x_athena_LIBS) +]) +dnl --------------------------------------------------------------------------- +dnl CF_X_EXT version: 3 updated: 2010/06/02 05:03:05 +dnl -------- +AC_DEFUN([CF_X_EXT],[ +CF_TRY_PKG_CONFIG(Xext,,[ + AC_CHECK_LIB(Xext,XextCreateExtension, + [CF_ADD_LIB(Xext)])]) +])dnl +dnl --------------------------------------------------------------------------- +dnl CF_X_TOOLKIT version: 15 updated: 2010/06/14 17:42:30 +dnl ------------ +dnl Check for X Toolkit libraries +dnl +AC_DEFUN([CF_X_TOOLKIT], +[ +AC_REQUIRE([AC_PATH_XTRA]) +AC_REQUIRE([CF_CHECK_CACHE]) + +cf_have_X_LIBS=no + +CF_TRY_PKG_CONFIG(xt,[ + + # workaround for broken ".pc" files used for X Toolkit. + case "x$X_PRE_LIBS" in #(vi + *-lICE*) + case "x$LIBS" in #(vi + *-lICE*) #(vi + ;; + *) + CF_VERBOSE(work around broken package) + CF_VERBOSE(...before $LIBS) + LIBS=`echo "$LIBS" | sed -e "s/[[ ]][[ ]]*/ /g" -e "s,-lXt ,-lXt $X_PRE_LIBS ," -e 's/ / /g'` + CF_VERBOSE(...after $LIBS) + ;; + esac + ;; + esac + + cf_have_X_LIBS=yes +],[ + + LDFLAGS="$X_LIBS $LDFLAGS" + CF_CHECK_CFLAGS($X_CFLAGS) + + AC_CHECK_FUNC(XOpenDisplay,,[ + AC_CHECK_LIB(X11,XOpenDisplay, + [CF_ADD_LIB(X11)],, + [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])]) + + AC_CHECK_FUNC(XtAppInitialize,,[ + AC_CHECK_LIB(Xt, XtAppInitialize, + [AC_DEFINE(HAVE_LIBXT) + cf_have_X_LIBS=Xt + LIBS="-lXt $X_PRE_LIBS $LIBS $X_EXTRA_LIBS"],, + [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])]) +]) + +if test $cf_have_X_LIBS = no ; then + AC_MSG_WARN( +[Unable to successfully link X Toolkit library (-lXt) with +test program. You will have to check and add the proper libraries by hand +to makefile.]) +fi +])dnl +dnl --------------------------------------------------------------------------- +dnl CF__CURSES_HEAD version: 2 updated: 2010/10/23 15:54:49 +dnl --------------- +dnl Define a reusable chunk which includes and when they +dnl are both available. +define([CF__CURSES_HEAD],[ +#ifdef HAVE_XCURSES +#include +char * XCursesProgramName = "test"; +#else +#include <${cf_cv_ncurses_header:-curses.h}> +#if defined(NCURSES_VERSION) && defined(HAVE_NCURSESW_TERM_H) +#include +#elif defined(NCURSES_VERSION) && defined(HAVE_NCURSES_TERM_H) +#include +#elif defined(HAVE_TERM_H) +#include +#endif +#endif +])