]> ncurses.scripts.mit.edu Git - ncurses.git/blobdiff - configure.in
ncurses 6.1 - patch 20190518
[ncurses.git] / configure.in
index d1bcd88e4251d930b7fd727ed7a44ecedfacd53d..03b1c64a952dd0ff59a9ddf08c250f6bb62338c8 100644 (file)
@@ -1,5 +1,5 @@
 dnl***************************************************************************
 dnl***************************************************************************
-dnl Copyright (c) 1998,1999 Free Software Foundation, Inc.                   *
+dnl Copyright (c) 1998-2018,2019 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                                                                          *
 dnl Permission is hereby granted, free of charge, to any person obtaining a  *
 dnl copy of this software and associated documentation files (the            *
@@ -26,81 +26,54 @@ dnl sale, use or other dealings in this Software without prior written       *
 dnl authorization.                                                           *
 dnl***************************************************************************
 dnl
 dnl authorization.                                                           *
 dnl***************************************************************************
 dnl
-dnl Author: Thomas E. Dickey <dickey@clark.net> 1996,1997
+dnl Author: Thomas E. Dickey 1995-on
 dnl
 dnl
-dnl $Id: configure.in,v 1.179 1999/10/24 00:32:42 tom Exp $
+dnl $Id: configure.in,v 1.679 2019/03/30 21:44:53 tom Exp $
 dnl Process this file with autoconf to produce a configure script.
 dnl Process this file with autoconf to produce a configure script.
-AC_PREREQ(2.12.971222)
-AC_REVISION($Revision: 1.179 $)
+dnl
+dnl See https://invisible-island.net/autoconf/ for additional information.
+dnl
+dnl ---------------------------------------------------------------------------
+AC_PREREQ(2.52.20170501)
+AC_REVISION($Revision: 1.679 $)
 AC_INIT(ncurses/base/lib_initscr.c)
 AC_CONFIG_HEADER(include/ncurses_cfg.h:include/ncurses_cfg.hin)
 
 AC_INIT(ncurses/base/lib_initscr.c)
 AC_CONFIG_HEADER(include/ncurses_cfg.h:include/ncurses_cfg.hin)
 
+CF_TOP_BUILDDIR
 CF_SUBST_NCURSES_VERSION
 CF_SUBST_NCURSES_VERSION
-CF_CHECK_CACHE
-AC_ARG_WITH(system-type,
-[  --with-system-type=XXX  test: override derived host system-type],
-[AC_MSG_WARN(overriding system type to $withval)
- cf_cv_system_name=$withval])
-
-# We need a configure script only when compiling as part of GNU C library.
-# Here we have to generate one of the files we need while compiling.
-#
-# The only problem is that users of the package might think they have to
-# run configure themself and find it irritating when nothing happens.
-#
-# So we try here to find out whether we are called from the glibc configure
-# or by a user.
-#
-dnl Check if we are a drop-in addition to glibc.
-AC_ARG_ENABLE(add-ons, dnl
-[  --enable-add-ons=DIR... used to check if we are a glibc add-on.],
-               [glibc_add_on=yes],
-               [glibc_add_on=])
-
-dnl We need to use [ and ] for other purposes for a while now.
-changequote(,)dnl
-if test x"$glibc_add_on" = "xyes" ; then
-  rm -f $srcdir/Banner
-  # We are in glibc.
-  rm -f $srcdir/Makefile
-  cp $srcdir/Makefile.glibc $srcdir/Makefile
-  echo "ncurses `grep \"^[     ]*ncurses-version[      ]*=.*$\" \
-               $srcdir/Makefile | sed -e \
-               's/^[   ]*ncurses-version[      ]*=[    ]*\([^  ^ ]*\)[         ]*$/\1/'`" > $srcdir/Banner
-  exit 0
-fi
-changequote([,])dnl
+CF_VERSION_INFO(NCURSES,ncurses)
+
+CF_WITH_REL_VERSION(NCURSES)
+CF_NCURSES_WITH_ABI_VERSION
+
+CF_WITH_SYSTYPE
 
 ###    Save the given $CFLAGS to allow user-override.
 cf_user_CFLAGS="$CFLAGS"
 
 ###    Default install-location
 CF_CFG_DEFAULTS
 
 ###    Save the given $CFLAGS to allow user-override.
 cf_user_CFLAGS="$CFLAGS"
 
 ###    Default install-location
 CF_CFG_DEFAULTS
+### Defaults for ncurses ABI
+CF_ABI_DEFAULTS
 
 ###    Checks for programs.
 
 ###    Checks for programs.
-AC_PROG_CC
-if test -n "$GCC" ; then
-AC_MSG_CHECKING(version of gcc)
-eval "$CC --version"
-fi
-if test $host != $build; then
-  AC_CHECK_PROGS(BUILD_CC, $CC gcc cc)
+AC_ARG_WITH(ada,
+       [  --without-ada           suppress check for Ada95, don't build demo],
+       [cf_with_ada=$withval],
+       [cf_with_ada=yes])
+
+if test "x$cf_with_ada" = xyes
+then
+       cf_prog_cc="gnatgcc gcc cc"
+else
+       cf_prog_cc="gcc cc"
 fi
 fi
+CF_PROG_CC($cf_prog_cc)
+
 AC_PROG_CPP
 AC_PROG_GCC_TRADITIONAL
 AC_PROG_CPP
 AC_PROG_GCC_TRADITIONAL
-AC_ISC_POSIX
-CF_ANSI_CC_REQD
-CF_PROG_EXT
-
-case "$cf_cv_system_name" in
-freebsd*) #(vi
-  test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
-  ;;
-*) LDPATH=$PATH:/sbin:/usr/sbin
-  AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
-  ;;
-esac
-AC_SUBST(LDCONFIG)
+CF_PROG_CC_C_O(CC,[$CFLAGS $CPPFLAGS])
+CF_PROG_LDCONFIG
 
 dnl DEFECT in autoconf 2.12:   an attempt to set policy, this breaks the
 dnl                            configure script by not letting us test if C++
 
 dnl DEFECT in autoconf 2.12:   an attempt to set policy, this breaks the
 dnl                            configure script by not letting us test if C++
@@ -115,11 +88,64 @@ if test "X$cf_with_cxx" = Xno ; then
        CXX=""
        GXX=""
 else
        CXX=""
        GXX=""
 else
+       # with autoconf 2.13, we can change the error to a warning:
+       pushdef([AC_MSG_ERROR],
+               [AC_MSG_RESULT(no)
+                AC_MSG_WARN([You don't have any C++ compiler, too bad])
+               cf_with_cxx=no; CXX=""; GXX="";])dnl
        AC_PROG_CXX
        AC_PROG_CXX
+       popdef([AC_MSG_ERROR])dnl
+
+       AC_LANG_PUSH(C++)
+       if test "x$cf_with_cxx" != xno
+       then
+               # Several of the C++ configurations do not work, particularly when
+               # cross-compiling (20140913 -TD)
+               AC_MSG_CHECKING(if $CXX works)
+
+               save_CPPFLAGS="$CPPFLAGS"
+               eval cf_includedir=${includedir}
+               CPPFLAGS="$CPPFLAGS -I${cf_includedir}"
+               AC_TRY_COMPILE([
+#include <stdlib.h>
+#include <stdio.h>
+],
+               [
+               printf("Hello world!\n")
+               ],
+               [cf_cxx_works=yes],
+               [cf_cxx_works=no])
+               CPPFLAGS="$save_CPPFLAGS"
+
+               AC_MSG_RESULT($cf_cxx_works)
+               if test "x$cf_cxx_works" = xno
+               then
+                       AC_MSG_WARN([Ignore $CXX, since it cannot compile hello-world.])
+                       cf_with_cxx=no; CXX=""; GXX="";
+               fi
+       fi
+       AC_LANG_POP
+
+       # autoconf 2.5x removed the error (hardcoding it to g++, or just blank)
+       if test "$CXX" = "g++" ; then
+               AC_PATH_PROG(CXX,g++)
+       fi
+       case "x$CXX" in
+       (x|xg++)
+               AC_MSG_WARN([You don't have any C++ compiler, too bad])
+               cf_with_cxx=no; CXX=""; GXX="";
+               ;;
+       esac
 fi
 fi
-changequote(,)dnl
-if test -n "$GXX" ; then case "`${CXX-g++} --version`" in 1*|2.[0-6]*) GXX=""; CXX=""; ac_cv_prog_gxx=no; cf_cxx_library=no ; echo No: templates do not work;; esac; fi
-changequote([,])dnl
+
+CF_GXX_VERSION
+case $GXX_VERSION in
+(1*|2.[[0-6]]*)
+       # GXX=""; CXX=""; ac_cv_prog_gxx=no
+       # cf_cxx_library=no
+       AC_MSG_WARN(templates do not work)
+       ;;
+esac
 
 AC_MSG_CHECKING(if you want to build C++ binding and demo)
 AC_ARG_WITH(cxx-binding,
 
 AC_MSG_CHECKING(if you want to build C++ binding and demo)
 AC_ARG_WITH(cxx-binding,
@@ -129,59 +155,158 @@ AC_ARG_WITH(cxx-binding,
 AC_MSG_RESULT($cf_with_cxx_binding)
 
 AC_MSG_CHECKING(if you want to build with Ada95)
 AC_MSG_RESULT($cf_with_cxx_binding)
 
 AC_MSG_CHECKING(if you want to build with Ada95)
-AC_ARG_WITH(ada,
-       [  --without-ada           suppress check for Ada95, don't build demo],
-       [cf_with_ada=$withval],
-       [cf_with_ada=yes])
 AC_MSG_RESULT($cf_with_ada)
 
 AC_MSG_RESULT($cf_with_ada)
 
+AC_MSG_CHECKING(if you want to install terminal database)
+AC_ARG_ENABLE(db-install,
+       [  --disable-db-install    suppress install of terminal database],
+       [cf_with_db_install=$enableval],
+       [cf_with_db_install=yes])
+AC_MSG_RESULT($cf_with_db_install)
+
+AC_MSG_CHECKING(if you want to install manpages)
+AC_ARG_WITH(manpages,
+       [  --without-manpages      suppress install of manpages],
+       [cf_with_manpages=$withval],
+       [cf_with_manpages=yes])
+AC_MSG_RESULT($cf_with_manpages)
+
 AC_MSG_CHECKING(if you want to build programs such as tic)
 AC_ARG_WITH(progs,
 AC_MSG_CHECKING(if you want to build programs such as tic)
 AC_ARG_WITH(progs,
-       [  --without-progs         suppress build with programs (e.g., tic)],
+       [  --without-progs         suppress build/install with programs (e.g., tic)],
        [cf_with_progs=$withval],
        [cf_with_progs=yes])
 AC_MSG_RESULT($cf_with_progs)
 
        [cf_with_progs=$withval],
        [cf_with_progs=yes])
 AC_MSG_RESULT($cf_with_progs)
 
-modules_to_build="ncurses"
-if test "X$cf_with_progs" != Xno ; then
-modules_to_build="$modules_to_build progs tack"
+if test -f $srcdir/tack/tack.h; then
+       if test "x$cross_compiling" = xyes ; then
+               CF_VERBOSE(ignoring tack because we are cross-compiling)
+               cf_with_tack=no
+       else
+               AC_MSG_CHECKING(if you want to build the tack program)
+               AC_ARG_WITH(tack,
+                       [  --without-tack          suppress build/install with tack program],
+                       [cf_with_tack=$withval],
+                       [cf_with_tack=$cf_with_progs])
+               AC_MSG_RESULT($cf_with_tack)
+       fi
+else
+       cf_with_tack=no
 fi
 fi
+
+AC_MSG_CHECKING(if you want to build test-programs)
+AC_ARG_WITH(tests,
+       [  --without-tests         suppress build/install with test-programs],
+       [cf_with_tests=$withval],
+       [cf_with_tests=yes])
+AC_MSG_RESULT($cf_with_tests)
+
+AC_MSG_CHECKING(if you wish to install curses.h)
+AC_ARG_WITH(curses-h,
+       [  --without-curses-h      install curses.h as ncurses.h only],
+       [with_curses_h=$withval],
+       [with_curses_h=yes])
+AC_MSG_RESULT($with_curses_h)
+
+modules_to_build="ncurses"
+test "X$cf_with_progs" != Xno && modules_to_build="$modules_to_build progs"
+test "X$cf_with_tack"  != Xno && modules_to_build="$modules_to_build tack"
 modules_to_build="$modules_to_build panel menu form"
 
 modules_to_build="$modules_to_build panel menu form"
 
-AC_PROG_AWK
-AC_PROG_MAKE_SET
+AC_ARG_PROGRAM
+
+CF_PROG_AWK
+CF_PROG_EGREP
 CF_PROG_INSTALL
 CF_PROG_INSTALL
+CF_PROG_LINT
+CF_PROG_LN_S
+
 AC_SYS_LONG_FILE_NAMES
 AC_SYS_LONG_FILE_NAMES
-AC_PROG_LN_S
-AC_PROG_RANLIB
-AC_CHECK_PROGS(LINT, tdlint lint alint)
-AC_CHECK_PROGS(MAN, man man_db)
-AC_SUBST(LINT_OPTS)
 
 
-dnl These are standard among *NIX systems, but not when cross-compiling
-CF_SUBST(loader,LD,ld)
-CF_SUBST(archiver,AR,ar)
-CF_SUBST(archiver options,AR_OPTS,rv)
+# Provide for renaming "ncurses5-config" to "ncurses5X-config", etc., in case
+# of package conflict.
+cf_config_suffix=
+AC_ARG_WITH(config-suffix,
+       [  --with-config-suffix=X  suffixes ncursesXX-config file],
+       [case "x$withval" in
+       (xyes|xno)
+               AC_MSG_WARN(expected a value for config-suffix option)
+               ;;
+       (*)     cf_config_suffix="$withval"
+               ;;
+       esac])
+AC_SUBST(cf_config_suffix)
 
 
+# If we find pkg-config, check if we should install the ".pc" files.
+CF_PKG_CONFIG
+CF_WITH_PKG_CONFIG_LIBDIR
+CF_ENABLE_PC_FILES
+if test -z "$MAKE_PC_FILES"
+then
+       AC_MSG_CHECKING(for suffix to add to pc-files)
+AC_ARG_WITH(pc-suffix,
+       [  --with-pc-suffix        suffixes pc-files],
+       [case "x$withval" in
+       (xyes|xno)
+               PC_MODULE_SUFFIX=
+               ;;
+       (*)     PC_MODULE_SUFFIX="$withval"
+               ;;
+       esac])
+       test -z "$PC_MODULE_SUFFIX" && PC_MODULE_SUFFIX=none
+       AC_MSG_RESULT($PC_MODULE_SUFFIX)
+       test "$PC_MODULE_SUFFIX" = none && PC_MODULE_SUFFIX=
+       AC_SUBST(PC_MODULE_SUFFIX)
+fi
+
+AC_MSG_CHECKING(if we should assume mixed-case filenames)
+AC_ARG_ENABLE(mixed-case,
+       [  --enable-mixed-case     tic should assume mixed-case filenames],
+       [enable_mixedcase=$enableval],
+       [enable_mixedcase=auto])
+AC_MSG_RESULT($enable_mixedcase)
+if test "$enable_mixedcase" = "auto" ; then
+       CF_MIXEDCASE_FILENAMES
+else
+       cf_cv_mixedcase=$enable_mixedcase
+       if test "x$enable_mixedcase" = "xyes" ; then
+               AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if tic should assume mixed-case filenames])
+       fi
+fi
+
+# do this after mixed-case option (tags/TAGS is not as important as tic).
+AC_PROG_MAKE_SET
+CF_MAKE_TAGS
 CF_MAKEFLAGS
 
 CF_MAKEFLAGS
 
+dnl These are standard among *NIX systems, but not when cross-compiling
+AC_CHECK_TOOL(RANLIB, ranlib, ':')
+AC_CHECK_TOOL(LD, ld, ld)
+AC_CHECK_TOOL(AR, ar, ar)
+AC_CHECK_TOOL(NM, nm, nm)
+CF_AR_FLAGS
+
 dnl Special option for use by system-builders: the install-prefix is used to
 dnl adjust the location into which the actual install is done, so that an
 dnl archive can be built without modifying the host system's configuration.
 AC_MSG_CHECKING(if you have specified an install-prefix)
 AC_ARG_WITH(install-prefix,
 dnl Special option for use by system-builders: the install-prefix is used to
 dnl adjust the location into which the actual install is done, so that an
 dnl archive can be built without modifying the host system's configuration.
 AC_MSG_CHECKING(if you have specified an install-prefix)
 AC_ARG_WITH(install-prefix,
-       [  --with-install-prefix   prefixes actual install-location],
-       [case "$withval" in #(vi
-       yes|no) #(vi
+       [  --with-install-prefix   prefixes actual install-location ($DESTDIR)],
+       [case "x$withval" in
+       (xyes|xno)
                ;;
                ;;
-       *)      INSTALL_PREFIX="$withval"
+       (*)     DESTDIR="$withval"
                ;;
        esac])
                ;;
        esac])
-AC_MSG_RESULT($INSTALL_PREFIX)
-AC_SUBST(INSTALL_PREFIX)
+AC_MSG_RESULT($DESTDIR)
+AC_SUBST(DESTDIR)
 
 ###############################################################################
 
 ###############################################################################
-CF_MAN_PAGES
+CF_HELP_MESSAGE(Build-Tools Needed to Compile Temporary Applications for Cross-compiling:)
+# If we're cross-compiling, allow the user to override the tools and their
+# options.  The configure script is oriented toward identifying the host
+# compiler, etc., but we need a build compiler to generate parts of the source.
+CF_BUILD_CC
 
 ###############################################################################
 CF_HELP_MESSAGE(Options to Specify the Libraries Built/Used:)
 
 ###############################################################################
 CF_HELP_MESSAGE(Options to Specify the Libraries Built/Used:)
@@ -190,6 +315,14 @@ CF_HELP_MESSAGE(Options to Specify the Libraries Built/Used:)
 ### Use "--without-normal --with-shared" to allow the default model to be
 ### shared, for example.
 cf_list_models=""
 ### Use "--without-normal --with-shared" to allow the default model to be
 ### shared, for example.
 cf_list_models=""
+AC_SUBST(cf_list_models)dnl    the complete list of models ("normal debug")
+
+CF_WITH_LIBTOOL
+if test "$with_libtool" != "no" ; then
+
+cf_list_models="$cf_list_models libtool"
+
+else
 
 AC_MSG_CHECKING(if you want to build shared libraries)
 AC_ARG_WITH(shared,
 
 AC_MSG_CHECKING(if you want to build shared libraries)
 AC_ARG_WITH(shared,
@@ -197,7 +330,7 @@ AC_ARG_WITH(shared,
        [with_shared=$withval],
        [with_shared=no])
 AC_MSG_RESULT($with_shared)
        [with_shared=$withval],
        [with_shared=no])
 AC_MSG_RESULT($with_shared)
-test "$with_shared" = "yes" && cf_list_models="$cf_list_models shared"
+test "x$with_shared" = "xyes" && cf_list_models="$cf_list_models shared"
 
 AC_MSG_CHECKING(if you want to build static libraries)
 AC_ARG_WITH(normal,
 
 AC_MSG_CHECKING(if you want to build static libraries)
 AC_ARG_WITH(normal,
@@ -205,7 +338,7 @@ AC_ARG_WITH(normal,
        [with_normal=$withval],
        [with_normal=yes])
 AC_MSG_RESULT($with_normal)
        [with_normal=$withval],
        [with_normal=yes])
 AC_MSG_RESULT($with_normal)
-test "$with_normal" = "yes" && cf_list_models="$cf_list_models normal"
+test "x$with_normal" = "xyes" && cf_list_models="$cf_list_models normal"
 
 AC_MSG_CHECKING(if you want to build debug libraries)
 AC_ARG_WITH(debug,
 
 AC_MSG_CHECKING(if you want to build debug libraries)
 AC_ARG_WITH(debug,
@@ -213,7 +346,7 @@ AC_ARG_WITH(debug,
        [with_debug=$withval],
        [with_debug=yes])
 AC_MSG_RESULT($with_debug)
        [with_debug=$withval],
        [with_debug=yes])
 AC_MSG_RESULT($with_debug)
-test "$with_debug" = "yes" && cf_list_models="$cf_list_models debug"
+test "x$with_debug" = "xyes" && cf_list_models="$cf_list_models debug"
 
 AC_MSG_CHECKING(if you want to build profiling libraries)
 AC_ARG_WITH(profile,
 
 AC_MSG_CHECKING(if you want to build profiling libraries)
 AC_ARG_WITH(profile,
@@ -221,76 +354,43 @@ AC_ARG_WITH(profile,
        [with_profile=$withval],
        [with_profile=no])
 AC_MSG_RESULT($with_profile)
        [with_profile=$withval],
        [with_profile=no])
 AC_MSG_RESULT($with_profile)
-test "$with_profile" = "yes" && cf_list_models="$cf_list_models profile"
-
-AC_MSG_CHECKING(if you want to build a separate terminfo library)
-AC_ARG_WITH(termlib,
-       [  --with-termlib          generate separate terminfo library],
-       [with_termlib=$withval],
-       [with_termlib=no])
-AC_MSG_RESULT($with_termlib)
+test "x$with_profile" = "xyes" && cf_list_models="$cf_list_models profile"
 
 
-### Checks for special libraries, must be done up-front.
-AC_MSG_CHECKING(if you want to link with dbmalloc for testing)
-AC_ARG_WITH(dbmalloc,
-       [  --with-dbmalloc         test: use Conor Cahill's dbmalloc library],
-       [with_dbmalloc=$withval],
-       [with_dbmalloc=no])
-AC_MSG_RESULT($with_dbmalloc)
-if test $with_dbmalloc = yes ; then
-       AC_CHECK_LIB(dbmalloc,debug_malloc)
-fi
-
-AC_MSG_CHECKING(if you want to link with dmalloc for testing)
-AC_ARG_WITH(dmalloc,
-       [  --with-dmalloc          test: use Gray Watson's dmalloc library],
-       [with_dmalloc=$withval],
-       [with_dmalloc=no])
-AC_MSG_RESULT($with_dmalloc)
-if test $with_dmalloc = yes ; then
-       AC_CHECK_LIB(dmalloc,dmalloc_debug)
 fi
 
 fi
 
-SHLIB_LIST=""
-AC_MSG_CHECKING(if you want to link with the gpm mouse library)
-AC_ARG_WITH(gpm,
-       [  --with-gpm              use Alessandro Rubini's GPM library],
-       [with_gpm=$withval],
-       [with_gpm=no])
-AC_MSG_RESULT($with_gpm)
-if test $with_gpm = yes ; then
-       AC_CHECK_LIB(gpm,Gpm_Open,[
-               EXTRA_LIBS="-lgpm -lncurses $EXTRA_LIBS"
-               SHLIB_LIST="-lgpm $SHLIB_LIST"
-               AC_DEFINE(HAVE_LIBGPM)
-               AC_CHECK_HEADERS(gpm.h)
-       ],AC_MSG_WARN(Cannot link with gpm library - read the FAQ))
+if test "X$cf_with_cxx_binding" != Xno; then
+if test "x$with_shared" = "xyes"; then
+AC_MSG_CHECKING(if you want to build C++ shared libraries)
+AC_ARG_WITH(cxx-shared,
+       [  --with-cxx-shared       generate C++ shared-libraries],
+       [with_shared_cxx=$withval],
+       [with_shared_cxx=no])
+AC_MSG_RESULT($with_shared_cxx)
+fi
 fi
 
 fi
 
-TINFO_LIST="$SHLIB_LIST"
-test $with_termlib = yes && SHLIB_LIST="$SHLIB_LIST -ltinfo"
-
-AC_SUBST(EXTRA_LIBS)
-AC_SUBST(TINFO_LIST)
-AC_SUBST(SHLIB_LIST)
+###############################################################################
 
 AC_MSG_CHECKING(for specified models)
 test -z "$cf_list_models" && cf_list_models=normal
 
 AC_MSG_CHECKING(for specified models)
 test -z "$cf_list_models" && cf_list_models=normal
+dnl If we use libtool to generate libraries, then it must be the only
+dnl specified model.
+test "$with_libtool" != "no" && cf_list_models=libtool
 AC_MSG_RESULT($cf_list_models)
 
 ### Use the first model as the default, and save its suffix for use in building
 ### up test-applications.
 AC_MSG_RESULT($cf_list_models)
 
 ### Use the first model as the default, and save its suffix for use in building
 ### up test-applications.
-DFT_LWR_MODEL=`echo $cf_list_models | $AWK '{print $1}'`
+AC_MSG_CHECKING(for default model)
+DFT_LWR_MODEL=`echo "$cf_list_models" | $AWK '{print $1}'`
+AC_MSG_RESULT($DFT_LWR_MODEL)
+
 CF_UPPER(DFT_UPR_MODEL,$DFT_LWR_MODEL)dnl
 CF_UPPER(DFT_UPR_MODEL,$DFT_LWR_MODEL)dnl
-CF_LIB_SUFFIX($DFT_LWR_MODEL,DFT_DEP_SUFFIX)dnl
-CF_LIB_TYPE($DFT_LWR_MODEL,DFT_ARG_SUFFIX)dnl
-CF_OBJ_SUBDIR($DFT_LWR_MODEL,DFT_OBJ_SUBDIR)dnl
-AC_SUBST(DFT_OBJ_SUBDIR)dnl    the default object-directory ("obj")
+
 AC_SUBST(DFT_LWR_MODEL)dnl     the default model ("normal")
 AC_SUBST(DFT_UPR_MODEL)dnl     the default model ("NORMAL")
 AC_SUBST(DFT_LWR_MODEL)dnl     the default model ("normal")
 AC_SUBST(DFT_UPR_MODEL)dnl     the default model ("NORMAL")
-AC_SUBST(DFT_DEP_SUFFIX)dnl    the corresponding library-suffix (".a")
-AC_SUBST(DFT_ARG_SUFFIX)dnl    the string to append to "-lncurses" ("")
-AC_SUBST(cf_list_models)dnl    the complete list of models ("normal debug")
+
+TICS_NAME=tic
+AC_SUBST(TICS_NAME)
 
 TINFO_NAME=tinfo
 AC_SUBST(TINFO_NAME)
 
 TINFO_NAME=tinfo
 AC_SUBST(TINFO_NAME)
@@ -299,80 +399,211 @@ LIB_NAME=ncurses
 AC_SUBST(LIB_NAME)
 
 LIB_DIR=../lib
 AC_SUBST(LIB_NAME)
 
 LIB_DIR=../lib
-CF_LIB_PREFIX(cf_prefix)
-LIB_PREFIX=$LIB_DIR/$cf_prefix
-AC_SUBST(LIB_PREFIX)
+LIB_2ND=../../lib
+
+CF_WITH_LIB_PREFIX(cf_prefix)
+
+LIB_SUFFIX=
+AC_SUBST(LIB_SUFFIX)
+CF_PATHSEP
+
+###############################################################################
+
+AC_MSG_CHECKING(if you want to build a separate terminfo library)
+AC_ARG_WITH(termlib,
+       [  --with-termlib          generate separate terminfo library],
+       [with_termlib=$withval],
+       [with_termlib=no])
+AC_MSG_RESULT($with_termlib)
+
+AC_MSG_CHECKING(if you want to build a separate tic library)
+AC_ARG_WITH(ticlib,
+       [  --with-ticlib           generate separate tic library],
+       [with_ticlib=$withval],
+       [with_ticlib=no])
+AC_MSG_RESULT($with_ticlib)
 
 dnl Not all ports of gcc support the -g option
 
 if test X"$CC_G_OPT" = X"" ; then
        CC_G_OPT='-g'
 
 dnl Not all ports of gcc support the -g option
 
 if test X"$CC_G_OPT" = X"" ; then
        CC_G_OPT='-g'
-       test -n "$GCC" && test "${ac_cv_prog_cc_g}" != yes && CC_G_OPT=''
+       test -n "$GCC" && test "x${ac_cv_prog_cc_g}" != xyes && CC_G_OPT=''
 fi
 AC_SUBST(CC_G_OPT)
 
 if test X"$CXX_G_OPT" = X"" ; then
        CXX_G_OPT='-g'
 fi
 AC_SUBST(CC_G_OPT)
 
 if test X"$CXX_G_OPT" = X"" ; then
        CXX_G_OPT='-g'
-       test -n "$GXX" && test "${ac_cv_prog_cxx_g}" != yes && CXX_G_OPT=''
+       test -n "$GXX" && test "x${ac_cv_prog_cxx_g}" != xyes && CXX_G_OPT=''
 fi
 AC_SUBST(CXX_G_OPT)
 
 fi
 AC_SUBST(CXX_G_OPT)
 
+AC_MSG_CHECKING(for default loader flags)
 case $DFT_LWR_MODEL in
 case $DFT_LWR_MODEL in
-normal)  LD_MODEL=''   ;;
-debug)   LD_MODEL=$CC_G_OPT ;;
-profile) LD_MODEL='-pg';;
-shared)  LD_MODEL=''   ;;
+(libtool) LD_MODEL=''   ;;
+(normal)  LD_MODEL=''   ;;
+(debug)   LD_MODEL=$CC_G_OPT ;;
+(profile) LD_MODEL='-pg';;
+(shared)  LD_MODEL=''   ;;
 esac
 AC_SUBST(LD_MODEL)dnl          the type of link (e.g., -g or -pg)
 esac
 AC_SUBST(LD_MODEL)dnl          the type of link (e.g., -g or -pg)
+AC_MSG_RESULT($LD_MODEL)
 
 
-AC_MSG_CHECKING(if rpath option should be used)
-AC_ARG_ENABLE(rpath,
-[  --enable-rpath          use rpath option when generating shared libraries],
-[cf_cv_ld_rpath=$enableval],
-[cf_cv_ld_rpath=no])
-AC_MSG_RESULT($cf_cv_ld_rpath)
+case $DFT_LWR_MODEL in
+(shared)
+CF_ENABLE_RPATH
+AC_MSG_CHECKING(if shared libraries should be relinked during install)
+AC_ARG_ENABLE(relink,
+[  --disable-relink        relink shared libraries during install],
+[cf_cv_do_relink=$enableval],
+[cf_cv_do_relink=yes])
+AC_MSG_RESULT($cf_cv_do_relink)
+       ;;
+esac
 
 
+# we will build libraries one-level down.
+rel_builddir=..
 CF_SHARED_OPTS
 CF_SHARED_OPTS
-if test "$CC_SHARED_OPTS" = "unknown"; then
-       for model in $cf_list_models; do
-               if test "$model" = "shared"; then
+for model in $cf_list_models; do
+       case $model in
+       (libtool)
+               CF_WITH_LIBTOOL_OPTS
+               CF_WITH_EXPORT_SYMS
+               ;;
+       (shared)
+               if test "$CC_SHARED_OPTS" = "unknown"; then
                        AC_ERROR(Shared libraries are not supported in this version)
                fi
                        AC_ERROR(Shared libraries are not supported in this version)
                fi
-       done
+               # workaround for inept transition to PIE vs PIC...
+               AC_MSG_CHECKING(if current CFLAGS link properly)
+               AC_TRY_LINK(
+                       [#include <stdio.h>],
+                       [printf("Hello work\n");],
+                       [cf_cflags_work=yes],
+                       [cf_cflags_work=no])
+               AC_MSG_RESULT($cf_cflags_work)
+               if test "$cf_cflags_work" = no
+               then
+                       CF_VERBOSE(try to work around by appending shared-options)
+                       CFLAGS="$CFLAGS $CC_SHARED_OPTS"
+               fi
+               CF_WITH_VERSIONED_SYMS
+               ;;
+       esac
+done
+
+### Checks for special libraries, must be done up-front.
+SHLIB_LIST=""
+CF_WITH_GPM
+if test "$with_gpm" != no ; then
+       AC_MSG_CHECKING(if you want to load GPM dynamically)
+       AC_ARG_WITH(dlsym,
+               [  --without-dlsym         do not use dlsym() to load GPM dynamically],
+               [with_dlsym=$withval],
+               [with_dlsym=yes])
+       AC_MSG_RESULT($with_dlsym)
+       if test "x$with_dlsym" = xyes ; then
+               CF_FUNC_DLSYM
+               if test "x$with_gpm" != xyes ; then
+                       CF_VERBOSE(assuming soname for gpm is $with_gpm)
+                       cf_cv_gpm_soname="$with_gpm"
+               else
+                       CF_LIB_SONAME([#include <gpm.h>],[if (Gpm_Open(0,0)) Gpm_Close();],gpm)
+               fi
+               test "$cf_cv_gpm_soname" != "unknown" && AC_DEFINE_UNQUOTED(LIBGPM_SONAME,"$cf_cv_gpm_soname",[Define as needed to set the gpm share library soname])
+               SHLIB_LIST="-ldl $SHLIB_LIST"
+               CF_ADD_LIB(dl,PRIVATE_LIBS)
+       else
+               SHLIB_LIST="-lgpm $SHLIB_LIST"
+               CF_ADD_LIB(gpm,TEST_LIBS)
+               CF_ADD_LIB(gpm,PRIVATE_LIBS)
+       fi
+       AC_DEFINE(HAVE_LIBGPM,1,[Define to 1 if we have the gpm library])
+       CF_CHECK_GPM_WGETCH
+fi
+
+CF_WITH_PCRE2
+CF_WITH_SYSMOUSE
+
+# pretend that ncurses==ncursesw==ncursest
+AC_MSG_CHECKING(if you want to disable library suffixes)
+CF_ARG_DISABLE(lib-suffixes,
+       [  --disable-lib-suffixes  disable library suffixes],
+       [disable_lib_suffixes=yes],
+       [disable_lib_suffixes=no],
+       no)
+AC_MSG_RESULT($disable_lib_suffixes)
+
+### If we're building with rpath, try to link non-standard libs that way too.
+if test "$DFT_LWR_MODEL" = "shared" && test "x$cf_cv_enable_rpath" != xno; then
+       CF_DISABLE_RPATH_HACK
 fi
 
 ###############################################################################
 CF_HELP_MESSAGE(Fine-Tuning Your Configuration:)
 
 fi
 
 ###############################################################################
 CF_HELP_MESSAGE(Fine-Tuning Your Configuration:)
 
+###    use option --with-extra-suffix to append suffix to headers and libraries
+AC_MSG_CHECKING(if you wish to append extra suffix to header/library paths)
+EXTRA_SUFFIX=
+AC_ARG_WITH(extra-suffix,
+       [  --with-extra-suffix=X   append extra suffix to header/library paths],
+       [case x$withval in
+       (no)
+               ;;
+       (xyes|x)
+               EXTRA_SUFFIX=$cf_cv_abi_version
+               ;;
+       (*)
+               EXTRA_SUFFIX=$withval
+               ;;
+       esac
+       ])
+AC_MSG_RESULT($EXTRA_SUFFIX)
+AC_SUBST(EXTRA_SUFFIX)
+
 ###    use option --disable-overwrite to leave out the link to -lcurses
 AC_MSG_CHECKING(if you wish to install ncurses overwriting curses)
 AC_ARG_ENABLE(overwrite,
 ###    use option --disable-overwrite to leave out the link to -lcurses
 AC_MSG_CHECKING(if you wish to install ncurses overwriting curses)
 AC_ARG_ENABLE(overwrite,
-       [  --disable-overwrite     leave out the link to -lcurses],
-       [with_overwrite=$enableval
-        test "$with_overwrite" = no && \
-        test "x$includedir" = 'x${prefix}/include' && \
-               includedir='$(prefix)/include/ncurses'
-       ],
-       [with_overwrite=yes])
+       [  --disable-overwrite     put headers in subdir, omit link to -lcurses],
+       [with_overwrite=$enableval],
+       [if test "$prefix" = "/usr" ; then with_overwrite=yes; else with_overwrite=no; fi])
 AC_MSG_RESULT($with_overwrite)
 AC_MSG_RESULT($with_overwrite)
-AC_MSG_CHECKING(where we will install curses.h)
-AC_MSG_RESULT($includedir)
 
 AC_MSG_CHECKING(if external terminfo-database is used)
 AC_ARG_ENABLE(database,
 
 AC_MSG_CHECKING(if external terminfo-database is used)
 AC_ARG_ENABLE(database,
-       [  --disable-database      use only built-in data],
-       [with_database=$enableval],
-       [with_database=yes])
-AC_MSG_RESULT($with_database)
-test $with_database != no && AC_DEFINE(USE_DATABASE)
-
-AC_MSG_CHECKING(if you want to build with function extensions)
-AC_ARG_ENABLE(ext-funcs,
-       [  --disable-ext-funcs     disable function-extensions],
-       [with_ext_funcs=$enableval],
-       [with_ext_funcs=yes])
-AC_MSG_RESULT($with_ext_funcs)
-test "$with_ext_funcs" = yes && AC_DEFINE(NCURSES_EXT_FUNCS)
+       [  --disable-database      do not use terminfo, only fallbacks/termcap],
+       [use_database=$enableval],
+       [use_database=yes])
+AC_MSG_RESULT($use_database)
+
+case $host_os in
+(os2*)
+       TERMINFO_SRC='${top_srcdir}/misc/emx.src'
+       ;;
+(*)
+       TERMINFO_SRC='${top_srcdir}/misc/terminfo.src'
+       ;;
+esac
+AC_SUBST(TERMINFO_SRC)
+
+NCURSES_USE_DATABASE=0
+if test "$use_database" != no ; then
+       NCURSES_USE_DATABASE=1
+
+       AC_MSG_CHECKING(which terminfo source-file will be installed)
+       AC_ARG_WITH(database,
+               [  --with-database=XXX     specify terminfo source to install],
+               [TERMINFO_SRC=$withval])
+       AC_MSG_RESULT($TERMINFO_SRC)
+
+       AC_MSG_CHECKING(whether to use hashed database instead of directory/tree)
+       AC_ARG_WITH(hashed-db,
+               [  --with-hashed-db        specify hashed-database library],,
+               [with_hashed_db=no])
+       AC_MSG_RESULT($with_hashed_db)
+else
+       with_hashed_db=no
+fi
+AC_SUBST(NCURSES_USE_DATABASE)
 
 AC_MSG_CHECKING(for list of fallback descriptions)
 AC_ARG_WITH(fallbacks,
 
 AC_MSG_CHECKING(for list of fallback descriptions)
 AC_ARG_WITH(fallbacks,
@@ -380,8 +611,62 @@ AC_ARG_WITH(fallbacks,
        [with_fallback=$withval],
        [with_fallback=])
 AC_MSG_RESULT($with_fallback)
        [with_fallback=$withval],
        [with_fallback=])
 AC_MSG_RESULT($with_fallback)
-FALLBACK_LIST=`echo $with_fallback|sed -e 's/,/ /g'`
+
+case ".$with_fallback" in
+(.|.no)
+       FALLBACK_LIST=
+       ;;
+(.yes)
+       AC_MSG_WARN(expected a list of terminal descriptions)
+       ;;
+(*)
+       FALLBACK_LIST=`echo "$with_fallback" | sed -e 's/,/ /g'`
+       ;;
+esac
+
+USE_FALLBACKS=
+test -z "$FALLBACK_LIST" && USE_FALLBACKS="#"
 AC_SUBST(FALLBACK_LIST)
 AC_SUBST(FALLBACK_LIST)
+AC_SUBST(USE_FALLBACKS)
+
+AC_MSG_CHECKING(if you want modern xterm or antique)
+AC_ARG_WITH(xterm-new,
+       [  --without-xterm-new     specify if xterm terminfo should be old version],
+       [with_xterm_new=$withval],
+       [with_xterm_new=yes])
+case $with_xterm_new in
+(no) with_xterm_new=xterm-old;;
+(*)     with_xterm_new=xterm-new;;
+esac
+AC_MSG_RESULT($with_xterm_new)
+WHICH_XTERM=$with_xterm_new
+AC_SUBST(WHICH_XTERM)
+
+AC_MSG_CHECKING(if xterm backspace sends BS or DEL)
+AC_ARG_WITH(xterm-kbs,
+       [  --with-xterm-kbs=XXX    specify if xterm backspace sends BS or DEL],
+       [with_xterm_kbs=$withval],
+       [with_xterm_kbs=BS])
+case x$with_xterm_kbs in
+(xyes|xno|xBS|xbs|x8)
+       with_xterm_kbs=BS
+       ;;
+(xDEL|xdel|x127)
+       with_xterm_kbs=DEL
+       ;;
+(*)
+       with_xterm_kbs=$withval
+       ;;
+esac
+AC_MSG_RESULT($with_xterm_kbs)
+XTERM_KBS=$with_xterm_kbs
+AC_SUBST(XTERM_KBS)
+
+MAKE_TERMINFO=
+if test "$use_database" = no ; then
+       TERMINFO="${datadir}/terminfo"
+       MAKE_TERMINFO="#"
+else
 
 AC_MSG_CHECKING(for list of terminfo directories)
 CF_WITH_PATHLIST(terminfo-dirs,
 
 AC_MSG_CHECKING(for list of terminfo directories)
 CF_WITH_PATHLIST(terminfo-dirs,
@@ -390,14 +675,29 @@ CF_WITH_PATHLIST(terminfo-dirs,
        DATADIR/terminfo,
        ${datadir}/terminfo)
 AC_MSG_RESULT($TERMINFO_DIRS)
        DATADIR/terminfo,
        ${datadir}/terminfo)
 AC_MSG_RESULT($TERMINFO_DIRS)
-test -n "$TERMINFO_DIRS" && AC_DEFINE_UNQUOTED(TERMINFO_DIRS,"$TERMINFO_DIRS")
+test -n "$TERMINFO_DIRS" && AC_DEFINE_UNQUOTED(TERMINFO_DIRS,"$TERMINFO_DIRS",[Define as needed to predefine the TERMINFO_DIR searchlist])
+
+case "x$TERMINFO" in
+x???:*)
+       AC_MSG_WARN(ignoring non-directory/file TERMINFO value)
+       unset TERMINFO
+       ;;
+esac
+
+AC_MSG_CHECKING(for default terminfo directory)
+CF_WITH_PATH(default-terminfo-dir,
+       [  --with-default-terminfo-dir=DIR default terminfo directory],
+       TERMINFO,
+       DATADIR/terminfo,
+       ${datadir}/terminfo)
+AC_MSG_RESULT($TERMINFO)
+AC_DEFINE_UNQUOTED(TERMINFO,"$TERMINFO",[Define to set the default terminal database path])
 
 
-if test $with_database = no ; then
-       if test -z $with_fallback ; then
-               AC_ERROR(You have disabled the database w/o specifying fallbacks)
-       fi
 fi
 
 fi
 
+AC_SUBST(TERMINFO)
+AC_SUBST(MAKE_TERMINFO)
+
 ###    use option --disable-big-core to make tic run on small machines
 ###    We need 4Mb, check if we can allocate 50% more than that.
 AC_MSG_CHECKING(if big-core option selected)
 ###    use option --disable-big-core to make tic run on small machines
 ###    We need 4Mb, check if we can allocate 50% more than that.
 AC_MSG_CHECKING(if big-core option selected)
@@ -407,12 +707,32 @@ AC_ARG_ENABLE(big-core,
        [AC_TRY_RUN([
 #include <stdlib.h>
 #include <string.h>
        [AC_TRY_RUN([
 #include <stdlib.h>
 #include <string.h>
-int main() { exit(malloc(6000000L) == 0); }],
+int main() {
+       unsigned long n = 6000000L;
+       char *s = malloc(n);
+       if (s != 0)
+               s[0] = s[n-1] = 0;
+       ${cf_cv_main_return:-return}(s == 0);
+}],
        [with_big_core=yes],
        [with_big_core=no],
        [with_big_core=no])])
 AC_MSG_RESULT($with_big_core)
        [with_big_core=yes],
        [with_big_core=no],
        [with_big_core=no])])
 AC_MSG_RESULT($with_big_core)
-test "$with_big_core" = "yes" && AC_DEFINE(HAVE_BIG_CORE)
+test "x$with_big_core" = "xyes" && AC_DEFINE(HAVE_BIG_CORE,1,[Define to 1 if machine has ample memory for tic])
+
+### ISO C only guarantees 512-char strings, we have tables which load faster
+### when constructed using "big" strings.  More than the C compiler, the awk
+### program is a limit on most vendor UNIX systems.  Check that we can build.
+AC_MSG_CHECKING(if big-strings option selected)
+AC_ARG_ENABLE(big-strings,
+       [  --disable-big-strings   assume compiler has only standard-size strings],
+       [with_big_strings=$enableval],
+       [CF_AWK_BIG_PRINTF(12000,with_big_strings)])
+AC_MSG_RESULT($with_big_strings)
+
+USE_BIG_STRINGS=0
+test "x$with_big_strings" = "xyes" && USE_BIG_STRINGS=1
+AC_SUBST(USE_BIG_STRINGS)
 
 ###    use option --enable-termcap to compile in the termcap fallback support
 AC_MSG_CHECKING(if you want termcap-fallback support)
 
 ###    use option --enable-termcap to compile in the termcap fallback support
 AC_MSG_CHECKING(if you want termcap-fallback support)
@@ -422,28 +742,65 @@ AC_ARG_ENABLE(termcap,
        [with_termcap=no])
 AC_MSG_RESULT($with_termcap)
 
        [with_termcap=no])
 AC_MSG_RESULT($with_termcap)
 
-if test "$with_termcap" != "yes" ; then
-       AC_DEFINE(PURE_TERMINFO)
+NCURSES_USE_TERMCAP=0
+if test "x$with_termcap" != "xyes" ; then
+       if test "$use_database" = no ; then
+               if test -z "$with_fallback" ; then
+                       AC_ERROR(You have disabled the database w/o specifying fallbacks)
+               fi
+       fi
+       AC_DEFINE(PURE_TERMINFO,1,[Define to 1 if we should support only terminfo])
 else
 
 else
 
-###    use option --enable-getcap to use a hacked getcap for reading termcaps
-AC_MSG_CHECKING(if fast termcap-loader is needed)
-AC_ARG_ENABLE(getcap,
-       [  --enable-getcap         fast termcap load, no xrefs to terminfo],
-       [with_getcap=$enableval],
-       [with_getcap=no])
-AC_MSG_RESULT($with_getcap)
-test "$with_getcap" = "yes" && AC_DEFINE(USE_GETCAP)
+       if test "$with_ticlib" != no ; then
+               AC_ERROR(Options --with-ticlib and --enable-termcap cannot be combined)
+       fi
 
 
-AC_MSG_CHECKING(if translated termcaps will be cached in ~/.terminfo)
-AC_ARG_ENABLE(getcap-cache,
-       [  --enable-getcap-cache   cache translated termcaps in ~/.terminfo],
-       [with_getcap_cache=$enableval],
-       [with_getcap_cache=no])
-AC_MSG_RESULT($with_getcap_cache)
-test "$with_getcap_cache" = "yes" && AC_DEFINE(USE_GETCAP_CACHE)
+       NCURSES_USE_TERMCAP=1
+       AC_MSG_CHECKING(for list of termcap files)
+       CF_WITH_PATHLIST(termpath,
+               [  --with-termpath=XXX     specify list of termcap files],
+               TERMPATH,
+               /etc/termcap:/usr/share/misc/termcap)
+       AC_MSG_RESULT($TERMPATH)
+       test -n "$TERMPATH" && AC_DEFINE_UNQUOTED(TERMPATH,"$TERMPATH",[Define to set the termcap searchlist])
+
+       ###     use option --enable-getcap to use a hacked getcap for reading termcaps
+       AC_MSG_CHECKING(if fast termcap-loader is needed)
+       AC_ARG_ENABLE(getcap,
+               [  --enable-getcap         fast termcap load, no xrefs to terminfo],
+               [with_getcap=$enableval],
+               [with_getcap=no])
+       AC_MSG_RESULT($with_getcap)
+       test "x$with_getcap" = "xyes" && AC_DEFINE(USE_GETCAP,1,[Define to 1 to use fast termcap-loader])
+
+       AC_MSG_CHECKING(if translated termcaps will be cached in ~/.terminfo)
+       AC_ARG_ENABLE(getcap-cache,
+               [  --enable-getcap-cache   cache translated termcaps in ~/.terminfo],
+               [with_getcap_cache=$enableval],
+               [with_getcap_cache=no])
+       AC_MSG_RESULT($with_getcap_cache)
+       test "x$with_getcap_cache" = "xyes" && AC_DEFINE(USE_GETCAP_CACHE,1,[Define to 1 if translated termcap should be stored in $HOME/.terminfo])
 
 fi
 
 fi
+AC_SUBST(NCURSES_USE_TERMCAP)
+
+###   Use option --disable-home-terminfo to completely remove ~/.terminfo
+AC_MSG_CHECKING(if ~/.terminfo is wanted)
+AC_ARG_ENABLE(home-terminfo,
+       [  --disable-home-terminfo drop ~/.terminfo from terminfo search-path],
+       [with_home_terminfo=$enableval],
+       [with_home_terminfo=yes])
+AC_MSG_RESULT($with_home_terminfo)
+test "x$with_home_terminfo" = "xyes" && AC_DEFINE(USE_HOME_TERMINFO,1,[Define to 1 if $HOME/.terminfo feature is wanted])
+
+AC_MSG_CHECKING(if you want to use restricted environment when running as root)
+AC_ARG_ENABLE(root-environ,
+       [  --disable-root-environ  restrict environment when running as root],
+       [with_root_environ=$enableval],
+       [with_root_environ=yes])
+AC_MSG_RESULT($with_root_environ)
+test "x$with_root_environ" = xyes && AC_DEFINE(USE_ROOT_ENVIRON,1,[Define to 1 if environment should be restricted for root user])
 
 ###   Use option --enable-symlinks to make tic use symlinks, not hard links
 ###   to reduce storage requirements for the terminfo database.
 
 ###   Use option --enable-symlinks to make tic use symlinks, not hard links
 ###   to reduce storage requirements for the terminfo database.
@@ -452,33 +809,54 @@ CF_LINK_FUNCS
 with_links=no
 with_symlinks=no
 
 with_links=no
 with_symlinks=no
 
-if test "$ac_cv_func_link" != yes ; then
-    AC_MSG_CHECKING(if tic should use symbolic links)
-    if test "$ac_cv_func_symlink" = yes ; then
-       with_symlinks=yes
-    else
-       with_symlinks=no
-    fi
-    AC_MSG_RESULT($with_symlinks)
-elif test "$ac_cv_func_symlink" != yes ; then
-    AC_MSG_CHECKING(if tic should use hard links)
-    if test "$ac_cv_func_link" = yes ; then
-       with_links=yes
-    else
-       with_links=no
-    fi
-    AC_MSG_RESULT($with_links)
-else
-    AC_MSG_CHECKING(if tic should use symbolic links)
-    AC_ARG_ENABLE(symlinks,
+# soft links (symbolic links) are useful for some systems where hard links do
+# not work, or to make it simpler to copy terminfo trees around.
+if test "x$ac_cv_func_symlink" = xyes ; then
+       AC_MSG_CHECKING(if tic should use symbolic links)
+       AC_ARG_ENABLE(symlinks,
        [  --enable-symlinks       make tic use symbolic links not hard links],
        [with_symlinks=$enableval],
        [with_symlinks=no])
        [  --enable-symlinks       make tic use symbolic links not hard links],
        [with_symlinks=$enableval],
        [with_symlinks=no])
-    AC_MSG_RESULT($with_symlinks)
+       AC_MSG_RESULT($with_symlinks)
 fi
 
 fi
 
-test "$with_links" = yes && AC_DEFINE(USE_LINKS)
-test "$with_symlinks" = yes && AC_DEFINE(USE_SYMLINKS)
+# If we have hard links and did not choose to use soft links instead, there is
+# no reason to make this choice optional - use the hard links.
+if test "$with_symlinks" = no ; then
+       AC_MSG_CHECKING(if tic should use hard links)
+       if test "x$ac_cv_func_link" = xyes ; then
+               with_links=yes
+       else
+               with_links=no
+       fi
+       AC_MSG_RESULT($with_links)
+fi
+
+test "x$with_links" = xyes && AC_DEFINE(USE_LINKS,1,[Define to 1 if hardlinks should be used in terminfo database])
+test "x$with_symlinks" = xyes && AC_DEFINE(USE_SYMLINKS,1,[Define to 1 if symbolic links should be used in terminfo database])
+
+###   use option --enable-broken-linker to force on use of broken-linker support
+AC_MSG_CHECKING(if you want broken-linker support code)
+AC_ARG_ENABLE(broken_linker,
+       [  --enable-broken_linker  compile with broken-linker support code],
+       [with_broken_linker=$enableval],
+       [with_broken_linker=${BROKEN_LINKER:-no}])
+AC_MSG_RESULT($with_broken_linker)
+
+BROKEN_LINKER=0
+if test "x$with_broken_linker" = xyes ; then
+       AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules])
+       BROKEN_LINKER=1
+elif test "$DFT_LWR_MODEL" = shared ; then
+       case $cf_cv_system_name in
+       (cygwin*)
+               AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules])
+               BROKEN_LINKER=1
+               CF_VERBOSE(cygwin linker is broken anyway)
+               ;;
+       esac
+fi
+AC_SUBST(BROKEN_LINKER)
 
 ###   use option --enable-bsdpad to have tputs process BSD-style prefix padding
 AC_MSG_CHECKING(if tputs should process BSD-style prefix padding)
 
 ###   use option --enable-bsdpad to have tputs process BSD-style prefix padding
 AC_MSG_CHECKING(if tputs should process BSD-style prefix padding)
@@ -487,74 +865,599 @@ AC_ARG_ENABLE(bsdpad,
        [with_bsdpad=$enableval],
        [with_bsdpad=no])
 AC_MSG_RESULT($with_bsdpad)
        [with_bsdpad=$enableval],
        [with_bsdpad=no])
 AC_MSG_RESULT($with_bsdpad)
-test "$with_bsdpad" = yes && AC_DEFINE(BSD_TPUTS)
+test "x$with_bsdpad" = xyes && AC_DEFINE(BSD_TPUTS,1,[Define to 1 to recognize BSD-style prefix padding])
+
+###   use option --enable-widec to turn on use of wide-character support
+NCURSES_CH_T=chtype
+NCURSES_LIBUTF8=0
+
+NEED_WCHAR_H=0
+NCURSES_MBSTATE_T=0
+NCURSES_WCHAR_T=0
+NCURSES_WINT_T=0
+
+# Check to define _XOPEN_SOURCE "automatically"
+CPPFLAGS_before_XOPEN="$CPPFLAGS"
+CF_XOPEN_SOURCE(600)
+CPPFLAGS_after_XOPEN="$CPPFLAGS"
+
+# Work around breakage on OS X
+CF_SIGWINCH
+
+# Checks for CODESET support.
+AM_LANGINFO_CODESET
+
+# use these variables to work around a defect in gcc's fixincludes.
+NCURSES_OK_WCHAR_T=
+NCURSES_OK_WINT_T=
+
+AC_MSG_CHECKING(if you want wide-character code)
+AC_ARG_ENABLE(widec,
+       [  --enable-widec          compile with wide-char/UTF-8 code],
+       [with_widec=$enableval],
+       [with_widec=no])
+AC_MSG_RESULT($with_widec)
+
+NCURSES_WCWIDTH_GRAPHICS=1
+AC_SUBST(NCURSES_WCWIDTH_GRAPHICS)
+
+if test "x$with_widec" = xyes ; then
+       if test "x$disable_lib_suffixes" = xno ; then
+               LIB_SUFFIX="w${LIB_SUFFIX}"
+       fi
+       AC_DEFINE(USE_WIDEC_SUPPORT,1,[Define to 1 to compile with wide-char/UTF-8 code])
+       AC_DEFINE(NCURSES_WIDECHAR,1,[Define to 1 to compile with wide-char/UTF-8 code])
+
+       CF_CHECK_WCHAR_H
+       CF_CHECK_WCWIDTH_GRAPHICS
+       test "$cf_cv_wcwidth_graphics" = no && NCURSES_WCWIDTH_GRAPHICS=0
+
+       # with_overwrite=no
+       NCURSES_CH_T=cchar_t
+       AC_CHECK_FUNCS(putwc btowc wctob mbtowc wctomb mblen mbrlen mbrtowc wcsrtombs mbsrtowcs wcstombs mbstowcs)
+       if test "x$ac_cv_func_putwc" != xyes ; then
+               CF_UTF8_LIB
+               if test "$cf_cv_utf8_lib" != no ; then
+                       NCURSES_LIBUTF8=1
+               fi
+       fi
+       CF_WCHAR_TYPE(mbstate_t, NCURSES_MBSTATE_T)
+       CF_WCHAR_TYPE(wchar_t,   NCURSES_WCHAR_T,   NCURSES_OK_WCHAR_T)
+       CF_WCHAR_TYPE(wint_t,    NCURSES_WINT_T,    NCURSES_OK_WINT_T)
+
+       if test "$NCURSES_MBSTATE_T" != 0; then
+               AC_DEFINE(NEED_MBSTATE_T_DEF,1,[Define to 1 if we must declare mbstate_t])
+       fi
+fi
+AC_SUBST(NCURSES_CH_T)
+AC_SUBST(NCURSES_LIBUTF8)
+
+AC_SUBST(NEED_WCHAR_H)
+AC_SUBST(NCURSES_MBSTATE_T)
+AC_SUBST(NCURSES_WCHAR_T)
+AC_SUBST(NCURSES_WINT_T)
+
+AC_SUBST(NCURSES_OK_WCHAR_T)
+AC_SUBST(NCURSES_OK_WINT_T)
+
+###   use option --disable-lp64 to allow long chtype
+AC_MSG_CHECKING(whether to enable _LP64 definition in curses.h)
+AC_ARG_ENABLE(lp64,
+       [  --disable-lp64          allow chtype to be long (ignore _LP64)],
+       [with_lp64=$enableval],
+       [with_lp64=$cf_dft_with_lp64])
+AC_MSG_RESULT($with_lp64)
+
+if test "x$with_lp64" = xyes ; then
+       cf_cv_enable_lp64=1
+else
+       cf_cv_enable_lp64=0
+fi
+AC_SUBST(cf_cv_enable_lp64)
+
+CF_LARGEFILE
+
+###   use option --disable-tparm-varargs to make tparm() conform to X/Open
+AC_MSG_CHECKING(if you want tparm not to use X/Open fixed-parameter list)
+AC_ARG_ENABLE(tparm-varargs,
+       [  --disable-tparm-varargs compile tparm() without varargs interface],
+       [with_tparm_varargs=$enableval],
+       [with_tparm_varargs=yes])
+AC_MSG_RESULT($with_tparm_varargs)
+NCURSES_TPARM_VARARGS=0
+test "x$with_tparm_varargs" = xyes && NCURSES_TPARM_VARARGS=1
+AC_SUBST(NCURSES_TPARM_VARARGS)
+
+###   use option --disable-tic-depends to make libtic not explicitly depend on ncurses/ncursesw
+if test "$with_ticlib" != no ; then
+AC_MSG_CHECKING(if you want tic library to use explicit dependency on ncurses$LIB_SUFFIX library)
+AC_ARG_ENABLE(tic-depends,
+       [  --disable-tic-depends   link tic library without explicit dependency on ncurses library],
+       [with_tic_depends=$enableval],
+       [with_tic_depends=yes])
+AC_MSG_RESULT($with_tic_depends)
+else
+       with_tic_depends=no
+fi
+
+###   use option --disable-wattr-macros to suppress wattr* macros from curses.h
+AC_MSG_CHECKING(if you want to suppress wattr* macros to help with ncurses5/ncurses6 transition)
+AC_ARG_ENABLE(wattr-macros,
+       [  --disable-wattr-macros  suppress wattr* macros to help with ncurses5/ncurses6 transition],
+       [with_wattr_macros=$enableval],
+       [with_wattr_macros=yes])
+if [[ "x$with_wattr_macros" != xyes ]]; then
+       NCURSES_WATTR_MACROS=0
+       AC_MSG_RESULT(yes)
+else
+       NCURSES_WATTR_MACROS=1
+       AC_MSG_RESULT(no)
+fi
+AC_SUBST(NCURSES_WATTR_MACROS)
+
+CF_WITH_X11_RGB
+
+###   use option --with-bool to override bool's type
+AC_MSG_CHECKING(for type of bool)
+AC_ARG_WITH(bool,
+       [  --with-bool=TYPE        override fallback type of bool variable],
+       [NCURSES_BOOL="$withval"],
+       [NCURSES_BOOL=auto])
+AC_MSG_RESULT($NCURSES_BOOL)
+AC_SUBST(NCURSES_BOOL)
+
+AC_MSG_CHECKING(for alternate terminal capabilities file)
+AC_ARG_WITH(caps,
+       [  --with-caps=alt         compile with alternate Caps file],
+       [TERMINFO_CAPS=Caps.$withval],
+       [TERMINFO_CAPS=Caps])
+test -f "${srcdir}/include/${TERMINFO_CAPS}" || TERMINFO_CAPS=Caps
+AC_MSG_RESULT($TERMINFO_CAPS)
+AC_SUBST(TERMINFO_CAPS)
+
+###   use option --with-chtype to override chtype's type
+AC_MSG_CHECKING(for type of chtype)
+AC_ARG_WITH(chtype,
+       [  --with-chtype=TYPE      override type of chtype],
+       [NCURSES_CHTYPE="$withval"],
+       [NCURSES_CHTYPE=$cf_dft_chtype])
+AC_MSG_RESULT($NCURSES_CHTYPE)
+
+###   use option --with-ospeed to override ospeed's type
+AC_MSG_CHECKING(for type of ospeed)
+AC_ARG_WITH(ospeed,
+       [  --with-ospeed=TYPE      override type of ospeed variable],
+       [NCURSES_OSPEED="$withval"],
+       [NCURSES_OSPEED=short])
+AC_MSG_RESULT($NCURSES_OSPEED)
+AC_SUBST(NCURSES_OSPEED)
+
+###   use option --with-mmask-t to override mmask_t's type
+AC_MSG_CHECKING(for type of mmask_t)
+AC_ARG_WITH(mmask-t,
+       [  --with-mmask-t=TYPE     override type of mmask_t],
+       [NCURSES_MMASK_T="$withval"],
+       [NCURSES_MMASK_T=$cf_dft_mmask_t])
+AC_MSG_RESULT($NCURSES_MMASK_T)
+
+###   use option --with-ccharw-max to override CCHARW_MAX size
+AC_MSG_CHECKING(for size CCHARW_MAX)
+AC_ARG_WITH(ccharw-max,
+       [  --with-ccharw-max=XXX   override size CCHARW_MAX],
+       [NCURSES_CCHARW_MAX="$withval"],
+       [NCURSES_CCHARW_MAX=5])
+AC_MSG_RESULT($NCURSES_CCHARW_MAX)
+AC_SUBST(NCURSES_CCHARW_MAX)
+
+AC_CHECK_SIZEOF([signed char], 0)
+if test "$ac_cv_sizeof_signed_char" = 1 ; then
+       NCURSES_SBOOL="signed char"
+else
+       NCURSES_SBOOL="char"
+fi
+AC_MSG_CHECKING(if you want to use signed Boolean array in term.h)
+AC_ARG_ENABLE(signed-char,
+       [  --enable-signed-char    compile using signed Boolean's in term.h],
+       [with_signed_char=$enableval],
+       [with_signed_char=no])
+AC_MSG_RESULT($with_signed_char)
+test "x$with_signed_char" != xyes && NCURSES_SBOOL="char"
+AC_SUBST(NCURSES_SBOOL)
+
+###   use option --with-tparm-arg to override tparm's argument type
+AC_MSG_CHECKING(for type of tparm args)
+AC_ARG_WITH(tparm-arg,
+       [  --with-tparm-arg=TYPE   override parameter type of tparm],
+       [NCURSES_TPARM_ARG="$withval"],
+       [NCURSES_TPARM_ARG=$cf_dft_tparm_arg])
+AC_MSG_RESULT($NCURSES_TPARM_ARG)
+AC_SUBST(NCURSES_TPARM_ARG)
+
+### Enable compiling-in rcs id's
+AC_MSG_CHECKING(if RCS identifiers should be compiled-in)
+AC_ARG_WITH(rcs-ids,
+       [  --with-rcs-ids          compile-in RCS identifiers],
+       [with_rcs_ids=$withval],
+       [with_rcs_ids=no])
+AC_MSG_RESULT($with_rcs_ids)
+test "x$with_rcs_ids" = xyes && AC_DEFINE(USE_RCS_IDS,1,[Define to 1 to compile-in RCS identifiers])
+
+###############################################################################
+CF_MAN_PAGES([ captoinfo clear infocmp infotocap reset tabs tic toe tput tset ])
+
+###############################################################################
+CF_HELP_MESSAGE(Extensions:)
+
+### Note that some functions (such as const) are normally disabled anyway.
+AC_MSG_CHECKING(if you want to build with function extensions)
+AC_ARG_ENABLE(ext-funcs,
+       [  --disable-ext-funcs     disable function-extensions],
+       [with_ext_funcs=$enableval],
+       [with_ext_funcs=yes])
+AC_MSG_RESULT($with_ext_funcs)
+if test "x$with_ext_funcs" = xyes ; then
+       NCURSES_EXT_FUNCS=1
+       AC_DEFINE(NCURSES_EXT_FUNCS,1,[Define to 1 to enable ncurses extended functions])
+       AC_DEFINE(HAVE_ASSUME_DEFAULT_COLORS,1,[Define to 1 to enable assume_default_colors() function in test-programs])
+       AC_DEFINE(HAVE_CURSES_VERSION,1,[Define to 1 to enable curses_version() function in test-programs])
+       AC_DEFINE(HAVE_HAS_KEY,1,[Define to 1 to enable has_key() function in test-programs])
+       AC_DEFINE(HAVE_RESIZETERM,1,[Define to 1 to enable resizeterm() function in test-programs])
+       AC_DEFINE(HAVE_RESIZE_TERM,1,[Define to 1 to enable resize_term() function in test-programs])
+       AC_DEFINE(HAVE_TERM_ENTRY_H,1,[Define to 1 to enable term_entry() function in test-programs])
+       AC_DEFINE(HAVE_USE_DEFAULT_COLORS,1,[Define to 1 to enable use_default_colors() function in test-programs])
+       AC_DEFINE(HAVE_USE_EXTENDED_NAMES,1,[Define to 1 to enable use_extended_names() function in test-programs])
+       AC_DEFINE(HAVE_USE_SCREEN,1,[Define to 1 to enable use_screen() function in test-programs])
+       AC_DEFINE(HAVE_USE_WINDOW,1,[Define to 1 to enable use_window() function in test-programs])
+       AC_DEFINE(HAVE_WRESIZE,1,[Define to 1 to enable wresize() function in test-programs])
+       GENERATED_EXT_FUNCS=generated
+       test "x$with_ext_funcs" = xyes || cf_dft_ext_spfuncs=no
+else
+       NCURSES_EXT_FUNCS=0
+       GENERATED_EXT_FUNCS=
+fi
+AC_SUBST(NCURSES_EXT_FUNCS)
+AC_SUBST(GENERATED_EXT_FUNCS)
+
+AC_MSG_CHECKING(if you want to build with SCREEN extensions)
+AC_ARG_ENABLE(sp-funcs,
+       [  --enable-sp-funcs       enable SCREEN-extensions],
+       [with_sp_funcs=$enableval],
+       [with_sp_funcs=$cf_dft_ext_spfuncs])
+AC_MSG_RESULT($with_sp_funcs)
+if test "x$with_sp_funcs" = xyes ; then
+       NCURSES_SP_FUNCS=1
+       AC_DEFINE(NCURSES_SP_FUNCS,1,[Define to 1 to enable SCREEN-extensions])
+       AC_DEFINE(HAVE_TPUTS_SP,1,[Define to 1 to enable tputs_sp() function in test-programs])
+       GENERATED_SP_FUNCS=generated
+else
+       NCURSES_SP_FUNCS=0
+       GENERATED_SP_FUNCS=
+fi
+AC_SUBST(NCURSES_SP_FUNCS)
+AC_SUBST(GENERATED_SP_FUNCS)
+
+AC_MSG_CHECKING(if you want to build with terminal-driver)
+AC_ARG_ENABLE(term-driver,
+       [  --enable-term-driver    enable terminal-driver],
+       [with_term_driver=$enableval],
+       [with_term_driver=no])
+AC_MSG_RESULT($with_term_driver)
+if test "x$with_term_driver" = xyes ; then
+       AC_DEFINE(USE_TERM_DRIVER,1,[Define to 1 to enable terminal-driver])
+       if test "x$with_termlib" != xno ; then
+               AC_MSG_ERROR(The term-driver option conflicts with the termlib option)
+       fi
+       if test "x$with_sp_funcs" != xyes ; then
+               AC_MSG_ERROR(The term-driver option relies upon sp-funcs)
+       fi
+fi
 
 ###   use option --enable-const to turn on use of const beyond that in XSI.
 AC_MSG_CHECKING(for extended use of const keyword)
 AC_ARG_ENABLE(const,
        [  --enable-const          compile with extra/non-standard const],
        [with_ext_const=$enableval],
 
 ###   use option --enable-const to turn on use of const beyond that in XSI.
 AC_MSG_CHECKING(for extended use of const keyword)
 AC_ARG_ENABLE(const,
        [  --enable-const          compile with extra/non-standard const],
        [with_ext_const=$enableval],
-       [with_ext_const=no])
+       [with_ext_const=$cf_dft_ext_const])
 AC_MSG_RESULT($with_ext_const)
 AC_MSG_RESULT($with_ext_const)
-NCURSES_CONST=""
-if test "$with_ext_const" = yes ; then
-       AC_DEFINE(NCURSES_CONST,const)
+NCURSES_CONST='/*nothing*/'
+if test "x$with_ext_const" = xyes ; then
        NCURSES_CONST=const
 fi
 AC_SUBST(NCURSES_CONST)
 
        NCURSES_CONST=const
 fi
 AC_SUBST(NCURSES_CONST)
 
-### Enable compiling-in rcs id's
-AC_MSG_CHECKING(if RCS identifiers should be compiled-in)
-AC_ARG_WITH(rcs-ids,
-       [  --with-rcs-ids          compile-in RCS identifiers],
-       [with_rcs_ids=$withval],
-       [with_rcs_ids=no])
-AC_MSG_RESULT($with_rcs_ids)
-test "$with_rcs_ids" = yes && AC_DEFINE(USE_RCS_IDS)
+###   use option --enable-ext-colors to turn on use of colors beyond 16.
+AC_MSG_CHECKING(if you want to use extended colors)
+AC_ARG_ENABLE(ext-colors,
+       [  --enable-ext-colors     compile for 256-color support],
+       [with_ext_colors=$enableval],
+       [with_ext_colors=$cf_dft_ext_colors])
+AC_MSG_RESULT($with_ext_colors)
+NCURSES_EXT_COLORS=0
+if test "x$with_ext_colors" = xyes ; then
+       if test "x$with_widec" != xyes ; then
+               AC_MSG_WARN(This option applies only to wide-character library)
+       else
+               # cannot be ABI 5 since it changes sizeof(cchar_t)
+               CF_NCURSES_ABI_6
+               NCURSES_EXT_COLORS=1
+               AC_DEFINE(NCURSES_EXT_COLORS,1,[Define to 1 to compile for 256-color support])
+               AC_DEFINE(HAVE_ALLOC_PAIR,1,[Define to 1 to enable alloc_pair() function])
+               AC_DEFINE(HAVE_INIT_EXTENDED_COLOR,1,[Define to 1 to enable init_extended_color() function in test-programs])
+               AC_DEFINE(HAVE_RESET_COLOR_PAIRS,1,[Define to 1 to enable reset_color_pairs() function in test-programs])
+       fi
+fi
+AC_SUBST(NCURSES_EXT_COLORS)
+
+###   use option --enable-ext-mouse to modify coding to support 5-button mice
+AC_MSG_CHECKING(if you want to use extended mouse encoding)
+AC_ARG_ENABLE(ext-mouse,
+       [  --enable-ext-mouse      compile for extended mouse-encoding],
+       [with_ext_mouse=$enableval],
+       [with_ext_mouse=$cf_dft_ext_mouse])
+AC_MSG_RESULT($with_ext_mouse)
+NCURSES_MOUSE_VERSION=1
+if test "x$with_ext_mouse" = xyes ; then
+       NCURSES_MOUSE_VERSION=2
+       CF_NCURSES_ABI_6
+fi
+AC_SUBST(NCURSES_MOUSE_VERSION)
+
+###   use option --enable-ext-putwin to turn on extended screendumps
+AC_MSG_CHECKING(if you want to use extended putwin/screendump)
+AC_ARG_ENABLE(ext-putwin,
+       [  --enable-ext-putwin     compile with extended putwin/screendump],
+       [with_ext_putwin=$enableval],
+       [with_ext_putwin=$cf_dft_ext_putwin])
+AC_MSG_RESULT($with_ext_putwin)
+if test "x$with_ext_putwin" = xyes ; then
+       AC_DEFINE(NCURSES_EXT_PUTWIN,1,[Define to 1 to compile with extended putwin/screendump])
+fi
+
+AC_MSG_CHECKING(if you want \$NCURSES_NO_PADDING code)
+AC_ARG_ENABLE(no-padding,
+       [  --enable-no-padding     compile with $NCURSES_NO_PADDING code],
+       [with_no_padding=$enableval],
+       [with_no_padding=$with_ext_funcs])
+AC_MSG_RESULT($with_no_padding)
+test "x$with_no_padding" = xyes && AC_DEFINE(NCURSES_NO_PADDING,1,[Define to 1 to compile with $NCURSES_NO_PADDING code])
+
+###   use option --enable-sigwinch to turn on use of SIGWINCH logic
+AC_MSG_CHECKING(if you want SIGWINCH handler)
+AC_ARG_ENABLE(sigwinch,
+       [  --enable-sigwinch       compile with SIGWINCH handler],
+       [with_sigwinch=$enableval],
+       [with_sigwinch=$with_ext_funcs])
+AC_MSG_RESULT($with_sigwinch)
+test "x$with_sigwinch" = xyes && AC_DEFINE(USE_SIGWINCH,1,[Define to 1 to compile with SIGWINCH handler])
+
+###   use option --enable-tcap-names to allow user to define new capabilities
+AC_MSG_CHECKING(if you want user-definable terminal capabilities like termcap)
+AC_ARG_ENABLE(tcap-names,
+       [  --enable-tcap-names     compile with user-definable terminal capabilities],
+       [with_tcap_names=$enableval],
+       [with_tcap_names=$with_ext_funcs])
+AC_MSG_RESULT($with_tcap_names)
+NCURSES_XNAMES=0
+test "x$with_tcap_names" = xyes && NCURSES_XNAMES=1
+AC_SUBST(NCURSES_XNAMES)
+
+##############################################################################
+CF_HELP_MESSAGE(Reentrant Code:)
+CF_WITH_PTHREAD
+
+if test "x$with_pthread" != xno; then
+       AC_CHECK_FUNC(pthread_kill,[
+               AC_MSG_CHECKING(if you want to allow EINTR in wgetch with pthreads)
+               AC_ARG_ENABLE(pthreads-eintr,
+                       [  --enable-pthreads-eintr enable EINTR in wgetch with pthreads],
+                       [use_pthreads_eintr=$enableval],
+                       [use_pthreads_eintr=no])
+               AC_MSG_RESULT($use_pthreads_eintr)
+               if test "x$use_pthreads_eintr" = xyes ; then
+                       AC_DEFINE(USE_PTHREADS_EINTR,1,[Define to 1 to enable EINTR in wgetch with pthreads])
+               fi])
+
+       AC_MSG_CHECKING(if you want to use weak-symbols for pthreads)
+       AC_ARG_ENABLE(weak-symbols,
+               [  --enable-weak-symbols   enable weak-symbols for pthreads],
+               [use_weak_symbols=$enableval],
+               [use_weak_symbols=no])
+       AC_MSG_RESULT($use_weak_symbols)
+       if test "x$use_weak_symbols" = xyes ; then
+               CF_WEAK_SYMBOLS
+       else
+               cf_cv_weak_symbols=no
+       fi
+
+       if test "x$cf_cv_weak_symbols" = xyes ; then
+               AC_DEFINE(USE_WEAK_SYMBOLS,1,[Define to 1 to enable weak-symbols for pthreads])
+       fi
+fi
+
+PTHREAD=
+if test "x$with_pthread" = "xyes" ; then
+       AC_DEFINE(USE_PTHREADS,1,[Define to 1 to use pthreads feature])
+       enable_reentrant=yes
+       if test "x$cf_cv_weak_symbols" = xyes ; then
+               PTHREAD=-lpthread
+               CF_ADD_LIB(pthread,PRIVATE_LIBS)
+       fi
+fi
+AC_SUBST(PTHREAD)
+
+# Reentrant code has to be opaque; there's little advantage to making ncurses
+# opaque outside of that, so there is no --enable-opaque option.  We can use
+# this option without --with-pthreads, but this will be always set for
+# pthreads.
+AC_MSG_CHECKING(if you want reentrant code)
+AC_ARG_ENABLE(reentrant,
+       [  --enable-reentrant      compile with reentrant code],
+       [with_reentrant=$enableval],
+       [with_reentrant=no])
+AC_MSG_RESULT($with_reentrant)
+if test "x$with_reentrant" = xyes ; then
+       cf_cv_enable_reentrant=1
+       cf_cv_enable_opaque="NCURSES_INTERNALS"
+       NCURSES_SIZE_T=int
+       if test "x$cf_cv_weak_symbols" = xyes ; then
+               CF_REMOVE_LIB(LIBS,$LIBS,pthread)
+               CF_ADD_LIB(pthread,TEST_LIBS)
+               CF_ADD_LIB(pthread,TEST_LIBS2)
+               CF_ADD_LIB(pthread,PRIVATE_LIBS)
+       else
+               # when not using weak symbols but with_reentrant,
+               # add 't' to the library suffix on all platforms
+               # except cygwin, where we only do that if ALSO
+               # compiling with full thread support.
+               case "$host" in
+               (*cygwin* | *msys*)
+                       if test "$with_pthread" = "yes" ; then
+                               if test "x$disable_lib_suffixes" = "xno" ; then
+                                       LIB_SUFFIX="t${LIB_SUFFIX}"
+                               fi
+                       fi ;;
+               (*)
+                       if test "x$disable_lib_suffixes" = "xno" ; then
+                               LIB_SUFFIX="t${LIB_SUFFIX}"
+                       fi
+                       ;;
+               esac
+       fi
+       AC_DEFINE(USE_REENTRANT,1,[Define to 1 to use reentrant feature])
+       CF_NCURSES_ABI_6
+else
+       cf_cv_enable_reentrant=0
+       cf_cv_enable_opaque="NCURSES_OPAQUE"
+       NCURSES_SIZE_T=short
+fi
+AC_SUBST(cf_cv_enable_reentrant)
+AC_SUBST(cf_cv_enable_opaque)
+
+AC_SUBST(NCURSES_SIZE_T)
+
+AC_MSG_CHECKING(if you want opaque curses-library structures)
+CF_ARG_ENABLE(opaque-curses,
+       [  --enable-opaque-curses  make curses WINDOW, etc., "opaque"],
+       [enable_opaque_curses=yes],[
+        test "$cf_cv_enable_reentrant" = 1 && enable_opaque_curses=yes
+        test "$cf_cv_enable_reentrant" = 1 || enable_opaque_curses=no
+       ])
+AC_MSG_RESULT($enable_opaque_curses)
+
+test "$cf_cv_enable_reentrant" = 1 && \
+test "$enable_opaque_curses" = no && \
+AC_MSG_ERROR(reentrant configuration requires opaque library)
+
+AC_MSG_CHECKING(if you want opaque form-library structures)
+AC_ARG_ENABLE(opaque-form,
+       [  --enable-opaque-form    make form-library structures "opaque"],
+       [enable_opaque_form=yes],[enable_opaque_form=no])
+AC_MSG_RESULT($enable_opaque_form)
+
+AC_MSG_CHECKING(if you want opaque menu-library structures)
+AC_ARG_ENABLE(opaque-menu,
+       [  --enable-opaque-menu    make menu-library structures "opaque"],
+       [enable_opaque_menu=yes],[enable_opaque_menu=no])
+AC_MSG_RESULT($enable_opaque_menu)
+
+AC_MSG_CHECKING(if you want opaque panel-library structures)
+AC_ARG_ENABLE(opaque-panel,
+       [  --enable-opaque-panel   make panel-library structures "opaque"],
+       [enable_opaque_panel=yes],[enable_opaque_panel=no])
+AC_MSG_RESULT($enable_opaque_panel)
+
+NCURSES_OPAQUE=0;              test "$enable_opaque_curses" = yes && NCURSES_OPAQUE=1
+NCURSES_OPAQUE_FORM=0; test "$enable_opaque_form"   = yes && NCURSES_OPAQUE_FORM=1
+NCURSES_OPAQUE_MENU=0; test "$enable_opaque_menu"   = yes && NCURSES_OPAQUE_MENU=1
+NCURSES_OPAQUE_PANEL=0;        test "$enable_opaque_panel"  = yes && NCURSES_OPAQUE_PANEL=1
+
+AC_SUBST(NCURSES_OPAQUE)
+AC_SUBST(NCURSES_OPAQUE_FORM)
+AC_SUBST(NCURSES_OPAQUE_MENU)
+AC_SUBST(NCURSES_OPAQUE_PANEL)
+
+### Allow using a different wrap-prefix
+if test "$cf_cv_enable_reentrant" != 0 || test "$BROKEN_LINKER" = 1 ; then
+       AC_MSG_CHECKING(for prefix used to wrap public variables)
+       AC_ARG_WITH(wrap-prefix,
+               [  --with-wrap-prefix=XXX  override prefix used for public variables],
+               [NCURSES_WRAP_PREFIX=$withval],
+               [NCURSES_WRAP_PREFIX=_nc_])
+       AC_MSG_RESULT($NCURSES_WRAP_PREFIX)
+else
+       NCURSES_WRAP_PREFIX=_nc_
+fi
+AC_SUBST(NCURSES_WRAP_PREFIX)
+AC_DEFINE_UNQUOTED(NCURSES_WRAP_PREFIX,"$NCURSES_WRAP_PREFIX",[Define to override _nc_ prefix])
 
 ###############################################################################
 
 ###############################################################################
-CF_HELP_MESSAGE(Experimental Code:)
-AC_MSG_CHECKING(if you want all experimental code)
+# These options are relatively safe to experiment with.
+CF_HELP_MESSAGE(Development Code:)
+AC_MSG_CHECKING(if you want all development code)
 AC_ARG_WITH(develop,
 AC_ARG_WITH(develop,
-       [  --with-develop          enable all experimental options for testing],
+       [  --without-develop       disable development options],
        [with_develop=$withval],
        [with_develop=no])
 AC_MSG_RESULT($with_develop)
 
        [with_develop=$withval],
        [with_develop=no])
 AC_MSG_RESULT($with_develop)
 
-###   use option --enable-broken-linker to force on use of broken-linker support
-AC_MSG_CHECKING(if you want broken-linker support code)
-AC_ARG_ENABLE(broken_linker,
-       [  --enable-broken_linker  compile with broken-linker support code],
-       [with_broken_linker=$enableval],
-       [with_broken_linker=$BROKEN_LINKER])
-AC_MSG_RESULT($with_broken_linker)
-test "$with_broken_linker" = yes && AC_DEFINE(BROKEN_LINKER)
-
 ###   use option --enable-hard-tabs to turn on use of hard-tabs optimize
 ###   use option --enable-hard-tabs to turn on use of hard-tabs optimize
-AC_MSG_CHECKING(if you want experimental hard-tabs code)
+AC_MSG_CHECKING(if you want hard-tabs code)
 AC_ARG_ENABLE(hard-tabs,
 AC_ARG_ENABLE(hard-tabs,
-       [  --enable-hard-tabs      compile with experimental hard-tabs code],
-       [with_hardtabs=$enableval],
-       [with_hardtabs=$with_develop])
-AC_MSG_RESULT($with_hardtabs)
-test "$with_hardtabs" = yes && AC_DEFINE(USE_HARD_TABS)
+       [  --enable-hard-tabs      compile with hard-tabs code],,
+       [enable_hard_tabs=$with_develop])
+AC_MSG_RESULT($enable_hard_tabs)
+test "x$enable_hard_tabs" = xyes && AC_DEFINE(USE_HARD_TABS,1,[Define to 1 to compile with hard-tabs code])
+
+###   use option --enable-xmc-glitch to turn on use of magic-cookie optimize
+AC_MSG_CHECKING(if you want limited support for xmc)
+AC_ARG_ENABLE(xmc-glitch,
+       [  --enable-xmc-glitch     compile with support for xmc (magic-cookie)],,
+       [enable_xmc_glitch=$with_develop])
+AC_MSG_RESULT($enable_xmc_glitch)
+test "x$enable_xmc_glitch" = xyes && AC_DEFINE(USE_XMC_SUPPORT,1,[Define to 1 to compile with support for xmc (magic-cookie)])
+
+###############################################################################
+# These are just experimental, probably should not be in a package:
+CF_HELP_MESSAGE(Experimental Code:)
+
+AC_MSG_CHECKING(if you do not want to assume colors are white-on-black)
+AC_ARG_ENABLE(assumed-color,
+       [  --disable-assumed-color do not assume anything about default-colors],
+       [with_assumed_color=$enableval],
+       [with_assumed_color=yes])
+AC_MSG_RESULT($with_assumed_color)
+test "x$with_assumed_color" = xyes && AC_DEFINE(USE_ASSUMED_COLOR,1,[Define to 1 to assume things about default-colors])
 
 ###   use option --enable-hashmap to turn on use of hashmap scrolling logic
 
 ###   use option --enable-hashmap to turn on use of hashmap scrolling logic
-AC_MSG_CHECKING(if you want experimental hashmap code)
+AC_MSG_CHECKING(if you want hashmap scrolling-optimization code)
 AC_ARG_ENABLE(hashmap,
 AC_ARG_ENABLE(hashmap,
-       [  --enable-hashmap        compile with experimental hashmap code],
+       [  --disable-hashmap       compile without hashmap scrolling-optimization],
        [with_hashmap=$enableval],
        [with_hashmap=yes])
 AC_MSG_RESULT($with_hashmap)
        [with_hashmap=$enableval],
        [with_hashmap=yes])
 AC_MSG_RESULT($with_hashmap)
-test "$with_hashmap" = yes && AC_DEFINE(USE_HASHMAP)
+test "x$with_hashmap" = xyes && AC_DEFINE(USE_HASHMAP,1,[Define to 1 to compile with hashmap scrolling-optimization])
+
+###   use option --enable-colorfgbg to turn on use of $COLORFGBG environment
+AC_MSG_CHECKING(if you want colorfgbg code)
+AC_ARG_ENABLE(colorfgbg,
+       [  --enable-colorfgbg      compile-in experimental $COLORFGBG code],
+       [with_colorfgbg=$enableval],
+       [with_colorfgbg=no])
+AC_MSG_RESULT($with_colorfgbg)
+test "x$with_colorfgbg" = xyes && AC_DEFINE(USE_COLORFGBG,1,[Define to 1 to compile-in experimental $COLORFGBG code])
+
+###   use option --enable-interop to turn on use of bindings used for interop
+AC_MSG_CHECKING(if you want interop bindings)
+AC_ARG_ENABLE(interop,
+       [  --enable-interop        compile-in interop bindings],
+       [with_exp_interop=$enableval],
+       [with_exp_interop=$cf_dft_interop])
+AC_MSG_RESULT($with_exp_interop)
+
+NCURSES_INTEROP_FUNCS=0
+test "x$with_exp_interop" = xyes && NCURSES_INTEROP_FUNCS=1
+AC_SUBST(NCURSES_INTEROP_FUNCS)
 
 
-AC_MSG_CHECKING(if you want experimental no-padding code)
-AC_ARG_ENABLE(no-padding,
-       [  --enable-no-padding     compile with experimental no-padding code],
-       [with_no_padding=$enableval],
-       [with_no_padding=yes])
-AC_MSG_RESULT($with_no_padding)
-test "$with_no_padding" = yes && AC_DEFINE(NCURSES_NO_PADDING)
 
 AC_MSG_CHECKING(if you want experimental safe-sprintf code)
 AC_ARG_ENABLE(safe-sprintf,
 
 AC_MSG_CHECKING(if you want experimental safe-sprintf code)
 AC_ARG_ENABLE(safe-sprintf,
@@ -562,160 +1465,189 @@ AC_ARG_ENABLE(safe-sprintf,
        [with_safe_sprintf=$enableval],
        [with_safe_sprintf=no])
 AC_MSG_RESULT($with_safe_sprintf)
        [with_safe_sprintf=$enableval],
        [with_safe_sprintf=no])
 AC_MSG_RESULT($with_safe_sprintf)
-test "$with_safe_sprintf" = yes && AC_DEFINE(USE_SAFE_SPRINTF)
 
 ###   use option --disable-scroll-hints to turn off use of scroll-hints scrolling logic
 
 ###   use option --disable-scroll-hints to turn off use of scroll-hints scrolling logic
+# when hashmap is used scroll hints are useless
+if test "$with_hashmap" = no ; then
 AC_MSG_CHECKING(if you want to experiment without scrolling-hints code)
 AC_ARG_ENABLE(scroll-hints,
 AC_MSG_CHECKING(if you want to experiment without scrolling-hints code)
 AC_ARG_ENABLE(scroll-hints,
-       [  --disable-scroll-hints  compile hashmap without scroll-hints code],
+       [  --disable-scroll-hints  compile without scroll-hints code],
        [with_scroll_hints=$enableval],
        [with_scroll_hints=$enableval],
-       [with_scroll_hints=yes;
-        # when hashmap is used scroll hints are useless
-        test $with_hashmap = yes && with_scroll_hints=no])
+       [with_scroll_hints=yes])
 AC_MSG_RESULT($with_scroll_hints)
 AC_MSG_RESULT($with_scroll_hints)
-test "$with_scroll_hints" = yes && AC_DEFINE(USE_SCROLL_HINTS)
-
-###   use option --enable-tcap-names to allow user to define new capabilities
-AC_MSG_CHECKING(if you want experimental definable names like termcap)
-AC_ARG_ENABLE(tcap-names,
-       [  --enable-tcap-names     compile with experimental definable-name code],
-       [with_tcap_names=$enableval],
-       [with_tcap_names=$with_develop])
-AC_MSG_RESULT($with_tcap_names)
-NCURSES_XNAMES=0
-test "$with_tcap_names" = yes && NCURSES_XNAMES=1
-AC_SUBST(NCURSES_XNAMES)
-
-###   use option --enable-sigwinch to turn on use of SIGWINCH logic
-AC_MSG_CHECKING(if you want experimental SIGWINCH handler)
-AC_ARG_ENABLE(sigwinch,
-       [  --enable-sigwinch       compile with experimental SIGWINCH handler],
-       [with_sigwinch=$enableval],
-       [with_sigwinch=yes])
-AC_MSG_RESULT($with_sigwinch)
-test "$with_sigwinch" = yes && AC_DEFINE(USE_SIGWINCH)
-
-###   use option --enable-widec to turn on use of wide-character support
-AC_MSG_CHECKING(if you want experimental wide-character code)
-AC_ARG_ENABLE(widec,
-       [  --enable-widec          compile with experimental wide-char code],
-       [with_widec=$enableval],
-       [with_widec=no])
-AC_MSG_RESULT($with_widec)
-test "$with_widec" = yes && AC_DEFINE(USE_WIDEC_SUPPORT)
+test "x$with_scroll_hints" = xyes && AC_DEFINE(USE_SCROLL_HINTS,1,[Define to 1 to compile without scroll-hints code])
+fi
 
 
-###   use option --enable-xmc-glitch to turn on use of magic-cookie optimize
-AC_MSG_CHECKING(if you want experimental xmc code)
-AC_ARG_ENABLE(xmc-glitch,
-       [  --enable-xmc-glitch     compile with experimental xmc code],
-       [with_xmc_glitch=$enableval],
-       [with_xmc_glitch=$with_develop])
-AC_MSG_RESULT($with_xmc_glitch)
-test "$with_xmc_glitch" = yes && AC_DEFINE(USE_XMC_SUPPORT)
+AC_MSG_CHECKING(if you want wgetch-events code)
+AC_ARG_ENABLE(wgetch-events,
+       [  --enable-wgetch-events  compile with wgetch-events code],
+       [with_wgetch_events=$enableval],
+       [with_wgetch_events=no])
+AC_MSG_RESULT($with_wgetch_events)
+test "x$with_wgetch_events" = xyes && AC_DEFINE(NCURSES_WGETCH_EVENTS,1,[Define to 1 to compile with wgetch-events code])
 
 ###############################################################################
 CF_HELP_MESSAGE(Testing/development Options:)
 
 ###    use option --disable-echo to suppress full display compiling commands
 
 ###############################################################################
 CF_HELP_MESSAGE(Testing/development Options:)
 
 ###    use option --disable-echo to suppress full display compiling commands
-AC_ARG_ENABLE(echo,
-       [  --enable-echo           build: display "compiling" commands (default)],
-       [with_echo=$enableval],
-       [with_echo=yes])
-if test "$with_echo" = yes; then
+CF_DISABLE_ECHO
+if test "x$enable_echo" = xyes; then
        ECHO_LINK=
 else
        ECHO_LINK='@ echo linking $@ ... ;'
        ECHO_LINK=
 else
        ECHO_LINK='@ echo linking $@ ... ;'
+       test -n "$LIBTOOL" && LIBTOOL="$LIBTOOL --silent"
+       test -n "$LIBTOOL_CXX" && LIBTOOL_CXX="$LIBTOOL_CXX --silent"
 fi
 AC_SUBST(ECHO_LINK)
 
 fi
 AC_SUBST(ECHO_LINK)
 
+# --disable-stripping is used for debugging
+CF_INSTALL_OPTS
+
+# If we're avoiding relinking of shared libraries during install, that is to
+# avoid modifying the build-tree.  For the same reason, avoid doing ranlib if
+# the install program has "-p" (for preserving timestamps).
+cf_cv_do_reranlib=yes
+if test "x$cf_cv_install_p" = xyes
+then
+       if test "x$cf_cv_do_relink" != xyes
+       then
+               cf_cv_do_reranlib=no
+               INSTALL_OPT_P="-p"
+               INSTALL_LIB="$INSTALL_LIB $INSTALL_OPT_P"
+       fi
+fi
+AC_SUBST(INSTALL_OPT_P)
+
 ###    use option --enable-warnings to turn on all gcc warnings
 ###    use option --enable-warnings to turn on all gcc warnings
+AC_MSG_CHECKING(if you want to see compiler warnings)
 AC_ARG_ENABLE(warnings,
        [  --enable-warnings       build: turn on GCC compiler warnings],
        [with_warnings=$enableval])
 AC_ARG_ENABLE(warnings,
        [  --enable-warnings       build: turn on GCC compiler warnings],
        [with_warnings=$enableval])
-if test -n "$with_warnings"; then
-       ADAFLAGS="$ADAFLAGS -gnatg"
-       CF_GCC_WARNINGS
+AC_MSG_RESULT($with_warnings)
+
+if test "x$with_warnings" = "xyes"; then
+       CF_ADD_ADAFLAGS(-gnatg)
+       CF_GCC_WARNINGS(Wno-unknown-pragmas Wswitch-enum)
+       if test "x$cf_with_cxx" = xyes ; then
+               CF_GXX_WARNINGS(Wno-unused)
+       fi
 fi
 CF_GCC_ATTRIBUTES
 fi
 CF_GCC_ATTRIBUTES
+CF_ENABLE_STRING_HACKS
 
 ###    use option --enable-assertions to turn on generation of assertion code
 
 ###    use option --enable-assertions to turn on generation of assertion code
+AC_MSG_CHECKING(if you want to enable runtime assertions)
 AC_ARG_ENABLE(assertions,
        [  --enable-assertions     test: turn on generation of assertion code],
        [with_assertions=$enableval],
        [with_assertions=no])
 AC_ARG_ENABLE(assertions,
        [  --enable-assertions     test: turn on generation of assertion code],
        [with_assertions=$enableval],
        [with_assertions=no])
+AC_MSG_RESULT($with_assertions)
 if test -n "$GCC"
 then
 if test -n "$GCC"
 then
-       if test $with_assertions = no
+       if test "$with_assertions" = no
        then
        then
-               AC_DEFINE(NDEBUG)
                CPPFLAGS="$CPPFLAGS -DNDEBUG"
        else
                CPPFLAGS="$CPPFLAGS -DNDEBUG"
        else
-               ADAFLAGS="$ADAFLAGS -gnata"
+               CF_ADD_ADAFLAGS(-gnata)
        fi
 fi
 
 ###    use option --disable-leaks to suppress "permanent" leaks, for testing
        fi
 fi
 
 ###    use option --disable-leaks to suppress "permanent" leaks, for testing
-AC_ARG_ENABLE(leaks,
-       [  --disable-leaks         test: suppress permanent memory-leaks],
-       [test $enableval = no && AC_DEFINE(NO_LEAKS)])
-AC_DEFINE(HAVE_NC_ALLOC_H)
+CF_DISABLE_LEAKS
+AC_DEFINE(HAVE_NC_ALLOC_H,1,[Define to 1 if we have nc_alloc.h header])
 
 ###    use option --enable-expanded to generate certain macros as functions
 AC_ARG_ENABLE(expanded,
        [  --enable-expanded       test: generate functions for certain macros],
 
 ###    use option --enable-expanded to generate certain macros as functions
 AC_ARG_ENABLE(expanded,
        [  --enable-expanded       test: generate functions for certain macros],
-       [test $enableval = yes && AC_DEFINE(NCURSES_EXPANDED)])
+       [test "x$enableval" = xyes && AC_DEFINE(NCURSES_EXPANDED,1,[Define to 1 to generate functions for certain macros])])
 
 ###    use option --disable-macros to suppress macros in favor of functions
 AC_ARG_ENABLE(macros,
        [  --disable-macros        test: use functions rather than macros],
 
 ###    use option --disable-macros to suppress macros in favor of functions
 AC_ARG_ENABLE(macros,
        [  --disable-macros        test: use functions rather than macros],
-       [test $enableval = no && AC_DEFINE(NCURSES_NOMACROS)])
+       [test "$enableval" = no && AC_DEFINE(NCURSES_NOMACROS,1,[Define to 1 to use functions rather than macros])])
+
+# Normally we only add trace() to the debug-library.  Allow this to be
+# extended to all models of the ncurses library:
+cf_all_traces=no
+case "$CFLAGS $CPPFLAGS" in
+(*-DTRACE*)
+       cf_all_traces=yes
+       ;;
+esac
+
+AC_MSG_CHECKING(whether to add trace feature to all models)
+AC_ARG_WITH(trace,
+[  --with-trace            test: add trace() function to all models of ncurses],
+[cf_with_trace=$withval],
+[cf_with_trace=$cf_all_traces])
+AC_MSG_RESULT($cf_with_trace)
+
+if test "x$cf_with_trace" = xyes ; then
+       LIB_TRACING=all
+       ADA_TRACE=TRUE
+       CF_ADD_CFLAGS(-DTRACE)
+       AC_DEFINE(HAVE__TRACEF,1,[Define to 1 if we have _tracef function])
+else
+       LIB_TRACING=DEBUG
+       ADA_TRACE=FALSE
+fi
+
+AC_SUBST(ADA_TRACE)
+
+CF_DISABLE_GNAT_PROJECTS
 
 ###    Checks for libraries.
 
 ###    Checks for libraries.
+case $cf_cv_system_name in
+(*mingw32*|*mingw64*)
+       CPPFLAGS="$CPPFLAGS -DWINVER=0x0501 -DWIN32_LEAN_AND_MEAN"
+       LIBS=" -lpsapi $LIBS"
+       ;;
+(*)
 AC_CHECK_FUNC(gettimeofday,
 AC_CHECK_FUNC(gettimeofday,
-       AC_DEFINE(HAVE_GETTIMEOFDAY),[
+       AC_DEFINE(HAVE_GETTIMEOFDAY,1,[Define to 1 if we have gettimeofday function]),[
 
 AC_CHECK_LIB(bsd, gettimeofday,
 
 AC_CHECK_LIB(bsd, gettimeofday,
-       AC_DEFINE(HAVE_GETTIMEOFDAY)
-       LIBS="$LIBS -lbsd")])dnl CLIX: bzero, select, gettimeofday
+       AC_DEFINE(HAVE_GETTIMEOFDAY,1,[Define to 1 if we have gettimeofday function])
+       CF_ADD_LIB(bsd))])dnl CLIX: bzero, select, gettimeofday
+       ;;
+esac
 
 
-MATH_LIB=""
-AC_CHECK_FUNC(sin,,
-       AC_CHECK_LIB(m, sin,[MATH_LIB="-lm"]))
+CF_MATH_LIB(MATH_LIB,pow(sin(x),x))
 AC_SUBST(MATH_LIB)
 
 ###    Checks for header files.
 AC_STDC_HEADERS
 AC_HEADER_DIRENT
 AC_SUBST(MATH_LIB)
 
 ###    Checks for header files.
 AC_STDC_HEADERS
 AC_HEADER_DIRENT
+AC_HEADER_TIME
 CF_REGEX
 
 dnl These are some other potentially nonportable headers.
 AC_CHECK_HEADERS( \
 fcntl.h \
 getopt.h \
 CF_REGEX
 
 dnl These are some other potentially nonportable headers.
 AC_CHECK_HEADERS( \
 fcntl.h \
 getopt.h \
-libc.h \
 limits.h \
 locale.h \
 limits.h \
 locale.h \
+math.h \
+poll.h \
 sys/bsdtypes.h \
 sys/ioctl.h \
 sys/param.h \
 sys/bsdtypes.h \
 sys/ioctl.h \
 sys/param.h \
-poll.h \
+sys/poll.h \
 sys/select.h \
 sys/select.h \
-sys/stropts.h \
 sys/time.h \
 sys/times.h \
 sys/time.h \
 sys/times.h \
-termio.h \
-termios.h \
 ttyent.h \
 unistd.h \
 ttyent.h \
 unistd.h \
-values.h \
+wctype.h \
 )
 
 )
 
+CF_GETOPT_HEADER
+
 # check for ISC (this may also define _POSIX_SOURCE)
 # Note: even non-Posix ISC needs <sys/bsdtypes.h> to declare fd_set
 # check for ISC (this may also define _POSIX_SOURCE)
 # Note: even non-Posix ISC needs <sys/bsdtypes.h> to declare fd_set
-if test "$ISC" = yes ; then
+if test "x$ISC" = xyes ; then
        AC_CHECK_LIB(cposix,main)
        AC_CHECK_LIB(cposix,main)
-       AC_CHECK_LIB(inet,bzero,LIBS="$LIBS -linet")dnl also 'select()'
-       AC_CHECK_HEADERS( sys/termio.h )
+       AC_CHECK_LIB(inet,bzero,CF_ADD_LIB(inet))dnl also 'select()'
 fi
 
 CF_SYS_TIME_SELECT
 fi
 
 CF_SYS_TIME_SELECT
@@ -723,93 +1655,160 @@ CF_SYS_TIME_SELECT
 ###    checks for compiler characteristics
 AC_LANG_C
 AC_C_CONST
 ###    checks for compiler characteristics
 AC_LANG_C
 AC_C_CONST
-AC_C_INLINE
-test $ac_cv_c_inline != no && AC_DEFINE(CC_HAS_INLINE_FUNCS)
+CF_C_INLINE(NCURSES_INLINE,1200)
+CF_SIG_ATOMIC_T
 
 
-CF_TYPEOF_CHTYPE
-CF_WIDEC_SHIFT
+if test $NCURSES_CHTYPE = auto ; then
+       CF_TYPEOF_CHTYPE
+else
+       cf_cv_typeof_chtype=$NCURSES_CHTYPE
+fi
+test "$cf_cv_typeof_chtype" = unsigned && cf_cv_typeof_chtype=""
+AC_SUBST(cf_cv_typeof_chtype)
+
+CF_UNSIGNED_LITERALS
+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)
+
+if test $NCURSES_MMASK_T = auto ; then
+       cf_cv_typeof_mmask_t=long
+else
+       cf_cv_typeof_mmask_t=$NCURSES_MMASK_T
+fi
+test "$cf_cv_typeof_mmask_t" = unsigned && cf_cv_typeof_mmask_t=""
+AC_SUBST(cf_cv_typeof_mmask_t)
 
 ###    Checks for external-data
 CF_ERRNO
 CF_LINK_DATAONLY
 
 ###    Checks for external-data
 CF_ERRNO
 CF_LINK_DATAONLY
-CF_SPEED_TYPE
 
 ###    Checks for library functions.
 
 ###    Checks for library functions.
-AC_CHECK_FUNCS( getcwd \
+AC_CHECK_FUNCS( \
+getcwd \
+getegid \
+geteuid \
+getopt \
 getttynam \
 getttynam \
-memccpy \
-nanosleep \
+issetugid \
+localeconv \
 poll \
 poll \
+putenv \
 remove \
 select \
 setbuf \
 setbuffer \
 remove \
 select \
 setbuf \
 setbuffer \
+setenv \
 setvbuf \
 sigaction \
 sigvec \
 strdup \
 strstr \
 setvbuf \
 sigaction \
 sigvec \
 strdup \
 strstr \
-tcgetattr \
+sysconf \
 tcgetpgrp \
 times \
 tcgetpgrp \
 times \
-vfscanf \
+tsearch \
 vsnprintf \
 vsnprintf \
-vsscanf \
 )
 
 )
 
+if test "x$ac_cv_func_getopt" = xno && \
+   test "x$cf_with_progs$cf_with_tests" != xnono; then
+       AC_MSG_ERROR(getopt is required for building programs)
+fi
 
 
-if test "$with_getcap" = "yes" ; then
+if test "x$with_safe_sprintf" = xyes
+then
+       if test "x$ac_cv_func_vsnprintf" = xyes
+       then
+               AC_MSG_WARN(will use vsnprintf instead of safe-sprintf option)
+       else
+               AC_DEFINE(USE_SAFE_SPRINTF,1,[Define to 1 to compile with experimental safe-sprintf code])
+       fi
+fi
+
+if test "x$with_getcap" = "xyes" ; then
        CF_CGETENT
 fi
 
 CF_ISASCII
 CF_STRUCT_SIGACTION
        CF_CGETENT
 fi
 
 CF_ISASCII
 CF_STRUCT_SIGACTION
-CF_STRUCT_TERMIOS
+CF_FUNC_NANOSLEEP
+CF_FUNC_TERMIOS
+CF_FUNC_VSSCANF
+CF_MKSTEMP
+
+# setup for prototype of fallback for vsscanf()
+CF_SUBST_IF(["$cf_cv_func_vsscanf" = vsscanf], HAVE_VSSCANF, 1, 0)
 
 dnl FIXME (may need this) AC_SYS_RESTARTABLE_SYSCALLS
 
 dnl FIXME (may need this) AC_SYS_RESTARTABLE_SYSCALLS
-if test "$cross_compiling" = yes ; then
+if test "x$cross_compiling" = xyes ; then
        AC_MSG_WARN(cross compiling: assume setvbuf params not reversed)
 else
        AC_FUNC_SETVBUF_REVERSED
 fi
        AC_MSG_WARN(cross compiling: assume setvbuf params not reversed)
 else
        AC_FUNC_SETVBUF_REVERSED
 fi
-AC_TYPE_SIGNAL
+AC_CHECK_TYPE(intptr_t, long)
+AC_CHECK_TYPE(ssize_t, int)
 CF_TYPE_SIGACTION
 CF_SIZECHANGE
 CF_FUNC_MEMMOVE
 CF_TYPE_SIGACTION
 CF_SIZECHANGE
 CF_FUNC_MEMMOVE
+CF_FUNC_POLL
+CF_VA_COPY
+AC_FUNC_VFORK
+CF_FOPEN_BIN_R
+
+# special check for test/ditto.c
+CF_FUNC_OPENPTY
+if test "$cf_cv_func_openpty" != no ; then
+       AC_DEFINE_UNQUOTED(USE_OPENPTY_HEADER,<$cf_cv_func_openpty>,[Define to actual header for openpty function])
+       AC_DEFINE(USE_XTERM_PTY,1,[Define to 1 if we should assume xterm pseudoterminal interface])
+       if test "x$cf_cv_lib_util" = xyes ; then
+               CF_ADD_LIB(util,TEST_LIBS)
+       fi
+fi
+AC_SUBST(TEST_LIBS)
+AC_SUBST(TEST_LIBS2)
+
+if test "$with_hashed_db" != no ; then
+       AC_DEFINE(USE_HASHED_DB,1,[Define to 1 if we should build terminfo in hashed database])
+       CF_HASHED_DB($with_hashed_db)
+fi
 
 dnl We'll do our own -g libraries, unless the user's overridden via $CFLAGS
 
 dnl We'll do our own -g libraries, unless the user's overridden via $CFLAGS
-if test -z "$cf_user_CFLAGS" ; then
+if test -z "$cf_user_CFLAGS" && test "$with_no_leaks" = no ; then
        CF_STRIP_G_OPT(CFLAGS)
        CF_STRIP_G_OPT(CXXFLAGS)
 fi
 
        CF_STRIP_G_OPT(CFLAGS)
        CF_STRIP_G_OPT(CXXFLAGS)
 fi
 
-dnl Check for C++ compiler characteristics (and ensure that it's there!)
+# Just in case, check if the C compiler has a bool type.
 CF_BOOL_DECL(cf_cv_cc_bool_type)
 CF_BOOL_DECL(cf_cv_cc_bool_type)
+
+# Check for C++ compiler characteristics (and ensure that it's there!)
 if test -n "$CXX" ; then
        AC_LANG_CPLUSPLUS
        CF_STDCPP_LIBRARY
 if test -n "$CXX" ; then
        AC_LANG_CPLUSPLUS
        CF_STDCPP_LIBRARY
-       case "`${CXX-g++} --version`" in
-       1*|2.[0-6]*)
-           cf_cxx_library=yes
-           ;;
-       2.7*)
-           CF_GPP_LIBRARY
-           ;;
-       *)
-           cf_cxx_library=no
-           ;;
+       CF_PROG_CC_C_O(CXX,[$CXXFLAGS $CPPFLAGS])
+
+       case $GXX_VERSION in
+       (1*|2.[0-6]*)
+               cf_cxx_library=yes
+               ;;
+       (*-2.7*|2.7*)
+               CF_GPP_LIBRARY
+               ;;
+       (*)
+               cf_cxx_library=no
+               ;;
        esac
        esac
+
        AC_CHECK_HEADERS(typeinfo)
        AC_CHECK_HEADERS(typeinfo)
+       CF_CXX_IOSTREAM_NAMESPACE
        CF_BOOL_DECL
        CF_BOOL_SIZE
        CF_ETIP_DEFINES
        CF_CPP_PARAM_INIT
        CF_BOOL_DECL
        CF_BOOL_SIZE
        CF_ETIP_DEFINES
        CF_CPP_PARAM_INIT
-       case $cf_cv_system_name in #(vi
-       sco3.2v5*)
-           CXXLDFLAGS="-u main"
-           ;;
-       esac
-       AC_SUBST(CXXLDFLAGS)
+       CF_CPP_STATIC_CAST
+       CF_CXX_AR_FLAGS
 else
        cf_cxx_library=no
        cf_cv_builtin_bool=1
 else
        cf_cxx_library=no
        cf_cv_builtin_bool=1
@@ -823,165 +1822,648 @@ else
        # Caveat: since the storage of the bool type is not standardized, it
        # may change.
 
        # Caveat: since the storage of the bool type is not standardized, it
        # may change.
 
-       AC_MSG_CHECKING(for fallback type of bool)
-       case "$host_cpu" in #(vi
-       i?86)   cf_cv_type_of_bool=char ;; #(vi
-       *)      cf_cv_type_of_bool=int  ;;
-       esac
-       AC_MSG_RESULT($cf_cv_type_of_bool)
+       if test "$NCURSES_BOOL" != auto ; then
+               cf_cv_type_of_bool=$NCURSES_BOOL
+               cf_cv_header_stdbool_h=0
+       else
+               if test "$cf_cv_header_stdbool_h" = 1 ; then
+                       CF_BOOL_SIZE
+               else
+                       AC_MSG_CHECKING(for fallback type of bool)
+                       case "$host_cpu" in
+                       (i?86)  cf_cv_type_of_bool=char ;;
+                       (*)     cf_cv_type_of_bool=int  ;;
+                       esac
+                       AC_MSG_RESULT($cf_cv_type_of_bool)
+               fi
+       fi
 fi
 AC_SUBST(CXXLIBS)
 
 fi
 AC_SUBST(CXXLIBS)
 
+# If the C compiler did not declare bool, and we did not determine that the C++
+# compiler does not declare bool, turn on an ifdef in curses.h that makes the
+# ncurses library use the same type as C++ bool.  Note that this allows one to
+# specify the type of bool in a configure-script option and postpone
+# integration with the C++ compiler provided that the types are compatible.
+USE_CXX_BOOL=1
+if test $cf_cv_cc_bool_type = 1
+then
+       # oops: C has a bool.  Unlikely, but C++ could differ.
+       USE_CXX_BOOL=0
+elif test $cf_cv_builtin_bool = 0
+then
+       # C++ has no bool
+       USE_CXX_BOOL=0
+else
+       # this is the normal case
+       USE_CXX_BOOL='defined(__cplusplus)'
+fi
+AC_SUBST(USE_CXX_BOOL)
+
 CF_HELP_MESSAGE(Ada95 Binding Options:)
 
 CF_HELP_MESSAGE(Ada95 Binding Options:)
 
+dnl If the Ada95 source-tree is present, add that to the build unless it will
+dnl not work, or was not requested.
+if test -f "${srcdir}/Ada95/Makefile.in" ; then
+
+dnl libtool does not know anything about GNAT, though a change made in 1998
+dnl provided for it "someday".  Disable the ada subtree if we are using
+dnl libtool -TD 20070714
+       if test "$cf_with_ada" != "no" ; then
+               if test "$with_libtool" != "no"; then
+                       AC_MSG_WARN(libtool does not support Ada - disabling feature)
+                       cf_with_ada=no
+               fi
+       fi
+
 dnl Check for availability of GNU Ada Translator (GNAT).
 dnl At the moment we support no other Ada95 compiler.
 dnl Check for availability of GNU Ada Translator (GNAT).
 dnl At the moment we support no other Ada95 compiler.
-if test "$cf_with_ada" != "no" ; then
-cf_ada_make=gnatmake
-AC_CHECK_PROG(gnat_exists, $cf_ada_make, yes, no)
-if test "$ac_cv_prog_gnat_exists" = no; then
-   cf_ada_make=
-else
-   CF_GNAT_VERSION
-   AC_CHECK_PROG(m4_exists, m4, yes, no)
-   if test "$ac_cv_prog_m4_exists" = no; then
-      cf_cv_prog_gnat_correct=no
-      echo Ada95 binding required program m4 not found. Ada95 binding disabled.
-   fi
-   if test "$cf_cv_prog_gnat_correct" = yes; then
-      AC_MSG_CHECKING(if GNAT works)
-      CF_GNAT_TRY_RUN([procedure conftest;],
-[with Text_IO;
-with GNAT.OS_Lib;
-procedure conftest is
-begin
-   Text_IO.Put ("Hello World");
-   Text_IO.New_Line;
-   GNAT.OS_Lib.OS_Exit (0);
-end conftest;],[cf_cv_prog_gnat_correct=yes],[cf_cv_prog_gnat_correct=no])
-      AC_MSG_RESULT($cf_cv_prog_gnat_correct)
-   fi
-fi
-if test        "$cf_cv_prog_gnat_correct" = yes; then
-   ADAFLAGS="-O3 -gnatpn $ADAFLAGS"
-
-   AC_ARG_WITH(ada-compiler,
-       [  --with-ada-compiler=CMD Specify Ada95 compiler command (default gnatmake)],
-       [cf_ada_compiler=$withval],
-       [cf_ada_compiler=gnatmake])
-
-   cf_ada_package=terminal_interface
-
-   AC_SUBST(cf_ada_make)
-   AC_SUBST(cf_ada_compiler)
-   AC_SUBST(cf_ada_package)
-   AC_SUBST(ADAFLAGS)
-   AC_SUBST(cf_compile_generics)
-   AC_SUBST(cf_generic_objects)
-
-   CF_WITH_PATH(ada-include,
-       [  --with-ada-include=DIR  Ada includes are in DIR],
-       ADA_INCLUDE,
-       PREFIX/lib/gnu-Ada/adainclude,
-       [$]prefix/lib/gnu-Ada/adainclude)
-   AC_SUBST(ADA_INCLUDE)
-
-   CF_WITH_PATH(ada-objects,
-       [  --with-ada-objects=DIR  Ada objects are in DIR],
-       ADA_OBJECTS,
-       PREFIX/lib/gnu-Ada/adalib,
-       [$]prefix/lib/gnu-Ada/adalib)
-   AC_SUBST(ADA_OBJECTS)
-
-   if test $with_shared = no
-   then
-      AC_MSG_WARN(Ada95 applications will not link properly with static libraries)
-   fi
-fi
-fi
-
-### It's not possible to appease gcc 2.6.3's conversion-warnings if we're
-### using a 'char' for bools.  gcc 2.7.0's conversion-warnings are broken too
-### badly to consider using for development purposes, but 2.5.8 is okay.
-if test -n "$with_warnings"; then
-       if test -n "$GCC"; then
-               case "`$CC --version`" in
-               2.6.3)
-                       if test "$cf_cv_type_of_bool" != "char"; then
-                               EXTRA_CFLAGS="$EXTRA_CFLAGS -Wconversion"
-                       fi
-                       ;;
-               2.5*)
-                       EXTRA_CFLAGS="$EXTRA_CFLAGS -Wconversion"
-                       ;;
-               esac
+       if test "$cf_with_ada" != "no" ; then
+               CF_PROG_GNAT
+               if test "x$cf_cv_prog_gnat_correct" = xyes; then
+                       CF_ADD_ADAFLAGS(-gnatpn)
+                       CF_FIXUP_ADAFLAGS
+
+                       CF_GNATPREP_OPT_T
+
+                       CF_GNAT_GENERICS
+                       CF_GNAT_SIGINT
+                       CF_GNAT_PROJECTS
+
+                       CF_WITH_ADA_COMPILER
+
+                       cf_ada_package=terminal_interface
+                       AC_SUBST(cf_ada_package)
+
+                       CF_WITH_ADA_INCLUDE
+                       CF_WITH_ADA_OBJECTS
+                       CF_WITH_ADA_SHAREDLIB
+               fi
        fi
        fi
+else
+       cf_with_ada=no
+fi
+
+# do this "late" to avoid conflict with header-checks
+if test "x$with_widec" = xyes ; then
+       AC_CHECK_SIZEOF(wchar_t)
 fi
 
 fi
 
-### Construct the library-subsets, if any, from this set of keywords:
-### none, base, ext_funcs, termlib.
+### Construct the ncurses library-subsets, if any, from this set of keywords:
+###    none, base, ext_funcs, ext_tinfo, ticlib, termlib, widechar
+###
+### ticlib modules may be a separate library, otherwise contained in termlib.
+### termlib modules may be a separate library, otherwise contained in ncurses.
+###
+### The of "+" or " " between the tokens controls the way the script
+### chooses to split module lists into libraries.
+###
+### (see CF_LIB_RULES).
 AC_MSG_CHECKING(for library subsets)
 AC_MSG_CHECKING(for library subsets)
-if test "$with_termlib" = yes ; then
-       LIB_SUBSETS="termlib "
+LIB_SUBSETS=
+
+if test "x$cf_with_progs" = xyes || test "$with_ticlib" != no || test "$with_termcap" != no; then
+       LIB_SUBSETS="${LIB_SUBSETS}ticlib"
+       if test "$with_ticlib" != no ; then
+               LIB_SUBSETS="${LIB_SUBSETS} "
+       else
+               LIB_SUBSETS="${LIB_SUBSETS}+"
+       fi
+fi
+
+LIB_SUBSETS="${LIB_SUBSETS}termlib"
+test "x$with_ext_funcs" = xyes && LIB_SUBSETS="${LIB_SUBSETS}+ext_tinfo"
+
+if test "$with_termlib" != no ; then
+       LIB_SUBSETS="${LIB_SUBSETS} "
 else
 else
-       LIB_SUBSETS="termlib+"
+       LIB_SUBSETS="${LIB_SUBSETS}+"
 fi
 fi
+
 LIB_SUBSETS="${LIB_SUBSETS}base"
 LIB_SUBSETS="${LIB_SUBSETS}base"
-test "$with_ext_funcs" = yes && LIB_SUBSETS="${LIB_SUBSETS}+ext_funcs"
+
+# Most term-driver calls are to tinfo, but some like init_pair are to the
+# base library (so it resides in base).
+if test "$with_term_driver" != no ; then
+       LIB_SUBSETS="${LIB_SUBSETS}+port_drivers"
+       case $cf_cv_system_name in
+       (*mingw32*|*mingw64*)
+               LIB_SUBSETS="${LIB_SUBSETS}+port_tinfo+port_win32con"
+               CPPFLAGS="$CPPFLAGS -DUSE_WIN32CON_DRIVER"
+               ;;
+       (*)
+               LIB_SUBSETS="${LIB_SUBSETS}+port_tinfo"
+               ;;
+       esac
+fi
+
+test "x$with_widec"     = xyes && LIB_SUBSETS="${LIB_SUBSETS}+widechar"
+test "x$with_ext_funcs" = xyes && LIB_SUBSETS="${LIB_SUBSETS}+ext_funcs"
+
 AC_MSG_RESULT($LIB_SUBSETS)
 
 ### Construct the list of include-directories to be generated
 CF_INCLUDE_DIRS
 CF_ADA_INCLUDE_DIRS
 
 AC_MSG_RESULT($LIB_SUBSETS)
 
 ### Construct the list of include-directories to be generated
 CF_INCLUDE_DIRS
 CF_ADA_INCLUDE_DIRS
 
-### Set up low-level terminfo dependencies for makefiles.  Note that we
-### could override this.
-if test "$with_termlib" = yes ; then
-       TEST_DEPS="${LIB_PREFIX}${TINFO_NAME}${DFT_DEP_SUFFIX}"
-       TEST_ARGS="-l${TINFO_NAME}${DFT_ARG_SUFFIX}"
+### Build up pieces for makefile rules
+AC_MSG_CHECKING(default library suffix)
+CF_LIB_TYPE($DFT_LWR_MODEL,DFT_ARG_SUFFIX)dnl
+AC_SUBST(DFT_ARG_SUFFIX)dnl the string to append to "-lncurses" ("")
+AC_MSG_RESULT($DFT_ARG_SUFFIX)
+
+AC_MSG_CHECKING(default library-dependency suffix)
+CF_LIB_SUFFIX($DFT_LWR_MODEL,DFT_LIB_SUFFIX,DFT_DEP_SUFFIX)dnl
+AC_SUBST(DFT_DEP_SUFFIX)dnl the corresponding library-suffix (".a")
+AC_MSG_RESULT($DFT_DEP_SUFFIX)
+
+AC_MSG_CHECKING(default object directory)
+CF_OBJ_SUBDIR($DFT_LWR_MODEL,DFT_OBJ_SUBDIR)dnl
+AC_SUBST(DFT_OBJ_SUBDIR)dnl the default object-directory ("obj")
+AC_MSG_RESULT($DFT_OBJ_SUBDIR)
+
+if test "x$cf_with_cxx" = xyes ; then
+AC_MSG_CHECKING(c++ library-dependency suffix)
+if test "$with_libtool" != "no"; then
+       # libtool thinks it can make c++ shared libraries (perhaps only g++)
+       CXX_LIB_SUFFIX=$DFT_DEP_SUFFIX
+elif test "$with_shared_cxx" != "no"; then
+       # also for g++ users...
+       CXX_LIB_SUFFIX=$DFT_DEP_SUFFIX
+else
+       # we normally make a static library because C/C++ library rules differ
+       CF_LIB_SUFFIX(normal,CXX_LIB_SUFFIX,CXX_DEP_SUFFIX)
+fi
+AC_MSG_RESULT($CXX_LIB_SUFFIX)
+AC_SUBST(CXX_LIB_SUFFIX)
+fi
+
+# do not want -ldl in build except as needed for -lncurses dependency
+if test "x$with_dlsym" = xyes ; then
+if test $DFT_LWR_MODEL = shared || \
+   test $DFT_LWR_MODEL = libtool ; then
+       CF_REMOVE_LIB(LIBS,$LIBS,dl)
+fi
+fi
+### Set up low-level terminfo dependencies for makefiles.
+
+# TICS_LIST and TINFO_LIST are needed to build libtic.so and libterm.so, but
+# do not need libdl
+TICS_LIST=
+if test "x$with_dlsym" = xyes ; then
+       CF_REMOVE_LIB(TINFO_LIST,$SHLIB_LIST,dl)
+fi
+
+USE_ARG_SUFFIX="${DFT_ARG_SUFFIX}${EXTRA_SUFFIX}"
+USE_LIB_SUFFIX="${LIB_SUFFIX}${EXTRA_SUFFIX}"
+USE_CFG_SUFFIX=${DFT_ARG_SUFFIX}${cf_cv_abi_version}
+if test -n "$EXTRA_SUFFIX" && test "x$EXTRA_SUFFIX" != "x${cf_cv_abi_version}"
+then
+       USE_CFG_SUFFIX="${USE_CFG_SUFFIX}${EXTRA_SUFFIX}"
+fi
+AC_SUBST(USE_ARG_SUFFIX)
+AC_SUBST(USE_CFG_SUFFIX)
+AC_SUBST(USE_LIB_SUFFIX)
+
+if test "$with_ticlib" != no ; then
+
+       if test "x$with_ticlib" != xyes ; then
+               TICS_NAME=$with_ticlib
+               TICS_SUFFIX="`echo ${DFT_LIB_SUFFIX}|sed -e "s/^${USE_LIB_SUFFIX}//"`"
+               TICS_ARG_SUFFIX="${with_ticlib}`echo ${USE_ARG_SUFFIX}|sed -e "s/^${LIB_SUFFIX}//"`"
+               TICS_DEP_SUFFIX="${with_ticlib}`echo ${DFT_DEP_SUFFIX}|sed -e "s/^${LIB_SUFFIX}//"`"
+               TICS_LIB_SUFFIX="${with_ticlib}"
+       else
+               TICS_SUFFIX=${DFT_LIB_SUFFIX}
+               TICS_ARG_SUFFIX="${TICS_NAME}${USE_ARG_SUFFIX}"
+               TICS_DEP_SUFFIX="${TICS_NAME}${DFT_DEP_SUFFIX}"
+               TICS_LIB_SUFFIX="${TICS_NAME}${USE_LIB_SUFFIX}"
+       fi
+       TICS_LDFLAGS="-L${LIB_DIR}"
+       TICS_LIBS="-l${TICS_ARG_SUFFIX}"
+else
+       TICS_SUFFIX=${DFT_LIB_SUFFIX}
+       TICS_LDFLAGS="-L${LIB_DIR}"
+       TICS_LIBS="-l${LIB_NAME}${USE_ARG_SUFFIX}"
+fi
+AC_SUBST(TICS_ARG_SUFFIX)
+AC_SUBST(TICS_DEP_SUFFIX)
+AC_SUBST(TICS_LIB_SUFFIX)
+AC_SUBST(TICS_LDFLAGS)
+AC_SUBST(TICS_LIBS)
+
+if test "$with_termlib" != no ; then
+
+       if test "x$with_termlib" != xyes ; then
+               TINFO_NAME=$with_termlib
+               TINFO_SUFFIX="`echo ${DFT_LIB_SUFFIX}|sed -e "s/^${USE_LIB_SUFFIX}//"`"
+               TINFO_ARG_SUFFIX="${with_termlib}`echo ${USE_ARG_SUFFIX}|sed -e "s/^${LIB_SUFFIX}//"`"
+               TINFO_DEP_SUFFIX="${with_termlib}`echo ${DFT_DEP_SUFFIX}|sed -e "s/^${LIB_SUFFIX}//"`"
+               TINFO_LIB_SUFFIX="${with_termlib}"
+       else
+               TINFO_SUFFIX=${DFT_LIB_SUFFIX}
+               TINFO_ARG_SUFFIX="${TINFO_NAME}${USE_ARG_SUFFIX}"
+               TINFO_DEP_SUFFIX="${TINFO_NAME}${DFT_DEP_SUFFIX}"
+               TINFO_LIB_SUFFIX="${TINFO_NAME}${USE_LIB_SUFFIX}"
+       fi
+
+       TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${TINFO_DEP_SUFFIX}"
+       TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${TINFO_DEP_SUFFIX}"
+       if test "$DFT_LWR_MODEL" = "libtool"; then
+               TEST_ARGS="${TEST_DEPS}"
+               TEST_ARG2="${TEST_DEP2}"
+               TINFO_LDFLAGS="-L${LIB_DIR}"
+               TINFO_LIBS="$TEST_ARGS"
+               TICS_LIST="$SHLIB_LIST $TEST_ARGS"
+               SHLIB_LIST="${SHLIB_LIST} $TEST_ARGS"
+       else
+               TEST_ARGS="-l${TINFO_ARG_SUFFIX}"
+               TEST_ARG2="-l${TINFO_ARG_SUFFIX}"
+               if test "x$with_term_driver" != xno ; then
+                       TICS_LIST="$SHLIB_LIST -l${LIB_NAME}${USE_ARG_SUFFIX}"
+                       TICS_LIBS="$TICS_LIBS -l${LIB_NAME}${USE_ARG_SUFFIX}"
+                       TINFO_LIBS="-l${LIB_NAME}${USE_ARG_SUFFIX} $TEST_ARGS"
+               else
+                       TICS_LIST="$SHLIB_LIST -l${TINFO_LIB_SUFFIX}"
+                       TINFO_LIBS="$TEST_ARGS"
+               fi
+               TINFO_LDFLAGS="-L${LIB_DIR}"
+               SHLIB_LIST="$SHLIB_LIST -l${TINFO_LIB_SUFFIX}"
+       fi
+else
+       # the next lines are needed for linking libtic over libncurses
+       TINFO_NAME=${LIB_NAME}
+       TINFO_SUFFIX=${DFT_LIB_SUFFIX}
+       TINFO_ARG_SUFFIX=${LIB_NAME}${USE_ARG_SUFFIX}
+       if test "x$with_tic_depends" = xyes ; then
+               TICS_LIST="$SHLIB_LIST -l${LIB_NAME}${USE_ARG_SUFFIX}"
+       else
+               TICS_LIST="$SHLIB_LIST"
+       fi
+
+       TINFO_LDFLAGS="-L${LIB_DIR}"
+       TINFO_LIBS="-l${LIB_NAME}${USE_ARG_SUFFIX}"
 fi
 fi
-PROG_DEPS="$TEST_DEPS"
-PROG_ARGS="$TEST_ARGS"
+
+if test "$DFT_LWR_MODEL" = shared ; then
+       case $cf_cv_system_name in
+       (cygwin*|msys*)
+               # "lib" files have ".dll.a" suffix, "cyg"or "msys-" files have ".dll"
+               TINFO_SUFFIX=.dll
+               ;;
+       esac
+fi
+
+AC_SUBST(TINFO_ARG_SUFFIX)
+AC_SUBST(TINFO_DEP_SUFFIX)
+AC_SUBST(TINFO_LIB_SUFFIX)
+AC_SUBST(TINFO_LDFLAGS)
+AC_SUBST(TINFO_LIBS)
+
+if test "x$with_dlsym" = xyes ; then
+       CF_REMOVE_LIB(TICS_LIST,$TICS_LIST,dl)
+fi
+
+if test "$DFT_LWR_MODEL" = "libtool"; then
+       OBJEXT=lo
+fi
+
+# needed for Ada95
+TINFO_LDFLAGS2=`echo "$TINFO_LDFLAGS" | sed -e 's,-L\.\./,-L../../,'`
+AC_SUBST(TINFO_LDFLAGS2)
+
+case $DFT_LWR_MODEL in
+(normal|debug|profile)
+       CF_LDFLAGS_STATIC
+       ;;
+esac
+
+AC_MSG_CHECKING(where we will install curses.h)
+AC_SUBST(includesubdir)
+includesubdir=
+if test "$with_overwrite" = no && \
+ ( test "x$includedir" = 'x${prefix}/include' || \
+   test "x$includedir" = "x${prefix}/include" )
+then
+       includesubdir="/ncurses${USE_LIB_SUFFIX}"
+fi
+AC_MSG_RESULT(${includedir}${includesubdir})
+
+### Resolve a conflict between normal and wide-curses by forcing applications
+### that will need libutf8 to add it to their configure script.
+if test "$with_overwrite" != no ; then
+if test "$NCURSES_LIBUTF8" = 1 ; then
+       NCURSES_LIBUTF8='defined(HAVE_LIBUTF8_H)'
+       AC_MSG_WARN(Wide-character applications must define HAVE_LIBUTF8_H to include curses.h)
+fi
+fi
+WITH_OVERWRITE=$with_overwrite
+
+AC_SUBST(WITH_OVERWRITE)
+AC_SUBST(TICS_LIST)
+AC_SUBST(TINFO_LIST)
+AC_SUBST(SHLIB_LIST)
+
+# used to separate tack out of the tree
+NCURSES_TREE=
+AC_SUBST(NCURSES_TREE)
+
+### predefined stuff for the test programs
+AC_DEFINE(HAVE_SLK_COLOR,1,[Define to 1 if we have slk_color for test-programs])
 
 ### Construct the list of subdirectories for which we'll customize makefiles
 ### with the appropriate compile-rules.
 
 CF_SRC_MODULES($modules_to_build)
 
 ### Construct the list of subdirectories for which we'll customize makefiles
 ### with the appropriate compile-rules.
 
 CF_SRC_MODULES($modules_to_build)
+
+if test "x$cf_with_ada" = "xyes" && test "x$cf_cv_prog_gnat_correct" = "xyes"; then
+   SUB_MAKEFILES="$SUB_MAKEFILES Ada95/gen/adacurses${USE_CFG_SUFFIX}-config:Ada95/gen/adacurses-config.in"
+   SUB_MAKEFILES="$SUB_MAKEFILES man/adacurses${USE_CFG_SUFFIX}-config.1:man/MKada_config.in"
+fi
+
 CF_DIRS_TO_MAKE
 
 CF_DIRS_TO_MAKE
 
+# symbols that differ when compiling Ada95 by itself.
+NCURSES_SHLIB2=$SHELL' $(top_srcdir)/misc/shlib'
+AC_SUBST(NCURSES_SHLIB2)
+
+# values to use as strings
+AC_DEFINE_UNQUOTED(NCURSES_PATHSEP,'$PATH_SEPARATOR',[Define to override ':' as library path-separator])
+
+AC_DEFINE_UNQUOTED(NCURSES_VERSION_STRING, "${NCURSES_MAJOR}.${NCURSES_MINOR}.${NCURSES_PATCH}",[Define to 1 if machine has ample memory for tic])
+
 ### Now that we're done running tests, add the compiler-warnings, if any
 ### Now that we're done running tests, add the compiler-warnings, if any
-CFLAGS="$CFLAGS $EXTRA_CFLAGS"
+CF_ADD_CFLAGS($EXTRA_CFLAGS)
+
+### Define substitutions for header files to avoid name-pollution
+CF_SUBST_IF(["x$cf_cv_have_tcgetattr" = xyes], HAVE_TCGETATTR, 1, 0)
+CF_SUBST_IF(["x$ac_cv_header_stdint_h" = xyes], HAVE_STDINT_H, 1, 0)
+CF_SUBST_IF(["x$ac_cv_header_termio_h" = xyes], HAVE_TERMIO_H, 1, 0)
+CF_SUBST_IF(["x$ac_cv_header_termios_h" = xyes], HAVE_TERMIOS_H, 1, 0)
 
 ################################################################################
 
 ################################################################################
+test "x$use_database" = xyes && \
+SUB_MAKEFILES="$SUB_MAKEFILES misc/run_tic.sh:misc/run_tic.in"
+
+SUB_MAKEFILES="$SUB_MAKEFILES misc/ncurses-config:misc/ncurses-config.in"
+SUB_MAKEFILES="$SUB_MAKEFILES man/ncurses${USE_CFG_SUFFIX}-config.1:man/MKncu_config.in"
+
+if test "x$enable_pc_files" = xyes && test -z "$MAKE_PC_FILES" ; then
+SUB_MAKEFILES="$SUB_MAKEFILES misc/gen-pkgconfig:misc/gen-pkgconfig.in"
+fi
+AC_SUBST(cross_compiling)
+
+AC_PATH_PROG(TIC_PATH,tic,unknown,$PATH:/usr/local/ncurses/bin)
+if test -n "$FALLBACK_LIST"
+then
+       if test "$TIC_PATH" = unknown
+       then
+               AC_MSG_WARN(no tic program found for fallbacks)
+       fi
+fi
+AC_SUBST(TIC_PATH)
+
+if test "x$cf_with_tests" != xno ; then
+       MAKE_TESTS=
+else
+       MAKE_TESTS="#"
+fi
+AC_SUBST(MAKE_TESTS)
+
+ADAHTML_DIR=../../doc/html/ada
+AC_SUBST(ADAHTML_DIR)
+
+# these could be configurable, but are not currently
+PANEL_NAME=panel
+MENU_NAME=menu
+FORM_NAME=form
+CXX_NAME=ncurses++
+
+AC_SUBST(PANEL_NAME)
+AC_SUBST(MENU_NAME)
+AC_SUBST(FORM_NAME)
+AC_SUBST(CXX_NAME)
+
+# workaround for OS/2 (20151017)
+case $cf_cv_system_name in
+(os2*)
+       LIBTOOL_OPTS_CXX="-os2dllname ncurs++"
+       ;;
+(*)
+       LIBTOOL_OPTS_CXX=
+       ;;
+esac
+AC_SUBST(LIBTOOL_OPTS_CXX)
+
+# workaround for g++ versus Solaris (20131116)
+case $cf_cv_system_name in
+(solaris2*)
+       case "x$CPPFLAGS" in
+       (*-D_XOPEN_SOURCE_EXTENDED*)
+               CF_VERBOSE(moving _XOPEN_SOURCE_EXTENDED to work around g++ problem)
+               CFLAGS="$CFLAGS -D_XOPEN_SOURCE_EXTENDED"
+               CPPFLAGS=`echo "x$CPPFLAGS" | sed -e  's/^.//' -e 's/-D_XOPEN_SOURCE_EXTENDED//'`
+               ;;
+       esac
+       ;;
+esac
+
+# Help to automatically enable the extended curses features when using either
+# the *-config or the ".pc" files by adding defines.
+AC_MSG_CHECKING(for defines to add to ncurses${USE_CFG_SUFFIX}-config script)
+PKG_CFLAGS=
+for cf_loop1 in $CPPFLAGS_after_XOPEN
+do
+       cf_found=no
+       for cf_loop2 in $CPPFLAGS_before_XOPEN
+       do
+               if test "x$cf_loop1" = "x$cf_loop2"
+               then
+                       cf_found=yes
+                       break
+               fi
+       done
+       test "$cf_found" = no && PKG_CFLAGS="$PKG_CFLAGS $cf_loop1"
+done
+AC_MSG_RESULT($PKG_CFLAGS)
+AC_SUBST(PKG_CFLAGS)
+
+# AC_CHECK_SIZEOF demands a literal parameter, no variables.  So we do this.
+case "x$NCURSES_OSPEED" in
+(*short*)
+       cf_compatible=1
+       ;;
+(*)
+       cf_compatible=0
+       ;;
+esac
+AC_DEFINE_UNQUOTED(NCURSES_OSPEED_COMPAT,$cf_compatible,[Define to 1 if termcap variable ospeed is short])
+
+case "x$cf_cv_typeof_chtype" in
+(xshort|xint|xlong)
+       cf_cv_typeof_chtype="unsigned $cf_cv_typeof_chtype"
+       ;;
+esac
+
+case "x$cf_cv_typeof_mmask_t" in
+(xshort|xint|xlong)
+       cf_cv_typeof_mmask_t="unsigned $cf_cv_typeof_mmask_t"
+       ;;
+esac
+
+# substitute into misc/Makefile to suppress
+# (un)install.data from the
+# (un)install rules.
+if test "x$cf_with_db_install" = "xno"; then
+       MISC_INSTALL_DATA=
+       MISC_UNINSTALL_DATA=
+else
+       MISC_INSTALL_DATA=install.data
+       MISC_UNINSTALL_DATA=uninstall.data
+fi
+AC_SUBST(MISC_INSTALL_DATA)
+AC_SUBST(MISC_UNINSTALL_DATA)
+
+if test "x$cf_with_db_install" = "xno" || test "x$TERMINFO_SRC" = "xno"; then
+       MAKE_DATABASE="#"
+else
+       MAKE_DATABASE="$MAKE_TERMINFO"
+fi
+AC_SUBST(MAKE_DATABASE)
+
+SUB_SCRIPTS=
+
+dnl Override the package used for exported symbols
+if test -n "$PACKAGE"
+then
+       PACKAGE="${PACKAGE}${DFT_ARG_SUFFIX}"
+       export PACKAGE
+       echo "package: $PACKAGE"
+fi
+
+UNALTERED_SYMS=
+cf_filter_syms=no
+
+if test -n "$RESULTING_SYMS"
+then
+       cf_filter_syms=$cf_dft_filter_syms
+       CF_VERBOSE(will map symbols to ABI=$cf_cv_abi_version)
+fi
+
+if test "x$WILDCARD_SYMS" = xno
+then
+       cf_filter_syms=yes
+fi
+
+test "x$cf_with_trace" = xyes && NCURSES_INLINE=
+
+UNALTERED_SYMS=`echo "$RESULTING_SYMS" | sed -e 's/\\$/\\\\$/g'`
+if test $cf_filter_syms = yes
+then
+       RESULTING_SYMS=resulting.map
+fi
+AC_SUBST(UNALTERED_SYMS)
+
+if test "x$cross_compiling" = xyes ; then
+       ADAGEN_LDFLAGS='$(CROSS_LDFLAGS)'
+       CHECK_BUILD="#"
+else
+       ADAGEN_LDFLAGS='$(NATIVE_LDFLAGS)'
+       CHECK_BUILD=
+fi
+AC_SUBST(ADAGEN_LDFLAGS)
+AC_SUBST(CHECK_BUILD)
+AC_SUBST(PRIVATE_LIBS)
+
+AC_DEFINE(HAVE_CURSES_DATA_BOOLNAMES,1,[definition needed for in-tree build of tack])
+
 AC_OUTPUT( \
        include/MKterm.h.awk \
 AC_OUTPUT( \
        include/MKterm.h.awk \
-       include/curses.h \
+       include/curses.head:include/curses.h.in \
+       include/ncurses_dll.h \
        include/termcap.h \
        include/unctrl.h \
        include/termcap.h \
        include/unctrl.h \
+       $SUB_SCRIPTS \
        $SUB_MAKEFILES \
        Makefile,[
        $SUB_MAKEFILES \
        Makefile,[
-CF_LIB_RULES
+if test "x$cf_with_tests" != xno ; then
+       CF_PRG_RULES([$srcdir/test/mk-test.awk INSTALL=no ECHO_LINK="$ECHO_LD"], test)
+fi
+CF_LIB_RULES($SRC_SUBDIRS)
+
+if test "x$cf_with_ada" = "xyes" && test "x$cf_cv_prog_gnat_correct" = "xyes"; then
+if test -z "$USE_OLD_MAKERULES" ; then
+       $AWK -f $srcdir/Ada95/mk-1st.awk <$srcdir/Ada95/src/modules >>Ada95/src/Makefile
+fi
+fi
 ],[
 ### Special initialization commands, used to pass information from the
 ### configuration-run into config.status
 
 AWK="$AWK"
 ],[
 ### Special initialization commands, used to pass information from the
 ### configuration-run into config.status
 
 AWK="$AWK"
-CF_LIST_MODELS="$cf_list_models"
+ALTERNATE_SYMS="$ALTERNATE_SYMS"
+DFT_ARG_SUFFIX="$DFT_ARG_SUFFIX"
 DFT_LWR_MODEL="$DFT_LWR_MODEL"
 DFT_LWR_MODEL="$DFT_LWR_MODEL"
+ECHO_LD="$ECHO_LD"
+EXTRA_SUFFIX="$EXTRA_SUFFIX"
 LDCONFIG="$LDCONFIG"
 LDCONFIG="$LDCONFIG"
+LIBTOOL_VERSION="$LIBTOOL_VERSION"
 LIB_NAME="$LIB_NAME"
 LIB_NAME="$LIB_NAME"
+LIB_PREFIX="$LIB_PREFIX"
 LIB_SUBSETS="$LIB_SUBSETS"
 LIB_SUBSETS="$LIB_SUBSETS"
+LIB_SUFFIX="$LIB_SUFFIX"
+LIB_TRACING="$LIB_TRACING"
+LN_S="$LN_S"
+MAKE_TERMINFO="$MAKE_TERMINFO"
+NCURSES_MAJOR="$NCURSES_MAJOR"
+NCURSES_MINOR="$NCURSES_MINOR"
+NCURSES_OSPEED="$NCURSES_OSPEED"
+NCURSES_PATCH="$NCURSES_PATCH"
 SRC_SUBDIRS="$SRC_SUBDIRS"
 SRC_SUBDIRS="$SRC_SUBDIRS"
+TERMINFO="$TERMINFO"
+TICS_ARG_SUFFIX="$TICS_ARG_SUFFIX"
+TICS_LIB_SUFFIX="$TICS_LIB_SUFFIX"
+TICS_NAME="$TICS_NAME"
+TICS_SUFFIX="$TICS_SUFFIX"
+TIC_PATH="$TIC_PATH"
+TINFO_ARG_SUFFIX="$TINFO_ARG_SUFFIX"
+TINFO_LIB_SUFFIX="$TINFO_LIB_SUFFIX"
 TINFO_NAME="$TINFO_NAME"
 TINFO_NAME="$TINFO_NAME"
-WITH_ECHO="$with_echo"
+TINFO_SUFFIX="$TINFO_SUFFIX"
+UNALTERED_SYMS="$UNALTERED_SYMS"
+USE_ARG_SUFFIX="$USE_ARG_SUFFIX"
+USE_CFG_SUFFIX="$USE_CFG_SUFFIX"
+USE_LIB_SUFFIX="$USE_LIB_SUFFIX"
+USE_OLD_MAKERULES="$USE_OLD_MAKERULES"
+WILDCARD_SYMS="$WILDCARD_SYMS"
+WITH_CURSES_H="$with_curses_h"
+WITH_ECHO="${enable_echo:=yes}"
 WITH_OVERWRITE="$with_overwrite"
 WITH_OVERWRITE="$with_overwrite"
+cf_LIST_MODELS="$cf_list_models"
 cf_cv_abi_version="$cf_cv_abi_version"
 cf_cv_abi_version="$cf_cv_abi_version"
+cf_cv_do_relink="$cf_cv_do_relink"
+cf_cv_do_reranlib="$cf_cv_do_reranlib"
 cf_cv_do_symlinks="$cf_cv_do_symlinks"
 cf_cv_do_symlinks="$cf_cv_do_symlinks"
+cf_cv_enable_lp64="$cf_cv_enable_lp64"
+cf_cv_enable_opaque="$cf_cv_enable_opaque"
+cf_cv_prog_CC_c_o=$cf_cv_prog_CC_c_o
+cf_cv_prog_CXX_c_o=$cf_cv_prog_CXX_c_o
+cf_cv_prog_gnat_correct=$cf_cv_prog_gnat_correct
 cf_cv_rel_version="$cf_cv_rel_version"
 cf_cv_rm_so_locs="$cf_cv_rm_so_locs"
 cf_cv_rel_version="$cf_cv_rel_version"
 cf_cv_rm_so_locs="$cf_cv_rm_so_locs"
+cf_cv_shared_soname='$cf_cv_shared_soname'
+cf_cv_shlib_version="$cf_cv_shlib_version"
+cf_cv_shlib_version_infix="$cf_cv_shlib_version_infix"
 cf_cv_system_name="$cf_cv_system_name"
 cf_cv_system_name="$cf_cv_system_name"
+cf_cv_term_driver="$with_term_driver"
+cf_with_ada="$cf_with_ada"
 cf_with_cxx_binding="$cf_with_cxx_binding"
 cf_with_cxx_binding="$cf_with_cxx_binding"
+cf_with_db_install="$cf_with_db_install"
+cf_with_manpages="$cf_with_manpages"
+cf_with_tests="$cf_with_tests"
+host="$host"
 target="$target"
 target="$target"
+with_shared_cxx="$with_shared_cxx"
 
 
-],sort)dnl
-${MAKE-make} preinstall
+],cat)dnl
+${MAKE:-make} preinstall