test/aclocal.m4

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