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