test/aclocal.m4

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