test/aclocal.m4

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