test/aclocal.m4

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