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