test/aclocal.m4

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