test/aclocal.m4

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