test/aclocal.m4

   1 dnl***************************************************************************
   2 dnl Copyright 2018-2019,2020 Thomas E. Dickey                                *
   3 dnl Copyright 2003-2017,2018 Free Software Foundation, Inc.                  *
   4 dnl                                                                          *
   5 dnl Permission is hereby granted, free of charge, to any person obtaining a  *
   6 dnl copy of this software and associated documentation files (the            *
   7 dnl "Software"), to deal in the Software without restriction, including      *
   8 dnl without limitation the rights to use, copy, modify, merge, publish,      *
   9 dnl distribute, distribute with modifications, sublicense, and/or sell       *
  10 dnl copies of the Software, and to permit persons to whom the Software is    *
  11 dnl furnished to do so, subject to the following conditions:                 *
  12 dnl                                                                          *
  13 dnl The above copyright notice and this permission notice shall be included  *
  14 dnl in all copies or substantial portions of the Software.                   *
  15 dnl                                                                          *
  16 dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  17 dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  18 dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  19 dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  20 dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  21 dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  22 dnl THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  23 dnl                                                                          *
  24 dnl Except as contained in this notice, the name(s) of the above copyright   *
  25 dnl holders shall not be used in advertising or otherwise to promote the     *
  26 dnl sale, use or other dealings in this Software without prior written       *
  27 dnl authorization.                                                           *
  28 dnl***************************************************************************
  29 dnl
  30 dnl $Id: aclocal.m4,v 1.183 2020/09/26 22:13:19 tom Exp $
  31 dnl
  32 dnl Author: Thomas E. Dickey
  33 dnl
  34 dnl Macros used in NCURSES test programs auto-configuration script.
  35 dnl
  36 dnl These macros are maintained separately from NCURSES.  The copyright on
  37 dnl this file applies to the aggregation of macros and does not affect use of
  38 dnl these macros in other applications.
  39 dnl
  40 dnl See these pages for additional information:
  41 dnl             https://invisible-island.net/autoconf/
  42 dnl             https://invisible-island.net/autoconf/my-autoconf.html
  43 dnl
  44 dnl ---------------------------------------------------------------------------
  45 dnl ---------------------------------------------------------------------------
  46 dnl AM_LANGINFO_CODESET version: 5 updated: 2020/03/10 18:53:47
  47 dnl -------------------
  48 dnl Inserted as requested by gettext 0.10.40
  49 dnl File from /usr/share/aclocal
  50 dnl codeset.m4
  51 dnl ====================
  52 dnl serial AM1
  53 dnl
  54 dnl From Bruno Haible.
  55 AC_DEFUN([AM_LANGINFO_CODESET],
  56 [
  57 AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset,
  58         [AC_TRY_LINK([#include <langinfo.h>],
  59         [char* cs = nl_langinfo(CODESET); (void)cs],
  60         am_cv_langinfo_codeset=yes,
  61         am_cv_langinfo_codeset=no)
  62         ])
  63         if test $am_cv_langinfo_codeset = yes; then
  64                 AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
  65                 [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
  66         fi
  67 ])dnl
  68 dnl ---------------------------------------------------------------------------
  69 dnl CF_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49
  70 dnl ------------------
  71 dnl Conditionally generate script according to whether we're using a given autoconf.
  72 dnl
  73 dnl $1 = version to compare against
  74 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
  75 dnl $3 = code to use if AC_ACVERSION is older than $1.
  76 define([CF_ACVERSION_CHECK],
  77 [
  78 ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
  79 ifdef([m4_version_compare],
  80 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
  81 [CF_ACVERSION_COMPARE(
  82 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
  83 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
  84 dnl ---------------------------------------------------------------------------
  85 dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
  86 dnl --------------------
  87 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
  88 dnl                      MAJOR2, MINOR2, TERNARY2,
  89 dnl                      PRINTABLE2, not FOUND, FOUND)
  90 define([CF_ACVERSION_COMPARE],
  91 [ifelse(builtin([eval], [$2 < $5]), 1,
  92 [ifelse([$8], , ,[$8])],
  93 [ifelse([$9], , ,[$9])])])dnl
  94 dnl ---------------------------------------------------------------------------
  95 dnl CF_ADD_CFLAGS version: 14 updated: 2020/04/04 16:16:13
  96 dnl -------------
  97 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
  98 dnl $1 = flags to add
  99 dnl $2 = if given makes this macro verbose.
 100 dnl
 101 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
 102 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
 103 dnl confused by the quotes (which require backslashes to keep them usable).
 104 AC_DEFUN([CF_ADD_CFLAGS],
 105 [
 106 cf_fix_cppflags=no
 107 cf_new_cflags=
 108 cf_new_cppflags=
 109 cf_new_extra_cppflags=
 110
 111 for cf_add_cflags in $1
 112 do
 113 case $cf_fix_cppflags in
 114 (no)
 115         case $cf_add_cflags in
 116         (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
 117                 case $cf_add_cflags in
 118                 (-D*)
 119                         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
 120
 121                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
 122                                 && test -z "${cf_tst_cflags}" \
 123                                 && cf_fix_cppflags=yes
 124
 125                         if test $cf_fix_cppflags = yes ; then
 126                                 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
 127                                 continue
 128                         elif test "${cf_tst_cflags}" = "\"'" ; then
 129                                 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
 130                                 continue
 131                         fi
 132                         ;;
 133                 esac
 134                 case "$CPPFLAGS" in
 135                 (*$cf_add_cflags)
 136                         ;;
 137                 (*)
 138                         case $cf_add_cflags in
 139                         (-D*)
 140                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
 141                                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
 142                                 ;;
 143                         esac
 144                         CF_APPEND_TEXT(cf_new_cppflags,$cf_add_cflags)
 145                         ;;
 146                 esac
 147                 ;;
 148         (*)
 149                 CF_APPEND_TEXT(cf_new_cflags,$cf_add_cflags)
 150                 ;;
 151         esac
 152         ;;
 153 (yes)
 154         CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
 155
 156         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
 157
 158         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
 159                 && test -z "${cf_tst_cflags}" \
 160                 && cf_fix_cppflags=no
 161         ;;
 162 esac
 163 done
 164
 165 if test -n "$cf_new_cflags" ; then
 166         ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
 167         CF_APPEND_TEXT(CFLAGS,$cf_new_cflags)
 168 fi
 169
 170 if test -n "$cf_new_cppflags" ; then
 171         ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
 172         CF_APPEND_TEXT(CPPFLAGS,$cf_new_cppflags)
 173 fi
 174
 175 if test -n "$cf_new_extra_cppflags" ; then
 176         ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
 177         CF_APPEND_TEXT(EXTRA_CPPFLAGS,$cf_new_extra_cppflags)
 178 fi
 179
 180 AC_SUBST(EXTRA_CPPFLAGS)
 181
 182 ])dnl
 183 dnl ---------------------------------------------------------------------------
 184 dnl CF_ADD_INCDIR version: 15 updated: 2018/06/20 20:23:13
 185 dnl -------------
 186 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it's
 187 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
 188 dnl but old versions (and some misinstalled ones) need that.  To make things
 189 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
 190 dnl the include-path).
 191 AC_DEFUN([CF_ADD_INCDIR],
 192 [
 193 if test -n "$1" ; then
 194   for cf_add_incdir in $1
 195   do
 196         while test $cf_add_incdir != /usr/include
 197         do
 198           if test -d $cf_add_incdir
 199           then
 200                 cf_have_incdir=no
 201                 if test -n "$CFLAGS$CPPFLAGS" ; then
 202                   # a loop is needed to ensure we can add subdirs of existing dirs
 203                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
 204                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
 205                           cf_have_incdir=yes; break
 206                         fi
 207                   done
 208                 fi
 209
 210                 if test "$cf_have_incdir" = no ; then
 211                   if test "$cf_add_incdir" = /usr/local/include ; then
 212                         if test "$GCC" = yes
 213                         then
 214                           cf_save_CPPFLAGS=$CPPFLAGS
 215                           CF_APPEND_TEXT(CPPFLAGS,-I$cf_add_incdir)
 216                           AC_TRY_COMPILE([#include <stdio.h>],
 217                                   [printf("Hello")],
 218                                   [],
 219                                   [cf_have_incdir=yes])
 220                           CPPFLAGS=$cf_save_CPPFLAGS
 221                         fi
 222                   fi
 223                 fi
 224
 225                 if test "$cf_have_incdir" = no ; then
 226                   CF_VERBOSE(adding $cf_add_incdir to include-path)
 227                   ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
 228
 229                   cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
 230                   test "$cf_top_incdir" = "$cf_add_incdir" && break
 231                   cf_add_incdir="$cf_top_incdir"
 232                 else
 233                   break
 234                 fi
 235           else
 236                 break
 237           fi
 238         done
 239   done
 240 fi
 241 ])dnl
 242 dnl ---------------------------------------------------------------------------
 243 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
 244 dnl ----------
 245 dnl Add a library, used to enforce consistency.
 246 dnl
 247 dnl $1 = library to add, without the "-l"
 248 dnl $2 = variable to update (default $LIBS)
 249 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
 250 dnl ---------------------------------------------------------------------------
 251 dnl CF_ADD_LIBDIR version: 10 updated: 2015/04/18 08:56:57
 252 dnl -------------
 253 dnl     Adds to the library-path
 254 dnl
 255 dnl     Some machines have trouble with multiple -L options.
 256 dnl
 257 dnl $1 is the (list of) directory(s) to add
 258 dnl $2 is the optional name of the variable to update (default LDFLAGS)
 259 dnl
 260 AC_DEFUN([CF_ADD_LIBDIR],
 261 [
 262 if test -n "$1" ; then
 263         for cf_add_libdir in $1
 264         do
 265                 if test $cf_add_libdir = /usr/lib ; then
 266                         :
 267                 elif test -d $cf_add_libdir
 268                 then
 269                         cf_have_libdir=no
 270                         if test -n "$LDFLAGS$LIBS" ; then
 271                                 # a loop is needed to ensure we can add subdirs of existing dirs
 272                                 for cf_test_libdir in $LDFLAGS $LIBS ; do
 273                                         if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
 274                                                 cf_have_libdir=yes; break
 275                                         fi
 276                                 done
 277                         fi
 278                         if test "$cf_have_libdir" = no ; then
 279                                 CF_VERBOSE(adding $cf_add_libdir to library-path)
 280                                 ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
 281                         fi
 282                 fi
 283         done
 284 fi
 285 ])dnl
 286 dnl ---------------------------------------------------------------------------
 287 dnl CF_ADD_LIBS version: 3 updated: 2019/11/02 16:47:33
 288 dnl -----------
 289 dnl Add one or more libraries, used to enforce consistency.  Libraries are
 290 dnl prepended to an existing list, since their dependencies are assumed to
 291 dnl already exist in the list.
 292 dnl
 293 dnl $1 = libraries to add, with the "-l", etc.
 294 dnl $2 = variable to update (default $LIBS)
 295 AC_DEFUN([CF_ADD_LIBS],[
 296 cf_add_libs="[$]ifelse($2,,LIBS,[$2])"
 297 # reverse order
 298 cf_add_0lib=
 299 for cf_add_1lib in $1; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done
 300 # filter duplicates
 301 for cf_add_1lib in $cf_add_0lib; do
 302         for cf_add_2lib in $cf_add_libs; do
 303                 if test "x$cf_add_1lib" = "x$cf_add_2lib"; then
 304                         cf_add_1lib=
 305                         break
 306                 fi
 307         done
 308         test -n "$cf_add_1lib" && cf_add_libs="$cf_add_1lib $cf_add_libs"
 309 done
 310 ifelse($2,,LIBS,[$2])="$cf_add_libs"
 311 ])dnl
 312 dnl ---------------------------------------------------------------------------
 313 dnl CF_ADD_LIB_AFTER version: 3 updated: 2013/07/09 21:27:22
 314 dnl ----------------
 315 dnl Add a given library after another, e.g., following the one it satisfies a
 316 dnl dependency for.
 317 dnl
 318 dnl $1 = the first library
 319 dnl $2 = its dependency
 320 AC_DEFUN([CF_ADD_LIB_AFTER],[
 321 CF_VERBOSE(...before $LIBS)
 322 LIBS=`echo "$LIBS" | sed -e "s/[[       ]][[    ]]*/ /g" -e "s%$1 %$1 $2 %" -e 's%  % %g'`
 323 CF_VERBOSE(...after  $LIBS)
 324 ])dnl
 325 dnl ---------------------------------------------------------------------------
 326 dnl CF_ADD_SUBDIR_PATH version: 4 updated: 2013/10/08 17:47:05
 327 dnl ------------------
 328 dnl Append to a search-list for a nonstandard header/lib-file
 329 dnl     $1 = the variable to return as result
 330 dnl     $2 = the package name
 331 dnl     $3 = the subdirectory, e.g., bin, include or lib
 332 dnl $4 = the directory under which we will test for subdirectories
 333 dnl $5 = a directory that we do not want $4 to match
 334 AC_DEFUN([CF_ADD_SUBDIR_PATH],
 335 [
 336 test "x$4" != "x$5" && \
 337 test -d "$4" && \
 338 ifelse([$5],NONE,,[(test -z "$5" || test x$5 = xNONE || test "x$4" != "x$5") &&]) {
 339         test -n "$verbose" && echo "    ... testing for $3-directories under $4"
 340         test -d $4/$3 &&          $1="[$]$1 $4/$3"
 341         test -d $4/$3/$2 &&       $1="[$]$1 $4/$3/$2"
 342         test -d $4/$3/$2/$3 &&    $1="[$]$1 $4/$3/$2/$3"
 343         test -d $4/$2/$3 &&       $1="[$]$1 $4/$2/$3"
 344         test -d $4/$2/$3/$2 &&    $1="[$]$1 $4/$2/$3/$2"
 345 }
 346 ])dnl
 347 dnl ---------------------------------------------------------------------------
 348 dnl CF_APPEND_TEXT version: 1 updated: 2017/02/25 18:58:55
 349 dnl --------------
 350 dnl use this macro for appending text without introducing an extra blank at
 351 dnl the beginning
 352 define([CF_APPEND_TEXT],
 353 [
 354         test -n "[$]$1" && $1="[$]$1 "
 355         $1="[$]{$1}$2"
 356 ])dnl
 357 dnl ---------------------------------------------------------------------------
 358 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
 359 dnl --------------
 360 dnl Allow user to disable a normally-on option.
 361 AC_DEFUN([CF_ARG_DISABLE],
 362 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
 363 dnl ---------------------------------------------------------------------------
 364 dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31
 365 dnl -------------
 366 dnl Allow user to enable a normally-off option.
 367 AC_DEFUN([CF_ARG_ENABLE],
 368 [CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl
 369 dnl ---------------------------------------------------------------------------
 370 dnl CF_ARG_OPTION version: 5 updated: 2015/05/10 19:52:14
 371 dnl -------------
 372 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
 373 dnl values.
 374 dnl
 375 dnl Parameters:
 376 dnl $1 = option name
 377 dnl $2 = help-string
 378 dnl $3 = action to perform if option is not default
 379 dnl $4 = action if perform if option is default
 380 dnl $5 = default option value (either 'yes' or 'no')
 381 AC_DEFUN([CF_ARG_OPTION],
 382 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
 383         if test "$enableval" != "$5" ; then
 384 ifelse([$3],,[    :]dnl
 385 ,[    $3]) ifelse([$4],,,[
 386         else
 387                 $4])
 388         fi],[enableval=$5 ifelse([$4],,,[
 389         $4
 390 ])dnl
 391 ])])dnl
 392 dnl ---------------------------------------------------------------------------
 393 dnl CF_CC_ENV_FLAGS version: 9 updated: 2018/07/29 18:03:26
 394 dnl ---------------
 395 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
 396 dnl into CC.  This will not help with broken scripts that wrap the compiler
 397 dnl with options, but eliminates a more common category of user confusion.
 398 dnl
 399 dnl In particular, it addresses the problem of being able to run the C
 400 dnl preprocessor in a consistent manner.
 401 dnl
 402 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
 403 dnl the nuisance of having inconsistent settings for compiler and preprocessor
 404 dnl outweighs that limitation.
 405 AC_DEFUN([CF_CC_ENV_FLAGS],
 406 [
 407 # This should have been defined by AC_PROG_CC
 408 : ${CC:=cc}
 409
 410 AC_MSG_CHECKING(\$CFLAGS variable)
 411 case "x$CFLAGS" in
 412 (*-[[IUD]]*)
 413         AC_MSG_RESULT(broken)
 414         AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
 415         cf_flags="$CFLAGS"
 416         CFLAGS=
 417         for cf_arg in $cf_flags
 418         do
 419                 CF_ADD_CFLAGS($cf_arg)
 420         done
 421         ;;
 422 (*)
 423         AC_MSG_RESULT(ok)
 424         ;;
 425 esac
 426
 427 AC_MSG_CHECKING(\$CC variable)
 428 case "$CC" in
 429 (*[[\ \ ]]-*)
 430         AC_MSG_RESULT(broken)
 431         AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
 432         # humor him...
 433         cf_prog=`echo "$CC" | sed -e 's/        / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
 434         cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'`
 435         CC="$cf_prog"
 436         for cf_arg in $cf_flags
 437         do
 438                 case "x$cf_arg" in
 439                 (x-[[IUDfgOW]]*)
 440                         CF_ADD_CFLAGS($cf_arg)
 441                         ;;
 442                 (*)
 443                         CC="$CC $cf_arg"
 444                         ;;
 445                 esac
 446         done
 447         CF_VERBOSE(resulting CC: '$CC')
 448         CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
 449         CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
 450         ;;
 451 (*)
 452         AC_MSG_RESULT(ok)
 453         ;;
 454 esac
 455 ])dnl
 456 dnl ---------------------------------------------------------------------------
 457 dnl CF_CHECK_CACHE version: 12 updated: 2012/10/02 20:55:03
 458 dnl --------------
 459 dnl Check if we're accidentally using a cache from a different machine.
 460 dnl Derive the system name, as a check for reusing the autoconf cache.
 461 dnl
 462 dnl If we've packaged config.guess and config.sub, run that (since it does a
 463 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
 464 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
 465 dnl which is useful in cross-compiles.
 466 dnl
 467 dnl Note: we would use $ac_config_sub, but that is one of the places where
 468 dnl autoconf 2.5x broke compatibility with autoconf 2.13
 469 AC_DEFUN([CF_CHECK_CACHE],
 470 [
 471 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
 472         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
 473         system_name="$host_os"
 474 else
 475         system_name="`(uname -s -r) 2>/dev/null`"
 476         if test -z "$system_name" ; then
 477                 system_name="`(hostname) 2>/dev/null`"
 478         fi
 479 fi
 480 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
 481 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
 482
 483 test -z "$system_name" && system_name="$cf_cv_system_name"
 484 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
 485
 486 if test ".$system_name" != ".$cf_cv_system_name" ; then
 487         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
 488         AC_MSG_ERROR("Please remove config.cache and try again.")
 489 fi
 490 ])dnl
 491 dnl ---------------------------------------------------------------------------
 492 dnl CF_CHECK_CFLAGS version: 3 updated: 2014/07/22 05:32:57
 493 dnl ---------------
 494 dnl Conditionally add to $CFLAGS and $CPPFLAGS values which are derived from
 495 dnl a build-configuration such as imake.  These have the pitfall that they
 496 dnl often contain compiler-specific options which we cannot use, mixed with
 497 dnl preprocessor options that we usually can.
 498 AC_DEFUN([CF_CHECK_CFLAGS],
 499 [
 500 CF_VERBOSE(checking additions to CFLAGS)
 501 cf_check_cflags="$CFLAGS"
 502 cf_check_cppflags="$CPPFLAGS"
 503 CF_ADD_CFLAGS($1,yes)
 504 if test "x$cf_check_cflags" != "x$CFLAGS" ; then
 505 AC_TRY_LINK([#include <stdio.h>],[printf("Hello world");],,
 506         [CF_VERBOSE(test-compile failed.  Undoing change to \$CFLAGS)
 507          if test "x$cf_check_cppflags" != "x$CPPFLAGS" ; then
 508                  CF_VERBOSE(but keeping change to \$CPPFLAGS)
 509          fi
 510          CFLAGS="$cf_check_flags"])
 511 fi
 512 ])dnl
 513 dnl ---------------------------------------------------------------------------
 514 dnl CF_CHECK_CURSES_LIB version: 2 updated: 2018/01/03 04:47:33
 515 dnl -------------------
 516 dnl $1 = nominal library name, used also for header lookup
 517 dnl $2 = suffix to append to library name
 518 dnl $3 = function to check for using AC_CHECK_LIB
 519 dnl $4 = optional parameter list for $3
 520 AC_DEFUN([CF_CHECK_CURSES_LIB],
 521 [
 522 AC_REQUIRE([CF_PKG_CONFIG])
 523
 524 cf_have_curses_lib=no
 525
 526 : ${NCURSES_CONFIG_PKG:=none}
 527 if test "x${NCURSES_CONFIG_PKG}" = xnone; then
 528         :
 529 elif test "x${PKG_CONFIG:=none}" != xnone; then
 530         AC_MSG_CHECKING(pkg-config for $1$2)
 531         if "$PKG_CONFIG" --exists $1$2 ; then
 532                 AC_MSG_RESULT(yes)
 533
 534                 AC_MSG_CHECKING(if the $1$2 package files work)
 535
 536                 cf_save_CPPFLAGS="$CPPFLAGS"
 537                 cf_save_LIBS="$LIBS"
 538
 539                 CF_ADD_CFLAGS(`$PKG_CONFIG --cflags $1$2`)
 540                 CF_ADD_LIBS(`$PKG_CONFIG --libs $1$2`)
 541
 542                 AC_TRY_LINK([#include <$1.h>],
 543                         [(void) $3 ( ]ifelse([$4],,,[[$4]])[ );],
 544                         [AC_TRY_RUN([#include <$1.h>
 545                                 int main(void)
 546                                 { (void) $3 ( ]ifelse([$4],,,[[$4]])[ ); return 0; }],
 547                                 [cf_have_curses_lib=yes],
 548                                 [cf_have_curses_lib=no],
 549                                 [cf_have_curses_lib=maybe])],
 550                         [cf_have_curses_lib=no])
 551                 AC_MSG_RESULT($cf_have_curses_lib)
 552                 test "$cf_have_curses_lib" = maybe && cf_have_curses_lib=yes
 553                 if test "$cf_have_curses_lib" != "yes"
 554                 then
 555                         CPPFLAGS="$cf_save_CPPFLAGS"
 556                         LIBS="$cf_save_LIBS"
 557                 else
 558                         CF_UPPER(cf_upper,have_lib$1)
 559                         AC_DEFINE_UNQUOTED($cf_upper,1)
 560                 fi
 561         fi
 562 fi
 563 if test "$cf_have_curses_lib" = no; then
 564         AC_CHECK_LIB($1$2,$3,[
 565                 CF_UPPER(cf_upper,have_lib$1)
 566                 CF_ADD_LIBS(-l$1$2)
 567                 AC_DEFINE_UNQUOTED($cf_upper,1)])
 568 fi
 569 ])dnl
 570 dnl ---------------------------------------------------------------------------
 571 dnl CF_CLANG_COMPILER version: 3 updated: 2020/08/28 04:10:22
 572 dnl -----------------
 573 dnl Check if the given compiler is really clang.  clang's C driver defines
 574 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
 575 dnl not ignore some gcc options.
 576 dnl
 577 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
 578 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
 579 dnl the wrappers for gcc and g++ warnings.
 580 dnl
 581 dnl $1 = GCC (default) or GXX
 582 dnl $2 = CLANG_COMPILER (default)
 583 dnl $3 = CFLAGS (default) or CXXFLAGS
 584 AC_DEFUN([CF_CLANG_COMPILER],[
 585 ifelse([$2],,CLANG_COMPILER,[$2])=no
 586
 587 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
 588         AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
 589         cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
 590         ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -Qunused-arguments"
 591         AC_TRY_COMPILE([],[
 592 #ifdef __clang__
 593 #else
 594 make an error
 595 #endif
 596 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
 597 cf_save_CFLAGS="$cf_save_CFLAGS -Qunused-arguments"
 598 ],[])
 599         ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
 600         AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
 601 fi
 602
 603 if test "x$CLANG_COMPILER" = "xyes" ; then
 604         CF_APPEND_TEXT(CFLAGS,-Wno-error=implicit-function-declaration)
 605 fi
 606 ])
 607 dnl ---------------------------------------------------------------------------
 608 dnl CF_CONST_X_STRING version: 4 updated: 2020/03/10 18:53:47
 609 dnl -----------------
 610 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
 611 dnl character-strings.
 612 dnl
 613 dnl It is ambiguous because the specification accommodated the pre-ANSI
 614 dnl compilers bundled by more than one vendor in lieu of providing a standard C
 615 dnl compiler other than by costly add-ons.  Because of this, the specification
 616 dnl did not take into account the use of const for telling the compiler that
 617 dnl string literals would be in readonly memory.
 618 dnl
 619 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
 620 dnl let the compiler decide how to represent Xt's strings which were #define'd.
 621 dnl That does not solve the problem of using the block of Xt's strings which
 622 dnl are compiled into the library (and is less efficient than one might want).
 623 dnl
 624 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
 625 dnl when compiling the library and compiling using the library, to tell the
 626 dnl compiler that String is const.
 627 AC_DEFUN([CF_CONST_X_STRING],
 628 [
 629 AC_REQUIRE([AC_PATH_XTRA])
 630
 631 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
 632
 633 AC_TRY_COMPILE(
 634 [
 635 #include <stdlib.h>
 636 #include <X11/Intrinsic.h>
 637 ],
 638 [String foo = malloc(1); (void)foo],[
 639
 640 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
 641         AC_TRY_COMPILE(
 642                 [
 643 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
 644 #undef  XTSTRINGDEFINES /* X11R5 and later */
 645 #include <stdlib.h>
 646 #include <X11/Intrinsic.h>
 647                 ],[String foo = malloc(1); *foo = 0],[
 648                         cf_cv_const_x_string=no
 649                 ],[
 650                         cf_cv_const_x_string=yes
 651                 ])
 652 ])
 653
 654 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
 655
 656 case $cf_cv_const_x_string in
 657 (no)
 658         CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
 659         ;;
 660 (*)
 661         CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
 662         ;;
 663 esac
 664
 665 ])
 666 ])dnl
 667 dnl ---------------------------------------------------------------------------
 668 dnl CF_CURSES_ACS_MAP version: 7 updated: 2012/10/06 16:39:58
 669 dnl -----------------
 670 dnl Check for likely values of acs_map[]:
 671 AC_DEFUN([CF_CURSES_ACS_MAP],
 672 [
 673 AC_REQUIRE([CF_NCURSES_WRAP_PREFIX])dnl
 674 AC_CACHE_CHECK(for alternate character set array, cf_cv_curses_acs_map,[
 675 cf_cv_curses_acs_map=unknown
 676 for name in acs_map _acs_map __acs_map ${NCURSES_WRAP_PREFIX}acs_map
 677 do
 678 AC_TRY_LINK([
 679 #include <${cf_cv_ncurses_header:-curses.h}>
 680 ],[
 681 $name['k'] = ACS_PLUS
 682 ],[cf_cv_curses_acs_map=$name; break])
 683 done
 684 ])
 685
 686 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_])
 687 ])
 688 dnl ---------------------------------------------------------------------------
 689 dnl CF_CURSES_CHECK_DATA version: 9 updated: 2020/02/08 21:00:26
 690 dnl --------------------
 691 dnl Check if curses.h defines the given data/variable.
 692 dnl Use this after CF_NCURSES_CONFIG or CF_CURSES_CONFIG.
 693 dnl
 694 dnl $1 = data item(s) to check for
 695 dnl $2 = action on success, e.g., "break" to quit checking a series of choices
 696 AC_DEFUN([CF_CURSES_CHECK_DATA],
 697 [
 698 for cf_data in $1
 699 do
 700 AC_MSG_CHECKING(for data $cf_data declaration in ${cf_cv_ncurses_header:-curses.h})
 701
 702 AC_TRY_COMPILE(CF__CURSES_HEAD,
 703 CF__CURSES_DATA(foo,$cf_data)
 704 ,[cf_result=yes
 705 ],[cf_result=no])
 706 AC_MSG_RESULT($cf_result)
 707
 708 if test $cf_result = yes ; then
 709         CF_UPPER(cf_result,have_curses_data_$cf_data)
 710         AC_DEFINE_UNQUOTED($cf_result)
 711         ifelse($2,,,[$2])
 712 else
 713         AC_MSG_CHECKING(for data $cf_data in library)
 714         # BSD linkers insist on making weak linkage, but resolve at runtime.
 715         AC_TRY_RUN(CF__CURSES_HEAD
 716 [
 717 extern char $cf_data;
 718 int main(void)
 719 {
 720         ]CF__CURSES_DATA(foo,$cf_data)[
 721         ${cf_cv_main_return:-return}(foo == 0);
 722 }],[cf_result=yes
 723 ],[cf_result=no],[
 724         # cross-compiling
 725         AC_TRY_LINK(CF__CURSES_HEAD
 726 [extern char $cf_data;],[
 727         do {
 728                 ]CF__CURSES_DATA(foo,$cf_data)[
 729                 ${cf_cv_main_return:-return}(foo == 0);
 730         } while (0)
 731 ],[cf_result=yes],[cf_result=no])
 732 ])
 733         AC_MSG_RESULT($cf_result)
 734         if test $cf_result = yes ; then
 735                 CF_UPPER(cf_result,decl_curses_data_$cf_data)
 736                 AC_DEFINE_UNQUOTED($cf_result)
 737                 # do not exit loop here, since we prefer system's declarations
 738         fi
 739 fi
 740 done
 741 ])dnl
 742 dnl ---------------------------------------------------------------------------
 743 dnl CF_CURSES_CHECK_TYPE version: 4 updated: 2012/10/06 16:39:58
 744 dnl --------------------
 745 dnl Check if curses.h defines the given type
 746 AC_DEFUN([CF_CURSES_CHECK_TYPE],
 747 [
 748 AC_MSG_CHECKING(for type $1 in ${cf_cv_ncurses_header:-curses.h})
 749 AC_TRY_COMPILE([
 750 #ifndef _XOPEN_SOURCE_EXTENDED
 751 #define _XOPEN_SOURCE_EXTENDED
 752 #endif
 753 #include <${cf_cv_ncurses_header:-curses.h}>],[
 754 $1 foo
 755 ],cf_result=yes,cf_result=no)
 756 AC_MSG_RESULT($cf_result)
 757 if test $cf_result = yes ; then
 758         CF_UPPER(cf_result,have_type_$1)
 759         AC_DEFINE_UNQUOTED($cf_result,1,[Define to 1 if we have type $1])
 760 else
 761         AC_DEFINE_UNQUOTED($1,$2,[Define to appropriate type if $1 is not declared])
 762 fi
 763 ])dnl
 764 dnl ---------------------------------------------------------------------------
 765 dnl CF_CURSES_CONFIG version: 2 updated: 2006/10/29 11:06:27
 766 dnl ----------------
 767 dnl Tie together the configure-script macros for curses.  It may be ncurses,
 768 dnl but unless asked, we do not make a special search for ncurses.  However,
 769 dnl still check for the ncurses version number, for use in other macros.
 770 AC_DEFUN([CF_CURSES_CONFIG],
 771 [
 772 CF_CURSES_CPPFLAGS
 773 CF_NCURSES_VERSION
 774 CF_CURSES_LIBS
 775 ])dnl
 776 dnl ---------------------------------------------------------------------------
 777 dnl CF_CURSES_CPPFLAGS version: 13 updated: 2018/06/20 20:23:13
 778 dnl ------------------
 779 dnl Look for the curses headers.
 780 AC_DEFUN([CF_CURSES_CPPFLAGS],[
 781
 782 AC_CACHE_CHECK(for extra include directories,cf_cv_curses_incdir,[
 783 cf_cv_curses_incdir=no
 784 case $host_os in
 785 (hpux10.*)
 786         if test "x$cf_cv_screen" = "xcurses_colr"
 787         then
 788                 test -d /usr/include/curses_colr && \
 789                 cf_cv_curses_incdir="-I/usr/include/curses_colr"
 790         fi
 791         ;;
 792 (sunos3*|sunos4*)
 793         if test "x$cf_cv_screen" = "xcurses_5lib"
 794         then
 795                 test -d /usr/5lib && \
 796                 test -d /usr/5include && \
 797                 cf_cv_curses_incdir="-I/usr/5include"
 798         fi
 799         ;;
 800 esac
 801 ])
 802 if test "$cf_cv_curses_incdir" != no
 803 then
 804         CF_APPEND_TEXT(CPPFLAGS,$cf_cv_curses_incdir)
 805 fi
 806
 807 CF_CURSES_HEADER
 808 CF_TERM_HEADER
 809 ])dnl
 810 dnl ---------------------------------------------------------------------------
 811 dnl CF_CURSES_FUNCS version: 19 updated: 2018/01/03 04:47:33
 812 dnl ---------------
 813 dnl Curses-functions are a little complicated, since a lot of them are macros.
 814 AC_DEFUN([CF_CURSES_FUNCS],
 815 [
 816 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
 817 AC_REQUIRE([CF_XOPEN_CURSES])
 818 AC_REQUIRE([CF_CURSES_TERM_H])
 819 AC_REQUIRE([CF_CURSES_UNCTRL_H])
 820 for cf_func in $1
 821 do
 822         CF_UPPER(cf_tr_func,$cf_func)
 823         AC_MSG_CHECKING(for ${cf_func})
 824         CF_MSG_LOG(${cf_func})
 825         AC_CACHE_VAL(cf_cv_func_$cf_func,[
 826                 eval cf_result='$ac_cv_func_'$cf_func
 827                 if test ".$cf_result" != ".no"; then
 828                         AC_TRY_LINK(CF__CURSES_HEAD,
 829                         [
 830 #ifndef ${cf_func}
 831 long foo = (long)(&${cf_func});
 832 fprintf(stderr, "testing linkage of $cf_func:%p\n", (void *)foo);
 833 if (foo + 1234L > 5678L)
 834         ${cf_cv_main_return:-return}(foo != 0);
 835 #endif
 836                         ],
 837                         [cf_result=yes],
 838                         [cf_result=no])
 839                 fi
 840                 eval 'cf_cv_func_'$cf_func'=$cf_result'
 841         ])
 842         # use the computed/retrieved cache-value:
 843         eval 'cf_result=$cf_cv_func_'$cf_func
 844         AC_MSG_RESULT($cf_result)
 845         if test $cf_result != no; then
 846                 AC_DEFINE_UNQUOTED(HAVE_${cf_tr_func})
 847         fi
 848 done
 849 ])dnl
 850 dnl ---------------------------------------------------------------------------
 851 dnl CF_CURSES_HEADER version: 5 updated: 2015/04/23 20:35:30
 852 dnl ----------------
 853 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
 854 dnl variations of ncurses' installs.
 855 dnl
 856 dnl $1 = ncurses when looking for ncurses, or is empty
 857 AC_DEFUN([CF_CURSES_HEADER],[
 858 AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[
 859 cf_cv_ncurses_header=none
 860 for cf_header in \
 861         ncurses.h ifelse($1,,,[$1/ncurses.h]) \
 862         curses.h ifelse($1,,,[$1/curses.h]) ifelse($1,,[ncurses/ncurses.h ncurses/curses.h])
 863 do
 864 AC_TRY_COMPILE([#include <${cf_header}>],
 865         [initscr(); tgoto("?", 0,0)],
 866         [cf_cv_ncurses_header=$cf_header; break],[])
 867 done
 868 ])
 869
 870 if test "$cf_cv_ncurses_header" = none ; then
 871         AC_MSG_ERROR(No curses header-files found)
 872 fi
 873
 874 # cheat, to get the right #define's for HAVE_NCURSES_H, etc.
 875 AC_CHECK_HEADERS($cf_cv_ncurses_header)
 876 ])dnl
 877 dnl ---------------------------------------------------------------------------
 878 dnl CF_CURSES_LIBS version: 42 updated: 2018/06/20 20:23:13
 879 dnl --------------
 880 dnl Look for the curses libraries.  Older curses implementations may require
 881 dnl termcap/termlib to be linked as well.  Call CF_CURSES_CPPFLAGS first.
 882 AC_DEFUN([CF_CURSES_LIBS],[
 883
 884 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
 885 AC_MSG_CHECKING(if we have identified curses libraries)
 886 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
 887         [initscr(); tgoto("?", 0,0)],
 888         cf_result=yes,
 889         cf_result=no)
 890 AC_MSG_RESULT($cf_result)
 891
 892 if test "$cf_result" = no ; then
 893 case $host_os in
 894 (freebsd*)
 895         AC_CHECK_LIB(mytinfo,tgoto,[CF_ADD_LIBS(-lmytinfo)])
 896         ;;
 897 (hpux10.*)
 898         # Looking at HPUX 10.20, the Hcurses library is the oldest (1997), cur_colr
 899         # next (1998), and xcurses "newer" (2000).  There is no header file for
 900         # Hcurses; the subdirectory curses_colr has the headers (curses.h and
 901         # term.h) for cur_colr
 902         if test "x$cf_cv_screen" = "xcurses_colr"
 903         then
 904                 AC_CHECK_LIB(cur_colr,initscr,[
 905                         CF_ADD_LIBS(-lcur_colr)
 906                         ac_cv_func_initscr=yes
 907                         ],[
 908                 AC_CHECK_LIB(Hcurses,initscr,[
 909                         # HP's header uses __HP_CURSES, but user claims _HP_CURSES.
 910                         CF_ADD_LIBS(-lHcurses)
 911                         CF_APPEND_TEXT(CPPFLAGS,-D__HP_CURSES -D_HP_CURSES)
 912                         ac_cv_func_initscr=yes
 913                         ])])
 914         fi
 915         ;;
 916 (linux*)
 917         case `arch 2>/dev/null` in
 918         (x86_64)
 919                 if test -d /lib64
 920                 then
 921                         CF_ADD_LIBDIR(/lib64)
 922                 else
 923                         CF_ADD_LIBDIR(/lib)
 924                 fi
 925                 ;;
 926         (*)
 927                 CF_ADD_LIBDIR(/lib)
 928                 ;;
 929         esac
 930         ;;
 931 (sunos3*|sunos4*)
 932         if test "x$cf_cv_screen" = "xcurses_5lib"
 933         then
 934                 if test -d /usr/5lib ; then
 935                         CF_ADD_LIBDIR(/usr/5lib)
 936                         CF_ADD_LIBS(-lcurses -ltermcap)
 937                 fi
 938         fi
 939         ac_cv_func_initscr=yes
 940         ;;
 941 esac
 942
 943 if test ".$ac_cv_func_initscr" != .yes ; then
 944         cf_save_LIBS="$LIBS"
 945
 946         if test ".${cf_cv_ncurses_version:-no}" != .no
 947         then
 948                 cf_check_list="ncurses curses cursesX"
 949         else
 950                 cf_check_list="cursesX curses ncurses"
 951         fi
 952
 953         # Check for library containing tgoto.  Do this before curses library
 954         # because it may be needed to link the test-case for initscr.
 955         if test "x$cf_term_lib" = x
 956         then
 957                 AC_CHECK_FUNC(tgoto,[cf_term_lib=predefined],[
 958                         for cf_term_lib in $cf_check_list otermcap termcap tinfo termlib unknown
 959                         do
 960                                 AC_CHECK_LIB($cf_term_lib,tgoto,[
 961                                         : ${cf_nculib_root:=$cf_term_lib}
 962                                         break
 963                                 ])
 964                         done
 965                 ])
 966         fi
 967
 968         # Check for library containing initscr
 969         test "$cf_term_lib" != predefined && test "$cf_term_lib" != unknown && LIBS="-l$cf_term_lib $cf_save_LIBS"
 970         if test "x$cf_curs_lib" = x
 971         then
 972                 for cf_curs_lib in $cf_check_list xcurses jcurses pdcurses unknown
 973                 do
 974                         LIBS="-l$cf_curs_lib $cf_save_LIBS"
 975                         if test "$cf_term_lib" = unknown || test "$cf_term_lib" = "$cf_curs_lib" ; then
 976                                 AC_MSG_CHECKING(if we can link with $cf_curs_lib library)
 977                                 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
 978                                         [initscr()],
 979                                         [cf_result=yes],
 980                                         [cf_result=no])
 981                                 AC_MSG_RESULT($cf_result)
 982                                 test $cf_result = yes && break
 983                         elif test "$cf_curs_lib" = "$cf_term_lib" ; then
 984                                 cf_result=no
 985                         elif test "$cf_term_lib" != predefined ; then
 986                                 AC_MSG_CHECKING(if we need both $cf_curs_lib and $cf_term_lib libraries)
 987                                 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
 988                                         [initscr(); tgoto((char *)0, 0, 0);],
 989                                         [cf_result=no],
 990                                         [
 991                                         LIBS="-l$cf_curs_lib -l$cf_term_lib $cf_save_LIBS"
 992                                         AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
 993                                                 [initscr()],
 994                                                 [cf_result=yes],
 995                                                 [cf_result=error])
 996                                         ])
 997                                 AC_MSG_RESULT($cf_result)
 998                                 test $cf_result != error && break
 999                         fi
1000                 done
1001         fi
1002         test $cf_curs_lib = unknown && AC_MSG_ERROR(no curses library found)
1003 fi
1004 fi
1005
1006 ])dnl
1007 dnl ---------------------------------------------------------------------------
1008 dnl CF_CURSES_TERM_H version: 12 updated: 2020/03/19 20:23:48
1009 dnl ----------------
1010 dnl SVr4 curses should have term.h as well (where it puts the definitions of
1011 dnl the low-level interface).  This may not be true in old/broken implementations,
1012 dnl as well as in misconfigured systems (e.g., gcc configured for Solaris 2.4
1013 dnl running with Solaris 2.5.1).
1014 AC_DEFUN([CF_CURSES_TERM_H],
1015 [
1016 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
1017
1018 AC_CACHE_CHECK(for term.h, cf_cv_term_header,[
1019
1020 # If we found <ncurses/curses.h>, look for <ncurses/term.h>, but always look
1021 # for <term.h> if we do not find the variant.
1022
1023 cf_header_list="term.h ncurses/term.h ncursesw/term.h"
1024
1025 case ${cf_cv_ncurses_header:-curses.h} in
1026 (*/*)
1027         cf_header_item=`echo ${cf_cv_ncurses_header:-curses.h} | sed -e 's%\..*%%' -e 's%/.*%/%'`term.h
1028         cf_header_list="$cf_header_item $cf_header_list"
1029         ;;
1030 esac
1031
1032 for cf_header in $cf_header_list
1033 do
1034         AC_TRY_COMPILE([
1035 #include <${cf_cv_ncurses_header:-curses.h}>
1036 #include <${cf_header}>],
1037         [WINDOW *x; (void)x],
1038         [cf_cv_term_header=$cf_header
1039          break],
1040         [cf_cv_term_header=no])
1041 done
1042
1043 case $cf_cv_term_header in
1044 (no)
1045         # If curses is ncurses, some packagers still mess it up by trying to make
1046         # us use GNU termcap.  This handles the most common case.
1047         for cf_header in ncurses/term.h ncursesw/term.h
1048         do
1049                 AC_TRY_COMPILE([
1050 #include <${cf_cv_ncurses_header:-curses.h}>
1051 #ifdef NCURSES_VERSION
1052 #include <${cf_header}>
1053 #else
1054 make an error
1055 #endif],
1056                         [WINDOW *x; (void)x],
1057                         [cf_cv_term_header=$cf_header
1058                          break],
1059                         [cf_cv_term_header=no])
1060         done
1061         ;;
1062 esac
1063 ])
1064
1065 case $cf_cv_term_header in
1066 (term.h)
1067         AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
1068         ;;
1069 (ncurses/term.h)
1070         AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
1071         ;;
1072 (ncursesw/term.h)
1073         AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
1074         ;;
1075 esac
1076 ])dnl
1077 dnl ---------------------------------------------------------------------------
1078 dnl CF_CURSES_UNCTRL_H version: 5 updated: 2020/03/19 20:23:48
1079 dnl ------------------
1080 dnl Any X/Open curses implementation must have unctrl.h, but ncurses packages
1081 dnl may put it in a subdirectory (along with ncurses' other headers, of
1082 dnl course).  Packages which put the headers in inconsistent locations are
1083 dnl broken).
1084 AC_DEFUN([CF_CURSES_UNCTRL_H],
1085 [
1086 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
1087
1088 AC_CACHE_CHECK(for unctrl.h, cf_cv_unctrl_header,[
1089
1090 # If we found <ncurses/curses.h>, look for <ncurses/unctrl.h>, but always look
1091 # for <unctrl.h> if we do not find the variant.
1092
1093 cf_header_list="unctrl.h ncurses/unctrl.h ncursesw/unctrl.h"
1094
1095 case ${cf_cv_ncurses_header:-curses.h} in
1096 (*/*)
1097         cf_header_item=`echo ${cf_cv_ncurses_header:-curses.h} | sed -e 's%\..*%%' -e 's%/.*%/%'`unctrl.h
1098         cf_header_list="$cf_header_item $cf_header_list"
1099         ;;
1100 esac
1101
1102 for cf_header in $cf_header_list
1103 do
1104         AC_TRY_COMPILE([
1105 #include <${cf_cv_ncurses_header:-curses.h}>
1106 #include <${cf_header}>],
1107         [WINDOW *x; (void)x],
1108         [cf_cv_unctrl_header=$cf_header
1109          break],
1110         [cf_cv_unctrl_header=no])
1111 done
1112 ])
1113
1114 case $cf_cv_unctrl_header in
1115 (no)
1116         AC_MSG_WARN(unctrl.h header not found)
1117         ;;
1118 esac
1119
1120 case $cf_cv_unctrl_header in
1121 (unctrl.h)
1122         AC_DEFINE(HAVE_UNCTRL_H,1,[Define to 1 if we have unctrl.h])
1123         ;;
1124 (ncurses/unctrl.h)
1125         AC_DEFINE(HAVE_NCURSES_UNCTRL_H,1,[Define to 1 if we have ncurses/unctrl.h])
1126         ;;
1127 (ncursesw/unctrl.h)
1128         AC_DEFINE(HAVE_NCURSESW_UNCTRL_H,1,[Define to 1 if we have ncursesw/unctrl.h])
1129         ;;
1130 esac
1131 ])dnl
1132 dnl ---------------------------------------------------------------------------
1133 dnl CF_CURSES_WACS_MAP version: 7 updated: 2020/03/19 20:23:48
1134 dnl ------------------
1135 dnl Check for likely values of wacs_map[].
1136 AC_DEFUN([CF_CURSES_WACS_MAP],
1137 [
1138 AC_CACHE_CHECK(for wide alternate character set array, cf_cv_curses_wacs_map,[
1139         cf_cv_curses_wacs_map=unknown
1140         for name in wacs_map _wacs_map __wacs_map _nc_wacs _wacs_char
1141         do
1142         AC_TRY_LINK([
1143 #ifndef _XOPEN_SOURCE_EXTENDED
1144 #define _XOPEN_SOURCE_EXTENDED
1145 #endif
1146 #include <${cf_cv_ncurses_header:-curses.h}>],
1147         [void *foo = &($name['k']); (void)foo],
1148         [cf_cv_curses_wacs_map=$name
1149          break])
1150         done])
1151
1152 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])
1153 ])dnl
1154 dnl ---------------------------------------------------------------------------
1155 dnl CF_CURSES_WACS_SYMBOLS version: 3 updated: 2020/03/19 20:23:48
1156 dnl ----------------------
1157 dnl Do a check to see if the WACS_xxx constants are defined compatibly with
1158 dnl X/Open Curses.  In particular, NetBSD's implementation of the WACS_xxx
1159 dnl constants is broken since those constants do not point to cchar_t's.
1160 AC_DEFUN([CF_CURSES_WACS_SYMBOLS],
1161 [
1162 AC_REQUIRE([CF_CURSES_WACS_MAP])
1163
1164 AC_CACHE_CHECK(for wide alternate character constants, cf_cv_curses_wacs_symbols,[
1165 cf_cv_curses_wacs_symbols=no
1166 if test "$cf_cv_curses_wacs_map" != unknown
1167 then
1168         AC_TRY_LINK([
1169 #ifndef _XOPEN_SOURCE_EXTENDED
1170 #define _XOPEN_SOURCE_EXTENDED
1171 #endif
1172 #include <${cf_cv_ncurses_header:-curses.h}>],
1173         [cchar_t *foo = WACS_PLUS;
1174          $cf_cv_curses_wacs_map['k'] = *WACS_PLUS; (void)foo],
1175         [cf_cv_curses_wacs_symbols=yes])
1176 else
1177         AC_TRY_LINK([
1178 #ifndef _XOPEN_SOURCE_EXTENDED
1179 #define _XOPEN_SOURCE_EXTENDED
1180 #endif
1181 #include <${cf_cv_ncurses_header:-curses.h}>],
1182         [cchar_t *foo = WACS_PLUS; (void)foo],
1183         [cf_cv_curses_wacs_symbols=yes])
1184 fi
1185 ])
1186
1187 test "$cf_cv_curses_wacs_symbols" != no && AC_DEFINE(CURSES_WACS_SYMBOLS,1,[Define to 1 if (n)curses supports wide-character WACS_ symbols])
1188 ])dnl
1189 dnl ---------------------------------------------------------------------------
1190 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
1191 dnl ----------
1192 dnl "dirname" is not portable, so we fake it with a shell script.
1193 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
1194 dnl ---------------------------------------------------------------------------
1195 dnl CF_DISABLE_ECHO version: 13 updated: 2015/04/18 08:56:57
1196 dnl ---------------
1197 dnl You can always use "make -n" to see the actual options, but it's hard to
1198 dnl pick out/analyze warning messages when the compile-line is long.
1199 dnl
1200 dnl Sets:
1201 dnl     ECHO_LT - symbol to control if libtool is verbose
1202 dnl     ECHO_LD - symbol to prefix "cc -o" lines
1203 dnl     RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1204 dnl     SHOW_CC - symbol to put before explicit "cc -c" lines
1205 dnl     ECHO_CC - symbol to put before any "cc" line
1206 dnl
1207 AC_DEFUN([CF_DISABLE_ECHO],[
1208 AC_MSG_CHECKING(if you want to see long compiling messages)
1209 CF_ARG_DISABLE(echo,
1210         [  --disable-echo          do not display "compiling" commands],
1211         [
1212         ECHO_LT='--silent'
1213         ECHO_LD='@echo linking [$]@;'
1214         RULE_CC='@echo compiling [$]<'
1215         SHOW_CC='@echo compiling [$]@'
1216         ECHO_CC='@'
1217 ],[
1218         ECHO_LT=''
1219         ECHO_LD=''
1220         RULE_CC=''
1221         SHOW_CC=''
1222         ECHO_CC=''
1223 ])
1224 AC_MSG_RESULT($enableval)
1225 AC_SUBST(ECHO_LT)
1226 AC_SUBST(ECHO_LD)
1227 AC_SUBST(RULE_CC)
1228 AC_SUBST(SHOW_CC)
1229 AC_SUBST(ECHO_CC)
1230 ])dnl
1231 dnl ---------------------------------------------------------------------------
1232 dnl CF_DISABLE_LEAKS version: 7 updated: 2012/10/02 20:55:03
1233 dnl ----------------
1234 dnl Combine no-leak checks with the libraries or tools that are used for the
1235 dnl checks.
1236 AC_DEFUN([CF_DISABLE_LEAKS],[
1237
1238 AC_REQUIRE([CF_WITH_DMALLOC])
1239 AC_REQUIRE([CF_WITH_DBMALLOC])
1240 AC_REQUIRE([CF_WITH_VALGRIND])
1241
1242 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1243 AC_ARG_ENABLE(leaks,
1244         [  --disable-leaks         test: free permanent memory, analyze leaks],
1245         [if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi],
1246         : ${with_no_leaks:=no})
1247 AC_MSG_RESULT($with_no_leaks)
1248
1249 if test "$with_no_leaks" = yes ; then
1250         AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1251         AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1252 fi
1253 ])dnl
1254 dnl ---------------------------------------------------------------------------
1255 dnl CF_DISABLE_RPATH_HACK version: 2 updated: 2011/02/13 13:31:33
1256 dnl ---------------------
1257 dnl The rpath-hack makes it simpler to build programs, particularly with the
1258 dnl *BSD ports which may have essential libraries in unusual places.  But it
1259 dnl can interfere with building an executable for the base system.  Use this
1260 dnl option in that case.
1261 AC_DEFUN([CF_DISABLE_RPATH_HACK],
1262 [
1263 AC_MSG_CHECKING(if rpath-hack should be disabled)
1264 CF_ARG_DISABLE(rpath-hack,
1265         [  --disable-rpath-hack    don't add rpath options for additional libraries],
1266         [cf_disable_rpath_hack=yes],
1267         [cf_disable_rpath_hack=no])
1268 AC_MSG_RESULT($cf_disable_rpath_hack)
1269 if test "$cf_disable_rpath_hack" = no ; then
1270         CF_RPATH_HACK
1271 fi
1272 ])
1273 dnl ---------------------------------------------------------------------------
1274 dnl CF_ENABLE_STRING_HACKS version: 5 updated: 2016/10/08 17:34:11
1275 dnl ----------------------
1276 dnl On a few platforms, the compiler and/or loader nags with untruthful
1277 dnl comments stating that "most" uses of strcat/strcpy/sprintf are incorrect,
1278 dnl and implying that most uses of the recommended alternatives are correct.
1279 dnl
1280 dnl Factually speaking, no one has actually counted the number of uses of these
1281 dnl functions versus the total of incorrect uses.  Samples of a few thousand
1282 dnl instances are meaningless compared to the hundreds of millions of lines of
1283 dnl existing C code.
1284 dnl
1285 dnl strlcat/strlcpy are (as of 2012) non-standard, and are available on some
1286 dnl platforms, in implementations of varying quality.  Likewise, snprintf is
1287 dnl standard - but evolved through phases, and older implementations are likely
1288 dnl to yield surprising results, as documented in manpages on various systems.
1289 AC_DEFUN([CF_ENABLE_STRING_HACKS],
1290 [
1291 AC_MSG_CHECKING(if you want to work around bogus compiler/loader warnings)
1292 AC_ARG_ENABLE(string-hacks,
1293         [  --enable-string-hacks   work around bogus compiler/loader warnings],
1294         [with_string_hacks=$enableval],
1295         [with_string_hacks=no])
1296 AC_MSG_RESULT($with_string_hacks)
1297
1298 if test "x$with_string_hacks" = "xyes"; then
1299         AC_DEFINE(USE_STRING_HACKS,1,[Define to 1 to work around bogus compiler/loader warnings])
1300         AC_MSG_WARN(enabling string-hacks to work around bogus compiler/loader warnings)
1301         AC_CHECK_FUNC(strlcat,[
1302                 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
1303                 ],[
1304                 AC_CHECK_LIB(bsd,strlcat,[
1305                         CF_ADD_LIB(bsd)
1306                         AC_CHECK_HEADERS(bsd/string.h)
1307                         AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
1308                         ])
1309                 ])
1310         AC_CHECK_FUNCS( strlcpy snprintf )
1311 fi
1312 ])dnl
1313 dnl ---------------------------------------------------------------------------
1314 dnl CF_ENABLE_WARNINGS version: 7 updated: 2020/08/29 09:05:21
1315 dnl ------------------
1316 dnl Configure-option to enable gcc warnings
1317 dnl
1318 dnl $1 = extra options to add, if supported
1319 dnl $2 = option for checking attributes.  By default, this is done when
1320 dnl      warnings are enabled.  For other values:
1321 dnl      yes: always do this, e.g., to use in generated library-headers
1322 dnl      no: never do this
1323 AC_DEFUN([CF_ENABLE_WARNINGS],[
1324 if ( test "$GCC" = yes || test "$GXX" = yes )
1325 then
1326 CF_FIX_WARNINGS(CFLAGS)
1327 CF_FIX_WARNINGS(CPPFLAGS)
1328 CF_FIX_WARNINGS(LDFLAGS)
1329 AC_MSG_CHECKING(if you want to turn on gcc warnings)
1330 CF_ARG_ENABLE(warnings,
1331         [  --enable-warnings       test: turn on gcc compiler warnings],
1332         [with_warnings=yes],
1333         [with_warnings=no])
1334 AC_MSG_RESULT($with_warnings)
1335 if test "$with_warnings" = "yes"
1336 then
1337         ifelse($2,,[CF_GCC_ATTRIBUTES])
1338         CF_GCC_WARNINGS($1)
1339 fi
1340 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
1341 fi
1342 ])dnl
1343 dnl ---------------------------------------------------------------------------
1344 dnl CF_FIND_LIBRARY version: 9 updated: 2008/03/23 14:48:54
1345 dnl ---------------
1346 dnl Look for a non-standard library, given parameters for AC_TRY_LINK.  We
1347 dnl prefer a standard location, and use -L options only if we do not find the
1348 dnl library in the standard library location(s).
1349 dnl     $1 = library name
1350 dnl     $2 = library class, usually the same as library name
1351 dnl     $3 = includes
1352 dnl     $4 = code fragment to compile/link
1353 dnl     $5 = corresponding function-name
1354 dnl     $6 = flag, nonnull if failure should not cause an error-exit
1355 dnl
1356 dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had
1357 dnl to use a -L option.
1358 AC_DEFUN([CF_FIND_LIBRARY],
1359 [
1360         eval 'cf_cv_have_lib_'$1'=no'
1361         cf_libdir=""
1362         AC_CHECK_FUNC($5,
1363                 eval 'cf_cv_have_lib_'$1'=yes',[
1364                 cf_save_LIBS="$LIBS"
1365                 AC_MSG_CHECKING(for $5 in -l$1)
1366                 LIBS="-l$1 $LIBS"
1367                 AC_TRY_LINK([$3],[$4],
1368                         [AC_MSG_RESULT(yes)
1369                          eval 'cf_cv_have_lib_'$1'=yes'
1370                         ],
1371                         [AC_MSG_RESULT(no)
1372                         CF_LIBRARY_PATH(cf_search,$2)
1373                         for cf_libdir in $cf_search
1374                         do
1375                                 AC_MSG_CHECKING(for -l$1 in $cf_libdir)
1376                                 LIBS="-L$cf_libdir -l$1 $cf_save_LIBS"
1377                                 AC_TRY_LINK([$3],[$4],
1378                                         [AC_MSG_RESULT(yes)
1379                                          eval 'cf_cv_have_lib_'$1'=yes'
1380                                          break],
1381                                         [AC_MSG_RESULT(no)
1382                                          LIBS="$cf_save_LIBS"])
1383                         done
1384                         ])
1385                 ])
1386 eval 'cf_found_library=[$]cf_cv_have_lib_'$1
1387 ifelse($6,,[
1388 if test $cf_found_library = no ; then
1389         AC_MSG_ERROR(Cannot link $1 library)
1390 fi
1391 ])
1392 ])dnl
1393 dnl ---------------------------------------------------------------------------
1394 dnl CF_FIND_LINKAGE version: 21 updated: 2018/06/20 20:23:13
1395 dnl ---------------
1396 dnl Find a library (specifically the linkage used in the code fragment),
1397 dnl searching for it if it is not already in the library path.
1398 dnl See also CF_ADD_SEARCHPATH.
1399 dnl
1400 dnl Parameters (4-on are optional):
1401 dnl     $1 = headers for library entrypoint
1402 dnl     $2 = code fragment for library entrypoint
1403 dnl     $3 = the library name without the "-l" option or ".so" suffix.
1404 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
1405 dnl     $5 = action to perform if not successful
1406 dnl     $6 = module name, if not the same as the library name
1407 dnl     $7 = extra libraries
1408 dnl
1409 dnl Sets these variables:
1410 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1411 dnl     $cf_cv_header_path_$3 - include-directory if needed
1412 dnl     $cf_cv_library_path_$3 - library-directory if needed
1413 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1414 AC_DEFUN([CF_FIND_LINKAGE],[
1415
1416 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1417 # will be set on completion of the AC_TRY_LINK below.
1418 cf_cv_header_path_$3=
1419 cf_cv_library_path_$3=
1420
1421 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1422
1423 cf_save_LIBS="$LIBS"
1424
1425 AC_TRY_LINK([$1],[$2],[
1426         cf_cv_find_linkage_$3=yes
1427         cf_cv_header_path_$3=/usr/include
1428         cf_cv_library_path_$3=/usr/lib
1429 ],[
1430
1431 LIBS="-l$3 $7 $cf_save_LIBS"
1432
1433 AC_TRY_LINK([$1],[$2],[
1434         cf_cv_find_linkage_$3=yes
1435         cf_cv_header_path_$3=/usr/include
1436         cf_cv_library_path_$3=/usr/lib
1437         cf_cv_library_file_$3="-l$3"
1438 ],[
1439         cf_cv_find_linkage_$3=no
1440         LIBS="$cf_save_LIBS"
1441
1442         CF_VERBOSE(find linkage for $3 library)
1443         CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1444
1445         cf_save_CPPFLAGS="$CPPFLAGS"
1446         cf_test_CPPFLAGS="$CPPFLAGS"
1447
1448         CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1449         for cf_cv_header_path_$3 in $cf_search
1450         do
1451                 if test -d $cf_cv_header_path_$3 ; then
1452                         CF_VERBOSE(... testing $cf_cv_header_path_$3)
1453                         CPPFLAGS="$cf_save_CPPFLAGS"
1454                         CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
1455                         AC_TRY_COMPILE([$1],[$2],[
1456                                 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1457                                 cf_cv_find_linkage_$3=maybe
1458                                 cf_test_CPPFLAGS="$CPPFLAGS"
1459                                 break],[
1460                                 CPPFLAGS="$cf_save_CPPFLAGS"
1461                                 ])
1462                 fi
1463         done
1464
1465         if test "$cf_cv_find_linkage_$3" = maybe ; then
1466
1467                 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1468
1469                 cf_save_LIBS="$LIBS"
1470                 cf_save_LDFLAGS="$LDFLAGS"
1471
1472                 ifelse([$6],,,[
1473                 CPPFLAGS="$cf_test_CPPFLAGS"
1474                 LIBS="-l$3 $7 $cf_save_LIBS"
1475                 AC_TRY_LINK([$1],[$2],[
1476                         CF_VERBOSE(... found $3 library in system)
1477                         cf_cv_find_linkage_$3=yes])
1478                         CPPFLAGS="$cf_save_CPPFLAGS"
1479                         LIBS="$cf_save_LIBS"
1480                         ])
1481
1482                 if test "$cf_cv_find_linkage_$3" != yes ; then
1483                         CF_LIBRARY_PATH(cf_search,$3)
1484                         for cf_cv_library_path_$3 in $cf_search
1485                         do
1486                                 if test -d $cf_cv_library_path_$3 ; then
1487                                         CF_VERBOSE(... testing $cf_cv_library_path_$3)
1488                                         CPPFLAGS="$cf_test_CPPFLAGS"
1489                                         LIBS="-l$3 $7 $cf_save_LIBS"
1490                                         LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1491                                         AC_TRY_LINK([$1],[$2],[
1492                                         CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1493                                         cf_cv_find_linkage_$3=yes
1494                                         cf_cv_library_file_$3="-l$3"
1495                                         break],[
1496                                         CPPFLAGS="$cf_save_CPPFLAGS"
1497                                         LIBS="$cf_save_LIBS"
1498                                         LDFLAGS="$cf_save_LDFLAGS"
1499                                         ])
1500                                 fi
1501                         done
1502                         CPPFLAGS="$cf_save_CPPFLAGS"
1503                         LDFLAGS="$cf_save_LDFLAGS"
1504                 fi
1505
1506         else
1507                 cf_cv_find_linkage_$3=no
1508         fi
1509         ],$7)
1510 ])
1511
1512 LIBS="$cf_save_LIBS"
1513
1514 if test "$cf_cv_find_linkage_$3" = yes ; then
1515 ifelse([$4],,[
1516         CF_ADD_INCDIR($cf_cv_header_path_$3)
1517         CF_ADD_LIBDIR($cf_cv_library_path_$3)
1518         CF_ADD_LIB($3)
1519 ],[$4])
1520 else
1521 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1522 fi
1523 ])dnl
1524 dnl ---------------------------------------------------------------------------
1525 dnl CF_FIX_WARNINGS version: 2 updated: 2020/08/28 15:08:28
1526 dnl ---------------
1527 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc.  Any of gcc's
1528 dnl "-Werror" flags can interfere with configure-checks.  Those go into
1529 dnl EXTRA_CFLAGS.
1530 dnl
1531 dnl $1 = variable name to repair
1532 define([CF_FIX_WARNINGS],[
1533 if ( test "$GCC" = yes || test "$GXX" = yes )
1534 then
1535         case [$]$1 in
1536         (*-Werror=*)
1537                 CF_VERBOSE(repairing $1: [$]$1)
1538                 cf_temp_flags=
1539                 for cf_temp_scan in [$]$1
1540                 do
1541                         case "x$cf_temp_scan" in
1542                         (x-Werror=*)
1543                                 CF_APPEND_TEXT(EXTRA_CFLAGS,"$cf_temp_scan")
1544                                 ;;
1545                         (*)
1546                                 CF_APPEND_TEXT(cf_temp_flags,"$cf_temp_scan")
1547                                 ;;
1548                         esac
1549                 done
1550                 $1="$cf_temp_flags"
1551                 CF_VERBOSE(... fixed [$]$1)
1552                 CF_VERBOSE(... extra $EXTRA_CFLAGS)
1553                 ;;
1554         esac
1555 fi
1556 AC_SUBST(EXTRA_CFLAGS)
1557 ])dnl
1558 dnl ---------------------------------------------------------------------------
1559 dnl CF_FUNC_CURSES_VERSION version: 7 updated: 2017/05/10 18:31:29
1560 dnl ----------------------
1561 dnl Solaris has a data item 'curses_version', which confuses AC_CHECK_FUNCS.
1562 dnl It's a character string "SVR4", not documented.
1563 AC_DEFUN([CF_FUNC_CURSES_VERSION],
1564 [
1565 AC_CACHE_CHECK(for function curses_version, cf_cv_func_curses_version,[
1566 AC_TRY_RUN([
1567 #include <${cf_cv_ncurses_header:-curses.h}>
1568 int main(void)
1569 {
1570         char temp[1024];
1571         sprintf(temp, "%s\n", curses_version());
1572         ${cf_cv_main_return:-return}(0);
1573 }]
1574 ,[cf_cv_func_curses_version=yes]
1575 ,[cf_cv_func_curses_version=no]
1576 ,[cf_cv_func_curses_version=unknown])
1577 rm -f core])
1578 test "$cf_cv_func_curses_version" = yes && AC_DEFINE(HAVE_CURSES_VERSION,1,[Define to 1 if we have curses_version function])
1579 ])
1580 dnl ---------------------------------------------------------------------------
1581 dnl CF_FUNC_OPENPTY version: 5 updated: 2015/09/12 14:46:50
1582 dnl ---------------
1583 dnl Check for openpty() function, along with <pty.h> header.  It may need the
1584 dnl "util" library as well.
1585 AC_DEFUN([CF_FUNC_OPENPTY],
1586 [
1587 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1588 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1589         cf_save_LIBS="$LIBS"
1590         test $cf_cv_lib_util = yes && { CF_ADD_LIB(util) }
1591         for cf_header in pty.h libutil.h util.h
1592         do
1593         AC_TRY_LINK([
1594 #include <$cf_header>
1595 ],[
1596         int x = openpty((int *)0, (int *)0, (char *)0,
1597                                    (struct termios *)0, (struct winsize *)0);
1598 ],[
1599                 cf_cv_func_openpty=$cf_header
1600                 break
1601 ],[
1602                 cf_cv_func_openpty=no
1603 ])
1604         done
1605         LIBS="$cf_save_LIBS"
1606 ])
1607 ])dnl
1608 dnl ---------------------------------------------------------------------------
1609 dnl CF_GCC_ATTRIBUTES version: 19 updated: 2020/08/29 09:05:21
1610 dnl -----------------
1611 dnl Test for availability of useful gcc __attribute__ directives to quiet
1612 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1613 dnl to documentation, unrecognized directives cause older compilers to barf.
1614 AC_DEFUN([CF_GCC_ATTRIBUTES],
1615 [
1616 if ( test "$GCC" = yes || test "$GXX" = yes )
1617 then
1618 cat > conftest.i <<EOF
1619 #ifndef GCC_PRINTF
1620 #define GCC_PRINTF 0
1621 #endif
1622 #ifndef GCC_SCANF
1623 #define GCC_SCANF 0
1624 #endif
1625 #ifndef GCC_NORETURN
1626 #define GCC_NORETURN /* nothing */
1627 #endif
1628 #ifndef GCC_UNUSED
1629 #define GCC_UNUSED /* nothing */
1630 #endif
1631 EOF
1632 if test "$GCC" = yes
1633 then
1634         AC_CHECKING([for $CC __attribute__ directives])
1635 cat > conftest.$ac_ext <<EOF
1636 #line __oline__ "${as_me:-configure}"
1637 #include "confdefs.h"
1638 #include "conftest.h"
1639 #include "conftest.i"
1640 #if     GCC_PRINTF
1641 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1642 #else
1643 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1644 #endif
1645 #if     GCC_SCANF
1646 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1647 #else
1648 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1649 #endif
1650 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1651 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1652 extern void foo(void) GCC_NORETURN;
1653 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
1654 EOF
1655         cf_printf_attribute=no
1656         cf_scanf_attribute=no
1657         for cf_attribute in scanf printf unused noreturn
1658         do
1659                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1660                 cf_directive="__attribute__(($cf_attribute))"
1661                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1662
1663                 case $cf_attribute in
1664                 (printf)
1665                         cf_printf_attribute=yes
1666                         cat >conftest.h <<EOF
1667 #define GCC_$cf_ATTRIBUTE 1
1668 EOF
1669                         ;;
1670                 (scanf)
1671                         cf_scanf_attribute=yes
1672                         cat >conftest.h <<EOF
1673 #define GCC_$cf_ATTRIBUTE 1
1674 EOF
1675                         ;;
1676                 (*)
1677                         cat >conftest.h <<EOF
1678 #define GCC_$cf_ATTRIBUTE $cf_directive
1679 EOF
1680                         ;;
1681                 esac
1682
1683                 if AC_TRY_EVAL(ac_compile); then
1684                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1685                         cat conftest.h >>confdefs.h
1686                         case $cf_attribute in
1687                         (noreturn)
1688                                 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1689                                 ;;
1690                         (printf)
1691                                 cf_value='/* nothing */'
1692                                 if test "$cf_printf_attribute" != no ; then
1693                                         cf_value='__attribute__((format(printf,fmt,var)))'
1694                                         AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1695                                 fi
1696                                 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1697                                 ;;
1698                         (scanf)
1699                                 cf_value='/* nothing */'
1700                                 if test "$cf_scanf_attribute" != no ; then
1701                                         cf_value='__attribute__((format(scanf,fmt,var)))'
1702                                         AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1703                                 fi
1704                                 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1705                                 ;;
1706                         (unused)
1707                                 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
1708                                 ;;
1709                         esac
1710                 fi
1711         done
1712 else
1713         fgrep define conftest.i >>confdefs.h
1714 fi
1715 rm -rf conftest*
1716 fi
1717 ])dnl
1718 dnl ---------------------------------------------------------------------------
1719 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
1720 dnl --------------
1721 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
1722 dnl compatible), attempt to determine if icc/clang is actually used.
1723 AC_DEFUN([CF_GCC_VERSION],[
1724 AC_REQUIRE([AC_PROG_CC])
1725 GCC_VERSION=none
1726 if test "$GCC" = yes ; then
1727         AC_MSG_CHECKING(version of $CC)
1728         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.]].*//'`"
1729         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1730         AC_MSG_RESULT($GCC_VERSION)
1731 fi
1732 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1733 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
1734 ])dnl
1735 dnl ---------------------------------------------------------------------------
1736 dnl CF_GCC_WARNINGS version: 38 updated: 2020/08/28 15:08:28
1737 dnl ---------------
1738 dnl Check if the compiler supports useful warning options.  There's a few that
1739 dnl we don't use, simply because they're too noisy:
1740 dnl
1741 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1742 dnl     -Winline (usually not worthwhile)
1743 dnl     -Wredundant-decls (system headers make this too noisy)
1744 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1745 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1746 dnl             is enabled for ncurses using "--enable-const".
1747 dnl     -pedantic
1748 dnl
1749 dnl Parameter:
1750 dnl     $1 is an optional list of gcc warning flags that a particular
1751 dnl             application might want to use, e.g., "no-unused" for
1752 dnl             -Wno-unused
1753 dnl Special:
1754 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1755 dnl
1756 AC_DEFUN([CF_GCC_WARNINGS],
1757 [
1758 AC_REQUIRE([CF_GCC_VERSION])
1759 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
1760 cat > conftest.$ac_ext <<EOF
1761 #line __oline__ "${as_me:-configure}"
1762 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1763 EOF
1764 if test "$INTEL_COMPILER" = yes
1765 then
1766 # The "-wdXXX" options suppress warnings:
1767 # remark #1419: external declaration in primary source file
1768 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1769 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1770 # remark #193: zero used for undefined preprocessing identifier
1771 # remark #593: variable "curs_sb_left_arrow" was set but never used
1772 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1773 # remark #869: parameter "tw" was never referenced
1774 # remark #981: operands are evaluated in unspecified order
1775 # warning #279: controlling expression is constant
1776
1777         AC_CHECKING([for $CC warning options])
1778         cf_save_CFLAGS="$CFLAGS"
1779         EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
1780         for cf_opt in \
1781                 wd1419 \
1782                 wd1683 \
1783                 wd1684 \
1784                 wd193 \
1785                 wd593 \
1786                 wd279 \
1787                 wd810 \
1788                 wd869 \
1789                 wd981
1790         do
1791                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1792                 if AC_TRY_EVAL(ac_compile); then
1793                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1794                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1795                 fi
1796         done
1797         CFLAGS="$cf_save_CFLAGS"
1798 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
1799 then
1800         AC_CHECKING([for $CC warning options])
1801         cf_save_CFLAGS="$CFLAGS"
1802         cf_warn_CONST=""
1803         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1804         cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
1805         test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
1806         for cf_opt in W Wall \
1807                 Wbad-function-cast \
1808                 Wcast-align \
1809                 Wcast-qual \
1810                 Wdeclaration-after-statement \
1811                 Wextra \
1812                 Winline \
1813                 Wmissing-declarations \
1814                 Wmissing-prototypes \
1815                 Wnested-externs \
1816                 Wpointer-arith \
1817                 Wshadow \
1818                 Wstrict-prototypes \
1819                 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
1820         do
1821                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1822                 if AC_TRY_EVAL(ac_compile); then
1823                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1824                         case $cf_opt in
1825                         (Winline)
1826                                 case $GCC_VERSION in
1827                                 ([[34]].*)
1828                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1829                                         continue;;
1830                                 esac
1831                                 ;;
1832                         (Wpointer-arith)
1833                                 case $GCC_VERSION in
1834                                 ([[12]].*)
1835                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1836                                         continue;;
1837                                 esac
1838                                 ;;
1839                         esac
1840                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1841                 fi
1842         done
1843         CFLAGS="$cf_save_CFLAGS"
1844 fi
1845 rm -rf conftest*
1846
1847 AC_SUBST(EXTRA_CFLAGS)
1848 ])dnl
1849 dnl ---------------------------------------------------------------------------
1850 dnl CF_GETOPT_HEADER version: 6 updated: 2014/07/22 14:45:54
1851 dnl ----------------
1852 dnl Check for getopt's variables which are commonly defined in stdlib.h,
1853 dnl unistd.h or (nonstandard) in getopt.h
1854 AC_DEFUN([CF_GETOPT_HEADER],
1855 [
1856 AC_HAVE_HEADERS(unistd.h getopt.h)
1857 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
1858 cf_cv_getopt_header=none
1859 for cf_header in stdio.h stdlib.h unistd.h getopt.h
1860 do
1861 AC_TRY_COMPILE([
1862 #include <$cf_header>],
1863 [int x = optind; char *y = optarg],
1864 [cf_cv_getopt_header=$cf_header
1865  break])
1866 done
1867 ])
1868 if test $cf_cv_getopt_header != none ; then
1869         AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
1870 fi
1871 if test $cf_cv_getopt_header = getopt.h ; then
1872         AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
1873 fi
1874 ])dnl
1875 dnl ---------------------------------------------------------------------------
1876 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
1877 dnl -------------
1878 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1879 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1880 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1881 dnl since it is interwoven with GNU extensions.
1882 dnl
1883 dnl Well, yes we could work around it...
1884 dnl
1885 dnl Parameters:
1886 dnl     $1 is the nominal value for _XOPEN_SOURCE
1887 AC_DEFUN([CF_GNU_SOURCE],
1888 [
1889 cf_gnu_xopen_source=ifelse($1,,500,$1)
1890
1891 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
1892 AC_TRY_COMPILE([#include <sys/types.h>],[
1893         #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
1894                 return 0;
1895         #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
1896                 return 0;
1897         #else
1898         #       error not GNU C library
1899         #endif],
1900         [cf_cv_gnu_library=yes],
1901         [cf_cv_gnu_library=no])
1902 ])
1903
1904 if test x$cf_cv_gnu_library = xyes; then
1905
1906         # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
1907         # was changed to help a little.  newlib incorporated the change about 4
1908         # years later.
1909         AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
1910                 cf_save="$CPPFLAGS"
1911                 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1912                 AC_TRY_COMPILE([#include <sys/types.h>],[
1913                         #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
1914                                 return 0;
1915                         #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
1916                                 return 0;
1917                         #else
1918                         #       error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
1919                         #endif],
1920                         [cf_cv_gnu_library_219=yes],
1921                         [cf_cv_gnu_library_219=no])
1922                 CPPFLAGS="$cf_save"
1923         ])
1924
1925         if test "x$cf_cv_gnu_library_219" = xyes; then
1926                 cf_save="$CPPFLAGS"
1927                 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
1928                         CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
1929                         AC_TRY_COMPILE([
1930                                 #include <limits.h>
1931                                 #include <sys/types.h>
1932                                 ],[
1933                                 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
1934                                         return 0;
1935                                 #else
1936                                 #       error GNU C library is too old
1937                                 #endif],
1938                                 [cf_cv_gnu_dftsrc_219=yes],
1939                                 [cf_cv_gnu_dftsrc_219=no])
1940                         ])
1941                 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
1942         else
1943                 cf_cv_gnu_dftsrc_219=maybe
1944         fi
1945
1946         if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
1947
1948                 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1949                 AC_TRY_COMPILE([#include <sys/types.h>],[
1950                         #ifndef _XOPEN_SOURCE
1951                         #error  expected _XOPEN_SOURCE to be defined
1952                         #endif],
1953                         [cf_cv_gnu_source=no],
1954                         [cf_save="$CPPFLAGS"
1955                          CF_ADD_CFLAGS(-D_GNU_SOURCE)
1956                          AC_TRY_COMPILE([#include <sys/types.h>],[
1957                                 #ifdef _XOPEN_SOURCE
1958                                 #error  expected _XOPEN_SOURCE to be undefined
1959                                 #endif],
1960                                 [cf_cv_gnu_source=no],
1961                                 [cf_cv_gnu_source=yes])
1962                         CPPFLAGS="$cf_save"
1963                         ])
1964                 ])
1965
1966                 if test "$cf_cv_gnu_source" = yes
1967                 then
1968                 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
1969                         CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
1970                         AC_TRY_COMPILE([#include <sys/types.h>],[
1971                                 #ifdef _DEFAULT_SOURCE
1972                                 #error  expected _DEFAULT_SOURCE to be undefined
1973                                 #endif],
1974                                 [cf_cv_default_source=no],
1975                                 [cf_cv_default_source=yes])
1976                         ])
1977                         if test "$cf_cv_default_source" = yes
1978                         then
1979                                 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1980                         fi
1981                 fi
1982         fi
1983
1984 fi
1985 ])dnl
1986 dnl ---------------------------------------------------------------------------
1987 dnl CF_HEADER_PATH version: 13 updated: 2015/04/15 19:08:48
1988 dnl --------------
1989 dnl Construct a search-list of directories for a nonstandard header-file
1990 dnl
1991 dnl Parameters
1992 dnl     $1 = the variable to return as result
1993 dnl     $2 = the package name
1994 AC_DEFUN([CF_HEADER_PATH],
1995 [
1996 $1=
1997
1998 # collect the current set of include-directories from compiler flags
1999 cf_header_path_list=""
2000 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2001         for cf_header_path in $CPPFLAGS $CFLAGS
2002         do
2003                 case $cf_header_path in
2004                 (-I*)
2005                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2006                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2007                         cf_header_path_list="$cf_header_path_list [$]$1"
2008                         ;;
2009                 esac
2010         done
2011 fi
2012
2013 # add the variations for the package we are looking for
2014 CF_SUBDIR_PATH($1,$2,include)
2015
2016 test "$includedir" != NONE && \
2017 test "$includedir" != "/usr/include" && \
2018 test -d "$includedir" && {
2019         test -d $includedir &&    $1="[$]$1 $includedir"
2020         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
2021 }
2022
2023 test "$oldincludedir" != NONE && \
2024 test "$oldincludedir" != "/usr/include" && \
2025 test -d "$oldincludedir" && {
2026         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
2027         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
2028 }
2029
2030 $1="[$]$1 $cf_header_path_list"
2031 ])dnl
2032 dnl ---------------------------------------------------------------------------
2033 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
2034 dnl ---------------
2035 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2036 AC_DEFUN([CF_HELP_MESSAGE],
2037 [CF_ACVERSION_CHECK(2.53,[],[
2038 AC_DIVERT_HELP($1)])dnl
2039 ])dnl
2040 dnl ---------------------------------------------------------------------------
2041 dnl CF_INHERIT_SCRIPT version: 2 updated: 2003/03/01 23:50:42
2042 dnl -----------------
2043 dnl If we do not have a given script, look for it in the parent directory.
2044 AC_DEFUN([CF_INHERIT_SCRIPT],
2045 [
2046 test -f $1 || ( test -f ../$1 && cp ../$1 ./ )
2047 ])dnl
2048 dnl ---------------------------------------------------------------------------
2049 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
2050 dnl ---------------
2051 dnl prompt for/fill-in useful install-program options
2052 AC_DEFUN([CF_INSTALL_OPTS],
2053 [
2054 CF_INSTALL_OPT_S
2055 CF_INSTALL_OPT_P
2056 CF_INSTALL_OPT_O
2057 ])dnl
2058 dnl ---------------------------------------------------------------------------
2059 dnl CF_INSTALL_OPT_O version: 2 updated: 2015/05/15 19:45:35
2060 dnl ----------------
2061 dnl Almost all "install" programs default to the current user's ownership.
2062 dnl Almost - MINIX is an exception.
2063 AC_DEFUN([CF_INSTALL_OPT_O],
2064 [
2065 AC_MSG_CHECKING(if install needs to be told about ownership)
2066 case `$ac_config_guess` in
2067 (*minix)
2068         with_install_o=yes
2069         ;;
2070 (*)
2071         with_install_o=no
2072         ;;
2073 esac
2074
2075 AC_MSG_RESULT($with_install_o)
2076 if test "x$with_install_o" = xyes
2077 then
2078         INSTALL_OPT_O=`id root|sed -e 's/uid=[[0-9]]*(/ -o /' -e 's/gid=[[0-9]]*(/ -g /' -e 's/ [[^=[:space:]]][[^=[:space:]]]*=.*/ /' -e 's/)//g'`
2079 else
2080         INSTALL_OPT_O=
2081 fi
2082
2083 AC_SUBST(INSTALL_OPT_O)
2084 ])dnl
2085 dnl ---------------------------------------------------------------------------
2086 dnl CF_INSTALL_OPT_P version: 1 updated: 2018/08/18 12:19:21
2087 dnl ----------------
2088 dnl Some install-programs accept a "-p" option to preserve file modification
2089 dnl timestamps.  That can be useful as an install option, as well as a way to
2090 dnl avoid the need for ranlib after copying a static archive.
2091 AC_DEFUN([CF_INSTALL_OPT_P],
2092 [
2093 : ${INSTALL:=install}
2094 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
2095         rm -rf conftest*
2096         date >conftest.in
2097         mkdir conftest.out
2098         sleep 3
2099         if $INSTALL -p conftest.in conftest.out 2>/dev/null
2100         then
2101                 if test -f conftest.out/conftest.in
2102                 then
2103                         test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
2104                         test conftest.out/conftest.in -nt conftest.in 2>conftest.err
2105                         if test -s conftest.err
2106                         then
2107                                 cf_cv_install_p=no
2108                         else
2109                                 cf_cv_install_p=yes
2110                         fi
2111                 else
2112                         cf_cv_install_p=no
2113                 fi
2114         else
2115                 cf_cv_install_p=no
2116         fi
2117         rm -rf conftest*
2118 ])
2119 ])dnl
2120 dnl ---------------------------------------------------------------------------
2121 dnl CF_INSTALL_OPT_S version: 2 updated: 2018/08/18 12:19:21
2122 dnl ----------------
2123 dnl By default, we should strip executables which are installed, but leave the
2124 dnl ability to suppress that for unit-testing.
2125 AC_DEFUN([CF_INSTALL_OPT_S],
2126 [
2127 AC_MSG_CHECKING(if you want to install stripped executables)
2128 CF_ARG_DISABLE(stripping,
2129         [  --disable-stripping     do not strip (debug info) installed executables],
2130         [with_stripping=no],
2131         [with_stripping=yes])
2132 AC_MSG_RESULT($with_stripping)
2133
2134 if test "$with_stripping" = yes
2135 then
2136         INSTALL_OPT_S="-s"
2137 else
2138         INSTALL_OPT_S=
2139 fi
2140 AC_SUBST(INSTALL_OPT_S)
2141 ])dnl
2142 dnl ---------------------------------------------------------------------------
2143 dnl CF_INTEL_COMPILER version: 7 updated: 2015/04/12 15:39:00
2144 dnl -----------------
2145 dnl Check if the given compiler is really the Intel compiler for Linux.  It
2146 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2147 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2148 dnl
2149 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2150 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
2151 dnl the wrappers for gcc and g++ warnings.
2152 dnl
2153 dnl $1 = GCC (default) or GXX
2154 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2155 dnl $3 = CFLAGS (default) or CXXFLAGS
2156 AC_DEFUN([CF_INTEL_COMPILER],[
2157 AC_REQUIRE([AC_CANONICAL_HOST])
2158 ifelse([$2],,INTEL_COMPILER,[$2])=no
2159
2160 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2161         case $host_os in
2162         (linux*|gnu*)
2163                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2164                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2165                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2166                 AC_TRY_COMPILE([],[
2167 #ifdef __INTEL_COMPILER
2168 #else
2169 make an error
2170 #endif
2171 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2172 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2173 ],[])
2174                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2175                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2176                 ;;
2177         esac
2178 fi
2179 ])dnl
2180 dnl ---------------------------------------------------------------------------
2181 dnl CF_LD_RPATH_OPT version: 8 updated: 2018/08/18 16:36:35
2182 dnl ---------------
2183 dnl For the given system and compiler, find the compiler flags to pass to the
2184 dnl loader to use the "rpath" feature.
2185 AC_DEFUN([CF_LD_RPATH_OPT],
2186 [
2187 AC_REQUIRE([CF_CHECK_CACHE])
2188
2189 LD_RPATH_OPT=
2190 if test "x$cf_cv_enable_rpath" != xno
2191 then
2192         AC_MSG_CHECKING(for an rpath option)
2193         case $cf_cv_system_name in
2194         (irix*)
2195                 if test "$GCC" = yes; then
2196                         LD_RPATH_OPT="-Wl,-rpath,"
2197                 else
2198                         LD_RPATH_OPT="-rpath "
2199                 fi
2200                 ;;
2201         (linux*|gnu*|k*bsd*-gnu|freebsd*)
2202                 LD_RPATH_OPT="-Wl,-rpath,"
2203                 ;;
2204         (openbsd[[2-9]].*|mirbsd*)
2205                 LD_RPATH_OPT="-Wl,-rpath,"
2206                 ;;
2207         (dragonfly*)
2208                 LD_RPATH_OPT="-rpath "
2209                 ;;
2210         (netbsd*)
2211                 LD_RPATH_OPT="-Wl,-rpath,"
2212                 ;;
2213         (osf*|mls+*)
2214                 LD_RPATH_OPT="-rpath "
2215                 ;;
2216         (solaris2*)
2217                 LD_RPATH_OPT="-R"
2218                 ;;
2219         (*)
2220                 ;;
2221         esac
2222         AC_MSG_RESULT($LD_RPATH_OPT)
2223
2224         case "x$LD_RPATH_OPT" in
2225         (x-R*)
2226                 AC_MSG_CHECKING(if we need a space after rpath option)
2227                 cf_save_LIBS="$LIBS"
2228                 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2229                 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2230                 LIBS="$cf_save_LIBS"
2231                 AC_MSG_RESULT($cf_rpath_space)
2232                 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2233                 ;;
2234         esac
2235 fi
2236 ])dnl
2237 dnl ---------------------------------------------------------------------------
2238 dnl CF_LIBRARY_PATH version: 10 updated: 2015/04/15 19:08:48
2239 dnl ---------------
2240 dnl Construct a search-list of directories for a nonstandard library-file
2241 dnl
2242 dnl Parameters
2243 dnl     $1 = the variable to return as result
2244 dnl     $2 = the package name
2245 AC_DEFUN([CF_LIBRARY_PATH],
2246 [
2247 $1=
2248 cf_library_path_list=""
2249 if test -n "${LDFLAGS}${LIBS}" ; then
2250         for cf_library_path in $LDFLAGS $LIBS
2251         do
2252                 case $cf_library_path in
2253                 (-L*)
2254                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2255                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2256                         cf_library_path_list="$cf_library_path_list [$]$1"
2257                         ;;
2258                 esac
2259         done
2260 fi
2261
2262 CF_SUBDIR_PATH($1,$2,lib)
2263
2264 $1="$cf_library_path_list [$]$1"
2265 ])dnl
2266 dnl ---------------------------------------------------------------------------
2267 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
2268 dnl ------------
2269 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
2270 dnl a monocase filesystem.
2271 AC_DEFUN([CF_MAKE_TAGS],[
2272 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2273
2274 AC_CHECK_PROGS(CTAGS, exctags ctags)
2275 AC_CHECK_PROGS(ETAGS, exetags etags)
2276
2277 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
2278
2279 if test "$cf_cv_mixedcase" = yes ; then
2280         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
2281 else
2282         MAKE_UPPER_TAGS=no
2283 fi
2284
2285 if test "$MAKE_UPPER_TAGS" = yes ; then
2286         MAKE_UPPER_TAGS=
2287 else
2288         MAKE_UPPER_TAGS="#"
2289 fi
2290
2291 if test "$MAKE_LOWER_TAGS" = yes ; then
2292         MAKE_LOWER_TAGS=
2293 else
2294         MAKE_LOWER_TAGS="#"
2295 fi
2296
2297 AC_SUBST(CTAGS)
2298 AC_SUBST(ETAGS)
2299
2300 AC_SUBST(MAKE_UPPER_TAGS)
2301 AC_SUBST(MAKE_LOWER_TAGS)
2302 ])dnl
2303 dnl ---------------------------------------------------------------------------
2304 dnl CF_MATH_LIB version: 9 updated: 2017/01/21 11:06:25
2305 dnl -----------
2306 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
2307 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
2308 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
2309 AC_DEFUN([CF_MATH_LIB],
2310 [
2311 AC_CACHE_CHECK(if -lm needed for math functions,
2312         cf_cv_need_libm,[
2313         AC_TRY_LINK([
2314         #include <stdio.h>
2315         #include <stdlib.h>
2316         #include <math.h>
2317         ],
2318         [double x = rand(); printf("result = %g\n", ]ifelse([$2],,sin(x),$2)[)],
2319         [cf_cv_need_libm=no],
2320         [cf_cv_need_libm=yes])])
2321 if test "$cf_cv_need_libm" = yes
2322 then
2323 ifelse($1,,[
2324         CF_ADD_LIB(m)
2325 ],[$1=-lm])
2326 fi
2327 ])
2328 dnl ---------------------------------------------------------------------------
2329 dnl CF_MIXEDCASE_FILENAMES version: 7 updated: 2015/04/12 15:39:00
2330 dnl ----------------------
2331 dnl Check if the file-system supports mixed-case filenames.  If we're able to
2332 dnl create a lowercase name and see it as uppercase, it doesn't support that.
2333 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
2334 [
2335 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
2336 if test "$cross_compiling" = yes ; then
2337         case $target_alias in
2338         (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*)
2339                 cf_cv_mixedcase=no
2340                 ;;
2341         (*)
2342                 cf_cv_mixedcase=yes
2343                 ;;
2344         esac
2345 else
2346         rm -f conftest CONFTEST
2347         echo test >conftest
2348         if test -f CONFTEST ; then
2349                 cf_cv_mixedcase=no
2350         else
2351                 cf_cv_mixedcase=yes
2352         fi
2353         rm -f conftest CONFTEST
2354 fi
2355 ])
2356 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
2357 ])dnl
2358 dnl ---------------------------------------------------------------------------
2359 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
2360 dnl ----------
2361 dnl Write a debug message to config.log, along with the line number in the
2362 dnl configure script.
2363 AC_DEFUN([CF_MSG_LOG],[
2364 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
2365 ])dnl
2366 dnl ---------------------------------------------------------------------------
2367 dnl CF_NCURSES_CC_CHECK version: 4 updated: 2007/07/29 10:39:05
2368 dnl -------------------
2369 dnl Check if we can compile with ncurses' header file
2370 dnl $1 is the cache variable to set
2371 dnl $2 is the header-file to include
2372 dnl $3 is the root name (ncurses or ncursesw)
2373 AC_DEFUN([CF_NCURSES_CC_CHECK],[
2374         AC_TRY_COMPILE([
2375 ]ifelse($3,ncursesw,[
2376 #define _XOPEN_SOURCE_EXTENDED
2377 #undef  HAVE_LIBUTF8_H  /* in case we used CF_UTF8_LIB */
2378 #define HAVE_LIBUTF8_H  /* to force ncurses' header file to use cchar_t */
2379 ])[
2380 #include <$2>],[
2381 #ifdef NCURSES_VERSION
2382 ]ifelse($3,ncursesw,[
2383 #ifndef WACS_BSSB
2384         make an error
2385 #endif
2386 ])[
2387 printf("%s\n", NCURSES_VERSION);
2388 #else
2389 #ifdef __NCURSES_H
2390 printf("old\n");
2391 #else
2392         make an error
2393 #endif
2394 #endif
2395         ]
2396         ,[$1=$2]
2397         ,[$1=no])
2398 ])dnl
2399 dnl ---------------------------------------------------------------------------
2400 dnl CF_NCURSES_CONFIG version: 23 updated: 2020/02/27 05:21:59
2401 dnl -----------------
2402 dnl Tie together the configure-script macros for ncurses, preferring these in
2403 dnl order:
2404 dnl a) ".pc" files for pkg-config, using $NCURSES_CONFIG_PKG
2405 dnl b) the "-config" script from ncurses, using $NCURSES_CONFIG
2406 dnl c) just plain libraries
2407 dnl
2408 dnl $1 is the root library name (default: "ncurses")
2409 AC_DEFUN([CF_NCURSES_CONFIG],[
2410 AC_REQUIRE([CF_PKG_CONFIG])
2411 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
2412 cf_have_ncuconfig=no
2413
2414 if test "x${PKG_CONFIG:=none}" != xnone; then
2415         AC_MSG_CHECKING(pkg-config for $cf_ncuconfig_root)
2416         if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
2417                 AC_MSG_RESULT(yes)
2418
2419                 AC_MSG_CHECKING(if the $cf_ncuconfig_root package files work)
2420                 cf_have_ncuconfig=unknown
2421
2422                 cf_save_CFLAGS="$CFLAGS"
2423                 cf_save_CPPFLAGS="$CPPFLAGS"
2424                 cf_save_LIBS="$LIBS"
2425
2426                 cf_pkg_cflags=`$PKG_CONFIG --cflags $cf_ncuconfig_root`
2427                 cf_pkg_libs=`$PKG_CONFIG --libs $cf_ncuconfig_root`
2428
2429                 # while -W for passing linker flags is prevalent, it is not "standard".
2430                 # At least one wrapper for c89/c99 (in Apple's xcode) has its own
2431                 # incompatible _and_ non-standard -W option which gives an error.  Work
2432                 # around that pitfall.
2433                 case "x${CC}@@${cf_pkg_libs}@${cf_pkg_cflags}" in
2434                 (x*c[[89]]9@@*-W*)
2435                         CF_ADD_CFLAGS($cf_pkg_cflags)
2436                         CF_ADD_LIBS($cf_pkg_libs)
2437
2438                         AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2439                                 [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2440                                 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2441                                         int main(void)
2442                                         { char *xx = curses_version(); return (xx == 0); }],
2443                                         [cf_test_ncuconfig=yes],
2444                                         [cf_test_ncuconfig=no],
2445                                         [cf_test_ncuconfig=maybe])],
2446                                 [cf_test_ncuconfig=no])
2447
2448                         CFLAGS="$cf_save_CFLAGS"
2449                         CPPFLAGS="$cf_save_CPPFLAGS"
2450                         LIBS="$cf_save_LIBS"
2451
2452                         if test "x$cf_test_ncuconfig" != xyes; then
2453                                 cf_temp=`echo "x$cf_pkg_cflags" | sed -e s/^x// -e 's/-W[[^     ]]*//g'`
2454                                 cf_pkg_cflags="$cf_temp"
2455                                 cf_temp=`echo "x$cf_pkg_libs" | sed -e s/^x// -e 's/-W[[^       ]]*//g'`
2456                                 cf_pkg_libs="$cf_temp"
2457                         fi
2458                         ;;
2459                 esac
2460
2461                 CF_ADD_CFLAGS($cf_pkg_cflags)
2462                 CF_ADD_LIBS($cf_pkg_libs)
2463
2464                 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2465                         [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2466                         [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2467                                 int main(void)
2468                                 { char *xx = curses_version(); return (xx == 0); }],
2469                                 [cf_have_ncuconfig=yes],
2470                                 [cf_have_ncuconfig=no],
2471                                 [cf_have_ncuconfig=maybe])],
2472                         [cf_have_ncuconfig=no])
2473                 AC_MSG_RESULT($cf_have_ncuconfig)
2474                 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
2475                 if test "$cf_have_ncuconfig" != "yes"
2476                 then
2477                         CPPFLAGS="$cf_save_CPPFLAGS"
2478                         LIBS="$cf_save_LIBS"
2479                         NCURSES_CONFIG_PKG=none
2480                 else
2481                         AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2482                         NCURSES_CONFIG_PKG=$cf_ncuconfig_root
2483                         CF_TERM_HEADER
2484                 fi
2485
2486         else
2487                 AC_MSG_RESULT(no)
2488                 NCURSES_CONFIG_PKG=none
2489         fi
2490 else
2491         NCURSES_CONFIG_PKG=none
2492 fi
2493
2494 if test "x$cf_have_ncuconfig" = "xno"; then
2495         cf_ncurses_config="${cf_ncuconfig_root}${NCURSES_CONFIG_SUFFIX}-config"; echo "Looking for ${cf_ncurses_config}"
2496
2497         CF_ACVERSION_CHECK(2.52,
2498                 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
2499                 [AC_PATH_PROGS(NCURSES_CONFIG,  ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
2500
2501         if test "$NCURSES_CONFIG" != none ; then
2502
2503                 CF_ADD_CFLAGS(`$NCURSES_CONFIG --cflags`)
2504                 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
2505
2506                 # even with config script, some packages use no-override for curses.h
2507                 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
2508
2509                 dnl like CF_NCURSES_CPPFLAGS
2510                 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2511
2512                 dnl like CF_NCURSES_LIBS
2513                 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
2514                 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2515
2516                 dnl like CF_NCURSES_VERSION
2517                 cf_cv_ncurses_version=`$NCURSES_CONFIG --version`
2518
2519         else
2520
2521                 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
2522                 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
2523
2524         fi
2525 else
2526         NCURSES_CONFIG=none
2527 fi
2528 ])dnl
2529 dnl ---------------------------------------------------------------------------
2530 dnl CF_NCURSES_CPPFLAGS version: 21 updated: 2012/10/06 08:57:51
2531 dnl -------------------
2532 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
2533 dnl the CPPFLAGS variable so we can include its header.
2534 dnl
2535 dnl The header files may be installed as either curses.h, or ncurses.h (would
2536 dnl be obsolete, except that some packagers prefer this name to distinguish it
2537 dnl from a "native" curses implementation).  If not installed for overwrite,
2538 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
2539 dnl /usr/include/ncurses), but someone may have installed overwriting the
2540 dnl vendor's curses.  Only very old versions (pre-1.9.2d, the first autoconf'd
2541 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
2542 dnl the header.
2543 dnl
2544 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
2545 dnl is already in the include-path, don't even bother with this, since we cannot
2546 dnl easily determine which file it is.  In this case, it has to be <curses.h>.
2547 dnl
2548 dnl The optional parameter gives the root name of the library, in case it is
2549 dnl not installed as the default curses library.  That is how the
2550 dnl wide-character version of ncurses is installed.
2551 AC_DEFUN([CF_NCURSES_CPPFLAGS],
2552 [AC_REQUIRE([CF_WITH_CURSES_DIR])
2553
2554 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
2555 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
2556
2557 test -n "$cf_cv_curses_dir" && \
2558 test "$cf_cv_curses_dir" != "no" && { \
2559   CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
2560 }
2561
2562 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
2563         cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
2564         ( test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw ) && cf_header_list="$cf_header_list curses.h ncurses.h"
2565         for cf_header in $cf_header_list
2566         do
2567                 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
2568                 test "$cf_cv_ncurses_h" != no && break
2569         done
2570 ])
2571
2572 CF_NCURSES_HEADER
2573 CF_TERM_HEADER
2574
2575 # some applications need this, but should check for NCURSES_VERSION
2576 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2577
2578 CF_NCURSES_VERSION
2579 ])dnl
2580 dnl ---------------------------------------------------------------------------
2581 dnl CF_NCURSES_EXT_FUNCS version: 4 updated: 2012/10/06 16:39:58
2582 dnl --------------------
2583 dnl Since 2007/11/17, ncurses has defined NCURSES_EXT_FUNCS; earlier versions
2584 dnl may provide these functions.  Define the symbol if it is not defined, and
2585 dnl if it is valid.
2586 AC_DEFUN([CF_NCURSES_EXT_FUNCS],
2587 [
2588 AC_CACHE_CHECK(for ncurses extended functions,cf_cv_ncurses_ext_funcs,[
2589 AC_TRY_COMPILE([
2590 #include <${cf_cv_ncurses_header:-curses.h}>],
2591 [
2592 int x = NCURSES_EXT_FUNCS
2593 ],[cf_cv_ncurses_ext_funcs=defined],[
2594 AC_TRY_LINK([
2595 #include <${cf_cv_ncurses_header:-curses.h}>],
2596 [
2597         (void) assume_default_colors (0, 0);
2598         (void) curses_version ();
2599         (void) define_key (0, 0);
2600         (void) is_term_resized (0, 0);
2601         (void) key_defined (0);
2602         (void) keybound (0, 0);
2603         (void) keyok (0, 0);
2604         (void) resize_term (0, 0);
2605         (void) resizeterm (0, 0);
2606         (void) use_default_colors ();
2607         (void) use_extended_names (0);
2608         (void) wresize (0, 0, 0);],
2609         [cf_cv_ncurses_ext_funcs=yes],
2610         [cf_cv_ncurses_ext_funcs=no])
2611 ])
2612 ])
2613 test "$cf_cv_ncurses_ext_funcs" = yes && AC_DEFINE(NCURSES_EXT_FUNCS,1,[Define to 1 if we have ncurses extensions])
2614 ])dnl
2615 dnl ---------------------------------------------------------------------------
2616 dnl CF_NCURSES_HEADER version: 4 updated: 2015/04/15 19:08:48
2617 dnl -----------------
2618 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
2619 dnl variations of ncurses' installs.
2620 dnl
2621 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
2622 AC_DEFUN([CF_NCURSES_HEADER],[
2623
2624 if test "$cf_cv_ncurses_h" != no ; then
2625         cf_cv_ncurses_header=$cf_cv_ncurses_h
2626 else
2627
2628 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
2629         test -n "$verbose" && echo
2630         CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
2631         test -n "$verbose" && echo search path $cf_search
2632         cf_save2_CPPFLAGS="$CPPFLAGS"
2633         for cf_incdir in $cf_search
2634         do
2635                 CF_ADD_INCDIR($cf_incdir)
2636                 for cf_header in \
2637                         ncurses.h \
2638                         curses.h
2639                 do
2640                         CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
2641                         if test "$cf_cv_ncurses_h2" != no ; then
2642                                 cf_cv_ncurses_h2=$cf_incdir/$cf_header
2643                                 test -n "$verbose" && echo $ac_n "      ... found $ac_c" 1>&AC_FD_MSG
2644                                 break
2645                         fi
2646                         test -n "$verbose" && echo "    ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
2647                 done
2648                 CPPFLAGS="$cf_save2_CPPFLAGS"
2649                 test "$cf_cv_ncurses_h2" != no && break
2650         done
2651         test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
2652         ])
2653
2654         CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
2655         cf_cv_ncurses_header=`basename $cf_cv_ncurses_h2`
2656         if test `basename $cf_1st_incdir` = $cf_ncuhdr_root ; then
2657                 cf_cv_ncurses_header=$cf_ncuhdr_root/$cf_cv_ncurses_header
2658         fi
2659         CF_ADD_INCDIR($cf_1st_incdir)
2660
2661 fi
2662
2663 # Set definitions to allow ifdef'ing for ncurses.h
2664
2665 case $cf_cv_ncurses_header in
2666 (*ncurses.h)
2667         AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
2668         ;;
2669 esac
2670
2671 case $cf_cv_ncurses_header in
2672 (ncurses/curses.h|ncurses/ncurses.h)
2673         AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
2674         ;;
2675 (ncursesw/curses.h|ncursesw/ncurses.h)
2676         AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
2677         ;;
2678 esac
2679
2680 ])dnl
2681 dnl ---------------------------------------------------------------------------
2682 dnl CF_NCURSES_LIBS version: 17 updated: 2015/04/15 19:08:48
2683 dnl ---------------
2684 dnl Look for the ncurses library.  This is a little complicated on Linux,
2685 dnl because it may be linked with the gpm (general purpose mouse) library.
2686 dnl Some distributions have gpm linked with (bsd) curses, which makes it
2687 dnl unusable with ncurses.  However, we don't want to link with gpm unless
2688 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
2689 dnl and the linker will record a dependency.
2690 dnl
2691 dnl The optional parameter gives the root name of the library, in case it is
2692 dnl not installed as the default curses library.  That is how the
2693 dnl wide-character version of ncurses is installed.
2694 AC_DEFUN([CF_NCURSES_LIBS],
2695 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
2696
2697 cf_nculib_root=ifelse($1,,ncurses,$1)
2698         # This works, except for the special case where we find gpm, but
2699         # ncurses is in a nonstandard location via $LIBS, and we really want
2700         # to link gpm.
2701 cf_ncurses_LIBS=""
2702 cf_ncurses_SAVE="$LIBS"
2703 AC_CHECK_LIB(gpm,Gpm_Open,
2704         [AC_CHECK_LIB(gpm,initscr,
2705                 [LIBS="$cf_ncurses_SAVE"],
2706                 [cf_ncurses_LIBS="-lgpm"])])
2707
2708 case $host_os in
2709 (freebsd*)
2710         # This is only necessary if you are linking against an obsolete
2711         # version of ncurses (but it should do no harm, since it's static).
2712         if test "$cf_nculib_root" = ncurses ; then
2713                 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
2714         fi
2715         ;;
2716 esac
2717
2718 CF_ADD_LIBS($cf_ncurses_LIBS)
2719
2720 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
2721 then
2722         CF_ADD_LIBS(-l$cf_nculib_root)
2723 else
2724         CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
2725                 [#include <${cf_cv_ncurses_header:-curses.h}>],
2726                 [initscr()],
2727                 initscr)
2728 fi
2729
2730 if test -n "$cf_ncurses_LIBS" ; then
2731         AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
2732         cf_ncurses_SAVE="$LIBS"
2733         for p in $cf_ncurses_LIBS ; do
2734                 q=`echo $LIBS | sed -e "s%$p %%" -e "s%$p$%%"`
2735                 if test "$q" != "$LIBS" ; then
2736                         LIBS="$q"
2737                 fi
2738         done
2739         AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2740                 [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2741                 [AC_MSG_RESULT(yes)],
2742                 [AC_MSG_RESULT(no)
2743                  LIBS="$cf_ncurses_SAVE"])
2744 fi
2745
2746 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
2747 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2748 ])dnl
2749 dnl ---------------------------------------------------------------------------
2750 dnl CF_NCURSES_PTHREADS version: 2 updated: 2016/04/22 05:07:41
2751 dnl -------------------
2752 dnl Use this followup check to ensure that we link with pthreads if ncurses
2753 dnl uses it.
2754 AC_DEFUN([CF_NCURSES_PTHREADS],[
2755 : ${cf_nculib_root:=ifelse($1,,ncurses,$1)}
2756 AC_CHECK_LIB($cf_nculib_root,_nc_init_pthreads,
2757         cf_cv_ncurses_pthreads=yes,
2758         cf_cv_ncurses_pthreads=no)
2759 if test "$cf_cv_ncurses_pthreads" = yes
2760 then
2761         CF_ADD_LIBS(-lpthread)
2762 fi
2763 ])dnl
2764 dnl ---------------------------------------------------------------------------
2765 dnl CF_NCURSES_VERSION version: 15 updated: 2017/05/09 19:26:10
2766 dnl ------------------
2767 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
2768 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS.  We don't use
2769 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
2770 AC_DEFUN([CF_NCURSES_VERSION],
2771 [
2772 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
2773 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
2774         cf_cv_ncurses_version=no
2775         cf_tempfile=out$$
2776         rm -f $cf_tempfile
2777         AC_TRY_RUN([
2778 #include <${cf_cv_ncurses_header:-curses.h}>
2779 #include <stdio.h>
2780 int main(void)
2781 {
2782         FILE *fp = fopen("$cf_tempfile", "w");
2783 #ifdef NCURSES_VERSION
2784 # ifdef NCURSES_VERSION_PATCH
2785         fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
2786 # else
2787         fprintf(fp, "%s\n", NCURSES_VERSION);
2788 # endif
2789 #else
2790 # ifdef __NCURSES_H
2791         fprintf(fp, "old\n");
2792 # else
2793         make an error
2794 # endif
2795 #endif
2796         ${cf_cv_main_return:-return}(0);
2797 }],[
2798         cf_cv_ncurses_version=`cat $cf_tempfile`],,[
2799
2800         # This will not work if the preprocessor splits the line after the
2801         # Autoconf token.  The 'unproto' program does that.
2802         cat > conftest.$ac_ext <<EOF
2803 #include <${cf_cv_ncurses_header:-curses.h}>
2804 #undef Autoconf
2805 #ifdef NCURSES_VERSION
2806 Autoconf NCURSES_VERSION
2807 #else
2808 #ifdef __NCURSES_H
2809 Autoconf "old"
2810 #endif
2811 ;
2812 #endif
2813 EOF
2814         cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
2815         AC_TRY_EVAL(cf_try)
2816         if test -f conftest.out ; then
2817                 cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%'`
2818                 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
2819                 rm -f conftest.out
2820         fi
2821 ])
2822         rm -f $cf_tempfile
2823 ])
2824 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2825 ])dnl
2826 dnl ---------------------------------------------------------------------------
2827 dnl CF_NCURSES_WRAP_PREFIX version: 1 updated: 2009/03/28 16:08:10
2828 dnl ----------------------
2829 dnl Check for ncurses "wrap-prefix" used for public variables which have been
2830 dnl wrapped with a function to help with concurrency control.
2831 AC_DEFUN([CF_NCURSES_WRAP_PREFIX],
2832 [
2833 AC_MSG_CHECKING(for ncurses wrap-prefix)
2834 AC_ARG_WITH(ncurses-wrap-prefix,
2835         [  --with-ncurses-wrap-prefix naming-prefix for ncurses wrapped-variables],
2836         [NCURSES_WRAP_PREFIX=$withval],
2837         [NCURSES_WRAP_PREFIX=_nc_])
2838 AC_MSG_RESULT($NCURSES_WRAP_PREFIX)
2839
2840 AC_SUBST(NCURSES_WRAP_PREFIX)
2841 ])
2842 dnl ---------------------------------------------------------------------------
2843 dnl CF_NETBSD_FORM_H version: 2 updated: 2012/10/06 16:39:58
2844 dnl ----------------
2845 dnl Check for NetBSD's form.h, which is incompatible with SVr4 and ncurses.
2846 dnl Some workarounds are needed in client programs to allow them to compile.
2847 AC_DEFUN([CF_NETBSD_FORM_H],[
2848 AC_CACHE_CHECK(for NetBSD form.h,cf_cv_netbsd_form_h,[
2849 AC_TRY_COMPILE([
2850 #include <${cf_cv_ncurses_header:-curses.h}>
2851 #include <form.h>
2852 ],[
2853         FORM *form;
2854         int y = current_field(form)->cursor_ypos;
2855         int x = current_field(form)->cursor_xpos;
2856 ],[cf_cv_netbsd_form_h=yes
2857 ],[cf_cv_netbsd_form_h=no])
2858 ])
2859
2860 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])
2861 ])dnl
2862 dnl ---------------------------------------------------------------------------
2863 dnl CF_NETBSD_MENU_H version: 2 updated: 2012/10/06 16:39:58
2864 dnl ----------------
2865 dnl Check for NetBSD's menu.h, which is incompatible with SVr4 and ncurses.
2866 dnl Some workarounds are needed in client programs to allow them to compile.
2867 AC_DEFUN([CF_NETBSD_MENU_H],[
2868 AC_CACHE_CHECK(for NetBSD menu.h,cf_cv_netbsd_menu_h,[
2869 AC_TRY_COMPILE([
2870 #include <${cf_cv_ncurses_header:-curses.h}>
2871 #include <menu.h>
2872 ],[
2873         MENU *menu;
2874         int y = menu->max_item_width;
2875 ],[cf_cv_netbsd_menu_h=yes
2876 ],[cf_cv_netbsd_menu_h=no])
2877 ])
2878
2879 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])
2880 ])dnl
2881 dnl ---------------------------------------------------------------------------
2882 dnl CF_NO_LEAKS_OPTION version: 6 updated: 2015/04/12 15:39:00
2883 dnl ------------------
2884 dnl see CF_WITH_NO_LEAKS
2885 AC_DEFUN([CF_NO_LEAKS_OPTION],[
2886 AC_MSG_CHECKING(if you want to use $1 for testing)
2887 AC_ARG_WITH($1,
2888         [$2],
2889         [AC_DEFINE_UNQUOTED($3,1,"Define to 1 if you want to use $1 for testing.")ifelse([$4],,[
2890          $4
2891 ])
2892         : ${with_cflags:=-g}
2893         : ${with_no_leaks:=yes}
2894          with_$1=yes],
2895         [with_$1=])
2896 AC_MSG_RESULT(${with_$1:-no})
2897
2898 case .$with_cflags in
2899 (.*-g*)
2900         case .$CFLAGS in
2901         (.*-g*)
2902                 ;;
2903         (*)
2904                 CF_ADD_CFLAGS([-g])
2905                 ;;
2906         esac
2907         ;;
2908 esac
2909 ])dnl
2910 dnl ---------------------------------------------------------------------------
2911 dnl CF_PATH_SYNTAX version: 16 updated: 2015/04/18 08:56:57
2912 dnl --------------
2913 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
2914 dnl begins with one of the prefix/exec_prefix variables, and then again if the
2915 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
2916 dnl delayed evaluation of those symbols.
2917 AC_DEFUN([CF_PATH_SYNTAX],[
2918 if test "x$prefix" != xNONE; then
2919         cf_path_syntax="$prefix"
2920 else
2921         cf_path_syntax="$ac_default_prefix"
2922 fi
2923
2924 case ".[$]$1" in
2925 (.\[$]\(*\)*|.\'*\'*)
2926         ;;
2927 (..|./*|.\\*)
2928         ;;
2929 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
2930         ;;
2931 (.\[$]{*prefix}*|.\[$]{*dir}*)
2932         eval $1="[$]$1"
2933         case ".[$]$1" in
2934         (.NONE/*)
2935                 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
2936                 ;;
2937         esac
2938         ;;
2939 (.no|.NONE/*)
2940         $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
2941         ;;
2942 (*)
2943         ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
2944         ;;
2945 esac
2946 ])dnl
2947 dnl ---------------------------------------------------------------------------
2948 dnl CF_PDCURSES_X11 version: 14 updated: 2018/06/20 20:23:13
2949 dnl ---------------
2950 dnl Configure for PDCurses' X11 library
2951 AC_DEFUN([CF_PDCURSES_X11],[
2952 AC_REQUIRE([CF_X_ATHENA])
2953
2954 CF_ACVERSION_CHECK(2.52,
2955         [AC_CHECK_TOOLS(XCURSES_CONFIG, xcurses-config, none)],
2956         [AC_PATH_PROGS(XCURSES_CONFIG, xcurses-config, none)])
2957
2958 if test "$XCURSES_CONFIG" != none ; then
2959
2960 CF_ADD_CFLAGS(`$XCURSES_CONFIG --cflags`)
2961 CF_ADD_LIBS(`$XCURSES_CONFIG --libs`)
2962
2963 cf_cv_lib_XCurses=yes
2964
2965 else
2966
2967 LDFLAGS="$LDFLAGS $X_LIBS"
2968 CF_CHECK_CFLAGS($X_CFLAGS)
2969 AC_CHECK_LIB(X11,XOpenDisplay,
2970         [CF_ADD_LIBS(-lX11)],,
2971         [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])
2972 AC_CACHE_CHECK(for XCurses library,cf_cv_lib_XCurses,[
2973 CF_ADD_LIBS(-lXCurses)
2974 AC_TRY_LINK([
2975 #include <xcurses.h>
2976 char *XCursesProgramName = "test";
2977 ],[XCursesExit();],
2978 [cf_cv_lib_XCurses=yes],
2979 [cf_cv_lib_XCurses=no])
2980 ])
2981
2982 fi
2983
2984 if test $cf_cv_lib_XCurses = yes ; then
2985         AC_DEFINE(UNIX,1,[Define to 1 if using PDCurses on Unix])
2986         AC_DEFINE(XCURSES,1,[Define to 1 if using PDCurses on Unix])
2987         AC_CHECK_HEADER(xcurses.h, AC_DEFINE(HAVE_XCURSES,1,[Define to 1 if using PDCurses on Unix]))
2988 else
2989         AC_MSG_ERROR(Cannot link with XCurses)
2990 fi
2991 ])dnl
2992 dnl ---------------------------------------------------------------------------
2993 dnl CF_PKG_CONFIG version: 10 updated: 2015/04/26 18:06:58
2994 dnl -------------
2995 dnl Check for the package-config program, unless disabled by command-line.
2996 AC_DEFUN([CF_PKG_CONFIG],
2997 [
2998 AC_MSG_CHECKING(if you want to use pkg-config)
2999 AC_ARG_WITH(pkg-config,
3000         [  --with-pkg-config{=path} enable/disable use of pkg-config],
3001         [cf_pkg_config=$withval],
3002         [cf_pkg_config=yes])
3003 AC_MSG_RESULT($cf_pkg_config)
3004
3005 case $cf_pkg_config in
3006 (no)
3007         PKG_CONFIG=none
3008         ;;
3009 (yes)
3010         CF_ACVERSION_CHECK(2.52,
3011                 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
3012                 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
3013         ;;
3014 (*)
3015         PKG_CONFIG=$withval
3016         ;;
3017 esac
3018
3019 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3020 if test "$PKG_CONFIG" != none ; then
3021         CF_PATH_SYNTAX(PKG_CONFIG)
3022 elif test "x$cf_pkg_config" != xno ; then
3023         AC_MSG_WARN(pkg-config is not installed)
3024 fi
3025
3026 AC_SUBST(PKG_CONFIG)
3027 ])dnl
3028 dnl ---------------------------------------------------------------------------
3029 dnl CF_POSIX_C_SOURCE version: 11 updated: 2018/12/31 20:46:17
3030 dnl -----------------
3031 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3032 dnl
3033 dnl     POSIX.1-1990                            _POSIX_SOURCE
3034 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
3035 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
3036 dnl             Bindings Option
3037 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
3038 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
3039 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
3040 dnl
3041 dnl Parameters:
3042 dnl     $1 is the nominal value for _POSIX_C_SOURCE
3043 AC_DEFUN([CF_POSIX_C_SOURCE],
3044 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
3045
3046 if test "$cf_cv_posix_visible" = no; then
3047
3048 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
3049
3050 cf_save_CFLAGS="$CFLAGS"
3051 cf_save_CPPFLAGS="$CPPFLAGS"
3052
3053 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3054 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3055
3056 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3057         CF_MSG_LOG(if the symbol is already defined go no further)
3058         AC_TRY_COMPILE([#include <sys/types.h>],[
3059 #ifndef _POSIX_C_SOURCE
3060 make an error
3061 #endif],
3062         [cf_cv_posix_c_source=no],
3063         [cf_want_posix_source=no
3064          case .$cf_POSIX_C_SOURCE in
3065          (.[[12]]??*)
3066                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3067                 ;;
3068          (.2)
3069                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3070                 cf_want_posix_source=yes
3071                 ;;
3072          (.*)
3073                 cf_want_posix_source=yes
3074                 ;;
3075          esac
3076          if test "$cf_want_posix_source" = yes ; then
3077                 AC_TRY_COMPILE([#include <sys/types.h>],[
3078 #ifdef _POSIX_SOURCE
3079 make an error
3080 #endif],[],
3081                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3082          fi
3083          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3084          CFLAGS="$cf_trim_CFLAGS"
3085          CPPFLAGS="$cf_trim_CPPFLAGS"
3086          CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
3087          CF_MSG_LOG(if the second compile does not leave our definition intact error)
3088          AC_TRY_COMPILE([#include <sys/types.h>],[
3089 #ifndef _POSIX_C_SOURCE
3090 make an error
3091 #endif],,
3092          [cf_cv_posix_c_source=no])
3093          CFLAGS="$cf_save_CFLAGS"
3094          CPPFLAGS="$cf_save_CPPFLAGS"
3095         ])
3096 ])
3097
3098 if test "$cf_cv_posix_c_source" != no ; then
3099         CFLAGS="$cf_trim_CFLAGS"
3100         CPPFLAGS="$cf_trim_CPPFLAGS"
3101         CF_ADD_CFLAGS($cf_cv_posix_c_source)
3102 fi
3103
3104 fi # cf_cv_posix_visible
3105
3106 ])dnl
3107 dnl ---------------------------------------------------------------------------
3108 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
3109 dnl ----------------
3110 dnl POSIX documents test-macros which an application may set before any system
3111 dnl headers are included to make features available.
3112 dnl
3113 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
3114 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
3115 dnl recent features visible in the system header files unless the application
3116 dnl overrides the corresponding test-macros.  Doing that introduces portability
3117 dnl problems.
3118 dnl
3119 dnl This macro makes a special check for the symbols used for this, to avoid a
3120 dnl conflicting definition.
3121 AC_DEFUN([CF_POSIX_VISIBLE],
3122 [
3123 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
3124 AC_TRY_COMPILE([#include <stdio.h>],[
3125 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
3126         && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
3127         && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
3128         && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
3129 #error conflicting symbols found
3130 #endif
3131 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
3132 ])
3133 ])dnl
3134 dnl ---------------------------------------------------------------------------
3135 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
3136 dnl ------------
3137 dnl Append definitions and rules for the given programs to the subdirectory
3138 dnl Makefiles, and the recursion rule for the top-level Makefile.
3139 dnl
3140 dnl parameters
3141 dnl     $1 = script to run
3142 dnl     $2 = list of subdirectories
3143 dnl
3144 dnl variables
3145 dnl     $AWK
3146 AC_DEFUN([CF_PRG_RULES],
3147 [
3148 for cf_dir in $2
3149 do
3150         if test ! -d $srcdir/$cf_dir; then
3151                 continue
3152         elif test -f $srcdir/$cf_dir/programs; then
3153                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
3154         fi
3155 done
3156
3157 ])dnl
3158 dnl ---------------------------------------------------------------------------
3159 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
3160 dnl ----------
3161 dnl standard check for CC, plus followup sanity checks
3162 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
3163 AC_DEFUN([CF_PROG_CC],[
3164 CF_ACVERSION_CHECK(2.53,
3165         [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
3166          AC_REQUIRE([AC_PROG_CC])],
3167         [])
3168 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
3169 CF_GCC_VERSION
3170 CF_ACVERSION_CHECK(2.52,
3171         [AC_PROG_CC_STDC],
3172         [CF_ANSI_CC_REQD])
3173 CF_CC_ENV_FLAGS
3174 ])dnl
3175 dnl ---------------------------------------------------------------------------
3176 dnl CF_PROG_INSTALL version: 7 updated: 2015/04/18 08:56:57
3177 dnl ---------------
3178 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
3179 dnl misc/tabset install won't work properly.  Usually this happens only when
3180 dnl using the fallback mkinstalldirs script
3181 AC_DEFUN([CF_PROG_INSTALL],
3182 [AC_PROG_INSTALL
3183 case $INSTALL in
3184 (/*)
3185         ;;
3186 (*)
3187         CF_DIRNAME(cf_dir,$INSTALL)
3188         test -z "$cf_dir" && cf_dir=.
3189         INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
3190         ;;
3191 esac
3192 ])dnl
3193 dnl ---------------------------------------------------------------------------
3194 dnl CF_PROG_LINT version: 4 updated: 2019/11/20 18:55:37
3195 dnl ------------
3196 AC_DEFUN([CF_PROG_LINT],
3197 [
3198 AC_CHECK_PROGS(LINT, lint cppcheck splint)
3199 case "x$LINT" in
3200 (xcppcheck|x*/cppcheck)
3201         test -z "$LINT_OPTS" && LINT_OPTS="--enable=all"
3202         ;;
3203 esac
3204 AC_SUBST(LINT_OPTS)
3205 ])dnl
3206 dnl ---------------------------------------------------------------------------
3207 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
3208 dnl ----------------
3209 dnl Remove all -U and -D options that refer to the given symbol from a list
3210 dnl of C compiler options.  This works around the problem that not all
3211 dnl compilers process -U and -D options from left-to-right, so a -U option
3212 dnl cannot be used to cancel the effect of a preceding -D option.
3213 dnl
3214 dnl $1 = target (which could be the same as the source variable)
3215 dnl $2 = source (including '$')
3216 dnl $3 = symbol to remove
3217 define([CF_REMOVE_DEFINE],
3218 [
3219 $1=`echo "$2" | \
3220         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
3221                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
3222 ])dnl
3223 dnl ---------------------------------------------------------------------------
3224 dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45
3225 dnl ---------------------
3226 dnl Restore flags saved in CF_SAVE_XTRA_FLAGS
3227 dnl $1 = name of current macro
3228 define([CF_RESTORE_XTRA_FLAGS],
3229 [
3230 LIBS="$cf_save_LIBS_$1"
3231 CFLAGS="$cf_save_CFLAGS_$1"
3232 CPPFLAGS="$cf_save_CPPFLAGS_$1"
3233 ])dnl
3234 dnl ---------------------------------------------------------------------------
3235 dnl CF_RPATH_HACK version: 11 updated: 2013/09/01 13:02:00
3236 dnl -------------
3237 AC_DEFUN([CF_RPATH_HACK],
3238 [
3239 AC_REQUIRE([CF_LD_RPATH_OPT])
3240 AC_MSG_CHECKING(for updated LDFLAGS)
3241 if test -n "$LD_RPATH_OPT" ; then
3242         AC_MSG_RESULT(maybe)
3243
3244         AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
3245         cf_rpath_list="/usr/lib /lib"
3246         if test "$cf_ldd_prog" != no
3247         then
3248                 cf_rpath_oops=
3249
3250 AC_TRY_LINK([#include <stdio.h>],
3251                 [printf("Hello");],
3252                 [cf_rpath_oops=`$cf_ldd_prog conftest$ac_exeext | fgrep ' not found' | sed -e 's% =>.*$%%' |sort | uniq`
3253                  cf_rpath_list=`$cf_ldd_prog conftest$ac_exeext | fgrep / | sed -e 's%^.*[[     ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort | uniq`])
3254
3255                 # If we passed the link-test, but get a "not found" on a given library,
3256                 # this could be due to inept reconfiguration of gcc to make it only
3257                 # partly honor /usr/local/lib (or whatever).  Sometimes this behavior
3258                 # is intentional, e.g., installing gcc in /usr/bin and suppressing the
3259                 # /usr/local libraries.
3260                 if test -n "$cf_rpath_oops"
3261                 then
3262                         for cf_rpath_src in $cf_rpath_oops
3263                         do
3264                                 for cf_rpath_dir in \
3265                                         /usr/local \
3266                                         /usr/pkg \
3267                                         /opt/sfw
3268                                 do
3269                                         if test -f $cf_rpath_dir/lib/$cf_rpath_src
3270                                         then
3271                                                 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
3272                                                 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
3273                                                 break
3274                                         fi
3275                                 done
3276                         done
3277                 fi
3278         fi
3279
3280         CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3281
3282         CF_RPATH_HACK_2(LDFLAGS)
3283         CF_RPATH_HACK_2(LIBS)
3284
3285         CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3286 else
3287         AC_MSG_RESULT(no)
3288 fi
3289 AC_SUBST(EXTRA_LDFLAGS)
3290 ])dnl
3291 dnl ---------------------------------------------------------------------------
3292 dnl CF_RPATH_HACK_2 version: 7 updated: 2015/04/12 15:39:00
3293 dnl ---------------
3294 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
3295 dnl EXTRA_LDFLAGS for each -L option found.
3296 dnl
3297 dnl $cf_rpath_list contains a list of directories to ignore.
3298 dnl
3299 dnl $1 = variable name to update.  The LDFLAGS variable should be the only one,
3300 dnl      but LIBS often has misplaced -L options.
3301 AC_DEFUN([CF_RPATH_HACK_2],
3302 [
3303 CF_VERBOSE(...checking $1 [$]$1)
3304
3305 cf_rpath_dst=
3306 for cf_rpath_src in [$]$1
3307 do
3308         case $cf_rpath_src in
3309         (-L*)
3310
3311                 # check if this refers to a directory which we will ignore
3312                 cf_rpath_skip=no
3313                 if test -n "$cf_rpath_list"
3314                 then
3315                         for cf_rpath_item in $cf_rpath_list
3316                         do
3317                                 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
3318                                 then
3319                                         cf_rpath_skip=yes
3320                                         break
3321                                 fi
3322                         done
3323                 fi
3324
3325                 if test "$cf_rpath_skip" = no
3326                 then
3327                         # transform the option
3328                         if test "$LD_RPATH_OPT" = "-R " ; then
3329                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
3330                         else
3331                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
3332                         fi
3333
3334                         # if we have not already added this, add it now
3335                         cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
3336                         if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
3337                         then
3338                                 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
3339                                 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
3340                         fi
3341                 fi
3342                 ;;
3343         esac
3344         cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
3345 done
3346 $1=$cf_rpath_dst
3347
3348 CF_VERBOSE(...checked $1 [$]$1)
3349 AC_SUBST(EXTRA_LDFLAGS)
3350 ])dnl
3351 dnl ---------------------------------------------------------------------------
3352 dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44
3353 dnl ------------------
3354 dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers
3355 dnl and libraries which do not update those variables.
3356 dnl
3357 dnl $1 = name of current macro
3358 define([CF_SAVE_XTRA_FLAGS],
3359 [
3360 cf_save_LIBS_$1="$LIBS"
3361 cf_save_CFLAGS_$1="$CFLAGS"
3362 cf_save_CPPFLAGS_$1="$CPPFLAGS"
3363 LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}"
3364 for cf_X_CFLAGS in $X_CFLAGS
3365 do
3366         case "x$cf_X_CFLAGS" in
3367         x-[[IUD]]*)
3368                 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS"
3369                 ;;
3370         *)
3371                 CFLAGS="$CFLAGS $cf_X_CFLAGS"
3372                 ;;
3373         esac
3374 done
3375 ])dnl
3376 dnl ---------------------------------------------------------------------------
3377 dnl CF_SIGWINCH version: 3 updated: 2020/03/10 18:53:47
3378 dnl -----------
3379 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
3380 dnl programs need this test).
3381 dnl
3382 dnl This is really a Mac OS X 10.4.3 workaround.  Defining _POSIX_C_SOURCE
3383 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses).  Oddly, the struct
3384 dnl winsize declaration is left alone - we may revisit this if Apple choose to
3385 dnl break that part of the interface as well.
3386 AC_DEFUN([CF_SIGWINCH],
3387 [
3388 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
3389         AC_TRY_COMPILE([
3390 #include <sys/types.h>
3391 #include <sys/signal.h>
3392 ],[int x = SIGWINCH; (void)x],
3393         [cf_cv_define_sigwinch=yes],
3394         [AC_TRY_COMPILE([
3395 #undef _XOPEN_SOURCE
3396 #undef _POSIX_SOURCE
3397 #undef _POSIX_C_SOURCE
3398 #include <sys/types.h>
3399 #include <sys/signal.h>
3400 ],[int x = SIGWINCH; (void)x],
3401         [cf_cv_define_sigwinch=maybe],
3402         [cf_cv_define_sigwinch=no])
3403 ])
3404 ])
3405
3406 if test "$cf_cv_define_sigwinch" = maybe ; then
3407 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
3408 cf_cv_fixup_sigwinch=unknown
3409 cf_sigwinch=32
3410 while test $cf_sigwinch != 1
3411 do
3412         AC_TRY_COMPILE([
3413 #undef _XOPEN_SOURCE
3414 #undef _POSIX_SOURCE
3415 #undef _POSIX_C_SOURCE
3416 #include <sys/types.h>
3417 #include <sys/signal.h>
3418 ],[
3419 #if SIGWINCH != $cf_sigwinch
3420 make an error
3421 #endif
3422 int x = SIGWINCH; (void)x],
3423         [cf_cv_fixup_sigwinch=$cf_sigwinch
3424          break])
3425
3426 cf_sigwinch=`expr $cf_sigwinch - 1`
3427 done
3428 ])
3429
3430         if test "$cf_cv_fixup_sigwinch" != unknown ; then
3431                 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
3432         fi
3433 fi
3434 ])dnl
3435 dnl ---------------------------------------------------------------------------
3436 dnl CF_SIG_ATOMIC_T version: 5 updated: 2020/03/10 18:53:47
3437 dnl ---------------
3438 dnl signal handler, but there are some gcc dependencies in that recommendation.
3439 dnl Try anyway.
3440 AC_DEFUN([CF_SIG_ATOMIC_T],
3441 [
3442 AC_MSG_CHECKING(for signal global datatype)
3443 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
3444         for cf_type in \
3445                 "volatile sig_atomic_t" \
3446                 "sig_atomic_t" \
3447                 "int"
3448         do
3449         AC_TRY_COMPILE([
3450 #include <sys/types.h>
3451 #include <signal.h>
3452 #include <stdio.h>
3453
3454 extern $cf_type x;
3455 $cf_type x;
3456 static void handler(int sig)
3457 {
3458         (void)sig;
3459         x = 5;
3460 }],
3461                 [signal(SIGINT, handler);
3462                  x = 1],
3463                 [cf_cv_sig_atomic_t=$cf_type],
3464                 [cf_cv_sig_atomic_t=no])
3465                 test "$cf_cv_sig_atomic_t" != no && break
3466         done
3467         ])
3468 AC_MSG_RESULT($cf_cv_sig_atomic_t)
3469 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t,[Define to signal global datatype])
3470 ])dnl
3471 dnl ---------------------------------------------------------------------------
3472 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
3473 dnl --------------
3474 dnl Construct a search-list for a nonstandard header/lib-file
3475 dnl     $1 = the variable to return as result
3476 dnl     $2 = the package name
3477 dnl     $3 = the subdirectory, e.g., bin, include or lib
3478 AC_DEFUN([CF_SUBDIR_PATH],
3479 [
3480 $1=
3481
3482 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
3483
3484 for cf_subdir_prefix in \
3485         /usr \
3486         /usr/local \
3487         /usr/pkg \
3488         /opt \
3489         /opt/local \
3490         [$]HOME
3491 do
3492         CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
3493 done
3494 ])dnl
3495 dnl ---------------------------------------------------------------------------
3496 dnl CF_SYS_TIME_SELECT version: 6 updated: 2015/04/18 08:56:57
3497 dnl ------------------
3498 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
3499 dnl older SCO configurations.
3500 AC_DEFUN([CF_SYS_TIME_SELECT],
3501 [
3502 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
3503 AC_CACHE_VAL(cf_cv_sys_time_select,[
3504 AC_TRY_COMPILE([
3505 #include <sys/types.h>
3506 #ifdef HAVE_SYS_TIME_H
3507 #include <sys/time.h>
3508 #endif
3509 #ifdef HAVE_SYS_SELECT_H
3510 #include <sys/select.h>
3511 #endif
3512 ],[],[cf_cv_sys_time_select=yes],
3513          [cf_cv_sys_time_select=no])
3514          ])
3515 AC_MSG_RESULT($cf_cv_sys_time_select)
3516 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>])
3517 ])dnl
3518 dnl ---------------------------------------------------------------------------
3519 dnl CF_TERM_HEADER version: 5 updated: 2020/03/19 20:23:48
3520 dnl --------------
3521 dnl Look for term.h, which is part of X/Open curses.  It defines the interface
3522 dnl to terminfo database.  Usually it is in the same include-path as curses.h,
3523 dnl but some packagers change this, breaking various applications.
3524 AC_DEFUN([CF_TERM_HEADER],[
3525 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
3526 case ${cf_cv_ncurses_header} in
3527 (*/ncurses.h|*/ncursesw.h)
3528         cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
3529         ;;
3530 (*)
3531         cf_term_header=term.h
3532         ;;
3533 esac
3534
3535 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
3536 do
3537 AC_TRY_COMPILE([#include <stdio.h>
3538 #include <${cf_cv_ncurses_header:-curses.h}>
3539 #include <$cf_test>
3540 ],[int x = auto_left_margin; (void)x],[
3541         cf_cv_term_header="$cf_test"],[
3542         cf_cv_term_header=unknown
3543         ])
3544         test "$cf_cv_term_header" != unknown && break
3545 done
3546 ])
3547
3548 # Set definitions to allow ifdef'ing to accommodate subdirectories
3549
3550 case $cf_cv_term_header in
3551 (*term.h)
3552         AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
3553         ;;
3554 esac
3555
3556 case $cf_cv_term_header in
3557 (ncurses/term.h)
3558         AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
3559         ;;
3560 (ncursesw/term.h)
3561         AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
3562         ;;
3563 esac
3564 ])dnl
3565 dnl ---------------------------------------------------------------------------
3566 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
3567 dnl ---------------
3568 dnl Define a top_builddir symbol, for applications that need an absolute path.
3569 AC_DEFUN([CF_TOP_BUILDDIR],
3570 [
3571 top_builddir=ifelse($1,,`pwd`,$1)
3572 AC_SUBST(top_builddir)
3573 ])dnl
3574 dnl ---------------------------------------------------------------------------
3575 dnl CF_TPUTS_PROTO version: 3 updated: 2015/04/17 21:26:14
3576 dnl --------------
3577 dnl Check for type of function-pointer passed to tputs.  Some old
3578 dnl implementations used functions that had different prototypes, making it
3579 dnl hard to compile portable programs using tputs.
3580 AC_DEFUN([CF_TPUTS_PROTO],[
3581 CF_CURSES_FUNCS(tputs)
3582 if test x$cf_cv_func_tputs = xyes
3583 then
3584         cf_done=no
3585         for cf_arg in int char
3586         do
3587                 for cf_ret in int void
3588                 do
3589                         if test $cf_ret = void
3590                         then
3591                                 cf_return="/* nothing */"
3592                         else
3593                                 cf_return="return value"
3594                         fi
3595                         AC_TRY_COMPILE([
3596 #include <${cf_cv_ncurses_header:-curses.h}>
3597 #include <$cf_cv_term_header>
3598
3599 static $cf_ret outc($cf_arg value) { $cf_return; }
3600 ],[
3601         tputs("hello", 0, outc);
3602         ${cf_cv_main_return:-return}(0);
3603 ],[
3604                 CF_VERBOSE([prototype $cf_ret func($cf_arg value)])
3605                 cat >>confdefs.h <<EOF
3606 #define TPUTS_ARG               $cf_arg
3607 #define TPUTS_PROTO(func,value) $cf_ret func(TPUTS_ARG value)
3608 #define TPUTS_RETURN(value)     $cf_return
3609 EOF
3610                 cf_done=yes
3611                 break
3612 ])
3613                 done
3614                 test $cf_done = yes && break
3615         done
3616 fi
3617 ])dnl
3618 dnl ---------------------------------------------------------------------------
3619 dnl CF_TRIM_X_LIBS version: 3 updated: 2015/04/12 15:39:00
3620 dnl --------------
3621 dnl Trim extra base X libraries added as a workaround for inconsistent library
3622 dnl dependencies returned by "new" pkg-config files.
3623 AC_DEFUN([CF_TRIM_X_LIBS],[
3624         for cf_trim_lib in Xmu Xt X11
3625         do
3626                 case "$LIBS" in
3627                 (*-l$cf_trim_lib\ *-l$cf_trim_lib*)
3628                         LIBS=`echo "$LIBS " | sed -e 's/  / /g' -e 's%-l'"$cf_trim_lib"' %%' -e 's/ $//'`
3629                         CF_VERBOSE(..trimmed $LIBS)
3630                         ;;
3631                 esac
3632         done
3633 ])
3634 dnl ---------------------------------------------------------------------------
3635 dnl CF_TRY_PKG_CONFIG version: 5 updated: 2013/07/06 21:27:06
3636 dnl -----------------
3637 dnl This is a simple wrapper to use for pkg-config, for libraries which may be
3638 dnl available in that form.
3639 dnl
3640 dnl $1 = package name
3641 dnl $2 = extra logic to use, if any, after updating CFLAGS and LIBS
3642 dnl $3 = logic to use if pkg-config does not have the package
3643 AC_DEFUN([CF_TRY_PKG_CONFIG],[
3644 AC_REQUIRE([CF_PKG_CONFIG])
3645
3646 if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists $1; then
3647         CF_VERBOSE(found package $1)
3648         cf_pkgconfig_incs="`$PKG_CONFIG --cflags $1 2>/dev/null`"
3649         cf_pkgconfig_libs="`$PKG_CONFIG --libs   $1 2>/dev/null`"
3650         CF_VERBOSE(package $1 CFLAGS: $cf_pkgconfig_incs)
3651         CF_VERBOSE(package $1 LIBS: $cf_pkgconfig_libs)
3652         CF_ADD_CFLAGS($cf_pkgconfig_incs)
3653         CF_ADD_LIBS($cf_pkgconfig_libs)
3654         ifelse([$2],,:,[$2])
3655 else
3656         cf_pkgconfig_incs=
3657         cf_pkgconfig_libs=
3658         ifelse([$3],,:,[$3])
3659 fi
3660 ])
3661 dnl ---------------------------------------------------------------------------
3662 dnl CF_TRY_XOPEN_SOURCE version: 2 updated: 2018/06/20 20:23:13
3663 dnl -------------------
3664 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
3665 dnl can define it successfully.
3666 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
3667 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
3668         AC_TRY_COMPILE([
3669 #include <stdlib.h>
3670 #include <string.h>
3671 #include <sys/types.h>
3672 ],[
3673 #ifndef _XOPEN_SOURCE
3674 make an error
3675 #endif],
3676         [cf_cv_xopen_source=no],
3677         [cf_save="$CPPFLAGS"
3678          CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE)
3679          AC_TRY_COMPILE([
3680 #include <stdlib.h>
3681 #include <string.h>
3682 #include <sys/types.h>
3683 ],[
3684 #ifdef _XOPEN_SOURCE
3685 make an error
3686 #endif],
3687         [cf_cv_xopen_source=no],
3688         [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
3689         CPPFLAGS="$cf_save"
3690         ])
3691 ])
3692
3693 if test "$cf_cv_xopen_source" != no ; then
3694         CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
3695         CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
3696         cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
3697         CF_ADD_CFLAGS($cf_temp_xopen_source)
3698 fi
3699 ])
3700 dnl ---------------------------------------------------------------------------
3701 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
3702 dnl --------
3703 dnl Make an uppercase version of a variable
3704 dnl $1=uppercase($2)
3705 AC_DEFUN([CF_UPPER],
3706 [
3707 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3708 ])dnl
3709 dnl ---------------------------------------------------------------------------
3710 dnl CF_UTF8_LIB version: 8 updated: 2012/10/06 08:57:51
3711 dnl -----------
3712 dnl Check for multibyte support, and if not found, utf8 compatibility library
3713 AC_DEFUN([CF_UTF8_LIB],
3714 [
3715 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
3716         cf_save_LIBS="$LIBS"
3717         AC_TRY_LINK([
3718 #include <stdlib.h>],[putwc(0,0);],
3719         [cf_cv_utf8_lib=yes],
3720         [CF_FIND_LINKAGE([
3721 #include <libutf8.h>],[putwc(0,0);],utf8,
3722                 [cf_cv_utf8_lib=add-on],
3723                 [cf_cv_utf8_lib=no])
3724 ])])
3725
3726 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
3727 # ncurses/ncursesw:
3728 if test "$cf_cv_utf8_lib" = "add-on" ; then
3729         AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
3730         CF_ADD_INCDIR($cf_cv_header_path_utf8)
3731         CF_ADD_LIBDIR($cf_cv_library_path_utf8)
3732         CF_ADD_LIBS($cf_cv_library_file_utf8)
3733 fi
3734 ])dnl
3735 dnl ---------------------------------------------------------------------------
3736 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
3737 dnl ----------
3738 dnl Use AC_VERBOSE w/o the warnings
3739 AC_DEFUN([CF_VERBOSE],
3740 [test -n "$verbose" && echo "   $1" 1>&AC_FD_MSG
3741 CF_MSG_LOG([$1])
3742 ])dnl
3743 dnl ---------------------------------------------------------------------------
3744 dnl CF_WCHAR_TYPE version: 4 updated: 2012/10/06 16:39:58
3745 dnl -------------
3746 dnl Check if type wide-character type $1 is declared, and if so, which header
3747 dnl file is needed.  The second parameter is used to set a shell variable when
3748 dnl the type is not found.  The first parameter sets a shell variable for the
3749 dnl opposite sense.
3750 AC_DEFUN([CF_WCHAR_TYPE],
3751 [
3752 # This is needed on Tru64 5.0 to declare $1
3753 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
3754 AC_TRY_COMPILE([
3755 #include <stdlib.h>
3756 #include <stdarg.h>
3757 #include <stdio.h>
3758 #ifdef HAVE_LIBUTF8_H
3759 #include <libutf8.h>
3760 #endif],
3761         [$1 state],
3762         [cf_cv_$1=no],
3763         [AC_TRY_COMPILE([
3764 #include <stdlib.h>
3765 #include <stdarg.h>
3766 #include <stdio.h>
3767 #include <wchar.h>
3768 #ifdef HAVE_LIBUTF8_H
3769 #include <libutf8.h>
3770 #endif],
3771         [$1 value],
3772         [cf_cv_$1=yes],
3773         [cf_cv_$1=unknown])])])
3774
3775 if test "$cf_cv_$1" = yes ; then
3776         AC_DEFINE(NEED_WCHAR_H,1,[Define to 1 if we must include wchar.h])
3777         NEED_WCHAR_H=1
3778 fi
3779
3780 ifelse([$2],,,[
3781 # if we do not find $1 in either place, use substitution to provide a fallback.
3782 if test "$cf_cv_$1" = unknown ; then
3783         $2=1
3784 fi
3785 ])
3786 ifelse($3,,,[
3787 # if we find $1 in either place, use substitution to provide a fallback.
3788 if test "$cf_cv_$1" != unknown ; then
3789         $3=1
3790 fi
3791 ])
3792 ])dnl
3793 dnl ---------------------------------------------------------------------------
3794 dnl CF_WITH_CURSES_DIR version: 3 updated: 2010/11/20 17:02:38
3795 dnl ------------------
3796 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
3797 dnl libraries.
3798 AC_DEFUN([CF_WITH_CURSES_DIR],[
3799
3800 AC_MSG_CHECKING(for specific curses-directory)
3801 AC_ARG_WITH(curses-dir,
3802         [  --with-curses-dir=DIR   directory in which (n)curses is installed],
3803         [cf_cv_curses_dir=$withval],
3804         [cf_cv_curses_dir=no])
3805 AC_MSG_RESULT($cf_cv_curses_dir)
3806
3807 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
3808 then
3809         CF_PATH_SYNTAX(withval)
3810         if test -d "$cf_cv_curses_dir"
3811         then
3812                 CF_ADD_INCDIR($cf_cv_curses_dir/include)
3813                 CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
3814         fi
3815 fi
3816 ])dnl
3817 dnl ---------------------------------------------------------------------------
3818 dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
3819 dnl ----------------
3820 dnl Configure-option for dbmalloc.  The optional parameter is used to override
3821 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
3822 AC_DEFUN([CF_WITH_DBMALLOC],[
3823 CF_NO_LEAKS_OPTION(dbmalloc,
3824         [  --with-dbmalloc         test: use Conor Cahill's dbmalloc library],
3825         [USE_DBMALLOC])
3826
3827 if test "$with_dbmalloc" = yes ; then
3828         AC_CHECK_HEADER(dbmalloc.h,
3829                 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
3830 fi
3831 ])dnl
3832 dnl ---------------------------------------------------------------------------
3833 dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
3834 dnl ---------------
3835 dnl Configure-option for dmalloc.  The optional parameter is used to override
3836 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
3837 AC_DEFUN([CF_WITH_DMALLOC],[
3838 CF_NO_LEAKS_OPTION(dmalloc,
3839         [  --with-dmalloc          test: use Gray Watson's dmalloc library],
3840         [USE_DMALLOC])
3841
3842 if test "$with_dmalloc" = yes ; then
3843         AC_CHECK_HEADER(dmalloc.h,
3844                 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
3845 fi
3846 ])dnl
3847 dnl ---------------------------------------------------------------------------
3848 dnl CF_WITH_LIB_BASENAME version: 1 updated: 2020/03/07 20:05:14
3849 dnl --------------------
3850 dnl Allow for overriding the basename of a library, i.e., the part to which
3851 dnl prefixes/suffixes are attached.
3852 dnl
3853 dnl $1 = variable to set
3854 dnl $2 = option name
3855 dnl $3 = default basename for library, if omitted use $2
3856 AC_DEFUN([CF_WITH_LIB_BASENAME],
3857 [
3858 AC_MSG_CHECKING(for desired basename for $2 library)
3859 AC_ARG_WITH($2-libname,
3860         [  --with-$2-libname=XXX override ifelse($3,,$2,$3) basename of library],
3861         [with_lib_basename=$withval],
3862         [with_lib_basename=ifelse($3,,$2,$3)])
3863 $1="$with_lib_basename"
3864
3865 case "x[$]$1" in
3866 (x|xno|xnone|xyes)
3867         $1=ifelse($3,,$2,$3)
3868         ;;
3869 (*)
3870         ;;
3871 esac
3872
3873 AC_MSG_RESULT([$]$1)
3874 AC_SUBST($1)
3875 ])dnl
3876 dnl ---------------------------------------------------------------------------
3877 dnl CF_WITH_NCURSES_ETC version: 5 updated: 2016/02/20 19:23:20
3878 dnl -------------------
3879 dnl Use this macro for programs which use any variant of "curses", e.g.,
3880 dnl "ncurses", and "PDCurses".  Programs that can use curses and some unrelated
3881 dnl library (such as slang) should use a "--with-screen=XXX" option.
3882 dnl
3883 dnl This does not use AC_DEFUN, because that would tell autoconf to run each
3884 dnl of the macros inside this one - before this macro.
3885 define([CF_WITH_NCURSES_ETC],[
3886 CF_WITH_CURSES_DIR
3887
3888 cf_cv_screen=curses
3889
3890 AC_MSG_CHECKING(for specified curses library type)
3891 AC_ARG_WITH(screen,
3892         [  --with-screen=XXX       use specified curses-libraries],
3893         [cf_cv_screen=$withval],[
3894
3895 AC_ARG_WITH(ncursesw,
3896         [  --with-ncursesw         use wide ncurses-libraries],
3897         [cf_cv_screen=ncursesw],[
3898
3899 AC_ARG_WITH(ncurses,
3900         [  --with-ncurses          use ncurses-libraries],
3901         [cf_cv_screen=ncurses],[
3902
3903 AC_ARG_WITH(pdcurses,
3904         [  --with-pdcurses         compile/link with pdcurses X11 library],
3905         [cf_cv_screen=pdcurses],[
3906
3907 AC_ARG_WITH(curses-colr,
3908         [  --with-curses-colr      compile/link with HPUX 10.x color-curses],
3909         [cf_cv_screen=curses_colr],[
3910
3911 AC_ARG_WITH(curses-5lib,
3912         [  --with-curses-5lib      compile/link with SunOS 5lib curses],
3913         [cf_cv_screen=curses_5lib])])])])])])
3914
3915 AC_MSG_RESULT($cf_cv_screen)
3916
3917 case $cf_cv_screen in
3918 (curses|curses_*)
3919         CF_CURSES_CONFIG
3920         ;;
3921 (ncursesw*)
3922         CF_UTF8_LIB
3923         CF_NCURSES_CONFIG($cf_cv_screen)
3924         ;;
3925 (ncurses*)
3926         CF_NCURSES_CONFIG($cf_cv_screen)
3927         ;;
3928 (pdcurses)
3929         CF_PDCURSES_X11
3930         ;;
3931 (*)
3932         AC_MSG_ERROR(unexpected screen-value: $cf_cv_screen)
3933         ;;
3934 esac
3935
3936 CF_NCURSES_PTHREADS($cf_cv_screen)
3937
3938 ])dnl
3939 dnl ---------------------------------------------------------------------------
3940 dnl CF_WITH_SCREEN_PDCURSES version: 1 updated: 2020/08/28 16:56:27
3941 dnl -----------------------
3942 dnl Call this macro before CF_ENABLE_WARNINGS for configure scripts which use
3943 dnl the "--with-screen=pdcurses" selection.  Doing that allows the configure
3944 dnl script to search for the X11/Xt header files to declare (or not) the
3945 dnl symbol needed to enable "const" in those header files.  If that configure
3946 dnl option is not used, then those checks are unnecessary.
3947 AC_DEFUN([CF_WITH_SCREEN_PDCURSES],[
3948 AC_PROVIDE([AC_PATH_XTRA])
3949 AC_PROVIDE([AC_PATH_X])
3950 if test -n "$with_screen" && test "x$with_screen" = "xpdcurses"
3951 then
3952         AC_PATH_X
3953         AC_PATH_XTRA
3954 fi
3955 ])dnl
3956 dnl ---------------------------------------------------------------------------
3957 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
3958 dnl ----------------
3959 AC_DEFUN([CF_WITH_VALGRIND],[
3960 CF_NO_LEAKS_OPTION(valgrind,
3961         [  --with-valgrind         test: use valgrind],
3962         [USE_VALGRIND])
3963 ])dnl
3964 dnl ---------------------------------------------------------------------------
3965 dnl CF_WITH_X11_RGB version: 2 updated: 2019/12/31 08:53:54
3966 dnl ---------------
3967 dnl Handle configure option "--with-x11-rgb", setting these shell
3968 dnl variables:
3969 dnl
3970 dnl $RGB_PATH is the option value, used for finding the X11 rgb file.
3971 dnl $no_x11_rgb is a "#" (comment) if "--without-x11-rgb" is given.
3972 dnl
3973 dnl Most Linux's use this:
3974 dnl     /usr/share/X11/rgb.txt
3975 dnl Debian uses this:
3976 dnl     /etc/X11/rgb.txt
3977 dnl DragonFlyBSD ports uses this:
3978 dnl     /usr/pkg/lib/X11/rgb.txt
3979 dnl FreeBSD ports use these:
3980 dnl     /usr/local/lib/X11/rgb.txt
3981 dnl     /usr/local/share/X11/rgb.txt
3982 dnl Mandriva has these:
3983 dnl     /usr/lib/X11/rgb.txt
3984 dnl     /usr/lib64/X11/rgb.txt
3985 dnl NetBSD has these
3986 dnl     /usr/X11R7/lib/X11/rgb.txt
3987 dnl OpenSolaris uses
3988 dnl     32-bit:
3989 dnl     /usr/X11/etc/X11/rgb.txt
3990 dnl     /usr/X11/share/X11/rgb.txt
3991 dnl     /usr/X11/lib/X11/rgb.txt
3992 dnl OSX uses
3993 dnl             /opt/local/share/X11/rgb.txt (MacPorts)
3994 dnl             /opt/X11/share/X11/rgb.txt (non-ports)
3995 dnl     64-bit:
3996 dnl     /usr/X11/etc/X11/rgb.txt
3997 dnl     /usr/X11/share/X11/rgb.txt (perhaps)
3998 dnl     /usr/X11/lib/amd64/X11/rgb.txt
3999 dnl Solaris10 uses (in this order):
4000 dnl     /usr/openwin/lib/X11/rgb.txt
4001 dnl     /usr/X11/lib/X11/rgb.txt
4002 AC_DEFUN([CF_WITH_X11_RGB],[
4003 AC_MSG_CHECKING(for X11 rgb file)
4004 AC_ARG_WITH(x11-rgb,
4005         [  --with-x11-rgb=FILE   file containing X11 rgb information (EPREFIX/lib/X11/rgb.txt)],
4006         [RGB_PATH=$withval],
4007         [RGB_PATH=auto])
4008
4009 if test "x[$]RGB_PATH" = xauto
4010 then
4011         RGB_PATH='${exec_prefix}/lib/X11/rgb.txt'
4012         for cf_path in \
4013                 /opt/local/share/X11/rgb.txt \
4014                 /opt/X11/share/X11/rgb.txt \
4015                 /usr/share/X11/rgb.txt \
4016                 /usr/X11/share/X11/rgb.txt \
4017                 /usr/X11/lib/X11/rgb.txt \
4018                 /usr/lib/X11/rgb.txt \
4019                 /etc/X11/rgb.txt \
4020                 /usr/pkg/lib/X11/rgb.txt \
4021                 /usr/X11R7/lib/X11/rgb.txt \
4022                 /usr/X11R6/lib/X11/rgb.txt \
4023                 /usr/X11R5/lib/X11/rgb.txt \
4024                 /usr/X11R4/lib/X11/rgb.txt \
4025                 /usr/local/lib/X11/rgb.txt \
4026                 /usr/local/share/X11/rgb.txt \
4027                 /usr/lib64/X11/rgb.txt
4028         do
4029                 if test -f "$cf_path" ; then
4030                         RGB_PATH="$cf_path"
4031                         break
4032                 fi
4033         done
4034 else
4035         cf_path=$RGB_PATH
4036         CF_PATH_SYNTAX(cf_path)
4037 fi
4038
4039 AC_MSG_RESULT($RGB_PATH)
4040 AC_SUBST(RGB_PATH)
4041 AC_DEFINE_UNQUOTED(RGB_PATH,"$cf_path",[Define to the full pathname of rgb.txt])
4042
4043 no_x11_rgb=
4044 if test "$RGB_PATH" = no
4045 then
4046         no_x11_rgb="#"
4047 fi
4048 AC_SUBST(no_x11_rgb)
4049 ])dnl
4050 dnl ---------------------------------------------------------------------------
4051 dnl CF_XOPEN_CURSES version: 15 updated: 2020/03/19 20:23:48
4052 dnl ---------------
4053 dnl Test if we should define X/Open source for curses, needed on Digital Unix
4054 dnl 4.x, to see the extended functions, but breaks on IRIX 6.x.
4055 dnl
4056 dnl The getbegyx() check is needed for HPUX, which omits legacy macros such
4057 dnl as getbegy().  The latter is better design, but the former is standard.
4058 AC_DEFUN([CF_XOPEN_CURSES],
4059 [
4060 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
4061 AC_CACHE_CHECK(definition to turn on extended curses functions,cf_cv_need_xopen_extension,[
4062 cf_cv_need_xopen_extension=unknown
4063 AC_TRY_LINK([
4064 #include <stdlib.h>
4065 #include <${cf_cv_ncurses_header:-curses.h}>],[
4066 #if defined(NCURSES_VERSION_PATCH)
4067 #if (NCURSES_VERSION_PATCH < 20100501) && (NCURSES_VERSION_PATCH >= 20100403)
4068         make an error
4069 #endif
4070 #endif
4071 #ifdef NCURSES_VERSION
4072         cchar_t check;
4073         int check2 = curs_set((int)sizeof(check));
4074 #endif
4075         long x = winnstr(stdscr, "", 0);
4076         int x1, y1;
4077 #ifdef NCURSES_VERSION
4078         (void)check2;
4079 #endif
4080         getbegyx(stdscr, y1, x1);
4081         (void)x;
4082         (void)y1;
4083         (void)x1;
4084         ],
4085         [cf_cv_need_xopen_extension=none],
4086         [
4087         for cf_try_xopen_extension in _XOPEN_SOURCE_EXTENDED NCURSES_WIDECHAR
4088         do
4089                 AC_TRY_LINK([
4090 #define $cf_try_xopen_extension 1
4091 #include <stdlib.h>
4092 #include <${cf_cv_ncurses_header:-curses.h}>],[
4093 #ifdef NCURSES_VERSION
4094                 cchar_t check;
4095                 int check2 = curs_set((int)sizeof(check));
4096 #endif
4097                 long x = winnstr(stdscr, "", 0);
4098                 int x1, y1;
4099                 getbegyx(stdscr, y1, x1);
4100 #ifdef NCURSES_VERSION
4101                 (void)check2;
4102 #endif
4103                 (void)x;
4104                 (void)y1;
4105                 (void)x1;
4106                 ],
4107                 [cf_cv_need_xopen_extension=$cf_try_xopen_extension; break])
4108         done
4109         ])
4110 ])
4111
4112 case $cf_cv_need_xopen_extension in
4113 (*_*)
4114         CF_APPEND_TEXT(CPPFLAGS,-D$cf_cv_need_xopen_extension)
4115         ;;
4116 esac
4117
4118 ])dnl
4119 dnl ---------------------------------------------------------------------------
4120 dnl CF_XOPEN_SOURCE version: 55 updated: 2018/12/31 20:46:17
4121 dnl ---------------
4122 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
4123 dnl or adapt to the vendor's definitions to get equivalent functionality,
4124 dnl without losing the common non-POSIX features.
4125 dnl
4126 dnl Parameters:
4127 dnl     $1 is the nominal value for _XOPEN_SOURCE
4128 dnl     $2 is the nominal value for _POSIX_C_SOURCE
4129 AC_DEFUN([CF_XOPEN_SOURCE],[
4130 AC_REQUIRE([AC_CANONICAL_HOST])
4131 AC_REQUIRE([CF_POSIX_VISIBLE])
4132
4133 if test "$cf_cv_posix_visible" = no; then
4134
4135 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
4136 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
4137 cf_xopen_source=
4138
4139 case $host_os in
4140 (aix[[4-7]]*)
4141         cf_xopen_source="-D_ALL_SOURCE"
4142         ;;
4143 (msys)
4144         cf_XOPEN_SOURCE=600
4145         ;;
4146 (darwin[[0-8]].*)
4147         cf_xopen_source="-D_APPLE_C_SOURCE"
4148         ;;
4149 (darwin*)
4150         cf_xopen_source="-D_DARWIN_C_SOURCE"
4151         cf_XOPEN_SOURCE=
4152         ;;
4153 (freebsd*|dragonfly*|midnightbsd*)
4154         # 5.x headers associate
4155         #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
4156         #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
4157         cf_POSIX_C_SOURCE=200112L
4158         cf_XOPEN_SOURCE=600
4159         cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
4160         ;;
4161 (hpux11*)
4162         cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
4163         ;;
4164 (hpux*)
4165         cf_xopen_source="-D_HPUX_SOURCE"
4166         ;;
4167 (irix[[56]].*)
4168         cf_xopen_source="-D_SGI_SOURCE"
4169         cf_XOPEN_SOURCE=
4170         ;;
4171 (linux*|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin)
4172         CF_GNU_SOURCE($cf_XOPEN_SOURCE)
4173         ;;
4174 (minix*)
4175         cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
4176         ;;
4177 (mirbsd*)
4178         # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
4179         cf_XOPEN_SOURCE=
4180         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4181         ;;
4182 (netbsd*)
4183         cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
4184         ;;
4185 (openbsd[[4-9]]*)
4186         # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
4187         cf_xopen_source="-D_BSD_SOURCE"
4188         cf_XOPEN_SOURCE=600
4189         ;;
4190 (openbsd*)
4191         # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
4192         ;;
4193 (osf[[45]]*)
4194         cf_xopen_source="-D_OSF_SOURCE"
4195         ;;
4196 (nto-qnx*)
4197         cf_xopen_source="-D_QNX_SOURCE"
4198         ;;
4199 (sco*)
4200         # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
4201         ;;
4202 (solaris2.*)
4203         cf_xopen_source="-D__EXTENSIONS__"
4204         cf_cv_xopen_source=broken
4205         ;;
4206 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
4207         cf_XOPEN_SOURCE=
4208         cf_POSIX_C_SOURCE=
4209         ;;
4210 (*)
4211         CF_TRY_XOPEN_SOURCE
4212         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4213         ;;
4214 esac
4215
4216 if test -n "$cf_xopen_source" ; then
4217         CF_ADD_CFLAGS($cf_xopen_source,true)
4218 fi
4219
4220 dnl In anything but the default case, we may have system-specific setting
4221 dnl which is still not guaranteed to provide all of the entrypoints that
4222 dnl _XOPEN_SOURCE would yield.
4223 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
4224         AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
4225         AC_TRY_COMPILE([#include <stdlib.h>],[
4226 #ifndef _XOPEN_SOURCE
4227 make an error
4228 #endif],
4229         [cf_XOPEN_SOURCE_set=yes],
4230         [cf_XOPEN_SOURCE_set=no])
4231         AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
4232         if test $cf_XOPEN_SOURCE_set = yes
4233         then
4234                 AC_TRY_COMPILE([#include <stdlib.h>],[
4235 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
4236 make an error
4237 #endif],
4238                 [cf_XOPEN_SOURCE_set_ok=yes],
4239                 [cf_XOPEN_SOURCE_set_ok=no])
4240                 if test $cf_XOPEN_SOURCE_set_ok = no
4241                 then
4242                         AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
4243                 fi
4244         else
4245                 CF_TRY_XOPEN_SOURCE
4246         fi
4247 fi
4248 fi # cf_cv_posix_visible
4249 ])
4250 dnl ---------------------------------------------------------------------------
4251 dnl CF_X_ATHENA version: 24 updated: 2020/03/10 18:53:47
4252 dnl -----------
4253 dnl Check for Xaw (Athena) libraries
4254 dnl
4255 dnl Sets $cf_x_athena according to the flavor of Xaw which is used.
4256 AC_DEFUN([CF_X_ATHENA],
4257 [
4258 cf_x_athena=${cf_x_athena:-Xaw}
4259
4260 AC_MSG_CHECKING(if you want to link with Xaw 3d library)
4261 withval=
4262 AC_ARG_WITH(Xaw3d,
4263         [  --with-Xaw3d            link with Xaw 3d library])
4264 if test "$withval" = yes ; then
4265         cf_x_athena=Xaw3d
4266         AC_MSG_RESULT(yes)
4267 else
4268         AC_MSG_RESULT(no)
4269 fi
4270
4271 AC_MSG_CHECKING(if you want to link with Xaw 3d xft library)
4272 withval=
4273 AC_ARG_WITH(Xaw3dxft,
4274         [  --with-Xaw3dxft         link with Xaw 3d xft library])
4275 if test "$withval" = yes ; then
4276         cf_x_athena=Xaw3dxft
4277         AC_MSG_RESULT(yes)
4278 else
4279         AC_MSG_RESULT(no)
4280 fi
4281
4282 AC_MSG_CHECKING(if you want to link with neXT Athena library)
4283 withval=
4284 AC_ARG_WITH(neXtaw,
4285         [  --with-neXtaw           link with neXT Athena library])
4286 if test "$withval" = yes ; then
4287         cf_x_athena=neXtaw
4288         AC_MSG_RESULT(yes)
4289 else
4290         AC_MSG_RESULT(no)
4291 fi
4292
4293 AC_MSG_CHECKING(if you want to link with Athena-Plus library)
4294 withval=
4295 AC_ARG_WITH(XawPlus,
4296         [  --with-XawPlus          link with Athena-Plus library])
4297 if test "$withval" = yes ; then
4298         cf_x_athena=XawPlus
4299         AC_MSG_RESULT(yes)
4300 else
4301         AC_MSG_RESULT(no)
4302 fi
4303
4304 cf_x_athena_lib=""
4305
4306 if test "$PKG_CONFIG" != none ; then
4307         cf_athena_list=
4308         test "$cf_x_athena" = Xaw && cf_athena_list="xaw8 xaw7 xaw6"
4309         for cf_athena_pkg in \
4310                 $cf_athena_list \
4311                 ${cf_x_athena} \
4312                 ${cf_x_athena}-devel \
4313                 lib${cf_x_athena} \
4314                 lib${cf_x_athena}-devel
4315         do
4316                 CF_TRY_PKG_CONFIG($cf_athena_pkg,[
4317                         cf_x_athena_lib="$cf_pkgconfig_libs"
4318                         CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
4319                         AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
4320
4321                         CF_TRIM_X_LIBS
4322
4323 AC_CACHE_CHECK(for usable $cf_x_athena/Xmu package,cf_cv_xaw_compat,[
4324 AC_TRY_LINK([
4325 #include <X11/Xmu/CharSet.h>
4326 ],[
4327 int check = XmuCompareISOLatin1("big", "small");
4328 (void)check;
4329 ],[cf_cv_xaw_compat=yes],[cf_cv_xaw_compat=no])])
4330
4331                         if test "$cf_cv_xaw_compat" = no
4332                         then
4333                                 # workaround for broken ".pc" files...
4334                                 case "$cf_x_athena_lib" in
4335                                 (*-lXmu*)
4336                                         ;;
4337                                 (*)
4338                                         CF_VERBOSE(work around broken package)
4339                                         cf_save_xmu="$LIBS"
4340                                         cf_first_lib=`echo "$cf_save_xmu" | sed -e 's/^[ ][ ]*//' -e 's/ .*//'`
4341                                         CF_TRY_PKG_CONFIG(xmu,[
4342                                                         LIBS="$cf_save_xmu"
4343                                                         CF_ADD_LIB_AFTER($cf_first_lib,$cf_pkgconfig_libs)
4344                                                 ],[
4345                                                         CF_ADD_LIB_AFTER($cf_first_lib,-lXmu)
4346                                                 ])
4347                                         CF_TRIM_X_LIBS
4348                                         ;;
4349                                 esac
4350                         fi
4351
4352                         break])
4353         done
4354 fi
4355
4356 if test -z "$cf_x_athena_lib" ; then
4357         CF_X_EXT
4358         CF_X_TOOLKIT
4359         CF_X_ATHENA_CPPFLAGS($cf_x_athena)
4360         CF_X_ATHENA_LIBS($cf_x_athena)
4361 fi
4362 ])dnl
4363 dnl ---------------------------------------------------------------------------
4364 dnl CF_X_ATHENA_CPPFLAGS version: 8 updated: 2020/01/16 05:21:56
4365 dnl --------------------
4366 dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
4367 dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
4368 AC_DEFUN([CF_X_ATHENA_CPPFLAGS],
4369 [
4370 AC_REQUIRE([AC_PATH_XTRA])
4371 cf_x_athena_root=ifelse([$1],,Xaw,[$1])
4372 cf_x_athena_inc=""
4373
4374 for cf_path in default \
4375         /usr/contrib/X11R6 \
4376         /usr/contrib/X11R5 \
4377         /usr/lib/X11R5 \
4378         /usr/local
4379 do
4380         if test -z "$cf_x_athena_inc" ; then
4381                 CF_SAVE_XTRA_FLAGS([CF_X_ATHENA_CPPFLAGS])
4382                 cf_test=X11/$cf_x_athena_root/SimpleMenu.h
4383                 if test $cf_path != default ; then
4384                         CF_APPEND_TEXT(CPPFLAGS,-I$cf_path/include)
4385                         AC_MSG_CHECKING(for $cf_test in $cf_path)
4386                 else
4387                         AC_MSG_CHECKING(for $cf_test)
4388                 fi
4389                 AC_TRY_COMPILE([
4390 #include <X11/Intrinsic.h>
4391 #include <$cf_test>],[],
4392                         [cf_result=yes],
4393                         [cf_result=no])
4394                 AC_MSG_RESULT($cf_result)
4395                 CF_RESTORE_XTRA_FLAGS([CF_X_ATHENA_CPPFLAGS])
4396                 if test "$cf_result" = yes ; then
4397                         test "$cf_path"  = default && cf_x_athena_inc=default
4398                         test "$cf_path" != default && cf_x_athena_inc=$cf_path/include
4399                         break
4400                 fi
4401         fi
4402 done
4403
4404 if test -z "$cf_x_athena_inc" ; then
4405         AC_MSG_WARN([Unable to find Athena header files])
4406 elif test "$cf_x_athena_inc" != default ; then
4407         CF_APPEND_TEXT(CPPFLAGS,-I$cf_x_athena_inc)
4408 fi
4409 ])
4410 dnl ---------------------------------------------------------------------------
4411 dnl CF_X_ATHENA_LIBS version: 13 updated: 2020/01/11 18:16:10
4412 dnl ----------------
4413 dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
4414 dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
4415 AC_DEFUN([CF_X_ATHENA_LIBS],
4416 [AC_REQUIRE([CF_X_TOOLKIT])
4417 cf_x_athena_root=ifelse([$1],,Xaw,[$1])
4418 cf_x_athena_lib=""
4419
4420 for cf_path in default \
4421         /usr/contrib/X11R6 \
4422         /usr/contrib/X11R5 \
4423         /usr/lib/X11R5 \
4424         /usr/local
4425 do
4426         for cf_lib in \
4427                 ${cf_x_athena_root} \
4428                 ${cf_x_athena_root}7 \
4429                 ${cf_x_athena_root}6
4430         do
4431         for cf_libs in \
4432                 "-l$cf_lib -lXmu" \
4433                 "-l$cf_lib -lXpm -lXmu" \
4434                 "-l${cf_lib}_s -lXmu_s"
4435         do
4436                 test -n "$cf_x_athena_lib" && break
4437
4438                 CF_SAVE_XTRA_FLAGS([CF_X_ATHENA_LIBS])
4439                 cf_test=XawSimpleMenuAddGlobalActions
4440                 test "$cf_path" != default && cf_libs="-L$cf_path/lib $cf_libs"
4441                 CF_ADD_LIBS($cf_libs)
4442                 AC_MSG_CHECKING(for $cf_test in $cf_libs)
4443                 AC_TRY_LINK([
4444 #include <X11/Intrinsic.h>
4445 #include <X11/$cf_x_athena_root/SimpleMenu.h>
4446 ],[
4447 $cf_test((XtAppContext) 0)],
4448                         [cf_result=yes],
4449                         [cf_result=no])
4450                 AC_MSG_RESULT($cf_result)
4451                 CF_RESTORE_XTRA_FLAGS([CF_X_ATHENA_LIBS])
4452
4453                 if test "$cf_result" = yes ; then
4454                         cf_x_athena_lib="$cf_libs"
4455                         break
4456                 fi
4457         done # cf_libs
4458                 test -n "$cf_x_athena_lib" && break
4459         done # cf_lib
4460 done
4461
4462 if test -z "$cf_x_athena_lib" ; then
4463         AC_MSG_ERROR(
4464 [Unable to successfully link Athena library (-l$cf_x_athena_root) with test program])
4465 fi
4466
4467 CF_ADD_LIBS($cf_x_athena_lib)
4468 CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
4469 AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
4470 ])
4471 dnl ---------------------------------------------------------------------------
4472 dnl CF_X_EXT version: 3 updated: 2010/06/02 05:03:05
4473 dnl --------
4474 AC_DEFUN([CF_X_EXT],[
4475 CF_TRY_PKG_CONFIG(Xext,,[
4476         AC_CHECK_LIB(Xext,XextCreateExtension,
4477                 [CF_ADD_LIB(Xext)])])
4478 ])dnl
4479 dnl ---------------------------------------------------------------------------
4480 dnl CF_X_TOOLKIT version: 25 updated: 2020/03/10 17:26:15
4481 dnl ------------
4482 dnl Check for X Toolkit libraries
4483 AC_DEFUN([CF_X_TOOLKIT],
4484 [
4485 AC_REQUIRE([AC_PATH_XTRA])
4486 AC_REQUIRE([CF_CHECK_CACHE])
4487
4488 # OSX is schizoid about who owns /usr/X11 (old) versus /opt/X11 (new) (and
4489 # in some cases has installed dummy files in the former, other cases replaced
4490 # it with a link to the new location).  This complicates the configure script.
4491 # Check for that pitfall, and recover using pkg-config
4492 #
4493 # If none of these are set, the configuration is almost certainly broken.
4494 if test -z "${X_CFLAGS}${X_PRE_LIBS}${X_LIBS}${X_EXTRA_LIBS}"
4495 then
4496         CF_TRY_PKG_CONFIG(x11,,[AC_MSG_WARN(unable to find X11 library)])
4497         CF_TRY_PKG_CONFIG(ice,,[AC_MSG_WARN(unable to find ICE library)])
4498         CF_TRY_PKG_CONFIG(sm,,[AC_MSG_WARN(unable to find SM library)])
4499         CF_TRY_PKG_CONFIG(xt,,[AC_MSG_WARN(unable to find Xt library)])
4500 else
4501         LIBS="$X_PRE_LIBS $LIBS $X_EXTRA_LIBS"
4502 fi
4503
4504 cf_have_X_LIBS=no
4505
4506 CF_TRY_PKG_CONFIG(xt,[
4507
4508         case "x$LIBS" in
4509         (*-lX11*)
4510                 ;;
4511         (*)
4512 # we have an "xt" package, but it may omit Xt's dependency on X11
4513 AC_CACHE_CHECK(for usable X dependency,cf_cv_xt_x11_compat,[
4514 AC_TRY_LINK([
4515 #include <X11/Xlib.h>
4516 ],[
4517         int rc1 = XDrawLine((Display*) 0, (Drawable) 0, (GC) 0, 0, 0, 0, 0);
4518         int rc2 = XClearWindow((Display*) 0, (Window) 0);
4519         int rc3 = XMoveWindow((Display*) 0, (Window) 0, 0, 0);
4520         int rc4 = XMoveResizeWindow((Display*)0, (Window)0, 0, 0, 0, 0);
4521 ],[cf_cv_xt_x11_compat=yes],[cf_cv_xt_x11_compat=no])])
4522                 if test "$cf_cv_xt_x11_compat" = no
4523                 then
4524                         CF_VERBOSE(work around broken X11 dependency)
4525                         # 2010/11/19 - good enough until a working Xt on Xcb is delivered.
4526                         CF_TRY_PKG_CONFIG(x11,,[CF_ADD_LIB_AFTER(-lXt,-lX11)])
4527                 fi
4528                 ;;
4529         esac
4530
4531 AC_CACHE_CHECK(for usable X Toolkit package,cf_cv_xt_ice_compat,[
4532 AC_TRY_LINK([
4533 #include <X11/Shell.h>
4534 ],[int num = IceConnectionNumber(0); (void) num
4535 ],[cf_cv_xt_ice_compat=yes],[cf_cv_xt_ice_compat=no])])
4536
4537         if test "$cf_cv_xt_ice_compat" = no
4538         then
4539                 # workaround for broken ".pc" files used for X Toolkit.
4540                 case "x$X_PRE_LIBS" in
4541                 (*-lICE*)
4542                         case "x$LIBS" in
4543                         (*-lICE*)
4544                                 ;;
4545                         (*)
4546                                 CF_VERBOSE(work around broken ICE dependency)
4547                                 CF_TRY_PKG_CONFIG(ice,
4548                                         [CF_TRY_PKG_CONFIG(sm)],
4549                                         [CF_ADD_LIB_AFTER(-lXt,$X_PRE_LIBS)])
4550                                 ;;
4551                         esac
4552                         ;;
4553                 esac
4554         fi
4555
4556         cf_have_X_LIBS=yes
4557 ],[
4558
4559         LDFLAGS="$X_LIBS $LDFLAGS"
4560         CF_CHECK_CFLAGS($X_CFLAGS)
4561
4562         AC_CHECK_FUNC(XOpenDisplay,,[
4563         AC_CHECK_LIB(X11,XOpenDisplay,
4564                 [CF_ADD_LIB(X11)])])
4565
4566         AC_CHECK_FUNC(XtAppInitialize,,[
4567         AC_CHECK_LIB(Xt, XtAppInitialize,
4568                 [AC_DEFINE(HAVE_LIBXT,1,[Define to 1 if we can compile with the Xt library])
4569                  cf_have_X_LIBS=Xt
4570                  LIBS="-lXt $LIBS"])])
4571 ])
4572
4573 if test $cf_have_X_LIBS = no ; then
4574         AC_MSG_WARN(
4575 [Unable to successfully link X Toolkit library (-lXt) with
4576 test program.  You will have to check and add the proper libraries by hand
4577 to makefile.])
4578 fi
4579 ])dnl
4580 dnl ---------------------------------------------------------------------------
4581 dnl CF__CURSES_DATA version: 2 updated: 2020/02/08 21:00:26
4582 dnl ---------------
4583 dnl Attempt to make a copy of a curses data item.  This is needed in the
4584 dnl check-data configure tests when using ncurses, because the symbol may be
4585 dnl actually a function return-value.  That could happen if the linker is
4586 dnl broken (does not resolve data-only references), or if ncurses is configured
4587 dnl to support re-entrant code.
4588 dnl $1 = target
4589 dnl $2 = source
4590 define([CF__CURSES_DATA],[
4591 #if defined($2) && ((defined(NCURSES_WRAPPED_VAR) && (NCURSES_VERSION_PATCH < 20200208)) || defined(NCURSES_BROKEN_LINKER) || defined(NCURSES_REENTRANT))
4592         const void *$1 = (const void *)($2);
4593 #else
4594         const void *$1 = &($2);
4595 #endif
4596         fprintf(stderr, "testing linkage of $2:%p\n", (const void *)$1);
4597 ])dnl
4598 dnl ---------------------------------------------------------------------------
4599 dnl CF__CURSES_HEAD version: 2 updated: 2010/10/23 15:54:49
4600 dnl ---------------
4601 dnl Define a reusable chunk which includes <curses.h> and <term.h> when they
4602 dnl are both available.
4603 define([CF__CURSES_HEAD],[
4604 #ifdef HAVE_XCURSES
4605 #include <xcurses.h>
4606 char * XCursesProgramName = "test";
4607 #else
4608 #include <${cf_cv_ncurses_header:-curses.h}>
4609 #if defined(NCURSES_VERSION) && defined(HAVE_NCURSESW_TERM_H)
4610 #include <ncursesw/term.h>
4611 #elif defined(NCURSES_VERSION) && defined(HAVE_NCURSES_TERM_H)
4612 #include <ncurses/term.h>
4613 #elif defined(HAVE_TERM_H)
4614 #include <term.h>
4615 #endif
4616 #endif
4617 ])