test/aclocal.m4

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