test/aclocal.m4

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