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