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.124 2015/12/13 02:14:52 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_FUNC_OPENPTY version: 5 updated: 2015/09/12 14:46:50
1301 dnl ---------------
1302 dnl Check for openpty() function, along with <pty.h> header.  It may need the
1303 dnl "util" library as well.
1304 AC_DEFUN([CF_FUNC_OPENPTY],
1305 [
1306 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1307 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1308         cf_save_LIBS="$LIBS"
1309         test $cf_cv_lib_util = yes && { CF_ADD_LIB(util) }
1310         for cf_header in pty.h libutil.h util.h
1311         do
1312         AC_TRY_LINK([
1313 #include <$cf_header>
1314 ],[
1315         int x = openpty((int *)0, (int *)0, (char *)0,
1316                                    (struct termios *)0, (struct winsize *)0);
1317 ],[
1318                 cf_cv_func_openpty=$cf_header
1319                 break
1320 ],[
1321                 cf_cv_func_openpty=no
1322 ])
1323         done
1324         LIBS="$cf_save_LIBS"
1325 ])
1326 ])dnl
1327 dnl ---------------------------------------------------------------------------
1328 dnl CF_GCC_ATTRIBUTES version: 17 updated: 2015/04/12 15:39:00
1329 dnl -----------------
1330 dnl Test for availability of useful gcc __attribute__ directives to quiet
1331 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1332 dnl to documentation, unrecognized directives cause older compilers to barf.
1333 AC_DEFUN([CF_GCC_ATTRIBUTES],
1334 [
1335 if test "$GCC" = yes
1336 then
1337 cat > conftest.i <<EOF
1338 #ifndef GCC_PRINTF
1339 #define GCC_PRINTF 0
1340 #endif
1341 #ifndef GCC_SCANF
1342 #define GCC_SCANF 0
1343 #endif
1344 #ifndef GCC_NORETURN
1345 #define GCC_NORETURN /* nothing */
1346 #endif
1347 #ifndef GCC_UNUSED
1348 #define GCC_UNUSED /* nothing */
1349 #endif
1350 EOF
1351 if test "$GCC" = yes
1352 then
1353         AC_CHECKING([for $CC __attribute__ directives])
1354 cat > conftest.$ac_ext <<EOF
1355 #line __oline__ "${as_me:-configure}"
1356 #include "confdefs.h"
1357 #include "conftest.h"
1358 #include "conftest.i"
1359 #if     GCC_PRINTF
1360 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1361 #else
1362 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1363 #endif
1364 #if     GCC_SCANF
1365 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1366 #else
1367 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1368 #endif
1369 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1370 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1371 extern void foo(void) GCC_NORETURN;
1372 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1373 EOF
1374         cf_printf_attribute=no
1375         cf_scanf_attribute=no
1376         for cf_attribute in scanf printf unused noreturn
1377         do
1378                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1379                 cf_directive="__attribute__(($cf_attribute))"
1380                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1381
1382                 case $cf_attribute in
1383                 (printf)
1384                         cf_printf_attribute=yes
1385                         cat >conftest.h <<EOF
1386 #define GCC_$cf_ATTRIBUTE 1
1387 EOF
1388                         ;;
1389                 (scanf)
1390                         cf_scanf_attribute=yes
1391                         cat >conftest.h <<EOF
1392 #define GCC_$cf_ATTRIBUTE 1
1393 EOF
1394                         ;;
1395                 (*)
1396                         cat >conftest.h <<EOF
1397 #define GCC_$cf_ATTRIBUTE $cf_directive
1398 EOF
1399                         ;;
1400                 esac
1401
1402                 if AC_TRY_EVAL(ac_compile); then
1403                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1404                         cat conftest.h >>confdefs.h
1405                         case $cf_attribute in
1406                         (noreturn)
1407                                 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1408                                 ;;
1409                         (printf)
1410                                 cf_value='/* nothing */'
1411                                 if test "$cf_printf_attribute" != no ; then
1412                                         cf_value='__attribute__((format(printf,fmt,var)))'
1413                                         AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1414                                 fi
1415                                 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1416                                 ;;
1417                         (scanf)
1418                                 cf_value='/* nothing */'
1419                                 if test "$cf_scanf_attribute" != no ; then
1420                                         cf_value='__attribute__((format(scanf,fmt,var)))'
1421                                         AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1422                                 fi
1423                                 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1424                                 ;;
1425                         (unused)
1426                                 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
1427                                 ;;
1428                         esac
1429                 fi
1430         done
1431 else
1432         fgrep define conftest.i >>confdefs.h
1433 fi
1434 rm -rf conftest*
1435 fi
1436 ])dnl
1437 dnl ---------------------------------------------------------------------------
1438 dnl CF_GCC_VERSION version: 7 updated: 2012/10/18 06:46:33
1439 dnl --------------
1440 dnl Find version of gcc
1441 AC_DEFUN([CF_GCC_VERSION],[
1442 AC_REQUIRE([AC_PROG_CC])
1443 GCC_VERSION=none
1444 if test "$GCC" = yes ; then
1445         AC_MSG_CHECKING(version of $CC)
1446         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.]].*//'`"
1447         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1448         AC_MSG_RESULT($GCC_VERSION)
1449 fi
1450 ])dnl
1451 dnl ---------------------------------------------------------------------------
1452 dnl CF_GCC_WARNINGS version: 32 updated: 2015/04/12 15:39:00
1453 dnl ---------------
1454 dnl Check if the compiler supports useful warning options.  There's a few that
1455 dnl we don't use, simply because they're too noisy:
1456 dnl
1457 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1458 dnl     -Wredundant-decls (system headers make this too noisy)
1459 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1460 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1461 dnl             is enabled for ncurses using "--enable-const".
1462 dnl     -pedantic
1463 dnl
1464 dnl Parameter:
1465 dnl     $1 is an optional list of gcc warning flags that a particular
1466 dnl             application might want to use, e.g., "no-unused" for
1467 dnl             -Wno-unused
1468 dnl Special:
1469 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1470 dnl
1471 AC_DEFUN([CF_GCC_WARNINGS],
1472 [
1473 AC_REQUIRE([CF_GCC_VERSION])
1474 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1475 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
1476
1477 cat > conftest.$ac_ext <<EOF
1478 #line __oline__ "${as_me:-configure}"
1479 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1480 EOF
1481
1482 if test "$INTEL_COMPILER" = yes
1483 then
1484 # The "-wdXXX" options suppress warnings:
1485 # remark #1419: external declaration in primary source file
1486 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1487 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1488 # remark #193: zero used for undefined preprocessing identifier
1489 # remark #593: variable "curs_sb_left_arrow" was set but never used
1490 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1491 # remark #869: parameter "tw" was never referenced
1492 # remark #981: operands are evaluated in unspecified order
1493 # warning #279: controlling expression is constant
1494
1495         AC_CHECKING([for $CC warning options])
1496         cf_save_CFLAGS="$CFLAGS"
1497         EXTRA_CFLAGS="-Wall"
1498         for cf_opt in \
1499                 wd1419 \
1500                 wd1683 \
1501                 wd1684 \
1502                 wd193 \
1503                 wd593 \
1504                 wd279 \
1505                 wd810 \
1506                 wd869 \
1507                 wd981
1508         do
1509                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1510                 if AC_TRY_EVAL(ac_compile); then
1511                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1512                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1513                 fi
1514         done
1515         CFLAGS="$cf_save_CFLAGS"
1516
1517 elif test "$GCC" = yes
1518 then
1519         AC_CHECKING([for $CC warning options])
1520         cf_save_CFLAGS="$CFLAGS"
1521         EXTRA_CFLAGS=
1522         cf_warn_CONST=""
1523         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1524         cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
1525         test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
1526         for cf_opt in W Wall \
1527                 Wbad-function-cast \
1528                 Wcast-align \
1529                 Wcast-qual \
1530                 Wdeclaration-after-statement \
1531                 Wextra \
1532                 Winline \
1533                 Wmissing-declarations \
1534                 Wmissing-prototypes \
1535                 Wnested-externs \
1536                 Wpointer-arith \
1537                 Wshadow \
1538                 Wstrict-prototypes \
1539                 Wundef $cf_gcc_warnings $cf_warn_CONST $1
1540         do
1541                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1542                 if AC_TRY_EVAL(ac_compile); then
1543                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1544                         case $cf_opt in
1545                         (Wcast-qual)
1546                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1547                                 ;;
1548                         (Winline)
1549                                 case $GCC_VERSION in
1550                                 ([[34]].*)
1551                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1552                                         continue;;
1553                                 esac
1554                                 ;;
1555                         (Wpointer-arith)
1556                                 case $GCC_VERSION in
1557                                 ([[12]].*)
1558                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1559                                         continue;;
1560                                 esac
1561                                 ;;
1562                         esac
1563                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1564                 fi
1565         done
1566         CFLAGS="$cf_save_CFLAGS"
1567 fi
1568 rm -rf conftest*
1569
1570 AC_SUBST(EXTRA_CFLAGS)
1571 ])dnl
1572 dnl ---------------------------------------------------------------------------
1573 dnl CF_GETOPT_HEADER version: 6 updated: 2014/07/22 14:45:54
1574 dnl ----------------
1575 dnl Check for getopt's variables which are commonly defined in stdlib.h,
1576 dnl unistd.h or (nonstandard) in getopt.h
1577 AC_DEFUN([CF_GETOPT_HEADER],
1578 [
1579 AC_HAVE_HEADERS(unistd.h getopt.h)
1580 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
1581 cf_cv_getopt_header=none
1582 for cf_header in stdio.h stdlib.h unistd.h getopt.h
1583 do
1584 AC_TRY_COMPILE([
1585 #include <$cf_header>],
1586 [int x = optind; char *y = optarg],
1587 [cf_cv_getopt_header=$cf_header
1588  break])
1589 done
1590 ])
1591 if test $cf_cv_getopt_header != none ; then
1592         AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
1593 fi
1594 if test $cf_cv_getopt_header = getopt.h ; then
1595         AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
1596 fi
1597 ])dnl
1598 dnl ---------------------------------------------------------------------------
1599 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1600 dnl -------------
1601 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1602 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1603 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1604 dnl since it is interwoven with GNU extensions.
1605 dnl
1606 dnl Well, yes we could work around it...
1607 AC_DEFUN([CF_GNU_SOURCE],
1608 [
1609 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1610 AC_TRY_COMPILE([#include <sys/types.h>],[
1611 #ifndef _XOPEN_SOURCE
1612 make an error
1613 #endif],
1614         [cf_cv_gnu_source=no],
1615         [cf_save="$CPPFLAGS"
1616          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1617          AC_TRY_COMPILE([#include <sys/types.h>],[
1618 #ifdef _XOPEN_SOURCE
1619 make an error
1620 #endif],
1621         [cf_cv_gnu_source=no],
1622         [cf_cv_gnu_source=yes])
1623         CPPFLAGS="$cf_save"
1624         ])
1625 ])
1626 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1627 ])dnl
1628 dnl ---------------------------------------------------------------------------
1629 dnl CF_HEADER_PATH version: 13 updated: 2015/04/15 19:08:48
1630 dnl --------------
1631 dnl Construct a search-list of directories for a nonstandard header-file
1632 dnl
1633 dnl Parameters
1634 dnl     $1 = the variable to return as result
1635 dnl     $2 = the package name
1636 AC_DEFUN([CF_HEADER_PATH],
1637 [
1638 $1=
1639
1640 # collect the current set of include-directories from compiler flags
1641 cf_header_path_list=""
1642 if test -n "${CFLAGS}${CPPFLAGS}" ; then
1643         for cf_header_path in $CPPFLAGS $CFLAGS
1644         do
1645                 case $cf_header_path in
1646                 (-I*)
1647                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
1648                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
1649                         cf_header_path_list="$cf_header_path_list [$]$1"
1650                         ;;
1651                 esac
1652         done
1653 fi
1654
1655 # add the variations for the package we are looking for
1656 CF_SUBDIR_PATH($1,$2,include)
1657
1658 test "$includedir" != NONE && \
1659 test "$includedir" != "/usr/include" && \
1660 test -d "$includedir" && {
1661         test -d $includedir &&    $1="[$]$1 $includedir"
1662         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
1663 }
1664
1665 test "$oldincludedir" != NONE && \
1666 test "$oldincludedir" != "/usr/include" && \
1667 test -d "$oldincludedir" && {
1668         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
1669         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
1670 }
1671
1672 $1="[$]$1 $cf_header_path_list"
1673 ])dnl
1674 dnl ---------------------------------------------------------------------------
1675 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
1676 dnl ---------------
1677 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
1678 AC_DEFUN([CF_HELP_MESSAGE],
1679 [AC_DIVERT_HELP([$1])dnl
1680 ])dnl
1681 dnl ---------------------------------------------------------------------------
1682 dnl CF_INHERIT_SCRIPT version: 2 updated: 2003/03/01 23:50:42
1683 dnl -----------------
1684 dnl If we do not have a given script, look for it in the parent directory.
1685 AC_DEFUN([CF_INHERIT_SCRIPT],
1686 [
1687 test -f $1 || ( test -f ../$1 && cp ../$1 ./ )
1688 ])dnl
1689 dnl ---------------------------------------------------------------------------
1690 dnl CF_INTEL_COMPILER version: 7 updated: 2015/04/12 15:39:00
1691 dnl -----------------
1692 dnl Check if the given compiler is really the Intel compiler for Linux.  It
1693 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
1694 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
1695 dnl
1696 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1697 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
1698 dnl the wrappers for gcc and g++ warnings.
1699 dnl
1700 dnl $1 = GCC (default) or GXX
1701 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
1702 dnl $3 = CFLAGS (default) or CXXFLAGS
1703 AC_DEFUN([CF_INTEL_COMPILER],[
1704 AC_REQUIRE([AC_CANONICAL_HOST])
1705 ifelse([$2],,INTEL_COMPILER,[$2])=no
1706
1707 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
1708         case $host_os in
1709         (linux*|gnu*)
1710                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
1711                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
1712                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
1713                 AC_TRY_COMPILE([],[
1714 #ifdef __INTEL_COMPILER
1715 #else
1716 make an error
1717 #endif
1718 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
1719 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
1720 ],[])
1721                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
1722                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
1723                 ;;
1724         esac
1725 fi
1726 ])dnl
1727 dnl ---------------------------------------------------------------------------
1728 dnl CF_LD_RPATH_OPT version: 6 updated: 2015/04/12 15:39:00
1729 dnl ---------------
1730 dnl For the given system and compiler, find the compiler flags to pass to the
1731 dnl loader to use the "rpath" feature.
1732 AC_DEFUN([CF_LD_RPATH_OPT],
1733 [
1734 AC_REQUIRE([CF_CHECK_CACHE])
1735
1736 LD_RPATH_OPT=
1737 AC_MSG_CHECKING(for an rpath option)
1738 case $cf_cv_system_name in
1739 (irix*)
1740         if test "$GCC" = yes; then
1741                 LD_RPATH_OPT="-Wl,-rpath,"
1742         else
1743                 LD_RPATH_OPT="-rpath "
1744         fi
1745         ;;
1746 (linux*|gnu*|k*bsd*-gnu)
1747         LD_RPATH_OPT="-Wl,-rpath,"
1748         ;;
1749 (openbsd[[2-9]].*|mirbsd*)
1750         LD_RPATH_OPT="-Wl,-rpath,"
1751         ;;
1752 (dragonfly*|freebsd*)
1753         LD_RPATH_OPT="-rpath "
1754         ;;
1755 (netbsd*)
1756         LD_RPATH_OPT="-Wl,-rpath,"
1757         ;;
1758 (osf*|mls+*)
1759         LD_RPATH_OPT="-rpath "
1760         ;;
1761 (solaris2*)
1762         LD_RPATH_OPT="-R"
1763         ;;
1764 (*)
1765         ;;
1766 esac
1767 AC_MSG_RESULT($LD_RPATH_OPT)
1768
1769 case "x$LD_RPATH_OPT" in
1770 (x-R*)
1771         AC_MSG_CHECKING(if we need a space after rpath option)
1772         cf_save_LIBS="$LIBS"
1773         CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
1774         AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
1775         LIBS="$cf_save_LIBS"
1776         AC_MSG_RESULT($cf_rpath_space)
1777         test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
1778         ;;
1779 esac
1780 ])dnl
1781 dnl ---------------------------------------------------------------------------
1782 dnl CF_LIBRARY_PATH version: 10 updated: 2015/04/15 19:08:48
1783 dnl ---------------
1784 dnl Construct a search-list of directories for a nonstandard library-file
1785 dnl
1786 dnl Parameters
1787 dnl     $1 = the variable to return as result
1788 dnl     $2 = the package name
1789 AC_DEFUN([CF_LIBRARY_PATH],
1790 [
1791 $1=
1792 cf_library_path_list=""
1793 if test -n "${LDFLAGS}${LIBS}" ; then
1794         for cf_library_path in $LDFLAGS $LIBS
1795         do
1796                 case $cf_library_path in
1797                 (-L*)
1798                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
1799                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
1800                         cf_library_path_list="$cf_library_path_list [$]$1"
1801                         ;;
1802                 esac
1803         done
1804 fi
1805
1806 CF_SUBDIR_PATH($1,$2,lib)
1807
1808 $1="$cf_library_path_list [$]$1"
1809 ])dnl
1810 dnl ---------------------------------------------------------------------------
1811 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
1812 dnl ------------
1813 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
1814 dnl a monocase filesystem.
1815 AC_DEFUN([CF_MAKE_TAGS],[
1816 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
1817
1818 AC_CHECK_PROGS(CTAGS, exctags ctags)
1819 AC_CHECK_PROGS(ETAGS, exetags etags)
1820
1821 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
1822
1823 if test "$cf_cv_mixedcase" = yes ; then
1824         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
1825 else
1826         MAKE_UPPER_TAGS=no
1827 fi
1828
1829 if test "$MAKE_UPPER_TAGS" = yes ; then
1830         MAKE_UPPER_TAGS=
1831 else
1832         MAKE_UPPER_TAGS="#"
1833 fi
1834
1835 if test "$MAKE_LOWER_TAGS" = yes ; then
1836         MAKE_LOWER_TAGS=
1837 else
1838         MAKE_LOWER_TAGS="#"
1839 fi
1840
1841 AC_SUBST(CTAGS)
1842 AC_SUBST(ETAGS)
1843
1844 AC_SUBST(MAKE_UPPER_TAGS)
1845 AC_SUBST(MAKE_LOWER_TAGS)
1846 ])dnl
1847 dnl ---------------------------------------------------------------------------
1848 dnl CF_MATH_LIB version: 8 updated: 2010/05/29 16:31:02
1849 dnl -----------
1850 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
1851 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
1852 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
1853 AC_DEFUN([CF_MATH_LIB],
1854 [
1855 AC_CACHE_CHECK(if -lm needed for math functions,
1856         cf_cv_need_libm,[
1857         AC_TRY_LINK([
1858         #include <stdio.h>
1859         #include <math.h>
1860         ],
1861         [double x = rand(); printf("result = %g\n", ]ifelse([$2],,sin(x),$2)[)],
1862         [cf_cv_need_libm=no],
1863         [cf_cv_need_libm=yes])])
1864 if test "$cf_cv_need_libm" = yes
1865 then
1866 ifelse($1,,[
1867         CF_ADD_LIB(m)
1868 ],[$1=-lm])
1869 fi
1870 ])
1871 dnl ---------------------------------------------------------------------------
1872 dnl CF_MIXEDCASE_FILENAMES version: 7 updated: 2015/04/12 15:39:00
1873 dnl ----------------------
1874 dnl Check if the file-system supports mixed-case filenames.  If we're able to
1875 dnl create a lowercase name and see it as uppercase, it doesn't support that.
1876 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
1877 [
1878 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
1879 if test "$cross_compiling" = yes ; then
1880         case $target_alias in
1881         (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*)
1882                 cf_cv_mixedcase=no
1883                 ;;
1884         (*)
1885                 cf_cv_mixedcase=yes
1886                 ;;
1887         esac
1888 else
1889         rm -f conftest CONFTEST
1890         echo test >conftest
1891         if test -f CONFTEST ; then
1892                 cf_cv_mixedcase=no
1893         else
1894                 cf_cv_mixedcase=yes
1895         fi
1896         rm -f conftest CONFTEST
1897 fi
1898 ])
1899 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
1900 ])dnl
1901 dnl ---------------------------------------------------------------------------
1902 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
1903 dnl ----------
1904 dnl Write a debug message to config.log, along with the line number in the
1905 dnl configure script.
1906 AC_DEFUN([CF_MSG_LOG],[
1907 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
1908 ])dnl
1909 dnl ---------------------------------------------------------------------------
1910 dnl CF_NCURSES_CC_CHECK version: 4 updated: 2007/07/29 10:39:05
1911 dnl -------------------
1912 dnl Check if we can compile with ncurses' header file
1913 dnl $1 is the cache variable to set
1914 dnl $2 is the header-file to include
1915 dnl $3 is the root name (ncurses or ncursesw)
1916 AC_DEFUN([CF_NCURSES_CC_CHECK],[
1917         AC_TRY_COMPILE([
1918 ]ifelse($3,ncursesw,[
1919 #define _XOPEN_SOURCE_EXTENDED
1920 #undef  HAVE_LIBUTF8_H  /* in case we used CF_UTF8_LIB */
1921 #define HAVE_LIBUTF8_H  /* to force ncurses' header file to use cchar_t */
1922 ])[
1923 #include <$2>],[
1924 #ifdef NCURSES_VERSION
1925 ]ifelse($3,ncursesw,[
1926 #ifndef WACS_BSSB
1927         make an error
1928 #endif
1929 ])[
1930 printf("%s\n", NCURSES_VERSION);
1931 #else
1932 #ifdef __NCURSES_H
1933 printf("old\n");
1934 #else
1935         make an error
1936 #endif
1937 #endif
1938         ]
1939         ,[$1=$2]
1940         ,[$1=no])
1941 ])dnl
1942 dnl ---------------------------------------------------------------------------
1943 dnl CF_NCURSES_CONFIG version: 17 updated: 2015/07/07 04:22:07
1944 dnl -----------------
1945 dnl Tie together the configure-script macros for ncurses, preferring these in
1946 dnl order:
1947 dnl a) ".pc" files for pkg-config, using $NCURSES_CONFIG_PKG
1948 dnl b) the "-config" script from ncurses, using $NCURSES_CONFIG
1949 dnl c) just plain libraries
1950 dnl
1951 dnl $1 is the root library name (default: "ncurses")
1952 AC_DEFUN([CF_NCURSES_CONFIG],[
1953 AC_REQUIRE([CF_PKG_CONFIG])
1954 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
1955 cf_have_ncuconfig=no
1956
1957 if test "x${PKG_CONFIG:=none}" != xnone; then
1958         AC_MSG_CHECKING(pkg-config for $cf_ncuconfig_root)
1959         if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
1960                 AC_MSG_RESULT(yes)
1961
1962                 AC_MSG_CHECKING(if the $cf_ncuconfig_root package files work)
1963                 cf_have_ncuconfig=unknown
1964
1965                 cf_save_CPPFLAGS="$CPPFLAGS"
1966                 cf_save_LIBS="$LIBS"
1967
1968                 CPPFLAGS="$CPPFLAGS `$PKG_CONFIG --cflags $cf_ncuconfig_root`"
1969                 CF_ADD_LIBS(`$PKG_CONFIG --libs $cf_ncuconfig_root`)
1970
1971                 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
1972                         [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
1973                         [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
1974                                 int main(void)
1975                                 { char *xx = curses_version(); return (xx == 0); }],
1976                                 [cf_have_ncuconfig=yes],
1977                                 [cf_have_ncuconfig=no],
1978                                 [cf_have_ncuconfig=maybe])],
1979                         [cf_have_ncuconfig=no])
1980                 AC_MSG_RESULT($cf_have_ncuconfig)
1981                 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
1982                 if test "$cf_have_ncuconfig" != "yes"
1983                 then
1984                         CPPFLAGS="$cf_save_CPPFLAGS"
1985                         LIBS="$cf_save_LIBS"
1986                         NCURSES_CONFIG_PKG=none
1987                 else
1988                         AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
1989                         NCURSES_CONFIG_PKG=$cf_ncuconfig_root
1990                 fi
1991
1992         else
1993                 AC_MSG_RESULT(no)
1994                 NCURSES_CONFIG_PKG=none
1995         fi
1996 else
1997         NCURSES_CONFIG_PKG=none
1998 fi
1999
2000 if test "x$cf_have_ncuconfig" = "xno"; then
2001         echo "Looking for ${cf_ncuconfig_root}-config"
2002
2003         CF_ACVERSION_CHECK(2.52,
2004                 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncuconfig_root}-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
2005                 [AC_PATH_PROGS(NCURSES_CONFIG,  ${cf_ncuconfig_root}-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
2006
2007         if test "$NCURSES_CONFIG" != none ; then
2008
2009                 CPPFLAGS="$CPPFLAGS `$NCURSES_CONFIG --cflags`"
2010                 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
2011
2012                 # even with config script, some packages use no-override for curses.h
2013                 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
2014
2015                 dnl like CF_NCURSES_CPPFLAGS
2016                 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2017
2018                 dnl like CF_NCURSES_LIBS
2019                 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
2020                 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2021
2022                 dnl like CF_NCURSES_VERSION
2023                 cf_cv_ncurses_version=`$NCURSES_CONFIG --version`
2024
2025         else
2026
2027                 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
2028                 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
2029
2030         fi
2031 else
2032         NCURSES_CONFIG=none
2033 fi
2034 ])dnl
2035 dnl ---------------------------------------------------------------------------
2036 dnl CF_NCURSES_CPPFLAGS version: 21 updated: 2012/10/06 08:57:51
2037 dnl -------------------
2038 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
2039 dnl the CPPFLAGS variable so we can include its header.
2040 dnl
2041 dnl The header files may be installed as either curses.h, or ncurses.h (would
2042 dnl be obsolete, except that some packagers prefer this name to distinguish it
2043 dnl from a "native" curses implementation).  If not installed for overwrite,
2044 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
2045 dnl /usr/include/ncurses), but someone may have installed overwriting the
2046 dnl vendor's curses.  Only very old versions (pre-1.9.2d, the first autoconf'd
2047 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
2048 dnl the header.
2049 dnl
2050 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
2051 dnl is already in the include-path, don't even bother with this, since we cannot
2052 dnl easily determine which file it is.  In this case, it has to be <curses.h>.
2053 dnl
2054 dnl The optional parameter gives the root name of the library, in case it is
2055 dnl not installed as the default curses library.  That is how the
2056 dnl wide-character version of ncurses is installed.
2057 AC_DEFUN([CF_NCURSES_CPPFLAGS],
2058 [AC_REQUIRE([CF_WITH_CURSES_DIR])
2059
2060 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
2061 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
2062
2063 test -n "$cf_cv_curses_dir" && \
2064 test "$cf_cv_curses_dir" != "no" && { \
2065   CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
2066 }
2067
2068 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
2069         cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
2070         ( test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw ) && cf_header_list="$cf_header_list curses.h ncurses.h"
2071         for cf_header in $cf_header_list
2072         do
2073                 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
2074                 test "$cf_cv_ncurses_h" != no && break
2075         done
2076 ])
2077
2078 CF_NCURSES_HEADER
2079 CF_TERM_HEADER
2080
2081 # some applications need this, but should check for NCURSES_VERSION
2082 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2083
2084 CF_NCURSES_VERSION
2085 ])dnl
2086 dnl ---------------------------------------------------------------------------
2087 dnl CF_NCURSES_EXT_FUNCS version: 4 updated: 2012/10/06 16:39:58
2088 dnl --------------------
2089 dnl Since 2007/11/17, ncurses has defined NCURSES_EXT_FUNCS; earlier versions
2090 dnl may provide these functions.  Define the symbol if it is not defined, and
2091 dnl if it is valid.
2092 AC_DEFUN([CF_NCURSES_EXT_FUNCS],
2093 [
2094 AC_CACHE_CHECK(for ncurses extended functions,cf_cv_ncurses_ext_funcs,[
2095 AC_TRY_COMPILE([
2096 #include <${cf_cv_ncurses_header:-curses.h}>],
2097 [
2098 int x = NCURSES_EXT_FUNCS
2099 ],[cf_cv_ncurses_ext_funcs=defined],[
2100 AC_TRY_LINK([
2101 #include <${cf_cv_ncurses_header:-curses.h}>],
2102 [
2103         (void) assume_default_colors (0, 0);
2104         (void) curses_version ();
2105         (void) define_key (0, 0);
2106         (void) is_term_resized (0, 0);
2107         (void) key_defined (0);
2108         (void) keybound (0, 0);
2109         (void) keyok (0, 0);
2110         (void) resize_term (0, 0);
2111         (void) resizeterm (0, 0);
2112         (void) use_default_colors ();
2113         (void) use_extended_names (0);
2114         (void) wresize (0, 0, 0);],
2115         [cf_cv_ncurses_ext_funcs=yes],
2116         [cf_cv_ncurses_ext_funcs=no])
2117 ])
2118 ])
2119 test "$cf_cv_ncurses_ext_funcs" = yes && AC_DEFINE(NCURSES_EXT_FUNCS,1,[Define to 1 if we have ncurses extensions])
2120 ])dnl
2121 dnl ---------------------------------------------------------------------------
2122 dnl CF_NCURSES_HEADER version: 4 updated: 2015/04/15 19:08:48
2123 dnl -----------------
2124 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
2125 dnl variations of ncurses' installs.
2126 dnl
2127 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
2128 AC_DEFUN([CF_NCURSES_HEADER],[
2129
2130 if test "$cf_cv_ncurses_h" != no ; then
2131         cf_cv_ncurses_header=$cf_cv_ncurses_h
2132 else
2133
2134 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
2135         test -n "$verbose" && echo
2136         CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
2137         test -n "$verbose" && echo search path $cf_search
2138         cf_save2_CPPFLAGS="$CPPFLAGS"
2139         for cf_incdir in $cf_search
2140         do
2141                 CF_ADD_INCDIR($cf_incdir)
2142                 for cf_header in \
2143                         ncurses.h \
2144                         curses.h
2145                 do
2146                         CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
2147                         if test "$cf_cv_ncurses_h2" != no ; then
2148                                 cf_cv_ncurses_h2=$cf_incdir/$cf_header
2149                                 test -n "$verbose" && echo $ac_n "      ... found $ac_c" 1>&AC_FD_MSG
2150                                 break
2151                         fi
2152                         test -n "$verbose" && echo "    ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
2153                 done
2154                 CPPFLAGS="$cf_save2_CPPFLAGS"
2155                 test "$cf_cv_ncurses_h2" != no && break
2156         done
2157         test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
2158         ])
2159
2160         CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
2161         cf_cv_ncurses_header=`basename $cf_cv_ncurses_h2`
2162         if test `basename $cf_1st_incdir` = $cf_ncuhdr_root ; then
2163                 cf_cv_ncurses_header=$cf_ncuhdr_root/$cf_cv_ncurses_header
2164         fi
2165         CF_ADD_INCDIR($cf_1st_incdir)
2166
2167 fi
2168
2169 # Set definitions to allow ifdef'ing for ncurses.h
2170
2171 case $cf_cv_ncurses_header in
2172 (*ncurses.h)
2173         AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
2174         ;;
2175 esac
2176
2177 case $cf_cv_ncurses_header in
2178 (ncurses/curses.h|ncurses/ncurses.h)
2179         AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
2180         ;;
2181 (ncursesw/curses.h|ncursesw/ncurses.h)
2182         AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
2183         ;;
2184 esac
2185
2186 ])dnl
2187 dnl ---------------------------------------------------------------------------
2188 dnl CF_NCURSES_LIBS version: 17 updated: 2015/04/15 19:08:48
2189 dnl ---------------
2190 dnl Look for the ncurses library.  This is a little complicated on Linux,
2191 dnl because it may be linked with the gpm (general purpose mouse) library.
2192 dnl Some distributions have gpm linked with (bsd) curses, which makes it
2193 dnl unusable with ncurses.  However, we don't want to link with gpm unless
2194 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
2195 dnl and the linker will record a dependency.
2196 dnl
2197 dnl The optional parameter gives the root name of the library, in case it is
2198 dnl not installed as the default curses library.  That is how the
2199 dnl wide-character version of ncurses is installed.
2200 AC_DEFUN([CF_NCURSES_LIBS],
2201 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
2202
2203 cf_nculib_root=ifelse($1,,ncurses,$1)
2204         # This works, except for the special case where we find gpm, but
2205         # ncurses is in a nonstandard location via $LIBS, and we really want
2206         # to link gpm.
2207 cf_ncurses_LIBS=""
2208 cf_ncurses_SAVE="$LIBS"
2209 AC_CHECK_LIB(gpm,Gpm_Open,
2210         [AC_CHECK_LIB(gpm,initscr,
2211                 [LIBS="$cf_ncurses_SAVE"],
2212                 [cf_ncurses_LIBS="-lgpm"])])
2213
2214 case $host_os in
2215 (freebsd*)
2216         # This is only necessary if you are linking against an obsolete
2217         # version of ncurses (but it should do no harm, since it's static).
2218         if test "$cf_nculib_root" = ncurses ; then
2219                 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
2220         fi
2221         ;;
2222 esac
2223
2224 CF_ADD_LIBS($cf_ncurses_LIBS)
2225
2226 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
2227 then
2228         CF_ADD_LIBS(-l$cf_nculib_root)
2229 else
2230         CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
2231                 [#include <${cf_cv_ncurses_header:-curses.h}>],
2232                 [initscr()],
2233                 initscr)
2234 fi
2235
2236 if test -n "$cf_ncurses_LIBS" ; then
2237         AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
2238         cf_ncurses_SAVE="$LIBS"
2239         for p in $cf_ncurses_LIBS ; do
2240                 q=`echo $LIBS | sed -e "s%$p %%" -e "s%$p$%%"`
2241                 if test "$q" != "$LIBS" ; then
2242                         LIBS="$q"
2243                 fi
2244         done
2245         AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2246                 [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2247                 [AC_MSG_RESULT(yes)],
2248                 [AC_MSG_RESULT(no)
2249                  LIBS="$cf_ncurses_SAVE"])
2250 fi
2251
2252 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
2253 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2254 ])dnl
2255 dnl ---------------------------------------------------------------------------
2256 dnl CF_NCURSES_VERSION version: 14 updated: 2012/10/06 08:57:51
2257 dnl ------------------
2258 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
2259 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS.  We don't use
2260 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
2261 AC_DEFUN([CF_NCURSES_VERSION],
2262 [
2263 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
2264 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
2265         cf_cv_ncurses_version=no
2266         cf_tempfile=out$$
2267         rm -f $cf_tempfile
2268         AC_TRY_RUN([
2269 #include <${cf_cv_ncurses_header:-curses.h}>
2270 #include <stdio.h>
2271 int main()
2272 {
2273         FILE *fp = fopen("$cf_tempfile", "w");
2274 #ifdef NCURSES_VERSION
2275 # ifdef NCURSES_VERSION_PATCH
2276         fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
2277 # else
2278         fprintf(fp, "%s\n", NCURSES_VERSION);
2279 # endif
2280 #else
2281 # ifdef __NCURSES_H
2282         fprintf(fp, "old\n");
2283 # else
2284         make an error
2285 # endif
2286 #endif
2287         ${cf_cv_main_return:-return}(0);
2288 }],[
2289         cf_cv_ncurses_version=`cat $cf_tempfile`],,[
2290
2291         # This will not work if the preprocessor splits the line after the
2292         # Autoconf token.  The 'unproto' program does that.
2293         cat > conftest.$ac_ext <<EOF
2294 #include <${cf_cv_ncurses_header:-curses.h}>
2295 #undef Autoconf
2296 #ifdef NCURSES_VERSION
2297 Autoconf NCURSES_VERSION
2298 #else
2299 #ifdef __NCURSES_H
2300 Autoconf "old"
2301 #endif
2302 ;
2303 #endif
2304 EOF
2305         cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
2306         AC_TRY_EVAL(cf_try)
2307         if test -f conftest.out ; then
2308                 cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%'`
2309                 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
2310                 rm -f conftest.out
2311         fi
2312 ])
2313         rm -f $cf_tempfile
2314 ])
2315 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2316 ])dnl
2317 dnl ---------------------------------------------------------------------------
2318 dnl CF_NCURSES_WRAP_PREFIX version: 1 updated: 2009/03/28 16:08:10
2319 dnl ----------------------
2320 dnl Check for ncurses "wrap-prefix" used for public variables which have been
2321 dnl wrapped with a function to help with concurrency control.
2322 AC_DEFUN([CF_NCURSES_WRAP_PREFIX],
2323 [
2324 AC_MSG_CHECKING(for ncurses wrap-prefix)
2325 AC_ARG_WITH(ncurses-wrap-prefix,
2326         [  --with-ncurses-wrap-prefix naming-prefix for ncurses wrapped-variables],
2327         [NCURSES_WRAP_PREFIX=$withval],
2328         [NCURSES_WRAP_PREFIX=_nc_])
2329 AC_MSG_RESULT($NCURSES_WRAP_PREFIX)
2330
2331 AC_SUBST(NCURSES_WRAP_PREFIX)
2332 ])
2333 dnl ---------------------------------------------------------------------------
2334 dnl CF_NETBSD_FORM_H version: 2 updated: 2012/10/06 16:39:58
2335 dnl ----------------
2336 dnl Check for NetBSD's form.h, which is incompatible with SVr4 and ncurses.
2337 dnl Some workarounds are needed in client programs to allow them to compile.
2338 AC_DEFUN([CF_NETBSD_FORM_H],[
2339 AC_CACHE_CHECK(for NetBSD form.h,cf_cv_netbsd_form_h,[
2340 AC_TRY_COMPILE([
2341 #include <${cf_cv_ncurses_header:-curses.h}>
2342 #include <form.h>
2343 ],[
2344         FORM *form;
2345         int y = current_field(form)->cursor_ypos;
2346         int x = current_field(form)->cursor_xpos;
2347 ],[cf_cv_netbsd_form_h=yes
2348 ],[cf_cv_netbsd_form_h=no])
2349 ])
2350
2351 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])
2352 ])dnl
2353 dnl ---------------------------------------------------------------------------
2354 dnl CF_NETBSD_MENU_H version: 2 updated: 2012/10/06 16:39:58
2355 dnl ----------------
2356 dnl Check for NetBSD's menu.h, which is incompatible with SVr4 and ncurses.
2357 dnl Some workarounds are needed in client programs to allow them to compile.
2358 AC_DEFUN([CF_NETBSD_MENU_H],[
2359 AC_CACHE_CHECK(for NetBSD menu.h,cf_cv_netbsd_menu_h,[
2360 AC_TRY_COMPILE([
2361 #include <${cf_cv_ncurses_header:-curses.h}>
2362 #include <menu.h>
2363 ],[
2364         MENU *menu;
2365         int y = menu->max_item_width;
2366 ],[cf_cv_netbsd_menu_h=yes
2367 ],[cf_cv_netbsd_menu_h=no])
2368 ])
2369
2370 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])
2371 ])dnl
2372 dnl ---------------------------------------------------------------------------
2373 dnl CF_NO_LEAKS_OPTION version: 6 updated: 2015/04/12 15:39:00
2374 dnl ------------------
2375 dnl see CF_WITH_NO_LEAKS
2376 AC_DEFUN([CF_NO_LEAKS_OPTION],[
2377 AC_MSG_CHECKING(if you want to use $1 for testing)
2378 AC_ARG_WITH($1,
2379         [$2],
2380         [AC_DEFINE_UNQUOTED($3,1,"Define to 1 if you want to use $1 for testing.")ifelse([$4],,[
2381          $4
2382 ])
2383         : ${with_cflags:=-g}
2384         : ${with_no_leaks:=yes}
2385          with_$1=yes],
2386         [with_$1=])
2387 AC_MSG_RESULT(${with_$1:-no})
2388
2389 case .$with_cflags in
2390 (.*-g*)
2391         case .$CFLAGS in
2392         (.*-g*)
2393                 ;;
2394         (*)
2395                 CF_ADD_CFLAGS([-g])
2396                 ;;
2397         esac
2398         ;;
2399 esac
2400 ])dnl
2401 dnl ---------------------------------------------------------------------------
2402 dnl CF_PATH_SYNTAX version: 16 updated: 2015/04/18 08:56:57
2403 dnl --------------
2404 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
2405 dnl begins with one of the prefix/exec_prefix variables, and then again if the
2406 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
2407 dnl delayed evaluation of those symbols.
2408 AC_DEFUN([CF_PATH_SYNTAX],[
2409 if test "x$prefix" != xNONE; then
2410         cf_path_syntax="$prefix"
2411 else
2412         cf_path_syntax="$ac_default_prefix"
2413 fi
2414
2415 case ".[$]$1" in
2416 (.\[$]\(*\)*|.\'*\'*)
2417         ;;
2418 (..|./*|.\\*)
2419         ;;
2420 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
2421         ;;
2422 (.\[$]{*prefix}*|.\[$]{*dir}*)
2423         eval $1="[$]$1"
2424         case ".[$]$1" in
2425         (.NONE/*)
2426                 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
2427                 ;;
2428         esac
2429         ;;
2430 (.no|.NONE/*)
2431         $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
2432         ;;
2433 (*)
2434         ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
2435         ;;
2436 esac
2437 ])dnl
2438 dnl ---------------------------------------------------------------------------
2439 dnl CF_PDCURSES_X11 version: 13 updated: 2012/10/06 16:39:58
2440 dnl ---------------
2441 dnl Configure for PDCurses' X11 library
2442 AC_DEFUN([CF_PDCURSES_X11],[
2443 AC_REQUIRE([CF_X_ATHENA])
2444
2445 CF_ACVERSION_CHECK(2.52,
2446         [AC_CHECK_TOOLS(XCURSES_CONFIG, xcurses-config, none)],
2447         [AC_PATH_PROGS(XCURSES_CONFIG, xcurses-config, none)])
2448
2449 if test "$XCURSES_CONFIG" != none ; then
2450
2451 CPPFLAGS="$CPPFLAGS `$XCURSES_CONFIG --cflags`"
2452 CF_ADD_LIBS(`$XCURSES_CONFIG --libs`)
2453
2454 cf_cv_lib_XCurses=yes
2455
2456 else
2457
2458 LDFLAGS="$LDFLAGS $X_LIBS"
2459 CF_CHECK_CFLAGS($X_CFLAGS)
2460 AC_CHECK_LIB(X11,XOpenDisplay,
2461         [CF_ADD_LIBS(-lX11)],,
2462         [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])
2463 AC_CACHE_CHECK(for XCurses library,cf_cv_lib_XCurses,[
2464 CF_ADD_LIBS(-lXCurses)
2465 AC_TRY_LINK([
2466 #include <xcurses.h>
2467 char *XCursesProgramName = "test";
2468 ],[XCursesExit();],
2469 [cf_cv_lib_XCurses=yes],
2470 [cf_cv_lib_XCurses=no])
2471 ])
2472
2473 fi
2474
2475 if test $cf_cv_lib_XCurses = yes ; then
2476         AC_DEFINE(UNIX,1,[Define to 1 if using PDCurses on Unix])
2477         AC_DEFINE(XCURSES,1,[Define to 1 if using PDCurses on Unix])
2478         AC_CHECK_HEADER(xcurses.h, AC_DEFINE(HAVE_XCURSES,1,[Define to 1 if using PDCurses on Unix]))
2479 else
2480         AC_MSG_ERROR(Cannot link with XCurses)
2481 fi
2482 ])dnl
2483 dnl ---------------------------------------------------------------------------
2484 dnl CF_PKG_CONFIG version: 10 updated: 2015/04/26 18:06:58
2485 dnl -------------
2486 dnl Check for the package-config program, unless disabled by command-line.
2487 AC_DEFUN([CF_PKG_CONFIG],
2488 [
2489 AC_MSG_CHECKING(if you want to use pkg-config)
2490 AC_ARG_WITH(pkg-config,
2491         [  --with-pkg-config{=path} enable/disable use of pkg-config],
2492         [cf_pkg_config=$withval],
2493         [cf_pkg_config=yes])
2494 AC_MSG_RESULT($cf_pkg_config)
2495
2496 case $cf_pkg_config in
2497 (no)
2498         PKG_CONFIG=none
2499         ;;
2500 (yes)
2501         CF_ACVERSION_CHECK(2.52,
2502                 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
2503                 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
2504         ;;
2505 (*)
2506         PKG_CONFIG=$withval
2507         ;;
2508 esac
2509
2510 test -z "$PKG_CONFIG" && PKG_CONFIG=none
2511 if test "$PKG_CONFIG" != none ; then
2512         CF_PATH_SYNTAX(PKG_CONFIG)
2513 elif test "x$cf_pkg_config" != xno ; then
2514         AC_MSG_WARN(pkg-config is not installed)
2515 fi
2516
2517 AC_SUBST(PKG_CONFIG)
2518 ])dnl
2519 dnl ---------------------------------------------------------------------------
2520 dnl CF_POSIX_C_SOURCE version: 9 updated: 2015/04/12 15:39:00
2521 dnl -----------------
2522 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
2523 dnl
2524 dnl     POSIX.1-1990                            _POSIX_SOURCE
2525 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
2526 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
2527 dnl             Bindings Option
2528 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
2529 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
2530 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
2531 dnl
2532 dnl Parameters:
2533 dnl     $1 is the nominal value for _POSIX_C_SOURCE
2534 AC_DEFUN([CF_POSIX_C_SOURCE],
2535 [
2536 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
2537
2538 cf_save_CFLAGS="$CFLAGS"
2539 cf_save_CPPFLAGS="$CPPFLAGS"
2540
2541 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
2542 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
2543
2544 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
2545         CF_MSG_LOG(if the symbol is already defined go no further)
2546         AC_TRY_COMPILE([#include <sys/types.h>],[
2547 #ifndef _POSIX_C_SOURCE
2548 make an error
2549 #endif],
2550         [cf_cv_posix_c_source=no],
2551         [cf_want_posix_source=no
2552          case .$cf_POSIX_C_SOURCE in
2553          (.[[12]]??*)
2554                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
2555                 ;;
2556          (.2)
2557                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
2558                 cf_want_posix_source=yes
2559                 ;;
2560          (.*)
2561                 cf_want_posix_source=yes
2562                 ;;
2563          esac
2564          if test "$cf_want_posix_source" = yes ; then
2565                 AC_TRY_COMPILE([#include <sys/types.h>],[
2566 #ifdef _POSIX_SOURCE
2567 make an error
2568 #endif],[],
2569                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
2570          fi
2571          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
2572          CFLAGS="$cf_trim_CFLAGS"
2573          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
2574          CF_MSG_LOG(if the second compile does not leave our definition intact error)
2575          AC_TRY_COMPILE([#include <sys/types.h>],[
2576 #ifndef _POSIX_C_SOURCE
2577 make an error
2578 #endif],,
2579          [cf_cv_posix_c_source=no])
2580          CFLAGS="$cf_save_CFLAGS"
2581          CPPFLAGS="$cf_save_CPPFLAGS"
2582         ])
2583 ])
2584
2585 if test "$cf_cv_posix_c_source" != no ; then
2586         CFLAGS="$cf_trim_CFLAGS"
2587         CPPFLAGS="$cf_trim_CPPFLAGS"
2588         CF_ADD_CFLAGS($cf_cv_posix_c_source)
2589 fi
2590
2591 ])dnl
2592 dnl ---------------------------------------------------------------------------
2593 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
2594 dnl ------------
2595 dnl Append definitions and rules for the given programs to the subdirectory
2596 dnl Makefiles, and the recursion rule for the top-level Makefile.
2597 dnl
2598 dnl parameters
2599 dnl     $1 = script to run
2600 dnl     $2 = list of subdirectories
2601 dnl
2602 dnl variables
2603 dnl     $AWK
2604 AC_DEFUN([CF_PRG_RULES],
2605 [
2606 for cf_dir in $2
2607 do
2608         if test ! -d $srcdir/$cf_dir; then
2609                 continue
2610         elif test -f $srcdir/$cf_dir/programs; then
2611                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
2612         fi
2613 done
2614
2615 ])dnl
2616 dnl ---------------------------------------------------------------------------
2617 dnl CF_PROG_CC version: 4 updated: 2014/07/12 18:57:58
2618 dnl ----------
2619 dnl standard check for CC, plus followup sanity checks
2620 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
2621 AC_DEFUN([CF_PROG_CC],[
2622 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
2623 CF_GCC_VERSION
2624 CF_ACVERSION_CHECK(2.52,
2625         [AC_PROG_CC_STDC],
2626         [CF_ANSI_CC_REQD])
2627 CF_CC_ENV_FLAGS
2628 ])dnl
2629 dnl ---------------------------------------------------------------------------
2630 dnl CF_PROG_INSTALL version: 7 updated: 2015/04/18 08:56:57
2631 dnl ---------------
2632 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
2633 dnl misc/tabset install won't work properly.  Usually this happens only when
2634 dnl using the fallback mkinstalldirs script
2635 AC_DEFUN([CF_PROG_INSTALL],
2636 [AC_PROG_INSTALL
2637 case $INSTALL in
2638 (/*)
2639         ;;
2640 (*)
2641         CF_DIRNAME(cf_dir,$INSTALL)
2642         test -z "$cf_dir" && cf_dir=.
2643         INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
2644         ;;
2645 esac
2646 ])dnl
2647 dnl ---------------------------------------------------------------------------
2648 dnl CF_PROG_LINT version: 2 updated: 2009/08/12 04:43:14
2649 dnl ------------
2650 AC_DEFUN([CF_PROG_LINT],
2651 [
2652 AC_CHECK_PROGS(LINT, tdlint lint alint splint lclint)
2653 AC_SUBST(LINT_OPTS)
2654 ])dnl
2655 dnl ---------------------------------------------------------------------------
2656 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
2657 dnl ----------------
2658 dnl Remove all -U and -D options that refer to the given symbol from a list
2659 dnl of C compiler options.  This works around the problem that not all
2660 dnl compilers process -U and -D options from left-to-right, so a -U option
2661 dnl cannot be used to cancel the effect of a preceding -D option.
2662 dnl
2663 dnl $1 = target (which could be the same as the source variable)
2664 dnl $2 = source (including '$')
2665 dnl $3 = symbol to remove
2666 define([CF_REMOVE_DEFINE],
2667 [
2668 $1=`echo "$2" | \
2669         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
2670                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
2671 ])dnl
2672 dnl ---------------------------------------------------------------------------
2673 dnl CF_RPATH_HACK version: 11 updated: 2013/09/01 13:02:00
2674 dnl -------------
2675 AC_DEFUN([CF_RPATH_HACK],
2676 [
2677 AC_REQUIRE([CF_LD_RPATH_OPT])
2678 AC_MSG_CHECKING(for updated LDFLAGS)
2679 if test -n "$LD_RPATH_OPT" ; then
2680         AC_MSG_RESULT(maybe)
2681
2682         AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
2683         cf_rpath_list="/usr/lib /lib"
2684         if test "$cf_ldd_prog" != no
2685         then
2686                 cf_rpath_oops=
2687
2688 AC_TRY_LINK([#include <stdio.h>],
2689                 [printf("Hello");],
2690                 [cf_rpath_oops=`$cf_ldd_prog conftest$ac_exeext | fgrep ' not found' | sed -e 's% =>.*$%%' |sort | uniq`
2691                  cf_rpath_list=`$cf_ldd_prog conftest$ac_exeext | fgrep / | sed -e 's%^.*[[     ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort | uniq`])
2692
2693                 # If we passed the link-test, but get a "not found" on a given library,
2694                 # this could be due to inept reconfiguration of gcc to make it only
2695                 # partly honor /usr/local/lib (or whatever).  Sometimes this behavior
2696                 # is intentional, e.g., installing gcc in /usr/bin and suppressing the
2697                 # /usr/local libraries.
2698                 if test -n "$cf_rpath_oops"
2699                 then
2700                         for cf_rpath_src in $cf_rpath_oops
2701                         do
2702                                 for cf_rpath_dir in \
2703                                         /usr/local \
2704                                         /usr/pkg \
2705                                         /opt/sfw
2706                                 do
2707                                         if test -f $cf_rpath_dir/lib/$cf_rpath_src
2708                                         then
2709                                                 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
2710                                                 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
2711                                                 break
2712                                         fi
2713                                 done
2714                         done
2715                 fi
2716         fi
2717
2718         CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
2719
2720         CF_RPATH_HACK_2(LDFLAGS)
2721         CF_RPATH_HACK_2(LIBS)
2722
2723         CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
2724 else
2725         AC_MSG_RESULT(no)
2726 fi
2727 AC_SUBST(EXTRA_LDFLAGS)
2728 ])dnl
2729 dnl ---------------------------------------------------------------------------
2730 dnl CF_RPATH_HACK_2 version: 7 updated: 2015/04/12 15:39:00
2731 dnl ---------------
2732 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
2733 dnl EXTRA_LDFLAGS for each -L option found.
2734 dnl
2735 dnl $cf_rpath_list contains a list of directories to ignore.
2736 dnl
2737 dnl $1 = variable name to update.  The LDFLAGS variable should be the only one,
2738 dnl      but LIBS often has misplaced -L options.
2739 AC_DEFUN([CF_RPATH_HACK_2],
2740 [
2741 CF_VERBOSE(...checking $1 [$]$1)
2742
2743 cf_rpath_dst=
2744 for cf_rpath_src in [$]$1
2745 do
2746         case $cf_rpath_src in
2747         (-L*)
2748
2749                 # check if this refers to a directory which we will ignore
2750                 cf_rpath_skip=no
2751                 if test -n "$cf_rpath_list"
2752                 then
2753                         for cf_rpath_item in $cf_rpath_list
2754                         do
2755                                 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
2756                                 then
2757                                         cf_rpath_skip=yes
2758                                         break
2759                                 fi
2760                         done
2761                 fi
2762
2763                 if test "$cf_rpath_skip" = no
2764                 then
2765                         # transform the option
2766                         if test "$LD_RPATH_OPT" = "-R " ; then
2767                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
2768                         else
2769                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
2770                         fi
2771
2772                         # if we have not already added this, add it now
2773                         cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
2774                         if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
2775                         then
2776                                 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
2777                                 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
2778                         fi
2779                 fi
2780                 ;;
2781         esac
2782         cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
2783 done
2784 $1=$cf_rpath_dst
2785
2786 CF_VERBOSE(...checked $1 [$]$1)
2787 AC_SUBST(EXTRA_LDFLAGS)
2788 ])dnl
2789 dnl ---------------------------------------------------------------------------
2790 dnl CF_SIG_ATOMIC_T version: 3 updated: 2012/10/04 20:12:20
2791 dnl ---------------
2792 dnl signal handler, but there are some gcc depedencies in that recommendation.
2793 dnl Try anyway.
2794 AC_DEFUN([CF_SIG_ATOMIC_T],
2795 [
2796 AC_MSG_CHECKING(for signal global datatype)
2797 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
2798         for cf_type in \
2799                 "volatile sig_atomic_t" \
2800                 "sig_atomic_t" \
2801                 "int"
2802         do
2803         AC_TRY_COMPILE([
2804 #include <sys/types.h>
2805 #include <signal.h>
2806 #include <stdio.h>
2807
2808 extern $cf_type x;
2809 $cf_type x;
2810 static void handler(int sig)
2811 {
2812         x = 5;
2813 }],
2814                 [signal(SIGINT, handler);
2815                  x = 1],
2816                 [cf_cv_sig_atomic_t=$cf_type],
2817                 [cf_cv_sig_atomic_t=no])
2818                 test "$cf_cv_sig_atomic_t" != no && break
2819         done
2820         ])
2821 AC_MSG_RESULT($cf_cv_sig_atomic_t)
2822 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t,[Define to signal global datatype])
2823 ])dnl
2824 dnl ---------------------------------------------------------------------------
2825 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
2826 dnl --------------
2827 dnl Construct a search-list for a nonstandard header/lib-file
2828 dnl     $1 = the variable to return as result
2829 dnl     $2 = the package name
2830 dnl     $3 = the subdirectory, e.g., bin, include or lib
2831 AC_DEFUN([CF_SUBDIR_PATH],
2832 [
2833 $1=
2834
2835 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
2836
2837 for cf_subdir_prefix in \
2838         /usr \
2839         /usr/local \
2840         /usr/pkg \
2841         /opt \
2842         /opt/local \
2843         [$]HOME
2844 do
2845         CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
2846 done
2847 ])dnl
2848 dnl ---------------------------------------------------------------------------
2849 dnl CF_SYS_TIME_SELECT version: 6 updated: 2015/04/18 08:56:57
2850 dnl ------------------
2851 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
2852 dnl older SCO configurations.
2853 AC_DEFUN([CF_SYS_TIME_SELECT],
2854 [
2855 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
2856 AC_CACHE_VAL(cf_cv_sys_time_select,[
2857 AC_TRY_COMPILE([
2858 #include <sys/types.h>
2859 #ifdef HAVE_SYS_TIME_H
2860 #include <sys/time.h>
2861 #endif
2862 #ifdef HAVE_SYS_SELECT_H
2863 #include <sys/select.h>
2864 #endif
2865 ],[],[cf_cv_sys_time_select=yes],
2866          [cf_cv_sys_time_select=no])
2867          ])
2868 AC_MSG_RESULT($cf_cv_sys_time_select)
2869 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>])
2870 ])dnl
2871 dnl ---------------------------------------------------------------------------
2872 dnl CF_TERM_HEADER version: 4 updated: 2015/04/15 19:08:48
2873 dnl --------------
2874 dnl Look for term.h, which is part of X/Open curses.  It defines the interface
2875 dnl to terminfo database.  Usually it is in the same include-path as curses.h,
2876 dnl but some packagers change this, breaking various applications.
2877 AC_DEFUN([CF_TERM_HEADER],[
2878 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
2879 case ${cf_cv_ncurses_header} in
2880 (*/ncurses.h|*/ncursesw.h)
2881         cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
2882         ;;
2883 (*)
2884         cf_term_header=term.h
2885         ;;
2886 esac
2887
2888 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
2889 do
2890 AC_TRY_COMPILE([#include <stdio.h>
2891 #include <${cf_cv_ncurses_header:-curses.h}>
2892 #include <$cf_test>
2893 ],[int x = auto_left_margin],[
2894         cf_cv_term_header="$cf_test"],[
2895         cf_cv_term_header=unknown
2896         ])
2897         test "$cf_cv_term_header" != unknown && break
2898 done
2899 ])
2900
2901 # Set definitions to allow ifdef'ing to accommodate subdirectories
2902
2903 case $cf_cv_term_header in
2904 (*term.h)
2905         AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
2906         ;;
2907 esac
2908
2909 case $cf_cv_term_header in
2910 (ncurses/term.h)
2911         AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
2912         ;;
2913 (ncursesw/term.h)
2914         AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
2915         ;;
2916 esac
2917 ])dnl
2918 dnl ---------------------------------------------------------------------------
2919 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
2920 dnl ---------------
2921 dnl Define a top_builddir symbol, for applications that need an absolute path.
2922 AC_DEFUN([CF_TOP_BUILDDIR],
2923 [
2924 top_builddir=ifelse($1,,`pwd`,$1)
2925 AC_SUBST(top_builddir)
2926 ])dnl
2927 dnl ---------------------------------------------------------------------------
2928 dnl CF_TPUTS_PROTO version: 3 updated: 2015/04/17 21:26:14
2929 dnl --------------
2930 dnl Check for type of function-pointer passed to tputs.  Some old
2931 dnl implementations used functions that had different prototypes, making it
2932 dnl hard to compile portable programs using tputs.
2933 AC_DEFUN([CF_TPUTS_PROTO],[
2934 CF_CURSES_FUNCS(tputs)
2935 if test x$cf_cv_func_tputs = xyes
2936 then
2937         cf_done=no
2938         for cf_arg in int char
2939         do
2940                 for cf_ret in int void
2941                 do
2942                         if test $cf_ret = void
2943                         then
2944                                 cf_return="/* nothing */"
2945                         else
2946                                 cf_return="return value"
2947                         fi
2948                         AC_TRY_COMPILE([
2949 #include <${cf_cv_ncurses_header:-curses.h}>
2950 #include <$cf_cv_term_header>
2951
2952 static $cf_ret outc($cf_arg value) { $cf_return; }
2953 ],[
2954         tputs("hello", 0, outc);
2955         ${cf_cv_main_return:-return}(0);
2956 ],[
2957                 CF_VERBOSE([prototype $cf_ret func($cf_arg value)])
2958                 cat >>confdefs.h <<EOF
2959 #define TPUTS_ARG               $cf_arg
2960 #define TPUTS_PROTO(func,value) $cf_ret func(TPUTS_ARG value)
2961 #define TPUTS_RETURN(value)     $cf_return
2962 EOF
2963                 cf_done=yes
2964                 break
2965 ])
2966                 done
2967                 test $cf_done = yes && break
2968         done
2969 fi
2970 ])dnl
2971 dnl ---------------------------------------------------------------------------
2972 dnl CF_TRIM_X_LIBS version: 3 updated: 2015/04/12 15:39:00
2973 dnl --------------
2974 dnl Trim extra base X libraries added as a workaround for inconsistent library
2975 dnl dependencies returned by "new" pkg-config files.
2976 AC_DEFUN([CF_TRIM_X_LIBS],[
2977         for cf_trim_lib in Xmu Xt X11
2978         do
2979                 case "$LIBS" in
2980                 (*-l$cf_trim_lib\ *-l$cf_trim_lib*)
2981                         LIBS=`echo "$LIBS " | sed -e 's/  / /g' -e 's%-l'"$cf_trim_lib"' %%' -e 's/ $//'`
2982                         CF_VERBOSE(..trimmed $LIBS)
2983                         ;;
2984                 esac
2985         done
2986 ])
2987 dnl ---------------------------------------------------------------------------
2988 dnl CF_TRY_PKG_CONFIG version: 5 updated: 2013/07/06 21:27:06
2989 dnl -----------------
2990 dnl This is a simple wrapper to use for pkg-config, for libraries which may be
2991 dnl available in that form.
2992 dnl
2993 dnl $1 = package name
2994 dnl $2 = extra logic to use, if any, after updating CFLAGS and LIBS
2995 dnl $3 = logic to use if pkg-config does not have the package
2996 AC_DEFUN([CF_TRY_PKG_CONFIG],[
2997 AC_REQUIRE([CF_PKG_CONFIG])
2998
2999 if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists $1; then
3000         CF_VERBOSE(found package $1)
3001         cf_pkgconfig_incs="`$PKG_CONFIG --cflags $1 2>/dev/null`"
3002         cf_pkgconfig_libs="`$PKG_CONFIG --libs   $1 2>/dev/null`"
3003         CF_VERBOSE(package $1 CFLAGS: $cf_pkgconfig_incs)
3004         CF_VERBOSE(package $1 LIBS: $cf_pkgconfig_libs)
3005         CF_ADD_CFLAGS($cf_pkgconfig_incs)
3006         CF_ADD_LIBS($cf_pkgconfig_libs)
3007         ifelse([$2],,:,[$2])
3008 else
3009         cf_pkgconfig_incs=
3010         cf_pkgconfig_libs=
3011         ifelse([$3],,:,[$3])
3012 fi
3013 ])
3014 dnl ---------------------------------------------------------------------------
3015 dnl CF_TRY_XOPEN_SOURCE version: 1 updated: 2011/10/30 17:09:50
3016 dnl -------------------
3017 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
3018 dnl can define it successfully.
3019 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
3020 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
3021         AC_TRY_COMPILE([
3022 #include <stdlib.h>
3023 #include <string.h>
3024 #include <sys/types.h>
3025 ],[
3026 #ifndef _XOPEN_SOURCE
3027 make an error
3028 #endif],
3029         [cf_cv_xopen_source=no],
3030         [cf_save="$CPPFLAGS"
3031          CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
3032          AC_TRY_COMPILE([
3033 #include <stdlib.h>
3034 #include <string.h>
3035 #include <sys/types.h>
3036 ],[
3037 #ifdef _XOPEN_SOURCE
3038 make an error
3039 #endif],
3040         [cf_cv_xopen_source=no],
3041         [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
3042         CPPFLAGS="$cf_save"
3043         ])
3044 ])
3045
3046 if test "$cf_cv_xopen_source" != no ; then
3047         CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
3048         CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
3049         cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
3050         CF_ADD_CFLAGS($cf_temp_xopen_source)
3051 fi
3052 ])
3053 dnl ---------------------------------------------------------------------------
3054 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
3055 dnl --------
3056 dnl Make an uppercase version of a variable
3057 dnl $1=uppercase($2)
3058 AC_DEFUN([CF_UPPER],
3059 [
3060 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3061 ])dnl
3062 dnl ---------------------------------------------------------------------------
3063 dnl CF_UTF8_LIB version: 8 updated: 2012/10/06 08:57:51
3064 dnl -----------
3065 dnl Check for multibyte support, and if not found, utf8 compatibility library
3066 AC_DEFUN([CF_UTF8_LIB],
3067 [
3068 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
3069         cf_save_LIBS="$LIBS"
3070         AC_TRY_LINK([
3071 #include <stdlib.h>],[putwc(0,0);],
3072         [cf_cv_utf8_lib=yes],
3073         [CF_FIND_LINKAGE([
3074 #include <libutf8.h>],[putwc(0,0);],utf8,
3075                 [cf_cv_utf8_lib=add-on],
3076                 [cf_cv_utf8_lib=no])
3077 ])])
3078
3079 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
3080 # ncurses/ncursesw:
3081 if test "$cf_cv_utf8_lib" = "add-on" ; then
3082         AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
3083         CF_ADD_INCDIR($cf_cv_header_path_utf8)
3084         CF_ADD_LIBDIR($cf_cv_library_path_utf8)
3085         CF_ADD_LIBS($cf_cv_library_file_utf8)
3086 fi
3087 ])dnl
3088 dnl ---------------------------------------------------------------------------
3089 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
3090 dnl ----------
3091 dnl Use AC_VERBOSE w/o the warnings
3092 AC_DEFUN([CF_VERBOSE],
3093 [test -n "$verbose" && echo "   $1" 1>&AC_FD_MSG
3094 CF_MSG_LOG([$1])
3095 ])dnl
3096 dnl ---------------------------------------------------------------------------
3097 dnl CF_WCHAR_TYPE version: 4 updated: 2012/10/06 16:39:58
3098 dnl -------------
3099 dnl Check if type wide-character type $1 is declared, and if so, which header
3100 dnl file is needed.  The second parameter is used to set a shell variable when
3101 dnl the type is not found.  The first parameter sets a shell variable for the
3102 dnl opposite sense.
3103 AC_DEFUN([CF_WCHAR_TYPE],
3104 [
3105 # This is needed on Tru64 5.0 to declare $1
3106 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
3107 AC_TRY_COMPILE([
3108 #include <stdlib.h>
3109 #include <stdarg.h>
3110 #include <stdio.h>
3111 #ifdef HAVE_LIBUTF8_H
3112 #include <libutf8.h>
3113 #endif],
3114         [$1 state],
3115         [cf_cv_$1=no],
3116         [AC_TRY_COMPILE([
3117 #include <stdlib.h>
3118 #include <stdarg.h>
3119 #include <stdio.h>
3120 #include <wchar.h>
3121 #ifdef HAVE_LIBUTF8_H
3122 #include <libutf8.h>
3123 #endif],
3124         [$1 value],
3125         [cf_cv_$1=yes],
3126         [cf_cv_$1=unknown])])])
3127
3128 if test "$cf_cv_$1" = yes ; then
3129         AC_DEFINE(NEED_WCHAR_H,1,[Define to 1 if we must include wchar.h])
3130         NEED_WCHAR_H=1
3131 fi
3132
3133 ifelse([$2],,,[
3134 # if we do not find $1 in either place, use substitution to provide a fallback.
3135 if test "$cf_cv_$1" = unknown ; then
3136         $2=1
3137 fi
3138 ])
3139 ifelse($3,,,[
3140 # if we find $1 in either place, use substitution to provide a fallback.
3141 if test "$cf_cv_$1" != unknown ; then
3142         $3=1
3143 fi
3144 ])
3145 ])dnl
3146 dnl ---------------------------------------------------------------------------
3147 dnl CF_WITH_CURSES_DIR version: 3 updated: 2010/11/20 17:02:38
3148 dnl ------------------
3149 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
3150 dnl libraries.
3151 AC_DEFUN([CF_WITH_CURSES_DIR],[
3152
3153 AC_MSG_CHECKING(for specific curses-directory)
3154 AC_ARG_WITH(curses-dir,
3155         [  --with-curses-dir=DIR   directory in which (n)curses is installed],
3156         [cf_cv_curses_dir=$withval],
3157         [cf_cv_curses_dir=no])
3158 AC_MSG_RESULT($cf_cv_curses_dir)
3159
3160 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
3161 then
3162         CF_PATH_SYNTAX(withval)
3163         if test -d "$cf_cv_curses_dir"
3164         then
3165                 CF_ADD_INCDIR($cf_cv_curses_dir/include)
3166                 CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
3167         fi
3168 fi
3169 ])dnl
3170 dnl ---------------------------------------------------------------------------
3171 dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
3172 dnl ----------------
3173 dnl Configure-option for dbmalloc.  The optional parameter is used to override
3174 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
3175 AC_DEFUN([CF_WITH_DBMALLOC],[
3176 CF_NO_LEAKS_OPTION(dbmalloc,
3177         [  --with-dbmalloc         test: use Conor Cahill's dbmalloc library],
3178         [USE_DBMALLOC])
3179
3180 if test "$with_dbmalloc" = yes ; then
3181         AC_CHECK_HEADER(dbmalloc.h,
3182                 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
3183 fi
3184 ])dnl
3185 dnl ---------------------------------------------------------------------------
3186 dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
3187 dnl ---------------
3188 dnl Configure-option for dmalloc.  The optional parameter is used to override
3189 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
3190 AC_DEFUN([CF_WITH_DMALLOC],[
3191 CF_NO_LEAKS_OPTION(dmalloc,
3192         [  --with-dmalloc          test: use Gray Watson's dmalloc library],
3193         [USE_DMALLOC])
3194
3195 if test "$with_dmalloc" = yes ; then
3196         AC_CHECK_HEADER(dmalloc.h,
3197                 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
3198 fi
3199 ])dnl
3200 dnl ---------------------------------------------------------------------------
3201 dnl CF_WITH_NCURSES_ETC version: 4 updated: 2015/04/25 20:53:11
3202 dnl -------------------
3203 dnl Use this macro for programs which use any variant of "curses", e.g.,
3204 dnl "ncurses", and "PDCurses".  Programs that can use curses and some unrelated
3205 dnl library (such as slang) should use a "--with-screen=XXX" option.
3206 dnl
3207 dnl This does not use AC_DEFUN, because that would tell autoconf to run each
3208 dnl of the macros inside this one - before this macro.
3209 define([CF_WITH_NCURSES_ETC],[
3210 CF_WITH_CURSES_DIR
3211
3212 cf_cv_screen=curses
3213
3214 AC_MSG_CHECKING(for specified curses library type)
3215 AC_ARG_WITH(screen,
3216         [  --with-screen=XXX       use specified curses-libraries],
3217         [cf_cv_screen=$withval],[
3218
3219 AC_ARG_WITH(ncursesw,
3220         [  --with-ncursesw         use wide ncurses-libraries],
3221         [cf_cv_screen=ncursesw],[
3222
3223 AC_ARG_WITH(ncurses,
3224         [  --with-ncurses          use ncurses-libraries],
3225         [cf_cv_screen=ncurses],[
3226
3227 AC_ARG_WITH(pdcurses,
3228         [  --with-pdcurses         compile/link with pdcurses X11 library],
3229         [cf_cv_screen=pdcurses],[
3230
3231 AC_ARG_WITH(curses-colr,
3232         [  --with-curses-colr      compile/link with HPUX 10.x color-curses],
3233         [cf_cv_screen=curses_colr],[
3234
3235 AC_ARG_WITH(curses-5lib,
3236         [  --with-curses-5lib      compile/link with SunOS 5lib curses],
3237         [cf_cv_screen=curses_5lib])])])])])])
3238
3239 AC_MSG_RESULT($cf_cv_screen)
3240
3241 case $cf_cv_screen in
3242 (curses|curses_*)
3243         CF_CURSES_CONFIG
3244         ;;
3245 (ncursesw*)
3246         CF_UTF8_LIB
3247         CF_NCURSES_CONFIG($cf_cv_screen)
3248         ;;
3249 (ncurses*)
3250         CF_NCURSES_CONFIG($cf_cv_screen)
3251         ;;
3252 (pdcurses)
3253         CF_PDCURSES_X11
3254         ;;
3255 (*)
3256         AC_MSG_ERROR(unexpected screen-value: $cf_cv_screen)
3257         ;;
3258 esac
3259
3260 ])dnl
3261 dnl ---------------------------------------------------------------------------
3262 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
3263 dnl ----------------
3264 AC_DEFUN([CF_WITH_VALGRIND],[
3265 CF_NO_LEAKS_OPTION(valgrind,
3266         [  --with-valgrind         test: use valgrind],
3267         [USE_VALGRIND])
3268 ])dnl
3269 dnl ---------------------------------------------------------------------------
3270 dnl CF_XOPEN_CURSES version: 13 updated: 2015/12/12 20:59:52
3271 dnl ---------------
3272 dnl Test if we should define X/Open source for curses, needed on Digital Unix
3273 dnl 4.x, to see the extended functions, but breaks on IRIX 6.x.
3274 dnl
3275 dnl The getbegyx() check is needed for HPUX, which omits legacy macros such
3276 dnl as getbegy().  The latter is better design, but the former is standard.
3277 AC_DEFUN([CF_XOPEN_CURSES],
3278 [
3279 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
3280 AC_CACHE_CHECK(definition to turn on extended curses functions,cf_cv_need_xopen_extension,[
3281 cf_cv_need_xopen_extension=unknown
3282 AC_TRY_LINK([
3283 #include <stdlib.h>
3284 #include <${cf_cv_ncurses_header:-curses.h}>],[
3285 #if defined(NCURSES_VERSION_PATCH)
3286 #if (NCURSES_VERSION_PATCH < 20100501) && (NCURSES_VERSION_PATCH >= 20100403)
3287         make an error
3288 #endif
3289 #endif
3290 #ifdef NCURSES_VERSION
3291         cchar_t check;
3292         int check2 = curs_set((int)sizeof(check));
3293 #endif
3294         long x = winnstr(stdscr, "", 0);
3295         int x1, y1;
3296         getbegyx(stdscr, y1, x1)],
3297         [cf_cv_need_xopen_extension=none],
3298         [
3299         for cf_try_xopen_extension in _XOPEN_SOURCE_EXTENDED NCURSES_WIDECHAR
3300         do
3301                 AC_TRY_LINK([
3302 #define $cf_try_xopen_extension 1
3303 #include <stdlib.h>
3304 #include <${cf_cv_ncurses_header:-curses.h}>],[
3305 #ifdef NCURSES_VERSION
3306                 cchar_t check;
3307                 int check2 = curs_set((int)sizeof(check));
3308 #endif
3309                 long x = winnstr(stdscr, "", 0);
3310                 int x1, y1;
3311                 getbegyx(stdscr, y1, x1)],
3312                 [cf_cv_need_xopen_extension=$cf_try_xopen_extension; break])
3313         done
3314         ])
3315 ])
3316
3317 case $cf_cv_need_xopen_extension in
3318 (*_*)
3319         CPPFLAGS="$CPPFLAGS -D$cf_cv_need_xopen_extension"
3320         ;;
3321 esac
3322
3323 ])dnl
3324 dnl ---------------------------------------------------------------------------
3325 dnl CF_XOPEN_SOURCE version: 50 updated: 2015/10/17 19:03:33
3326 dnl ---------------
3327 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
3328 dnl or adapt to the vendor's definitions to get equivalent functionality,
3329 dnl without losing the common non-POSIX features.
3330 dnl
3331 dnl Parameters:
3332 dnl     $1 is the nominal value for _XOPEN_SOURCE
3333 dnl     $2 is the nominal value for _POSIX_C_SOURCE
3334 AC_DEFUN([CF_XOPEN_SOURCE],[
3335 AC_REQUIRE([AC_CANONICAL_HOST])
3336
3337 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
3338 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
3339 cf_xopen_source=
3340
3341 case $host_os in
3342 (aix[[4-7]]*)
3343         cf_xopen_source="-D_ALL_SOURCE"
3344         ;;
3345 (cygwin|msys)
3346         cf_XOPEN_SOURCE=600
3347         ;;
3348 (darwin[[0-8]].*)
3349         cf_xopen_source="-D_APPLE_C_SOURCE"
3350         ;;
3351 (darwin*)
3352         cf_xopen_source="-D_DARWIN_C_SOURCE"
3353         cf_XOPEN_SOURCE=
3354         ;;
3355 (freebsd*|dragonfly*)
3356         # 5.x headers associate
3357         #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
3358         #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
3359         cf_POSIX_C_SOURCE=200112L
3360         cf_XOPEN_SOURCE=600
3361         cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
3362         ;;
3363 (hpux11*)
3364         cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
3365         ;;
3366 (hpux*)
3367         cf_xopen_source="-D_HPUX_SOURCE"
3368         ;;
3369 (irix[[56]].*)
3370         cf_xopen_source="-D_SGI_SOURCE"
3371         cf_XOPEN_SOURCE=
3372         ;;
3373 (linux*|gnu*|mint*|k*bsd*-gnu)
3374         CF_GNU_SOURCE
3375         ;;
3376 (minix*)
3377         cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
3378         ;;
3379 (mirbsd*)
3380         # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
3381         cf_XOPEN_SOURCE=
3382         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
3383         ;;
3384 (netbsd*)
3385         cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
3386         ;;
3387 (openbsd[[4-9]]*)
3388         # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
3389         cf_xopen_source="-D_BSD_SOURCE"
3390         cf_XOPEN_SOURCE=600
3391         ;;
3392 (openbsd*)
3393         # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
3394         ;;
3395 (os2*)
3396         cf_XOPEN_SOURCE=
3397         ;;
3398 (osf[[45]]*)
3399         cf_xopen_source="-D_OSF_SOURCE"
3400         ;;
3401 (nto-qnx*)
3402         cf_xopen_source="-D_QNX_SOURCE"
3403         ;;
3404 (sco*)
3405         # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
3406         ;;
3407 (solaris2.*)
3408         cf_xopen_source="-D__EXTENSIONS__"
3409         cf_cv_xopen_source=broken
3410         ;;
3411 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
3412         cf_XOPEN_SOURCE=
3413         cf_POSIX_C_SOURCE=
3414         ;;
3415 (*)
3416         CF_TRY_XOPEN_SOURCE
3417         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
3418         ;;
3419 esac
3420
3421 if test -n "$cf_xopen_source" ; then
3422         CF_ADD_CFLAGS($cf_xopen_source,true)
3423 fi
3424
3425 dnl In anything but the default case, we may have system-specific setting
3426 dnl which is still not guaranteed to provide all of the entrypoints that
3427 dnl _XOPEN_SOURCE would yield.
3428 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
3429         AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
3430         AC_TRY_COMPILE([#include <stdlib.h>],[
3431 #ifndef _XOPEN_SOURCE
3432 make an error
3433 #endif],
3434         [cf_XOPEN_SOURCE_set=yes],
3435         [cf_XOPEN_SOURCE_set=no])
3436         AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
3437         if test $cf_XOPEN_SOURCE_set = yes
3438         then
3439                 AC_TRY_COMPILE([#include <stdlib.h>],[
3440 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
3441 make an error
3442 #endif],
3443                 [cf_XOPEN_SOURCE_set_ok=yes],
3444                 [cf_XOPEN_SOURCE_set_ok=no])
3445                 if test $cf_XOPEN_SOURCE_set_ok = no
3446                 then
3447                         AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
3448                 fi
3449         else
3450                 CF_TRY_XOPEN_SOURCE
3451         fi
3452 fi
3453 ])
3454 dnl ---------------------------------------------------------------------------
3455 dnl CF_X_ATHENA version: 23 updated: 2015/04/12 15:39:00
3456 dnl -----------
3457 dnl Check for Xaw (Athena) libraries
3458 dnl
3459 dnl Sets $cf_x_athena according to the flavor of Xaw which is used.
3460 AC_DEFUN([CF_X_ATHENA],
3461 [
3462 cf_x_athena=${cf_x_athena:-Xaw}
3463
3464 AC_MSG_CHECKING(if you want to link with Xaw 3d library)
3465 withval=
3466 AC_ARG_WITH(Xaw3d,
3467         [  --with-Xaw3d            link with Xaw 3d library])
3468 if test "$withval" = yes ; then
3469         cf_x_athena=Xaw3d
3470         AC_MSG_RESULT(yes)
3471 else
3472         AC_MSG_RESULT(no)
3473 fi
3474
3475 AC_MSG_CHECKING(if you want to link with Xaw 3d xft library)
3476 withval=
3477 AC_ARG_WITH(Xaw3dxft,
3478         [  --with-Xaw3dxft         link with Xaw 3d xft library])
3479 if test "$withval" = yes ; then
3480         cf_x_athena=Xaw3dxft
3481         AC_MSG_RESULT(yes)
3482 else
3483         AC_MSG_RESULT(no)
3484 fi
3485
3486 AC_MSG_CHECKING(if you want to link with neXT Athena library)
3487 withval=
3488 AC_ARG_WITH(neXtaw,
3489         [  --with-neXtaw           link with neXT Athena library])
3490 if test "$withval" = yes ; then
3491         cf_x_athena=neXtaw
3492         AC_MSG_RESULT(yes)
3493 else
3494         AC_MSG_RESULT(no)
3495 fi
3496
3497 AC_MSG_CHECKING(if you want to link with Athena-Plus library)
3498 withval=
3499 AC_ARG_WITH(XawPlus,
3500         [  --with-XawPlus          link with Athena-Plus library])
3501 if test "$withval" = yes ; then
3502         cf_x_athena=XawPlus
3503         AC_MSG_RESULT(yes)
3504 else
3505         AC_MSG_RESULT(no)
3506 fi
3507
3508 cf_x_athena_lib=""
3509
3510 if test "$PKG_CONFIG" != none ; then
3511         cf_athena_list=
3512         test "$cf_x_athena" = Xaw && cf_athena_list="xaw8 xaw7 xaw6"
3513         for cf_athena_pkg in \
3514                 $cf_athena_list \
3515                 ${cf_x_athena} \
3516                 ${cf_x_athena}-devel \
3517                 lib${cf_x_athena} \
3518                 lib${cf_x_athena}-devel
3519         do
3520                 CF_TRY_PKG_CONFIG($cf_athena_pkg,[
3521                         cf_x_athena_lib="$cf_pkgconfig_libs"
3522                         CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
3523                         AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
3524
3525                         CF_TRIM_X_LIBS
3526
3527 AC_CACHE_CHECK(for usable $cf_x_athena/Xmu package,cf_cv_xaw_compat,[
3528 AC_TRY_LINK([
3529 #include <X11/Xmu/CharSet.h>
3530 ],[
3531 int check = XmuCompareISOLatin1("big", "small")
3532 ],[cf_cv_xaw_compat=yes],[cf_cv_xaw_compat=no])])
3533
3534                         if test "$cf_cv_xaw_compat" = no
3535                         then
3536                                 # workaround for broken ".pc" files...
3537                                 case "$cf_x_athena_lib" in
3538                                 (*-lXmu*)
3539                                         ;;
3540                                 (*)
3541                                         CF_VERBOSE(work around broken package)
3542                                         cf_save_xmu="$LIBS"
3543                                         cf_first_lib=`echo "$cf_save_xmu" | sed -e 's/^[ ][ ]*//' -e 's/ .*//'`
3544                                         CF_TRY_PKG_CONFIG(xmu,[
3545                                                         LIBS="$cf_save_xmu"
3546                                                         CF_ADD_LIB_AFTER($cf_first_lib,$cf_pkgconfig_libs)
3547                                                 ],[
3548                                                         CF_ADD_LIB_AFTER($cf_first_lib,-lXmu)
3549                                                 ])
3550                                         CF_TRIM_X_LIBS
3551                                         ;;
3552                                 esac
3553                         fi
3554
3555                         break])
3556         done
3557 fi
3558
3559 if test -z "$cf_x_athena_lib" ; then
3560         CF_X_EXT
3561         CF_X_TOOLKIT
3562         CF_X_ATHENA_CPPFLAGS($cf_x_athena)
3563         CF_X_ATHENA_LIBS($cf_x_athena)
3564 fi
3565 ])dnl
3566 dnl ---------------------------------------------------------------------------
3567 dnl CF_X_ATHENA_CPPFLAGS version: 5 updated: 2010/05/26 17:35:30
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_CPPFLAGS],
3572 [
3573 cf_x_athena_root=ifelse([$1],,Xaw,[$1])
3574 cf_x_athena_inc=""
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         if test -z "$cf_x_athena_inc" ; then
3583                 cf_save="$CPPFLAGS"
3584                 cf_test=X11/$cf_x_athena_root/SimpleMenu.h
3585                 if test $cf_path != default ; then
3586                         CPPFLAGS="$cf_save -I$cf_path/include"
3587                         AC_MSG_CHECKING(for $cf_test in $cf_path)
3588                 else
3589                         AC_MSG_CHECKING(for $cf_test)
3590                 fi
3591                 AC_TRY_COMPILE([
3592 #include <X11/Intrinsic.h>
3593 #include <$cf_test>],[],
3594                         [cf_result=yes],
3595                         [cf_result=no])
3596                 AC_MSG_RESULT($cf_result)
3597                 if test "$cf_result" = yes ; then
3598                         cf_x_athena_inc=$cf_path
3599                         break
3600                 else
3601                         CPPFLAGS="$cf_save"
3602                 fi
3603         fi
3604 done
3605
3606 if test -z "$cf_x_athena_inc" ; then
3607         AC_MSG_WARN(
3608 [Unable to successfully find Athena header files with test program])
3609 elif test "$cf_x_athena_inc" != default ; then
3610         CPPFLAGS="$CPPFLAGS -I$cf_x_athena_inc"
3611 fi
3612 ])
3613 dnl ---------------------------------------------------------------------------
3614 dnl CF_X_ATHENA_LIBS version: 12 updated: 2011/07/17 19:55:02
3615 dnl ----------------
3616 dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
3617 dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
3618 AC_DEFUN([CF_X_ATHENA_LIBS],
3619 [AC_REQUIRE([CF_X_TOOLKIT])
3620 cf_x_athena_root=ifelse([$1],,Xaw,[$1])
3621 cf_x_athena_lib=""
3622
3623 for cf_path in default \
3624         /usr/contrib/X11R6 \
3625         /usr/contrib/X11R5 \
3626         /usr/lib/X11R5 \
3627         /usr/local
3628 do
3629         for cf_lib in \
3630                 ${cf_x_athena_root} \
3631                 ${cf_x_athena_root}7 \
3632                 ${cf_x_athena_root}6
3633         do
3634         for cf_libs in \
3635                 "-l$cf_lib -lXmu" \
3636                 "-l$cf_lib -lXpm -lXmu" \
3637                 "-l${cf_lib}_s -lXmu_s"
3638         do
3639                 if test -z "$cf_x_athena_lib" ; then
3640                         cf_save="$LIBS"
3641                         cf_test=XawSimpleMenuAddGlobalActions
3642                         if test $cf_path != default ; then
3643                                 CF_ADD_LIBS(-L$cf_path/lib $cf_libs)
3644                                 AC_MSG_CHECKING(for $cf_libs in $cf_path)
3645                         else
3646                                 CF_ADD_LIBS($cf_libs)
3647                                 AC_MSG_CHECKING(for $cf_test in $cf_libs)
3648                         fi
3649                         AC_TRY_LINK([
3650 #include <X11/Intrinsic.h>
3651 #include <X11/$cf_x_athena_root/SimpleMenu.h>
3652 ],[
3653 $cf_test((XtAppContext) 0)],
3654                                 [cf_result=yes],
3655                                 [cf_result=no])
3656                         AC_MSG_RESULT($cf_result)
3657                         if test "$cf_result" = yes ; then
3658                                 cf_x_athena_lib="$cf_libs"
3659                                 break
3660                         fi
3661                         LIBS="$cf_save"
3662                 fi
3663         done # cf_libs
3664                 test -n "$cf_x_athena_lib" && break
3665         done # cf_lib
3666 done
3667
3668 if test -z "$cf_x_athena_lib" ; then
3669         AC_MSG_ERROR(
3670 [Unable to successfully link Athena library (-l$cf_x_athena_root) with test program])
3671 fi
3672
3673 CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
3674 AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
3675 ])
3676 dnl ---------------------------------------------------------------------------
3677 dnl CF_X_EXT version: 3 updated: 2010/06/02 05:03:05
3678 dnl --------
3679 AC_DEFUN([CF_X_EXT],[
3680 CF_TRY_PKG_CONFIG(Xext,,[
3681         AC_CHECK_LIB(Xext,XextCreateExtension,
3682                 [CF_ADD_LIB(Xext)])])
3683 ])dnl
3684 dnl ---------------------------------------------------------------------------
3685 dnl CF_X_TOOLKIT version: 23 updated: 2015/04/12 15:39:00
3686 dnl ------------
3687 dnl Check for X Toolkit libraries
3688 AC_DEFUN([CF_X_TOOLKIT],
3689 [
3690 AC_REQUIRE([AC_PATH_XTRA])
3691 AC_REQUIRE([CF_CHECK_CACHE])
3692
3693 # OSX is schizoid about who owns /usr/X11 (old) versus /opt/X11 (new), and (and
3694 # in some cases has installed dummy files in the former, other cases replaced
3695 # it with a link to the new location).  This complicates the configure script.
3696 # Check for that pitfall, and recover using pkg-config
3697 #
3698 # If none of these are set, the configuration is almost certainly broken.
3699 if test -z "${X_CFLAGS}${X_PRE_LIBS}${X_LIBS}${X_EXTRA_LIBS}"
3700 then
3701         CF_TRY_PKG_CONFIG(x11,,[AC_MSG_WARN(unable to find X11 library)])
3702         CF_TRY_PKG_CONFIG(ice,,[AC_MSG_WARN(unable to find ICE library)])
3703         CF_TRY_PKG_CONFIG(sm,,[AC_MSG_WARN(unable to find SM library)])
3704         CF_TRY_PKG_CONFIG(xt,,[AC_MSG_WARN(unable to find Xt library)])
3705 fi
3706
3707 cf_have_X_LIBS=no
3708
3709 CF_TRY_PKG_CONFIG(xt,[
3710
3711         case "x$LIBS" in
3712         (*-lX11*)
3713                 ;;
3714         (*)
3715 # we have an "xt" package, but it may omit Xt's dependency on X11
3716 AC_CACHE_CHECK(for usable X dependency,cf_cv_xt_x11_compat,[
3717 AC_TRY_LINK([
3718 #include <X11/Xlib.h>
3719 ],[
3720         int rc1 = XDrawLine((Display*) 0, (Drawable) 0, (GC) 0, 0, 0, 0, 0);
3721         int rc2 = XClearWindow((Display*) 0, (Window) 0);
3722         int rc3 = XMoveWindow((Display*) 0, (Window) 0, 0, 0);
3723         int rc4 = XMoveResizeWindow((Display*)0, (Window)0, 0, 0, 0, 0);
3724 ],[cf_cv_xt_x11_compat=yes],[cf_cv_xt_x11_compat=no])])
3725                 if test "$cf_cv_xt_x11_compat" = no
3726                 then
3727                         CF_VERBOSE(work around broken X11 dependency)
3728                         # 2010/11/19 - good enough until a working Xt on Xcb is delivered.
3729                         CF_TRY_PKG_CONFIG(x11,,[CF_ADD_LIB_AFTER(-lXt,-lX11)])
3730                 fi
3731                 ;;
3732         esac
3733
3734 AC_CACHE_CHECK(for usable X Toolkit package,cf_cv_xt_ice_compat,[
3735 AC_TRY_LINK([
3736 #include <X11/Shell.h>
3737 ],[int num = IceConnectionNumber(0)
3738 ],[cf_cv_xt_ice_compat=yes],[cf_cv_xt_ice_compat=no])])
3739
3740         if test "$cf_cv_xt_ice_compat" = no
3741         then
3742                 # workaround for broken ".pc" files used for X Toolkit.
3743                 case "x$X_PRE_LIBS" in
3744                 (*-lICE*)
3745                         case "x$LIBS" in
3746                         (*-lICE*)
3747                                 ;;
3748                         (*)
3749                                 CF_VERBOSE(work around broken ICE dependency)
3750                                 CF_TRY_PKG_CONFIG(ice,
3751                                         [CF_TRY_PKG_CONFIG(sm)],
3752                                         [CF_ADD_LIB_AFTER(-lXt,$X_PRE_LIBS)])
3753                                 ;;
3754                         esac
3755                         ;;
3756                 esac
3757         fi
3758
3759         cf_have_X_LIBS=yes
3760 ],[
3761
3762         LDFLAGS="$X_LIBS $LDFLAGS"
3763         CF_CHECK_CFLAGS($X_CFLAGS)
3764
3765         AC_CHECK_FUNC(XOpenDisplay,,[
3766         AC_CHECK_LIB(X11,XOpenDisplay,
3767                 [CF_ADD_LIB(X11)],,
3768                 [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])])
3769
3770         AC_CHECK_FUNC(XtAppInitialize,,[
3771         AC_CHECK_LIB(Xt, XtAppInitialize,
3772                 [AC_DEFINE(HAVE_LIBXT,1,[Define to 1 if we can compile with the Xt library])
3773                  cf_have_X_LIBS=Xt
3774                  LIBS="-lXt $X_PRE_LIBS $LIBS $X_EXTRA_LIBS"],,
3775                 [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])])
3776 ])
3777
3778 if test $cf_have_X_LIBS = no ; then
3779         AC_MSG_WARN(
3780 [Unable to successfully link X Toolkit library (-lXt) with
3781 test program.  You will have to check and add the proper libraries by hand
3782 to makefile.])
3783 fi
3784 ])dnl
3785 dnl ---------------------------------------------------------------------------
3786 dnl CF__CURSES_HEAD version: 2 updated: 2010/10/23 15:54:49
3787 dnl ---------------
3788 dnl Define a reusable chunk which includes <curses.h> and <term.h> when they
3789 dnl are both available.
3790 define([CF__CURSES_HEAD],[
3791 #ifdef HAVE_XCURSES
3792 #include <xcurses.h>
3793 char * XCursesProgramName = "test";
3794 #else
3795 #include <${cf_cv_ncurses_header:-curses.h}>
3796 #if defined(NCURSES_VERSION) && defined(HAVE_NCURSESW_TERM_H)
3797 #include <ncursesw/term.h>
3798 #elif defined(NCURSES_VERSION) && defined(HAVE_NCURSES_TERM_H)
3799 #include <ncurses/term.h>
3800 #elif defined(HAVE_TERM_H)
3801 #include <term.h>
3802 #endif
3803 #endif
3804 ])