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