test/aclocal.m4

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