test/aclocal.m4

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