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