ncurses 5.9 - patch 20150307
[ncurses.git] / test / aclocal.m4
index 47928a057bf1751ba11232d18655f9d0e8a1d683..a9a5045d3807a28ef8cd097de7251411d636dfab 100644 (file)
-dnl $Id: aclocal.m4,v 1.6 2003/10/19 00:09:23 tom Exp $
+dnl***************************************************************************
+dnl Copyright (c) 2003-2013,2014 Free Software Foundation, Inc.              *
+dnl                                                                          *
+dnl Permission is hereby granted, free of charge, to any person obtaining a  *
+dnl copy of this software and associated documentation files (the            *
+dnl "Software"), to deal in the Software without restriction, including      *
+dnl without limitation the rights to use, copy, modify, merge, publish,      *
+dnl distribute, distribute with modifications, sublicense, and/or sell       *
+dnl copies of the Software, and to permit persons to whom the Software is    *
+dnl furnished to do so, subject to the following conditions:                 *
+dnl                                                                          *
+dnl The above copyright notice and this permission notice shall be included  *
+dnl in all copies or substantial portions of the Software.                   *
+dnl                                                                          *
+dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+dnl THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+dnl                                                                          *
+dnl Except as contained in this notice, the name(s) of the above copyright   *
+dnl holders shall not be used in advertising or otherwise to promote the     *
+dnl sale, use or other dealings in this Software without prior written       *
+dnl authorization.                                                           *
+dnl***************************************************************************
+dnl
+dnl $Id: aclocal.m4,v 1.102 2014/12/06 13:39:47 tom Exp $
+dnl
+dnl Author: Thomas E. Dickey
+dnl
+dnl Macros used in NCURSES test programs auto-configuration script.
+dnl
+dnl These macros are maintained separately from NCURSES.  The copyright on
+dnl this file applies to the aggregation of macros and does not affect use of
+dnl these macros in other applications.
+dnl
+dnl See http://invisible-island.net/autoconf/ for additional information.
+dnl
+dnl ---------------------------------------------------------------------------
+dnl ---------------------------------------------------------------------------
+dnl CF_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49
+dnl ------------------
+dnl Conditionally generate script according to whether we're using a given autoconf.
+dnl
+dnl $1 = version to compare against
+dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
+dnl $3 = code to use if AC_ACVERSION is older than $1.
+define([CF_ACVERSION_CHECK],
+[
+ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
+ifdef([m4_version_compare],
+[m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
+[CF_ACVERSION_COMPARE(
+AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
+AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
+dnl --------------------
+dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
+dnl                      MAJOR2, MINOR2, TERNARY2,
+dnl                      PRINTABLE2, not FOUND, FOUND)
+define([CF_ACVERSION_COMPARE],
+[ifelse(builtin([eval], [$2 < $5]), 1,
+[ifelse([$8], , ,[$8])],
+[ifelse([$9], , ,[$9])])])dnl
 dnl ---------------------------------------------------------------------------
+dnl CF_ADD_CFLAGS version: 11 updated: 2014/07/22 05:32:57
+dnl -------------
+dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
+dnl The second parameter if given makes this macro verbose.
+dnl
+dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
+dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
+dnl confused by the quotes (which require backslashes to keep them usable).
+AC_DEFUN([CF_ADD_CFLAGS],
+[
+cf_fix_cppflags=no
+cf_new_cflags=
+cf_new_cppflags=
+cf_new_extra_cppflags=
+
+for cf_add_cflags in $1
+do
+case $cf_fix_cppflags in
+no)
+       case $cf_add_cflags in #(vi
+       -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi
+               case $cf_add_cflags in
+               -D*)
+                       cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
+
+                       test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
+                               && test -z "${cf_tst_cflags}" \
+                               && cf_fix_cppflags=yes
+
+                       if test $cf_fix_cppflags = yes ; then
+                               cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
+                               continue
+                       elif test "${cf_tst_cflags}" = "\"'" ; then
+                               cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
+                               continue
+                       fi
+                       ;;
+               esac
+               case "$CPPFLAGS" in
+               *$cf_add_cflags) #(vi
+                       ;;
+               *) #(vi
+                       case $cf_add_cflags in #(vi
+                       -D*)
+                               cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
+                               CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
+                               ;;
+                       esac
+                       cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
+                       ;;
+               esac
+               ;;
+       *)
+               cf_new_cflags="$cf_new_cflags $cf_add_cflags"
+               ;;
+       esac
+       ;;
+yes)
+       cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
+
+       cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
+
+       test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
+               && test -z "${cf_tst_cflags}" \
+               && cf_fix_cppflags=no
+       ;;
+esac
+done
+
+if test -n "$cf_new_cflags" ; then
+       ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
+       CFLAGS="$CFLAGS $cf_new_cflags"
+fi
+
+if test -n "$cf_new_cppflags" ; then
+       ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
+       CPPFLAGS="$CPPFLAGS $cf_new_cppflags"
+fi
+
+if test -n "$cf_new_extra_cppflags" ; then
+       ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
+       EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
+fi
+
+AC_SUBST(EXTRA_CPPFLAGS)
+
+])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_ADD_INCDIR version: 4 updated: 2002/12/21 14:25:52
+dnl CF_ADD_INCDIR version: 13 updated: 2010/05/26 16:44:57
 dnl -------------
 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it's
 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
 dnl but old versions (and some misinstalled ones) need that.  To make things
-dnl worse, gcc 3.x gives error messages if -I/usr/local/include is added to
+dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
 dnl the include-path).
 AC_DEFUN([CF_ADD_INCDIR],
 [
-for cf_add_incdir in $1
-do
-       while true
+if test -n "$1" ; then
+  for cf_add_incdir in $1
+  do
+       while test $cf_add_incdir != /usr/include
        do
-               case $cf_add_incdir in
-               /usr/include) # (vi
-                       ;;
-               /usr/local/include) # (vi
+         if test -d $cf_add_incdir
+         then
+               cf_have_incdir=no
+               if test -n "$CFLAGS$CPPFLAGS" ; then
+                 # a loop is needed to ensure we can add subdirs of existing dirs
+                 for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
+                       if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
+                         cf_have_incdir=yes; break
+                       fi
+                 done
+               fi
+
+               if test "$cf_have_incdir" = no ; then
+                 if test "$cf_add_incdir" = /usr/local/include ; then
                        if test "$GCC" = yes
                        then
-                               cf_save_CPPFLAGS="$CPPFLAGS"
-                               CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
-                               AC_TRY_COMPILE([#include <stdio.h>],
-                                               [printf("Hello")],
-                                               [],
-                                               [CPPFLAGS="$cf_save_CPPFLAGS"])
+                         cf_save_CPPFLAGS=$CPPFLAGS
+                         CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
+                         AC_TRY_COMPILE([#include <stdio.h>],
+                                 [printf("Hello")],
+                                 [],
+                                 [cf_have_incdir=yes])
+                         CPPFLAGS=$cf_save_CPPFLAGS
                        fi
-                       ;;
-               *) # (vi
-                       CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
-                       ;;
-               esac
-               cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
-               test "$cf_top_incdir" = "$cf_add_incdir" && break
-               cf_add_incdir="$cf_top_incdir"
+                 fi
+               fi
+
+               if test "$cf_have_incdir" = no ; then
+                 CF_VERBOSE(adding $cf_add_incdir to include-path)
+                 ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
+
+                 cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
+                 test "$cf_top_incdir" = "$cf_add_incdir" && break
+                 cf_add_incdir="$cf_top_incdir"
+               else
+                 break
+               fi
+         fi
+       done
+  done
+fi
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
+dnl ----------
+dnl Add a library, used to enforce consistency.
+dnl
+dnl $1 = library to add, without the "-l"
+dnl $2 = variable to update (default $LIBS)
+AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_ADD_LIBDIR version: 9 updated: 2010/05/26 16:44:57
+dnl -------------
+dnl    Adds to the library-path
+dnl
+dnl    Some machines have trouble with multiple -L options.
+dnl
+dnl $1 is the (list of) directory(s) to add
+dnl $2 is the optional name of the variable to update (default LDFLAGS)
+dnl
+AC_DEFUN([CF_ADD_LIBDIR],
+[
+if test -n "$1" ; then
+  for cf_add_libdir in $1
+  do
+    if test $cf_add_libdir = /usr/lib ; then
+      :
+    elif test -d $cf_add_libdir
+    then
+      cf_have_libdir=no
+      if test -n "$LDFLAGS$LIBS" ; then
+        # a loop is needed to ensure we can add subdirs of existing dirs
+        for cf_test_libdir in $LDFLAGS $LIBS ; do
+          if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
+            cf_have_libdir=yes; break
+          fi
+        done
+      fi
+      if test "$cf_have_libdir" = no ; then
+        CF_VERBOSE(adding $cf_add_libdir to library-path)
+        ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
+      fi
+    fi
+  done
+fi
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_ADD_LIBS version: 2 updated: 2014/07/13 14:33:27
+dnl -----------
+dnl Add one or more libraries, used to enforce consistency.  Libraries are
+dnl prepended to an existing list, since their dependencies are assumed to
+dnl already exist in the list.
+dnl
+dnl $1 = libraries to add, with the "-l", etc.
+dnl $2 = variable to update (default $LIBS)
+AC_DEFUN([CF_ADD_LIBS],[
+cf_add_libs="$1"
+# Filter out duplicates - this happens with badly-designed ".pc" files...
+for cf_add_1lib in [$]ifelse($2,,LIBS,[$2])
+do
+       for cf_add_2lib in $cf_add_libs
+       do
+               if test "x$cf_add_1lib" = "x$cf_add_2lib"
+               then
+                       cf_add_1lib=
+                       break
+               fi
        done
+       test -n "$cf_add_1lib" && cf_add_libs="$cf_add_libs $cf_add_1lib"
 done
+ifelse($2,,LIBS,[$2])="$cf_add_libs"
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_ADD_LIB_AFTER version: 3 updated: 2013/07/09 21:27:22
+dnl ----------------
+dnl Add a given library after another, e.g., following the one it satisfies a
+dnl dependency for.
+dnl
+dnl $1 = the first library
+dnl $2 = its dependency
+AC_DEFUN([CF_ADD_LIB_AFTER],[
+CF_VERBOSE(...before $LIBS)
+LIBS=`echo "$LIBS" | sed -e "s/[[      ]][[    ]]*/ /g" -e "s%$1 %$1 $2 %" -e 's%  % %g'`
+CF_VERBOSE(...after  $LIBS)
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_ADD_SUBDIR_PATH version: 4 updated: 2013/10/08 17:47:05
+dnl ------------------
+dnl Append to a search-list for a nonstandard header/lib-file
+dnl    $1 = the variable to return as result
+dnl    $2 = the package name
+dnl    $3 = the subdirectory, e.g., bin, include or lib
+dnl $4 = the directory under which we will test for subdirectories
+dnl $5 = a directory that we do not want $4 to match
+AC_DEFUN([CF_ADD_SUBDIR_PATH],
+[
+test "x$4" != "x$5" && \
+test -d "$4" && \
+ifelse([$5],NONE,,[(test -z "$5" || test x$5 = xNONE || test "x$4" != "x$5") &&]) {
+       test -n "$verbose" && echo "    ... testing for $3-directories under $4"
+       test -d $4/$3 &&          $1="[$]$1 $4/$3"
+       test -d $4/$3/$2 &&       $1="[$]$1 $4/$3/$2"
+       test -d $4/$3/$2/$3 &&    $1="[$]$1 $4/$3/$2/$3"
+       test -d $4/$2/$3 &&       $1="[$]$1 $4/$2/$3"
+       test -d $4/$2/$3/$2 &&    $1="[$]$1 $4/$2/$3/$2"
+}
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
+dnl --------------
+dnl Allow user to disable a normally-on option.
+AC_DEFUN([CF_ARG_DISABLE],
+[CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31
+dnl -------------
+dnl Allow user to enable a normally-off option.
+AC_DEFUN([CF_ARG_ENABLE],
+[CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_ARG_OPTION version: 4 updated: 2010/05/26 05:38:42
+dnl -------------
+dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
+dnl values.
+dnl
+dnl Parameters:
+dnl $1 = option name
+dnl $2 = help-string
+dnl $3 = action to perform if option is not default
+dnl $4 = action if perform if option is default
+dnl $5 = default option value (either 'yes' or 'no')
+AC_DEFUN([CF_ARG_OPTION],
+[AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
+  if test "$enableval" != "$5" ; then
+ifelse([$3],,[    :]dnl
+,[    $3]) ifelse([$4],,,[
+  else
+    $4])
+  fi],[enableval=$5 ifelse([$4],,,[
+  $4
+])dnl
+  ])])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_CC_ENV_FLAGS version: 1 updated: 2012/10/03 05:25:49
+dnl ---------------
+dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
+dnl into CC.  This will not help with broken scripts that wrap the compiler with
+dnl options, but eliminates a more common category of user confusion.
+AC_DEFUN([CF_CC_ENV_FLAGS],
+[
+# This should have been defined by AC_PROG_CC
+: ${CC:=cc}
+
+AC_MSG_CHECKING(\$CC variable)
+case "$CC" in #(vi
+*[[\ \ ]]-[[IUD]]*)
+       AC_MSG_RESULT(broken)
+       AC_MSG_WARN(your environment misuses the CC variable to hold CFLAGS/CPPFLAGS options)
+       # humor him...
+       cf_flags=`echo "$CC" | sed -e 's/^[[^   ]]*[[   ]]//'`
+       CC=`echo "$CC" | sed -e 's/[[   ]].*//'`
+       CF_ADD_CFLAGS($cf_flags)
+       ;;
+*)
+       AC_MSG_RESULT(ok)
+       ;;
+esac
 ])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_CHECK_CACHE version: 7 updated: 2001/12/19 00:50:10
+dnl CF_CHECK_CACHE version: 12 updated: 2012/10/02 20:55:03
 dnl --------------
 dnl Check if we're accidentally using a cache from a different machine.
 dnl Derive the system name, as a check for reusing the autoconf cache.
@@ -48,9 +386,12 @@ dnl If we've packaged config.guess and config.sub, run that (since it does a
 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
 dnl which is useful in cross-compiles.
+dnl
+dnl Note: we would use $ac_config_sub, but that is one of the places where
+dnl autoconf 2.5x broke compatibility with autoconf 2.13
 AC_DEFUN([CF_CHECK_CACHE],
 [
-if test -f $srcdir/config.guess ; then
+if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
        ifelse([$1],,[AC_CANONICAL_HOST],[$1])
        system_name="$host_os"
 else
@@ -59,7 +400,7 @@ else
                system_name="`(hostname) 2>/dev/null`"
        fi
 fi
-test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name")
+test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
 
 test -z "$system_name" && system_name="$cf_cv_system_name"
@@ -67,53 +408,167 @@ test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name
 
 if test ".$system_name" != ".$cf_cv_system_name" ; then
        AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
-       AC_ERROR("Please remove config.cache and try again.")
+       AC_MSG_ERROR("Please remove config.cache and try again.")
+fi
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_CHECK_CFLAGS version: 3 updated: 2014/07/22 05:32:57
+dnl ---------------
+dnl Conditionally add to $CFLAGS and $CPPFLAGS values which are derived from
+dnl a build-configuration such as imake.  These have the pitfall that they
+dnl often contain compiler-specific options which we cannot use, mixed with
+dnl preprocessor options that we usually can.
+AC_DEFUN([CF_CHECK_CFLAGS],
+[
+CF_VERBOSE(checking additions to CFLAGS)
+cf_check_cflags="$CFLAGS"
+cf_check_cppflags="$CPPFLAGS"
+CF_ADD_CFLAGS($1,yes)
+if test "x$cf_check_cflags" != "x$CFLAGS" ; then
+AC_TRY_LINK([#include <stdio.h>],[printf("Hello world");],,
+       [CF_VERBOSE(test-compile failed.  Undoing change to \$CFLAGS)
+        if test "x$cf_check_cppflags" != "x$CPPFLAGS" ; then
+                CF_VERBOSE(but keeping change to \$CPPFLAGS)
+        fi
+        CFLAGS="$cf_check_flags"])
 fi
 ])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_CURSES_ACS_MAP version: 3 updated: 2003/05/17 22:19:02
+dnl CF_CLANG_COMPILER version: 2 updated: 2013/11/19 19:23:35
+dnl -----------------
+dnl Check if the given compiler is really clang.  clang's C driver defines
+dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
+dnl not ignore some gcc options.
+dnl
+dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
+dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
+dnl the wrappers for gcc and g++ warnings.
+dnl
+dnl $1 = GCC (default) or GXX
+dnl $2 = CLANG_COMPILER (default)
+dnl $3 = CFLAGS (default) or CXXFLAGS
+AC_DEFUN([CF_CLANG_COMPILER],[
+ifelse([$2],,CLANG_COMPILER,[$2])=no
+
+if test "$ifelse([$1],,[$1],GCC)" = yes ; then
+       AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
+       cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
+       ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -Qunused-arguments"
+       AC_TRY_COMPILE([],[
+#ifdef __clang__
+#else
+make an error
+#endif
+],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
+cf_save_CFLAGS="$cf_save_CFLAGS -Qunused-arguments"
+],[])
+       ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
+       AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
+fi
+])
+dnl ---------------------------------------------------------------------------
+dnl CF_CURSES_ACS_MAP version: 7 updated: 2012/10/06 16:39:58
 dnl -----------------
 dnl Check for likely values of acs_map[]:
 AC_DEFUN([CF_CURSES_ACS_MAP],
 [
+AC_REQUIRE([CF_NCURSES_WRAP_PREFIX])dnl
 AC_CACHE_CHECK(for alternate character set array, cf_cv_curses_acs_map,[
 cf_cv_curses_acs_map=unknown
-for name in acs_map _acs_map __acs_map _nc_acs_map
+for name in acs_map _acs_map __acs_map ${NCURSES_WRAP_PREFIX}acs_map
 do
 AC_TRY_LINK([
-#include <${cf_cv_ncurses_header-curses.h}>
+#include <${cf_cv_ncurses_header:-curses.h}>
 ],[
 $name['k'] = ACS_PLUS
 ],[cf_cv_curses_acs_map=$name; break])
 done
 ])
 
-test "$cf_cv_curses_acs_map" != unknown && AC_DEFINE_UNQUOTED(CURSES_ACS_ARRAY,$cf_cv_curses_acs_map)
+test "$cf_cv_curses_acs_map" != unknown && AC_DEFINE_UNQUOTED(CURSES_ACS_ARRAY,$cf_cv_curses_acs_map,[Define as needed to override ncurses prefix _nc_])
+])
+dnl ---------------------------------------------------------------------------
+dnl CF_CURSES_CHECK_DATA version: 5 updated: 2014/07/19 18:41:17
+dnl --------------------
+dnl Check if curses.h defines the given data/variable.
+dnl Use this after CF_NCURSES_CONFIG or CF_CURSES_CONFIG.
+AC_DEFUN([CF_CURSES_CHECK_DATA],
+[
+AC_MSG_CHECKING(for data $1 declaration in ${cf_cv_ncurses_header:-curses.h})
+
+AC_TRY_COMPILE(CF__CURSES_HEAD,[
+void *foo = &($1)
+],cf_result=yes,cf_result=no)
+AC_MSG_RESULT($cf_result)
+
+if test $cf_result = yes ; then
+       CF_UPPER(cf_result,have_curses_data_$1)
+       AC_DEFINE_UNQUOTED($cf_result)
+else
+       AC_MSG_CHECKING(for data $1 in library)
+       # BSD linkers insist on making weak linkage, but resolve at runtime.
+       AC_TRY_RUN(CF__CURSES_HEAD
+[
+extern char $1;
+int main(void)
+{
+       void *foo = &($1);
+       fprintf(stderr, "testing linkage of $1:%p\n", foo);
+       ${cf_cv_main_return:-return}(foo == 0);
+}],[cf_result=yes],[cf_result=no],[
+       # cross-compiling
+       AC_TRY_LINK(CF__CURSES_HEAD
+[extern char $1;],[
+       do {
+               void *foo = &($1);
+               fprintf(stderr, "testing linkage of $1:%p\n", foo);
+               ${cf_cv_main_return:-return}(foo == 0);
+       } while (0)
+],[cf_result=yes],[cf_result=no])
 ])
+       AC_MSG_RESULT($cf_result)
+       if test $cf_result = yes ; then
+               CF_UPPER(cf_result,decl_curses_data_$1)
+               AC_DEFINE_UNQUOTED($cf_result)
+       fi
+fi
+])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_CURSES_CHECK_TYPE version: 2 updated: 2003/03/01 23:40:33
+dnl CF_CURSES_CHECK_TYPE version: 4 updated: 2012/10/06 16:39:58
 dnl --------------------
 dnl Check if curses.h defines the given type
 AC_DEFUN([CF_CURSES_CHECK_TYPE],
 [
-AC_MSG_CHECKING(for type $1 in ${cf_cv_ncurses_header-curses.h})
+AC_MSG_CHECKING(for type $1 in ${cf_cv_ncurses_header:-curses.h})
 AC_TRY_COMPILE([
 #ifndef _XOPEN_SOURCE_EXTENDED
 #define _XOPEN_SOURCE_EXTENDED
 #endif
-#include <${cf_cv_ncurses_header-curses.h}>],[
+#include <${cf_cv_ncurses_header:-curses.h}>],[
 $1 foo
 ],cf_result=yes,cf_result=no)
 AC_MSG_RESULT($cf_result)
 if test $cf_result = yes ; then
        CF_UPPER(cf_result,have_type_$1)
-       AC_DEFINE_UNQUOTED($cf_result)
+       AC_DEFINE_UNQUOTED($cf_result,1,[Define to 1 if we have type $1])
 else
-       AC_DEFINE_UNQUOTED($1,$2)
+       AC_DEFINE_UNQUOTED($1,$2,[Define to appropriate type if $1 is not declared])
 fi
 ])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_CURSES_CPPFLAGS version: 7 updated: 2003/06/06 00:48:41
+dnl CF_CURSES_CONFIG version: 2 updated: 2006/10/29 11:06:27
+dnl ----------------
+dnl Tie together the configure-script macros for curses.  It may be ncurses,
+dnl but unless asked, we do not make a special search for ncurses.  However,
+dnl still check for the ncurses version number, for use in other macros.
+AC_DEFUN([CF_CURSES_CONFIG],
+[
+CF_CURSES_CPPFLAGS
+CF_NCURSES_VERSION
+CF_CURSES_LIBS
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_CURSES_CPPFLAGS version: 11 updated: 2011/04/09 14:51:08
 dnl ------------------
 dnl Look for the curses headers.
 AC_DEFUN([CF_CURSES_CPPFLAGS],[
@@ -121,26 +576,83 @@ AC_DEFUN([CF_CURSES_CPPFLAGS],[
 AC_CACHE_CHECK(for extra include directories,cf_cv_curses_incdir,[
 cf_cv_curses_incdir=no
 case $host_os in #(vi
-hpux10.*|hpux11.*) #(vi
-       test -d /usr/include/curses_colr && \
-       cf_cv_curses_incdir="-I/usr/include/curses_colr"
+hpux10.*) #(vi
+       if test "x$cf_cv_screen" = "xcurses_colr"
+       then
+               test -d /usr/include/curses_colr && \
+               cf_cv_curses_incdir="-I/usr/include/curses_colr"
+       fi
        ;;
 sunos3*|sunos4*)
-       test -d /usr/5lib && \
-       test -d /usr/5include && \
-       cf_cv_curses_incdir="-I/usr/5include"
+       if test "x$cf_cv_screen" = "xcurses_5lib"
+       then
+               test -d /usr/5lib && \
+               test -d /usr/5include && \
+               cf_cv_curses_incdir="-I/usr/5include"
+       fi
        ;;
 esac
 ])
-test "$cf_cv_curses_incdir" != no && CPPFLAGS="$cf_cv_curses_incdir $CPPFLAGS"
+test "$cf_cv_curses_incdir" != no && CPPFLAGS="$CPPFLAGS $cf_cv_curses_incdir"
 
+CF_CURSES_HEADER
+CF_TERM_HEADER
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_CURSES_FUNCS version: 18 updated: 2014/07/19 18:44:41
+dnl ---------------
+dnl Curses-functions are a little complicated, since a lot of them are macros.
+AC_DEFUN([CF_CURSES_FUNCS],
+[
+AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
+AC_REQUIRE([CF_XOPEN_CURSES])
+AC_REQUIRE([CF_CURSES_TERM_H])
+AC_REQUIRE([CF_CURSES_UNCTRL_H])
+for cf_func in $1
+do
+       CF_UPPER(cf_tr_func,$cf_func)
+       AC_MSG_CHECKING(for ${cf_func})
+       CF_MSG_LOG(${cf_func})
+       AC_CACHE_VAL(cf_cv_func_$cf_func,[
+               eval cf_result='$ac_cv_func_'$cf_func
+               if test ".$cf_result" != ".no"; then
+                       AC_TRY_LINK(CF__CURSES_HEAD,
+                       [
+#ifndef ${cf_func}
+long foo = (long)(&${cf_func});
+fprintf(stderr, "testing linkage of $cf_func:%p\n", foo);
+if (foo + 1234 > 5678)
+       ${cf_cv_main_return:-return}(foo);
+#endif
+                       ],
+                       [cf_result=yes],
+                       [cf_result=no])
+               fi
+               eval 'cf_cv_func_'$cf_func'=$cf_result'
+       ])
+       # use the computed/retrieved cache-value:
+       eval 'cf_result=$cf_cv_func_'$cf_func
+       AC_MSG_RESULT($cf_result)
+       if test $cf_result != no; then
+               AC_DEFINE_UNQUOTED(HAVE_${cf_tr_func})
+       fi
+done
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_CURSES_HEADER version: 3 updated: 2011/05/01 19:47:45
+dnl ----------------
+dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
+dnl variations of ncurses' installs.
+dnl
+dnl $1 = ncurses when looking for ncurses, or is empty
+AC_DEFUN([CF_CURSES_HEADER],[
 AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[
 cf_cv_ncurses_header=none
-for cf_header in \
-       curses.h \
+for cf_header in ifelse($1,,,[ \
+    $1/ncurses.h \
+       $1/curses.h]) \
        ncurses.h \
-       ncurses/curses.h \
-       ncurses/ncurses.h
+       curses.h ifelse($1,,[ncurses/ncurses.h ncurses/curses.h])
 do
 AC_TRY_COMPILE([#include <${cf_header}>],
        [initscr(); tgoto("?", 0,0)],
@@ -154,55 +666,77 @@ fi
 
 # cheat, to get the right #define's for HAVE_NCURSES_H, etc.
 AC_CHECK_HEADERS($cf_cv_ncurses_header)
-
 ])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_CURSES_LIBS version: 22 updated: 2002/10/27 18:21:42
+dnl CF_CURSES_LIBS version: 37 updated: 2013/02/09 17:33:50
 dnl --------------
 dnl Look for the curses libraries.  Older curses implementations may require
 dnl termcap/termlib to be linked as well.  Call CF_CURSES_CPPFLAGS first.
 AC_DEFUN([CF_CURSES_LIBS],[
 
+AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
 AC_MSG_CHECKING(if we have identified curses libraries)
-AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>],
-       [initscr(); tgoto("?", 0,0)],
-       cf_result=yes,
-       cf_result=no)
+AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
+    [initscr(); tgoto("?", 0,0)],
+    cf_result=yes,
+    cf_result=no)
 AC_MSG_RESULT($cf_result)
 
 if test "$cf_result" = no ; then
 case $host_os in #(vi
 freebsd*) #(vi
-       AC_CHECK_LIB(mytinfo,tgoto,[LIBS="-lmytinfo $LIBS"])
-       ;;
-hpux10.*|hpux11.*) #(vi
-       AC_CHECK_LIB(cur_colr,initscr,[
-               LIBS="-lcur_colr $LIBS"
-               ac_cv_func_initscr=yes
-               ],[
-       AC_CHECK_LIB(Hcurses,initscr,[
-               # HP's header uses __HP_CURSES, but user claims _HP_CURSES.
-               LIBS="-lHcurses $LIBS"
-               CPPFLAGS="-D__HP_CURSES -D_HP_CURSES $CPPFLAGS"
-               ac_cv_func_initscr=yes
-               ])])
-       ;;
-linux*) # Suse Linux does not follow /usr/lib convention
-       LIBS="$LIBS -L/lib"
+    AC_CHECK_LIB(mytinfo,tgoto,[CF_ADD_LIBS(-lmytinfo)])
+    ;;
+hpux10.*) #(vi
+       # Looking at HPUX 10.20, the Hcurses library is the oldest (1997), cur_colr
+       # next (1998), and xcurses "newer" (2000).  There is no header file for
+       # Hcurses; the subdirectory curses_colr has the headers (curses.h and
+       # term.h) for cur_colr
+       if test "x$cf_cv_screen" = "xcurses_colr"
+       then
+               AC_CHECK_LIB(cur_colr,initscr,[
+                       CF_ADD_LIBS(-lcur_colr)
+                       ac_cv_func_initscr=yes
+                       ],[
+               AC_CHECK_LIB(Hcurses,initscr,[
+                       # HP's header uses __HP_CURSES, but user claims _HP_CURSES.
+                       CF_ADD_LIBS(-lHcurses)
+                       CPPFLAGS="$CPPFLAGS -D__HP_CURSES -D_HP_CURSES"
+                       ac_cv_func_initscr=yes
+                       ])])
+       fi
        ;;
-sunos3*|sunos4*)
-       test -d /usr/5lib && \
-       LIBS="$LIBS -L/usr/5lib -lcurses -ltermcap"
-       ac_cv_func_initscr=yes
+linux*)
+       case `arch 2>/dev/null` in
+       x86_64)
+               if test -d /lib64
+               then
+                       CF_ADD_LIBDIR(/lib64)
+               else
+                       CF_ADD_LIBDIR(/lib)
+               fi
+               ;;
+       *)
+               CF_ADD_LIBDIR(/lib)
+               ;;
+       esac
        ;;
+sunos3*|sunos4*)
+       if test "x$cf_cv_screen" = "xcurses_5lib"
+       then
+               if test -d /usr/5lib ; then
+                       CF_ADD_LIBDIR(/usr/5lib)
+                       CF_ADD_LIBS(-lcurses -ltermcap)
+               fi
+    fi
+    ac_cv_func_initscr=yes
+    ;;
 esac
 
 if test ".$ac_cv_func_initscr" != .yes ; then
        cf_save_LIBS="$LIBS"
-       cf_term_lib=""
-       cf_curs_lib=""
 
-       if test ".${cf_cv_ncurses_version-no}" != .no
+       if test ".${cf_cv_ncurses_version:-no}" != .no
        then
                cf_check_list="ncurses curses cursesX"
        else
@@ -211,40 +745,46 @@ if test ".$ac_cv_func_initscr" != .yes ; then
 
        # Check for library containing tgoto.  Do this before curses library
        # because it may be needed to link the test-case for initscr.
-       AC_CHECK_FUNC(tgoto,[cf_term_lib=predefined],[
-               for cf_term_lib in $cf_check_list termcap termlib unknown
-               do
-                       AC_CHECK_LIB($cf_term_lib,tgoto,[break])
-               done
-       ])
+       if test "x$cf_term_lib" = x
+       then
+               AC_CHECK_FUNC(tgoto,[cf_term_lib=predefined],[
+                       for cf_term_lib in $cf_check_list otermcap termcap tinfo termlib unknown
+                       do
+                               AC_CHECK_LIB($cf_term_lib,tgoto,[break])
+                       done
+               ])
+       fi
 
        # Check for library containing initscr
        test "$cf_term_lib" != predefined && test "$cf_term_lib" != unknown && LIBS="-l$cf_term_lib $cf_save_LIBS"
-       for cf_curs_lib in $cf_check_list xcurses jcurses unknown
-       do
-               AC_CHECK_LIB($cf_curs_lib,initscr,[break])
-       done
-       test $cf_curs_lib = unknown && AC_ERROR(no curses library found)
+       if test "x$cf_curs_lib" = x
+       then
+               for cf_curs_lib in $cf_check_list xcurses jcurses pdcurses unknown
+               do
+                       AC_CHECK_LIB($cf_curs_lib,initscr,[break])
+               done
+       fi
+       test $cf_curs_lib = unknown && AC_MSG_ERROR(no curses library found)
 
        LIBS="-l$cf_curs_lib $cf_save_LIBS"
        if test "$cf_term_lib" = unknown ; then
                AC_MSG_CHECKING(if we can link with $cf_curs_lib library)
-               AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>],
+               AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
                        [initscr()],
                        [cf_result=yes],
                        [cf_result=no])
                AC_MSG_RESULT($cf_result)
-               test $cf_result = no && AC_ERROR(Cannot link curses library)
+               test $cf_result = no && AC_MSG_ERROR(Cannot link curses library)
        elif test "$cf_curs_lib" = "$cf_term_lib" ; then
                :
        elif test "$cf_term_lib" != predefined ; then
                AC_MSG_CHECKING(if we need both $cf_curs_lib and $cf_term_lib libraries)
-               AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>],
+               AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
                        [initscr(); tgoto((char *)0, 0, 0);],
                        [cf_result=no],
                        [
                        LIBS="-l$cf_curs_lib -l$cf_term_lib $cf_save_LIBS"
-                       AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>],
+                       AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
                                [initscr()],
                                [cf_result=yes],
                                [cf_result=error])
@@ -256,32 +796,293 @@ fi
 
 ])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_CURSES_WACS_MAP version: 3 updated: 2003/05/17 22:19:02
+dnl CF_CURSES_TERM_H version: 10 updated: 2012/10/06 08:57:51
+dnl ----------------
+dnl SVr4 curses should have term.h as well (where it puts the definitions of
+dnl the low-level interface).  This may not be true in old/broken implementations,
+dnl as well as in misconfigured systems (e.g., gcc configured for Solaris 2.4
+dnl running with Solaris 2.5.1).
+AC_DEFUN([CF_CURSES_TERM_H],
+[
+AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
+
+AC_CACHE_CHECK(for term.h, cf_cv_term_header,[
+
+# If we found <ncurses/curses.h>, look for <ncurses/term.h>, but always look
+# for <term.h> if we do not find the variant.
+
+cf_header_list="term.h ncurses/term.h ncursesw/term.h"
+
+case ${cf_cv_ncurses_header:-curses.h} in #(vi
+*/*)
+       cf_header_item=`echo ${cf_cv_ncurses_header:-curses.h} | sed -e 's%\..*%%' -e 's%/.*%/%'`term.h
+       cf_header_list="$cf_header_item $cf_header_list"
+       ;;
+esac
+
+for cf_header in $cf_header_list
+do
+       AC_TRY_COMPILE([
+#include <${cf_cv_ncurses_header:-curses.h}>
+#include <${cf_header}>],
+       [WINDOW *x],
+       [cf_cv_term_header=$cf_header
+        break],
+       [cf_cv_term_header=no])
+done
+
+case $cf_cv_term_header in #(vi
+no)
+       # If curses is ncurses, some packagers still mess it up by trying to make
+       # us use GNU termcap.  This handles the most common case.
+       for cf_header in ncurses/term.h ncursesw/term.h
+       do
+               AC_TRY_COMPILE([
+#include <${cf_cv_ncurses_header:-curses.h}>
+#ifdef NCURSES_VERSION
+#include <${cf_header}>
+#else
+make an error
+#endif],
+                       [WINDOW *x],
+                       [cf_cv_term_header=$cf_header
+                        break],
+                       [cf_cv_term_header=no])
+       done
+       ;;
+esac
+])
+
+case $cf_cv_term_header in #(vi
+term.h) #(vi
+       AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
+       ;;
+ncurses/term.h) #(vi
+       AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
+       ;;
+ncursesw/term.h)
+       AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
+       ;;
+esac
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_CURSES_UNCTRL_H version: 3 updated: 2013/11/03 06:26:10
+dnl ------------------
+dnl Any X/Open curses implementation must have unctrl.h, but ncurses packages
+dnl may put it in a subdirectory (along with ncurses' other headers, of
+dnl course).  Packages which put the headers in inconsistent locations are
+dnl broken).
+AC_DEFUN([CF_CURSES_UNCTRL_H],
+[
+AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
+
+AC_CACHE_CHECK(for unctrl.h, cf_cv_unctrl_header,[
+
+# If we found <ncurses/curses.h>, look for <ncurses/unctrl.h>, but always look
+# for <unctrl.h> if we do not find the variant.
+
+cf_header_list="unctrl.h ncurses/unctrl.h ncursesw/unctrl.h"
+
+case ${cf_cv_ncurses_header:-curses.h} in #(vi
+*/*)
+       cf_header_item=`echo ${cf_cv_ncurses_header:-curses.h} | sed -e 's%\..*%%' -e 's%/.*%/%'`unctrl.h
+       cf_header_list="$cf_header_item $cf_header_list"
+       ;;
+esac
+
+for cf_header in $cf_header_list
+do
+       AC_TRY_COMPILE([
+#include <${cf_cv_ncurses_header:-curses.h}>
+#include <${cf_header}>],
+       [WINDOW *x],
+       [cf_cv_unctrl_header=$cf_header
+        break],
+       [cf_cv_unctrl_header=no])
+done
+])
+
+case $cf_cv_unctrl_header in #(vi
+no)
+       AC_MSG_WARN(unctrl.h header not found)
+       ;;
+esac
+
+case $cf_cv_unctrl_header in #(vi
+unctrl.h) #(vi
+       AC_DEFINE(HAVE_UNCTRL_H,1,[Define to 1 if we have unctrl.h])
+       ;;
+ncurses/unctrl.h) #(vi
+       AC_DEFINE(HAVE_NCURSES_UNCTRL_H,1,[Define to 1 if we have ncurses/unctrl.h])
+       ;;
+ncursesw/unctrl.h)
+       AC_DEFINE(HAVE_NCURSESW_UNCTRL_H,1,[Define to 1 if we have ncursesw/unctrl.h])
+       ;;
+esac
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_CURSES_WACS_MAP version: 6 updated: 2012/10/06 08:57:51
 dnl ------------------
-dnl Check for likely values of wacs_map[]:
+dnl Check for likely values of wacs_map[].
 AC_DEFUN([CF_CURSES_WACS_MAP],
 [
 AC_CACHE_CHECK(for wide alternate character set array, cf_cv_curses_wacs_map,[
        cf_cv_curses_wacs_map=unknown
-       for name in wacs_map _wacs_map __wacs_map _nc_wacs
+       for name in wacs_map _wacs_map __wacs_map _nc_wacs _wacs_char
        do
        AC_TRY_LINK([
 #ifndef _XOPEN_SOURCE_EXTENDED
 #define _XOPEN_SOURCE_EXTENDED
 #endif
-#include <${cf_cv_ncurses_header-curses.h}>],
-       [$name['k'] = *WACS_PLUS],
+#include <${cf_cv_ncurses_header:-curses.h}>],
+       [void *foo = &($name['k'])],
        [cf_cv_curses_wacs_map=$name
         break])
        done])
+
+test "$cf_cv_curses_wacs_map" != unknown && AC_DEFINE_UNQUOTED(CURSES_WACS_ARRAY,$cf_cv_curses_wacs_map,[Define to name of (n)curses wide-character array])
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_CURSES_WACS_SYMBOLS version: 2 updated: 2012/10/06 08:57:51
+dnl ----------------------
+dnl Do a check to see if the WACS_xxx constants are defined compatibly with
+dnl X/Open Curses.  In particular, NetBSD's implementation of the WACS_xxx
+dnl constants is broken since those constants do not point to cchar_t's.
+AC_DEFUN([CF_CURSES_WACS_SYMBOLS],
+[
+AC_REQUIRE([CF_CURSES_WACS_MAP])
+
+AC_CACHE_CHECK(for wide alternate character constants, cf_cv_curses_wacs_symbols,[
+cf_cv_curses_wacs_symbols=no
+if test "$cf_cv_curses_wacs_map" != unknown
+then
+       AC_TRY_LINK([
+#ifndef _XOPEN_SOURCE_EXTENDED
+#define _XOPEN_SOURCE_EXTENDED
+#endif
+#include <${cf_cv_ncurses_header:-curses.h}>],
+       [cchar_t *foo = WACS_PLUS;
+        $cf_cv_curses_wacs_map['k'] = *WACS_PLUS],
+       [cf_cv_curses_wacs_symbols=yes])
+else
+       AC_TRY_LINK([
+#ifndef _XOPEN_SOURCE_EXTENDED
+#define _XOPEN_SOURCE_EXTENDED
+#endif
+#include <${cf_cv_ncurses_header:-curses.h}>],
+       [cchar_t *foo = WACS_PLUS],
+       [cf_cv_curses_wacs_symbols=yes])
+fi
 ])
+
+test "$cf_cv_curses_wacs_symbols" != no && AC_DEFINE(CURSES_WACS_SYMBOLS,1,[Define to 1 if (n)curses supports wide-character WACS_ symbols])
+])dnl
 dnl ---------------------------------------------------------------------------
 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
 dnl ----------
 dnl "dirname" is not portable, so we fake it with a shell script.
 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_FIND_LIBRARY version: 7 updated: 2000/04/13 21:38:04
+dnl CF_DISABLE_ECHO version: 12 updated: 2012/10/06 16:30:28
+dnl ---------------
+dnl You can always use "make -n" to see the actual options, but it's hard to
+dnl pick out/analyze warning messages when the compile-line is long.
+dnl
+dnl Sets:
+dnl    ECHO_LT - symbol to control if libtool is verbose
+dnl    ECHO_LD - symbol to prefix "cc -o" lines
+dnl    RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
+dnl    SHOW_CC - symbol to put before explicit "cc -c" lines
+dnl    ECHO_CC - symbol to put before any "cc" line
+dnl
+AC_DEFUN([CF_DISABLE_ECHO],[
+AC_MSG_CHECKING(if you want to see long compiling messages)
+CF_ARG_DISABLE(echo,
+       [  --disable-echo          do not display "compiling" commands],
+       [
+    ECHO_LT='--silent'
+    ECHO_LD='@echo linking [$]@;'
+    RULE_CC='@echo compiling [$]<'
+    SHOW_CC='@echo compiling [$]@'
+    ECHO_CC='@'
+],[
+    ECHO_LT=''
+    ECHO_LD=''
+    RULE_CC=''
+    SHOW_CC=''
+    ECHO_CC=''
+])
+AC_MSG_RESULT($enableval)
+AC_SUBST(ECHO_LT)
+AC_SUBST(ECHO_LD)
+AC_SUBST(RULE_CC)
+AC_SUBST(SHOW_CC)
+AC_SUBST(ECHO_CC)
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_DISABLE_LEAKS version: 7 updated: 2012/10/02 20:55:03
+dnl ----------------
+dnl Combine no-leak checks with the libraries or tools that are used for the
+dnl checks.
+AC_DEFUN([CF_DISABLE_LEAKS],[
+
+AC_REQUIRE([CF_WITH_DMALLOC])
+AC_REQUIRE([CF_WITH_DBMALLOC])
+AC_REQUIRE([CF_WITH_VALGRIND])
+
+AC_MSG_CHECKING(if you want to perform memory-leak testing)
+AC_ARG_ENABLE(leaks,
+       [  --disable-leaks         test: free permanent memory, analyze leaks],
+       [if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi],
+       : ${with_no_leaks:=no})
+AC_MSG_RESULT($with_no_leaks)
+
+if test "$with_no_leaks" = yes ; then
+       AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
+       AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
+fi
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_DISABLE_RPATH_HACK version: 2 updated: 2011/02/13 13:31:33
+dnl ---------------------
+dnl The rpath-hack makes it simpler to build programs, particularly with the
+dnl *BSD ports which may have essential libraries in unusual places.  But it
+dnl can interfere with building an executable for the base system.  Use this
+dnl option in that case.
+AC_DEFUN([CF_DISABLE_RPATH_HACK],
+[
+AC_MSG_CHECKING(if rpath-hack should be disabled)
+CF_ARG_DISABLE(rpath-hack,
+       [  --disable-rpath-hack    don't add rpath options for additional libraries],
+       [cf_disable_rpath_hack=yes],
+       [cf_disable_rpath_hack=no])
+AC_MSG_RESULT($cf_disable_rpath_hack)
+if test "$cf_disable_rpath_hack" = no ; then
+       CF_RPATH_HACK
+fi
+])
+dnl ---------------------------------------------------------------------------
+dnl CF_ENABLE_WARNINGS version: 4 updated: 2009/07/26 17:53:03
+dnl ------------------
+dnl Configure-option to enable gcc warnings
+AC_DEFUN([CF_ENABLE_WARNINGS],[
+if ( test "$GCC" = yes || test "$GXX" = yes )
+then
+AC_MSG_CHECKING(if you want to turn on gcc warnings)
+CF_ARG_ENABLE(warnings,
+       [  --enable-warnings       test: turn on gcc compiler warnings],
+       [with_warnings=yes],
+       [with_warnings=no])
+AC_MSG_RESULT($with_warnings)
+if test "$with_warnings" = "yes"
+then
+       CF_GCC_ATTRIBUTES
+       CF_GCC_WARNINGS
+fi
+fi
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_FIND_LIBRARY version: 9 updated: 2008/03/23 14:48:54
 dnl ---------------
 dnl Look for a non-standard library, given parameters for AC_TRY_LINK.  We
 dnl prefer a standard location, and use -L options only if we do not find the
@@ -291,7 +1092,7 @@ dnl        $2 = library class, usually the same as library name
 dnl    $3 = includes
 dnl    $4 = code fragment to compile/link
 dnl    $5 = corresponding function-name
-dnl    $6 = flag, nonnull if failure causes an error-exit
+dnl    $6 = flag, nonnull if failure should not cause an error-exit
 dnl
 dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had
 dnl to use a -L option.
@@ -326,12 +1127,142 @@ AC_DEFUN([CF_FIND_LIBRARY],
 eval 'cf_found_library=[$]cf_cv_have_lib_'$1
 ifelse($6,,[
 if test $cf_found_library = no ; then
-       AC_ERROR(Cannot link $1 library)
+       AC_MSG_ERROR(Cannot link $1 library)
 fi
 ])
 ])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_FUNC_CURSES_VERSION version: 3 updated: 2003/05/17 22:19:02
+dnl CF_FIND_LINKAGE version: 19 updated: 2010/05/29 16:31:02
+dnl ---------------
+dnl Find a library (specifically the linkage used in the code fragment),
+dnl searching for it if it is not already in the library path.
+dnl See also CF_ADD_SEARCHPATH.
+dnl
+dnl Parameters (4-on are optional):
+dnl     $1 = headers for library entrypoint
+dnl     $2 = code fragment for library entrypoint
+dnl     $3 = the library name without the "-l" option or ".so" suffix.
+dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
+dnl     $5 = action to perform if not successful
+dnl     $6 = module name, if not the same as the library name
+dnl     $7 = extra libraries
+dnl
+dnl Sets these variables:
+dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
+dnl     $cf_cv_header_path_$3 - include-directory if needed
+dnl     $cf_cv_library_path_$3 - library-directory if needed
+dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
+AC_DEFUN([CF_FIND_LINKAGE],[
+
+# If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
+# will be set on completion of the AC_TRY_LINK below.
+cf_cv_header_path_$3=
+cf_cv_library_path_$3=
+
+CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
+
+cf_save_LIBS="$LIBS"
+
+AC_TRY_LINK([$1],[$2],[
+       cf_cv_find_linkage_$3=yes
+       cf_cv_header_path_$3=/usr/include
+       cf_cv_library_path_$3=/usr/lib
+],[
+
+LIBS="-l$3 $7 $cf_save_LIBS"
+
+AC_TRY_LINK([$1],[$2],[
+       cf_cv_find_linkage_$3=yes
+       cf_cv_header_path_$3=/usr/include
+       cf_cv_library_path_$3=/usr/lib
+       cf_cv_library_file_$3="-l$3"
+],[
+       cf_cv_find_linkage_$3=no
+       LIBS="$cf_save_LIBS"
+
+    CF_VERBOSE(find linkage for $3 library)
+    CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
+
+    cf_save_CPPFLAGS="$CPPFLAGS"
+    cf_test_CPPFLAGS="$CPPFLAGS"
+
+    CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
+    for cf_cv_header_path_$3 in $cf_search
+    do
+      if test -d $cf_cv_header_path_$3 ; then
+        CF_VERBOSE(... testing $cf_cv_header_path_$3)
+        CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
+        AC_TRY_COMPILE([$1],[$2],[
+            CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
+            cf_cv_find_linkage_$3=maybe
+            cf_test_CPPFLAGS="$CPPFLAGS"
+            break],[
+            CPPFLAGS="$cf_save_CPPFLAGS"
+            ])
+      fi
+    done
+
+    if test "$cf_cv_find_linkage_$3" = maybe ; then
+
+      CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
+
+      cf_save_LIBS="$LIBS"
+      cf_save_LDFLAGS="$LDFLAGS"
+
+      ifelse([$6],,,[
+        CPPFLAGS="$cf_test_CPPFLAGS"
+        LIBS="-l$3 $7 $cf_save_LIBS"
+        AC_TRY_LINK([$1],[$2],[
+            CF_VERBOSE(... found $3 library in system)
+            cf_cv_find_linkage_$3=yes])
+            CPPFLAGS="$cf_save_CPPFLAGS"
+            LIBS="$cf_save_LIBS"
+            ])
+
+      if test "$cf_cv_find_linkage_$3" != yes ; then
+        CF_LIBRARY_PATH(cf_search,$3)
+        for cf_cv_library_path_$3 in $cf_search
+        do
+          if test -d $cf_cv_library_path_$3 ; then
+            CF_VERBOSE(... testing $cf_cv_library_path_$3)
+            CPPFLAGS="$cf_test_CPPFLAGS"
+            LIBS="-l$3 $7 $cf_save_LIBS"
+            LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
+            AC_TRY_LINK([$1],[$2],[
+                CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
+                cf_cv_find_linkage_$3=yes
+                cf_cv_library_file_$3="-l$3"
+                break],[
+                CPPFLAGS="$cf_save_CPPFLAGS"
+                LIBS="$cf_save_LIBS"
+                LDFLAGS="$cf_save_LDFLAGS"
+                ])
+          fi
+        done
+        CPPFLAGS="$cf_save_CPPFLAGS"
+        LDFLAGS="$cf_save_LDFLAGS"
+      fi
+
+    else
+      cf_cv_find_linkage_$3=no
+    fi
+    ],$7)
+])
+
+LIBS="$cf_save_LIBS"
+
+if test "$cf_cv_find_linkage_$3" = yes ; then
+ifelse([$4],,[
+       CF_ADD_INCDIR($cf_cv_header_path_$3)
+       CF_ADD_LIBDIR($cf_cv_library_path_$3)
+       CF_ADD_LIB($3)
+],[$4])
+else
+ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
+fi
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_FUNC_CURSES_VERSION version: 6 updated: 2012/10/06 16:39:58
 dnl ----------------------
 dnl Solaris has a data item 'curses_version', which confuses AC_CHECK_FUNCS.
 dnl It's a character string "SVR4", not documented.
@@ -339,21 +1270,292 @@ AC_DEFUN([CF_FUNC_CURSES_VERSION],
 [
 AC_CACHE_CHECK(for function curses_version, cf_cv_func_curses_version,[
 AC_TRY_RUN([
-#include <${cf_cv_ncurses_header-curses.h}>
+#include <${cf_cv_ncurses_header:-curses.h}>
 int main()
 {
        char temp[1024];
        sprintf(temp, "%s\n", curses_version());
-       exit(0);
+       ${cf_cv_main_return:-return}(0);
 }]
 ,[cf_cv_func_curses_version=yes]
 ,[cf_cv_func_curses_version=no]
 ,[cf_cv_func_curses_version=unknown])
 rm -f core])
-test "$cf_cv_func_curses_version" = yes && AC_DEFINE(HAVE_CURSES_VERSION)
+test "$cf_cv_func_curses_version" = yes && AC_DEFINE(HAVE_CURSES_VERSION,1,[Define to 1 if we have curses_version function])
+])
+dnl ---------------------------------------------------------------------------
+dnl CF_GCC_ATTRIBUTES version: 16 updated: 2012/10/02 20:55:03
+dnl -----------------
+dnl Test for availability of useful gcc __attribute__ directives to quiet
+dnl compiler warnings.  Though useful, not all are supported -- and contrary
+dnl to documentation, unrecognized directives cause older compilers to barf.
+AC_DEFUN([CF_GCC_ATTRIBUTES],
+[
+if test "$GCC" = yes
+then
+cat > conftest.i <<EOF
+#ifndef GCC_PRINTF
+#define GCC_PRINTF 0
+#endif
+#ifndef GCC_SCANF
+#define GCC_SCANF 0
+#endif
+#ifndef GCC_NORETURN
+#define GCC_NORETURN /* nothing */
+#endif
+#ifndef GCC_UNUSED
+#define GCC_UNUSED /* nothing */
+#endif
+EOF
+if test "$GCC" = yes
+then
+       AC_CHECKING([for $CC __attribute__ directives])
+cat > conftest.$ac_ext <<EOF
+#line __oline__ "${as_me:-configure}"
+#include "confdefs.h"
+#include "conftest.h"
+#include "conftest.i"
+#if    GCC_PRINTF
+#define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
+#else
+#define GCC_PRINTFLIKE(fmt,var) /*nothing*/
+#endif
+#if    GCC_SCANF
+#define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
+#else
+#define GCC_SCANFLIKE(fmt,var)  /*nothing*/
+#endif
+extern void wow(char *,...) GCC_SCANFLIKE(1,2);
+extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
+extern void foo(void) GCC_NORETURN;
+int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
+EOF
+       cf_printf_attribute=no
+       cf_scanf_attribute=no
+       for cf_attribute in scanf printf unused noreturn
+       do
+               CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
+               cf_directive="__attribute__(($cf_attribute))"
+               echo "checking for $CC $cf_directive" 1>&AC_FD_CC
+
+               case $cf_attribute in #(vi
+               printf) #(vi
+                       cf_printf_attribute=yes
+                       cat >conftest.h <<EOF
+#define GCC_$cf_ATTRIBUTE 1
+EOF
+                       ;;
+               scanf) #(vi
+                       cf_scanf_attribute=yes
+                       cat >conftest.h <<EOF
+#define GCC_$cf_ATTRIBUTE 1
+EOF
+                       ;;
+               *) #(vi
+                       cat >conftest.h <<EOF
+#define GCC_$cf_ATTRIBUTE $cf_directive
+EOF
+                       ;;
+               esac
+
+               if AC_TRY_EVAL(ac_compile); then
+                       test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
+                       cat conftest.h >>confdefs.h
+                       case $cf_attribute in #(vi
+                       noreturn) #(vi
+                               AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
+                               ;;
+                       printf) #(vi
+                               cf_value='/* nothing */'
+                               if test "$cf_printf_attribute" != no ; then
+                                       cf_value='__attribute__((format(printf,fmt,var)))'
+                                       AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
+                               fi
+                               AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
+                               ;;
+                       scanf) #(vi
+                               cf_value='/* nothing */'
+                               if test "$cf_scanf_attribute" != no ; then
+                                       cf_value='__attribute__((format(scanf,fmt,var)))'
+                                       AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
+                               fi
+                               AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
+                               ;;
+                       unused) #(vi
+                               AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
+                               ;;
+                       esac
+               fi
+       done
+else
+       fgrep define conftest.i >>confdefs.h
+fi
+rm -rf conftest*
+fi
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_GCC_VERSION version: 7 updated: 2012/10/18 06:46:33
+dnl --------------
+dnl Find version of gcc
+AC_DEFUN([CF_GCC_VERSION],[
+AC_REQUIRE([AC_PROG_CC])
+GCC_VERSION=none
+if test "$GCC" = yes ; then
+       AC_MSG_CHECKING(version of $CC)
+       GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC[[^)]]*) //' -e 's/^.*(Debian[[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
+       test -z "$GCC_VERSION" && GCC_VERSION=unknown
+       AC_MSG_RESULT($GCC_VERSION)
+fi
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_GCC_WARNINGS version: 31 updated: 2013/11/19 19:23:35
+dnl ---------------
+dnl Check if the compiler supports useful warning options.  There's a few that
+dnl we don't use, simply because they're too noisy:
+dnl
+dnl    -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
+dnl    -Wredundant-decls (system headers make this too noisy)
+dnl    -Wtraditional (combines too many unrelated messages, only a few useful)
+dnl    -Wwrite-strings (too noisy, but should review occasionally).  This
+dnl            is enabled for ncurses using "--enable-const".
+dnl    -pedantic
+dnl
+dnl Parameter:
+dnl    $1 is an optional list of gcc warning flags that a particular
+dnl            application might want to use, e.g., "no-unused" for
+dnl            -Wno-unused
+dnl Special:
+dnl    If $with_ext_const is "yes", add a check for -Wwrite-strings
+dnl
+AC_DEFUN([CF_GCC_WARNINGS],
+[
+AC_REQUIRE([CF_GCC_VERSION])
+CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
+CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
+
+cat > conftest.$ac_ext <<EOF
+#line __oline__ "${as_me:-configure}"
+int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
+EOF
+
+if test "$INTEL_COMPILER" = yes
+then
+# The "-wdXXX" options suppress warnings:
+# remark #1419: external declaration in primary source file
+# remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
+# remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
+# remark #193: zero used for undefined preprocessing identifier
+# remark #593: variable "curs_sb_left_arrow" was set but never used
+# remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
+# remark #869: parameter "tw" was never referenced
+# remark #981: operands are evaluated in unspecified order
+# warning #279: controlling expression is constant
+
+       AC_CHECKING([for $CC warning options])
+       cf_save_CFLAGS="$CFLAGS"
+       EXTRA_CFLAGS="-Wall"
+       for cf_opt in \
+               wd1419 \
+               wd1683 \
+               wd1684 \
+               wd193 \
+               wd593 \
+               wd279 \
+               wd810 \
+               wd869 \
+               wd981
+       do
+               CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
+               if AC_TRY_EVAL(ac_compile); then
+                       test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
+                       EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
+               fi
+       done
+       CFLAGS="$cf_save_CFLAGS"
+
+elif test "$GCC" = yes
+then
+       AC_CHECKING([for $CC warning options])
+       cf_save_CFLAGS="$CFLAGS"
+       EXTRA_CFLAGS=
+       cf_warn_CONST=""
+       test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
+       cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
+       test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
+       for cf_opt in W Wall \
+               Wbad-function-cast \
+               Wcast-align \
+               Wcast-qual \
+               Wdeclaration-after-statement \
+               Wextra \
+               Winline \
+               Wmissing-declarations \
+               Wmissing-prototypes \
+               Wnested-externs \
+               Wpointer-arith \
+               Wshadow \
+               Wstrict-prototypes \
+               Wundef $cf_gcc_warnings $cf_warn_CONST $1
+       do
+               CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
+               if AC_TRY_EVAL(ac_compile); then
+                       test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
+                       case $cf_opt in #(vi
+                       Wcast-qual) #(vi
+                               CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
+                               ;;
+                       Winline) #(vi
+                               case $GCC_VERSION in
+                               [[34]].*)
+                                       CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
+                                       continue;;
+                               esac
+                               ;;
+                       Wpointer-arith) #(vi
+                               case $GCC_VERSION in
+                               [[12]].*)
+                                       CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
+                                       continue;;
+                               esac
+                               ;;
+                       esac
+                       EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
+               fi
+       done
+       CFLAGS="$cf_save_CFLAGS"
+fi
+rm -rf conftest*
+
+AC_SUBST(EXTRA_CFLAGS)
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_GETOPT_HEADER version: 6 updated: 2014/07/22 14:45:54
+dnl ----------------
+dnl Check for getopt's variables which are commonly defined in stdlib.h,
+dnl unistd.h or (nonstandard) in getopt.h
+AC_DEFUN([CF_GETOPT_HEADER],
+[
+AC_HAVE_HEADERS(unistd.h getopt.h)
+AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
+cf_cv_getopt_header=none
+for cf_header in stdio.h stdlib.h unistd.h getopt.h
+do
+AC_TRY_COMPILE([
+#include <$cf_header>],
+[int x = optind; char *y = optarg],
+[cf_cv_getopt_header=$cf_header
+ break])
+done
 ])
+if test $cf_cv_getopt_header != none ; then
+       AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
+fi
+if test $cf_cv_getopt_header = getopt.h ; then
+       AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
+fi
+])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_GNU_SOURCE version: 3 updated: 2000/10/29 23:30:53
+dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
 dnl -------------
 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
@@ -383,11 +1585,35 @@ make an error
 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
 ])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_HEADER_PATH version: 8 updated: 2002/11/10 14:46:59
+dnl CF_HEADER_PATH version: 12 updated: 2010/05/05 05:22:40
 dnl --------------
-dnl Construct a search-list for a nonstandard header-file
+dnl Construct a search-list of directories for a nonstandard header-file
+dnl
+dnl Parameters
+dnl    $1 = the variable to return as result
+dnl    $2 = the package name
 AC_DEFUN([CF_HEADER_PATH],
-[CF_SUBDIR_PATH($1,$2,include)
+[
+$1=
+
+# collect the current set of include-directories from compiler flags
+cf_header_path_list=""
+if test -n "${CFLAGS}${CPPFLAGS}" ; then
+       for cf_header_path in $CPPFLAGS $CFLAGS
+       do
+               case $cf_header_path in #(vi
+               -I*)
+                       cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
+                       CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
+                       cf_header_path_list="$cf_header_path_list [$]$1"
+                       ;;
+               esac
+       done
+fi
+
+# add the variations for the package we are looking for
+CF_SUBDIR_PATH($1,$2,include)
+
 test "$includedir" != NONE && \
 test "$includedir" != "/usr/include" && \
 test -d "$includedir" && {
@@ -402,6 +1628,14 @@ test -d "$oldincludedir" && {
        test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
 }
 
+$1="[$]$1 $cf_header_path_list"
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
+dnl ---------------
+dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
+AC_DEFUN([CF_HELP_MESSAGE],
+[AC_DIVERT_HELP([$1])dnl
 ])dnl
 dnl ---------------------------------------------------------------------------
 dnl CF_INHERIT_SCRIPT version: 2 updated: 2003/03/01 23:50:42
@@ -412,13 +1646,227 @@ AC_DEFUN([CF_INHERIT_SCRIPT],
 test -f $1 || ( test -f ../$1 && cp ../$1 ./ )
 ])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_LIBRARY_PATH version: 7 updated: 2002/11/10 14:46:59
+dnl CF_INTEL_COMPILER version: 6 updated: 2014/03/17 13:13:07
+dnl -----------------
+dnl Check if the given compiler is really the Intel compiler for Linux.  It
+dnl tries to imitate gcc, but does not return an error when it finds a mismatch
+dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
+dnl
+dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
+dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
+dnl the wrappers for gcc and g++ warnings.
+dnl
+dnl $1 = GCC (default) or GXX
+dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
+dnl $3 = CFLAGS (default) or CXXFLAGS
+AC_DEFUN([CF_INTEL_COMPILER],[
+AC_REQUIRE([AC_CANONICAL_HOST])
+ifelse([$2],,INTEL_COMPILER,[$2])=no
+
+if test "$ifelse([$1],,[$1],GCC)" = yes ; then
+       case $host_os in
+       linux*|gnu*)
+               AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
+               cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
+               ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
+               AC_TRY_COMPILE([],[
+#ifdef __INTEL_COMPILER
+#else
+make an error
+#endif
+],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
+cf_save_CFLAGS="$cf_save_CFLAGS -we147"
+],[])
+               ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
+               AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
+               ;;
+       esac
+fi
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_LD_RPATH_OPT version: 5 updated: 2011/07/17 14:48:41
+dnl ---------------
+dnl For the given system and compiler, find the compiler flags to pass to the
+dnl loader to use the "rpath" feature.
+AC_DEFUN([CF_LD_RPATH_OPT],
+[
+AC_REQUIRE([CF_CHECK_CACHE])
+
+LD_RPATH_OPT=
+AC_MSG_CHECKING(for an rpath option)
+case $cf_cv_system_name in #(vi
+irix*) #(vi
+       if test "$GCC" = yes; then
+               LD_RPATH_OPT="-Wl,-rpath,"
+       else
+               LD_RPATH_OPT="-rpath "
+       fi
+       ;;
+linux*|gnu*|k*bsd*-gnu) #(vi
+       LD_RPATH_OPT="-Wl,-rpath,"
+       ;;
+openbsd[[2-9]].*|mirbsd*) #(vi
+       LD_RPATH_OPT="-Wl,-rpath,"
+       ;;
+dragonfly*|freebsd*) #(vi
+       LD_RPATH_OPT="-rpath "
+       ;;
+netbsd*) #(vi
+       LD_RPATH_OPT="-Wl,-rpath,"
+       ;;
+osf*|mls+*) #(vi
+       LD_RPATH_OPT="-rpath "
+       ;;
+solaris2*) #(vi
+       LD_RPATH_OPT="-R"
+       ;;
+*)
+       ;;
+esac
+AC_MSG_RESULT($LD_RPATH_OPT)
+
+case "x$LD_RPATH_OPT" in #(vi
+x-R*)
+       AC_MSG_CHECKING(if we need a space after rpath option)
+       cf_save_LIBS="$LIBS"
+       CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
+       AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
+       LIBS="$cf_save_LIBS"
+       AC_MSG_RESULT($cf_rpath_space)
+       test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
+       ;;
+esac
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_LIBRARY_PATH version: 9 updated: 2010/03/28 12:52:50
 dnl ---------------
-dnl Construct a search-list for a nonstandard library-file
+dnl Construct a search-list of directories for a nonstandard library-file
+dnl
+dnl Parameters
+dnl    $1 = the variable to return as result
+dnl    $2 = the package name
 AC_DEFUN([CF_LIBRARY_PATH],
-[CF_SUBDIR_PATH($1,$2,lib)])dnl
+[
+$1=
+cf_library_path_list=""
+if test -n "${LDFLAGS}${LIBS}" ; then
+       for cf_library_path in $LDFLAGS $LIBS
+       do
+               case $cf_library_path in #(vi
+               -L*)
+                       cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
+                       CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
+                       cf_library_path_list="$cf_library_path_list [$]$1"
+                       ;;
+               esac
+       done
+fi
+
+CF_SUBDIR_PATH($1,$2,lib)
+
+$1="$cf_library_path_list [$]$1"
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
+dnl ------------
+dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
+dnl a monocase filesystem.
+AC_DEFUN([CF_MAKE_TAGS],[
+AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
+
+AC_CHECK_PROGS(CTAGS, exctags ctags)
+AC_CHECK_PROGS(ETAGS, exetags etags)
+
+AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
+
+if test "$cf_cv_mixedcase" = yes ; then
+       AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
+else
+       MAKE_UPPER_TAGS=no
+fi
+
+if test "$MAKE_UPPER_TAGS" = yes ; then
+       MAKE_UPPER_TAGS=
+else
+       MAKE_UPPER_TAGS="#"
+fi
+
+if test "$MAKE_LOWER_TAGS" = yes ; then
+       MAKE_LOWER_TAGS=
+else
+       MAKE_LOWER_TAGS="#"
+fi
+
+AC_SUBST(CTAGS)
+AC_SUBST(ETAGS)
+
+AC_SUBST(MAKE_UPPER_TAGS)
+AC_SUBST(MAKE_LOWER_TAGS)
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_MATH_LIB version: 8 updated: 2010/05/29 16:31:02
+dnl -----------
+dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
+dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
+dnl AC_CHECK_LIB(m,sin), because that fails for C++.
+AC_DEFUN([CF_MATH_LIB],
+[
+AC_CACHE_CHECK(if -lm needed for math functions,
+       cf_cv_need_libm,[
+       AC_TRY_LINK([
+       #include <stdio.h>
+       #include <math.h>
+       ],
+       [double x = rand(); printf("result = %g\n", ]ifelse([$2],,sin(x),$2)[)],
+       [cf_cv_need_libm=no],
+       [cf_cv_need_libm=yes])])
+if test "$cf_cv_need_libm" = yes
+then
+ifelse($1,,[
+       CF_ADD_LIB(m)
+],[$1=-lm])
+fi
+])
+dnl ---------------------------------------------------------------------------
+dnl CF_MIXEDCASE_FILENAMES version: 6 updated: 2013/10/08 17:47:05
+dnl ----------------------
+dnl Check if the file-system supports mixed-case filenames.  If we're able to
+dnl create a lowercase name and see it as uppercase, it doesn't support that.
+AC_DEFUN([CF_MIXEDCASE_FILENAMES],
+[
+AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
+if test "$cross_compiling" = yes ; then
+       case $target_alias in #(vi
+       *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*) #(vi
+               cf_cv_mixedcase=no
+               ;;
+       *)
+               cf_cv_mixedcase=yes
+               ;;
+       esac
+else
+       rm -f conftest CONFTEST
+       echo test >conftest
+       if test -f CONFTEST ; then
+               cf_cv_mixedcase=no
+       else
+               cf_cv_mixedcase=yes
+       fi
+       rm -f conftest CONFTEST
+fi
+])
+test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
+dnl ----------
+dnl Write a debug message to config.log, along with the line number in the
+dnl configure script.
+AC_DEFUN([CF_MSG_LOG],[
+echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
+])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_NCURSES_CC_CHECK version: 3 updated: 2003/01/12 18:59:28
+dnl CF_NCURSES_CC_CHECK version: 4 updated: 2007/07/29 10:39:05
 dnl -------------------
 dnl Check if we can compile with ncurses' header file
 dnl $1 is the cache variable to set
@@ -447,11 +1895,54 @@ printf("old\n");
 #endif
 #endif
        ]
-       ,[$1=$cf_header]
+       ,[$1=$2]
        ,[$1=no])
 ])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_NCURSES_CPPFLAGS version: 16 updated: 2002/12/29 18:30:46
+dnl CF_NCURSES_CONFIG version: 10 updated: 2012/10/06 08:57:51
+dnl -----------------
+dnl Tie together the configure-script macros for ncurses.
+dnl Prefer the "-config" script from ncurses 6.x, to simplify analysis.
+dnl Allow that to be overridden using the $NCURSES_CONFIG environment variable.
+dnl
+dnl $1 is the root library name (default: "ncurses")
+AC_DEFUN([CF_NCURSES_CONFIG],
+[
+cf_ncuconfig_root=ifelse($1,,ncurses,$1)
+
+echo "Looking for ${cf_ncuconfig_root}-config"
+
+CF_ACVERSION_CHECK(2.52,
+       [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
+       [AC_PATH_PROGS(NCURSES_CONFIG, ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
+
+if test "$NCURSES_CONFIG" != none ; then
+
+CPPFLAGS="$CPPFLAGS `$NCURSES_CONFIG --cflags`"
+CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
+
+# even with config script, some packages use no-override for curses.h
+CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
+
+dnl like CF_NCURSES_CPPFLAGS
+AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
+
+dnl like CF_NCURSES_LIBS
+CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
+AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
+
+dnl like CF_NCURSES_VERSION
+cf_cv_ncurses_version=`$NCURSES_CONFIG --version`
+
+else
+
+CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
+CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
+
+fi
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_NCURSES_CPPFLAGS version: 21 updated: 2012/10/06 08:57:51
 dnl -------------------
 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
 dnl the CPPFLAGS variable so we can include its header.
@@ -475,11 +1966,13 @@ dnl wide-character version of ncurses is installed.
 AC_DEFUN([CF_NCURSES_CPPFLAGS],
 [AC_REQUIRE([CF_WITH_CURSES_DIR])
 
+AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
 
 test -n "$cf_cv_curses_dir" && \
-test "$cf_cv_curses_dir" != "no" && \
-CPPFLAGS="-I$cf_cv_curses_dir/include -I$cf_cv_curses_dir/include/$cf_ncuhdr_root $CPPFLAGS"
+test "$cf_cv_curses_dir" != "no" && { \
+  CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
+}
 
 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
        cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
@@ -491,9 +1984,62 @@ AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
        done
 ])
 
+CF_NCURSES_HEADER
+CF_TERM_HEADER
+
+# some applications need this, but should check for NCURSES_VERSION
+AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
+
+CF_NCURSES_VERSION
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_NCURSES_EXT_FUNCS version: 4 updated: 2012/10/06 16:39:58
+dnl --------------------
+dnl Since 2007/11/17, ncurses has defined NCURSES_EXT_FUNCS; earlier versions
+dnl may provide these functions.  Define the symbol if it is not defined, and
+dnl if it is valid.
+AC_DEFUN([CF_NCURSES_EXT_FUNCS],
+[
+AC_CACHE_CHECK(for ncurses extended functions,cf_cv_ncurses_ext_funcs,[
+AC_TRY_COMPILE([
+#include <${cf_cv_ncurses_header:-curses.h}>],
+[
+int x = NCURSES_EXT_FUNCS
+],[cf_cv_ncurses_ext_funcs=defined],[
+AC_TRY_LINK([
+#include <${cf_cv_ncurses_header:-curses.h}>],
+[
+       (void) assume_default_colors (0, 0);
+       (void) curses_version ();
+       (void) define_key (0, 0);
+       (void) is_term_resized (0, 0);
+       (void) key_defined (0);
+       (void) keybound (0, 0);
+       (void) keyok (0, 0);
+       (void) resize_term (0, 0);
+       (void) resizeterm (0, 0);
+       (void) use_default_colors ();
+       (void) use_extended_names (0);
+       (void) wresize (0, 0, 0);],
+       [cf_cv_ncurses_ext_funcs=yes],
+       [cf_cv_ncurses_ext_funcs=no])
+])
+])
+test "$cf_cv_ncurses_ext_funcs" = yes && AC_DEFINE(NCURSES_EXT_FUNCS,1,[Define to 1 if we have ncurses extensions])
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_NCURSES_HEADER version: 3 updated: 2012/10/06 08:57:51
+dnl -----------------
+dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
+dnl variations of ncurses' installs.
+dnl
+dnl See also CF_CURSES_HEADER, which sets the same cache variable.
+AC_DEFUN([CF_NCURSES_HEADER],[
+
 if test "$cf_cv_ncurses_h" != no ; then
        cf_cv_ncurses_header=$cf_cv_ncurses_h
 else
+
 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
        test -n "$verbose" && echo
        CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
@@ -517,7 +2063,7 @@ AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
                CPPFLAGS="$cf_save2_CPPFLAGS"
                test "$cf_cv_ncurses_h2" != no && break
        done
-       test "$cf_cv_ncurses_h2" = no && AC_ERROR(not found)
+       test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
        ])
 
        CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
@@ -529,27 +2075,26 @@ AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
 
 fi
 
-AC_DEFINE(NCURSES)
+# Set definitions to allow ifdef'ing for ncurses.h
 
 case $cf_cv_ncurses_header in # (vi
 *ncurses.h)
-       AC_DEFINE(HAVE_NCURSES_H)
+       AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
        ;;
 esac
 
 case $cf_cv_ncurses_header in # (vi
 ncurses/curses.h|ncurses/ncurses.h)
-       AC_DEFINE(HAVE_NCURSES_NCURSES_H)
+       AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
        ;;
 ncursesw/curses.h|ncursesw/ncurses.h)
-       AC_DEFINE(HAVE_NCURSESW_NCURSES_H)
+       AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
        ;;
 esac
 
-CF_NCURSES_VERSION
 ])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_NCURSES_LIBS version: 11 updated: 2002/12/22 14:22:25
+dnl CF_NCURSES_LIBS version: 16 updated: 2010/11/20 17:02:38
 dnl ---------------
 dnl Look for the ncurses library.  This is a little complicated on Linux,
 dnl because it may be linked with the gpm (general purpose mouse) library.
@@ -579,18 +2124,20 @@ case $host_os in #(vi
 freebsd*)
        # This is only necessary if you are linking against an obsolete
        # version of ncurses (but it should do no harm, since it's static).
-       AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
+       if test "$cf_nculib_root" = ncurses ; then
+               AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
+       fi
        ;;
 esac
 
-LIBS="$cf_ncurses_LIBS $LIBS"
+CF_ADD_LIBS($cf_ncurses_LIBS)
 
 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
 then
-       LIBS="-L$cf_cv_curses_dir/lib -l$cf_nculib_root $LIBS"
+       CF_ADD_LIBS(-l$cf_nculib_root)
 else
        CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
-               [#include <${cf_cv_ncurses_header-curses.h}>],
+               [#include <${cf_cv_ncurses_header:-curses.h}>],
                [initscr()],
                initscr)
 fi
@@ -604,7 +2151,7 @@ if test -n "$cf_ncurses_LIBS" ; then
                        LIBS="$q"
                fi
        done
-       AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>],
+       AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
                [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
                [AC_MSG_RESULT(yes)],
                [AC_MSG_RESULT(no)
@@ -615,19 +2162,20 @@ CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
 ])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_NCURSES_VERSION version: 10 updated: 2002/10/27 18:21:42
+dnl CF_NCURSES_VERSION version: 14 updated: 2012/10/06 08:57:51
 dnl ------------------
 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS.  We don't use
 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
 AC_DEFUN([CF_NCURSES_VERSION],
 [
+AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
        cf_cv_ncurses_version=no
        cf_tempfile=out$$
        rm -f $cf_tempfile
        AC_TRY_RUN([
-#include <${cf_cv_ncurses_header-curses.h}>
+#include <${cf_cv_ncurses_header:-curses.h}>
 #include <stdio.h>
 int main()
 {
@@ -645,14 +2193,14 @@ int main()
        make an error
 # endif
 #endif
-       exit(0);
+       ${cf_cv_main_return:-return}(0);
 }],[
        cf_cv_ncurses_version=`cat $cf_tempfile`],,[
 
        # This will not work if the preprocessor splits the line after the
        # Autoconf token.  The 'unproto' program does that.
        cat > conftest.$ac_ext <<EOF
-#include <${cf_cv_ncurses_header-curses.h}>
+#include <${cf_cv_ncurses_header:-curses.h}>
 #undef Autoconf
 #ifdef NCURSES_VERSION
 Autoconf NCURSES_VERSION
@@ -673,16 +2221,106 @@ EOF
 ])
        rm -f $cf_tempfile
 ])
-test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES)
+test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
 ])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_PATH_SYNTAX version: 9 updated: 2002/09/17 23:03:38
-dnl --------------
-dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
-dnl begins with one of the prefix/exec_prefix variables, and then again if the
+dnl CF_NCURSES_WRAP_PREFIX version: 1 updated: 2009/03/28 16:08:10
+dnl ----------------------
+dnl Check for ncurses "wrap-prefix" used for public variables which have been
+dnl wrapped with a function to help with concurrency control.
+AC_DEFUN([CF_NCURSES_WRAP_PREFIX],
+[
+AC_MSG_CHECKING(for ncurses wrap-prefix)
+AC_ARG_WITH(ncurses-wrap-prefix,
+       [  --with-ncurses-wrap-prefix naming-prefix for ncurses wrapped-variables],
+       [NCURSES_WRAP_PREFIX=$withval],
+       [NCURSES_WRAP_PREFIX=_nc_])
+AC_MSG_RESULT($NCURSES_WRAP_PREFIX)
+
+AC_SUBST(NCURSES_WRAP_PREFIX)
+])
+dnl ---------------------------------------------------------------------------
+dnl CF_NETBSD_FORM_H version: 2 updated: 2012/10/06 16:39:58
+dnl ----------------
+dnl Check for NetBSD's form.h, which is incompatible with SVr4 and ncurses.
+dnl Some workarounds are needed in client programs to allow them to compile.
+AC_DEFUN([CF_NETBSD_FORM_H],[
+AC_CACHE_CHECK(for NetBSD form.h,cf_cv_netbsd_form_h,[
+AC_TRY_COMPILE([
+#include <${cf_cv_ncurses_header:-curses.h}>
+#include <form.h>
+],[
+       FORM *form;
+       int y = current_field(form)->cursor_ypos;
+       int x = current_field(form)->cursor_xpos;
+],[cf_cv_netbsd_form_h=yes
+],[cf_cv_netbsd_form_h=no])
+])
+
+test "$cf_cv_netbsd_form_h" = yes && AC_DEFINE(HAVE_NETBSD_FORM_H,1,[Define to 1 if we appear to be using NetBSD form.h])
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_NETBSD_MENU_H version: 2 updated: 2012/10/06 16:39:58
+dnl ----------------
+dnl Check for NetBSD's menu.h, which is incompatible with SVr4 and ncurses.
+dnl Some workarounds are needed in client programs to allow them to compile.
+AC_DEFUN([CF_NETBSD_MENU_H],[
+AC_CACHE_CHECK(for NetBSD menu.h,cf_cv_netbsd_menu_h,[
+AC_TRY_COMPILE([
+#include <${cf_cv_ncurses_header:-curses.h}>
+#include <menu.h>
+],[
+       MENU *menu;
+       int y = menu->max_item_width;
+],[cf_cv_netbsd_menu_h=yes
+],[cf_cv_netbsd_menu_h=no])
+])
+
+test "$cf_cv_netbsd_menu_h" = yes && AC_DEFINE(HAVE_NETBSD_MENU_H,1,[Define to 1 if we appear to be using NetBSD menu.h])
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_NO_LEAKS_OPTION version: 5 updated: 2012/10/02 20:55:03
+dnl ------------------
+dnl see CF_WITH_NO_LEAKS
+AC_DEFUN([CF_NO_LEAKS_OPTION],[
+AC_MSG_CHECKING(if you want to use $1 for testing)
+AC_ARG_WITH($1,
+       [$2],
+       [AC_DEFINE_UNQUOTED($3,1,"Define to 1 if you want to use $1 for testing.")ifelse([$4],,[
+        $4
+])
+       : ${with_cflags:=-g}
+       : ${with_no_leaks:=yes}
+        with_$1=yes],
+       [with_$1=])
+AC_MSG_RESULT(${with_$1:-no})
+
+case .$with_cflags in #(vi
+.*-g*)
+       case .$CFLAGS in #(vi
+       .*-g*) #(vi
+               ;;
+       *)
+               CF_ADD_CFLAGS([-g])
+               ;;
+       esac
+       ;;
+esac
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_PATH_SYNTAX version: 14 updated: 2012/06/19 20:58:54
+dnl --------------
+dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
+dnl begins with one of the prefix/exec_prefix variables, and then again if the
 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
 dnl delayed evaluation of those symbols.
 AC_DEFUN([CF_PATH_SYNTAX],[
+if test "x$prefix" != xNONE; then
+  cf_path_syntax="$prefix"
+else
+  cf_path_syntax="$ac_default_prefix"
+fi
+
 case ".[$]$1" in #(vi
 .\[$]\(*\)*|.\'*\'*) #(vi
   ;;
@@ -690,121 +2328,432 @@ case ".[$]$1" in #(vi
   ;;
 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
   ;;
-.\[$]{*prefix}*) #(vi
+.\[$]{*prefix}*|.\[$]{*dir}*) #(vi
   eval $1="[$]$1"
   case ".[$]$1" in #(vi
   .NONE/*)
-    $1=`echo [$]$1 | sed -e s%NONE%$ac_default_prefix%`
+    $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
     ;;
   esac
   ;; #(vi
-.NONE/*)
-  $1=`echo [$]$1 | sed -e s%NONE%$ac_default_prefix%`
+.no|.NONE/*)
+  $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
   ;;
 *)
-  ifelse($2,,[AC_ERROR([expected a pathname, not \"[$]$1\"])],$2)
+  ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
   ;;
 esac
 ])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_PREDEFINE version: 1 updated: 2003/07/26 17:53:56
-dnl ------------
-dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
+dnl CF_PDCURSES_X11 version: 13 updated: 2012/10/06 16:39:58
+dnl ---------------
+dnl Configure for PDCurses' X11 library
+AC_DEFUN([CF_PDCURSES_X11],[
+AC_REQUIRE([CF_X_ATHENA])
+
+CF_ACVERSION_CHECK(2.52,
+       [AC_CHECK_TOOLS(XCURSES_CONFIG, xcurses-config, none)],
+       [AC_PATH_PROGS(XCURSES_CONFIG, xcurses-config, none)])
+
+if test "$XCURSES_CONFIG" != none ; then
+
+CPPFLAGS="$CPPFLAGS `$XCURSES_CONFIG --cflags`"
+CF_ADD_LIBS(`$XCURSES_CONFIG --libs`)
+
+cf_cv_lib_XCurses=yes
+
+else
+
+LDFLAGS="$LDFLAGS $X_LIBS"
+CF_CHECK_CFLAGS($X_CFLAGS)
+AC_CHECK_LIB(X11,XOpenDisplay,
+       [CF_ADD_LIBS(-lX11)],,
+       [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])
+AC_CACHE_CHECK(for XCurses library,cf_cv_lib_XCurses,[
+CF_ADD_LIBS(-lXCurses)
+AC_TRY_LINK([
+#include <xcurses.h>
+char *XCursesProgramName = "test";
+],[XCursesExit();],
+[cf_cv_lib_XCurses=yes],
+[cf_cv_lib_XCurses=no])
+])
+
+fi
+
+if test $cf_cv_lib_XCurses = yes ; then
+       AC_DEFINE(UNIX,1,[Define to 1 if using PDCurses on Unix])
+       AC_DEFINE(XCURSES,1,[Define to 1 if using PDCurses on Unix])
+       AC_CHECK_HEADER(xcurses.h, AC_DEFINE(HAVE_XCURSES,1,[Define to 1 if using PDCurses on Unix]))
+else
+       AC_MSG_ERROR(Cannot link with XCurses)
+fi
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_PKG_CONFIG version: 7 updated: 2011/04/29 04:53:22
+dnl -------------
+dnl Check for the package-config program, unless disabled by command-line.
+AC_DEFUN([CF_PKG_CONFIG],
+[
+AC_MSG_CHECKING(if you want to use pkg-config)
+AC_ARG_WITH(pkg-config,
+       [  --with-pkg-config{=path} enable/disable use of pkg-config],
+       [cf_pkg_config=$withval],
+       [cf_pkg_config=yes])
+AC_MSG_RESULT($cf_pkg_config)
+
+case $cf_pkg_config in #(vi
+no) #(vi
+       PKG_CONFIG=none
+       ;;
+yes) #(vi
+       CF_ACVERSION_CHECK(2.52,
+               [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
+               [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
+       ;;
+*)
+       PKG_CONFIG=$withval
+       ;;
+esac
+
+test -z "$PKG_CONFIG" && PKG_CONFIG=none
+if test "$PKG_CONFIG" != none ; then
+       CF_PATH_SYNTAX(PKG_CONFIG)
+fi
+
+AC_SUBST(PKG_CONFIG)
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_POSIX_C_SOURCE version: 8 updated: 2010/05/26 05:38:42
+dnl -----------------
+dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
+dnl
+dnl    POSIX.1-1990                            _POSIX_SOURCE
+dnl    POSIX.1-1990 and                        _POSIX_SOURCE and
+dnl            POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
+dnl            Bindings Option
+dnl    POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
+dnl    POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
+dnl    X/Open 2000                             _POSIX_C_SOURCE=200112L
 dnl
-dnl $1 = symbol to test
-dnl $2 = value (if any) to use for a predefinition
-AC_DEFUN([CF_PREDEFINE],
+dnl Parameters:
+dnl    $1 is the nominal value for _POSIX_C_SOURCE
+AC_DEFUN([CF_POSIX_C_SOURCE],
 [
-AC_MSG_CHECKING(if we must define $1)
-AC_TRY_COMPILE([#include <sys/types.h>
-],[
-#ifndef $1
-make an error
-#endif],[cf_result=no],[cf_result=yes])
-AC_MSG_RESULT($cf_result)
+cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
 
-if test "$cf_result" = yes ; then
-       CPPFLAGS="$CPPFLAGS ifelse($2,,-D$1,[-D$1=$2])"
-elif test "x$2" != "x" ; then
-       AC_MSG_CHECKING(checking for compatible value versus $2)
-       AC_TRY_COMPILE([#include <sys/types.h>
-],[
-#if $1-$2 < 0
+cf_save_CFLAGS="$CFLAGS"
+cf_save_CPPFLAGS="$CPPFLAGS"
+
+CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
+CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
+
+AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
+       CF_MSG_LOG(if the symbol is already defined go no further)
+       AC_TRY_COMPILE([#include <sys/types.h>],[
+#ifndef _POSIX_C_SOURCE
 make an error
-#endif],[cf_result=yes],[cf_result=no])
-       AC_MSG_RESULT($cf_result)
-       if test "$cf_result" = no ; then
-               # perhaps we can override it - try...
-               CPPFLAGS="$CPPFLAGS -D$1=$2"
+#endif],
+       [cf_cv_posix_c_source=no],
+       [cf_want_posix_source=no
+        case .$cf_POSIX_C_SOURCE in #(vi
+        .[[12]]??*) #(vi
+               cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
+               ;;
+        .2) #(vi
+               cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
+               cf_want_posix_source=yes
+               ;;
+        .*)
+               cf_want_posix_source=yes
+               ;;
+        esac
+        if test "$cf_want_posix_source" = yes ; then
+               AC_TRY_COMPILE([#include <sys/types.h>],[
+#ifdef _POSIX_SOURCE
+make an error
+#endif],[],
+               cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
+        fi
+        CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
+        CFLAGS="$cf_trim_CFLAGS"
+        CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
+        CF_MSG_LOG(if the second compile does not leave our definition intact error)
+        AC_TRY_COMPILE([#include <sys/types.h>],[
+#ifndef _POSIX_C_SOURCE
+make an error
+#endif],,
+        [cf_cv_posix_c_source=no])
+        CFLAGS="$cf_save_CFLAGS"
+        CPPFLAGS="$cf_save_CPPFLAGS"
+       ])
+])
+
+if test "$cf_cv_posix_c_source" != no ; then
+       CFLAGS="$cf_trim_CFLAGS"
+       CPPFLAGS="$cf_trim_CPPFLAGS"
+       CF_ADD_CFLAGS($cf_cv_posix_c_source)
+fi
+
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
+dnl ------------
+dnl Append definitions and rules for the given programs to the subdirectory
+dnl Makefiles, and the recursion rule for the top-level Makefile.
+dnl
+dnl parameters
+dnl    $1 = script to run
+dnl    $2 = list of subdirectories
+dnl
+dnl variables
+dnl    $AWK
+AC_DEFUN([CF_PRG_RULES],
+[
+for cf_dir in $2
+do
+       if test ! -d $srcdir/$cf_dir; then
+               continue
+       elif test -f $srcdir/$cf_dir/programs; then
+               $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
+       fi
+done
+
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_PROG_CC version: 4 updated: 2014/07/12 18:57:58
+dnl ----------
+dnl standard check for CC, plus followup sanity checks
+dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
+AC_DEFUN([CF_PROG_CC],[
+ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
+CF_GCC_VERSION
+CF_ACVERSION_CHECK(2.52,
+       [AC_PROG_CC_STDC],
+       [CF_ANSI_CC_REQD])
+CF_CC_ENV_FLAGS
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
+dnl ---------------
+dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
+dnl misc/tabset install won't work properly.  Usually this happens only when
+dnl using the fallback mkinstalldirs script
+AC_DEFUN([CF_PROG_INSTALL],
+[AC_PROG_INSTALL
+case $INSTALL in
+/*)
+  ;;
+*)
+  CF_DIRNAME(cf_dir,$INSTALL)
+  test -z "$cf_dir" && cf_dir=.
+  INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
+  ;;
+esac
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_PROG_LINT version: 2 updated: 2009/08/12 04:43:14
+dnl ------------
+AC_DEFUN([CF_PROG_LINT],
+[
+AC_CHECK_PROGS(LINT, tdlint lint alint splint lclint)
+AC_SUBST(LINT_OPTS)
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
+dnl ----------------
+dnl Remove all -U and -D options that refer to the given symbol from a list
+dnl of C compiler options.  This works around the problem that not all
+dnl compilers process -U and -D options from left-to-right, so a -U option
+dnl cannot be used to cancel the effect of a preceding -D option.
+dnl
+dnl $1 = target (which could be the same as the source variable)
+dnl $2 = source (including '$')
+dnl $3 = symbol to remove
+define([CF_REMOVE_DEFINE],
+[
+$1=`echo "$2" | \
+       sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
+               -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_RPATH_HACK version: 11 updated: 2013/09/01 13:02:00
+dnl -------------
+AC_DEFUN([CF_RPATH_HACK],
+[
+AC_REQUIRE([CF_LD_RPATH_OPT])
+AC_MSG_CHECKING(for updated LDFLAGS)
+if test -n "$LD_RPATH_OPT" ; then
+       AC_MSG_RESULT(maybe)
+
+       AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
+       cf_rpath_list="/usr/lib /lib"
+       if test "$cf_ldd_prog" != no
+       then
+               cf_rpath_oops=
+
+AC_TRY_LINK([#include <stdio.h>],
+               [printf("Hello");],
+               [cf_rpath_oops=`$cf_ldd_prog conftest$ac_exeext | fgrep ' not found' | sed -e 's% =>.*$%%' |sort | uniq`
+                cf_rpath_list=`$cf_ldd_prog conftest$ac_exeext | fgrep / | sed -e 's%^.*[[     ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort | uniq`])
+
+               # If we passed the link-test, but get a "not found" on a given library,
+               # this could be due to inept reconfiguration of gcc to make it only
+               # partly honor /usr/local/lib (or whatever).  Sometimes this behavior
+               # is intentional, e.g., installing gcc in /usr/bin and suppressing the
+               # /usr/local libraries.
+               if test -n "$cf_rpath_oops"
+               then
+                       for cf_rpath_src in $cf_rpath_oops
+                       do
+                               for cf_rpath_dir in \
+                                       /usr/local \
+                                       /usr/pkg \
+                                       /opt/sfw
+                               do
+                                       if test -f $cf_rpath_dir/lib/$cf_rpath_src
+                                       then
+                                               CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
+                                               LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
+                                               break
+                                       fi
+                               done
+                       done
+               fi
        fi
+
+       CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
+
+       CF_RPATH_HACK_2(LDFLAGS)
+       CF_RPATH_HACK_2(LIBS)
+
+       CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
+else
+       AC_MSG_RESULT(no)
 fi
+AC_SUBST(EXTRA_LDFLAGS)
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_RPATH_HACK_2 version: 6 updated: 2010/04/17 16:31:24
+dnl ---------------
+dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
+dnl EXTRA_LDFLAGS for each -L option found.
+dnl
+dnl $cf_rpath_list contains a list of directories to ignore.
+dnl
+dnl $1 = variable name to update.  The LDFLAGS variable should be the only one,
+dnl      but LIBS often has misplaced -L options.
+AC_DEFUN([CF_RPATH_HACK_2],
+[
+CF_VERBOSE(...checking $1 [$]$1)
+
+cf_rpath_dst=
+for cf_rpath_src in [$]$1
+do
+       case $cf_rpath_src in #(vi
+       -L*) #(vi
+
+               # check if this refers to a directory which we will ignore
+               cf_rpath_skip=no
+               if test -n "$cf_rpath_list"
+               then
+                       for cf_rpath_item in $cf_rpath_list
+                       do
+                               if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
+                               then
+                                       cf_rpath_skip=yes
+                                       break
+                               fi
+                       done
+               fi
+
+               if test "$cf_rpath_skip" = no
+               then
+                       # transform the option
+                       if test "$LD_RPATH_OPT" = "-R " ; then
+                               cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
+                       else
+                               cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
+                       fi
+
+                       # if we have not already added this, add it now
+                       cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
+                       if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
+                       then
+                               CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
+                               EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
+                       fi
+               fi
+               ;;
+       esac
+       cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
+done
+$1=$cf_rpath_dst
+
+CF_VERBOSE(...checked $1 [$]$1)
+AC_SUBST(EXTRA_LDFLAGS)
 ])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_SUBDIR_PATH version: 3 updated: 2002/12/29 18:30:46
+dnl CF_SIG_ATOMIC_T version: 3 updated: 2012/10/04 20:12:20
+dnl ---------------
+dnl signal handler, but there are some gcc depedencies in that recommendation.
+dnl Try anyway.
+AC_DEFUN([CF_SIG_ATOMIC_T],
+[
+AC_MSG_CHECKING(for signal global datatype)
+AC_CACHE_VAL(cf_cv_sig_atomic_t,[
+       for cf_type in \
+               "volatile sig_atomic_t" \
+               "sig_atomic_t" \
+               "int"
+       do
+       AC_TRY_COMPILE([
+#include <sys/types.h>
+#include <signal.h>
+#include <stdio.h>
+
+extern $cf_type x;
+$cf_type x;
+static void handler(int sig)
+{
+       x = 5;
+}],
+               [signal(SIGINT, handler);
+                x = 1],
+               [cf_cv_sig_atomic_t=$cf_type],
+               [cf_cv_sig_atomic_t=no])
+               test "$cf_cv_sig_atomic_t" != no && break
+       done
+       ])
+AC_MSG_RESULT($cf_cv_sig_atomic_t)
+test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t,[Define to signal global datatype])
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
 dnl --------------
 dnl Construct a search-list for a nonstandard header/lib-file
 dnl    $1 = the variable to return as result
 dnl    $2 = the package name
 dnl    $3 = the subdirectory, e.g., bin, include or lib
 AC_DEFUN([CF_SUBDIR_PATH],
-[$1=""
-
-test -d [$]HOME && {
-       test -n "$verbose" && echo "    ... testing $3-directories under [$]HOME"
-       test -d [$]HOME/$3 &&          $1="[$]$1 [$]HOME/$3"
-       test -d [$]HOME/$3/$2 &&       $1="[$]$1 [$]HOME/$3/$2"
-       test -d [$]HOME/$3/$2/$3 &&    $1="[$]$1 [$]HOME/$3/$2/$3"
-}
-
-# For other stuff under the home directory, it should be sufficient to put
-# a symbolic link for $HOME/$2 to the actual package location:
-test -d [$]HOME/$2 && {
-       test -n "$verbose" && echo "    ... testing $3-directories under [$]HOME/$2"
-       test -d [$]HOME/$2/$3 &&       $1="[$]$1 [$]HOME/$2/$3"
-       test -d [$]HOME/$2/$3/$2 &&    $1="[$]$1 [$]HOME/$2/$3/$2"
-}
-
-test "$prefix" != /usr/local && \
-test -d /usr/local && {
-       test -n "$verbose" && echo "    ... testing $3-directories under /usr/local"
-       test -d /usr/local/$3 &&       $1="[$]$1 /usr/local/$3"
-       test -d /usr/local/$3/$2 &&    $1="[$]$1 /usr/local/$3/$2"
-       test -d /usr/local/$3/$2/$3 && $1="[$]$1 /usr/local/$3/$2/$3"
-       test -d /usr/local/$2/$3 &&    $1="[$]$1 /usr/local/$2/$3"
-       test -d /usr/local/$2/$3/$2 && $1="[$]$1 /usr/local/$2/$3/$2"
-}
-
-test "$prefix" != NONE && \
-test -d $prefix && {
-       test -n "$verbose" && echo "    ... testing $3-directories under $prefix"
-       test -d $prefix/$3 &&          $1="[$]$1 $prefix/$3"
-       test -d $prefix/$3/$2 &&       $1="[$]$1 $prefix/$3/$2"
-       test -d $prefix/$3/$2/$3 &&    $1="[$]$1 $prefix/$3/$2/$3"
-       test -d $prefix/$2/$3 &&       $1="[$]$1 $prefix/$2/$3"
-       test -d $prefix/$2/$3/$2 &&    $1="[$]$1 $prefix/$2/$3/$2"
-}
+[
+$1=
 
-test "$prefix" != /opt && \
-test -d /opt && {
-       test -n "$verbose" && echo "    ... testing $3-directories under /opt"
-       test -d /opt/$3 &&             $1="[$]$1 /opt/$3"
-       test -d /opt/$3/$2 &&          $1="[$]$1 /opt/$3/$2"
-       test -d /opt/$3/$2/$3 &&       $1="[$]$1 /opt/$3/$2/$3"
-       test -d /opt/$2/$3 &&          $1="[$]$1 /opt/$2/$3"
-       test -d /opt/$2/$3/$2 &&       $1="[$]$1 /opt/$2/$3/$2"
-}
+CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
 
-test "$prefix" != /usr && \
-test -d /usr && {
-       test -n "$verbose" && echo "    ... testing $3-directories under /usr"
-       test -d /usr/$3 &&             $1="[$]$1 /usr/$3"
-       test -d /usr/$3/$2 &&          $1="[$]$1 /usr/$3/$2"
-       test -d /usr/$3/$2/$3 &&       $1="[$]$1 /usr/$3/$2/$3"
-       test -d /usr/$2/$3 &&          $1="[$]$1 /usr/$2/$3"
-}
+for cf_subdir_prefix in \
+       /usr \
+       /usr/local \
+       /usr/pkg \
+       /opt \
+       /opt/local \
+       [$]HOME
+do
+       CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
+done
 ])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_SYS_TIME_SELECT version: 4 updated: 2000/10/04 09:18:40
+dnl CF_SYS_TIME_SELECT version: 5 updated: 2012/10/04 05:24:07
 dnl ------------------
 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
 dnl older SCO configurations.
@@ -824,9 +2773,191 @@ AC_TRY_COMPILE([
      [cf_cv_sys_time_select=no])
      ])
 AC_MSG_RESULT($cf_cv_sys_time_select)
-test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT)
+test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT,1,[Define to 1 if we can include <sys/time.h> with <sys/select.h>])
 ])dnl
 dnl ---------------------------------------------------------------------------
+dnl CF_TERM_HEADER version: 3 updated: 2012/10/06 08:57:51
+dnl --------------
+dnl Look for term.h, which is part of X/Open curses.  It defines the interface
+dnl to terminfo database.  Usually it is in the same include-path as curses.h,
+dnl but some packagers change this, breaking various applications.
+AC_DEFUN([CF_TERM_HEADER],[
+AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
+case ${cf_cv_ncurses_header} in #(vi
+*/ncurses.h|*/ncursesw.h) #(vi
+       cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
+       ;;
+*)
+       cf_term_header=term.h
+       ;;
+esac
+
+for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
+do
+AC_TRY_COMPILE([#include <stdio.h>
+#include <${cf_cv_ncurses_header:-curses.h}>
+#include <$cf_test>
+],[int x = auto_left_margin],[
+       cf_cv_term_header="$cf_test"],[
+       cf_cv_term_header=unknown
+       ])
+       test "$cf_cv_term_header" != unknown && break
+done
+])
+
+# Set definitions to allow ifdef'ing to accommodate subdirectories
+
+case $cf_cv_term_header in # (vi
+*term.h)
+       AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
+       ;;
+esac
+
+case $cf_cv_term_header in # (vi
+ncurses/term.h) #(vi
+       AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
+       ;;
+ncursesw/term.h)
+       AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
+       ;;
+esac
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
+dnl ---------------
+dnl Define a top_builddir symbol, for applications that need an absolute path.
+AC_DEFUN([CF_TOP_BUILDDIR],
+[
+top_builddir=ifelse($1,,`pwd`,$1)
+AC_SUBST(top_builddir)
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_TPUTS_PROTO version: 2 updated: 2011/04/23 19:25:50
+dnl --------------
+dnl Check for type of function-pointer passed to tputs.  Some old
+dnl implementations used functions that had different prototypes, making it
+dnl hard to compile portable programs using tputs.
+AC_DEFUN([CF_TPUTS_PROTO],[
+CF_CURSES_FUNCS(tputs)
+if test x$cf_cv_func_tputs = xyes
+then
+       cf_done=no
+       for cf_arg in int char
+       do
+               for cf_ret in int void
+               do
+                       if test $cf_ret = void
+                       then
+                               cf_return="/* nothing */"
+                       else
+                               cf_return="return value"
+                       fi
+                       AC_TRY_COMPILE([
+#include <${cf_cv_ncurses_header:-curses.h}>
+#include <$cf_cv_term_header>
+
+static $cf_ret outc($cf_arg value) { $cf_return; }
+],[
+       tputs("hello", 0, outc); 
+       ${cf_cv_main_return:-return}(0);
+],[
+               CF_VERBOSE([prototype $cf_ret func($cf_arg value)])
+               cat >>confdefs.h <<EOF
+#define TPUTS_ARG               $cf_arg
+#define TPUTS_PROTO(func,value) $cf_ret func(TPUTS_ARG value)
+#define TPUTS_RETURN(value)     $cf_return
+EOF
+               cf_done=yes
+               break
+])
+               done
+               test $cf_done = yes && break
+       done
+fi
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_TRIM_X_LIBS version: 2 updated: 2013/07/09 21:27:22
+dnl --------------
+dnl Trim extra base X libraries added as a workaround for inconsistent library
+dnl dependencies returned by "new" pkg-config files.
+AC_DEFUN([CF_TRIM_X_LIBS],[
+       for cf_trim_lib in Xmu Xt X11
+       do
+               case "$LIBS" in
+               *-l$cf_trim_lib\ *-l$cf_trim_lib*)
+                       LIBS=`echo "$LIBS " | sed -e 's/  / /g' -e 's%-l'"$cf_trim_lib"' %%' -e 's/ $//'`
+                       CF_VERBOSE(..trimmed $LIBS)
+                       ;;
+               esac
+       done
+])
+dnl ---------------------------------------------------------------------------
+dnl CF_TRY_PKG_CONFIG version: 5 updated: 2013/07/06 21:27:06
+dnl -----------------
+dnl This is a simple wrapper to use for pkg-config, for libraries which may be
+dnl available in that form.
+dnl
+dnl $1 = package name
+dnl $2 = extra logic to use, if any, after updating CFLAGS and LIBS
+dnl $3 = logic to use if pkg-config does not have the package
+AC_DEFUN([CF_TRY_PKG_CONFIG],[
+AC_REQUIRE([CF_PKG_CONFIG])
+
+if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists $1; then
+       CF_VERBOSE(found package $1)
+       cf_pkgconfig_incs="`$PKG_CONFIG --cflags $1 2>/dev/null`"
+       cf_pkgconfig_libs="`$PKG_CONFIG --libs   $1 2>/dev/null`"
+       CF_VERBOSE(package $1 CFLAGS: $cf_pkgconfig_incs)
+       CF_VERBOSE(package $1 LIBS: $cf_pkgconfig_libs)
+       CF_ADD_CFLAGS($cf_pkgconfig_incs)
+       CF_ADD_LIBS($cf_pkgconfig_libs)
+       ifelse([$2],,:,[$2])
+else
+       cf_pkgconfig_incs=
+       cf_pkgconfig_libs=
+       ifelse([$3],,:,[$3])
+fi
+])
+dnl ---------------------------------------------------------------------------
+dnl CF_TRY_XOPEN_SOURCE version: 1 updated: 2011/10/30 17:09:50
+dnl -------------------
+dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
+dnl can define it successfully.
+AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
+AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
+       AC_TRY_COMPILE([
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+],[
+#ifndef _XOPEN_SOURCE
+make an error
+#endif],
+       [cf_cv_xopen_source=no],
+       [cf_save="$CPPFLAGS"
+        CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
+        AC_TRY_COMPILE([
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+],[
+#ifdef _XOPEN_SOURCE
+make an error
+#endif],
+       [cf_cv_xopen_source=no],
+       [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
+       CPPFLAGS="$cf_save"
+       ])
+])
+
+if test "$cf_cv_xopen_source" != no ; then
+       CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
+       CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
+       cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
+       CF_ADD_CFLAGS($cf_temp_xopen_source)
+fi
+])
+dnl ---------------------------------------------------------------------------
 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
 dnl --------
 dnl Make an uppercase version of a variable
@@ -836,7 +2967,7 @@ AC_DEFUN([CF_UPPER],
 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
 ])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_UTF8_LIB version: 4 updated: 2003/03/01 18:36:42
+dnl CF_UTF8_LIB version: 8 updated: 2012/10/06 08:57:51
 dnl -----------
 dnl Check for multibyte support, and if not found, utf8 compatibility library
 AC_DEFUN([CF_UTF8_LIB],
@@ -846,30 +2977,709 @@ AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
        AC_TRY_LINK([
 #include <stdlib.h>],[putwc(0,0);],
        [cf_cv_utf8_lib=yes],
-       [LIBS="-lutf8 $LIBS"
-        AC_TRY_LINK([
-#include <libutf8.h>],[putwc(0,0);],
+       [CF_FIND_LINKAGE([
+#include <libutf8.h>],[putwc(0,0);],utf8,
                [cf_cv_utf8_lib=add-on],
                [cf_cv_utf8_lib=no])
-       LIBS="$cf_save_LIBS"
 ])])
 
 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
 # ncurses/ncursesw:
 if test "$cf_cv_utf8_lib" = "add-on" ; then
-       AC_DEFINE(HAVE_LIBUTF8_H)
-       LIBS="-lutf8 $LIBS"
+       AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
+       CF_ADD_INCDIR($cf_cv_header_path_utf8)
+       CF_ADD_LIBDIR($cf_cv_library_path_utf8)
+       CF_ADD_LIBS($cf_cv_library_file_utf8)
 fi
 ])dnl
 dnl ---------------------------------------------------------------------------
-dnl CF_WITH_CURSES_DIR version: 2 updated: 2002/11/10 14:46:59
+dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
+dnl ----------
+dnl Use AC_VERBOSE w/o the warnings
+AC_DEFUN([CF_VERBOSE],
+[test -n "$verbose" && echo "  $1" 1>&AC_FD_MSG
+CF_MSG_LOG([$1])
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_WCHAR_TYPE version: 4 updated: 2012/10/06 16:39:58
+dnl -------------
+dnl Check if type wide-character type $1 is declared, and if so, which header
+dnl file is needed.  The second parameter is used to set a shell variable when
+dnl the type is not found.  The first parameter sets a shell variable for the
+dnl opposite sense.
+AC_DEFUN([CF_WCHAR_TYPE],
+[
+# This is needed on Tru64 5.0 to declare $1
+AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
+AC_TRY_COMPILE([
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>
+#ifdef HAVE_LIBUTF8_H
+#include <libutf8.h>
+#endif],
+       [$1 state],
+       [cf_cv_$1=no],
+       [AC_TRY_COMPILE([
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <wchar.h>
+#ifdef HAVE_LIBUTF8_H
+#include <libutf8.h>
+#endif],
+       [$1 value],
+       [cf_cv_$1=yes],
+       [cf_cv_$1=unknown])])])
+
+if test "$cf_cv_$1" = yes ; then
+       AC_DEFINE(NEED_WCHAR_H,1,[Define to 1 if we must include wchar.h])
+       NEED_WCHAR_H=1
+fi
+
+ifelse([$2],,,[
+# if we do not find $1 in either place, use substitution to provide a fallback.
+if test "$cf_cv_$1" = unknown ; then
+       $2=1
+fi
+])
+ifelse($3,,,[
+# if we find $1 in either place, use substitution to provide a fallback.
+if test "$cf_cv_$1" != unknown ; then
+       $3=1
+fi
+])
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_WITH_CURSES_DIR version: 3 updated: 2010/11/20 17:02:38
 dnl ------------------
 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
 dnl libraries.
 AC_DEFUN([CF_WITH_CURSES_DIR],[
+
+AC_MSG_CHECKING(for specific curses-directory)
 AC_ARG_WITH(curses-dir,
        [  --with-curses-dir=DIR   directory in which (n)curses is installed],
-       [CF_PATH_SYNTAX(withval)
-        cf_cv_curses_dir=$withval],
+       [cf_cv_curses_dir=$withval],
        [cf_cv_curses_dir=no])
+AC_MSG_RESULT($cf_cv_curses_dir)
+
+if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
+then
+       CF_PATH_SYNTAX(withval)
+       if test -d "$cf_cv_curses_dir"
+       then
+               CF_ADD_INCDIR($cf_cv_curses_dir/include)
+               CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
+       fi
+fi
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
+dnl ----------------
+dnl Configure-option for dbmalloc.  The optional parameter is used to override
+dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
+AC_DEFUN([CF_WITH_DBMALLOC],[
+CF_NO_LEAKS_OPTION(dbmalloc,
+       [  --with-dbmalloc         test: use Conor Cahill's dbmalloc library],
+       [USE_DBMALLOC])
+
+if test "$with_dbmalloc" = yes ; then
+       AC_CHECK_HEADER(dbmalloc.h,
+               [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
+fi
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
+dnl ---------------
+dnl Configure-option for dmalloc.  The optional parameter is used to override
+dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
+AC_DEFUN([CF_WITH_DMALLOC],[
+CF_NO_LEAKS_OPTION(dmalloc,
+       [  --with-dmalloc          test: use Gray Watson's dmalloc library],
+       [USE_DMALLOC])
+
+if test "$with_dmalloc" = yes ; then
+       AC_CHECK_HEADER(dmalloc.h,
+               [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
+fi
 ])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_WITH_NCURSES_ETC version: 2 updated: 2012/01/13 10:49:00
+dnl -------------------
+dnl Use this macro for programs which use any variant of "curses", e.g.,
+dnl "ncurses", and "PDCurses".  Programs that can use curses and some unrelated
+dnl library (such as slang) should use a "--with-screen=XXX" option.
+dnl
+dnl This does not use AC_DEFUN, because that would tell autoconf to run each
+dnl of the macros inside this one - before this macro.
+define([CF_WITH_NCURSES_ETC],[
+CF_WITH_CURSES_DIR
+
+cf_cv_screen=curses
+
+AC_MSG_CHECKING(for specified curses library type)
+AC_ARG_WITH(ncursesw,
+       [  --with-ncursesw         use wide ncurses-libraries],
+       [cf_cv_screen=ncursesw],[
+
+AC_ARG_WITH(ncurses,
+       [  --with-ncurses          use ncurses-libraries],
+       [cf_cv_screen=ncurses],[
+
+AC_ARG_WITH(pdcurses,
+       [  --with-pdcurses         compile/link with pdcurses X11 library],
+       [cf_cv_screen=pdcurses],[
+
+AC_ARG_WITH(curses-colr,
+       [  --with-curses-colr      compile/link with HPUX 10.x color-curses],
+       [cf_cv_screen=curses_colr],[
+
+AC_ARG_WITH(curses-5lib,
+       [  --with-curses-5lib      compile/link with SunOS 5lib curses],
+       [cf_cv_screen=curses_5lib])])])])])
+
+AC_MSG_RESULT($cf_cv_screen)
+
+case $cf_cv_screen in #(vi
+curses|curses_*) #(vi
+       CF_CURSES_CONFIG
+       ;;
+ncurses) #(vi
+       CF_NCURSES_CONFIG
+       ;;
+ncursesw) #(vi
+       CF_UTF8_LIB
+       CF_NCURSES_CONFIG(ncursesw)
+       ;;
+pdcurses)
+       CF_PDCURSES_X11
+       ;;
+esac
+
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
+dnl ----------------
+AC_DEFUN([CF_WITH_VALGRIND],[
+CF_NO_LEAKS_OPTION(valgrind,
+       [  --with-valgrind         test: use valgrind],
+       [USE_VALGRIND])
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_XOPEN_CURSES version: 11 updated: 2011/01/18 18:15:30
+dnl ---------------
+dnl Test if we should define X/Open source for curses, needed on Digital Unix
+dnl 4.x, to see the extended functions, but breaks on IRIX 6.x.
+dnl
+dnl The getbegyx() check is needed for HPUX, which omits legacy macros such
+dnl as getbegy().  The latter is better design, but the former is standard.
+AC_DEFUN([CF_XOPEN_CURSES],
+[
+AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
+AC_CACHE_CHECK(if we must define _XOPEN_SOURCE_EXTENDED,cf_cv_need_xopen_extension,[
+AC_TRY_LINK([
+#include <stdlib.h>
+#include <${cf_cv_ncurses_header:-curses.h}>],[
+#if defined(NCURSES_VERSION_PATCH)
+#if (NCURSES_VERSION_PATCH < 20100501) && (NCURSES_VERSION_PATCH >= 20100403)
+       make an error
+#endif
+#endif
+       long x = winnstr(stdscr, "", 0);
+       int x1, y1;
+       getbegyx(stdscr, y1, x1)],
+       [cf_cv_need_xopen_extension=no],
+       [AC_TRY_LINK([
+#define _XOPEN_SOURCE_EXTENDED
+#include <stdlib.h>
+#include <${cf_cv_ncurses_header:-curses.h}>],[
+#ifdef NCURSES_VERSION
+       cchar_t check;
+       int check2 = curs_set((int)sizeof(check));
+#endif
+       long x = winnstr(stdscr, "", 0);
+       int x1, y1;
+       getbegyx(stdscr, y1, x1)],
+       [cf_cv_need_xopen_extension=yes],
+       [cf_cv_need_xopen_extension=unknown])])])
+test $cf_cv_need_xopen_extension = yes && CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE_EXTENDED"
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_XOPEN_SOURCE version: 48 updated: 2014/09/01 12:29:14
+dnl ---------------
+dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
+dnl or adapt to the vendor's definitions to get equivalent functionality,
+dnl without losing the common non-POSIX features.
+dnl
+dnl Parameters:
+dnl    $1 is the nominal value for _XOPEN_SOURCE
+dnl    $2 is the nominal value for _POSIX_C_SOURCE
+AC_DEFUN([CF_XOPEN_SOURCE],[
+AC_REQUIRE([AC_CANONICAL_HOST])
+
+cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
+cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
+cf_xopen_source=
+
+case $host_os in #(vi
+aix[[4-7]]*) #(vi
+       cf_xopen_source="-D_ALL_SOURCE"
+       ;;
+cygwin|msys) #(vi
+       cf_XOPEN_SOURCE=600
+       ;;
+darwin[[0-8]].*) #(vi
+       cf_xopen_source="-D_APPLE_C_SOURCE"
+       ;;
+darwin*) #(vi
+       cf_xopen_source="-D_DARWIN_C_SOURCE"
+       cf_XOPEN_SOURCE=
+       ;;
+freebsd*|dragonfly*) #(vi
+       # 5.x headers associate
+       #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
+       #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
+       cf_POSIX_C_SOURCE=200112L
+       cf_XOPEN_SOURCE=600
+       cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
+       ;;
+hpux11*) #(vi
+       cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
+       ;;
+hpux*) #(vi
+       cf_xopen_source="-D_HPUX_SOURCE"
+       ;;
+irix[[56]].*) #(vi
+       cf_xopen_source="-D_SGI_SOURCE"
+       cf_XOPEN_SOURCE=
+       ;;
+linux*|gnu*|mint*|k*bsd*-gnu) #(vi
+       CF_GNU_SOURCE
+       ;;
+minix*) #(vi
+       cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
+       ;;
+mirbsd*) #(vi
+       # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
+       cf_XOPEN_SOURCE=
+       CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
+       ;;
+netbsd*) #(vi
+       cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
+       ;;
+openbsd[[4-9]]*) #(vi
+       # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
+       cf_xopen_source="-D_BSD_SOURCE"
+       cf_XOPEN_SOURCE=600
+       ;;
+openbsd*) #(vi
+       # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
+       ;;
+osf[[45]]*) #(vi
+       cf_xopen_source="-D_OSF_SOURCE"
+       ;;
+nto-qnx*) #(vi
+       cf_xopen_source="-D_QNX_SOURCE"
+       ;;
+sco*) #(vi
+       # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
+       ;;
+solaris2.*) #(vi
+       cf_xopen_source="-D__EXTENSIONS__"
+       cf_cv_xopen_source=broken
+       ;;
+sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
+       cf_XOPEN_SOURCE=
+       cf_POSIX_C_SOURCE=
+       ;;
+*)
+       CF_TRY_XOPEN_SOURCE
+       CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
+       ;;
+esac
+
+if test -n "$cf_xopen_source" ; then
+       CF_ADD_CFLAGS($cf_xopen_source,true)
+fi
+
+dnl In anything but the default case, we may have system-specific setting
+dnl which is still not guaranteed to provide all of the entrypoints that
+dnl _XOPEN_SOURCE would yield.
+if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
+       AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
+       AC_TRY_COMPILE([#include <stdlib.h>],[
+#ifndef _XOPEN_SOURCE
+make an error
+#endif],
+       [cf_XOPEN_SOURCE_set=yes],
+       [cf_XOPEN_SOURCE_set=no])
+       AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
+       if test $cf_XOPEN_SOURCE_set = yes
+       then
+               AC_TRY_COMPILE([#include <stdlib.h>],[
+#if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
+make an error
+#endif],
+               [cf_XOPEN_SOURCE_set_ok=yes],
+               [cf_XOPEN_SOURCE_set_ok=no])
+               if test $cf_XOPEN_SOURCE_set_ok = no
+               then
+                       AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
+               fi
+       else
+               CF_TRY_XOPEN_SOURCE
+       fi
+fi
+])
+dnl ---------------------------------------------------------------------------
+dnl CF_X_ATHENA version: 22 updated: 2014/07/12 18:57:58
+dnl -----------
+dnl Check for Xaw (Athena) libraries
+dnl
+dnl Sets $cf_x_athena according to the flavor of Xaw which is used.
+AC_DEFUN([CF_X_ATHENA],
+[
+cf_x_athena=${cf_x_athena:-Xaw}
+
+AC_MSG_CHECKING(if you want to link with Xaw 3d library)
+withval=
+AC_ARG_WITH(Xaw3d,
+       [  --with-Xaw3d            link with Xaw 3d library])
+if test "$withval" = yes ; then
+       cf_x_athena=Xaw3d
+       AC_MSG_RESULT(yes)
+else
+       AC_MSG_RESULT(no)
+fi
+
+AC_MSG_CHECKING(if you want to link with Xaw 3d xft library)
+withval=
+AC_ARG_WITH(Xaw3dxft,
+       [  --with-Xaw3dxft         link with Xaw 3d xft library])
+if test "$withval" = yes ; then
+       cf_x_athena=Xaw3dxft
+       AC_MSG_RESULT(yes)
+else
+       AC_MSG_RESULT(no)
+fi
+
+AC_MSG_CHECKING(if you want to link with neXT Athena library)
+withval=
+AC_ARG_WITH(neXtaw,
+       [  --with-neXtaw           link with neXT Athena library])
+if test "$withval" = yes ; then
+       cf_x_athena=neXtaw
+       AC_MSG_RESULT(yes)
+else
+       AC_MSG_RESULT(no)
+fi
+
+AC_MSG_CHECKING(if you want to link with Athena-Plus library)
+withval=
+AC_ARG_WITH(XawPlus,
+       [  --with-XawPlus          link with Athena-Plus library])
+if test "$withval" = yes ; then
+       cf_x_athena=XawPlus
+       AC_MSG_RESULT(yes)
+else
+       AC_MSG_RESULT(no)
+fi
+
+cf_x_athena_lib=""
+
+if test "$PKG_CONFIG" != none ; then
+       cf_athena_list=
+       test "$cf_x_athena" = Xaw && cf_athena_list="xaw8 xaw7 xaw6"
+       for cf_athena_pkg in \
+               $cf_athena_list \
+               ${cf_x_athena} \
+               ${cf_x_athena}-devel \
+               lib${cf_x_athena} \
+               lib${cf_x_athena}-devel
+       do
+               CF_TRY_PKG_CONFIG($cf_athena_pkg,[
+                       cf_x_athena_lib="$cf_pkgconfig_libs"
+                       CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
+                       AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
+
+                       CF_TRIM_X_LIBS
+
+AC_CACHE_CHECK(for usable $cf_x_athena/Xmu package,cf_cv_xaw_compat,[
+AC_TRY_LINK([
+#include <X11/Xmu/CharSet.h>
+],[
+int check = XmuCompareISOLatin1("big", "small")
+],[cf_cv_xaw_compat=yes],[cf_cv_xaw_compat=no])])
+
+                       if test "$cf_cv_xaw_compat" = no
+                       then
+                               # workaround for broken ".pc" files...
+                               case "$cf_x_athena_lib" in #(vi
+                               *-lXmu*) #(vi
+                                       ;;
+                               *)
+                                       CF_VERBOSE(work around broken package)
+                                       cf_save_xmu="$LIBS"
+                                       cf_first_lib=`echo "$cf_save_xmu" | sed -e 's/^[ ][ ]*//' -e 's/ .*//'`
+                                       CF_TRY_PKG_CONFIG(xmu,[
+                                                       LIBS="$cf_save_xmu"
+                                                       CF_ADD_LIB_AFTER($cf_first_lib,$cf_pkgconfig_libs)
+                                               ],[
+                                                       CF_ADD_LIB_AFTER($cf_first_lib,-lXmu)
+                                               ])
+                                       CF_TRIM_X_LIBS
+                                       ;;
+                               esac
+                       fi
+
+                       break])
+       done
+fi
+
+if test -z "$cf_x_athena_lib" ; then
+       CF_X_EXT
+       CF_X_TOOLKIT
+       CF_X_ATHENA_CPPFLAGS($cf_x_athena)
+       CF_X_ATHENA_LIBS($cf_x_athena)
+fi
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_X_ATHENA_CPPFLAGS version: 5 updated: 2010/05/26 17:35:30
+dnl --------------------
+dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
+dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
+AC_DEFUN([CF_X_ATHENA_CPPFLAGS],
+[
+cf_x_athena_root=ifelse([$1],,Xaw,[$1])
+cf_x_athena_inc=""
+
+for cf_path in default \
+       /usr/contrib/X11R6 \
+       /usr/contrib/X11R5 \
+       /usr/lib/X11R5 \
+       /usr/local
+do
+       if test -z "$cf_x_athena_inc" ; then
+               cf_save="$CPPFLAGS"
+               cf_test=X11/$cf_x_athena_root/SimpleMenu.h
+               if test $cf_path != default ; then
+                       CPPFLAGS="$cf_save -I$cf_path/include"
+                       AC_MSG_CHECKING(for $cf_test in $cf_path)
+               else
+                       AC_MSG_CHECKING(for $cf_test)
+               fi
+               AC_TRY_COMPILE([
+#include <X11/Intrinsic.h>
+#include <$cf_test>],[],
+                       [cf_result=yes],
+                       [cf_result=no])
+               AC_MSG_RESULT($cf_result)
+               if test "$cf_result" = yes ; then
+                       cf_x_athena_inc=$cf_path
+                       break
+               else
+                       CPPFLAGS="$cf_save"
+               fi
+       fi
+done
+
+if test -z "$cf_x_athena_inc" ; then
+       AC_MSG_WARN(
+[Unable to successfully find Athena header files with test program])
+elif test "$cf_x_athena_inc" != default ; then
+       CPPFLAGS="$CPPFLAGS -I$cf_x_athena_inc"
+fi
+])
+dnl ---------------------------------------------------------------------------
+dnl CF_X_ATHENA_LIBS version: 12 updated: 2011/07/17 19:55:02
+dnl ----------------
+dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
+dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
+AC_DEFUN([CF_X_ATHENA_LIBS],
+[AC_REQUIRE([CF_X_TOOLKIT])
+cf_x_athena_root=ifelse([$1],,Xaw,[$1])
+cf_x_athena_lib=""
+
+for cf_path in default \
+       /usr/contrib/X11R6 \
+       /usr/contrib/X11R5 \
+       /usr/lib/X11R5 \
+       /usr/local
+do
+       for cf_lib in \
+               ${cf_x_athena_root} \
+               ${cf_x_athena_root}7 \
+               ${cf_x_athena_root}6
+       do
+       for cf_libs in \
+               "-l$cf_lib -lXmu" \
+               "-l$cf_lib -lXpm -lXmu" \
+               "-l${cf_lib}_s -lXmu_s"
+       do
+               if test -z "$cf_x_athena_lib" ; then
+                       cf_save="$LIBS"
+                       cf_test=XawSimpleMenuAddGlobalActions
+                       if test $cf_path != default ; then
+                               CF_ADD_LIBS(-L$cf_path/lib $cf_libs)
+                               AC_MSG_CHECKING(for $cf_libs in $cf_path)
+                       else
+                               CF_ADD_LIBS($cf_libs)
+                               AC_MSG_CHECKING(for $cf_test in $cf_libs)
+                       fi
+                       AC_TRY_LINK([
+#include <X11/Intrinsic.h>
+#include <X11/$cf_x_athena_root/SimpleMenu.h>
+],[
+$cf_test((XtAppContext) 0)],
+                               [cf_result=yes],
+                               [cf_result=no])
+                       AC_MSG_RESULT($cf_result)
+                       if test "$cf_result" = yes ; then
+                               cf_x_athena_lib="$cf_libs"
+                               break
+                       fi
+                       LIBS="$cf_save"
+               fi
+       done # cf_libs
+               test -n "$cf_x_athena_lib" && break
+       done # cf_lib
+done
+
+if test -z "$cf_x_athena_lib" ; then
+       AC_MSG_ERROR(
+[Unable to successfully link Athena library (-l$cf_x_athena_root) with test program])
+fi
+
+CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
+AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
+])
+dnl ---------------------------------------------------------------------------
+dnl CF_X_EXT version: 3 updated: 2010/06/02 05:03:05
+dnl --------
+AC_DEFUN([CF_X_EXT],[
+CF_TRY_PKG_CONFIG(Xext,,[
+       AC_CHECK_LIB(Xext,XextCreateExtension,
+               [CF_ADD_LIB(Xext)])])
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF_X_TOOLKIT version: 22 updated: 2014/07/13 14:33:27
+dnl ------------
+dnl Check for X Toolkit libraries
+AC_DEFUN([CF_X_TOOLKIT],
+[
+AC_REQUIRE([AC_PATH_XTRA])
+AC_REQUIRE([CF_CHECK_CACHE])
+
+# OSX is schizoid about who owns /usr/X11 (old) versus /opt/X11 (new), and (and
+# in some cases has installed dummy files in the former, other cases replaced
+# it with a link to the new location).  This complicates the configure script. 
+# Check for that pitfall, and recover using pkg-config
+#
+# If none of these are set, the configuration is almost certainly broken.
+if test -z "${X_CFLAGS}${X_PRE_LIBS}${X_LIBS}${X_EXTRA_LIBS}"
+then
+       CF_TRY_PKG_CONFIG(x11,,[AC_MSG_WARN(unable to find X11 library)])
+       CF_TRY_PKG_CONFIG(ice,,[AC_MSG_WARN(unable to find ICE library)])
+       CF_TRY_PKG_CONFIG(sm,,[AC_MSG_WARN(unable to find SM library)])
+       CF_TRY_PKG_CONFIG(xt,,[AC_MSG_WARN(unable to find Xt library)])
+fi
+
+cf_have_X_LIBS=no
+
+CF_TRY_PKG_CONFIG(xt,[
+
+       case "x$LIBS" in #(vi
+       *-lX11*) #(vi
+               ;;
+       *)
+# we have an "xt" package, but it may omit Xt's dependency on X11
+AC_CACHE_CHECK(for usable X dependency,cf_cv_xt_x11_compat,[
+AC_TRY_LINK([
+#include <X11/Xlib.h>
+],[
+       int rc1 = XDrawLine((Display*) 0, (Drawable) 0, (GC) 0, 0, 0, 0, 0);
+       int rc2 = XClearWindow((Display*) 0, (Window) 0);
+       int rc3 = XMoveWindow((Display*) 0, (Window) 0, 0, 0);
+       int rc4 = XMoveResizeWindow((Display*)0, (Window)0, 0, 0, 0, 0);
+],[cf_cv_xt_x11_compat=yes],[cf_cv_xt_x11_compat=no])])
+               if test "$cf_cv_xt_x11_compat" = no
+               then
+                       CF_VERBOSE(work around broken X11 dependency)
+                       # 2010/11/19 - good enough until a working Xt on Xcb is delivered.
+                       CF_TRY_PKG_CONFIG(x11,,[CF_ADD_LIB_AFTER(-lXt,-lX11)])
+               fi
+               ;;
+       esac
+
+AC_CACHE_CHECK(for usable X Toolkit package,cf_cv_xt_ice_compat,[
+AC_TRY_LINK([
+#include <X11/Shell.h>
+],[int num = IceConnectionNumber(0)
+],[cf_cv_xt_ice_compat=yes],[cf_cv_xt_ice_compat=no])])
+
+       if test "$cf_cv_xt_ice_compat" = no
+       then
+               # workaround for broken ".pc" files used for X Toolkit.
+               case "x$X_PRE_LIBS" in #(vi
+               *-lICE*)
+                       case "x$LIBS" in #(vi
+                       *-lICE*) #(vi
+                               ;;
+                       *)
+                               CF_VERBOSE(work around broken ICE dependency)
+                               CF_TRY_PKG_CONFIG(ice,
+                                       [CF_TRY_PKG_CONFIG(sm)],
+                                       [CF_ADD_LIB_AFTER(-lXt,$X_PRE_LIBS)])
+                               ;;
+                       esac
+                       ;;
+               esac
+       fi
+
+       cf_have_X_LIBS=yes
+],[
+
+       LDFLAGS="$X_LIBS $LDFLAGS"
+       CF_CHECK_CFLAGS($X_CFLAGS)
+
+       AC_CHECK_FUNC(XOpenDisplay,,[
+       AC_CHECK_LIB(X11,XOpenDisplay,
+               [CF_ADD_LIB(X11)],,
+               [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])])
+
+       AC_CHECK_FUNC(XtAppInitialize,,[
+       AC_CHECK_LIB(Xt, XtAppInitialize,
+               [AC_DEFINE(HAVE_LIBXT,1,[Define to 1 if we can compile with the Xt library])
+                cf_have_X_LIBS=Xt
+                LIBS="-lXt $X_PRE_LIBS $LIBS $X_EXTRA_LIBS"],,
+               [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])])
+])
+
+if test $cf_have_X_LIBS = no ; then
+       AC_MSG_WARN(
+[Unable to successfully link X Toolkit library (-lXt) with
+test program.  You will have to check and add the proper libraries by hand
+to makefile.])
+fi
+])dnl
+dnl ---------------------------------------------------------------------------
+dnl CF__CURSES_HEAD version: 2 updated: 2010/10/23 15:54:49
+dnl ---------------
+dnl Define a reusable chunk which includes <curses.h> and <term.h> when they
+dnl are both available.
+define([CF__CURSES_HEAD],[
+#ifdef HAVE_XCURSES
+#include <xcurses.h>
+char * XCursesProgramName = "test";
+#else
+#include <${cf_cv_ncurses_header:-curses.h}>
+#if defined(NCURSES_VERSION) && defined(HAVE_NCURSESW_TERM_H)
+#include <ncursesw/term.h>
+#elif defined(NCURSES_VERSION) && defined(HAVE_NCURSES_TERM_H)
+#include <ncurses/term.h>
+#elif defined(HAVE_TERM_H)
+#include <term.h>
+#endif
+#endif
+])