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.176 2020/02/09 02:02:53 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: 4 updated: 2015/04/18 08:56:57
  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);],
  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: 3 updated: 2020/01/11 18:39:22
 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)],[
 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: 11 updated: 2015/04/15 19:08: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],
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],
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: 4 updated: 2015/04/15 19:08: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],
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: 6 updated: 2012/10/06 08:57:51
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'])],
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: 2 updated: 2012/10/06 08:57:51
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],
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],
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: 17 updated: 2015/04/12 15:39:00
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) { 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: 21 updated: 2018/06/20 20:23:13
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_CPPFLAGS="$CPPFLAGS"
2375                 cf_save_LIBS="$LIBS"
2376
2377                 CF_ADD_CFLAGS(`$PKG_CONFIG --cflags $cf_ncuconfig_root`)
2378                 CF_ADD_LIBS(`$PKG_CONFIG --libs $cf_ncuconfig_root`)
2379
2380                 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2381                         [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2382                         [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2383                                 int main(void)
2384                                 { char *xx = curses_version(); return (xx == 0); }],
2385                                 [cf_have_ncuconfig=yes],
2386                                 [cf_have_ncuconfig=no],
2387                                 [cf_have_ncuconfig=maybe])],
2388                         [cf_have_ncuconfig=no])
2389                 AC_MSG_RESULT($cf_have_ncuconfig)
2390                 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
2391                 if test "$cf_have_ncuconfig" != "yes"
2392                 then
2393                         CPPFLAGS="$cf_save_CPPFLAGS"
2394                         LIBS="$cf_save_LIBS"
2395                         NCURSES_CONFIG_PKG=none
2396                 else
2397                         AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2398                         NCURSES_CONFIG_PKG=$cf_ncuconfig_root
2399                         CF_TERM_HEADER
2400                 fi
2401
2402         else
2403                 AC_MSG_RESULT(no)
2404                 NCURSES_CONFIG_PKG=none
2405         fi
2406 else
2407         NCURSES_CONFIG_PKG=none
2408 fi
2409
2410 if test "x$cf_have_ncuconfig" = "xno"; then
2411         cf_ncurses_config="${cf_ncuconfig_root}${NCURSES_CONFIG_SUFFIX}-config"; echo "Looking for ${cf_ncurses_config}"
2412
2413         CF_ACVERSION_CHECK(2.52,
2414                 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
2415                 [AC_PATH_PROGS(NCURSES_CONFIG,  ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
2416
2417         if test "$NCURSES_CONFIG" != none ; then
2418
2419                 CF_ADD_CFLAGS(`$NCURSES_CONFIG --cflags`)
2420                 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
2421
2422                 # even with config script, some packages use no-override for curses.h
2423                 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
2424
2425                 dnl like CF_NCURSES_CPPFLAGS
2426                 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2427
2428                 dnl like CF_NCURSES_LIBS
2429                 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
2430                 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2431
2432                 dnl like CF_NCURSES_VERSION
2433                 cf_cv_ncurses_version=`$NCURSES_CONFIG --version`
2434
2435         else
2436
2437                 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
2438                 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
2439
2440         fi
2441 else
2442         NCURSES_CONFIG=none
2443 fi
2444 ])dnl
2445 dnl ---------------------------------------------------------------------------
2446 dnl CF_NCURSES_CPPFLAGS version: 21 updated: 2012/10/06 08:57:51
2447 dnl -------------------
2448 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
2449 dnl the CPPFLAGS variable so we can include its header.
2450 dnl
2451 dnl The header files may be installed as either curses.h, or ncurses.h (would
2452 dnl be obsolete, except that some packagers prefer this name to distinguish it
2453 dnl from a "native" curses implementation).  If not installed for overwrite,
2454 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
2455 dnl /usr/include/ncurses), but someone may have installed overwriting the
2456 dnl vendor's curses.  Only very old versions (pre-1.9.2d, the first autoconf'd
2457 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
2458 dnl the header.
2459 dnl
2460 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
2461 dnl is already in the include-path, don't even bother with this, since we cannot
2462 dnl easily determine which file it is.  In this case, it has to be <curses.h>.
2463 dnl
2464 dnl The optional parameter gives the root name of the library, in case it is
2465 dnl not installed as the default curses library.  That is how the
2466 dnl wide-character version of ncurses is installed.
2467 AC_DEFUN([CF_NCURSES_CPPFLAGS],
2468 [AC_REQUIRE([CF_WITH_CURSES_DIR])
2469
2470 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
2471 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
2472
2473 test -n "$cf_cv_curses_dir" && \
2474 test "$cf_cv_curses_dir" != "no" && { \
2475   CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
2476 }
2477
2478 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
2479         cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
2480         ( test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw ) && cf_header_list="$cf_header_list curses.h ncurses.h"
2481         for cf_header in $cf_header_list
2482         do
2483                 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
2484                 test "$cf_cv_ncurses_h" != no && break
2485         done
2486 ])
2487
2488 CF_NCURSES_HEADER
2489 CF_TERM_HEADER
2490
2491 # some applications need this, but should check for NCURSES_VERSION
2492 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2493
2494 CF_NCURSES_VERSION
2495 ])dnl
2496 dnl ---------------------------------------------------------------------------
2497 dnl CF_NCURSES_EXT_FUNCS version: 4 updated: 2012/10/06 16:39:58
2498 dnl --------------------
2499 dnl Since 2007/11/17, ncurses has defined NCURSES_EXT_FUNCS; earlier versions
2500 dnl may provide these functions.  Define the symbol if it is not defined, and
2501 dnl if it is valid.
2502 AC_DEFUN([CF_NCURSES_EXT_FUNCS],
2503 [
2504 AC_CACHE_CHECK(for ncurses extended functions,cf_cv_ncurses_ext_funcs,[
2505 AC_TRY_COMPILE([
2506 #include <${cf_cv_ncurses_header:-curses.h}>],
2507 [
2508 int x = NCURSES_EXT_FUNCS
2509 ],[cf_cv_ncurses_ext_funcs=defined],[
2510 AC_TRY_LINK([
2511 #include <${cf_cv_ncurses_header:-curses.h}>],
2512 [
2513         (void) assume_default_colors (0, 0);
2514         (void) curses_version ();
2515         (void) define_key (0, 0);
2516         (void) is_term_resized (0, 0);
2517         (void) key_defined (0);
2518         (void) keybound (0, 0);
2519         (void) keyok (0, 0);
2520         (void) resize_term (0, 0);
2521         (void) resizeterm (0, 0);
2522         (void) use_default_colors ();
2523         (void) use_extended_names (0);
2524         (void) wresize (0, 0, 0);],
2525         [cf_cv_ncurses_ext_funcs=yes],
2526         [cf_cv_ncurses_ext_funcs=no])
2527 ])
2528 ])
2529 test "$cf_cv_ncurses_ext_funcs" = yes && AC_DEFINE(NCURSES_EXT_FUNCS,1,[Define to 1 if we have ncurses extensions])
2530 ])dnl
2531 dnl ---------------------------------------------------------------------------
2532 dnl CF_NCURSES_HEADER version: 4 updated: 2015/04/15 19:08:48
2533 dnl -----------------
2534 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
2535 dnl variations of ncurses' installs.
2536 dnl
2537 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
2538 AC_DEFUN([CF_NCURSES_HEADER],[
2539
2540 if test "$cf_cv_ncurses_h" != no ; then
2541         cf_cv_ncurses_header=$cf_cv_ncurses_h
2542 else
2543
2544 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
2545         test -n "$verbose" && echo
2546         CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
2547         test -n "$verbose" && echo search path $cf_search
2548         cf_save2_CPPFLAGS="$CPPFLAGS"
2549         for cf_incdir in $cf_search
2550         do
2551                 CF_ADD_INCDIR($cf_incdir)
2552                 for cf_header in \
2553                         ncurses.h \
2554                         curses.h
2555                 do
2556                         CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
2557                         if test "$cf_cv_ncurses_h2" != no ; then
2558                                 cf_cv_ncurses_h2=$cf_incdir/$cf_header
2559                                 test -n "$verbose" && echo $ac_n "      ... found $ac_c" 1>&AC_FD_MSG
2560                                 break
2561                         fi
2562                         test -n "$verbose" && echo "    ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
2563                 done
2564                 CPPFLAGS="$cf_save2_CPPFLAGS"
2565                 test "$cf_cv_ncurses_h2" != no && break
2566         done
2567         test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
2568         ])
2569
2570         CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
2571         cf_cv_ncurses_header=`basename $cf_cv_ncurses_h2`
2572         if test `basename $cf_1st_incdir` = $cf_ncuhdr_root ; then
2573                 cf_cv_ncurses_header=$cf_ncuhdr_root/$cf_cv_ncurses_header
2574         fi
2575         CF_ADD_INCDIR($cf_1st_incdir)
2576
2577 fi
2578
2579 # Set definitions to allow ifdef'ing for ncurses.h
2580
2581 case $cf_cv_ncurses_header in
2582 (*ncurses.h)
2583         AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
2584         ;;
2585 esac
2586
2587 case $cf_cv_ncurses_header in
2588 (ncurses/curses.h|ncurses/ncurses.h)
2589         AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
2590         ;;
2591 (ncursesw/curses.h|ncursesw/ncurses.h)
2592         AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
2593         ;;
2594 esac
2595
2596 ])dnl
2597 dnl ---------------------------------------------------------------------------
2598 dnl CF_NCURSES_LIBS version: 17 updated: 2015/04/15 19:08:48
2599 dnl ---------------
2600 dnl Look for the ncurses library.  This is a little complicated on Linux,
2601 dnl because it may be linked with the gpm (general purpose mouse) library.
2602 dnl Some distributions have gpm linked with (bsd) curses, which makes it
2603 dnl unusable with ncurses.  However, we don't want to link with gpm unless
2604 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
2605 dnl and the linker will record a dependency.
2606 dnl
2607 dnl The optional parameter gives the root name of the library, in case it is
2608 dnl not installed as the default curses library.  That is how the
2609 dnl wide-character version of ncurses is installed.
2610 AC_DEFUN([CF_NCURSES_LIBS],
2611 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
2612
2613 cf_nculib_root=ifelse($1,,ncurses,$1)
2614         # This works, except for the special case where we find gpm, but
2615         # ncurses is in a nonstandard location via $LIBS, and we really want
2616         # to link gpm.
2617 cf_ncurses_LIBS=""
2618 cf_ncurses_SAVE="$LIBS"
2619 AC_CHECK_LIB(gpm,Gpm_Open,
2620         [AC_CHECK_LIB(gpm,initscr,
2621                 [LIBS="$cf_ncurses_SAVE"],
2622                 [cf_ncurses_LIBS="-lgpm"])])
2623
2624 case $host_os in
2625 (freebsd*)
2626         # This is only necessary if you are linking against an obsolete
2627         # version of ncurses (but it should do no harm, since it's static).
2628         if test "$cf_nculib_root" = ncurses ; then
2629                 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
2630         fi
2631         ;;
2632 esac
2633
2634 CF_ADD_LIBS($cf_ncurses_LIBS)
2635
2636 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
2637 then
2638         CF_ADD_LIBS(-l$cf_nculib_root)
2639 else
2640         CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
2641                 [#include <${cf_cv_ncurses_header:-curses.h}>],
2642                 [initscr()],
2643                 initscr)
2644 fi
2645
2646 if test -n "$cf_ncurses_LIBS" ; then
2647         AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
2648         cf_ncurses_SAVE="$LIBS"
2649         for p in $cf_ncurses_LIBS ; do
2650                 q=`echo $LIBS | sed -e "s%$p %%" -e "s%$p$%%"`
2651                 if test "$q" != "$LIBS" ; then
2652                         LIBS="$q"
2653                 fi
2654         done
2655         AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2656                 [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2657                 [AC_MSG_RESULT(yes)],
2658                 [AC_MSG_RESULT(no)
2659                  LIBS="$cf_ncurses_SAVE"])
2660 fi
2661
2662 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
2663 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2664 ])dnl
2665 dnl ---------------------------------------------------------------------------
2666 dnl CF_NCURSES_PTHREADS version: 2 updated: 2016/04/22 05:07:41
2667 dnl -------------------
2668 dnl Use this followup check to ensure that we link with pthreads if ncurses
2669 dnl uses it.
2670 AC_DEFUN([CF_NCURSES_PTHREADS],[
2671 : ${cf_nculib_root:=ifelse($1,,ncurses,$1)}
2672 AC_CHECK_LIB($cf_nculib_root,_nc_init_pthreads,
2673         cf_cv_ncurses_pthreads=yes,
2674         cf_cv_ncurses_pthreads=no)
2675 if test "$cf_cv_ncurses_pthreads" = yes
2676 then
2677         CF_ADD_LIBS(-lpthread)
2678 fi
2679 ])dnl
2680 dnl ---------------------------------------------------------------------------
2681 dnl CF_NCURSES_VERSION version: 15 updated: 2017/05/09 19:26:10
2682 dnl ------------------
2683 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
2684 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS.  We don't use
2685 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
2686 AC_DEFUN([CF_NCURSES_VERSION],
2687 [
2688 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
2689 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
2690         cf_cv_ncurses_version=no
2691         cf_tempfile=out$$
2692         rm -f $cf_tempfile
2693         AC_TRY_RUN([
2694 #include <${cf_cv_ncurses_header:-curses.h}>
2695 #include <stdio.h>
2696 int main(void)
2697 {
2698         FILE *fp = fopen("$cf_tempfile", "w");
2699 #ifdef NCURSES_VERSION
2700 # ifdef NCURSES_VERSION_PATCH
2701         fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
2702 # else
2703         fprintf(fp, "%s\n", NCURSES_VERSION);
2704 # endif
2705 #else
2706 # ifdef __NCURSES_H
2707         fprintf(fp, "old\n");
2708 # else
2709         make an error
2710 # endif
2711 #endif
2712         ${cf_cv_main_return:-return}(0);
2713 }],[
2714         cf_cv_ncurses_version=`cat $cf_tempfile`],,[
2715
2716         # This will not work if the preprocessor splits the line after the
2717         # Autoconf token.  The 'unproto' program does that.
2718         cat > conftest.$ac_ext <<EOF
2719 #include <${cf_cv_ncurses_header:-curses.h}>
2720 #undef Autoconf
2721 #ifdef NCURSES_VERSION
2722 Autoconf NCURSES_VERSION
2723 #else
2724 #ifdef __NCURSES_H
2725 Autoconf "old"
2726 #endif
2727 ;
2728 #endif
2729 EOF
2730         cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
2731         AC_TRY_EVAL(cf_try)
2732         if test -f conftest.out ; then
2733                 cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%'`
2734                 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
2735                 rm -f conftest.out
2736         fi
2737 ])
2738         rm -f $cf_tempfile
2739 ])
2740 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2741 ])dnl
2742 dnl ---------------------------------------------------------------------------
2743 dnl CF_NCURSES_WRAP_PREFIX version: 1 updated: 2009/03/28 16:08:10
2744 dnl ----------------------
2745 dnl Check for ncurses "wrap-prefix" used for public variables which have been
2746 dnl wrapped with a function to help with concurrency control.
2747 AC_DEFUN([CF_NCURSES_WRAP_PREFIX],
2748 [
2749 AC_MSG_CHECKING(for ncurses wrap-prefix)
2750 AC_ARG_WITH(ncurses-wrap-prefix,
2751         [  --with-ncurses-wrap-prefix naming-prefix for ncurses wrapped-variables],
2752         [NCURSES_WRAP_PREFIX=$withval],
2753         [NCURSES_WRAP_PREFIX=_nc_])
2754 AC_MSG_RESULT($NCURSES_WRAP_PREFIX)
2755
2756 AC_SUBST(NCURSES_WRAP_PREFIX)
2757 ])
2758 dnl ---------------------------------------------------------------------------
2759 dnl CF_NETBSD_FORM_H version: 2 updated: 2012/10/06 16:39:58
2760 dnl ----------------
2761 dnl Check for NetBSD's form.h, which is incompatible with SVr4 and ncurses.
2762 dnl Some workarounds are needed in client programs to allow them to compile.
2763 AC_DEFUN([CF_NETBSD_FORM_H],[
2764 AC_CACHE_CHECK(for NetBSD form.h,cf_cv_netbsd_form_h,[
2765 AC_TRY_COMPILE([
2766 #include <${cf_cv_ncurses_header:-curses.h}>
2767 #include <form.h>
2768 ],[
2769         FORM *form;
2770         int y = current_field(form)->cursor_ypos;
2771         int x = current_field(form)->cursor_xpos;
2772 ],[cf_cv_netbsd_form_h=yes
2773 ],[cf_cv_netbsd_form_h=no])
2774 ])
2775
2776 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])
2777 ])dnl
2778 dnl ---------------------------------------------------------------------------
2779 dnl CF_NETBSD_MENU_H version: 2 updated: 2012/10/06 16:39:58
2780 dnl ----------------
2781 dnl Check for NetBSD's menu.h, which is incompatible with SVr4 and ncurses.
2782 dnl Some workarounds are needed in client programs to allow them to compile.
2783 AC_DEFUN([CF_NETBSD_MENU_H],[
2784 AC_CACHE_CHECK(for NetBSD menu.h,cf_cv_netbsd_menu_h,[
2785 AC_TRY_COMPILE([
2786 #include <${cf_cv_ncurses_header:-curses.h}>
2787 #include <menu.h>
2788 ],[
2789         MENU *menu;
2790         int y = menu->max_item_width;
2791 ],[cf_cv_netbsd_menu_h=yes
2792 ],[cf_cv_netbsd_menu_h=no])
2793 ])
2794
2795 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])
2796 ])dnl
2797 dnl ---------------------------------------------------------------------------
2798 dnl CF_NO_LEAKS_OPTION version: 6 updated: 2015/04/12 15:39:00
2799 dnl ------------------
2800 dnl see CF_WITH_NO_LEAKS
2801 AC_DEFUN([CF_NO_LEAKS_OPTION],[
2802 AC_MSG_CHECKING(if you want to use $1 for testing)
2803 AC_ARG_WITH($1,
2804         [$2],
2805         [AC_DEFINE_UNQUOTED($3,1,"Define to 1 if you want to use $1 for testing.")ifelse([$4],,[
2806          $4
2807 ])
2808         : ${with_cflags:=-g}
2809         : ${with_no_leaks:=yes}
2810          with_$1=yes],
2811         [with_$1=])
2812 AC_MSG_RESULT(${with_$1:-no})
2813
2814 case .$with_cflags in
2815 (.*-g*)
2816         case .$CFLAGS in
2817         (.*-g*)
2818                 ;;
2819         (*)
2820                 CF_ADD_CFLAGS([-g])
2821                 ;;
2822         esac
2823         ;;
2824 esac
2825 ])dnl
2826 dnl ---------------------------------------------------------------------------
2827 dnl CF_PATH_SYNTAX version: 16 updated: 2015/04/18 08:56:57
2828 dnl --------------
2829 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
2830 dnl begins with one of the prefix/exec_prefix variables, and then again if the
2831 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
2832 dnl delayed evaluation of those symbols.
2833 AC_DEFUN([CF_PATH_SYNTAX],[
2834 if test "x$prefix" != xNONE; then
2835         cf_path_syntax="$prefix"
2836 else
2837         cf_path_syntax="$ac_default_prefix"
2838 fi
2839
2840 case ".[$]$1" in
2841 (.\[$]\(*\)*|.\'*\'*)
2842         ;;
2843 (..|./*|.\\*)
2844         ;;
2845 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
2846         ;;
2847 (.\[$]{*prefix}*|.\[$]{*dir}*)
2848         eval $1="[$]$1"
2849         case ".[$]$1" in
2850         (.NONE/*)
2851                 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
2852                 ;;
2853         esac
2854         ;;
2855 (.no|.NONE/*)
2856         $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
2857         ;;
2858 (*)
2859         ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
2860         ;;
2861 esac
2862 ])dnl
2863 dnl ---------------------------------------------------------------------------
2864 dnl CF_PDCURSES_X11 version: 14 updated: 2018/06/20 20:23:13
2865 dnl ---------------
2866 dnl Configure for PDCurses' X11 library
2867 AC_DEFUN([CF_PDCURSES_X11],[
2868 AC_REQUIRE([CF_X_ATHENA])
2869
2870 CF_ACVERSION_CHECK(2.52,
2871         [AC_CHECK_TOOLS(XCURSES_CONFIG, xcurses-config, none)],
2872         [AC_PATH_PROGS(XCURSES_CONFIG, xcurses-config, none)])
2873
2874 if test "$XCURSES_CONFIG" != none ; then
2875
2876 CF_ADD_CFLAGS(`$XCURSES_CONFIG --cflags`)
2877 CF_ADD_LIBS(`$XCURSES_CONFIG --libs`)
2878
2879 cf_cv_lib_XCurses=yes
2880
2881 else
2882
2883 LDFLAGS="$LDFLAGS $X_LIBS"
2884 CF_CHECK_CFLAGS($X_CFLAGS)
2885 AC_CHECK_LIB(X11,XOpenDisplay,
2886         [CF_ADD_LIBS(-lX11)],,
2887         [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])
2888 AC_CACHE_CHECK(for XCurses library,cf_cv_lib_XCurses,[
2889 CF_ADD_LIBS(-lXCurses)
2890 AC_TRY_LINK([
2891 #include <xcurses.h>
2892 char *XCursesProgramName = "test";
2893 ],[XCursesExit();],
2894 [cf_cv_lib_XCurses=yes],
2895 [cf_cv_lib_XCurses=no])
2896 ])
2897
2898 fi
2899
2900 if test $cf_cv_lib_XCurses = yes ; then
2901         AC_DEFINE(UNIX,1,[Define to 1 if using PDCurses on Unix])
2902         AC_DEFINE(XCURSES,1,[Define to 1 if using PDCurses on Unix])
2903         AC_CHECK_HEADER(xcurses.h, AC_DEFINE(HAVE_XCURSES,1,[Define to 1 if using PDCurses on Unix]))
2904 else
2905         AC_MSG_ERROR(Cannot link with XCurses)
2906 fi
2907 ])dnl
2908 dnl ---------------------------------------------------------------------------
2909 dnl CF_PKG_CONFIG version: 10 updated: 2015/04/26 18:06:58
2910 dnl -------------
2911 dnl Check for the package-config program, unless disabled by command-line.
2912 AC_DEFUN([CF_PKG_CONFIG],
2913 [
2914 AC_MSG_CHECKING(if you want to use pkg-config)
2915 AC_ARG_WITH(pkg-config,
2916         [  --with-pkg-config{=path} enable/disable use of pkg-config],
2917         [cf_pkg_config=$withval],
2918         [cf_pkg_config=yes])
2919 AC_MSG_RESULT($cf_pkg_config)
2920
2921 case $cf_pkg_config in
2922 (no)
2923         PKG_CONFIG=none
2924         ;;
2925 (yes)
2926         CF_ACVERSION_CHECK(2.52,
2927                 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
2928                 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
2929         ;;
2930 (*)
2931         PKG_CONFIG=$withval
2932         ;;
2933 esac
2934
2935 test -z "$PKG_CONFIG" && PKG_CONFIG=none
2936 if test "$PKG_CONFIG" != none ; then
2937         CF_PATH_SYNTAX(PKG_CONFIG)
2938 elif test "x$cf_pkg_config" != xno ; then
2939         AC_MSG_WARN(pkg-config is not installed)
2940 fi
2941
2942 AC_SUBST(PKG_CONFIG)
2943 ])dnl
2944 dnl ---------------------------------------------------------------------------
2945 dnl CF_POSIX_C_SOURCE version: 11 updated: 2018/12/31 20:46:17
2946 dnl -----------------
2947 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
2948 dnl
2949 dnl     POSIX.1-1990                            _POSIX_SOURCE
2950 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
2951 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
2952 dnl             Bindings Option
2953 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
2954 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
2955 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
2956 dnl
2957 dnl Parameters:
2958 dnl     $1 is the nominal value for _POSIX_C_SOURCE
2959 AC_DEFUN([CF_POSIX_C_SOURCE],
2960 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
2961
2962 if test "$cf_cv_posix_visible" = no; then
2963
2964 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
2965
2966 cf_save_CFLAGS="$CFLAGS"
2967 cf_save_CPPFLAGS="$CPPFLAGS"
2968
2969 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
2970 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
2971
2972 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
2973         CF_MSG_LOG(if the symbol is already defined go no further)
2974         AC_TRY_COMPILE([#include <sys/types.h>],[
2975 #ifndef _POSIX_C_SOURCE
2976 make an error
2977 #endif],
2978         [cf_cv_posix_c_source=no],
2979         [cf_want_posix_source=no
2980          case .$cf_POSIX_C_SOURCE in
2981          (.[[12]]??*)
2982                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
2983                 ;;
2984          (.2)
2985                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
2986                 cf_want_posix_source=yes
2987                 ;;
2988          (.*)
2989                 cf_want_posix_source=yes
2990                 ;;
2991          esac
2992          if test "$cf_want_posix_source" = yes ; then
2993                 AC_TRY_COMPILE([#include <sys/types.h>],[
2994 #ifdef _POSIX_SOURCE
2995 make an error
2996 #endif],[],
2997                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
2998          fi
2999          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3000          CFLAGS="$cf_trim_CFLAGS"
3001          CPPFLAGS="$cf_trim_CPPFLAGS"
3002          CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
3003          CF_MSG_LOG(if the second compile does not leave our definition intact error)
3004          AC_TRY_COMPILE([#include <sys/types.h>],[
3005 #ifndef _POSIX_C_SOURCE
3006 make an error
3007 #endif],,
3008          [cf_cv_posix_c_source=no])
3009          CFLAGS="$cf_save_CFLAGS"
3010          CPPFLAGS="$cf_save_CPPFLAGS"
3011         ])
3012 ])
3013
3014 if test "$cf_cv_posix_c_source" != no ; then
3015         CFLAGS="$cf_trim_CFLAGS"
3016         CPPFLAGS="$cf_trim_CPPFLAGS"
3017         CF_ADD_CFLAGS($cf_cv_posix_c_source)
3018 fi
3019
3020 fi # cf_cv_posix_visible
3021
3022 ])dnl
3023 dnl ---------------------------------------------------------------------------
3024 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
3025 dnl ----------------
3026 dnl POSIX documents test-macros which an application may set before any system
3027 dnl headers are included to make features available.
3028 dnl
3029 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
3030 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
3031 dnl recent features visible in the system header files unless the application
3032 dnl overrides the corresponding test-macros.  Doing that introduces portability
3033 dnl problems.
3034 dnl
3035 dnl This macro makes a special check for the symbols used for this, to avoid a
3036 dnl conflicting definition.
3037 AC_DEFUN([CF_POSIX_VISIBLE],
3038 [
3039 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
3040 AC_TRY_COMPILE([#include <stdio.h>],[
3041 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
3042         && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
3043         && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
3044         && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
3045 #error conflicting symbols found
3046 #endif
3047 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
3048 ])
3049 ])dnl
3050 dnl ---------------------------------------------------------------------------
3051 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
3052 dnl ------------
3053 dnl Append definitions and rules for the given programs to the subdirectory
3054 dnl Makefiles, and the recursion rule for the top-level Makefile.
3055 dnl
3056 dnl parameters
3057 dnl     $1 = script to run
3058 dnl     $2 = list of subdirectories
3059 dnl
3060 dnl variables
3061 dnl     $AWK
3062 AC_DEFUN([CF_PRG_RULES],
3063 [
3064 for cf_dir in $2
3065 do
3066         if test ! -d $srcdir/$cf_dir; then
3067                 continue
3068         elif test -f $srcdir/$cf_dir/programs; then
3069                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
3070         fi
3071 done
3072
3073 ])dnl
3074 dnl ---------------------------------------------------------------------------
3075 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
3076 dnl ----------
3077 dnl standard check for CC, plus followup sanity checks
3078 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
3079 AC_DEFUN([CF_PROG_CC],[
3080 CF_ACVERSION_CHECK(2.53,
3081         [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
3082          AC_REQUIRE([AC_PROG_CC])],
3083         [])
3084 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
3085 CF_GCC_VERSION
3086 CF_ACVERSION_CHECK(2.52,
3087         [AC_PROG_CC_STDC],
3088         [CF_ANSI_CC_REQD])
3089 CF_CC_ENV_FLAGS
3090 ])dnl
3091 dnl ---------------------------------------------------------------------------
3092 dnl CF_PROG_INSTALL version: 7 updated: 2015/04/18 08:56:57
3093 dnl ---------------
3094 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
3095 dnl misc/tabset install won't work properly.  Usually this happens only when
3096 dnl using the fallback mkinstalldirs script
3097 AC_DEFUN([CF_PROG_INSTALL],
3098 [AC_PROG_INSTALL
3099 case $INSTALL in
3100 (/*)
3101         ;;
3102 (*)
3103         CF_DIRNAME(cf_dir,$INSTALL)
3104         test -z "$cf_dir" && cf_dir=.
3105         INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
3106         ;;
3107 esac
3108 ])dnl
3109 dnl ---------------------------------------------------------------------------
3110 dnl CF_PROG_LINT version: 4 updated: 2019/11/20 18:55:37
3111 dnl ------------
3112 AC_DEFUN([CF_PROG_LINT],
3113 [
3114 AC_CHECK_PROGS(LINT, lint cppcheck splint)
3115 case "x$LINT" in
3116 (xcppcheck|x*/cppcheck)
3117         test -z "$LINT_OPTS" && LINT_OPTS="--enable=all"
3118         ;;
3119 esac
3120 AC_SUBST(LINT_OPTS)
3121 ])dnl
3122 dnl ---------------------------------------------------------------------------
3123 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
3124 dnl ----------------
3125 dnl Remove all -U and -D options that refer to the given symbol from a list
3126 dnl of C compiler options.  This works around the problem that not all
3127 dnl compilers process -U and -D options from left-to-right, so a -U option
3128 dnl cannot be used to cancel the effect of a preceding -D option.
3129 dnl
3130 dnl $1 = target (which could be the same as the source variable)
3131 dnl $2 = source (including '$')
3132 dnl $3 = symbol to remove
3133 define([CF_REMOVE_DEFINE],
3134 [
3135 $1=`echo "$2" | \
3136         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
3137                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
3138 ])dnl
3139 dnl ---------------------------------------------------------------------------
3140 dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45
3141 dnl ---------------------
3142 dnl Restore flags saved in CF_SAVE_XTRA_FLAGS
3143 dnl $1 = name of current macro
3144 define([CF_RESTORE_XTRA_FLAGS],
3145 [
3146 LIBS="$cf_save_LIBS_$1"
3147 CFLAGS="$cf_save_CFLAGS_$1"
3148 CPPFLAGS="$cf_save_CPPFLAGS_$1"
3149 ])dnl
3150 dnl ---------------------------------------------------------------------------
3151 dnl CF_RPATH_HACK version: 11 updated: 2013/09/01 13:02:00
3152 dnl -------------
3153 AC_DEFUN([CF_RPATH_HACK],
3154 [
3155 AC_REQUIRE([CF_LD_RPATH_OPT])
3156 AC_MSG_CHECKING(for updated LDFLAGS)
3157 if test -n "$LD_RPATH_OPT" ; then
3158         AC_MSG_RESULT(maybe)
3159
3160         AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
3161         cf_rpath_list="/usr/lib /lib"
3162         if test "$cf_ldd_prog" != no
3163         then
3164                 cf_rpath_oops=
3165
3166 AC_TRY_LINK([#include <stdio.h>],
3167                 [printf("Hello");],
3168                 [cf_rpath_oops=`$cf_ldd_prog conftest$ac_exeext | fgrep ' not found' | sed -e 's% =>.*$%%' |sort | uniq`
3169                  cf_rpath_list=`$cf_ldd_prog conftest$ac_exeext | fgrep / | sed -e 's%^.*[[     ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort | uniq`])
3170
3171                 # If we passed the link-test, but get a "not found" on a given library,
3172                 # this could be due to inept reconfiguration of gcc to make it only
3173                 # partly honor /usr/local/lib (or whatever).  Sometimes this behavior
3174                 # is intentional, e.g., installing gcc in /usr/bin and suppressing the
3175                 # /usr/local libraries.
3176                 if test -n "$cf_rpath_oops"
3177                 then
3178                         for cf_rpath_src in $cf_rpath_oops
3179                         do
3180                                 for cf_rpath_dir in \
3181                                         /usr/local \
3182                                         /usr/pkg \
3183                                         /opt/sfw
3184                                 do
3185                                         if test -f $cf_rpath_dir/lib/$cf_rpath_src
3186                                         then
3187                                                 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
3188                                                 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
3189                                                 break
3190                                         fi
3191                                 done
3192                         done
3193                 fi
3194         fi
3195
3196         CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3197
3198         CF_RPATH_HACK_2(LDFLAGS)
3199         CF_RPATH_HACK_2(LIBS)
3200
3201         CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3202 else
3203         AC_MSG_RESULT(no)
3204 fi
3205 AC_SUBST(EXTRA_LDFLAGS)
3206 ])dnl
3207 dnl ---------------------------------------------------------------------------
3208 dnl CF_RPATH_HACK_2 version: 7 updated: 2015/04/12 15:39:00
3209 dnl ---------------
3210 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
3211 dnl EXTRA_LDFLAGS for each -L option found.
3212 dnl
3213 dnl $cf_rpath_list contains a list of directories to ignore.
3214 dnl
3215 dnl $1 = variable name to update.  The LDFLAGS variable should be the only one,
3216 dnl      but LIBS often has misplaced -L options.
3217 AC_DEFUN([CF_RPATH_HACK_2],
3218 [
3219 CF_VERBOSE(...checking $1 [$]$1)
3220
3221 cf_rpath_dst=
3222 for cf_rpath_src in [$]$1
3223 do
3224         case $cf_rpath_src in
3225         (-L*)
3226
3227                 # check if this refers to a directory which we will ignore
3228                 cf_rpath_skip=no
3229                 if test -n "$cf_rpath_list"
3230                 then
3231                         for cf_rpath_item in $cf_rpath_list
3232                         do
3233                                 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
3234                                 then
3235                                         cf_rpath_skip=yes
3236                                         break
3237                                 fi
3238                         done
3239                 fi
3240
3241                 if test "$cf_rpath_skip" = no
3242                 then
3243                         # transform the option
3244                         if test "$LD_RPATH_OPT" = "-R " ; then
3245                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
3246                         else
3247                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
3248                         fi
3249
3250                         # if we have not already added this, add it now
3251                         cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
3252                         if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
3253                         then
3254                                 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
3255                                 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
3256                         fi
3257                 fi
3258                 ;;
3259         esac
3260         cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
3261 done
3262 $1=$cf_rpath_dst
3263
3264 CF_VERBOSE(...checked $1 [$]$1)
3265 AC_SUBST(EXTRA_LDFLAGS)
3266 ])dnl
3267 dnl ---------------------------------------------------------------------------
3268 dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44
3269 dnl ------------------
3270 dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers
3271 dnl and libraries which do not update those variables.
3272 dnl
3273 dnl $1 = name of current macro
3274 define([CF_SAVE_XTRA_FLAGS],
3275 [
3276 cf_save_LIBS_$1="$LIBS"
3277 cf_save_CFLAGS_$1="$CFLAGS"
3278 cf_save_CPPFLAGS_$1="$CPPFLAGS"
3279 LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}"
3280 for cf_X_CFLAGS in $X_CFLAGS
3281 do
3282         case "x$cf_X_CFLAGS" in
3283         x-[[IUD]]*)
3284                 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS"
3285                 ;;
3286         *)
3287                 CFLAGS="$CFLAGS $cf_X_CFLAGS"
3288                 ;;
3289         esac
3290 done
3291 ])dnl
3292 dnl ---------------------------------------------------------------------------
3293 dnl CF_SIGWINCH version: 2 updated: 2019/03/23 19:54:44
3294 dnl -----------
3295 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
3296 dnl programs need this test).
3297 dnl
3298 dnl This is really a Mac OS X 10.4.3 workaround.  Defining _POSIX_C_SOURCE
3299 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses).  Oddly, the struct
3300 dnl winsize declaration is left alone - we may revisit this if Apple choose to
3301 dnl break that part of the interface as well.
3302 AC_DEFUN([CF_SIGWINCH],
3303 [
3304 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
3305         AC_TRY_COMPILE([
3306 #include <sys/types.h>
3307 #include <sys/signal.h>
3308 ],[int x = SIGWINCH],
3309         [cf_cv_define_sigwinch=yes],
3310         [AC_TRY_COMPILE([
3311 #undef _XOPEN_SOURCE
3312 #undef _POSIX_SOURCE
3313 #undef _POSIX_C_SOURCE
3314 #include <sys/types.h>
3315 #include <sys/signal.h>
3316 ],[int x = SIGWINCH],
3317         [cf_cv_define_sigwinch=maybe],
3318         [cf_cv_define_sigwinch=no])
3319 ])
3320 ])
3321
3322 if test "$cf_cv_define_sigwinch" = maybe ; then
3323 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
3324 cf_cv_fixup_sigwinch=unknown
3325 cf_sigwinch=32
3326 while test $cf_sigwinch != 1
3327 do
3328         AC_TRY_COMPILE([
3329 #undef _XOPEN_SOURCE
3330 #undef _POSIX_SOURCE
3331 #undef _POSIX_C_SOURCE
3332 #include <sys/types.h>
3333 #include <sys/signal.h>
3334 ],[
3335 #if SIGWINCH != $cf_sigwinch
3336 make an error
3337 #endif
3338 int x = SIGWINCH],
3339         [cf_cv_fixup_sigwinch=$cf_sigwinch
3340          break])
3341
3342 cf_sigwinch=`expr $cf_sigwinch - 1`
3343 done
3344 ])
3345
3346         if test "$cf_cv_fixup_sigwinch" != unknown ; then
3347                 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
3348         fi
3349 fi
3350 ])dnl
3351 dnl ---------------------------------------------------------------------------
3352 dnl CF_SIG_ATOMIC_T version: 4 updated: 2020/01/18 12:30:44
3353 dnl ---------------
3354 dnl signal handler, but there are some gcc dependencies in that recommendation.
3355 dnl Try anyway.
3356 AC_DEFUN([CF_SIG_ATOMIC_T],
3357 [
3358 AC_MSG_CHECKING(for signal global datatype)
3359 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
3360         for cf_type in \
3361                 "volatile sig_atomic_t" \
3362                 "sig_atomic_t" \
3363                 "int"
3364         do
3365         AC_TRY_COMPILE([
3366 #include <sys/types.h>
3367 #include <signal.h>
3368 #include <stdio.h>
3369
3370 extern $cf_type x;
3371 $cf_type x;
3372 static void handler(int sig)
3373 {
3374         x = 5;
3375 }],
3376                 [signal(SIGINT, handler);
3377                  x = 1],
3378                 [cf_cv_sig_atomic_t=$cf_type],
3379                 [cf_cv_sig_atomic_t=no])
3380                 test "$cf_cv_sig_atomic_t" != no && break
3381         done
3382         ])
3383 AC_MSG_RESULT($cf_cv_sig_atomic_t)
3384 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t,[Define to signal global datatype])
3385 ])dnl
3386 dnl ---------------------------------------------------------------------------
3387 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
3388 dnl --------------
3389 dnl Construct a search-list for a nonstandard header/lib-file
3390 dnl     $1 = the variable to return as result
3391 dnl     $2 = the package name
3392 dnl     $3 = the subdirectory, e.g., bin, include or lib
3393 AC_DEFUN([CF_SUBDIR_PATH],
3394 [
3395 $1=
3396
3397 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
3398
3399 for cf_subdir_prefix in \
3400         /usr \
3401         /usr/local \
3402         /usr/pkg \
3403         /opt \
3404         /opt/local \
3405         [$]HOME
3406 do
3407         CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
3408 done
3409 ])dnl
3410 dnl ---------------------------------------------------------------------------
3411 dnl CF_SYS_TIME_SELECT version: 6 updated: 2015/04/18 08:56:57
3412 dnl ------------------
3413 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
3414 dnl older SCO configurations.
3415 AC_DEFUN([CF_SYS_TIME_SELECT],
3416 [
3417 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
3418 AC_CACHE_VAL(cf_cv_sys_time_select,[
3419 AC_TRY_COMPILE([
3420 #include <sys/types.h>
3421 #ifdef HAVE_SYS_TIME_H
3422 #include <sys/time.h>
3423 #endif
3424 #ifdef HAVE_SYS_SELECT_H
3425 #include <sys/select.h>
3426 #endif
3427 ],[],[cf_cv_sys_time_select=yes],
3428          [cf_cv_sys_time_select=no])
3429          ])
3430 AC_MSG_RESULT($cf_cv_sys_time_select)
3431 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>])
3432 ])dnl
3433 dnl ---------------------------------------------------------------------------
3434 dnl CF_TERM_HEADER version: 4 updated: 2015/04/15 19:08:48
3435 dnl --------------
3436 dnl Look for term.h, which is part of X/Open curses.  It defines the interface
3437 dnl to terminfo database.  Usually it is in the same include-path as curses.h,
3438 dnl but some packagers change this, breaking various applications.
3439 AC_DEFUN([CF_TERM_HEADER],[
3440 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
3441 case ${cf_cv_ncurses_header} in
3442 (*/ncurses.h|*/ncursesw.h)
3443         cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
3444         ;;
3445 (*)
3446         cf_term_header=term.h
3447         ;;
3448 esac
3449
3450 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
3451 do
3452 AC_TRY_COMPILE([#include <stdio.h>
3453 #include <${cf_cv_ncurses_header:-curses.h}>
3454 #include <$cf_test>
3455 ],[int x = auto_left_margin],[
3456         cf_cv_term_header="$cf_test"],[
3457         cf_cv_term_header=unknown
3458         ])
3459         test "$cf_cv_term_header" != unknown && break
3460 done
3461 ])
3462
3463 # Set definitions to allow ifdef'ing to accommodate subdirectories
3464
3465 case $cf_cv_term_header in
3466 (*term.h)
3467         AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
3468         ;;
3469 esac
3470
3471 case $cf_cv_term_header in
3472 (ncurses/term.h)
3473         AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
3474         ;;
3475 (ncursesw/term.h)
3476         AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
3477         ;;
3478 esac
3479 ])dnl
3480 dnl ---------------------------------------------------------------------------
3481 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
3482 dnl ---------------
3483 dnl Define a top_builddir symbol, for applications that need an absolute path.
3484 AC_DEFUN([CF_TOP_BUILDDIR],
3485 [
3486 top_builddir=ifelse($1,,`pwd`,$1)
3487 AC_SUBST(top_builddir)
3488 ])dnl
3489 dnl ---------------------------------------------------------------------------
3490 dnl CF_TPUTS_PROTO version: 3 updated: 2015/04/17 21:26:14
3491 dnl --------------
3492 dnl Check for type of function-pointer passed to tputs.  Some old
3493 dnl implementations used functions that had different prototypes, making it
3494 dnl hard to compile portable programs using tputs.
3495 AC_DEFUN([CF_TPUTS_PROTO],[
3496 CF_CURSES_FUNCS(tputs)
3497 if test x$cf_cv_func_tputs = xyes
3498 then
3499         cf_done=no
3500         for cf_arg in int char
3501         do
3502                 for cf_ret in int void
3503                 do
3504                         if test $cf_ret = void
3505                         then
3506                                 cf_return="/* nothing */"
3507                         else
3508                                 cf_return="return value"
3509                         fi
3510                         AC_TRY_COMPILE([
3511 #include <${cf_cv_ncurses_header:-curses.h}>
3512 #include <$cf_cv_term_header>
3513
3514 static $cf_ret outc($cf_arg value) { $cf_return; }
3515 ],[
3516         tputs("hello", 0, outc);
3517         ${cf_cv_main_return:-return}(0);
3518 ],[
3519                 CF_VERBOSE([prototype $cf_ret func($cf_arg value)])
3520                 cat >>confdefs.h <<EOF
3521 #define TPUTS_ARG               $cf_arg
3522 #define TPUTS_PROTO(func,value) $cf_ret func(TPUTS_ARG value)
3523 #define TPUTS_RETURN(value)     $cf_return
3524 EOF
3525                 cf_done=yes
3526                 break
3527 ])
3528                 done
3529                 test $cf_done = yes && break
3530         done
3531 fi
3532 ])dnl
3533 dnl ---------------------------------------------------------------------------
3534 dnl CF_TRIM_X_LIBS version: 3 updated: 2015/04/12 15:39:00
3535 dnl --------------
3536 dnl Trim extra base X libraries added as a workaround for inconsistent library
3537 dnl dependencies returned by "new" pkg-config files.
3538 AC_DEFUN([CF_TRIM_X_LIBS],[
3539         for cf_trim_lib in Xmu Xt X11
3540         do
3541                 case "$LIBS" in
3542                 (*-l$cf_trim_lib\ *-l$cf_trim_lib*)
3543                         LIBS=`echo "$LIBS " | sed -e 's/  / /g' -e 's%-l'"$cf_trim_lib"' %%' -e 's/ $//'`
3544                         CF_VERBOSE(..trimmed $LIBS)
3545                         ;;
3546                 esac
3547         done
3548 ])
3549 dnl ---------------------------------------------------------------------------
3550 dnl CF_TRY_PKG_CONFIG version: 5 updated: 2013/07/06 21:27:06
3551 dnl -----------------
3552 dnl This is a simple wrapper to use for pkg-config, for libraries which may be
3553 dnl available in that form.
3554 dnl
3555 dnl $1 = package name
3556 dnl $2 = extra logic to use, if any, after updating CFLAGS and LIBS
3557 dnl $3 = logic to use if pkg-config does not have the package
3558 AC_DEFUN([CF_TRY_PKG_CONFIG],[
3559 AC_REQUIRE([CF_PKG_CONFIG])
3560
3561 if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists $1; then
3562         CF_VERBOSE(found package $1)
3563         cf_pkgconfig_incs="`$PKG_CONFIG --cflags $1 2>/dev/null`"
3564         cf_pkgconfig_libs="`$PKG_CONFIG --libs   $1 2>/dev/null`"
3565         CF_VERBOSE(package $1 CFLAGS: $cf_pkgconfig_incs)
3566         CF_VERBOSE(package $1 LIBS: $cf_pkgconfig_libs)
3567         CF_ADD_CFLAGS($cf_pkgconfig_incs)
3568         CF_ADD_LIBS($cf_pkgconfig_libs)
3569         ifelse([$2],,:,[$2])
3570 else
3571         cf_pkgconfig_incs=
3572         cf_pkgconfig_libs=
3573         ifelse([$3],,:,[$3])
3574 fi
3575 ])
3576 dnl ---------------------------------------------------------------------------
3577 dnl CF_TRY_XOPEN_SOURCE version: 2 updated: 2018/06/20 20:23:13
3578 dnl -------------------
3579 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
3580 dnl can define it successfully.
3581 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
3582 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
3583         AC_TRY_COMPILE([
3584 #include <stdlib.h>
3585 #include <string.h>
3586 #include <sys/types.h>
3587 ],[
3588 #ifndef _XOPEN_SOURCE
3589 make an error
3590 #endif],
3591         [cf_cv_xopen_source=no],
3592         [cf_save="$CPPFLAGS"
3593          CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE)
3594          AC_TRY_COMPILE([
3595 #include <stdlib.h>
3596 #include <string.h>
3597 #include <sys/types.h>
3598 ],[
3599 #ifdef _XOPEN_SOURCE
3600 make an error
3601 #endif],
3602         [cf_cv_xopen_source=no],
3603         [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
3604         CPPFLAGS="$cf_save"
3605         ])
3606 ])
3607
3608 if test "$cf_cv_xopen_source" != no ; then
3609         CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
3610         CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
3611         cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
3612         CF_ADD_CFLAGS($cf_temp_xopen_source)
3613 fi
3614 ])
3615 dnl ---------------------------------------------------------------------------
3616 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
3617 dnl --------
3618 dnl Make an uppercase version of a variable
3619 dnl $1=uppercase($2)
3620 AC_DEFUN([CF_UPPER],
3621 [
3622 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3623 ])dnl
3624 dnl ---------------------------------------------------------------------------
3625 dnl CF_UTF8_LIB version: 8 updated: 2012/10/06 08:57:51
3626 dnl -----------
3627 dnl Check for multibyte support, and if not found, utf8 compatibility library
3628 AC_DEFUN([CF_UTF8_LIB],
3629 [
3630 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
3631         cf_save_LIBS="$LIBS"
3632         AC_TRY_LINK([
3633 #include <stdlib.h>],[putwc(0,0);],
3634         [cf_cv_utf8_lib=yes],
3635         [CF_FIND_LINKAGE([
3636 #include <libutf8.h>],[putwc(0,0);],utf8,
3637                 [cf_cv_utf8_lib=add-on],
3638                 [cf_cv_utf8_lib=no])
3639 ])])
3640
3641 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
3642 # ncurses/ncursesw:
3643 if test "$cf_cv_utf8_lib" = "add-on" ; then
3644         AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
3645         CF_ADD_INCDIR($cf_cv_header_path_utf8)
3646         CF_ADD_LIBDIR($cf_cv_library_path_utf8)
3647         CF_ADD_LIBS($cf_cv_library_file_utf8)
3648 fi
3649 ])dnl
3650 dnl ---------------------------------------------------------------------------
3651 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
3652 dnl ----------
3653 dnl Use AC_VERBOSE w/o the warnings
3654 AC_DEFUN([CF_VERBOSE],
3655 [test -n "$verbose" && echo "   $1" 1>&AC_FD_MSG
3656 CF_MSG_LOG([$1])
3657 ])dnl
3658 dnl ---------------------------------------------------------------------------
3659 dnl CF_WCHAR_TYPE version: 4 updated: 2012/10/06 16:39:58
3660 dnl -------------
3661 dnl Check if type wide-character type $1 is declared, and if so, which header
3662 dnl file is needed.  The second parameter is used to set a shell variable when
3663 dnl the type is not found.  The first parameter sets a shell variable for the
3664 dnl opposite sense.
3665 AC_DEFUN([CF_WCHAR_TYPE],
3666 [
3667 # This is needed on Tru64 5.0 to declare $1
3668 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
3669 AC_TRY_COMPILE([
3670 #include <stdlib.h>
3671 #include <stdarg.h>
3672 #include <stdio.h>
3673 #ifdef HAVE_LIBUTF8_H
3674 #include <libutf8.h>
3675 #endif],
3676         [$1 state],
3677         [cf_cv_$1=no],
3678         [AC_TRY_COMPILE([
3679 #include <stdlib.h>
3680 #include <stdarg.h>
3681 #include <stdio.h>
3682 #include <wchar.h>
3683 #ifdef HAVE_LIBUTF8_H
3684 #include <libutf8.h>
3685 #endif],
3686         [$1 value],
3687         [cf_cv_$1=yes],
3688         [cf_cv_$1=unknown])])])
3689
3690 if test "$cf_cv_$1" = yes ; then
3691         AC_DEFINE(NEED_WCHAR_H,1,[Define to 1 if we must include wchar.h])
3692         NEED_WCHAR_H=1
3693 fi
3694
3695 ifelse([$2],,,[
3696 # if we do not find $1 in either place, use substitution to provide a fallback.
3697 if test "$cf_cv_$1" = unknown ; then
3698         $2=1
3699 fi
3700 ])
3701 ifelse($3,,,[
3702 # if we find $1 in either place, use substitution to provide a fallback.
3703 if test "$cf_cv_$1" != unknown ; then
3704         $3=1
3705 fi
3706 ])
3707 ])dnl
3708 dnl ---------------------------------------------------------------------------
3709 dnl CF_WITH_CURSES_DIR version: 3 updated: 2010/11/20 17:02:38
3710 dnl ------------------
3711 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
3712 dnl libraries.
3713 AC_DEFUN([CF_WITH_CURSES_DIR],[
3714
3715 AC_MSG_CHECKING(for specific curses-directory)
3716 AC_ARG_WITH(curses-dir,
3717         [  --with-curses-dir=DIR   directory in which (n)curses is installed],
3718         [cf_cv_curses_dir=$withval],
3719         [cf_cv_curses_dir=no])
3720 AC_MSG_RESULT($cf_cv_curses_dir)
3721
3722 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
3723 then
3724         CF_PATH_SYNTAX(withval)
3725         if test -d "$cf_cv_curses_dir"
3726         then
3727                 CF_ADD_INCDIR($cf_cv_curses_dir/include)
3728                 CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
3729         fi
3730 fi
3731 ])dnl
3732 dnl ---------------------------------------------------------------------------
3733 dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
3734 dnl ----------------
3735 dnl Configure-option for dbmalloc.  The optional parameter is used to override
3736 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
3737 AC_DEFUN([CF_WITH_DBMALLOC],[
3738 CF_NO_LEAKS_OPTION(dbmalloc,
3739         [  --with-dbmalloc         test: use Conor Cahill's dbmalloc library],
3740         [USE_DBMALLOC])
3741
3742 if test "$with_dbmalloc" = yes ; then
3743         AC_CHECK_HEADER(dbmalloc.h,
3744                 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
3745 fi
3746 ])dnl
3747 dnl ---------------------------------------------------------------------------
3748 dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
3749 dnl ---------------
3750 dnl Configure-option for dmalloc.  The optional parameter is used to override
3751 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
3752 AC_DEFUN([CF_WITH_DMALLOC],[
3753 CF_NO_LEAKS_OPTION(dmalloc,
3754         [  --with-dmalloc          test: use Gray Watson's dmalloc library],
3755         [USE_DMALLOC])
3756
3757 if test "$with_dmalloc" = yes ; then
3758         AC_CHECK_HEADER(dmalloc.h,
3759                 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
3760 fi
3761 ])dnl
3762 dnl ---------------------------------------------------------------------------
3763 dnl CF_WITH_NCURSES_ETC version: 5 updated: 2016/02/20 19:23:20
3764 dnl -------------------
3765 dnl Use this macro for programs which use any variant of "curses", e.g.,
3766 dnl "ncurses", and "PDCurses".  Programs that can use curses and some unrelated
3767 dnl library (such as slang) should use a "--with-screen=XXX" option.
3768 dnl
3769 dnl This does not use AC_DEFUN, because that would tell autoconf to run each
3770 dnl of the macros inside this one - before this macro.
3771 define([CF_WITH_NCURSES_ETC],[
3772 CF_WITH_CURSES_DIR
3773
3774 cf_cv_screen=curses
3775
3776 AC_MSG_CHECKING(for specified curses library type)
3777 AC_ARG_WITH(screen,
3778         [  --with-screen=XXX       use specified curses-libraries],
3779         [cf_cv_screen=$withval],[
3780
3781 AC_ARG_WITH(ncursesw,
3782         [  --with-ncursesw         use wide ncurses-libraries],
3783         [cf_cv_screen=ncursesw],[
3784
3785 AC_ARG_WITH(ncurses,
3786         [  --with-ncurses          use ncurses-libraries],
3787         [cf_cv_screen=ncurses],[
3788
3789 AC_ARG_WITH(pdcurses,
3790         [  --with-pdcurses         compile/link with pdcurses X11 library],
3791         [cf_cv_screen=pdcurses],[
3792
3793 AC_ARG_WITH(curses-colr,
3794         [  --with-curses-colr      compile/link with HPUX 10.x color-curses],
3795         [cf_cv_screen=curses_colr],[
3796
3797 AC_ARG_WITH(curses-5lib,
3798         [  --with-curses-5lib      compile/link with SunOS 5lib curses],
3799         [cf_cv_screen=curses_5lib])])])])])])
3800
3801 AC_MSG_RESULT($cf_cv_screen)
3802
3803 case $cf_cv_screen in
3804 (curses|curses_*)
3805         CF_CURSES_CONFIG
3806         ;;
3807 (ncursesw*)
3808         CF_UTF8_LIB
3809         CF_NCURSES_CONFIG($cf_cv_screen)
3810         ;;
3811 (ncurses*)
3812         CF_NCURSES_CONFIG($cf_cv_screen)
3813         ;;
3814 (pdcurses)
3815         CF_PDCURSES_X11
3816         ;;
3817 (*)
3818         AC_MSG_ERROR(unexpected screen-value: $cf_cv_screen)
3819         ;;
3820 esac
3821
3822 CF_NCURSES_PTHREADS($cf_cv_screen)
3823
3824 ])dnl
3825 dnl ---------------------------------------------------------------------------
3826 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
3827 dnl ----------------
3828 AC_DEFUN([CF_WITH_VALGRIND],[
3829 CF_NO_LEAKS_OPTION(valgrind,
3830         [  --with-valgrind         test: use valgrind],
3831         [USE_VALGRIND])
3832 ])dnl
3833 dnl ---------------------------------------------------------------------------
3834 dnl CF_WITH_X11_RGB version: 2 updated: 2019/12/31 08:53:54
3835 dnl ---------------
3836 dnl Handle configure option "--with-x11-rgb", setting these shell
3837 dnl variables:
3838 dnl
3839 dnl $RGB_PATH is the option value, used for finding the X11 rgb file.
3840 dnl $no_x11_rgb is a "#" (comment) if "--without-x11-rgb" is given.
3841 dnl
3842 dnl Most Linux's use this:
3843 dnl     /usr/share/X11/rgb.txt
3844 dnl Debian uses this:
3845 dnl     /etc/X11/rgb.txt
3846 dnl DragonFlyBSD ports uses this:
3847 dnl     /usr/pkg/lib/X11/rgb.txt
3848 dnl FreeBSD ports use these:
3849 dnl     /usr/local/lib/X11/rgb.txt
3850 dnl     /usr/local/share/X11/rgb.txt
3851 dnl Mandriva has these:
3852 dnl     /usr/lib/X11/rgb.txt
3853 dnl     /usr/lib64/X11/rgb.txt
3854 dnl NetBSD has these
3855 dnl     /usr/X11R7/lib/X11/rgb.txt
3856 dnl OpenSolaris uses
3857 dnl     32-bit:
3858 dnl     /usr/X11/etc/X11/rgb.txt
3859 dnl     /usr/X11/share/X11/rgb.txt
3860 dnl     /usr/X11/lib/X11/rgb.txt
3861 dnl OSX uses
3862 dnl             /opt/local/share/X11/rgb.txt (MacPorts)
3863 dnl             /opt/X11/share/X11/rgb.txt (non-ports)
3864 dnl     64-bit:
3865 dnl     /usr/X11/etc/X11/rgb.txt
3866 dnl     /usr/X11/share/X11/rgb.txt (perhaps)
3867 dnl     /usr/X11/lib/amd64/X11/rgb.txt
3868 dnl Solaris10 uses (in this order):
3869 dnl     /usr/openwin/lib/X11/rgb.txt
3870 dnl     /usr/X11/lib/X11/rgb.txt
3871 AC_DEFUN([CF_WITH_X11_RGB],[
3872 AC_MSG_CHECKING(for X11 rgb file)
3873 AC_ARG_WITH(x11-rgb,
3874         [  --with-x11-rgb=FILE   file containing X11 rgb information (EPREFIX/lib/X11/rgb.txt)],
3875         [RGB_PATH=$withval],
3876         [RGB_PATH=auto])
3877
3878 if test "x[$]RGB_PATH" = xauto
3879 then
3880         RGB_PATH='${exec_prefix}/lib/X11/rgb.txt'
3881         for cf_path in \
3882                 /opt/local/share/X11/rgb.txt \
3883                 /opt/X11/share/X11/rgb.txt \
3884                 /usr/share/X11/rgb.txt \
3885                 /usr/X11/share/X11/rgb.txt \
3886                 /usr/X11/lib/X11/rgb.txt \
3887                 /usr/lib/X11/rgb.txt \
3888                 /etc/X11/rgb.txt \
3889                 /usr/pkg/lib/X11/rgb.txt \
3890                 /usr/X11R7/lib/X11/rgb.txt \
3891                 /usr/X11R6/lib/X11/rgb.txt \
3892                 /usr/X11R5/lib/X11/rgb.txt \
3893                 /usr/X11R4/lib/X11/rgb.txt \
3894                 /usr/local/lib/X11/rgb.txt \
3895                 /usr/local/share/X11/rgb.txt \
3896                 /usr/lib64/X11/rgb.txt
3897         do
3898                 if test -f "$cf_path" ; then
3899                         RGB_PATH="$cf_path"
3900                         break
3901                 fi
3902         done
3903 else
3904         cf_path=$RGB_PATH
3905         CF_PATH_SYNTAX(cf_path)
3906 fi
3907
3908 AC_MSG_RESULT($RGB_PATH)
3909 AC_SUBST(RGB_PATH)
3910 AC_DEFINE_UNQUOTED(RGB_PATH,"$cf_path",[Define to the full pathname of rgb.txt])
3911
3912 no_x11_rgb=
3913 if test "$RGB_PATH" = no
3914 then
3915         no_x11_rgb="#"
3916 fi
3917 AC_SUBST(no_x11_rgb)
3918 ])dnl
3919 dnl ---------------------------------------------------------------------------
3920 dnl CF_XOPEN_CURSES version: 14 updated: 2018/06/20 20:23:13
3921 dnl ---------------
3922 dnl Test if we should define X/Open source for curses, needed on Digital Unix
3923 dnl 4.x, to see the extended functions, but breaks on IRIX 6.x.
3924 dnl
3925 dnl The getbegyx() check is needed for HPUX, which omits legacy macros such
3926 dnl as getbegy().  The latter is better design, but the former is standard.
3927 AC_DEFUN([CF_XOPEN_CURSES],
3928 [
3929 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
3930 AC_CACHE_CHECK(definition to turn on extended curses functions,cf_cv_need_xopen_extension,[
3931 cf_cv_need_xopen_extension=unknown
3932 AC_TRY_LINK([
3933 #include <stdlib.h>
3934 #include <${cf_cv_ncurses_header:-curses.h}>],[
3935 #if defined(NCURSES_VERSION_PATCH)
3936 #if (NCURSES_VERSION_PATCH < 20100501) && (NCURSES_VERSION_PATCH >= 20100403)
3937         make an error
3938 #endif
3939 #endif
3940 #ifdef NCURSES_VERSION
3941         cchar_t check;
3942         int check2 = curs_set((int)sizeof(check));
3943 #endif
3944         long x = winnstr(stdscr, "", 0);
3945         int x1, y1;
3946         getbegyx(stdscr, y1, x1)],
3947         [cf_cv_need_xopen_extension=none],
3948         [
3949         for cf_try_xopen_extension in _XOPEN_SOURCE_EXTENDED NCURSES_WIDECHAR
3950         do
3951                 AC_TRY_LINK([
3952 #define $cf_try_xopen_extension 1
3953 #include <stdlib.h>
3954 #include <${cf_cv_ncurses_header:-curses.h}>],[
3955 #ifdef NCURSES_VERSION
3956                 cchar_t check;
3957                 int check2 = curs_set((int)sizeof(check));
3958 #endif
3959                 long x = winnstr(stdscr, "", 0);
3960                 int x1, y1;
3961                 getbegyx(stdscr, y1, x1)],
3962                 [cf_cv_need_xopen_extension=$cf_try_xopen_extension; break])
3963         done
3964         ])
3965 ])
3966
3967 case $cf_cv_need_xopen_extension in
3968 (*_*)
3969         CF_APPEND_TEXT(CPPFLAGS,-D$cf_cv_need_xopen_extension)
3970         ;;
3971 esac
3972
3973 ])dnl
3974 dnl ---------------------------------------------------------------------------
3975 dnl CF_XOPEN_SOURCE version: 55 updated: 2018/12/31 20:46:17
3976 dnl ---------------
3977 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
3978 dnl or adapt to the vendor's definitions to get equivalent functionality,
3979 dnl without losing the common non-POSIX features.
3980 dnl
3981 dnl Parameters:
3982 dnl     $1 is the nominal value for _XOPEN_SOURCE
3983 dnl     $2 is the nominal value for _POSIX_C_SOURCE
3984 AC_DEFUN([CF_XOPEN_SOURCE],[
3985 AC_REQUIRE([AC_CANONICAL_HOST])
3986 AC_REQUIRE([CF_POSIX_VISIBLE])
3987
3988 if test "$cf_cv_posix_visible" = no; then
3989
3990 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
3991 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
3992 cf_xopen_source=
3993
3994 case $host_os in
3995 (aix[[4-7]]*)
3996         cf_xopen_source="-D_ALL_SOURCE"
3997         ;;
3998 (msys)
3999         cf_XOPEN_SOURCE=600
4000         ;;
4001 (darwin[[0-8]].*)
4002         cf_xopen_source="-D_APPLE_C_SOURCE"
4003         ;;
4004 (darwin*)
4005         cf_xopen_source="-D_DARWIN_C_SOURCE"
4006         cf_XOPEN_SOURCE=
4007         ;;
4008 (freebsd*|dragonfly*|midnightbsd*)
4009         # 5.x headers associate
4010         #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
4011         #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
4012         cf_POSIX_C_SOURCE=200112L
4013         cf_XOPEN_SOURCE=600
4014         cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
4015         ;;
4016 (hpux11*)
4017         cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
4018         ;;
4019 (hpux*)
4020         cf_xopen_source="-D_HPUX_SOURCE"
4021         ;;
4022 (irix[[56]].*)
4023         cf_xopen_source="-D_SGI_SOURCE"
4024         cf_XOPEN_SOURCE=
4025         ;;
4026 (linux*|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin)
4027         CF_GNU_SOURCE($cf_XOPEN_SOURCE)
4028         ;;
4029 (minix*)
4030         cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
4031         ;;
4032 (mirbsd*)
4033         # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
4034         cf_XOPEN_SOURCE=
4035         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4036         ;;
4037 (netbsd*)
4038         cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
4039         ;;
4040 (openbsd[[4-9]]*)
4041         # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
4042         cf_xopen_source="-D_BSD_SOURCE"
4043         cf_XOPEN_SOURCE=600
4044         ;;
4045 (openbsd*)
4046         # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
4047         ;;
4048 (osf[[45]]*)
4049         cf_xopen_source="-D_OSF_SOURCE"
4050         ;;
4051 (nto-qnx*)
4052         cf_xopen_source="-D_QNX_SOURCE"
4053         ;;
4054 (sco*)
4055         # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
4056         ;;
4057 (solaris2.*)
4058         cf_xopen_source="-D__EXTENSIONS__"
4059         cf_cv_xopen_source=broken
4060         ;;
4061 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
4062         cf_XOPEN_SOURCE=
4063         cf_POSIX_C_SOURCE=
4064         ;;
4065 (*)
4066         CF_TRY_XOPEN_SOURCE
4067         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4068         ;;
4069 esac
4070
4071 if test -n "$cf_xopen_source" ; then
4072         CF_ADD_CFLAGS($cf_xopen_source,true)
4073 fi
4074
4075 dnl In anything but the default case, we may have system-specific setting
4076 dnl which is still not guaranteed to provide all of the entrypoints that
4077 dnl _XOPEN_SOURCE would yield.
4078 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
4079         AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
4080         AC_TRY_COMPILE([#include <stdlib.h>],[
4081 #ifndef _XOPEN_SOURCE
4082 make an error
4083 #endif],
4084         [cf_XOPEN_SOURCE_set=yes],
4085         [cf_XOPEN_SOURCE_set=no])
4086         AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
4087         if test $cf_XOPEN_SOURCE_set = yes
4088         then
4089                 AC_TRY_COMPILE([#include <stdlib.h>],[
4090 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
4091 make an error
4092 #endif],
4093                 [cf_XOPEN_SOURCE_set_ok=yes],
4094                 [cf_XOPEN_SOURCE_set_ok=no])
4095                 if test $cf_XOPEN_SOURCE_set_ok = no
4096                 then
4097                         AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
4098                 fi
4099         else
4100                 CF_TRY_XOPEN_SOURCE
4101         fi
4102 fi
4103 fi # cf_cv_posix_visible
4104 ])
4105 dnl ---------------------------------------------------------------------------
4106 dnl CF_X_ATHENA version: 23 updated: 2015/04/12 15:39:00
4107 dnl -----------
4108 dnl Check for Xaw (Athena) libraries
4109 dnl
4110 dnl Sets $cf_x_athena according to the flavor of Xaw which is used.
4111 AC_DEFUN([CF_X_ATHENA],
4112 [
4113 cf_x_athena=${cf_x_athena:-Xaw}
4114
4115 AC_MSG_CHECKING(if you want to link with Xaw 3d library)
4116 withval=
4117 AC_ARG_WITH(Xaw3d,
4118         [  --with-Xaw3d            link with Xaw 3d library])
4119 if test "$withval" = yes ; then
4120         cf_x_athena=Xaw3d
4121         AC_MSG_RESULT(yes)
4122 else
4123         AC_MSG_RESULT(no)
4124 fi
4125
4126 AC_MSG_CHECKING(if you want to link with Xaw 3d xft library)
4127 withval=
4128 AC_ARG_WITH(Xaw3dxft,
4129         [  --with-Xaw3dxft         link with Xaw 3d xft library])
4130 if test "$withval" = yes ; then
4131         cf_x_athena=Xaw3dxft
4132         AC_MSG_RESULT(yes)
4133 else
4134         AC_MSG_RESULT(no)
4135 fi
4136
4137 AC_MSG_CHECKING(if you want to link with neXT Athena library)
4138 withval=
4139 AC_ARG_WITH(neXtaw,
4140         [  --with-neXtaw           link with neXT Athena library])
4141 if test "$withval" = yes ; then
4142         cf_x_athena=neXtaw
4143         AC_MSG_RESULT(yes)
4144 else
4145         AC_MSG_RESULT(no)
4146 fi
4147
4148 AC_MSG_CHECKING(if you want to link with Athena-Plus library)
4149 withval=
4150 AC_ARG_WITH(XawPlus,
4151         [  --with-XawPlus          link with Athena-Plus library])
4152 if test "$withval" = yes ; then
4153         cf_x_athena=XawPlus
4154         AC_MSG_RESULT(yes)
4155 else
4156         AC_MSG_RESULT(no)
4157 fi
4158
4159 cf_x_athena_lib=""
4160
4161 if test "$PKG_CONFIG" != none ; then
4162         cf_athena_list=
4163         test "$cf_x_athena" = Xaw && cf_athena_list="xaw8 xaw7 xaw6"
4164         for cf_athena_pkg in \
4165                 $cf_athena_list \
4166                 ${cf_x_athena} \
4167                 ${cf_x_athena}-devel \
4168                 lib${cf_x_athena} \
4169                 lib${cf_x_athena}-devel
4170         do
4171                 CF_TRY_PKG_CONFIG($cf_athena_pkg,[
4172                         cf_x_athena_lib="$cf_pkgconfig_libs"
4173                         CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
4174                         AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
4175
4176                         CF_TRIM_X_LIBS
4177
4178 AC_CACHE_CHECK(for usable $cf_x_athena/Xmu package,cf_cv_xaw_compat,[
4179 AC_TRY_LINK([
4180 #include <X11/Xmu/CharSet.h>
4181 ],[
4182 int check = XmuCompareISOLatin1("big", "small")
4183 ],[cf_cv_xaw_compat=yes],[cf_cv_xaw_compat=no])])
4184
4185                         if test "$cf_cv_xaw_compat" = no
4186                         then
4187                                 # workaround for broken ".pc" files...
4188                                 case "$cf_x_athena_lib" in
4189                                 (*-lXmu*)
4190                                         ;;
4191                                 (*)
4192                                         CF_VERBOSE(work around broken package)
4193                                         cf_save_xmu="$LIBS"
4194                                         cf_first_lib=`echo "$cf_save_xmu" | sed -e 's/^[ ][ ]*//' -e 's/ .*//'`
4195                                         CF_TRY_PKG_CONFIG(xmu,[
4196                                                         LIBS="$cf_save_xmu"
4197                                                         CF_ADD_LIB_AFTER($cf_first_lib,$cf_pkgconfig_libs)
4198                                                 ],[
4199                                                         CF_ADD_LIB_AFTER($cf_first_lib,-lXmu)
4200                                                 ])
4201                                         CF_TRIM_X_LIBS
4202                                         ;;
4203                                 esac
4204                         fi
4205
4206                         break])
4207         done
4208 fi
4209
4210 if test -z "$cf_x_athena_lib" ; then
4211         CF_X_EXT
4212         CF_X_TOOLKIT
4213         CF_X_ATHENA_CPPFLAGS($cf_x_athena)
4214         CF_X_ATHENA_LIBS($cf_x_athena)
4215 fi
4216 ])dnl
4217 dnl ---------------------------------------------------------------------------
4218 dnl CF_X_ATHENA_CPPFLAGS version: 8 updated: 2020/01/16 05:21:56
4219 dnl --------------------
4220 dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
4221 dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
4222 AC_DEFUN([CF_X_ATHENA_CPPFLAGS],
4223 [
4224 AC_REQUIRE([AC_PATH_XTRA])
4225 cf_x_athena_root=ifelse([$1],,Xaw,[$1])
4226 cf_x_athena_inc=""
4227
4228 for cf_path in default \
4229         /usr/contrib/X11R6 \
4230         /usr/contrib/X11R5 \
4231         /usr/lib/X11R5 \
4232         /usr/local
4233 do
4234         if test -z "$cf_x_athena_inc" ; then
4235                 CF_SAVE_XTRA_FLAGS([CF_X_ATHENA_CPPFLAGS])
4236                 cf_test=X11/$cf_x_athena_root/SimpleMenu.h
4237                 if test $cf_path != default ; then
4238                         CF_APPEND_TEXT(CPPFLAGS,-I$cf_path/include)
4239                         AC_MSG_CHECKING(for $cf_test in $cf_path)
4240                 else
4241                         AC_MSG_CHECKING(for $cf_test)
4242                 fi
4243                 AC_TRY_COMPILE([
4244 #include <X11/Intrinsic.h>
4245 #include <$cf_test>],[],
4246                         [cf_result=yes],
4247                         [cf_result=no])
4248                 AC_MSG_RESULT($cf_result)
4249                 CF_RESTORE_XTRA_FLAGS([CF_X_ATHENA_CPPFLAGS])
4250                 if test "$cf_result" = yes ; then
4251                         test "$cf_path"  = default && cf_x_athena_inc=default
4252                         test "$cf_path" != default && cf_x_athena_inc=$cf_path/include
4253                         break
4254                 fi
4255         fi
4256 done
4257
4258 if test -z "$cf_x_athena_inc" ; then
4259         AC_MSG_WARN([Unable to find Athena header files])
4260 elif test "$cf_x_athena_inc" != default ; then
4261         CF_APPEND_TEXT(CPPFLAGS,-I$cf_x_athena_inc)
4262 fi
4263 ])
4264 dnl ---------------------------------------------------------------------------
4265 dnl CF_X_ATHENA_LIBS version: 13 updated: 2020/01/11 18:16:10
4266 dnl ----------------
4267 dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
4268 dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
4269 AC_DEFUN([CF_X_ATHENA_LIBS],
4270 [AC_REQUIRE([CF_X_TOOLKIT])
4271 cf_x_athena_root=ifelse([$1],,Xaw,[$1])
4272 cf_x_athena_lib=""
4273
4274 for cf_path in default \
4275         /usr/contrib/X11R6 \
4276         /usr/contrib/X11R5 \
4277         /usr/lib/X11R5 \
4278         /usr/local
4279 do
4280         for cf_lib in \
4281                 ${cf_x_athena_root} \
4282                 ${cf_x_athena_root}7 \
4283                 ${cf_x_athena_root}6
4284         do
4285         for cf_libs in \
4286                 "-l$cf_lib -lXmu" \
4287                 "-l$cf_lib -lXpm -lXmu" \
4288                 "-l${cf_lib}_s -lXmu_s"
4289         do
4290                 test -n "$cf_x_athena_lib" && break
4291
4292                 CF_SAVE_XTRA_FLAGS([CF_X_ATHENA_LIBS])
4293                 cf_test=XawSimpleMenuAddGlobalActions
4294                 test "$cf_path" != default && cf_libs="-L$cf_path/lib $cf_libs"
4295                 CF_ADD_LIBS($cf_libs)
4296                 AC_MSG_CHECKING(for $cf_test in $cf_libs)
4297                 AC_TRY_LINK([
4298 #include <X11/Intrinsic.h>
4299 #include <X11/$cf_x_athena_root/SimpleMenu.h>
4300 ],[
4301 $cf_test((XtAppContext) 0)],
4302                         [cf_result=yes],
4303                         [cf_result=no])
4304                 AC_MSG_RESULT($cf_result)
4305                 CF_RESTORE_XTRA_FLAGS([CF_X_ATHENA_LIBS])
4306
4307                 if test "$cf_result" = yes ; then
4308                         cf_x_athena_lib="$cf_libs"
4309                         break
4310                 fi
4311         done # cf_libs
4312                 test -n "$cf_x_athena_lib" && break
4313         done # cf_lib
4314 done
4315
4316 if test -z "$cf_x_athena_lib" ; then
4317         AC_MSG_ERROR(
4318 [Unable to successfully link Athena library (-l$cf_x_athena_root) with test program])
4319 fi
4320
4321 CF_ADD_LIBS($cf_x_athena_lib)
4322 CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
4323 AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
4324 ])
4325 dnl ---------------------------------------------------------------------------
4326 dnl CF_X_EXT version: 3 updated: 2010/06/02 05:03:05
4327 dnl --------
4328 AC_DEFUN([CF_X_EXT],[
4329 CF_TRY_PKG_CONFIG(Xext,,[
4330         AC_CHECK_LIB(Xext,XextCreateExtension,
4331                 [CF_ADD_LIB(Xext)])])
4332 ])dnl
4333 dnl ---------------------------------------------------------------------------
4334 dnl CF_X_TOOLKIT version: 24 updated: 2019/03/23 19:54:44
4335 dnl ------------
4336 dnl Check for X Toolkit libraries
4337 AC_DEFUN([CF_X_TOOLKIT],
4338 [
4339 AC_REQUIRE([AC_PATH_XTRA])
4340 AC_REQUIRE([CF_CHECK_CACHE])
4341
4342 # OSX is schizoid about who owns /usr/X11 (old) versus /opt/X11 (new) (and
4343 # in some cases has installed dummy files in the former, other cases replaced
4344 # it with a link to the new location).  This complicates the configure script.
4345 # Check for that pitfall, and recover using pkg-config
4346 #
4347 # If none of these are set, the configuration is almost certainly broken.
4348 if test -z "${X_CFLAGS}${X_PRE_LIBS}${X_LIBS}${X_EXTRA_LIBS}"
4349 then
4350         CF_TRY_PKG_CONFIG(x11,,[AC_MSG_WARN(unable to find X11 library)])
4351         CF_TRY_PKG_CONFIG(ice,,[AC_MSG_WARN(unable to find ICE library)])
4352         CF_TRY_PKG_CONFIG(sm,,[AC_MSG_WARN(unable to find SM library)])
4353         CF_TRY_PKG_CONFIG(xt,,[AC_MSG_WARN(unable to find Xt library)])
4354 fi
4355
4356 cf_have_X_LIBS=no
4357
4358 CF_TRY_PKG_CONFIG(xt,[
4359
4360         case "x$LIBS" in
4361         (*-lX11*)
4362                 ;;
4363         (*)
4364 # we have an "xt" package, but it may omit Xt's dependency on X11
4365 AC_CACHE_CHECK(for usable X dependency,cf_cv_xt_x11_compat,[
4366 AC_TRY_LINK([
4367 #include <X11/Xlib.h>
4368 ],[
4369         int rc1 = XDrawLine((Display*) 0, (Drawable) 0, (GC) 0, 0, 0, 0, 0);
4370         int rc2 = XClearWindow((Display*) 0, (Window) 0);
4371         int rc3 = XMoveWindow((Display*) 0, (Window) 0, 0, 0);
4372         int rc4 = XMoveResizeWindow((Display*)0, (Window)0, 0, 0, 0, 0);
4373 ],[cf_cv_xt_x11_compat=yes],[cf_cv_xt_x11_compat=no])])
4374                 if test "$cf_cv_xt_x11_compat" = no
4375                 then
4376                         CF_VERBOSE(work around broken X11 dependency)
4377                         # 2010/11/19 - good enough until a working Xt on Xcb is delivered.
4378                         CF_TRY_PKG_CONFIG(x11,,[CF_ADD_LIB_AFTER(-lXt,-lX11)])
4379                 fi
4380                 ;;
4381         esac
4382
4383 AC_CACHE_CHECK(for usable X Toolkit package,cf_cv_xt_ice_compat,[
4384 AC_TRY_LINK([
4385 #include <X11/Shell.h>
4386 ],[int num = IceConnectionNumber(0)
4387 ],[cf_cv_xt_ice_compat=yes],[cf_cv_xt_ice_compat=no])])
4388
4389         if test "$cf_cv_xt_ice_compat" = no
4390         then
4391                 # workaround for broken ".pc" files used for X Toolkit.
4392                 case "x$X_PRE_LIBS" in
4393                 (*-lICE*)
4394                         case "x$LIBS" in
4395                         (*-lICE*)
4396                                 ;;
4397                         (*)
4398                                 CF_VERBOSE(work around broken ICE dependency)
4399                                 CF_TRY_PKG_CONFIG(ice,
4400                                         [CF_TRY_PKG_CONFIG(sm)],
4401                                         [CF_ADD_LIB_AFTER(-lXt,$X_PRE_LIBS)])
4402                                 ;;
4403                         esac
4404                         ;;
4405                 esac
4406         fi
4407
4408         cf_have_X_LIBS=yes
4409 ],[
4410
4411         LDFLAGS="$X_LIBS $LDFLAGS"
4412         CF_CHECK_CFLAGS($X_CFLAGS)
4413
4414         AC_CHECK_FUNC(XOpenDisplay,,[
4415         AC_CHECK_LIB(X11,XOpenDisplay,
4416                 [CF_ADD_LIB(X11)],,
4417                 [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])])
4418
4419         AC_CHECK_FUNC(XtAppInitialize,,[
4420         AC_CHECK_LIB(Xt, XtAppInitialize,
4421                 [AC_DEFINE(HAVE_LIBXT,1,[Define to 1 if we can compile with the Xt library])
4422                  cf_have_X_LIBS=Xt
4423                  LIBS="-lXt $X_PRE_LIBS $LIBS $X_EXTRA_LIBS"],,
4424                 [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])])
4425 ])
4426
4427 if test $cf_have_X_LIBS = no ; then
4428         AC_MSG_WARN(
4429 [Unable to successfully link X Toolkit library (-lXt) with
4430 test program.  You will have to check and add the proper libraries by hand
4431 to makefile.])
4432 fi
4433 ])dnl
4434 dnl ---------------------------------------------------------------------------
4435 dnl CF__CURSES_DATA version: 2 updated: 2020/02/08 21:00:26
4436 dnl ---------------
4437 dnl Attempt to make a copy of a curses data item.  This is needed in the
4438 dnl check-data configure tests when using ncurses, because the symbol may be
4439 dnl actually a function return-value.  That could happen if the linker is
4440 dnl broken (does not resolve data-only references), or if ncurses is configured
4441 dnl to support re-entrant code.
4442 dnl $1 = target
4443 dnl $2 = source
4444 define([CF__CURSES_DATA],[
4445 #if defined($2) && ((defined(NCURSES_WRAPPED_VAR) && (NCURSES_VERSION_PATCH < 20200208)) || defined(NCURSES_BROKEN_LINKER) || defined(NCURSES_REENTRANT))
4446         const void *$1 = (const void *)($2);
4447 #else
4448         const void *$1 = &($2);
4449 #endif
4450         fprintf(stderr, "testing linkage of $2:%p\n", (const void *)$1);
4451 ])dnl
4452 dnl ---------------------------------------------------------------------------
4453 dnl CF__CURSES_HEAD version: 2 updated: 2010/10/23 15:54:49
4454 dnl ---------------
4455 dnl Define a reusable chunk which includes <curses.h> and <term.h> when they
4456 dnl are both available.
4457 define([CF__CURSES_HEAD],[
4458 #ifdef HAVE_XCURSES
4459 #include <xcurses.h>
4460 char * XCursesProgramName = "test";
4461 #else
4462 #include <${cf_cv_ncurses_header:-curses.h}>
4463 #if defined(NCURSES_VERSION) && defined(HAVE_NCURSESW_TERM_H)
4464 #include <ncursesw/term.h>
4465 #elif defined(NCURSES_VERSION) && defined(HAVE_NCURSES_TERM_H)
4466 #include <ncurses/term.h>
4467 #elif defined(HAVE_TERM_H)
4468 #include <term.h>
4469 #endif
4470 #endif
4471 ])