test/aclocal.m4

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