test/aclocal.m4

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