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