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