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