ncurses 5.0
[ncurses.git] / aclocal.m4
index efaa3949c2195223706f4e6737b84bb7c3cf6fd0..b4edb242bb98ec10c43ed693acab4c921dc48e35 100644 (file)
@@ -1,29 +1,41 @@
-dnl*****************************************************************************
-dnl Copyright 1996,1997 by Thomas E. Dickey <dickey@clark.net>                 *
-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,1999 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 <dickey@clark.net> 1996,1997,1998
+dnl
+dnl $Id: aclocal.m4,v 1.179 1999/10/23 21:49:25 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 \
+       "-Aa -D_HPUX_SOURCE +e" \
+       "-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 <stdio.h>
+#include <sys/types.h>
+],[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 <stdlib.h>
 #include <stdio.h>
-#if HAVE_BUILTIN_H
+#if HAVE_GXX_BUILTIN_H
+#include <g++/builtin.h>
+#elif HAVE_GPP_BUILTIN_H
+#include <gpp/builtin.h>
+#elif HAVE_BUILTIN_H
 #include <builtin.h>
 #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,250 @@ 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 <builtin.h>
+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 <stdlib.h>],[
+       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 ---------------------------------------------------------------------------
-AC_DEFUN([NC_DIRS_TO_MAKE],
+dnl Check for data that is usually declared in <stdio.h> or <errno.h>, 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([
+#if HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#include <stdio.h>
+#include <sys/types.h>
+#include <errno.h> ],
+    [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([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 <errno.h>
+AC_DEFUN([CF_ERRNO],
 [
-AC_MSG_CHECKING([for errno external decl])
-AC_CACHE_VAL(nc_cv_extern_errno,[
-       AC_TRY_COMPILE([
-#include <errno.h>],
-               [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 <etip.h.in>
+],[],[
+       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 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 <<EOF
+AC_DEFUN([CF_GCC_ATTRIBUTES],
+[
+if test -n "$GCC"
+then
+cat > conftest.i <<EOF
 #ifndef GCC_PRINTF
 #define GCC_PRINTF 0
 #endif
@@ -222,7 +486,7 @@ AC_DEFUN([NC_GCC_ATTRIBUTES],
 EOF
 if test -n "$GCC"
 then
-       AC_CHECKING([for gcc __attribute__ directives])
+       AC_CHECKING([for $CC __attribute__ directives])
        changequote(,)dnl
 cat > conftest.$ac_ext <<EOF
 #line __oline__ "configure"
@@ -245,25 +509,25 @@ extern void foo(void) GCC_NORETURN;
 int main(int argc GCC_UNUSED, char *argv[] GCC_UNUSED) { return 0; }
 EOF
        changequote([,])dnl
-       for nc_attribute in scanf printf unused noreturn
+       for cf_attribute in scanf printf unused noreturn
        do
-               NC_UPPERCASE($nc_attribute,NC_ATTRIBUTE)
-               nc_directive="__attribute__(($nc_attribute))"
-               echo "checking for gcc $nc_directive" 1>&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 <<EOF
-#define GCC_$NC_ATTRIBUTE 1
+#define GCC_$CF_ATTRIBUTE 1
 EOF
                        ;;
                *)
                cat >conftest.h <<EOF
-#define GCC_$NC_ATTRIBUTE $nc_directive
+#define GCC_$CF_ATTRIBUTE $cf_directive
 EOF
                        ;;
                esac
                if AC_TRY_EVAL(ac_compile); then
-                       test -n "$verbose" && AC_MSG_RESULT(... $nc_attribute)
+                       test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
                        cat conftest.h >>confdefs.h
 #              else
 #                      sed -e 's/__attr.*/\/*nothing*\//' conftest.h >>confdefs.h
@@ -273,7 +537,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 +546,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 <<EOF
 #line __oline__ "configure"
-int main(int argc, char *argv[]) { return argv[argc-1] == 0; }
+int main(int argc, char *argv[]) { return (argv[argc-1] == 0) ; }
 EOF
        changequote([,])dnl
-       AC_CHECKING([for gcc warning options])
-       nc_save_CFLAGS="$CFLAGS"
-       nc_warn_CFLAGS="-W -Wall"
-       nc_warn_CONST=""
-       test "$with_ext_const" = yes && nc_warn_CONST="Wwrite-strings"
-       for nc_opt in \
+       AC_CHECKING([for $CC warning options])
+       cf_save_CFLAGS="$CFLAGS"
+       EXTRA_CFLAGS="-W -Wall"
+       cf_warn_CONST=""
+       test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
+       for cf_opt in \
                Wbad-function-cast \
                Wcast-align \
                Wcast-qual \
@@ -308,41 +574,124 @@ EOF
                Wnested-externs \
                Wpointer-arith \
                Wshadow \
-               Wstrict-prototypes $nc_warn_CONST
+               Wstrict-prototypes $cf_warn_CONST
        do
-               CFLAGS="$nc_save_CFLAGS $nc_warn_CFLAGS -$nc_opt"
+               CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
                if AC_TRY_EVAL(ac_compile); then
-                       test -n "$verbose" && AC_MSG_RESULT(... -$nc_opt)
-                       nc_warn_CFLAGS="$nc_warn_CFLAGS -$nc_opt"
+                       test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
+                       EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
+                       test "$cf_opt" = Wcast-qual && EXTRA_CFLAGS="$EXTRA_CFLAGS -DXTSTRINGDEFINES"
                fi
        done
        rm -f conftest*
-       CFLAGS="$nc_save_CFLAGS"
+       CFLAGS="$cf_save_CFLAGS"
+fi
+AC_SUBST(EXTRA_CFLAGS)
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl Verify that a test program compiles and runs with GNAT
+dnl $cf_ada_make is set to the program that compiles/links
+AC_DEFUN([CF_GNAT_TRY_RUN],
+[
+rm -f conftest*
+cat >>conftest.ads <<CF_EOF
+$1
+CF_EOF
+cat >>conftest.adb <<CF_EOF
+$2
+CF_EOF
+if ( $cf_ada_make conftest 1>&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-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.10 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 -lm"
+       AC_TRY_LINK([
+#include <$cf_gpp_libname/builtin.h>
+       ],
+       [//float foo=abs(1.0);
+        two_arg_error_handler_t foo2 = lib_error_handler],
+       [cf_cxx_library=yes
+        CXXLIBS="$CXXLIBS -l$cf_gpp_libname -lm"
+        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 <builtin.h>
+       ],
+       [//float foo=abs(1.0);
+        two_arg_error_handler_t foo2 = lib_error_handler],
+       [cf_cxx_library=yes
+        CXXLIBS="$CXXLIBS -l$cf_gpp_libname -lm"
+        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 +711,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 <ctype.h>],[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)    $1=''     ;;
+       *)      $1='lib'  ;;
+       esac
+       LIB_PREFIX=[$]$1
+       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 +747,152 @@ dnl one:
 dnl    lib<name>.so    ->
 dnl    lib<name>.so.<major>    ->
 dnl    lib<name>.so.<maj>.<minor>
-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)
+                       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
+                       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 \
+                               MODEL=$CF_ITEM \
+                               model=$cf_subdir \
+                               prefix=$cf_prefix \
+                               suffix=$cf_suffix \
+                               subset=$cf_subset \
+                               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 \
+                               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 '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 <<NC_EOF
+               if test -f $srcdir/$cf_dir/headers; then
+cat >> Makefile <<CF_EOF
 install.includes \\
-NC_EOF
+uninstall.includes \\
+CF_EOF
                fi
-if test "$nc_dir" != "c++" ; then
+if test "$cf_dir" != "c++" ; then
 echo 'lint \' >> Makefile
 fi
-cat >> Makefile <<NC_EOF
+cat >> Makefile <<CF_EOF
 lintlib \\
 install.libs \\
-install.$nc_dir ::
-       cd $nc_dir; \$(MAKE) \$(NC_MFLAGS) \[$]@
-NC_EOF
-       elif test -f $srcdir/$nc_dir/headers; then
-cat >> Makefile <<NC_EOF
+uninstall.libs \\
+install.$cf_dir \\
+uninstall.$cf_dir ::
+       cd $cf_dir && \$(MAKE) \$(CF_MFLAGS) \[$]@
+CF_EOF
+       elif test -f $srcdir/$cf_dir/headers; then
+cat >> Makefile <<CF_EOF
 
 install.libs \\
-install.includes ::
-       cd $nc_dir; \$(MAKE) \$(NC_MFLAGS) \[$]@
-NC_EOF
+uninstall.libs \\
+install.includes \\
+uninstall.includes ::
+       cd $cf_dir && \$(MAKE) \$(CF_MFLAGS) \[$]@
+CF_EOF
 fi
 done
 
-cat >> Makefile <<NC_EOF
+cat >> Makefile <<CF_EOF
 
-install.data ::
-       cd misc; \$(MAKE) \$(NC_MFLAGS) \[$]@
+install.data \
+uninstall.data ::
+       cd misc && \$(MAKE) \$(CF_MFLAGS) \[$]@
 
-install.man ::
-       cd man; \$(MAKE) \$(NC_MFLAGS) \[$]@
+install.man \
+uninstall.man ::
+       cd man && \$(MAKE) \$(CF_MFLAGS) \[$]@
 
 distclean ::
        rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
        rm -f headers.sh headers.sed
        rm -rf \$(DIRS_TO_MAKE)
-NC_EOF
+CF_EOF
 
 dnl If we're installing into a subdirectory of /usr/include, etc., we should
 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
@@ -492,8 +904,8 @@ rm -f headers.sed headers.sh
 
 dnl ( generating this script makes the makefiles a little tidier :-)
 echo creating headers.sh
-cat >headers.sh <<NC_EOF
-#!/bin/sh
+cat >headers.sh <<CF_EOF
+#! /bin/sh
 # This shell script is generated by the 'configure' script.  It is invoked in a
 # subdirectory of the build tree.  It generates a sed-script in the parent
 # directory that is used to adjust includes for header files that reside in a
@@ -527,31 +939,45 @@ case \$DST in
        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 <<NC_EOF
+       if test -f $srcdir/$cf_dir/headers; then
+       cat >>$cf_dir/Makefile <<CF_EOF
 \$(INSTALL_PREFIX)\$(includedir) :
        \$(srcdir)/../mkinstalldirs \[$]@
 
 install \\
 install.libs \\
 install.includes :: \$(INSTALL_PREFIX)\$(includedir) \\
-NC_EOF
+CF_EOF
                j=""
-               for i in `cat $srcdir/$nc_dir/headers |fgrep -v "#"`
+               for i in `cat $srcdir/$cf_dir/headers |fgrep -v "#"`
                do
-                       test -n "$j" && echo "          $j \\" >>$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 "  @ (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_EOF
+
+uninstall \\
+uninstall.libs \\
+uninstall.includes ::
+CF_EOF
+               for i in `cat $srcdir/$cf_dir/headers |fgrep -v "#"`
                do
-                       echo "  @ ../headers.sh \$(INSTALL_DATA) \$(INSTALL_PREFIX)\$(includedir) \$(srcdir) $i" >>$nc_dir/Makefile
+                       i=`basename $i`
+                       echo "  -@ (cd \$(INSTALL_PREFIX)\$(includedir) && rm -f $i)" >>$cf_dir/Makefile
+                       test $i = curses.h && echo "    -@ (cd \$(INSTALL_PREFIX)\$(includedir) && rm -f ncurses.h)" >>$cf_dir/Makefile
                done
        fi
 done
@@ -559,26 +985,34 @@ done
 ])dnl
 dnl ---------------------------------------------------------------------------
 dnl Compute the library-suffix from the given model name
-AC_DEFUN([NC_LIB_SUFFIX],
+dnl $1 = model name
+dnl $2 = 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
+               openbsd*|freebsd*)
+                       $2='.so.$(REL_VERSION)' ;;
+               netbsd*)
+                       if test -f /usr/libexec/ld.elf_so; then
+                               $2='.so'
+                       else
+                               $2='.so.$(REL_VERSION)'
+                       fi
+                       ;;
+               hpux*)  $2='.sl'  ;;
                *)      $2='.so'  ;;
                esac
        esac
 ])dnl
 dnl ---------------------------------------------------------------------------
 dnl Compute the string to append to -library from the given model name
-AC_DEFUN([NC_LIB_TYPE],
+AC_DEFUN([CF_LIB_TYPE],
 [
        case $1 in
        normal)  $2=''   ;;
@@ -592,10 +1026,10 @@ 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 <<EOF
@@ -630,7 +1064,7 @@ EOF
        fi
        rm -f conftest.$ac_ext func.o
        ( eval $ac_cv_prog_RANLIB conftest.a ) 2>&5 >/dev/null
-       nc_saveLIBS="$LIBS"
+       cf_saveLIBS="$LIBS"
        LIBS="conftest.a $LIBS"
        AC_TRY_RUN([
        int main()
@@ -639,191 +1073,327 @@ 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($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 <sys/types.h>
+#include <sys/stat.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#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
        ])
-AC_MSG_RESULT($nc_cv_link_dataonly)
-test $nc_cv_link_dataonly = no && AC_DEFINE(BROKEN_LINKER)
+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 <<NC_EOF
+               cat >cf_makeflags.tmp <<CF_EOF
 all :
-       echo '.$nc_option'
-NC_EOF
-               set nc_result=`${MAKE-make} -f ncurses.tmp 2>/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 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
+
+  if test "$prefix" = "NONE" ; then
+     cf_prefix="$ac_default_prefix"
   else
-    nc_subdir='$mandir/man'
+     cf_prefix="$prefix"
   fi
 
-cat >man/edit_man.sh <<NC_EOF
+  case "$cf_manpage_form" in # (vi
+  *formatted*) # (vi
+    cf_subdir='$mandir/cat'
+    cf_format=yes
+    ;;
+  *)
+    cf_subdir='$mandir/man'
+    cf_format=no
+    ;;
+  esac
+
+test ! -d man && mkdir man
+cat >man/edit_man.sh <<CF_EOF
 changequote({{,}})dnl
-#!/bin/sh
+#! /bin/sh
 # this script is generated by the configure-script
-prefix="$nc_prefix"
+prefix="$cf_prefix"
 datadir="$datadir"
-MKDIRS="`cd $srcdir;pwd`/mkinstalldirs"
+MKDIRS="`cd $srcdir && pwd`/mkinstalldirs"
 INSTALL="$INSTALL"
 INSTALL_DATA="$INSTALL_DATA"
 TMP=\${TMPDIR-/tmp}/man\$\$
 trap "rm -f \$TMP" 0 1 2 5 15
 
+verb=\{{$}}1
+shift
+
 mandir=\{{$}}1
 shift
 
-for i in \{{$}}*
-do
-case \$i in
+for i in \{{$}}* ; do
+case \$i in #(vi
+*.orig|*.rej) ;; #(vi
 *.[0-9]*)
        section=\`expr "\$i" : '.*\\.\\([0-9]\\)[xm]*'\`;
-       if [ ! -d $nc_subdir\${section} ]; then
-               \$MKDIRS $nc_subdir\$section
+       if test \$verb = installing ; then
+       if test ! -d $cf_subdir\${section} ; then
+               \$MKDIRS $cf_subdir\$section
+       fi
        fi
        source=\`basename \$i\`
-NC_EOF
-if test -z "$nc_rename" ; then
-cat >>man/edit_man.sh <<NC_EOF
-       target=$nc_subdir\${section}/\$source
+CF_EOF
+if test "$cf_manpage_renames" = no ; then
+cat >>man/edit_man.sh <<CF_EOF
+       target=$cf_subdir\${section}/\$source
        sed -e "s,@DATADIR@,\$datadir," < \$i >\$TMP
-NC_EOF
+CF_EOF
 else
-cat >>man/edit_man.sh <<NC_EOF
-       target=\`grep "^\$source" $nc_rename | $AWK '{print \{{$}}2}'\`
+cat >>man/edit_man.sh <<CF_EOF
+       target=\`grep "^\$source" $cf_manpage_renames | $AWK '{print \{{$}}2}'\`
        if test -z "\$target" ; then
                echo '? missing rename for '\$source
                target="\$source"
        fi
-       target="$nc_subdir\$section/\$target"
-       sed -e 's,@DATADIR@,\$datadir,' < \$i | sed -f edit_man.sed >\$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 <<NC_EOF
+if test $cf_format = yes ; then
+cat >>man/edit_man.sh <<CF_EOF
        nroff -man \$TMP >\$TMP.out
        mv \$TMP.out \$TMP
-NC_EOF
+CF_EOF
 fi
-case "$nc_form" in
-compress)
-cat >>man/edit_man.sh <<NC_EOF
+case "$cf_manpage_form" in #(vi
+*compress*) #(vi
+cat >>man/edit_man.sh <<CF_EOF
+       if test \$verb = installing ; then
        if ( compress -f \$TMP )
        then
                mv \$TMP.Z \$TMP
-               target="\$target.Z"
        fi
-NC_EOF
+       fi
+       target="\$target.Z"
+CF_EOF
   ;;
-gzip)
-cat >>man/edit_man.sh <<NC_EOF
+*gzip*) #(vi
+cat >>man/edit_man.sh <<CF_EOF
+       if test \$verb = installing ; then
        if ( gzip -f \$TMP )
        then
                mv \$TMP.gz \$TMP
-               target="\$target.gz"
        fi
-NC_EOF
+       fi
+       target="\$target.gz"
+CF_EOF
   ;;
-BSDI)
-cat >>man/edit_man.sh <<NC_EOF
+*BSDI*)
+cat >>man/edit_man.sh <<CF_EOF
        # BSDI installs only .0 suffixes in the cat directories
        target="\`echo \$target|sed -e 's/\.[1-9]\+.\?/.0/'\`"
-NC_EOF
+CF_EOF
   ;;
 esac
-cat >>man/edit_man.sh <<NC_EOF
-       echo installing \$target
-       \$INSTALL_DATA \$TMP \$target
+cat >>man/edit_man.sh <<CF_EOF
+       echo \$verb \$target
+       if test \$verb = installing ; then
+               \$INSTALL_DATA \$TMP \$target
+       else
+               rm -f \$target
+       fi
        ;;
 esac
-done 
-NC_EOF
+done
+CF_EOF
 changequote([,])dnl
 chmod 755 man/edit_man.sh
-AC_MSG_RESULT($nc_form)
+
 ])dnl
 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,144 +1403,285 @@ 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
+  ;;
+.\[$]{*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 <sys/types.h>
 #include <regex.h>],[
        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 <regexp.h>],[
                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 <regexpr.h>],[
                        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
+
+       case $cf_cv_system_name in
+       hpux10.*)
                # (tested with gcc 2.7.2 -- I don't have c89)
-               if test "${CC}" = "gcc"; then
+               if test -n "$GCC"; then
                        CC_SHARED_OPTS='-fPIC'
+                       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*)
+       hpux*)
+               # (tested with gcc 2.7.2 -- I don't have c89)
+               if test -n "$GCC"; then
+                       CC_SHARED_OPTS='-fPIC'
+                       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 "${CC}" = "gcc"; then
+               if test -n "$GCC"; then
                        CC_SHARED_OPTS='-fPIC'
                else
                        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)
+               CC_SHARED_OPTS='-fpic'
+               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
+               if test $cf_cv_shlib_version = no ; then
+                       MK_SHARED_LIB='$(CC) -shared -Wl,-stats,-lc -o $[@]'
+               else
+                       MK_SHARED_LIB='$(CC) -shared -Wl,-soname,`basename $[@].$(ABI_VERSION)`,-stats,-lc -o $[@]'
+               fi
+               ;;
+       openbsd2*)
+               CC_SHARED_OPTS='-fpic -DPIC'
+               MK_SHARED_LIB='$(LD) -Bshareable -soname,`basename $[@].$(ABI_VERSION)` -o $[@]'
                ;;
-       NetBSD|FreeBSD)
+       openbsd*|freebsd*)
                CC_SHARED_OPTS='-fpic -DPIC'
                MK_SHARED_LIB='$(LD) -Bshareable -o $[@]'
+               test $cf_cv_shlib_version = auto && cf_cv_shlib_version=rel
+               ;;
+       netbsd*)
+               CC_SHARED_OPTS='-fpic -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 $[@].$(ABI_VERSION)` -o $[@]'
+                       test $cf_cv_shlib_version = auto && cf_cv_shlib_version=rel
+               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='-fpic'
+               else
+                       CC_SHARED_OPTS='-belf -KPIC'
+               fi
+               MK_SHARED_LIB='$(LD) -dy -G -h `basename [$]@.$(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
                        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
                ;;
-       UNIX_SV)
+       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='-fpic'
+               else
+                       CC_SHARED_OPTS='-KPIC'
+               fi
+               MK_SHARED_LIB='$(LD) -dy -G -h `basename $[@].$(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 $[@]'
@@ -980,240 +1691,567 @@ AC_DEFUN([NC_SHARED_OPTS],
                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 $[@]')
+                       if test "$cf_cv_do_symlinks" = reverse ; then
+                               AC_ERROR(cannot use --with-shlib-version with this platform)
+                       fi
+                       if test "$cf_cv_shlib_version" = rel ; then
+                               MK_SHARED_LIB="$MK_SHARED_LIB"'.$(REL_VERSION)'
+                       else
+                               MK_SHARED_LIB="$MK_SHARED_LIB"'.$(ABI_VERSION)'
+                       fi
+                       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 <sys/types.h>
+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 <sys/types.h>
 #if HAVE_TERMIOS_H
 #include <termios.h>
-#endif],
-       [speed_t x = 0],
-       [nc_cv_type_speed_t=yes],
-       [nc_cv_type_speed_t=no])
+#else
+#if HAVE_TERMIO_H
+#include <termio.h>
+#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        <sys/stream.h>
+#include        <sys/ptem.h>
+#endif
+#if !defined(sun) || !defined(HAVE_TERMIOS_H)
+#include <sys/ioctl.h>
+#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 <sys/types.h>],
+       [speed_t some_variable = 0],
+       [OSPEED_TYPE=speed_t],
+       [OSPEED_TYPE=unsigned])
+AC_TRY_COMPILE([#include <termios.h>],
+       [speed_t some_variable = 0],
+       [OSPEED_TYPE=speed_t
+        OSPEED_INCLUDES="#include <termios.h>"],[])
+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_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_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 -d $srcdir/Ada95; 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 -lm"
+AC_TRY_LINK([
+#include <strstream.h>],[
+char buf[80];
+strstreambuf foo(buf, sizeof(buf))
+//destroy foo
+],
+       [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 <sys/types.h>
+#include <signal.h>],
+       [struct sigaction act],
+       [sigact_bad=no],
+       [
+AC_TRY_COMPILE([
+#define _POSIX_SOURCE
+#include <sys/types.h>
+#include <signal.h>],
+       [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 <termios.h>],
+               [struct termios foo; int x = foo.c_iflag],
+               termios_bad=no, [
+               AC_TRY_COMPILE([
+#define _POSIX_SOURCE
+#include <termios.h>],
+                       [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 <stdio.h>
-#include <sys/types.h>
-#include <errno.h> ],
-       [ 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 <sys/time.h> with <sys/select.h>; 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 <termios.h>
+AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
+AC_CACHE_VAL(cf_cv_sys_time_select,[
+AC_TRY_COMPILE([
+#include <sys/types.h>
+#if HAVE_SYS_TIME_H
+#include <sys/time.h>
 #endif
-#if SYSTEM_LOOKS_LIKE_SCO
-/* they neglected to define struct winsize in termios.h -- it's only
-   in termio.h */
-#include       <sys/stream.h>
-#include       <sys/ptem.h>
+#if HAVE_SYS_SELECT_H
+#include <sys/select.h>
 #endif
-#if !defined(sun) || !defined(HAVE_TERMIOS_H)
-#include <sys/ioctl.h>
+],[],[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 <stddef.h>    /* we want wchar_t */
+#define WANT_BITS 39
+#else
+#define WANT_BITS 31
 #endif
+#include <stdio.h>
 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 <signal.h>],
                [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 <stdio.h>
+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