test/aclocal.m4

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