test/aclocal.m4

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