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