test/aclocal.m4

   1 dnl***************************************************************************
   2 dnl Copyright (c) 2003-2015,2016 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.135 2016/09/10 22:09:38 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: 4 updated: 2016/09/10 15:33:21
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_CHECK_LIB(bsd,strlcat,[
1150                         CF_ADD_LIB(bsd)
1151                         AC_CHECK_HEADERS(bsd/string.h)
1152                         AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
1153                         ])
1154                 ])
1155         AC_CHECK_FUNCS( strlcpy snprintf )
1156 fi
1157 ])dnl
1158 dnl ---------------------------------------------------------------------------
1159 dnl CF_ENABLE_WARNINGS version: 4 updated: 2009/07/26 17:53:03
1160 dnl ------------------
1161 dnl Configure-option to enable gcc warnings
1162 AC_DEFUN([CF_ENABLE_WARNINGS],[
1163 if ( test "$GCC" = yes || test "$GXX" = yes )
1164 then
1165 AC_MSG_CHECKING(if you want to turn on gcc warnings)
1166 CF_ARG_ENABLE(warnings,
1167         [  --enable-warnings       test: turn on gcc compiler warnings],
1168         [with_warnings=yes],
1169         [with_warnings=no])
1170 AC_MSG_RESULT($with_warnings)
1171 if test "$with_warnings" = "yes"
1172 then
1173         CF_GCC_ATTRIBUTES
1174         CF_GCC_WARNINGS
1175 fi
1176 fi
1177 ])dnl
1178 dnl ---------------------------------------------------------------------------
1179 dnl CF_FIND_LIBRARY version: 9 updated: 2008/03/23 14:48:54
1180 dnl ---------------
1181 dnl Look for a non-standard library, given parameters for AC_TRY_LINK.  We
1182 dnl prefer a standard location, and use -L options only if we do not find the
1183 dnl library in the standard library location(s).
1184 dnl     $1 = library name
1185 dnl     $2 = library class, usually the same as library name
1186 dnl     $3 = includes
1187 dnl     $4 = code fragment to compile/link
1188 dnl     $5 = corresponding function-name
1189 dnl     $6 = flag, nonnull if failure should not cause an error-exit
1190 dnl
1191 dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had
1192 dnl to use a -L option.
1193 AC_DEFUN([CF_FIND_LIBRARY],
1194 [
1195         eval 'cf_cv_have_lib_'$1'=no'
1196         cf_libdir=""
1197         AC_CHECK_FUNC($5,
1198                 eval 'cf_cv_have_lib_'$1'=yes',[
1199                 cf_save_LIBS="$LIBS"
1200                 AC_MSG_CHECKING(for $5 in -l$1)
1201                 LIBS="-l$1 $LIBS"
1202                 AC_TRY_LINK([$3],[$4],
1203                         [AC_MSG_RESULT(yes)
1204                          eval 'cf_cv_have_lib_'$1'=yes'
1205                         ],
1206                         [AC_MSG_RESULT(no)
1207                         CF_LIBRARY_PATH(cf_search,$2)
1208                         for cf_libdir in $cf_search
1209                         do
1210                                 AC_MSG_CHECKING(for -l$1 in $cf_libdir)
1211                                 LIBS="-L$cf_libdir -l$1 $cf_save_LIBS"
1212                                 AC_TRY_LINK([$3],[$4],
1213                                         [AC_MSG_RESULT(yes)
1214                                          eval 'cf_cv_have_lib_'$1'=yes'
1215                                          break],
1216                                         [AC_MSG_RESULT(no)
1217                                          LIBS="$cf_save_LIBS"])
1218                         done
1219                         ])
1220                 ])
1221 eval 'cf_found_library=[$]cf_cv_have_lib_'$1
1222 ifelse($6,,[
1223 if test $cf_found_library = no ; then
1224         AC_MSG_ERROR(Cannot link $1 library)
1225 fi
1226 ])
1227 ])dnl
1228 dnl ---------------------------------------------------------------------------
1229 dnl CF_FIND_LINKAGE version: 20 updated: 2015/04/18 08:56:57
1230 dnl ---------------
1231 dnl Find a library (specifically the linkage used in the code fragment),
1232 dnl searching for it if it is not already in the library path.
1233 dnl See also CF_ADD_SEARCHPATH.
1234 dnl
1235 dnl Parameters (4-on are optional):
1236 dnl     $1 = headers for library entrypoint
1237 dnl     $2 = code fragment for library entrypoint
1238 dnl     $3 = the library name without the "-l" option or ".so" suffix.
1239 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
1240 dnl     $5 = action to perform if not successful
1241 dnl     $6 = module name, if not the same as the library name
1242 dnl     $7 = extra libraries
1243 dnl
1244 dnl Sets these variables:
1245 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1246 dnl     $cf_cv_header_path_$3 - include-directory if needed
1247 dnl     $cf_cv_library_path_$3 - library-directory if needed
1248 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1249 AC_DEFUN([CF_FIND_LINKAGE],[
1250
1251 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1252 # will be set on completion of the AC_TRY_LINK below.
1253 cf_cv_header_path_$3=
1254 cf_cv_library_path_$3=
1255
1256 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1257
1258 cf_save_LIBS="$LIBS"
1259
1260 AC_TRY_LINK([$1],[$2],[
1261         cf_cv_find_linkage_$3=yes
1262         cf_cv_header_path_$3=/usr/include
1263         cf_cv_library_path_$3=/usr/lib
1264 ],[
1265
1266 LIBS="-l$3 $7 $cf_save_LIBS"
1267
1268 AC_TRY_LINK([$1],[$2],[
1269         cf_cv_find_linkage_$3=yes
1270         cf_cv_header_path_$3=/usr/include
1271         cf_cv_library_path_$3=/usr/lib
1272         cf_cv_library_file_$3="-l$3"
1273 ],[
1274         cf_cv_find_linkage_$3=no
1275         LIBS="$cf_save_LIBS"
1276
1277         CF_VERBOSE(find linkage for $3 library)
1278         CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1279
1280         cf_save_CPPFLAGS="$CPPFLAGS"
1281         cf_test_CPPFLAGS="$CPPFLAGS"
1282
1283         CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1284         for cf_cv_header_path_$3 in $cf_search
1285         do
1286                 if test -d $cf_cv_header_path_$3 ; then
1287                         CF_VERBOSE(... testing $cf_cv_header_path_$3)
1288                         CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
1289                         AC_TRY_COMPILE([$1],[$2],[
1290                                 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1291                                 cf_cv_find_linkage_$3=maybe
1292                                 cf_test_CPPFLAGS="$CPPFLAGS"
1293                                 break],[
1294                                 CPPFLAGS="$cf_save_CPPFLAGS"
1295                                 ])
1296                 fi
1297         done
1298
1299         if test "$cf_cv_find_linkage_$3" = maybe ; then
1300
1301                 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1302
1303                 cf_save_LIBS="$LIBS"
1304                 cf_save_LDFLAGS="$LDFLAGS"
1305
1306                 ifelse([$6],,,[
1307                 CPPFLAGS="$cf_test_CPPFLAGS"
1308                 LIBS="-l$3 $7 $cf_save_LIBS"
1309                 AC_TRY_LINK([$1],[$2],[
1310                         CF_VERBOSE(... found $3 library in system)
1311                         cf_cv_find_linkage_$3=yes])
1312                         CPPFLAGS="$cf_save_CPPFLAGS"
1313                         LIBS="$cf_save_LIBS"
1314                         ])
1315
1316                 if test "$cf_cv_find_linkage_$3" != yes ; then
1317                         CF_LIBRARY_PATH(cf_search,$3)
1318                         for cf_cv_library_path_$3 in $cf_search
1319                         do
1320                                 if test -d $cf_cv_library_path_$3 ; then
1321                                         CF_VERBOSE(... testing $cf_cv_library_path_$3)
1322                                         CPPFLAGS="$cf_test_CPPFLAGS"
1323                                         LIBS="-l$3 $7 $cf_save_LIBS"
1324                                         LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1325                                         AC_TRY_LINK([$1],[$2],[
1326                                         CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1327                                         cf_cv_find_linkage_$3=yes
1328                                         cf_cv_library_file_$3="-l$3"
1329                                         break],[
1330                                         CPPFLAGS="$cf_save_CPPFLAGS"
1331                                         LIBS="$cf_save_LIBS"
1332                                         LDFLAGS="$cf_save_LDFLAGS"
1333                                         ])
1334                                 fi
1335                         done
1336                         CPPFLAGS="$cf_save_CPPFLAGS"
1337                         LDFLAGS="$cf_save_LDFLAGS"
1338                 fi
1339
1340         else
1341                 cf_cv_find_linkage_$3=no
1342         fi
1343         ],$7)
1344 ])
1345
1346 LIBS="$cf_save_LIBS"
1347
1348 if test "$cf_cv_find_linkage_$3" = yes ; then
1349 ifelse([$4],,[
1350         CF_ADD_INCDIR($cf_cv_header_path_$3)
1351         CF_ADD_LIBDIR($cf_cv_library_path_$3)
1352         CF_ADD_LIB($3)
1353 ],[$4])
1354 else
1355 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1356 fi
1357 ])dnl
1358 dnl ---------------------------------------------------------------------------
1359 dnl CF_FUNC_CURSES_VERSION version: 6 updated: 2012/10/06 16:39:58
1360 dnl ----------------------
1361 dnl Solaris has a data item 'curses_version', which confuses AC_CHECK_FUNCS.
1362 dnl It's a character string "SVR4", not documented.
1363 AC_DEFUN([CF_FUNC_CURSES_VERSION],
1364 [
1365 AC_CACHE_CHECK(for function curses_version, cf_cv_func_curses_version,[
1366 AC_TRY_RUN([
1367 #include <${cf_cv_ncurses_header:-curses.h}>
1368 int main()
1369 {
1370         char temp[1024];
1371         sprintf(temp, "%s\n", curses_version());
1372         ${cf_cv_main_return:-return}(0);
1373 }]
1374 ,[cf_cv_func_curses_version=yes]
1375 ,[cf_cv_func_curses_version=no]
1376 ,[cf_cv_func_curses_version=unknown])
1377 rm -f core])
1378 test "$cf_cv_func_curses_version" = yes && AC_DEFINE(HAVE_CURSES_VERSION,1,[Define to 1 if we have curses_version function])
1379 ])
1380 dnl ---------------------------------------------------------------------------
1381 dnl CF_FUNC_OPENPTY version: 5 updated: 2015/09/12 14:46:50
1382 dnl ---------------
1383 dnl Check for openpty() function, along with <pty.h> header.  It may need the
1384 dnl "util" library as well.
1385 AC_DEFUN([CF_FUNC_OPENPTY],
1386 [
1387 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1388 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1389         cf_save_LIBS="$LIBS"
1390         test $cf_cv_lib_util = yes && { CF_ADD_LIB(util) }
1391         for cf_header in pty.h libutil.h util.h
1392         do
1393         AC_TRY_LINK([
1394 #include <$cf_header>
1395 ],[
1396         int x = openpty((int *)0, (int *)0, (char *)0,
1397                                    (struct termios *)0, (struct winsize *)0);
1398 ],[
1399                 cf_cv_func_openpty=$cf_header
1400                 break
1401 ],[
1402                 cf_cv_func_openpty=no
1403 ])
1404         done
1405         LIBS="$cf_save_LIBS"
1406 ])
1407 ])dnl
1408 dnl ---------------------------------------------------------------------------
1409 dnl CF_GCC_ATTRIBUTES version: 17 updated: 2015/04/12 15:39:00
1410 dnl -----------------
1411 dnl Test for availability of useful gcc __attribute__ directives to quiet
1412 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1413 dnl to documentation, unrecognized directives cause older compilers to barf.
1414 AC_DEFUN([CF_GCC_ATTRIBUTES],
1415 [
1416 if test "$GCC" = yes
1417 then
1418 cat > conftest.i <<EOF
1419 #ifndef GCC_PRINTF
1420 #define GCC_PRINTF 0
1421 #endif
1422 #ifndef GCC_SCANF
1423 #define GCC_SCANF 0
1424 #endif
1425 #ifndef GCC_NORETURN
1426 #define GCC_NORETURN /* nothing */
1427 #endif
1428 #ifndef GCC_UNUSED
1429 #define GCC_UNUSED /* nothing */
1430 #endif
1431 EOF
1432 if test "$GCC" = yes
1433 then
1434         AC_CHECKING([for $CC __attribute__ directives])
1435 cat > conftest.$ac_ext <<EOF
1436 #line __oline__ "${as_me:-configure}"
1437 #include "confdefs.h"
1438 #include "conftest.h"
1439 #include "conftest.i"
1440 #if     GCC_PRINTF
1441 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1442 #else
1443 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1444 #endif
1445 #if     GCC_SCANF
1446 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1447 #else
1448 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1449 #endif
1450 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1451 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1452 extern void foo(void) GCC_NORETURN;
1453 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1454 EOF
1455         cf_printf_attribute=no
1456         cf_scanf_attribute=no
1457         for cf_attribute in scanf printf unused noreturn
1458         do
1459                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1460                 cf_directive="__attribute__(($cf_attribute))"
1461                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1462
1463                 case $cf_attribute in
1464                 (printf)
1465                         cf_printf_attribute=yes
1466                         cat >conftest.h <<EOF
1467 #define GCC_$cf_ATTRIBUTE 1
1468 EOF
1469                         ;;
1470                 (scanf)
1471                         cf_scanf_attribute=yes
1472                         cat >conftest.h <<EOF
1473 #define GCC_$cf_ATTRIBUTE 1
1474 EOF
1475                         ;;
1476                 (*)
1477                         cat >conftest.h <<EOF
1478 #define GCC_$cf_ATTRIBUTE $cf_directive
1479 EOF
1480                         ;;
1481                 esac
1482
1483                 if AC_TRY_EVAL(ac_compile); then
1484                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1485                         cat conftest.h >>confdefs.h
1486                         case $cf_attribute in
1487                         (noreturn)
1488                                 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1489                                 ;;
1490                         (printf)
1491                                 cf_value='/* nothing */'
1492                                 if test "$cf_printf_attribute" != no ; then
1493                                         cf_value='__attribute__((format(printf,fmt,var)))'
1494                                         AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1495                                 fi
1496                                 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1497                                 ;;
1498                         (scanf)
1499                                 cf_value='/* nothing */'
1500                                 if test "$cf_scanf_attribute" != no ; then
1501                                         cf_value='__attribute__((format(scanf,fmt,var)))'
1502                                         AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1503                                 fi
1504                                 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1505                                 ;;
1506                         (unused)
1507                                 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
1508                                 ;;
1509                         esac
1510                 fi
1511         done
1512 else
1513         fgrep define conftest.i >>confdefs.h
1514 fi
1515 rm -rf conftest*
1516 fi
1517 ])dnl
1518 dnl ---------------------------------------------------------------------------
1519 dnl CF_GCC_VERSION version: 7 updated: 2012/10/18 06:46:33
1520 dnl --------------
1521 dnl Find version of gcc
1522 AC_DEFUN([CF_GCC_VERSION],[
1523 AC_REQUIRE([AC_PROG_CC])
1524 GCC_VERSION=none
1525 if test "$GCC" = yes ; then
1526         AC_MSG_CHECKING(version of $CC)
1527         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.]].*//'`"
1528         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1529         AC_MSG_RESULT($GCC_VERSION)
1530 fi
1531 ])dnl
1532 dnl ---------------------------------------------------------------------------
1533 dnl CF_GCC_WARNINGS version: 32 updated: 2015/04/12 15:39:00
1534 dnl ---------------
1535 dnl Check if the compiler supports useful warning options.  There's a few that
1536 dnl we don't use, simply because they're too noisy:
1537 dnl
1538 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1539 dnl     -Wredundant-decls (system headers make this too noisy)
1540 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1541 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1542 dnl             is enabled for ncurses using "--enable-const".
1543 dnl     -pedantic
1544 dnl
1545 dnl Parameter:
1546 dnl     $1 is an optional list of gcc warning flags that a particular
1547 dnl             application might want to use, e.g., "no-unused" for
1548 dnl             -Wno-unused
1549 dnl Special:
1550 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1551 dnl
1552 AC_DEFUN([CF_GCC_WARNINGS],
1553 [
1554 AC_REQUIRE([CF_GCC_VERSION])
1555 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1556 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
1557
1558 cat > conftest.$ac_ext <<EOF
1559 #line __oline__ "${as_me:-configure}"
1560 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1561 EOF
1562
1563 if test "$INTEL_COMPILER" = yes
1564 then
1565 # The "-wdXXX" options suppress warnings:
1566 # remark #1419: external declaration in primary source file
1567 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1568 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1569 # remark #193: zero used for undefined preprocessing identifier
1570 # remark #593: variable "curs_sb_left_arrow" was set but never used
1571 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1572 # remark #869: parameter "tw" was never referenced
1573 # remark #981: operands are evaluated in unspecified order
1574 # warning #279: controlling expression is constant
1575
1576         AC_CHECKING([for $CC warning options])
1577         cf_save_CFLAGS="$CFLAGS"
1578         EXTRA_CFLAGS="-Wall"
1579         for cf_opt in \
1580                 wd1419 \
1581                 wd1683 \
1582                 wd1684 \
1583                 wd193 \
1584                 wd593 \
1585                 wd279 \
1586                 wd810 \
1587                 wd869 \
1588                 wd981
1589         do
1590                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1591                 if AC_TRY_EVAL(ac_compile); then
1592                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1593                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1594                 fi
1595         done
1596         CFLAGS="$cf_save_CFLAGS"
1597
1598 elif test "$GCC" = yes
1599 then
1600         AC_CHECKING([for $CC warning options])
1601         cf_save_CFLAGS="$CFLAGS"
1602         EXTRA_CFLAGS=
1603         cf_warn_CONST=""
1604         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1605         cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
1606         test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
1607         for cf_opt in W Wall \
1608                 Wbad-function-cast \
1609                 Wcast-align \
1610                 Wcast-qual \
1611                 Wdeclaration-after-statement \
1612                 Wextra \
1613                 Winline \
1614                 Wmissing-declarations \
1615                 Wmissing-prototypes \
1616                 Wnested-externs \
1617                 Wpointer-arith \
1618                 Wshadow \
1619                 Wstrict-prototypes \
1620                 Wundef $cf_gcc_warnings $cf_warn_CONST $1
1621         do
1622                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1623                 if AC_TRY_EVAL(ac_compile); then
1624                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1625                         case $cf_opt in
1626                         (Wcast-qual)
1627                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1628                                 ;;
1629                         (Winline)
1630                                 case $GCC_VERSION in
1631                                 ([[34]].*)
1632                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1633                                         continue;;
1634                                 esac
1635                                 ;;
1636                         (Wpointer-arith)
1637                                 case $GCC_VERSION in
1638                                 ([[12]].*)
1639                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1640                                         continue;;
1641                                 esac
1642                                 ;;
1643                         esac
1644                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1645                 fi
1646         done
1647         CFLAGS="$cf_save_CFLAGS"
1648 fi
1649 rm -rf conftest*
1650
1651 AC_SUBST(EXTRA_CFLAGS)
1652 ])dnl
1653 dnl ---------------------------------------------------------------------------
1654 dnl CF_GETOPT_HEADER version: 6 updated: 2014/07/22 14:45:54
1655 dnl ----------------
1656 dnl Check for getopt's variables which are commonly defined in stdlib.h,
1657 dnl unistd.h or (nonstandard) in getopt.h
1658 AC_DEFUN([CF_GETOPT_HEADER],
1659 [
1660 AC_HAVE_HEADERS(unistd.h getopt.h)
1661 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
1662 cf_cv_getopt_header=none
1663 for cf_header in stdio.h stdlib.h unistd.h getopt.h
1664 do
1665 AC_TRY_COMPILE([
1666 #include <$cf_header>],
1667 [int x = optind; char *y = optarg],
1668 [cf_cv_getopt_header=$cf_header
1669  break])
1670 done
1671 ])
1672 if test $cf_cv_getopt_header != none ; then
1673         AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
1674 fi
1675 if test $cf_cv_getopt_header = getopt.h ; then
1676         AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
1677 fi
1678 ])dnl
1679 dnl ---------------------------------------------------------------------------
1680 dnl CF_GNU_SOURCE version: 7 updated: 2016/08/05 05:15:37
1681 dnl -------------
1682 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1683 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1684 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1685 dnl since it is interwoven with GNU extensions.
1686 dnl
1687 dnl Well, yes we could work around it...
1688 AC_DEFUN([CF_GNU_SOURCE],
1689 [
1690 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1691 AC_TRY_COMPILE([#include <sys/types.h>],[
1692 #ifndef _XOPEN_SOURCE
1693 make an error
1694 #endif],
1695         [cf_cv_gnu_source=no],
1696         [cf_save="$CPPFLAGS"
1697          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1698          AC_TRY_COMPILE([#include <sys/types.h>],[
1699 #ifdef _XOPEN_SOURCE
1700 make an error
1701 #endif],
1702         [cf_cv_gnu_source=no],
1703         [cf_cv_gnu_source=yes])
1704         CPPFLAGS="$cf_save"
1705         ])
1706 ])
1707
1708 if test "$cf_cv_gnu_source" = yes
1709 then
1710 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
1711 CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1712         AC_TRY_COMPILE([#include <sys/types.h>],[
1713 #ifdef _DEFAULT_SOURCE
1714 make an error
1715 #endif],
1716                 [cf_cv_default_source=no],
1717                 [cf_cv_default_source=yes])
1718         ])
1719 test "$cf_cv_default_source" = yes && CPPFLAGS="$CPPFLAGS -D_DEFAULT_SOURCE"
1720 fi
1721 ])dnl
1722 dnl ---------------------------------------------------------------------------
1723 dnl CF_HEADER_PATH version: 13 updated: 2015/04/15 19:08:48
1724 dnl --------------
1725 dnl Construct a search-list of directories for a nonstandard header-file
1726 dnl
1727 dnl Parameters
1728 dnl     $1 = the variable to return as result
1729 dnl     $2 = the package name
1730 AC_DEFUN([CF_HEADER_PATH],
1731 [
1732 $1=
1733
1734 # collect the current set of include-directories from compiler flags
1735 cf_header_path_list=""
1736 if test -n "${CFLAGS}${CPPFLAGS}" ; then
1737         for cf_header_path in $CPPFLAGS $CFLAGS
1738         do
1739                 case $cf_header_path in
1740                 (-I*)
1741                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
1742                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
1743                         cf_header_path_list="$cf_header_path_list [$]$1"
1744                         ;;
1745                 esac
1746         done
1747 fi
1748
1749 # add the variations for the package we are looking for
1750 CF_SUBDIR_PATH($1,$2,include)
1751
1752 test "$includedir" != NONE && \
1753 test "$includedir" != "/usr/include" && \
1754 test -d "$includedir" && {
1755         test -d $includedir &&    $1="[$]$1 $includedir"
1756         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
1757 }
1758
1759 test "$oldincludedir" != NONE && \
1760 test "$oldincludedir" != "/usr/include" && \
1761 test -d "$oldincludedir" && {
1762         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
1763         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
1764 }
1765
1766 $1="[$]$1 $cf_header_path_list"
1767 ])dnl
1768 dnl ---------------------------------------------------------------------------
1769 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
1770 dnl ---------------
1771 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
1772 AC_DEFUN([CF_HELP_MESSAGE],
1773 [AC_DIVERT_HELP([$1])dnl
1774 ])dnl
1775 dnl ---------------------------------------------------------------------------
1776 dnl CF_INHERIT_SCRIPT version: 2 updated: 2003/03/01 23:50:42
1777 dnl -----------------
1778 dnl If we do not have a given script, look for it in the parent directory.
1779 AC_DEFUN([CF_INHERIT_SCRIPT],
1780 [
1781 test -f $1 || ( test -f ../$1 && cp ../$1 ./ )
1782 ])dnl
1783 dnl ---------------------------------------------------------------------------
1784 dnl CF_INTEL_COMPILER version: 7 updated: 2015/04/12 15:39:00
1785 dnl -----------------
1786 dnl Check if the given compiler is really the Intel compiler for Linux.  It
1787 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
1788 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
1789 dnl
1790 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1791 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
1792 dnl the wrappers for gcc and g++ warnings.
1793 dnl
1794 dnl $1 = GCC (default) or GXX
1795 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
1796 dnl $3 = CFLAGS (default) or CXXFLAGS
1797 AC_DEFUN([CF_INTEL_COMPILER],[
1798 AC_REQUIRE([AC_CANONICAL_HOST])
1799 ifelse([$2],,INTEL_COMPILER,[$2])=no
1800
1801 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
1802         case $host_os in
1803         (linux*|gnu*)
1804                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
1805                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
1806                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
1807                 AC_TRY_COMPILE([],[
1808 #ifdef __INTEL_COMPILER
1809 #else
1810 make an error
1811 #endif
1812 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
1813 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
1814 ],[])
1815                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
1816                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
1817                 ;;
1818         esac
1819 fi
1820 ])dnl
1821 dnl ---------------------------------------------------------------------------
1822 dnl CF_LD_RPATH_OPT version: 7 updated: 2016/02/20 18:01:19
1823 dnl ---------------
1824 dnl For the given system and compiler, find the compiler flags to pass to the
1825 dnl loader to use the "rpath" feature.
1826 AC_DEFUN([CF_LD_RPATH_OPT],
1827 [
1828 AC_REQUIRE([CF_CHECK_CACHE])
1829
1830 LD_RPATH_OPT=
1831 AC_MSG_CHECKING(for an rpath option)
1832 case $cf_cv_system_name in
1833 (irix*)
1834         if test "$GCC" = yes; then
1835                 LD_RPATH_OPT="-Wl,-rpath,"
1836         else
1837                 LD_RPATH_OPT="-rpath "
1838         fi
1839         ;;
1840 (linux*|gnu*|k*bsd*-gnu|freebsd*)
1841         LD_RPATH_OPT="-Wl,-rpath,"
1842         ;;
1843 (openbsd[[2-9]].*|mirbsd*)
1844         LD_RPATH_OPT="-Wl,-rpath,"
1845         ;;
1846 (dragonfly*)
1847         LD_RPATH_OPT="-rpath "
1848         ;;
1849 (netbsd*)
1850         LD_RPATH_OPT="-Wl,-rpath,"
1851         ;;
1852 (osf*|mls+*)
1853         LD_RPATH_OPT="-rpath "
1854         ;;
1855 (solaris2*)
1856         LD_RPATH_OPT="-R"
1857         ;;
1858 (*)
1859         ;;
1860 esac
1861 AC_MSG_RESULT($LD_RPATH_OPT)
1862
1863 case "x$LD_RPATH_OPT" in
1864 (x-R*)
1865         AC_MSG_CHECKING(if we need a space after rpath option)
1866         cf_save_LIBS="$LIBS"
1867         CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
1868         AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
1869         LIBS="$cf_save_LIBS"
1870         AC_MSG_RESULT($cf_rpath_space)
1871         test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
1872         ;;
1873 esac
1874 ])dnl
1875 dnl ---------------------------------------------------------------------------
1876 dnl CF_LIBRARY_PATH version: 10 updated: 2015/04/15 19:08:48
1877 dnl ---------------
1878 dnl Construct a search-list of directories for a nonstandard library-file
1879 dnl
1880 dnl Parameters
1881 dnl     $1 = the variable to return as result
1882 dnl     $2 = the package name
1883 AC_DEFUN([CF_LIBRARY_PATH],
1884 [
1885 $1=
1886 cf_library_path_list=""
1887 if test -n "${LDFLAGS}${LIBS}" ; then
1888         for cf_library_path in $LDFLAGS $LIBS
1889         do
1890                 case $cf_library_path in
1891                 (-L*)
1892                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
1893                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
1894                         cf_library_path_list="$cf_library_path_list [$]$1"
1895                         ;;
1896                 esac
1897         done
1898 fi
1899
1900 CF_SUBDIR_PATH($1,$2,lib)
1901
1902 $1="$cf_library_path_list [$]$1"
1903 ])dnl
1904 dnl ---------------------------------------------------------------------------
1905 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
1906 dnl ------------
1907 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
1908 dnl a monocase filesystem.
1909 AC_DEFUN([CF_MAKE_TAGS],[
1910 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
1911
1912 AC_CHECK_PROGS(CTAGS, exctags ctags)
1913 AC_CHECK_PROGS(ETAGS, exetags etags)
1914
1915 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
1916
1917 if test "$cf_cv_mixedcase" = yes ; then
1918         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
1919 else
1920         MAKE_UPPER_TAGS=no
1921 fi
1922
1923 if test "$MAKE_UPPER_TAGS" = yes ; then
1924         MAKE_UPPER_TAGS=
1925 else
1926         MAKE_UPPER_TAGS="#"
1927 fi
1928
1929 if test "$MAKE_LOWER_TAGS" = yes ; then
1930         MAKE_LOWER_TAGS=
1931 else
1932         MAKE_LOWER_TAGS="#"
1933 fi
1934
1935 AC_SUBST(CTAGS)
1936 AC_SUBST(ETAGS)
1937
1938 AC_SUBST(MAKE_UPPER_TAGS)
1939 AC_SUBST(MAKE_LOWER_TAGS)
1940 ])dnl
1941 dnl ---------------------------------------------------------------------------
1942 dnl CF_MATH_LIB version: 8 updated: 2010/05/29 16:31:02
1943 dnl -----------
1944 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
1945 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
1946 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
1947 AC_DEFUN([CF_MATH_LIB],
1948 [
1949 AC_CACHE_CHECK(if -lm needed for math functions,
1950         cf_cv_need_libm,[
1951         AC_TRY_LINK([
1952         #include <stdio.h>
1953         #include <math.h>
1954         ],
1955         [double x = rand(); printf("result = %g\n", ]ifelse([$2],,sin(x),$2)[)],
1956         [cf_cv_need_libm=no],
1957         [cf_cv_need_libm=yes])])
1958 if test "$cf_cv_need_libm" = yes
1959 then
1960 ifelse($1,,[
1961         CF_ADD_LIB(m)
1962 ],[$1=-lm])
1963 fi
1964 ])
1965 dnl ---------------------------------------------------------------------------
1966 dnl CF_MIXEDCASE_FILENAMES version: 7 updated: 2015/04/12 15:39:00
1967 dnl ----------------------
1968 dnl Check if the file-system supports mixed-case filenames.  If we're able to
1969 dnl create a lowercase name and see it as uppercase, it doesn't support that.
1970 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
1971 [
1972 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
1973 if test "$cross_compiling" = yes ; then
1974         case $target_alias in
1975         (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*)
1976                 cf_cv_mixedcase=no
1977                 ;;
1978         (*)
1979                 cf_cv_mixedcase=yes
1980                 ;;
1981         esac
1982 else
1983         rm -f conftest CONFTEST
1984         echo test >conftest
1985         if test -f CONFTEST ; then
1986                 cf_cv_mixedcase=no
1987         else
1988                 cf_cv_mixedcase=yes
1989         fi
1990         rm -f conftest CONFTEST
1991 fi
1992 ])
1993 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
1994 ])dnl
1995 dnl ---------------------------------------------------------------------------
1996 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
1997 dnl ----------
1998 dnl Write a debug message to config.log, along with the line number in the
1999 dnl configure script.
2000 AC_DEFUN([CF_MSG_LOG],[
2001 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
2002 ])dnl
2003 dnl ---------------------------------------------------------------------------
2004 dnl CF_NCURSES_CC_CHECK version: 4 updated: 2007/07/29 10:39:05
2005 dnl -------------------
2006 dnl Check if we can compile with ncurses' header file
2007 dnl $1 is the cache variable to set
2008 dnl $2 is the header-file to include
2009 dnl $3 is the root name (ncurses or ncursesw)
2010 AC_DEFUN([CF_NCURSES_CC_CHECK],[
2011         AC_TRY_COMPILE([
2012 ]ifelse($3,ncursesw,[
2013 #define _XOPEN_SOURCE_EXTENDED
2014 #undef  HAVE_LIBUTF8_H  /* in case we used CF_UTF8_LIB */
2015 #define HAVE_LIBUTF8_H  /* to force ncurses' header file to use cchar_t */
2016 ])[
2017 #include <$2>],[
2018 #ifdef NCURSES_VERSION
2019 ]ifelse($3,ncursesw,[
2020 #ifndef WACS_BSSB
2021         make an error
2022 #endif
2023 ])[
2024 printf("%s\n", NCURSES_VERSION);
2025 #else
2026 #ifdef __NCURSES_H
2027 printf("old\n");
2028 #else
2029         make an error
2030 #endif
2031 #endif
2032         ]
2033         ,[$1=$2]
2034         ,[$1=no])
2035 ])dnl
2036 dnl ---------------------------------------------------------------------------
2037 dnl CF_NCURSES_CONFIG version: 17 updated: 2015/07/07 04:22:07
2038 dnl -----------------
2039 dnl Tie together the configure-script macros for ncurses, preferring these in
2040 dnl order:
2041 dnl a) ".pc" files for pkg-config, using $NCURSES_CONFIG_PKG
2042 dnl b) the "-config" script from ncurses, using $NCURSES_CONFIG
2043 dnl c) just plain libraries
2044 dnl
2045 dnl $1 is the root library name (default: "ncurses")
2046 AC_DEFUN([CF_NCURSES_CONFIG],[
2047 AC_REQUIRE([CF_PKG_CONFIG])
2048 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
2049 cf_have_ncuconfig=no
2050
2051 if test "x${PKG_CONFIG:=none}" != xnone; then
2052         AC_MSG_CHECKING(pkg-config for $cf_ncuconfig_root)
2053         if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
2054                 AC_MSG_RESULT(yes)
2055
2056                 AC_MSG_CHECKING(if the $cf_ncuconfig_root package files work)
2057                 cf_have_ncuconfig=unknown
2058
2059                 cf_save_CPPFLAGS="$CPPFLAGS"
2060                 cf_save_LIBS="$LIBS"
2061
2062                 CPPFLAGS="$CPPFLAGS `$PKG_CONFIG --cflags $cf_ncuconfig_root`"
2063                 CF_ADD_LIBS(`$PKG_CONFIG --libs $cf_ncuconfig_root`)
2064
2065                 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2066                         [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2067                         [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2068                                 int main(void)
2069                                 { char *xx = curses_version(); return (xx == 0); }],
2070                                 [cf_have_ncuconfig=yes],
2071                                 [cf_have_ncuconfig=no],
2072                                 [cf_have_ncuconfig=maybe])],
2073                         [cf_have_ncuconfig=no])
2074                 AC_MSG_RESULT($cf_have_ncuconfig)
2075                 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
2076                 if test "$cf_have_ncuconfig" != "yes"
2077                 then
2078                         CPPFLAGS="$cf_save_CPPFLAGS"
2079                         LIBS="$cf_save_LIBS"
2080                         NCURSES_CONFIG_PKG=none
2081                 else
2082                         AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2083                         NCURSES_CONFIG_PKG=$cf_ncuconfig_root
2084                 fi
2085
2086         else
2087                 AC_MSG_RESULT(no)
2088                 NCURSES_CONFIG_PKG=none
2089         fi
2090 else
2091         NCURSES_CONFIG_PKG=none
2092 fi
2093
2094 if test "x$cf_have_ncuconfig" = "xno"; then
2095         echo "Looking for ${cf_ncuconfig_root}-config"
2096
2097         CF_ACVERSION_CHECK(2.52,
2098                 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncuconfig_root}-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
2099                 [AC_PATH_PROGS(NCURSES_CONFIG,  ${cf_ncuconfig_root}-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
2100
2101         if test "$NCURSES_CONFIG" != none ; then
2102
2103                 CPPFLAGS="$CPPFLAGS `$NCURSES_CONFIG --cflags`"
2104                 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
2105
2106                 # even with config script, some packages use no-override for curses.h
2107                 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
2108
2109                 dnl like CF_NCURSES_CPPFLAGS
2110                 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2111
2112                 dnl like CF_NCURSES_LIBS
2113                 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
2114                 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2115
2116                 dnl like CF_NCURSES_VERSION
2117                 cf_cv_ncurses_version=`$NCURSES_CONFIG --version`
2118
2119         else
2120
2121                 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
2122                 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
2123
2124         fi
2125 else
2126         NCURSES_CONFIG=none
2127 fi
2128 ])dnl
2129 dnl ---------------------------------------------------------------------------
2130 dnl CF_NCURSES_CPPFLAGS version: 21 updated: 2012/10/06 08:57:51
2131 dnl -------------------
2132 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
2133 dnl the CPPFLAGS variable so we can include its header.
2134 dnl
2135 dnl The header files may be installed as either curses.h, or ncurses.h (would
2136 dnl be obsolete, except that some packagers prefer this name to distinguish it
2137 dnl from a "native" curses implementation).  If not installed for overwrite,
2138 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
2139 dnl /usr/include/ncurses), but someone may have installed overwriting the
2140 dnl vendor's curses.  Only very old versions (pre-1.9.2d, the first autoconf'd
2141 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
2142 dnl the header.
2143 dnl
2144 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
2145 dnl is already in the include-path, don't even bother with this, since we cannot
2146 dnl easily determine which file it is.  In this case, it has to be <curses.h>.
2147 dnl
2148 dnl The optional parameter gives the root name of the library, in case it is
2149 dnl not installed as the default curses library.  That is how the
2150 dnl wide-character version of ncurses is installed.
2151 AC_DEFUN([CF_NCURSES_CPPFLAGS],
2152 [AC_REQUIRE([CF_WITH_CURSES_DIR])
2153
2154 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
2155 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
2156
2157 test -n "$cf_cv_curses_dir" && \
2158 test "$cf_cv_curses_dir" != "no" && { \
2159   CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
2160 }
2161
2162 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
2163         cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
2164         ( test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw ) && cf_header_list="$cf_header_list curses.h ncurses.h"
2165         for cf_header in $cf_header_list
2166         do
2167                 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
2168                 test "$cf_cv_ncurses_h" != no && break
2169         done
2170 ])
2171
2172 CF_NCURSES_HEADER
2173 CF_TERM_HEADER
2174
2175 # some applications need this, but should check for NCURSES_VERSION
2176 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2177
2178 CF_NCURSES_VERSION
2179 ])dnl
2180 dnl ---------------------------------------------------------------------------
2181 dnl CF_NCURSES_EXT_FUNCS version: 4 updated: 2012/10/06 16:39:58
2182 dnl --------------------
2183 dnl Since 2007/11/17, ncurses has defined NCURSES_EXT_FUNCS; earlier versions
2184 dnl may provide these functions.  Define the symbol if it is not defined, and
2185 dnl if it is valid.
2186 AC_DEFUN([CF_NCURSES_EXT_FUNCS],
2187 [
2188 AC_CACHE_CHECK(for ncurses extended functions,cf_cv_ncurses_ext_funcs,[
2189 AC_TRY_COMPILE([
2190 #include <${cf_cv_ncurses_header:-curses.h}>],
2191 [
2192 int x = NCURSES_EXT_FUNCS
2193 ],[cf_cv_ncurses_ext_funcs=defined],[
2194 AC_TRY_LINK([
2195 #include <${cf_cv_ncurses_header:-curses.h}>],
2196 [
2197         (void) assume_default_colors (0, 0);
2198         (void) curses_version ();
2199         (void) define_key (0, 0);
2200         (void) is_term_resized (0, 0);
2201         (void) key_defined (0);
2202         (void) keybound (0, 0);
2203         (void) keyok (0, 0);
2204         (void) resize_term (0, 0);
2205         (void) resizeterm (0, 0);
2206         (void) use_default_colors ();
2207         (void) use_extended_names (0);
2208         (void) wresize (0, 0, 0);],
2209         [cf_cv_ncurses_ext_funcs=yes],
2210         [cf_cv_ncurses_ext_funcs=no])
2211 ])
2212 ])
2213 test "$cf_cv_ncurses_ext_funcs" = yes && AC_DEFINE(NCURSES_EXT_FUNCS,1,[Define to 1 if we have ncurses extensions])
2214 ])dnl
2215 dnl ---------------------------------------------------------------------------
2216 dnl CF_NCURSES_HEADER version: 4 updated: 2015/04/15 19:08:48
2217 dnl -----------------
2218 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
2219 dnl variations of ncurses' installs.
2220 dnl
2221 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
2222 AC_DEFUN([CF_NCURSES_HEADER],[
2223
2224 if test "$cf_cv_ncurses_h" != no ; then
2225         cf_cv_ncurses_header=$cf_cv_ncurses_h
2226 else
2227
2228 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
2229         test -n "$verbose" && echo
2230         CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
2231         test -n "$verbose" && echo search path $cf_search
2232         cf_save2_CPPFLAGS="$CPPFLAGS"
2233         for cf_incdir in $cf_search
2234         do
2235                 CF_ADD_INCDIR($cf_incdir)
2236                 for cf_header in \
2237                         ncurses.h \
2238                         curses.h
2239                 do
2240                         CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
2241                         if test "$cf_cv_ncurses_h2" != no ; then
2242                                 cf_cv_ncurses_h2=$cf_incdir/$cf_header
2243                                 test -n "$verbose" && echo $ac_n "      ... found $ac_c" 1>&AC_FD_MSG
2244                                 break
2245                         fi
2246                         test -n "$verbose" && echo "    ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
2247                 done
2248                 CPPFLAGS="$cf_save2_CPPFLAGS"
2249                 test "$cf_cv_ncurses_h2" != no && break
2250         done
2251         test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
2252         ])
2253
2254         CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
2255         cf_cv_ncurses_header=`basename $cf_cv_ncurses_h2`
2256         if test `basename $cf_1st_incdir` = $cf_ncuhdr_root ; then
2257                 cf_cv_ncurses_header=$cf_ncuhdr_root/$cf_cv_ncurses_header
2258         fi
2259         CF_ADD_INCDIR($cf_1st_incdir)
2260
2261 fi
2262
2263 # Set definitions to allow ifdef'ing for ncurses.h
2264
2265 case $cf_cv_ncurses_header in
2266 (*ncurses.h)
2267         AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
2268         ;;
2269 esac
2270
2271 case $cf_cv_ncurses_header in
2272 (ncurses/curses.h|ncurses/ncurses.h)
2273         AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
2274         ;;
2275 (ncursesw/curses.h|ncursesw/ncurses.h)
2276         AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
2277         ;;
2278 esac
2279
2280 ])dnl
2281 dnl ---------------------------------------------------------------------------
2282 dnl CF_NCURSES_LIBS version: 17 updated: 2015/04/15 19:08:48
2283 dnl ---------------
2284 dnl Look for the ncurses library.  This is a little complicated on Linux,
2285 dnl because it may be linked with the gpm (general purpose mouse) library.
2286 dnl Some distributions have gpm linked with (bsd) curses, which makes it
2287 dnl unusable with ncurses.  However, we don't want to link with gpm unless
2288 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
2289 dnl and the linker will record a dependency.
2290 dnl
2291 dnl The optional parameter gives the root name of the library, in case it is
2292 dnl not installed as the default curses library.  That is how the
2293 dnl wide-character version of ncurses is installed.
2294 AC_DEFUN([CF_NCURSES_LIBS],
2295 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
2296
2297 cf_nculib_root=ifelse($1,,ncurses,$1)
2298         # This works, except for the special case where we find gpm, but
2299         # ncurses is in a nonstandard location via $LIBS, and we really want
2300         # to link gpm.
2301 cf_ncurses_LIBS=""
2302 cf_ncurses_SAVE="$LIBS"
2303 AC_CHECK_LIB(gpm,Gpm_Open,
2304         [AC_CHECK_LIB(gpm,initscr,
2305                 [LIBS="$cf_ncurses_SAVE"],
2306                 [cf_ncurses_LIBS="-lgpm"])])
2307
2308 case $host_os in
2309 (freebsd*)
2310         # This is only necessary if you are linking against an obsolete
2311         # version of ncurses (but it should do no harm, since it's static).
2312         if test "$cf_nculib_root" = ncurses ; then
2313                 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
2314         fi
2315         ;;
2316 esac
2317
2318 CF_ADD_LIBS($cf_ncurses_LIBS)
2319
2320 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
2321 then
2322         CF_ADD_LIBS(-l$cf_nculib_root)
2323 else
2324         CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
2325                 [#include <${cf_cv_ncurses_header:-curses.h}>],
2326                 [initscr()],
2327                 initscr)
2328 fi
2329
2330 if test -n "$cf_ncurses_LIBS" ; then
2331         AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
2332         cf_ncurses_SAVE="$LIBS"
2333         for p in $cf_ncurses_LIBS ; do
2334                 q=`echo $LIBS | sed -e "s%$p %%" -e "s%$p$%%"`
2335                 if test "$q" != "$LIBS" ; then
2336                         LIBS="$q"
2337                 fi
2338         done
2339         AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2340                 [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2341                 [AC_MSG_RESULT(yes)],
2342                 [AC_MSG_RESULT(no)
2343                  LIBS="$cf_ncurses_SAVE"])
2344 fi
2345
2346 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
2347 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2348 ])dnl
2349 dnl ---------------------------------------------------------------------------
2350 dnl CF_NCURSES_PTHREADS version: 2 updated: 2016/04/22 05:07:41
2351 dnl -------------------
2352 dnl Use this followup check to ensure that we link with pthreads if ncurses
2353 dnl uses it.
2354 AC_DEFUN([CF_NCURSES_PTHREADS],[
2355 : ${cf_nculib_root:=ifelse($1,,ncurses,$1)}
2356 AC_CHECK_LIB($cf_nculib_root,_nc_init_pthreads,
2357         cf_cv_ncurses_pthreads=yes,
2358         cf_cv_ncurses_pthreads=no)
2359 if test "$cf_cv_ncurses_pthreads" = yes
2360 then
2361         CF_ADD_LIBS(-lpthread)
2362 fi
2363 ])dnl
2364 dnl ---------------------------------------------------------------------------
2365 dnl CF_NCURSES_VERSION version: 14 updated: 2012/10/06 08:57:51
2366 dnl ------------------
2367 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
2368 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS.  We don't use
2369 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
2370 AC_DEFUN([CF_NCURSES_VERSION],
2371 [
2372 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
2373 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
2374         cf_cv_ncurses_version=no
2375         cf_tempfile=out$$
2376         rm -f $cf_tempfile
2377         AC_TRY_RUN([
2378 #include <${cf_cv_ncurses_header:-curses.h}>
2379 #include <stdio.h>
2380 int main()
2381 {
2382         FILE *fp = fopen("$cf_tempfile", "w");
2383 #ifdef NCURSES_VERSION
2384 # ifdef NCURSES_VERSION_PATCH
2385         fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
2386 # else
2387         fprintf(fp, "%s\n", NCURSES_VERSION);
2388 # endif
2389 #else
2390 # ifdef __NCURSES_H
2391         fprintf(fp, "old\n");
2392 # else
2393         make an error
2394 # endif
2395 #endif
2396         ${cf_cv_main_return:-return}(0);
2397 }],[
2398         cf_cv_ncurses_version=`cat $cf_tempfile`],,[
2399
2400         # This will not work if the preprocessor splits the line after the
2401         # Autoconf token.  The 'unproto' program does that.
2402         cat > conftest.$ac_ext <<EOF
2403 #include <${cf_cv_ncurses_header:-curses.h}>
2404 #undef Autoconf
2405 #ifdef NCURSES_VERSION
2406 Autoconf NCURSES_VERSION
2407 #else
2408 #ifdef __NCURSES_H
2409 Autoconf "old"
2410 #endif
2411 ;
2412 #endif
2413 EOF
2414         cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
2415         AC_TRY_EVAL(cf_try)
2416         if test -f conftest.out ; then
2417                 cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%'`
2418                 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
2419                 rm -f conftest.out
2420         fi
2421 ])
2422         rm -f $cf_tempfile
2423 ])
2424 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2425 ])dnl
2426 dnl ---------------------------------------------------------------------------
2427 dnl CF_NCURSES_WRAP_PREFIX version: 1 updated: 2009/03/28 16:08:10
2428 dnl ----------------------
2429 dnl Check for ncurses "wrap-prefix" used for public variables which have been
2430 dnl wrapped with a function to help with concurrency control.
2431 AC_DEFUN([CF_NCURSES_WRAP_PREFIX],
2432 [
2433 AC_MSG_CHECKING(for ncurses wrap-prefix)
2434 AC_ARG_WITH(ncurses-wrap-prefix,
2435         [  --with-ncurses-wrap-prefix naming-prefix for ncurses wrapped-variables],
2436         [NCURSES_WRAP_PREFIX=$withval],
2437         [NCURSES_WRAP_PREFIX=_nc_])
2438 AC_MSG_RESULT($NCURSES_WRAP_PREFIX)
2439
2440 AC_SUBST(NCURSES_WRAP_PREFIX)
2441 ])
2442 dnl ---------------------------------------------------------------------------
2443 dnl CF_NETBSD_FORM_H version: 2 updated: 2012/10/06 16:39:58
2444 dnl ----------------
2445 dnl Check for NetBSD's form.h, which is incompatible with SVr4 and ncurses.
2446 dnl Some workarounds are needed in client programs to allow them to compile.
2447 AC_DEFUN([CF_NETBSD_FORM_H],[
2448 AC_CACHE_CHECK(for NetBSD form.h,cf_cv_netbsd_form_h,[
2449 AC_TRY_COMPILE([
2450 #include <${cf_cv_ncurses_header:-curses.h}>
2451 #include <form.h>
2452 ],[
2453         FORM *form;
2454         int y = current_field(form)->cursor_ypos;
2455         int x = current_field(form)->cursor_xpos;
2456 ],[cf_cv_netbsd_form_h=yes
2457 ],[cf_cv_netbsd_form_h=no])
2458 ])
2459
2460 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])
2461 ])dnl
2462 dnl ---------------------------------------------------------------------------
2463 dnl CF_NETBSD_MENU_H version: 2 updated: 2012/10/06 16:39:58
2464 dnl ----------------
2465 dnl Check for NetBSD's menu.h, which is incompatible with SVr4 and ncurses.
2466 dnl Some workarounds are needed in client programs to allow them to compile.
2467 AC_DEFUN([CF_NETBSD_MENU_H],[
2468 AC_CACHE_CHECK(for NetBSD menu.h,cf_cv_netbsd_menu_h,[
2469 AC_TRY_COMPILE([
2470 #include <${cf_cv_ncurses_header:-curses.h}>
2471 #include <menu.h>
2472 ],[
2473         MENU *menu;
2474         int y = menu->max_item_width;
2475 ],[cf_cv_netbsd_menu_h=yes
2476 ],[cf_cv_netbsd_menu_h=no])
2477 ])
2478
2479 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])
2480 ])dnl
2481 dnl ---------------------------------------------------------------------------
2482 dnl CF_NO_LEAKS_OPTION version: 6 updated: 2015/04/12 15:39:00
2483 dnl ------------------
2484 dnl see CF_WITH_NO_LEAKS
2485 AC_DEFUN([CF_NO_LEAKS_OPTION],[
2486 AC_MSG_CHECKING(if you want to use $1 for testing)
2487 AC_ARG_WITH($1,
2488         [$2],
2489         [AC_DEFINE_UNQUOTED($3,1,"Define to 1 if you want to use $1 for testing.")ifelse([$4],,[
2490          $4
2491 ])
2492         : ${with_cflags:=-g}
2493         : ${with_no_leaks:=yes}
2494          with_$1=yes],
2495         [with_$1=])
2496 AC_MSG_RESULT(${with_$1:-no})
2497
2498 case .$with_cflags in
2499 (.*-g*)
2500         case .$CFLAGS in
2501         (.*-g*)
2502                 ;;
2503         (*)
2504                 CF_ADD_CFLAGS([-g])
2505                 ;;
2506         esac
2507         ;;
2508 esac
2509 ])dnl
2510 dnl ---------------------------------------------------------------------------
2511 dnl CF_PATH_SYNTAX version: 16 updated: 2015/04/18 08:56:57
2512 dnl --------------
2513 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
2514 dnl begins with one of the prefix/exec_prefix variables, and then again if the
2515 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
2516 dnl delayed evaluation of those symbols.
2517 AC_DEFUN([CF_PATH_SYNTAX],[
2518 if test "x$prefix" != xNONE; then
2519         cf_path_syntax="$prefix"
2520 else
2521         cf_path_syntax="$ac_default_prefix"
2522 fi
2523
2524 case ".[$]$1" in
2525 (.\[$]\(*\)*|.\'*\'*)
2526         ;;
2527 (..|./*|.\\*)
2528         ;;
2529 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
2530         ;;
2531 (.\[$]{*prefix}*|.\[$]{*dir}*)
2532         eval $1="[$]$1"
2533         case ".[$]$1" in
2534         (.NONE/*)
2535                 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
2536                 ;;
2537         esac
2538         ;;
2539 (.no|.NONE/*)
2540         $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
2541         ;;
2542 (*)
2543         ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
2544         ;;
2545 esac
2546 ])dnl
2547 dnl ---------------------------------------------------------------------------
2548 dnl CF_PDCURSES_X11 version: 13 updated: 2012/10/06 16:39:58
2549 dnl ---------------
2550 dnl Configure for PDCurses' X11 library
2551 AC_DEFUN([CF_PDCURSES_X11],[
2552 AC_REQUIRE([CF_X_ATHENA])
2553
2554 CF_ACVERSION_CHECK(2.52,
2555         [AC_CHECK_TOOLS(XCURSES_CONFIG, xcurses-config, none)],
2556         [AC_PATH_PROGS(XCURSES_CONFIG, xcurses-config, none)])
2557
2558 if test "$XCURSES_CONFIG" != none ; then
2559
2560 CPPFLAGS="$CPPFLAGS `$XCURSES_CONFIG --cflags`"
2561 CF_ADD_LIBS(`$XCURSES_CONFIG --libs`)
2562
2563 cf_cv_lib_XCurses=yes
2564
2565 else
2566
2567 LDFLAGS="$LDFLAGS $X_LIBS"
2568 CF_CHECK_CFLAGS($X_CFLAGS)
2569 AC_CHECK_LIB(X11,XOpenDisplay,
2570         [CF_ADD_LIBS(-lX11)],,
2571         [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])
2572 AC_CACHE_CHECK(for XCurses library,cf_cv_lib_XCurses,[
2573 CF_ADD_LIBS(-lXCurses)
2574 AC_TRY_LINK([
2575 #include <xcurses.h>
2576 char *XCursesProgramName = "test";
2577 ],[XCursesExit();],
2578 [cf_cv_lib_XCurses=yes],
2579 [cf_cv_lib_XCurses=no])
2580 ])
2581
2582 fi
2583
2584 if test $cf_cv_lib_XCurses = yes ; then
2585         AC_DEFINE(UNIX,1,[Define to 1 if using PDCurses on Unix])
2586         AC_DEFINE(XCURSES,1,[Define to 1 if using PDCurses on Unix])
2587         AC_CHECK_HEADER(xcurses.h, AC_DEFINE(HAVE_XCURSES,1,[Define to 1 if using PDCurses on Unix]))
2588 else
2589         AC_MSG_ERROR(Cannot link with XCurses)
2590 fi
2591 ])dnl
2592 dnl ---------------------------------------------------------------------------
2593 dnl CF_PKG_CONFIG version: 10 updated: 2015/04/26 18:06:58
2594 dnl -------------
2595 dnl Check for the package-config program, unless disabled by command-line.
2596 AC_DEFUN([CF_PKG_CONFIG],
2597 [
2598 AC_MSG_CHECKING(if you want to use pkg-config)
2599 AC_ARG_WITH(pkg-config,
2600         [  --with-pkg-config{=path} enable/disable use of pkg-config],
2601         [cf_pkg_config=$withval],
2602         [cf_pkg_config=yes])
2603 AC_MSG_RESULT($cf_pkg_config)
2604
2605 case $cf_pkg_config in
2606 (no)
2607         PKG_CONFIG=none
2608         ;;
2609 (yes)
2610         CF_ACVERSION_CHECK(2.52,
2611                 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
2612                 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
2613         ;;
2614 (*)
2615         PKG_CONFIG=$withval
2616         ;;
2617 esac
2618
2619 test -z "$PKG_CONFIG" && PKG_CONFIG=none
2620 if test "$PKG_CONFIG" != none ; then
2621         CF_PATH_SYNTAX(PKG_CONFIG)
2622 elif test "x$cf_pkg_config" != xno ; then
2623         AC_MSG_WARN(pkg-config is not installed)
2624 fi
2625
2626 AC_SUBST(PKG_CONFIG)
2627 ])dnl
2628 dnl ---------------------------------------------------------------------------
2629 dnl CF_POSIX_C_SOURCE version: 9 updated: 2015/04/12 15:39:00
2630 dnl -----------------
2631 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
2632 dnl
2633 dnl     POSIX.1-1990                            _POSIX_SOURCE
2634 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
2635 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
2636 dnl             Bindings Option
2637 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
2638 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
2639 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
2640 dnl
2641 dnl Parameters:
2642 dnl     $1 is the nominal value for _POSIX_C_SOURCE
2643 AC_DEFUN([CF_POSIX_C_SOURCE],
2644 [
2645 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
2646
2647 cf_save_CFLAGS="$CFLAGS"
2648 cf_save_CPPFLAGS="$CPPFLAGS"
2649
2650 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
2651 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
2652
2653 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
2654         CF_MSG_LOG(if the symbol is already defined go no further)
2655         AC_TRY_COMPILE([#include <sys/types.h>],[
2656 #ifndef _POSIX_C_SOURCE
2657 make an error
2658 #endif],
2659         [cf_cv_posix_c_source=no],
2660         [cf_want_posix_source=no
2661          case .$cf_POSIX_C_SOURCE in
2662          (.[[12]]??*)
2663                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
2664                 ;;
2665          (.2)
2666                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
2667                 cf_want_posix_source=yes
2668                 ;;
2669          (.*)
2670                 cf_want_posix_source=yes
2671                 ;;
2672          esac
2673          if test "$cf_want_posix_source" = yes ; then
2674                 AC_TRY_COMPILE([#include <sys/types.h>],[
2675 #ifdef _POSIX_SOURCE
2676 make an error
2677 #endif],[],
2678                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
2679          fi
2680          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
2681          CFLAGS="$cf_trim_CFLAGS"
2682          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
2683          CF_MSG_LOG(if the second compile does not leave our definition intact error)
2684          AC_TRY_COMPILE([#include <sys/types.h>],[
2685 #ifndef _POSIX_C_SOURCE
2686 make an error
2687 #endif],,
2688          [cf_cv_posix_c_source=no])
2689          CFLAGS="$cf_save_CFLAGS"
2690          CPPFLAGS="$cf_save_CPPFLAGS"
2691         ])
2692 ])
2693
2694 if test "$cf_cv_posix_c_source" != no ; then
2695         CFLAGS="$cf_trim_CFLAGS"
2696         CPPFLAGS="$cf_trim_CPPFLAGS"
2697         CF_ADD_CFLAGS($cf_cv_posix_c_source)
2698 fi
2699
2700 ])dnl
2701 dnl ---------------------------------------------------------------------------
2702 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
2703 dnl ------------
2704 dnl Append definitions and rules for the given programs to the subdirectory
2705 dnl Makefiles, and the recursion rule for the top-level Makefile.
2706 dnl
2707 dnl parameters
2708 dnl     $1 = script to run
2709 dnl     $2 = list of subdirectories
2710 dnl
2711 dnl variables
2712 dnl     $AWK
2713 AC_DEFUN([CF_PRG_RULES],
2714 [
2715 for cf_dir in $2
2716 do
2717         if test ! -d $srcdir/$cf_dir; then
2718                 continue
2719         elif test -f $srcdir/$cf_dir/programs; then
2720                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
2721         fi
2722 done
2723
2724 ])dnl
2725 dnl ---------------------------------------------------------------------------
2726 dnl CF_PROG_CC version: 4 updated: 2014/07/12 18:57:58
2727 dnl ----------
2728 dnl standard check for CC, plus followup sanity checks
2729 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
2730 AC_DEFUN([CF_PROG_CC],[
2731 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
2732 CF_GCC_VERSION
2733 CF_ACVERSION_CHECK(2.52,
2734         [AC_PROG_CC_STDC],
2735         [CF_ANSI_CC_REQD])
2736 CF_CC_ENV_FLAGS
2737 ])dnl
2738 dnl ---------------------------------------------------------------------------
2739 dnl CF_PROG_INSTALL version: 7 updated: 2015/04/18 08:56:57
2740 dnl ---------------
2741 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
2742 dnl misc/tabset install won't work properly.  Usually this happens only when
2743 dnl using the fallback mkinstalldirs script
2744 AC_DEFUN([CF_PROG_INSTALL],
2745 [AC_PROG_INSTALL
2746 case $INSTALL in
2747 (/*)
2748         ;;
2749 (*)
2750         CF_DIRNAME(cf_dir,$INSTALL)
2751         test -z "$cf_dir" && cf_dir=.
2752         INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
2753         ;;
2754 esac
2755 ])dnl
2756 dnl ---------------------------------------------------------------------------
2757 dnl CF_PROG_LINT version: 3 updated: 2016/05/22 15:25:54
2758 dnl ------------
2759 AC_DEFUN([CF_PROG_LINT],
2760 [
2761 AC_CHECK_PROGS(LINT, lint cppcheck splint)
2762 AC_SUBST(LINT_OPTS)
2763 ])dnl
2764 dnl ---------------------------------------------------------------------------
2765 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
2766 dnl ----------------
2767 dnl Remove all -U and -D options that refer to the given symbol from a list
2768 dnl of C compiler options.  This works around the problem that not all
2769 dnl compilers process -U and -D options from left-to-right, so a -U option
2770 dnl cannot be used to cancel the effect of a preceding -D option.
2771 dnl
2772 dnl $1 = target (which could be the same as the source variable)
2773 dnl $2 = source (including '$')
2774 dnl $3 = symbol to remove
2775 define([CF_REMOVE_DEFINE],
2776 [
2777 $1=`echo "$2" | \
2778         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
2779                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
2780 ])dnl
2781 dnl ---------------------------------------------------------------------------
2782 dnl CF_RPATH_HACK version: 11 updated: 2013/09/01 13:02:00
2783 dnl -------------
2784 AC_DEFUN([CF_RPATH_HACK],
2785 [
2786 AC_REQUIRE([CF_LD_RPATH_OPT])
2787 AC_MSG_CHECKING(for updated LDFLAGS)
2788 if test -n "$LD_RPATH_OPT" ; then
2789         AC_MSG_RESULT(maybe)
2790
2791         AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
2792         cf_rpath_list="/usr/lib /lib"
2793         if test "$cf_ldd_prog" != no
2794         then
2795                 cf_rpath_oops=
2796
2797 AC_TRY_LINK([#include <stdio.h>],
2798                 [printf("Hello");],
2799                 [cf_rpath_oops=`$cf_ldd_prog conftest$ac_exeext | fgrep ' not found' | sed -e 's% =>.*$%%' |sort | uniq`
2800                  cf_rpath_list=`$cf_ldd_prog conftest$ac_exeext | fgrep / | sed -e 's%^.*[[     ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort | uniq`])
2801
2802                 # If we passed the link-test, but get a "not found" on a given library,
2803                 # this could be due to inept reconfiguration of gcc to make it only
2804                 # partly honor /usr/local/lib (or whatever).  Sometimes this behavior
2805                 # is intentional, e.g., installing gcc in /usr/bin and suppressing the
2806                 # /usr/local libraries.
2807                 if test -n "$cf_rpath_oops"
2808                 then
2809                         for cf_rpath_src in $cf_rpath_oops
2810                         do
2811                                 for cf_rpath_dir in \
2812                                         /usr/local \
2813                                         /usr/pkg \
2814                                         /opt/sfw
2815                                 do
2816                                         if test -f $cf_rpath_dir/lib/$cf_rpath_src
2817                                         then
2818                                                 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
2819                                                 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
2820                                                 break
2821                                         fi
2822                                 done
2823                         done
2824                 fi
2825         fi
2826
2827         CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
2828
2829         CF_RPATH_HACK_2(LDFLAGS)
2830         CF_RPATH_HACK_2(LIBS)
2831
2832         CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
2833 else
2834         AC_MSG_RESULT(no)
2835 fi
2836 AC_SUBST(EXTRA_LDFLAGS)
2837 ])dnl
2838 dnl ---------------------------------------------------------------------------
2839 dnl CF_RPATH_HACK_2 version: 7 updated: 2015/04/12 15:39:00
2840 dnl ---------------
2841 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
2842 dnl EXTRA_LDFLAGS for each -L option found.
2843 dnl
2844 dnl $cf_rpath_list contains a list of directories to ignore.
2845 dnl
2846 dnl $1 = variable name to update.  The LDFLAGS variable should be the only one,
2847 dnl      but LIBS often has misplaced -L options.
2848 AC_DEFUN([CF_RPATH_HACK_2],
2849 [
2850 CF_VERBOSE(...checking $1 [$]$1)
2851
2852 cf_rpath_dst=
2853 for cf_rpath_src in [$]$1
2854 do
2855         case $cf_rpath_src in
2856         (-L*)
2857
2858                 # check if this refers to a directory which we will ignore
2859                 cf_rpath_skip=no
2860                 if test -n "$cf_rpath_list"
2861                 then
2862                         for cf_rpath_item in $cf_rpath_list
2863                         do
2864                                 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
2865                                 then
2866                                         cf_rpath_skip=yes
2867                                         break
2868                                 fi
2869                         done
2870                 fi
2871
2872                 if test "$cf_rpath_skip" = no
2873                 then
2874                         # transform the option
2875                         if test "$LD_RPATH_OPT" = "-R " ; then
2876                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
2877                         else
2878                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
2879                         fi
2880
2881                         # if we have not already added this, add it now
2882                         cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
2883                         if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
2884                         then
2885                                 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
2886                                 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
2887                         fi
2888                 fi
2889                 ;;
2890         esac
2891         cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
2892 done
2893 $1=$cf_rpath_dst
2894
2895 CF_VERBOSE(...checked $1 [$]$1)
2896 AC_SUBST(EXTRA_LDFLAGS)
2897 ])dnl
2898 dnl ---------------------------------------------------------------------------
2899 dnl CF_SIGWINCH version: 1 updated: 2006/04/02 16:41:09
2900 dnl -----------
2901 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
2902 dnl programs need this test).
2903 dnl
2904 dnl This is really a MacOS X 10.4.3 workaround.  Defining _POSIX_C_SOURCE
2905 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses).  Oddly, the struct
2906 dnl winsize declaration is left alone - we may revisit this if Apple choose to
2907 dnl break that part of the interface as well.
2908 AC_DEFUN([CF_SIGWINCH],
2909 [
2910 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
2911         AC_TRY_COMPILE([
2912 #include <sys/types.h>
2913 #include <sys/signal.h>
2914 ],[int x = SIGWINCH],
2915         [cf_cv_define_sigwinch=yes],
2916         [AC_TRY_COMPILE([
2917 #undef _XOPEN_SOURCE
2918 #undef _POSIX_SOURCE
2919 #undef _POSIX_C_SOURCE
2920 #include <sys/types.h>
2921 #include <sys/signal.h>
2922 ],[int x = SIGWINCH],
2923         [cf_cv_define_sigwinch=maybe],
2924         [cf_cv_define_sigwinch=no])
2925 ])
2926 ])
2927
2928 if test "$cf_cv_define_sigwinch" = maybe ; then
2929 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
2930 cf_cv_fixup_sigwinch=unknown
2931 cf_sigwinch=32
2932 while test $cf_sigwinch != 1
2933 do
2934         AC_TRY_COMPILE([
2935 #undef _XOPEN_SOURCE
2936 #undef _POSIX_SOURCE
2937 #undef _POSIX_C_SOURCE
2938 #include <sys/types.h>
2939 #include <sys/signal.h>
2940 ],[
2941 #if SIGWINCH != $cf_sigwinch
2942 make an error
2943 #endif
2944 int x = SIGWINCH],
2945         [cf_cv_fixup_sigwinch=$cf_sigwinch
2946          break])
2947
2948 cf_sigwinch=`expr $cf_sigwinch - 1`
2949 done
2950 ])
2951
2952         if test "$cf_cv_fixup_sigwinch" != unknown ; then
2953                 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
2954         fi
2955 fi
2956 ])dnl
2957 dnl ---------------------------------------------------------------------------
2958 dnl CF_SIG_ATOMIC_T version: 3 updated: 2012/10/04 20:12:20
2959 dnl ---------------
2960 dnl signal handler, but there are some gcc depedencies in that recommendation.
2961 dnl Try anyway.
2962 AC_DEFUN([CF_SIG_ATOMIC_T],
2963 [
2964 AC_MSG_CHECKING(for signal global datatype)
2965 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
2966         for cf_type in \
2967                 "volatile sig_atomic_t" \
2968                 "sig_atomic_t" \
2969                 "int"
2970         do
2971         AC_TRY_COMPILE([
2972 #include <sys/types.h>
2973 #include <signal.h>
2974 #include <stdio.h>
2975
2976 extern $cf_type x;
2977 $cf_type x;
2978 static void handler(int sig)
2979 {
2980         x = 5;
2981 }],
2982                 [signal(SIGINT, handler);
2983                  x = 1],
2984                 [cf_cv_sig_atomic_t=$cf_type],
2985                 [cf_cv_sig_atomic_t=no])
2986                 test "$cf_cv_sig_atomic_t" != no && break
2987         done
2988         ])
2989 AC_MSG_RESULT($cf_cv_sig_atomic_t)
2990 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t,[Define to signal global datatype])
2991 ])dnl
2992 dnl ---------------------------------------------------------------------------
2993 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
2994 dnl --------------
2995 dnl Construct a search-list for a nonstandard header/lib-file
2996 dnl     $1 = the variable to return as result
2997 dnl     $2 = the package name
2998 dnl     $3 = the subdirectory, e.g., bin, include or lib
2999 AC_DEFUN([CF_SUBDIR_PATH],
3000 [
3001 $1=
3002
3003 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
3004
3005 for cf_subdir_prefix in \
3006         /usr \
3007         /usr/local \
3008         /usr/pkg \
3009         /opt \
3010         /opt/local \
3011         [$]HOME
3012 do
3013         CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
3014 done
3015 ])dnl
3016 dnl ---------------------------------------------------------------------------
3017 dnl CF_SYS_TIME_SELECT version: 6 updated: 2015/04/18 08:56:57
3018 dnl ------------------
3019 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
3020 dnl older SCO configurations.
3021 AC_DEFUN([CF_SYS_TIME_SELECT],
3022 [
3023 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
3024 AC_CACHE_VAL(cf_cv_sys_time_select,[
3025 AC_TRY_COMPILE([
3026 #include <sys/types.h>
3027 #ifdef HAVE_SYS_TIME_H
3028 #include <sys/time.h>
3029 #endif
3030 #ifdef HAVE_SYS_SELECT_H
3031 #include <sys/select.h>
3032 #endif
3033 ],[],[cf_cv_sys_time_select=yes],
3034          [cf_cv_sys_time_select=no])
3035          ])
3036 AC_MSG_RESULT($cf_cv_sys_time_select)
3037 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>])
3038 ])dnl
3039 dnl ---------------------------------------------------------------------------
3040 dnl CF_TERM_HEADER version: 4 updated: 2015/04/15 19:08:48
3041 dnl --------------
3042 dnl Look for term.h, which is part of X/Open curses.  It defines the interface
3043 dnl to terminfo database.  Usually it is in the same include-path as curses.h,
3044 dnl but some packagers change this, breaking various applications.
3045 AC_DEFUN([CF_TERM_HEADER],[
3046 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
3047 case ${cf_cv_ncurses_header} in
3048 (*/ncurses.h|*/ncursesw.h)
3049         cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
3050         ;;
3051 (*)
3052         cf_term_header=term.h
3053         ;;
3054 esac
3055
3056 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
3057 do
3058 AC_TRY_COMPILE([#include <stdio.h>
3059 #include <${cf_cv_ncurses_header:-curses.h}>
3060 #include <$cf_test>
3061 ],[int x = auto_left_margin],[
3062         cf_cv_term_header="$cf_test"],[
3063         cf_cv_term_header=unknown
3064         ])
3065         test "$cf_cv_term_header" != unknown && break
3066 done
3067 ])
3068
3069 # Set definitions to allow ifdef'ing to accommodate subdirectories
3070
3071 case $cf_cv_term_header in
3072 (*term.h)
3073         AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
3074         ;;
3075 esac
3076
3077 case $cf_cv_term_header in
3078 (ncurses/term.h)
3079         AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
3080         ;;
3081 (ncursesw/term.h)
3082         AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
3083         ;;
3084 esac
3085 ])dnl
3086 dnl ---------------------------------------------------------------------------
3087 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
3088 dnl ---------------
3089 dnl Define a top_builddir symbol, for applications that need an absolute path.
3090 AC_DEFUN([CF_TOP_BUILDDIR],
3091 [
3092 top_builddir=ifelse($1,,`pwd`,$1)
3093 AC_SUBST(top_builddir)
3094 ])dnl
3095 dnl ---------------------------------------------------------------------------
3096 dnl CF_TPUTS_PROTO version: 3 updated: 2015/04/17 21:26:14
3097 dnl --------------
3098 dnl Check for type of function-pointer passed to tputs.  Some old
3099 dnl implementations used functions that had different prototypes, making it
3100 dnl hard to compile portable programs using tputs.
3101 AC_DEFUN([CF_TPUTS_PROTO],[
3102 CF_CURSES_FUNCS(tputs)
3103 if test x$cf_cv_func_tputs = xyes
3104 then
3105         cf_done=no
3106         for cf_arg in int char
3107         do
3108                 for cf_ret in int void
3109                 do
3110                         if test $cf_ret = void
3111                         then
3112                                 cf_return="/* nothing */"
3113                         else
3114                                 cf_return="return value"
3115                         fi
3116                         AC_TRY_COMPILE([
3117 #include <${cf_cv_ncurses_header:-curses.h}>
3118 #include <$cf_cv_term_header>
3119
3120 static $cf_ret outc($cf_arg value) { $cf_return; }
3121 ],[
3122         tputs("hello", 0, outc);
3123         ${cf_cv_main_return:-return}(0);
3124 ],[
3125                 CF_VERBOSE([prototype $cf_ret func($cf_arg value)])
3126                 cat >>confdefs.h <<EOF
3127 #define TPUTS_ARG               $cf_arg
3128 #define TPUTS_PROTO(func,value) $cf_ret func(TPUTS_ARG value)
3129 #define TPUTS_RETURN(value)     $cf_return
3130 EOF
3131                 cf_done=yes
3132                 break
3133 ])
3134                 done
3135                 test $cf_done = yes && break
3136         done
3137 fi
3138 ])dnl
3139 dnl ---------------------------------------------------------------------------
3140 dnl CF_TRIM_X_LIBS version: 3 updated: 2015/04/12 15:39:00
3141 dnl --------------
3142 dnl Trim extra base X libraries added as a workaround for inconsistent library
3143 dnl dependencies returned by "new" pkg-config files.
3144 AC_DEFUN([CF_TRIM_X_LIBS],[
3145         for cf_trim_lib in Xmu Xt X11
3146         do
3147                 case "$LIBS" in
3148                 (*-l$cf_trim_lib\ *-l$cf_trim_lib*)
3149                         LIBS=`echo "$LIBS " | sed -e 's/  / /g' -e 's%-l'"$cf_trim_lib"' %%' -e 's/ $//'`
3150                         CF_VERBOSE(..trimmed $LIBS)
3151                         ;;
3152                 esac
3153         done
3154 ])
3155 dnl ---------------------------------------------------------------------------
3156 dnl CF_TRY_PKG_CONFIG version: 5 updated: 2013/07/06 21:27:06
3157 dnl -----------------
3158 dnl This is a simple wrapper to use for pkg-config, for libraries which may be
3159 dnl available in that form.
3160 dnl
3161 dnl $1 = package name
3162 dnl $2 = extra logic to use, if any, after updating CFLAGS and LIBS
3163 dnl $3 = logic to use if pkg-config does not have the package
3164 AC_DEFUN([CF_TRY_PKG_CONFIG],[
3165 AC_REQUIRE([CF_PKG_CONFIG])
3166
3167 if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists $1; then
3168         CF_VERBOSE(found package $1)
3169         cf_pkgconfig_incs="`$PKG_CONFIG --cflags $1 2>/dev/null`"
3170         cf_pkgconfig_libs="`$PKG_CONFIG --libs   $1 2>/dev/null`"
3171         CF_VERBOSE(package $1 CFLAGS: $cf_pkgconfig_incs)
3172         CF_VERBOSE(package $1 LIBS: $cf_pkgconfig_libs)
3173         CF_ADD_CFLAGS($cf_pkgconfig_incs)
3174         CF_ADD_LIBS($cf_pkgconfig_libs)
3175         ifelse([$2],,:,[$2])
3176 else
3177         cf_pkgconfig_incs=
3178         cf_pkgconfig_libs=
3179         ifelse([$3],,:,[$3])
3180 fi
3181 ])
3182 dnl ---------------------------------------------------------------------------
3183 dnl CF_TRY_XOPEN_SOURCE version: 1 updated: 2011/10/30 17:09:50
3184 dnl -------------------
3185 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
3186 dnl can define it successfully.
3187 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
3188 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
3189         AC_TRY_COMPILE([
3190 #include <stdlib.h>
3191 #include <string.h>
3192 #include <sys/types.h>
3193 ],[
3194 #ifndef _XOPEN_SOURCE
3195 make an error
3196 #endif],
3197         [cf_cv_xopen_source=no],
3198         [cf_save="$CPPFLAGS"
3199          CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
3200          AC_TRY_COMPILE([
3201 #include <stdlib.h>
3202 #include <string.h>
3203 #include <sys/types.h>
3204 ],[
3205 #ifdef _XOPEN_SOURCE
3206 make an error
3207 #endif],
3208         [cf_cv_xopen_source=no],
3209         [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
3210         CPPFLAGS="$cf_save"
3211         ])
3212 ])
3213
3214 if test "$cf_cv_xopen_source" != no ; then
3215         CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
3216         CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
3217         cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
3218         CF_ADD_CFLAGS($cf_temp_xopen_source)
3219 fi
3220 ])
3221 dnl ---------------------------------------------------------------------------
3222 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
3223 dnl --------
3224 dnl Make an uppercase version of a variable
3225 dnl $1=uppercase($2)
3226 AC_DEFUN([CF_UPPER],
3227 [
3228 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3229 ])dnl
3230 dnl ---------------------------------------------------------------------------
3231 dnl CF_UTF8_LIB version: 8 updated: 2012/10/06 08:57:51
3232 dnl -----------
3233 dnl Check for multibyte support, and if not found, utf8 compatibility library
3234 AC_DEFUN([CF_UTF8_LIB],
3235 [
3236 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
3237         cf_save_LIBS="$LIBS"
3238         AC_TRY_LINK([
3239 #include <stdlib.h>],[putwc(0,0);],
3240         [cf_cv_utf8_lib=yes],
3241         [CF_FIND_LINKAGE([
3242 #include <libutf8.h>],[putwc(0,0);],utf8,
3243                 [cf_cv_utf8_lib=add-on],
3244                 [cf_cv_utf8_lib=no])
3245 ])])
3246
3247 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
3248 # ncurses/ncursesw:
3249 if test "$cf_cv_utf8_lib" = "add-on" ; then
3250         AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
3251         CF_ADD_INCDIR($cf_cv_header_path_utf8)
3252         CF_ADD_LIBDIR($cf_cv_library_path_utf8)
3253         CF_ADD_LIBS($cf_cv_library_file_utf8)
3254 fi
3255 ])dnl
3256 dnl ---------------------------------------------------------------------------
3257 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
3258 dnl ----------
3259 dnl Use AC_VERBOSE w/o the warnings
3260 AC_DEFUN([CF_VERBOSE],
3261 [test -n "$verbose" && echo "   $1" 1>&AC_FD_MSG
3262 CF_MSG_LOG([$1])
3263 ])dnl
3264 dnl ---------------------------------------------------------------------------
3265 dnl CF_WCHAR_TYPE version: 4 updated: 2012/10/06 16:39:58
3266 dnl -------------
3267 dnl Check if type wide-character type $1 is declared, and if so, which header
3268 dnl file is needed.  The second parameter is used to set a shell variable when
3269 dnl the type is not found.  The first parameter sets a shell variable for the
3270 dnl opposite sense.
3271 AC_DEFUN([CF_WCHAR_TYPE],
3272 [
3273 # This is needed on Tru64 5.0 to declare $1
3274 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
3275 AC_TRY_COMPILE([
3276 #include <stdlib.h>
3277 #include <stdarg.h>
3278 #include <stdio.h>
3279 #ifdef HAVE_LIBUTF8_H
3280 #include <libutf8.h>
3281 #endif],
3282         [$1 state],
3283         [cf_cv_$1=no],
3284         [AC_TRY_COMPILE([
3285 #include <stdlib.h>
3286 #include <stdarg.h>
3287 #include <stdio.h>
3288 #include <wchar.h>
3289 #ifdef HAVE_LIBUTF8_H
3290 #include <libutf8.h>
3291 #endif],
3292         [$1 value],
3293         [cf_cv_$1=yes],
3294         [cf_cv_$1=unknown])])])
3295
3296 if test "$cf_cv_$1" = yes ; then
3297         AC_DEFINE(NEED_WCHAR_H,1,[Define to 1 if we must include wchar.h])
3298         NEED_WCHAR_H=1
3299 fi
3300
3301 ifelse([$2],,,[
3302 # if we do not find $1 in either place, use substitution to provide a fallback.
3303 if test "$cf_cv_$1" = unknown ; then
3304         $2=1
3305 fi
3306 ])
3307 ifelse($3,,,[
3308 # if we find $1 in either place, use substitution to provide a fallback.
3309 if test "$cf_cv_$1" != unknown ; then
3310         $3=1
3311 fi
3312 ])
3313 ])dnl
3314 dnl ---------------------------------------------------------------------------
3315 dnl CF_WITH_CURSES_DIR version: 3 updated: 2010/11/20 17:02:38
3316 dnl ------------------
3317 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
3318 dnl libraries.
3319 AC_DEFUN([CF_WITH_CURSES_DIR],[
3320
3321 AC_MSG_CHECKING(for specific curses-directory)
3322 AC_ARG_WITH(curses-dir,
3323         [  --with-curses-dir=DIR   directory in which (n)curses is installed],
3324         [cf_cv_curses_dir=$withval],
3325         [cf_cv_curses_dir=no])
3326 AC_MSG_RESULT($cf_cv_curses_dir)
3327
3328 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
3329 then
3330         CF_PATH_SYNTAX(withval)
3331         if test -d "$cf_cv_curses_dir"
3332         then
3333                 CF_ADD_INCDIR($cf_cv_curses_dir/include)
3334                 CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
3335         fi
3336 fi
3337 ])dnl
3338 dnl ---------------------------------------------------------------------------
3339 dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
3340 dnl ----------------
3341 dnl Configure-option for dbmalloc.  The optional parameter is used to override
3342 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
3343 AC_DEFUN([CF_WITH_DBMALLOC],[
3344 CF_NO_LEAKS_OPTION(dbmalloc,
3345         [  --with-dbmalloc         test: use Conor Cahill's dbmalloc library],
3346         [USE_DBMALLOC])
3347
3348 if test "$with_dbmalloc" = yes ; then
3349         AC_CHECK_HEADER(dbmalloc.h,
3350                 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
3351 fi
3352 ])dnl
3353 dnl ---------------------------------------------------------------------------
3354 dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
3355 dnl ---------------
3356 dnl Configure-option for dmalloc.  The optional parameter is used to override
3357 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
3358 AC_DEFUN([CF_WITH_DMALLOC],[
3359 CF_NO_LEAKS_OPTION(dmalloc,
3360         [  --with-dmalloc          test: use Gray Watson's dmalloc library],
3361         [USE_DMALLOC])
3362
3363 if test "$with_dmalloc" = yes ; then
3364         AC_CHECK_HEADER(dmalloc.h,
3365                 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
3366 fi
3367 ])dnl
3368 dnl ---------------------------------------------------------------------------
3369 dnl CF_WITH_NCURSES_ETC version: 5 updated: 2016/02/20 19:23:20
3370 dnl -------------------
3371 dnl Use this macro for programs which use any variant of "curses", e.g.,
3372 dnl "ncurses", and "PDCurses".  Programs that can use curses and some unrelated
3373 dnl library (such as slang) should use a "--with-screen=XXX" option.
3374 dnl
3375 dnl This does not use AC_DEFUN, because that would tell autoconf to run each
3376 dnl of the macros inside this one - before this macro.
3377 define([CF_WITH_NCURSES_ETC],[
3378 CF_WITH_CURSES_DIR
3379
3380 cf_cv_screen=curses
3381
3382 AC_MSG_CHECKING(for specified curses library type)
3383 AC_ARG_WITH(screen,
3384         [  --with-screen=XXX       use specified curses-libraries],
3385         [cf_cv_screen=$withval],[
3386
3387 AC_ARG_WITH(ncursesw,
3388         [  --with-ncursesw         use wide ncurses-libraries],
3389         [cf_cv_screen=ncursesw],[
3390
3391 AC_ARG_WITH(ncurses,
3392         [  --with-ncurses          use ncurses-libraries],
3393         [cf_cv_screen=ncurses],[
3394
3395 AC_ARG_WITH(pdcurses,
3396         [  --with-pdcurses         compile/link with pdcurses X11 library],
3397         [cf_cv_screen=pdcurses],[
3398
3399 AC_ARG_WITH(curses-colr,
3400         [  --with-curses-colr      compile/link with HPUX 10.x color-curses],
3401         [cf_cv_screen=curses_colr],[
3402
3403 AC_ARG_WITH(curses-5lib,
3404         [  --with-curses-5lib      compile/link with SunOS 5lib curses],
3405         [cf_cv_screen=curses_5lib])])])])])])
3406
3407 AC_MSG_RESULT($cf_cv_screen)
3408
3409 case $cf_cv_screen in
3410 (curses|curses_*)
3411         CF_CURSES_CONFIG
3412         ;;
3413 (ncursesw*)
3414         CF_UTF8_LIB
3415         CF_NCURSES_CONFIG($cf_cv_screen)
3416         ;;
3417 (ncurses*)
3418         CF_NCURSES_CONFIG($cf_cv_screen)
3419         ;;
3420 (pdcurses)
3421         CF_PDCURSES_X11
3422         ;;
3423 (*)
3424         AC_MSG_ERROR(unexpected screen-value: $cf_cv_screen)
3425         ;;
3426 esac
3427
3428 CF_NCURSES_PTHREADS($cf_cv_screen)
3429
3430 ])dnl
3431 dnl ---------------------------------------------------------------------------
3432 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
3433 dnl ----------------
3434 AC_DEFUN([CF_WITH_VALGRIND],[
3435 CF_NO_LEAKS_OPTION(valgrind,
3436         [  --with-valgrind         test: use valgrind],
3437         [USE_VALGRIND])
3438 ])dnl
3439 dnl ---------------------------------------------------------------------------
3440 dnl CF_XOPEN_CURSES version: 13 updated: 2015/12/12 20:59:52
3441 dnl ---------------
3442 dnl Test if we should define X/Open source for curses, needed on Digital Unix
3443 dnl 4.x, to see the extended functions, but breaks on IRIX 6.x.
3444 dnl
3445 dnl The getbegyx() check is needed for HPUX, which omits legacy macros such
3446 dnl as getbegy().  The latter is better design, but the former is standard.
3447 AC_DEFUN([CF_XOPEN_CURSES],
3448 [
3449 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
3450 AC_CACHE_CHECK(definition to turn on extended curses functions,cf_cv_need_xopen_extension,[
3451 cf_cv_need_xopen_extension=unknown
3452 AC_TRY_LINK([
3453 #include <stdlib.h>
3454 #include <${cf_cv_ncurses_header:-curses.h}>],[
3455 #if defined(NCURSES_VERSION_PATCH)
3456 #if (NCURSES_VERSION_PATCH < 20100501) && (NCURSES_VERSION_PATCH >= 20100403)
3457         make an error
3458 #endif
3459 #endif
3460 #ifdef NCURSES_VERSION
3461         cchar_t check;
3462         int check2 = curs_set((int)sizeof(check));
3463 #endif
3464         long x = winnstr(stdscr, "", 0);
3465         int x1, y1;
3466         getbegyx(stdscr, y1, x1)],
3467         [cf_cv_need_xopen_extension=none],
3468         [
3469         for cf_try_xopen_extension in _XOPEN_SOURCE_EXTENDED NCURSES_WIDECHAR
3470         do
3471                 AC_TRY_LINK([
3472 #define $cf_try_xopen_extension 1
3473 #include <stdlib.h>
3474 #include <${cf_cv_ncurses_header:-curses.h}>],[
3475 #ifdef NCURSES_VERSION
3476                 cchar_t check;
3477                 int check2 = curs_set((int)sizeof(check));
3478 #endif
3479                 long x = winnstr(stdscr, "", 0);
3480                 int x1, y1;
3481                 getbegyx(stdscr, y1, x1)],
3482                 [cf_cv_need_xopen_extension=$cf_try_xopen_extension; break])
3483         done
3484         ])
3485 ])
3486
3487 case $cf_cv_need_xopen_extension in
3488 (*_*)
3489         CPPFLAGS="$CPPFLAGS -D$cf_cv_need_xopen_extension"
3490         ;;
3491 esac
3492
3493 ])dnl
3494 dnl ---------------------------------------------------------------------------
3495 dnl CF_XOPEN_SOURCE version: 52 updated: 2016/08/27 12:21:42
3496 dnl ---------------
3497 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
3498 dnl or adapt to the vendor's definitions to get equivalent functionality,
3499 dnl without losing the common non-POSIX features.
3500 dnl
3501 dnl Parameters:
3502 dnl     $1 is the nominal value for _XOPEN_SOURCE
3503 dnl     $2 is the nominal value for _POSIX_C_SOURCE
3504 AC_DEFUN([CF_XOPEN_SOURCE],[
3505 AC_REQUIRE([AC_CANONICAL_HOST])
3506
3507 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
3508 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
3509 cf_xopen_source=
3510
3511 case $host_os in
3512 (aix[[4-7]]*)
3513         cf_xopen_source="-D_ALL_SOURCE"
3514         ;;
3515 (msys)
3516         cf_XOPEN_SOURCE=600
3517         ;;
3518 (darwin[[0-8]].*)
3519         cf_xopen_source="-D_APPLE_C_SOURCE"
3520         ;;
3521 (darwin*)
3522         cf_xopen_source="-D_DARWIN_C_SOURCE"
3523         cf_XOPEN_SOURCE=
3524         ;;
3525 (freebsd*|dragonfly*)
3526         # 5.x headers associate
3527         #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
3528         #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
3529         cf_POSIX_C_SOURCE=200112L
3530         cf_XOPEN_SOURCE=600
3531         cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
3532         ;;
3533 (hpux11*)
3534         cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
3535         ;;
3536 (hpux*)
3537         cf_xopen_source="-D_HPUX_SOURCE"
3538         ;;
3539 (irix[[56]].*)
3540         cf_xopen_source="-D_SGI_SOURCE"
3541         cf_XOPEN_SOURCE=
3542         ;;
3543 (linux*|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin)
3544         CF_GNU_SOURCE
3545         ;;
3546 (minix*)
3547         cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
3548         ;;
3549 (mirbsd*)
3550         # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
3551         cf_XOPEN_SOURCE=
3552         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
3553         ;;
3554 (netbsd*)
3555         cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
3556         ;;
3557 (openbsd[[4-9]]*)
3558         # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
3559         cf_xopen_source="-D_BSD_SOURCE"
3560         cf_XOPEN_SOURCE=600
3561         ;;
3562 (openbsd*)
3563         # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
3564         ;;
3565 (osf[[45]]*)
3566         cf_xopen_source="-D_OSF_SOURCE"
3567         ;;
3568 (nto-qnx*)
3569         cf_xopen_source="-D_QNX_SOURCE"
3570         ;;
3571 (sco*)
3572         # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
3573         ;;
3574 (solaris2.*)
3575         cf_xopen_source="-D__EXTENSIONS__"
3576         cf_cv_xopen_source=broken
3577         ;;
3578 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
3579         cf_XOPEN_SOURCE=
3580         cf_POSIX_C_SOURCE=
3581         ;;
3582 (*)
3583         CF_TRY_XOPEN_SOURCE
3584         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
3585         ;;
3586 esac
3587
3588 if test -n "$cf_xopen_source" ; then
3589         CF_ADD_CFLAGS($cf_xopen_source,true)
3590 fi
3591
3592 dnl In anything but the default case, we may have system-specific setting
3593 dnl which is still not guaranteed to provide all of the entrypoints that
3594 dnl _XOPEN_SOURCE would yield.
3595 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
3596         AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
3597         AC_TRY_COMPILE([#include <stdlib.h>],[
3598 #ifndef _XOPEN_SOURCE
3599 make an error
3600 #endif],
3601         [cf_XOPEN_SOURCE_set=yes],
3602         [cf_XOPEN_SOURCE_set=no])
3603         AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
3604         if test $cf_XOPEN_SOURCE_set = yes
3605         then
3606                 AC_TRY_COMPILE([#include <stdlib.h>],[
3607 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
3608 make an error
3609 #endif],
3610                 [cf_XOPEN_SOURCE_set_ok=yes],
3611                 [cf_XOPEN_SOURCE_set_ok=no])
3612                 if test $cf_XOPEN_SOURCE_set_ok = no
3613                 then
3614                         AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
3615                 fi
3616         else
3617                 CF_TRY_XOPEN_SOURCE
3618         fi
3619 fi
3620 ])
3621 dnl ---------------------------------------------------------------------------
3622 dnl CF_X_ATHENA version: 23 updated: 2015/04/12 15:39:00
3623 dnl -----------
3624 dnl Check for Xaw (Athena) libraries
3625 dnl
3626 dnl Sets $cf_x_athena according to the flavor of Xaw which is used.
3627 AC_DEFUN([CF_X_ATHENA],
3628 [
3629 cf_x_athena=${cf_x_athena:-Xaw}
3630
3631 AC_MSG_CHECKING(if you want to link with Xaw 3d library)
3632 withval=
3633 AC_ARG_WITH(Xaw3d,
3634         [  --with-Xaw3d            link with Xaw 3d library])
3635 if test "$withval" = yes ; then
3636         cf_x_athena=Xaw3d
3637         AC_MSG_RESULT(yes)
3638 else
3639         AC_MSG_RESULT(no)
3640 fi
3641
3642 AC_MSG_CHECKING(if you want to link with Xaw 3d xft library)
3643 withval=
3644 AC_ARG_WITH(Xaw3dxft,
3645         [  --with-Xaw3dxft         link with Xaw 3d xft library])
3646 if test "$withval" = yes ; then
3647         cf_x_athena=Xaw3dxft
3648         AC_MSG_RESULT(yes)
3649 else
3650         AC_MSG_RESULT(no)
3651 fi
3652
3653 AC_MSG_CHECKING(if you want to link with neXT Athena library)
3654 withval=
3655 AC_ARG_WITH(neXtaw,
3656         [  --with-neXtaw           link with neXT Athena library])
3657 if test "$withval" = yes ; then
3658         cf_x_athena=neXtaw
3659         AC_MSG_RESULT(yes)
3660 else
3661         AC_MSG_RESULT(no)
3662 fi
3663
3664 AC_MSG_CHECKING(if you want to link with Athena-Plus library)
3665 withval=
3666 AC_ARG_WITH(XawPlus,
3667         [  --with-XawPlus          link with Athena-Plus library])
3668 if test "$withval" = yes ; then
3669         cf_x_athena=XawPlus
3670         AC_MSG_RESULT(yes)
3671 else
3672         AC_MSG_RESULT(no)
3673 fi
3674
3675 cf_x_athena_lib=""
3676
3677 if test "$PKG_CONFIG" != none ; then
3678         cf_athena_list=
3679         test "$cf_x_athena" = Xaw && cf_athena_list="xaw8 xaw7 xaw6"
3680         for cf_athena_pkg in \
3681                 $cf_athena_list \
3682                 ${cf_x_athena} \
3683                 ${cf_x_athena}-devel \
3684                 lib${cf_x_athena} \
3685                 lib${cf_x_athena}-devel
3686         do
3687                 CF_TRY_PKG_CONFIG($cf_athena_pkg,[
3688                         cf_x_athena_lib="$cf_pkgconfig_libs"
3689                         CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
3690                         AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
3691
3692                         CF_TRIM_X_LIBS
3693
3694 AC_CACHE_CHECK(for usable $cf_x_athena/Xmu package,cf_cv_xaw_compat,[
3695 AC_TRY_LINK([
3696 #include <X11/Xmu/CharSet.h>
3697 ],[
3698 int check = XmuCompareISOLatin1("big", "small")
3699 ],[cf_cv_xaw_compat=yes],[cf_cv_xaw_compat=no])])
3700
3701                         if test "$cf_cv_xaw_compat" = no
3702                         then
3703                                 # workaround for broken ".pc" files...
3704                                 case "$cf_x_athena_lib" in
3705                                 (*-lXmu*)
3706                                         ;;
3707                                 (*)
3708                                         CF_VERBOSE(work around broken package)
3709                                         cf_save_xmu="$LIBS"
3710                                         cf_first_lib=`echo "$cf_save_xmu" | sed -e 's/^[ ][ ]*//' -e 's/ .*//'`
3711                                         CF_TRY_PKG_CONFIG(xmu,[
3712                                                         LIBS="$cf_save_xmu"
3713                                                         CF_ADD_LIB_AFTER($cf_first_lib,$cf_pkgconfig_libs)
3714                                                 ],[
3715                                                         CF_ADD_LIB_AFTER($cf_first_lib,-lXmu)
3716                                                 ])
3717                                         CF_TRIM_X_LIBS
3718                                         ;;
3719                                 esac
3720                         fi
3721
3722                         break])
3723         done
3724 fi
3725
3726 if test -z "$cf_x_athena_lib" ; then
3727         CF_X_EXT
3728         CF_X_TOOLKIT
3729         CF_X_ATHENA_CPPFLAGS($cf_x_athena)
3730         CF_X_ATHENA_LIBS($cf_x_athena)
3731 fi
3732 ])dnl
3733 dnl ---------------------------------------------------------------------------
3734 dnl CF_X_ATHENA_CPPFLAGS version: 5 updated: 2010/05/26 17:35:30
3735 dnl --------------------
3736 dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
3737 dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
3738 AC_DEFUN([CF_X_ATHENA_CPPFLAGS],
3739 [
3740 cf_x_athena_root=ifelse([$1],,Xaw,[$1])
3741 cf_x_athena_inc=""
3742
3743 for cf_path in default \
3744         /usr/contrib/X11R6 \
3745         /usr/contrib/X11R5 \
3746         /usr/lib/X11R5 \
3747         /usr/local
3748 do
3749         if test -z "$cf_x_athena_inc" ; then
3750                 cf_save="$CPPFLAGS"
3751                 cf_test=X11/$cf_x_athena_root/SimpleMenu.h
3752                 if test $cf_path != default ; then
3753                         CPPFLAGS="$cf_save -I$cf_path/include"
3754                         AC_MSG_CHECKING(for $cf_test in $cf_path)
3755                 else
3756                         AC_MSG_CHECKING(for $cf_test)
3757                 fi
3758                 AC_TRY_COMPILE([
3759 #include <X11/Intrinsic.h>
3760 #include <$cf_test>],[],
3761                         [cf_result=yes],
3762                         [cf_result=no])
3763                 AC_MSG_RESULT($cf_result)
3764                 if test "$cf_result" = yes ; then
3765                         cf_x_athena_inc=$cf_path
3766                         break
3767                 else
3768                         CPPFLAGS="$cf_save"
3769                 fi
3770         fi
3771 done
3772
3773 if test -z "$cf_x_athena_inc" ; then
3774         AC_MSG_WARN(
3775 [Unable to successfully find Athena header files with test program])
3776 elif test "$cf_x_athena_inc" != default ; then
3777         CPPFLAGS="$CPPFLAGS -I$cf_x_athena_inc"
3778 fi
3779 ])
3780 dnl ---------------------------------------------------------------------------
3781 dnl CF_X_ATHENA_LIBS version: 12 updated: 2011/07/17 19:55:02
3782 dnl ----------------
3783 dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
3784 dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
3785 AC_DEFUN([CF_X_ATHENA_LIBS],
3786 [AC_REQUIRE([CF_X_TOOLKIT])
3787 cf_x_athena_root=ifelse([$1],,Xaw,[$1])
3788 cf_x_athena_lib=""
3789
3790 for cf_path in default \
3791         /usr/contrib/X11R6 \
3792         /usr/contrib/X11R5 \
3793         /usr/lib/X11R5 \
3794         /usr/local
3795 do
3796         for cf_lib in \
3797                 ${cf_x_athena_root} \
3798                 ${cf_x_athena_root}7 \
3799                 ${cf_x_athena_root}6
3800         do
3801         for cf_libs in \
3802                 "-l$cf_lib -lXmu" \
3803                 "-l$cf_lib -lXpm -lXmu" \
3804                 "-l${cf_lib}_s -lXmu_s"
3805         do
3806                 if test -z "$cf_x_athena_lib" ; then
3807                         cf_save="$LIBS"
3808                         cf_test=XawSimpleMenuAddGlobalActions
3809                         if test $cf_path != default ; then
3810                                 CF_ADD_LIBS(-L$cf_path/lib $cf_libs)
3811                                 AC_MSG_CHECKING(for $cf_libs in $cf_path)
3812                         else
3813                                 CF_ADD_LIBS($cf_libs)
3814                                 AC_MSG_CHECKING(for $cf_test in $cf_libs)
3815                         fi
3816                         AC_TRY_LINK([
3817 #include <X11/Intrinsic.h>
3818 #include <X11/$cf_x_athena_root/SimpleMenu.h>
3819 ],[
3820 $cf_test((XtAppContext) 0)],
3821                                 [cf_result=yes],
3822                                 [cf_result=no])
3823                         AC_MSG_RESULT($cf_result)
3824                         if test "$cf_result" = yes ; then
3825                                 cf_x_athena_lib="$cf_libs"
3826                                 break
3827                         fi
3828                         LIBS="$cf_save"
3829                 fi
3830         done # cf_libs
3831                 test -n "$cf_x_athena_lib" && break
3832         done # cf_lib
3833 done
3834
3835 if test -z "$cf_x_athena_lib" ; then
3836         AC_MSG_ERROR(
3837 [Unable to successfully link Athena library (-l$cf_x_athena_root) with test program])
3838 fi
3839
3840 CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
3841 AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
3842 ])
3843 dnl ---------------------------------------------------------------------------
3844 dnl CF_X_EXT version: 3 updated: 2010/06/02 05:03:05
3845 dnl --------
3846 AC_DEFUN([CF_X_EXT],[
3847 CF_TRY_PKG_CONFIG(Xext,,[
3848         AC_CHECK_LIB(Xext,XextCreateExtension,
3849                 [CF_ADD_LIB(Xext)])])
3850 ])dnl
3851 dnl ---------------------------------------------------------------------------
3852 dnl CF_X_TOOLKIT version: 23 updated: 2015/04/12 15:39:00
3853 dnl ------------
3854 dnl Check for X Toolkit libraries
3855 AC_DEFUN([CF_X_TOOLKIT],
3856 [
3857 AC_REQUIRE([AC_PATH_XTRA])
3858 AC_REQUIRE([CF_CHECK_CACHE])
3859
3860 # OSX is schizoid about who owns /usr/X11 (old) versus /opt/X11 (new), and (and
3861 # in some cases has installed dummy files in the former, other cases replaced
3862 # it with a link to the new location).  This complicates the configure script.
3863 # Check for that pitfall, and recover using pkg-config
3864 #
3865 # If none of these are set, the configuration is almost certainly broken.
3866 if test -z "${X_CFLAGS}${X_PRE_LIBS}${X_LIBS}${X_EXTRA_LIBS}"
3867 then
3868         CF_TRY_PKG_CONFIG(x11,,[AC_MSG_WARN(unable to find X11 library)])
3869         CF_TRY_PKG_CONFIG(ice,,[AC_MSG_WARN(unable to find ICE library)])
3870         CF_TRY_PKG_CONFIG(sm,,[AC_MSG_WARN(unable to find SM library)])
3871         CF_TRY_PKG_CONFIG(xt,,[AC_MSG_WARN(unable to find Xt library)])
3872 fi
3873
3874 cf_have_X_LIBS=no
3875
3876 CF_TRY_PKG_CONFIG(xt,[
3877
3878         case "x$LIBS" in
3879         (*-lX11*)
3880                 ;;
3881         (*)
3882 # we have an "xt" package, but it may omit Xt's dependency on X11
3883 AC_CACHE_CHECK(for usable X dependency,cf_cv_xt_x11_compat,[
3884 AC_TRY_LINK([
3885 #include <X11/Xlib.h>
3886 ],[
3887         int rc1 = XDrawLine((Display*) 0, (Drawable) 0, (GC) 0, 0, 0, 0, 0);
3888         int rc2 = XClearWindow((Display*) 0, (Window) 0);
3889         int rc3 = XMoveWindow((Display*) 0, (Window) 0, 0, 0);
3890         int rc4 = XMoveResizeWindow((Display*)0, (Window)0, 0, 0, 0, 0);
3891 ],[cf_cv_xt_x11_compat=yes],[cf_cv_xt_x11_compat=no])])
3892                 if test "$cf_cv_xt_x11_compat" = no
3893                 then
3894                         CF_VERBOSE(work around broken X11 dependency)
3895                         # 2010/11/19 - good enough until a working Xt on Xcb is delivered.
3896                         CF_TRY_PKG_CONFIG(x11,,[CF_ADD_LIB_AFTER(-lXt,-lX11)])
3897                 fi
3898                 ;;
3899         esac
3900
3901 AC_CACHE_CHECK(for usable X Toolkit package,cf_cv_xt_ice_compat,[
3902 AC_TRY_LINK([
3903 #include <X11/Shell.h>
3904 ],[int num = IceConnectionNumber(0)
3905 ],[cf_cv_xt_ice_compat=yes],[cf_cv_xt_ice_compat=no])])
3906
3907         if test "$cf_cv_xt_ice_compat" = no
3908         then
3909                 # workaround for broken ".pc" files used for X Toolkit.
3910                 case "x$X_PRE_LIBS" in
3911                 (*-lICE*)
3912                         case "x$LIBS" in
3913                         (*-lICE*)
3914                                 ;;
3915                         (*)
3916                                 CF_VERBOSE(work around broken ICE dependency)
3917                                 CF_TRY_PKG_CONFIG(ice,
3918                                         [CF_TRY_PKG_CONFIG(sm)],
3919                                         [CF_ADD_LIB_AFTER(-lXt,$X_PRE_LIBS)])
3920                                 ;;
3921                         esac
3922                         ;;
3923                 esac
3924         fi
3925
3926         cf_have_X_LIBS=yes
3927 ],[
3928
3929         LDFLAGS="$X_LIBS $LDFLAGS"
3930         CF_CHECK_CFLAGS($X_CFLAGS)
3931
3932         AC_CHECK_FUNC(XOpenDisplay,,[
3933         AC_CHECK_LIB(X11,XOpenDisplay,
3934                 [CF_ADD_LIB(X11)],,
3935                 [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])])
3936
3937         AC_CHECK_FUNC(XtAppInitialize,,[
3938         AC_CHECK_LIB(Xt, XtAppInitialize,
3939                 [AC_DEFINE(HAVE_LIBXT,1,[Define to 1 if we can compile with the Xt library])
3940                  cf_have_X_LIBS=Xt
3941                  LIBS="-lXt $X_PRE_LIBS $LIBS $X_EXTRA_LIBS"],,
3942                 [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])])
3943 ])
3944
3945 if test $cf_have_X_LIBS = no ; then
3946         AC_MSG_WARN(
3947 [Unable to successfully link X Toolkit library (-lXt) with
3948 test program.  You will have to check and add the proper libraries by hand
3949 to makefile.])
3950 fi
3951 ])dnl
3952 dnl ---------------------------------------------------------------------------
3953 dnl CF__CURSES_HEAD version: 2 updated: 2010/10/23 15:54:49
3954 dnl ---------------
3955 dnl Define a reusable chunk which includes <curses.h> and <term.h> when they
3956 dnl are both available.
3957 define([CF__CURSES_HEAD],[
3958 #ifdef HAVE_XCURSES
3959 #include <xcurses.h>
3960 char * XCursesProgramName = "test";
3961 #else
3962 #include <${cf_cv_ncurses_header:-curses.h}>
3963 #if defined(NCURSES_VERSION) && defined(HAVE_NCURSESW_TERM_H)
3964 #include <ncursesw/term.h>
3965 #elif defined(NCURSES_VERSION) && defined(HAVE_NCURSES_TERM_H)
3966 #include <ncurses/term.h>
3967 #elif defined(HAVE_TERM_H)
3968 #include <term.h>
3969 #endif
3970 #endif
3971 ])