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