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