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.213 2023/02/25 13:45:56 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: 11 updated: 2023/02/20 11:15:46
 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" | sed -e "s%^$cf_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: 2 updated: 2023/02/25 08:45:56
1688 dnl ---------------
1689 dnl Check for gettimeofday or clock_gettime.  In 2023, the former is still more
1690 dnl widely supported, but "deprecated" (2008), so we will use the latter if it
1691 dnl is available, to reduce compiler warnings.
1692 AC_DEFUN([CF_FUNC_GETTIME],[
1693 AC_CACHE_CHECK(for clock_gettime,cf_cv_func_clock_gettime,[
1694                 AC_TRY_LINK([#include <time.h>],
1695                 [struct timespec ts;
1696                 int rc = clock_gettime(CLOCK_REALTIME, &ts); (void) rc; (void)ts],
1697                 [cf_cv_func_clock_gettime=yes],
1698                 [cf_cv_func_clock_gettime=no])
1699 ])
1700
1701 if test "$cf_cv_func_clock_gettime" = yes
1702 then
1703         AC_DEFINE(HAVE_CLOCK_GETTIME,1,[Define to 1 if we have clock_gettime function])
1704 else
1705 AC_CHECK_FUNC(gettimeofday,
1706         AC_DEFINE(HAVE_GETTIMEOFDAY,1,[Define to 1 if we have gettimeofday function]),[
1707
1708 AC_CHECK_LIB(bsd, gettimeofday,
1709         AC_DEFINE(HAVE_GETTIMEOFDAY,1,[Define to 1 if we have gettimeofday function])
1710         CF_ADD_LIB(bsd))])dnl CLIX: bzero, select, gettimeofday
1711 fi
1712 ])dnl
1713 dnl ---------------------------------------------------------------------------
1714 dnl CF_FUNC_OPENPTY version: 6 updated: 2021/01/01 13:31:04
1715 dnl ---------------
1716 dnl Check for openpty() function, along with <pty.h> header.  It may need the
1717 dnl "util" library as well.
1718 AC_DEFUN([CF_FUNC_OPENPTY],
1719 [
1720 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1721 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1722         cf_save_LIBS="$LIBS"
1723         test "$cf_cv_lib_util" = yes && { CF_ADD_LIB(util) }
1724         for cf_header in pty.h libutil.h util.h
1725         do
1726         AC_TRY_LINK([
1727 #include <$cf_header>
1728 ],[
1729         int x = openpty((int *)0, (int *)0, (char *)0,
1730                                    (struct termios *)0, (struct winsize *)0);
1731 ],[
1732                 cf_cv_func_openpty=$cf_header
1733                 break
1734 ],[
1735                 cf_cv_func_openpty=no
1736 ])
1737         done
1738         LIBS="$cf_save_LIBS"
1739 ])
1740 ])dnl
1741 dnl ---------------------------------------------------------------------------
1742 dnl CF_GCC_ATTRIBUTES version: 24 updated: 2021/03/20 12:00:25
1743 dnl -----------------
1744 dnl Test for availability of useful gcc __attribute__ directives to quiet
1745 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1746 dnl to documentation, unrecognized directives cause older compilers to barf.
1747 AC_DEFUN([CF_GCC_ATTRIBUTES],
1748 [AC_REQUIRE([AC_PROG_FGREP])dnl
1749 AC_REQUIRE([CF_C11_NORETURN])dnl
1750
1751 if test "$GCC" = yes || test "$GXX" = yes
1752 then
1753 cat > conftest.i <<EOF
1754 #ifndef GCC_PRINTF
1755 #define GCC_PRINTF 0
1756 #endif
1757 #ifndef GCC_SCANF
1758 #define GCC_SCANF 0
1759 #endif
1760 #ifndef GCC_NORETURN
1761 #define GCC_NORETURN /* nothing */
1762 #endif
1763 #ifndef GCC_UNUSED
1764 #define GCC_UNUSED /* nothing */
1765 #endif
1766 EOF
1767 if test "$GCC" = yes
1768 then
1769         AC_CHECKING([for $CC __attribute__ directives])
1770 cat > "conftest.$ac_ext" <<EOF
1771 #line __oline__ "${as_me:-configure}"
1772 #include <stdio.h>
1773 #include "confdefs.h"
1774 #include "conftest.h"
1775 #include "conftest.i"
1776 #if     GCC_PRINTF
1777 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1778 #else
1779 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1780 #endif
1781 #if     GCC_SCANF
1782 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1783 #else
1784 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1785 #endif
1786 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1787 extern GCC_NORETURN void oops(char *,...) GCC_PRINTFLIKE(1,2);
1788 extern GCC_NORETURN void foo(void);
1789 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
1790 EOF
1791         cf_printf_attribute=no
1792         cf_scanf_attribute=no
1793         for cf_attribute in scanf printf unused noreturn
1794         do
1795                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1796                 cf_directive="__attribute__(($cf_attribute))"
1797                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1798
1799                 case "$cf_attribute" in
1800                 (printf)
1801                         cf_printf_attribute=yes
1802                         cat >conftest.h <<EOF
1803 #define GCC_$cf_ATTRIBUTE 1
1804 EOF
1805                         ;;
1806                 (scanf)
1807                         cf_scanf_attribute=yes
1808                         cat >conftest.h <<EOF
1809 #define GCC_$cf_ATTRIBUTE 1
1810 EOF
1811                         ;;
1812                 (*)
1813                         cat >conftest.h <<EOF
1814 #define GCC_$cf_ATTRIBUTE $cf_directive
1815 EOF
1816                         ;;
1817                 esac
1818
1819                 if AC_TRY_EVAL(ac_compile); then
1820                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1821                         cat conftest.h >>confdefs.h
1822                         case "$cf_attribute" in
1823                         (noreturn)
1824                                 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1825                                 ;;
1826                         (printf)
1827                                 cf_value='/* nothing */'
1828                                 if test "$cf_printf_attribute" != no ; then
1829                                         cf_value='__attribute__((format(printf,fmt,var)))'
1830                                         AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1831                                 fi
1832                                 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1833                                 ;;
1834                         (scanf)
1835                                 cf_value='/* nothing */'
1836                                 if test "$cf_scanf_attribute" != no ; then
1837                                         cf_value='__attribute__((format(scanf,fmt,var)))'
1838                                         AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1839                                 fi
1840                                 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1841                                 ;;
1842                         (unused)
1843                                 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
1844                                 ;;
1845                         esac
1846                 fi
1847         done
1848 else
1849         ${FGREP-fgrep} define conftest.i >>confdefs.h
1850 fi
1851 rm -rf ./conftest*
1852 fi
1853 ])dnl
1854 dnl ---------------------------------------------------------------------------
1855 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
1856 dnl --------------
1857 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
1858 dnl compatible), attempt to determine if icc/clang is actually used.
1859 AC_DEFUN([CF_GCC_VERSION],[
1860 AC_REQUIRE([AC_PROG_CC])
1861 GCC_VERSION=none
1862 if test "$GCC" = yes ; then
1863         AC_MSG_CHECKING(version of $CC)
1864         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.]].*//'`"
1865         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1866         AC_MSG_RESULT($GCC_VERSION)
1867 fi
1868 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1869 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
1870 ])dnl
1871 dnl ---------------------------------------------------------------------------
1872 dnl CF_GCC_WARNINGS version: 41 updated: 2021/01/01 16:53:59
1873 dnl ---------------
1874 dnl Check if the compiler supports useful warning options.  There's a few that
1875 dnl we don't use, simply because they're too noisy:
1876 dnl
1877 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1878 dnl     -Winline (usually not worthwhile)
1879 dnl     -Wredundant-decls (system headers make this too noisy)
1880 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1881 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1882 dnl             is enabled for ncurses using "--enable-const".
1883 dnl     -pedantic
1884 dnl
1885 dnl Parameter:
1886 dnl     $1 is an optional list of gcc warning flags that a particular
1887 dnl             application might want to use, e.g., "no-unused" for
1888 dnl             -Wno-unused
1889 dnl Special:
1890 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1891 dnl
1892 AC_DEFUN([CF_GCC_WARNINGS],
1893 [
1894 AC_REQUIRE([CF_GCC_VERSION])
1895 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
1896 cat > "conftest.$ac_ext" <<EOF
1897 #line __oline__ "${as_me:-configure}"
1898 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1899 EOF
1900 if test "$INTEL_COMPILER" = yes
1901 then
1902 # The "-wdXXX" options suppress warnings:
1903 # remark #1419: external declaration in primary source file
1904 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1905 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1906 # remark #193: zero used for undefined preprocessing identifier
1907 # remark #593: variable "curs_sb_left_arrow" was set but never used
1908 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1909 # remark #869: parameter "tw" was never referenced
1910 # remark #981: operands are evaluated in unspecified order
1911 # warning #279: controlling expression is constant
1912
1913         AC_CHECKING([for $CC warning options])
1914         cf_save_CFLAGS="$CFLAGS"
1915         EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
1916         for cf_opt in \
1917                 wd1419 \
1918                 wd1683 \
1919                 wd1684 \
1920                 wd193 \
1921                 wd593 \
1922                 wd279 \
1923                 wd810 \
1924                 wd869 \
1925                 wd981
1926         do
1927                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1928                 if AC_TRY_EVAL(ac_compile); then
1929                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1930                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1931                 fi
1932         done
1933         CFLAGS="$cf_save_CFLAGS"
1934 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
1935 then
1936         AC_CHECKING([for $CC warning options])
1937         cf_save_CFLAGS="$CFLAGS"
1938         cf_warn_CONST=""
1939         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1940         cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
1941         test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
1942         for cf_opt in W Wall \
1943                 Wbad-function-cast \
1944                 Wcast-align \
1945                 Wcast-qual \
1946                 Wdeclaration-after-statement \
1947                 Wextra \
1948                 Winline \
1949                 Wmissing-declarations \
1950                 Wmissing-prototypes \
1951                 Wnested-externs \
1952                 Wpointer-arith \
1953                 Wshadow \
1954                 Wstrict-prototypes \
1955                 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
1956         do
1957                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1958                 if AC_TRY_EVAL(ac_compile); then
1959                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1960                         case "$cf_opt" in
1961                         (Winline)
1962                                 case "$GCC_VERSION" in
1963                                 ([[34]].*)
1964                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1965                                         continue;;
1966                                 esac
1967                                 ;;
1968                         (Wpointer-arith)
1969                                 case "$GCC_VERSION" in
1970                                 ([[12]].*)
1971                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1972                                         continue;;
1973                                 esac
1974                                 ;;
1975                         esac
1976                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1977                 fi
1978         done
1979         CFLAGS="$cf_save_CFLAGS"
1980 fi
1981 rm -rf ./conftest*
1982
1983 AC_SUBST(EXTRA_CFLAGS)
1984 ])dnl
1985 dnl ---------------------------------------------------------------------------
1986 dnl CF_GETOPT_HEADER version: 8 updated: 2021/06/19 19:16:16
1987 dnl ----------------
1988 dnl Check for getopt's variables which are commonly defined in stdlib.h,
1989 dnl unistd.h or (nonstandard) in getopt.h
1990 AC_DEFUN([CF_GETOPT_HEADER],
1991 [
1992 AC_HAVE_HEADERS(unistd.h getopt.h)
1993 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
1994 cf_cv_getopt_header=none
1995 for cf_header in stdio.h stdlib.h unistd.h getopt.h
1996 do
1997 AC_TRY_COMPILE([
1998 #include <$cf_header>],
1999 [int x = optind; char *y = optarg; (void)x; (void)y],
2000 [cf_cv_getopt_header=$cf_header
2001  break])
2002 done
2003 ])
2004 if test "$cf_cv_getopt_header" != none ; then
2005         AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
2006 fi
2007 if test "$cf_cv_getopt_header" = getopt.h ; then
2008         AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
2009 fi
2010 ])dnl
2011 dnl ---------------------------------------------------------------------------
2012 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
2013 dnl -------------
2014 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
2015 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
2016 dnl (or misfeature) of glibc2, which breaks portability of many applications,
2017 dnl since it is interwoven with GNU extensions.
2018 dnl
2019 dnl Well, yes we could work around it...
2020 dnl
2021 dnl Parameters:
2022 dnl     $1 is the nominal value for _XOPEN_SOURCE
2023 AC_DEFUN([CF_GNU_SOURCE],
2024 [
2025 cf_gnu_xopen_source=ifelse($1,,500,$1)
2026
2027 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
2028 AC_TRY_COMPILE([#include <sys/types.h>],[
2029         #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
2030                 return 0;
2031         #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
2032                 return 0;
2033         #else
2034         #       error not GNU C library
2035         #endif],
2036         [cf_cv_gnu_library=yes],
2037         [cf_cv_gnu_library=no])
2038 ])
2039
2040 if test x$cf_cv_gnu_library = xyes; then
2041
2042         # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
2043         # was changed to help a little.  newlib incorporated the change about 4
2044         # years later.
2045         AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
2046                 cf_save="$CPPFLAGS"
2047                 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
2048                 AC_TRY_COMPILE([#include <sys/types.h>],[
2049                         #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
2050                                 return 0;
2051                         #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
2052                                 return 0;
2053                         #else
2054                         #       error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
2055                         #endif],
2056                         [cf_cv_gnu_library_219=yes],
2057                         [cf_cv_gnu_library_219=no])
2058                 CPPFLAGS="$cf_save"
2059         ])
2060
2061         if test "x$cf_cv_gnu_library_219" = xyes; then
2062                 cf_save="$CPPFLAGS"
2063                 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
2064                         CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
2065                         AC_TRY_COMPILE([
2066                                 #include <limits.h>
2067                                 #include <sys/types.h>
2068                                 ],[
2069                                 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
2070                                         return 0;
2071                                 #else
2072                                 #       error GNU C library is too old
2073                                 #endif],
2074                                 [cf_cv_gnu_dftsrc_219=yes],
2075                                 [cf_cv_gnu_dftsrc_219=no])
2076                         ])
2077                 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
2078         else
2079                 cf_cv_gnu_dftsrc_219=maybe
2080         fi
2081
2082         if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
2083
2084                 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
2085                 AC_TRY_COMPILE([#include <sys/types.h>],[
2086                         #ifndef _XOPEN_SOURCE
2087                         #error  expected _XOPEN_SOURCE to be defined
2088                         #endif],
2089                         [cf_cv_gnu_source=no],
2090                         [cf_save="$CPPFLAGS"
2091                          CF_ADD_CFLAGS(-D_GNU_SOURCE)
2092                          AC_TRY_COMPILE([#include <sys/types.h>],[
2093                                 #ifdef _XOPEN_SOURCE
2094                                 #error  expected _XOPEN_SOURCE to be undefined
2095                                 #endif],
2096                                 [cf_cv_gnu_source=no],
2097                                 [cf_cv_gnu_source=yes])
2098                         CPPFLAGS="$cf_save"
2099                         ])
2100                 ])
2101
2102                 if test "$cf_cv_gnu_source" = yes
2103                 then
2104                 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
2105                         CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
2106                         AC_TRY_COMPILE([#include <sys/types.h>],[
2107                                 #ifdef _DEFAULT_SOURCE
2108                                 #error  expected _DEFAULT_SOURCE to be undefined
2109                                 #endif],
2110                                 [cf_cv_default_source=no],
2111                                 [cf_cv_default_source=yes])
2112                         ])
2113                         if test "$cf_cv_default_source" = yes
2114                         then
2115                                 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
2116                         fi
2117                 fi
2118         fi
2119
2120 fi
2121 ])dnl
2122 dnl ---------------------------------------------------------------------------
2123 dnl CF_HEADER_PATH version: 15 updated: 2021/01/01 13:31:04
2124 dnl --------------
2125 dnl Construct a search-list of directories for a nonstandard header-file
2126 dnl
2127 dnl Parameters
2128 dnl     $1 = the variable to return as result
2129 dnl     $2 = the package name
2130 AC_DEFUN([CF_HEADER_PATH],
2131 [
2132 $1=
2133
2134 # collect the current set of include-directories from compiler flags
2135 cf_header_path_list=""
2136 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2137         for cf_header_path in $CPPFLAGS $CFLAGS
2138         do
2139                 case "$cf_header_path" in
2140                 (-I*)
2141                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2142                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2143                         cf_header_path_list="$cf_header_path_list [$]$1"
2144                         ;;
2145                 esac
2146         done
2147 fi
2148
2149 # add the variations for the package we are looking for
2150 CF_SUBDIR_PATH($1,$2,include)
2151
2152 test "$includedir" != NONE && \
2153 test "$includedir" != "/usr/include" && \
2154 test -d "$includedir" && {
2155         test -d "$includedir" &&    $1="[$]$1 $includedir"
2156         test -d "$includedir/$2" && $1="[$]$1 $includedir/$2"
2157 }
2158
2159 test "$oldincludedir" != NONE && \
2160 test "$oldincludedir" != "/usr/include" && \
2161 test -d "$oldincludedir" && {
2162         test -d "$oldincludedir"    && $1="[$]$1 $oldincludedir"
2163         test -d "$oldincludedir/$2" && $1="[$]$1 $oldincludedir/$2"
2164 }
2165
2166 $1="[$]$1 $cf_header_path_list"
2167 ])dnl
2168 dnl ---------------------------------------------------------------------------
2169 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
2170 dnl ---------------
2171 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2172 AC_DEFUN([CF_HELP_MESSAGE],
2173 [CF_ACVERSION_CHECK(2.53,[],[
2174 AC_DIVERT_HELP($1)])dnl
2175 ])dnl
2176 dnl ---------------------------------------------------------------------------
2177 dnl CF_INHERIT_SCRIPT version: 2 updated: 2003/03/01 23:50:42
2178 dnl -----------------
2179 dnl If we do not have a given script, look for it in the parent directory.
2180 AC_DEFUN([CF_INHERIT_SCRIPT],
2181 [
2182 test -f $1 || ( test -f ../$1 && cp ../$1 ./ )
2183 ])dnl
2184 dnl ---------------------------------------------------------------------------
2185 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
2186 dnl ---------------
2187 dnl prompt for/fill-in useful install-program options
2188 AC_DEFUN([CF_INSTALL_OPTS],
2189 [
2190 CF_INSTALL_OPT_S
2191 CF_INSTALL_OPT_P
2192 CF_INSTALL_OPT_O
2193 ])dnl
2194 dnl ---------------------------------------------------------------------------
2195 dnl CF_INSTALL_OPT_O version: 3 updated: 2020/12/31 20:19:42
2196 dnl ----------------
2197 dnl Almost all "install" programs default to the current user's ownership.
2198 dnl Almost - MINIX is an exception.
2199 AC_DEFUN([CF_INSTALL_OPT_O],
2200 [
2201 AC_MSG_CHECKING(if install needs to be told about ownership)
2202 case `$ac_config_guess` in
2203 (*minix)
2204         with_install_o=yes
2205         ;;
2206 (*)
2207         with_install_o=no
2208         ;;
2209 esac
2210
2211 AC_MSG_RESULT($with_install_o)
2212 if test "x$with_install_o" = xyes
2213 then
2214         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'`"
2215 else
2216         INSTALL_OPT_O=
2217 fi
2218
2219 AC_SUBST(INSTALL_OPT_O)
2220 ])dnl
2221 dnl ---------------------------------------------------------------------------
2222 dnl CF_INSTALL_OPT_P version: 3 updated: 2021/01/01 13:31:04
2223 dnl ----------------
2224 dnl Some install-programs accept a "-p" option to preserve file modification
2225 dnl timestamps.  That can be useful as an install option, as well as a way to
2226 dnl avoid the need for ranlib after copying a static archive.
2227 AC_DEFUN([CF_INSTALL_OPT_P],
2228 [
2229 : "${INSTALL:=install}"
2230 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
2231         rm -rf ./conftest*
2232         date >conftest.in
2233         mkdir conftest.out
2234         sleep 3
2235         if $INSTALL -p conftest.in conftest.out 2>/dev/null
2236         then
2237                 if test -f conftest.out/conftest.in
2238                 then
2239                         test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
2240                         test conftest.out/conftest.in -nt conftest.in 2>conftest.err
2241                         if test -s conftest.err
2242                         then
2243                                 cf_cv_install_p=no
2244                         else
2245                                 cf_cv_install_p=yes
2246                         fi
2247                 else
2248                         cf_cv_install_p=no
2249                 fi
2250         else
2251                 cf_cv_install_p=no
2252         fi
2253         rm -rf ./conftest*
2254 ])
2255 ])dnl
2256 dnl ---------------------------------------------------------------------------
2257 dnl CF_INSTALL_OPT_S version: 3 updated: 2021/01/05 19:23:48
2258 dnl ----------------
2259 dnl By default, we should strip executables which are installed, but leave the
2260 dnl ability to suppress that for unit-testing.
2261 AC_DEFUN([CF_INSTALL_OPT_S],
2262 [
2263 AC_MSG_CHECKING(if you want to install stripped executables)
2264 CF_ARG_DISABLE(stripping,
2265         [  --disable-stripping     do not strip (debug info) installed executables],
2266         [enable_stripping=no],
2267         [enable_stripping=yes])
2268 AC_MSG_RESULT($enable_stripping)
2269
2270 if test "$enable_stripping" = yes
2271 then
2272         INSTALL_OPT_S="-s"
2273 else
2274         INSTALL_OPT_S=
2275 fi
2276 AC_SUBST(INSTALL_OPT_S)
2277 ])dnl
2278 dnl ---------------------------------------------------------------------------
2279 dnl CF_INTEL_COMPILER version: 9 updated: 2023/02/18 17:41:25
2280 dnl -----------------
2281 dnl Check if the given compiler is really the Intel compiler for Linux.  It
2282 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2283 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2284 dnl
2285 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2286 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
2287 dnl the wrappers for gcc and g++ warnings.
2288 dnl
2289 dnl $1 = GCC (default) or GXX
2290 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2291 dnl $3 = CFLAGS (default) or CXXFLAGS
2292 AC_DEFUN([CF_INTEL_COMPILER],[
2293 AC_REQUIRE([AC_CANONICAL_HOST])
2294 ifelse([$2],,INTEL_COMPILER,[$2])=no
2295
2296 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2297         case "$host_os" in
2298         (linux*|gnu*)
2299                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2300                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2301                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2302                 AC_TRY_COMPILE([],[
2303 #ifdef __INTEL_COMPILER
2304 #else
2305 #error __INTEL_COMPILER is not defined
2306 #endif
2307 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2308 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2309 ],[])
2310                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2311                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2312                 ;;
2313         esac
2314 fi
2315 ])dnl
2316 dnl ---------------------------------------------------------------------------
2317 dnl CF_LD_RPATH_OPT version: 9 updated: 2021/01/01 13:31:04
2318 dnl ---------------
2319 dnl For the given system and compiler, find the compiler flags to pass to the
2320 dnl loader to use the "rpath" feature.
2321 AC_DEFUN([CF_LD_RPATH_OPT],
2322 [
2323 AC_REQUIRE([CF_CHECK_CACHE])
2324
2325 LD_RPATH_OPT=
2326 if test "x$cf_cv_enable_rpath" != xno
2327 then
2328         AC_MSG_CHECKING(for an rpath option)
2329         case "$cf_cv_system_name" in
2330         (irix*)
2331                 if test "$GCC" = yes; then
2332                         LD_RPATH_OPT="-Wl,-rpath,"
2333                 else
2334                         LD_RPATH_OPT="-rpath "
2335                 fi
2336                 ;;
2337         (linux*|gnu*|k*bsd*-gnu|freebsd*)
2338                 LD_RPATH_OPT="-Wl,-rpath,"
2339                 ;;
2340         (openbsd[[2-9]].*|mirbsd*)
2341                 LD_RPATH_OPT="-Wl,-rpath,"
2342                 ;;
2343         (dragonfly*)
2344                 LD_RPATH_OPT="-rpath "
2345                 ;;
2346         (netbsd*)
2347                 LD_RPATH_OPT="-Wl,-rpath,"
2348                 ;;
2349         (osf*|mls+*)
2350                 LD_RPATH_OPT="-rpath "
2351                 ;;
2352         (solaris2*)
2353                 LD_RPATH_OPT="-R"
2354                 ;;
2355         (*)
2356                 ;;
2357         esac
2358         AC_MSG_RESULT($LD_RPATH_OPT)
2359
2360         case "x$LD_RPATH_OPT" in
2361         (x-R*)
2362                 AC_MSG_CHECKING(if we need a space after rpath option)
2363                 cf_save_LIBS="$LIBS"
2364                 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2365                 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2366                 LIBS="$cf_save_LIBS"
2367                 AC_MSG_RESULT($cf_rpath_space)
2368                 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2369                 ;;
2370         esac
2371 fi
2372 ])dnl
2373 dnl ---------------------------------------------------------------------------
2374 dnl CF_LIBRARY_PATH version: 11 updated: 2021/01/01 13:31:04
2375 dnl ---------------
2376 dnl Construct a search-list of directories for a nonstandard library-file
2377 dnl
2378 dnl Parameters
2379 dnl     $1 = the variable to return as result
2380 dnl     $2 = the package name
2381 AC_DEFUN([CF_LIBRARY_PATH],
2382 [
2383 $1=
2384 cf_library_path_list=""
2385 if test -n "${LDFLAGS}${LIBS}" ; then
2386         for cf_library_path in $LDFLAGS $LIBS
2387         do
2388                 case "$cf_library_path" in
2389                 (-L*)
2390                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2391                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2392                         cf_library_path_list="$cf_library_path_list [$]$1"
2393                         ;;
2394                 esac
2395         done
2396 fi
2397
2398 CF_SUBDIR_PATH($1,$2,lib)
2399
2400 $1="$cf_library_path_list [$]$1"
2401 ])dnl
2402 dnl ---------------------------------------------------------------------------
2403 dnl CF_MAKE_PHONY version: 3 updated: 2021/01/08 16:08:21
2404 dnl -------------
2405 dnl Check if the make-program handles a ".PHONY" target, e.g,. a target which
2406 dnl acts as a placeholder.
2407 dnl
2408 dnl The ".PHONY" feature was proposed in 2011 here
2409 dnl     https://www.austingroupbugs.net/view.php?id=523
2410 dnl and is scheduled for release in P1003.1 Issue 8 (late 2022).
2411 dnl
2412 dnl This is not supported by SVr4 make (or SunOS 4, 4.3SD, etc), but works with
2413 dnl a few others (i.e., GNU make and the non-POSIX "BSD" make):
2414 dnl
2415 dnl + This is a GNU make feature (since April 1988, but in turn from binutils,
2416 dnl   date unspecified).
2417 dnl
2418 dnl + It was adopted in NetBSD make in June 1995.
2419 dnl
2420 dnl + The other BSD make programs are derived from the NetBSD make (and for
2421 dnl   that reason are not actually different "implementations").
2422 dnl
2423 dnl + Some features of NetBSD make were actually adapted from pmake, which
2424 dnl   began as a modified GNU make starting in 1993.
2425 dnl
2426 dnl + Version 3.8 of the dmake program in January 1992 also implemented this
2427 dnl   GNU make extension, but is less well known than the BSD make.
2428 AC_DEFUN([CF_MAKE_PHONY],[
2429 AC_CACHE_CHECK(for \".PHONY\" make-support, cf_cv_make_PHONY,[
2430         rm -rf conftest*
2431         (
2432                 mkdir conftest || exit 1
2433                 cd conftest
2434                 cat >makefile <<'CF_EOF'
2435 .PHONY: always
2436 DATA=0
2437 always: always.out
2438         @echo "** making [$]@ [$](DATA)"
2439 once: once.out
2440         @echo "** making [$]@ [$](DATA)"
2441 always.out:
2442         @echo "** making [$]@ [$](DATA)"
2443         echo [$](DATA) > [$]@
2444 once.out:
2445         @echo "** making [$]@ [$](DATA)"
2446         echo [$](DATA) > [$]@
2447 CF_EOF
2448                 for cf_data in 1 2 3
2449                 do
2450                         ${MAKE:-make} always DATA=$cf_data
2451                         ${MAKE:-make} once   DATA=$cf_data
2452                         ${MAKE:-make} -t always once
2453                         if test -f always ; then
2454                                 echo "no (case 1)" > ../conftest.tmp
2455                         elif test ! -f always.out ; then
2456                                 echo "no (case 2)" > ../conftest.tmp
2457                         elif test ! -f once.out ; then
2458                                 echo "no (case 3)" > ../conftest.tmp
2459                         elif ! cmp -s always.out once.out ; then
2460                                 echo "no (case 4)" > ../conftest.tmp
2461                                 diff always.out once.out
2462                         else
2463                                 cf_check="`cat always.out`"
2464                                 if test "x$cf_check" != "x$cf_data" ; then
2465                                         echo "no (case 5)" > ../conftest.tmp
2466                                 else
2467                                         echo yes > ../conftest.tmp
2468                                         rm -f ./*.out
2469                                         continue
2470                                 fi
2471                         fi
2472                         break
2473                 done
2474         ) >&AC_FD_CC 2>&1
2475         cf_cv_make_PHONY="`cat conftest.tmp`"
2476         rm -rf conftest*
2477 ])
2478 MAKE_NO_PHONY="#"
2479 MAKE_PHONY="#"
2480 test "x$cf_cv_make_PHONY" = xyes && MAKE_PHONY=
2481 test "x$cf_cv_make_PHONY" != xyes && MAKE_NO_PHONY=
2482 AC_SUBST(MAKE_NO_PHONY)
2483 AC_SUBST(MAKE_PHONY)
2484 ])dnl
2485 dnl ---------------------------------------------------------------------------
2486 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
2487 dnl ------------
2488 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
2489 dnl a monocase filesystem.
2490 AC_DEFUN([CF_MAKE_TAGS],[
2491 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2492
2493 AC_CHECK_PROGS(CTAGS, exctags ctags)
2494 AC_CHECK_PROGS(ETAGS, exetags etags)
2495
2496 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
2497
2498 if test "$cf_cv_mixedcase" = yes ; then
2499         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
2500 else
2501         MAKE_UPPER_TAGS=no
2502 fi
2503
2504 if test "$MAKE_UPPER_TAGS" = yes ; then
2505         MAKE_UPPER_TAGS=
2506 else
2507         MAKE_UPPER_TAGS="#"
2508 fi
2509
2510 if test "$MAKE_LOWER_TAGS" = yes ; then
2511         MAKE_LOWER_TAGS=
2512 else
2513         MAKE_LOWER_TAGS="#"
2514 fi
2515
2516 AC_SUBST(CTAGS)
2517 AC_SUBST(ETAGS)
2518
2519 AC_SUBST(MAKE_UPPER_TAGS)
2520 AC_SUBST(MAKE_LOWER_TAGS)
2521 ])dnl
2522 dnl ---------------------------------------------------------------------------
2523 dnl CF_MATH_LIB version: 11 updated: 2022/07/27 19:01:48
2524 dnl -----------
2525 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
2526 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
2527 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
2528 AC_DEFUN([CF_MATH_LIB],
2529 [
2530 AC_CACHE_CHECK(if -lm needed for math functions,
2531         cf_cv_need_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_need_libm=no],
2539         [cf_cv_need_libm=yes])])
2540
2541 if test "$cf_cv_need_libm" = yes
2542 then
2543
2544         cf_save_LIBS="$LIBS"
2545         LIBS="$LIBS -lm"
2546         AC_CACHE_CHECK(if -lm is available for math functions,
2547         cf_cv_have_libm,[
2548         AC_TRY_LINK([
2549                 #include <stdio.h>
2550                 #include <stdlib.h>
2551                 #include <math.h>
2552         ],
2553         [double x = rand(); printf("result = %g\\n", ]ifelse([$2],,sin(x),$2)[)],
2554         [cf_cv_have_libm=yes],
2555         [cf_cv_have_libm=no])])
2556         LIBS="$cf_save_LIBS"
2557
2558         if test "$cf_cv_have_libm" = yes
2559         then
2560                 ifelse($1,,[CF_ADD_LIB(m)],[$1=-lm])
2561         fi
2562 else
2563         cf_cv_have_libm=yes
2564 fi
2565
2566 if test "$cf_cv_have_libm" = yes
2567 then
2568         AC_DEFINE(HAVE_MATH_FUNCS,1,[Define to 1 if math functions are available])
2569 fi
2570 ])
2571 dnl ---------------------------------------------------------------------------
2572 dnl CF_MIXEDCASE_FILENAMES version: 9 updated: 2021/01/01 16:53:59
2573 dnl ----------------------
2574 dnl Check if the file-system supports mixed-case filenames.  If we're able to
2575 dnl create a lowercase name and see it as uppercase, it doesn't support that.
2576 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
2577 [
2578 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
2579 if test "$cross_compiling" = yes ; then
2580         case "$target_alias" in
2581         (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*)
2582                 cf_cv_mixedcase=no
2583                 ;;
2584         (*)
2585                 cf_cv_mixedcase=yes
2586                 ;;
2587         esac
2588 else
2589         rm -f conftest CONFTEST
2590         echo test >conftest
2591         if test -f CONFTEST ; then
2592                 cf_cv_mixedcase=no
2593         else
2594                 cf_cv_mixedcase=yes
2595         fi
2596         rm -f conftest CONFTEST
2597 fi
2598 ])
2599 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
2600 ])dnl
2601 dnl ---------------------------------------------------------------------------
2602 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
2603 dnl ----------
2604 dnl Write a debug message to config.log, along with the line number in the
2605 dnl configure script.
2606 AC_DEFUN([CF_MSG_LOG],[
2607 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
2608 ])dnl
2609 dnl ---------------------------------------------------------------------------
2610 dnl CF_NCURSES_CC_CHECK version: 6 updated: 2023/02/18 17:47:58
2611 dnl -------------------
2612 dnl Check if we can compile with ncurses' header file
2613 dnl $1 is the cache variable to set
2614 dnl $2 is the header-file to include
2615 dnl $3 is the root name (ncurses or ncursesw)
2616 AC_DEFUN([CF_NCURSES_CC_CHECK],[
2617         AC_TRY_COMPILE([
2618 ]ifelse($3,ncursesw,[
2619 #define _XOPEN_SOURCE_EXTENDED
2620 #undef  HAVE_LIBUTF8_H  /* in case we used CF_UTF8_LIB */
2621 #define HAVE_LIBUTF8_H  /* to force ncurses' header file to use cchar_t */
2622 ])[
2623 #include <$2>],[
2624 #ifdef NCURSES_VERSION
2625 ]ifelse($3,ncursesw,[
2626 #ifndef WACS_BSSB
2627         #error WACS_BSSB is not defined
2628 #endif
2629 ])[
2630 printf("%s\\n", NCURSES_VERSION);
2631 #else
2632 #ifdef __NCURSES_H
2633 printf("old\\n");
2634 #else
2635         #error __NCURSES_H is not defined
2636 #endif
2637 #endif
2638         ]
2639         ,[$1=$2]
2640         ,[$1=no])
2641 ])dnl
2642 dnl ---------------------------------------------------------------------------
2643 dnl CF_NCURSES_CONFIG version: 28 updated: 2021/08/28 15:20:37
2644 dnl -----------------
2645 dnl Tie together the configure-script macros for ncurses, preferring these in
2646 dnl order:
2647 dnl a) ".pc" files for pkg-config, using $NCURSES_CONFIG_PKG
2648 dnl b) the "-config" script from ncurses, using $NCURSES_CONFIG
2649 dnl c) just plain libraries
2650 dnl
2651 dnl $1 is the root library name (default: "ncurses")
2652 AC_DEFUN([CF_NCURSES_CONFIG],[
2653 AC_REQUIRE([CF_PKG_CONFIG])
2654 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
2655 cf_have_ncuconfig=no
2656
2657 if test "x${PKG_CONFIG:=none}" != xnone; then
2658         AC_MSG_CHECKING(pkg-config for $cf_ncuconfig_root)
2659         if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
2660                 AC_MSG_RESULT(yes)
2661
2662                 AC_MSG_CHECKING(if the $cf_ncuconfig_root package files work)
2663                 cf_have_ncuconfig=unknown
2664
2665                 cf_save_CFLAGS="$CFLAGS"
2666                 cf_save_CPPFLAGS="$CPPFLAGS"
2667                 cf_save_LIBS="$LIBS"
2668
2669                 cf_pkg_cflags="`$PKG_CONFIG --cflags $cf_ncuconfig_root`"
2670                 cf_pkg_libs="`$PKG_CONFIG --libs $cf_ncuconfig_root`"
2671
2672                 # while -W for passing linker flags is prevalent, it is not "standard".
2673                 # At least one wrapper for c89/c99 (in Apple's xcode) has its own
2674                 # incompatible _and_ non-standard -W option which gives an error.  Work
2675                 # around that pitfall.
2676                 case "x${CC}@@${cf_pkg_libs}@${cf_pkg_cflags}" in
2677                 (x*c[[89]]9@@*-W*)
2678                         CF_ADD_CFLAGS($cf_pkg_cflags)
2679                         CF_ADD_LIBS($cf_pkg_libs)
2680
2681                         AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2682                                 [initscr(); mousemask(0,0); tigetstr((char *)0);],
2683                                 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2684                                         int main(void)
2685                                         { const char *xx = curses_version(); return (xx == 0); }],
2686                                         [cf_test_ncuconfig=yes],
2687                                         [cf_test_ncuconfig=no],
2688                                         [cf_test_ncuconfig=maybe])],
2689                                 [cf_test_ncuconfig=no])
2690
2691                         CFLAGS="$cf_save_CFLAGS"
2692                         CPPFLAGS="$cf_save_CPPFLAGS"
2693                         LIBS="$cf_save_LIBS"
2694
2695                         if test "x$cf_test_ncuconfig" != xyes; then
2696                                 cf_temp=`echo "x$cf_pkg_cflags" | sed -e s/^x// -e 's/-W[[^     ]]*//g'`
2697                                 cf_pkg_cflags="$cf_temp"
2698                                 cf_temp=`echo "x$cf_pkg_libs" | sed -e s/^x// -e 's/-W[[^       ]]*//g'`
2699                                 cf_pkg_libs="$cf_temp"
2700                         fi
2701                         ;;
2702                 esac
2703
2704                 CF_APPEND_CFLAGS($cf_pkg_cflags)
2705                 CF_ADD_LIBS($cf_pkg_libs)
2706
2707                 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2708                         [initscr(); mousemask(0,0); tigetstr((char *)0);],
2709                         [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2710                                 int main(void)
2711                                 { const char *xx = curses_version(); return (xx == 0); }],
2712                                 [cf_have_ncuconfig=yes],
2713                                 [cf_have_ncuconfig=no],
2714                                 [cf_have_ncuconfig=maybe])],
2715                         [cf_have_ncuconfig=no])
2716                 AC_MSG_RESULT($cf_have_ncuconfig)
2717                 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
2718                 if test "$cf_have_ncuconfig" != "yes"
2719                 then
2720                         CPPFLAGS="$cf_save_CPPFLAGS"
2721                         LIBS="$cf_save_LIBS"
2722                         NCURSES_CONFIG_PKG=none
2723                 else
2724                         AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2725                         NCURSES_CONFIG_PKG=$cf_ncuconfig_root
2726                         CF_TERM_HEADER
2727                 fi
2728
2729         else
2730                 AC_MSG_RESULT(no)
2731                 NCURSES_CONFIG_PKG=none
2732         fi
2733 else
2734         NCURSES_CONFIG_PKG=none
2735 fi
2736
2737 if test "x$cf_have_ncuconfig" = "xno"; then
2738         cf_ncurses_config="${cf_ncuconfig_root}${NCURSES_CONFIG_SUFFIX}-config"; echo "Looking for ${cf_ncurses_config}"
2739
2740         CF_ACVERSION_CHECK(2.52,
2741                 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
2742                 [AC_PATH_PROGS(NCURSES_CONFIG,  ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
2743
2744         if test "$NCURSES_CONFIG" != none ; then
2745
2746                 CF_APPEND_CFLAGS(`$NCURSES_CONFIG --cflags`)
2747                 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
2748
2749                 # even with config script, some packages use no-override for curses.h
2750                 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
2751
2752                 dnl like CF_NCURSES_CPPFLAGS
2753                 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2754
2755                 dnl like CF_NCURSES_LIBS
2756                 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
2757                 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2758
2759                 dnl like CF_NCURSES_VERSION
2760                 cf_cv_ncurses_version="`$NCURSES_CONFIG --version`"
2761
2762         else
2763
2764                 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
2765                 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
2766
2767         fi
2768 else
2769         NCURSES_CONFIG=none
2770 fi
2771 ])dnl
2772 dnl ---------------------------------------------------------------------------
2773 dnl CF_NCURSES_CPPFLAGS version: 22 updated: 2021/01/02 09:31:20
2774 dnl -------------------
2775 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
2776 dnl the CPPFLAGS variable so we can include its header.
2777 dnl
2778 dnl The header files may be installed as either curses.h, or ncurses.h (would
2779 dnl be obsolete, except that some packagers prefer this name to distinguish it
2780 dnl from a "native" curses implementation).  If not installed for overwrite,
2781 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
2782 dnl /usr/include/ncurses), but someone may have installed overwriting the
2783 dnl vendor's curses.  Only very old versions (pre-1.9.2d, the first autoconf'd
2784 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
2785 dnl the header.
2786 dnl
2787 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
2788 dnl is already in the include-path, don't even bother with this, since we cannot
2789 dnl easily determine which file it is.  In this case, it has to be <curses.h>.
2790 dnl
2791 dnl The optional parameter gives the root name of the library, in case it is
2792 dnl not installed as the default curses library.  That is how the
2793 dnl wide-character version of ncurses is installed.
2794 AC_DEFUN([CF_NCURSES_CPPFLAGS],
2795 [AC_REQUIRE([CF_WITH_CURSES_DIR])
2796
2797 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
2798 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
2799
2800 test -n "$cf_cv_curses_dir" && \
2801 test "$cf_cv_curses_dir" != "no" && { \
2802   CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
2803 }
2804
2805 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
2806         cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
2807         { test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw; } && cf_header_list="$cf_header_list curses.h ncurses.h"
2808         for cf_header in $cf_header_list
2809         do
2810                 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
2811                 test "$cf_cv_ncurses_h" != no && break
2812         done
2813 ])
2814
2815 CF_NCURSES_HEADER
2816 CF_TERM_HEADER
2817
2818 # some applications need this, but should check for NCURSES_VERSION
2819 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2820
2821 CF_NCURSES_VERSION
2822 ])dnl
2823 dnl ---------------------------------------------------------------------------
2824 dnl CF_NCURSES_EXT_FUNCS version: 4 updated: 2012/10/06 16:39:58
2825 dnl --------------------
2826 dnl Since 2007/11/17, ncurses has defined NCURSES_EXT_FUNCS; earlier versions
2827 dnl may provide these functions.  Define the symbol if it is not defined, and
2828 dnl if it is valid.
2829 AC_DEFUN([CF_NCURSES_EXT_FUNCS],
2830 [
2831 AC_CACHE_CHECK(for ncurses extended functions,cf_cv_ncurses_ext_funcs,[
2832 AC_TRY_COMPILE([
2833 #include <${cf_cv_ncurses_header:-curses.h}>],
2834 [
2835 int x = NCURSES_EXT_FUNCS
2836 ],[cf_cv_ncurses_ext_funcs=defined],[
2837 AC_TRY_LINK([
2838 #include <${cf_cv_ncurses_header:-curses.h}>],
2839 [
2840         (void) assume_default_colors (0, 0);
2841         (void) curses_version ();
2842         (void) define_key (0, 0);
2843         (void) is_term_resized (0, 0);
2844         (void) key_defined (0);
2845         (void) keybound (0, 0);
2846         (void) keyok (0, 0);
2847         (void) resize_term (0, 0);
2848         (void) resizeterm (0, 0);
2849         (void) use_default_colors ();
2850         (void) use_extended_names (0);
2851         (void) wresize (0, 0, 0);],
2852         [cf_cv_ncurses_ext_funcs=yes],
2853         [cf_cv_ncurses_ext_funcs=no])
2854 ])
2855 ])
2856 test "$cf_cv_ncurses_ext_funcs" = yes && AC_DEFINE(NCURSES_EXT_FUNCS,1,[Define to 1 if we have ncurses extensions])
2857 ])dnl
2858 dnl ---------------------------------------------------------------------------
2859 dnl CF_NCURSES_HEADER version: 7 updated: 2021/01/04 19:33:05
2860 dnl -----------------
2861 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
2862 dnl variations of ncurses' installs.
2863 dnl
2864 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
2865 AC_DEFUN([CF_NCURSES_HEADER],[
2866
2867 if test "$cf_cv_ncurses_h" != no ; then
2868         cf_cv_ncurses_header=$cf_cv_ncurses_h
2869 else
2870
2871 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
2872         test -n "$verbose" && echo
2873         CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
2874         test -n "$verbose" && echo "search path $cf_search"
2875         cf_save2_CPPFLAGS="$CPPFLAGS"
2876         for cf_incdir in $cf_search
2877         do
2878                 CF_ADD_INCDIR($cf_incdir)
2879                 for cf_header in \
2880                         ncurses.h \
2881                         curses.h
2882                 do
2883                         CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
2884                         if test "$cf_cv_ncurses_h2" != no ; then
2885                                 cf_cv_ncurses_h2=$cf_incdir/$cf_header
2886                                 test -n "$verbose" && echo $ECHO_N "    ... found $ECHO_C" 1>&AC_FD_MSG
2887                                 break
2888                         fi
2889                         test -n "$verbose" && echo "    ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
2890                 done
2891                 CPPFLAGS="$cf_save2_CPPFLAGS"
2892                 test "$cf_cv_ncurses_h2" != no && break
2893         done
2894         test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
2895         ])
2896
2897         CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
2898         cf_cv_ncurses_header="`basename "$cf_cv_ncurses_h2"`"
2899         if test "`basename "$cf_1st_incdir"`" = "$cf_ncuhdr_root" ; then
2900                 cf_cv_ncurses_header="$cf_ncuhdr_root/$cf_cv_ncurses_header"
2901         fi
2902         CF_ADD_INCDIR($cf_1st_incdir)
2903
2904 fi
2905
2906 # Set definitions to allow ifdef'ing for ncurses.h
2907
2908 case "$cf_cv_ncurses_header" in
2909 (*ncurses.h)
2910         AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
2911         ;;
2912 esac
2913
2914 case "$cf_cv_ncurses_header" in
2915 (ncurses/curses.h|ncurses/ncurses.h)
2916         AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
2917         ;;
2918 (ncursesw/curses.h|ncursesw/ncurses.h)
2919         AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
2920         ;;
2921 esac
2922
2923 ])dnl
2924 dnl ---------------------------------------------------------------------------
2925 dnl CF_NCURSES_LIBS version: 21 updated: 2021/09/04 06:37:12
2926 dnl ---------------
2927 dnl Look for the ncurses library.  This is a little complicated on Linux,
2928 dnl because it may be linked with the gpm (general purpose mouse) library.
2929 dnl Some distributions have gpm linked with (bsd) curses, which makes it
2930 dnl unusable with ncurses.  However, we don't want to link with gpm unless
2931 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
2932 dnl and the linker will record a dependency.
2933 dnl
2934 dnl The optional parameter gives the root name of the library, in case it is
2935 dnl not installed as the default curses library.  That is how the
2936 dnl wide-character version of ncurses is installed.
2937 AC_DEFUN([CF_NCURSES_LIBS],
2938 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
2939
2940 cf_nculib_root=ifelse($1,,ncurses,$1)
2941         # This works, except for the special case where we find gpm, but
2942         # ncurses is in a nonstandard location via $LIBS, and we really want
2943         # to link gpm.
2944 cf_ncurses_LIBS=""
2945 cf_ncurses_SAVE="$LIBS"
2946 AC_CHECK_LIB(gpm,Gpm_Open,
2947         [AC_CHECK_LIB(gpm,initscr,
2948                 [LIBS="$cf_ncurses_SAVE"],
2949                 [cf_ncurses_LIBS="-lgpm"])])
2950
2951 case "$host_os" in
2952 (freebsd*)
2953         # This is only necessary if you are linking against an obsolete
2954         # version of ncurses (but it should do no harm, since it is static).
2955         if test "$cf_nculib_root" = ncurses ; then
2956                 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
2957         fi
2958         ;;
2959 esac
2960
2961 CF_ADD_LIBS($cf_ncurses_LIBS)
2962
2963 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
2964 then
2965         CF_ADD_LIBS(-l$cf_nculib_root)
2966 else
2967         CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
2968                 [#include <${cf_cv_ncurses_header:-curses.h}>],
2969                 [initscr()],
2970                 initscr)
2971 fi
2972
2973 if test -n "$cf_ncurses_LIBS" ; then
2974         AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
2975         cf_ncurses_SAVE="$LIBS"
2976         for p in $cf_ncurses_LIBS ; do
2977                 q=`echo "$LIBS" | sed -e "s%$p %%" -e "s%$p$%%"`
2978                 if test "$q" != "$LIBS" ; then
2979                         LIBS="$q"
2980                 fi
2981         done
2982         AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2983                 [initscr(); mousemask(0,0); tigetstr((char *)0);],
2984                 [AC_MSG_RESULT(yes)],
2985                 [AC_MSG_RESULT(no)
2986                  LIBS="$cf_ncurses_SAVE"])
2987 fi
2988
2989 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
2990 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2991 ])dnl
2992 dnl ---------------------------------------------------------------------------
2993 dnl CF_NCURSES_PTHREADS version: 2 updated: 2016/04/22 05:07:41
2994 dnl -------------------
2995 dnl Use this followup check to ensure that we link with pthreads if ncurses
2996 dnl uses it.
2997 AC_DEFUN([CF_NCURSES_PTHREADS],[
2998 : ${cf_nculib_root:=ifelse($1,,ncurses,$1)}
2999 AC_CHECK_LIB($cf_nculib_root,_nc_init_pthreads,
3000         cf_cv_ncurses_pthreads=yes,
3001         cf_cv_ncurses_pthreads=no)
3002 if test "$cf_cv_ncurses_pthreads" = yes
3003 then
3004         CF_ADD_LIBS(-lpthread)
3005 fi
3006 ])dnl
3007 dnl ---------------------------------------------------------------------------
3008 dnl CF_NCURSES_VERSION version: 17 updated: 2023/01/05 18:54:02
3009 dnl ------------------
3010 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
3011 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS.  We don't use
3012 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
3013 AC_DEFUN([CF_NCURSES_VERSION],
3014 [
3015 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
3016 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
3017         cf_cv_ncurses_version=no
3018         cf_tempfile=out$$
3019         rm -f "$cf_tempfile"
3020         AC_TRY_RUN([
3021 $ac_includes_default
3022
3023 #include <${cf_cv_ncurses_header:-curses.h}>
3024
3025 int main(void)
3026 {
3027         FILE *fp = fopen("$cf_tempfile", "w");
3028 #ifdef NCURSES_VERSION
3029 # ifdef NCURSES_VERSION_PATCH
3030         fprintf(fp, "%s.%d\\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
3031 # else
3032         fprintf(fp, "%s\\n", NCURSES_VERSION);
3033 # endif
3034 #else
3035 # ifdef __NCURSES_H
3036         fprintf(fp, "old\\n");
3037 # else
3038         make an error
3039 # endif
3040 #endif
3041         ${cf_cv_main_return:-return}(0);
3042 }],[
3043         cf_cv_ncurses_version=`cat $cf_tempfile`],,[
3044
3045         # This will not work if the preprocessor splits the line after the
3046         # Autoconf token.  The 'unproto' program does that.
3047         cat > "conftest.$ac_ext" <<EOF
3048 #include <${cf_cv_ncurses_header:-curses.h}>
3049 #undef Autoconf
3050 #ifdef NCURSES_VERSION
3051 Autoconf NCURSES_VERSION
3052 #else
3053 #ifdef __NCURSES_H
3054 Autoconf "old"
3055 #endif
3056 ;
3057 #endif
3058 EOF
3059         cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
3060         AC_TRY_EVAL(cf_try)
3061         if test -f conftest.out ; then
3062                 cf_out=`sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%' conftest.out`
3063                 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
3064                 rm -f conftest.out
3065         fi
3066 ])
3067         rm -f "$cf_tempfile"
3068 ])
3069 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3070 ])dnl
3071 dnl ---------------------------------------------------------------------------
3072 dnl CF_NCURSES_WRAP_PREFIX version: 1 updated: 2009/03/28 16:08:10
3073 dnl ----------------------
3074 dnl Check for ncurses "wrap-prefix" used for public variables which have been
3075 dnl wrapped with a function to help with concurrency control.
3076 AC_DEFUN([CF_NCURSES_WRAP_PREFIX],
3077 [
3078 AC_MSG_CHECKING(for ncurses wrap-prefix)
3079 AC_ARG_WITH(ncurses-wrap-prefix,
3080         [  --with-ncurses-wrap-prefix naming-prefix for ncurses wrapped-variables],
3081         [NCURSES_WRAP_PREFIX=$withval],
3082         [NCURSES_WRAP_PREFIX=_nc_])
3083 AC_MSG_RESULT($NCURSES_WRAP_PREFIX)
3084
3085 AC_SUBST(NCURSES_WRAP_PREFIX)
3086 ])
3087 dnl ---------------------------------------------------------------------------
3088 dnl CF_NETBSD_FORM_H version: 2 updated: 2012/10/06 16:39:58
3089 dnl ----------------
3090 dnl Check for NetBSD's form.h, which is incompatible with SVr4 and ncurses.
3091 dnl Some workarounds are needed in client programs to allow them to compile.
3092 AC_DEFUN([CF_NETBSD_FORM_H],[
3093 AC_CACHE_CHECK(for NetBSD form.h,cf_cv_netbsd_form_h,[
3094 AC_TRY_COMPILE([
3095 #include <${cf_cv_ncurses_header:-curses.h}>
3096 #include <form.h>
3097 ],[
3098         FORM *form;
3099         int y = current_field(form)->cursor_ypos;
3100         int x = current_field(form)->cursor_xpos;
3101 ],[cf_cv_netbsd_form_h=yes
3102 ],[cf_cv_netbsd_form_h=no])
3103 ])
3104
3105 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])
3106 ])dnl
3107 dnl ---------------------------------------------------------------------------
3108 dnl CF_NETBSD_MENU_H version: 2 updated: 2012/10/06 16:39:58
3109 dnl ----------------
3110 dnl Check for NetBSD's menu.h, which is incompatible with SVr4 and ncurses.
3111 dnl Some workarounds are needed in client programs to allow them to compile.
3112 AC_DEFUN([CF_NETBSD_MENU_H],[
3113 AC_CACHE_CHECK(for NetBSD menu.h,cf_cv_netbsd_menu_h,[
3114 AC_TRY_COMPILE([
3115 #include <${cf_cv_ncurses_header:-curses.h}>
3116 #include <menu.h>
3117 ],[
3118         MENU *menu;
3119         int y = menu->max_item_width;
3120 ],[cf_cv_netbsd_menu_h=yes
3121 ],[cf_cv_netbsd_menu_h=no])
3122 ])
3123
3124 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])
3125 ])dnl
3126 dnl ---------------------------------------------------------------------------
3127 dnl CF_NO_LEAKS_OPTION version: 9 updated: 2021/06/13 19:45:41
3128 dnl ------------------
3129 dnl see CF_WITH_NO_LEAKS
3130 dnl
3131 dnl $1 = option/name
3132 dnl $2 = help-text
3133 dnl $3 = symbol to define if the option is set
3134 dnl $4 = additional actions to take if the option is set
3135 AC_DEFUN([CF_NO_LEAKS_OPTION],[
3136 AC_MSG_CHECKING(if you want to use $1 for testing)
3137 AC_ARG_WITH($1,
3138         [$2],
3139         [case "x$withval" in
3140         (x|xno) ;;
3141         (*)
3142                 : "${with_cflags:=-g}"
3143                 : "${enable_leaks:=no}"
3144                 with_$1=yes
3145                 AC_DEFINE_UNQUOTED($3,1,"Define to 1 if you want to use $1 for testing.")ifelse([$4],,[
3146          $4
3147 ])
3148                 ;;
3149         esac],
3150         [with_$1=])
3151 AC_MSG_RESULT(${with_$1:-no})
3152
3153 case ".$with_cflags" in
3154 (.*-g*)
3155         case .$CFLAGS in
3156         (.*-g*)
3157                 ;;
3158         (*)
3159                 CF_ADD_CFLAGS([-g])
3160                 ;;
3161         esac
3162         ;;
3163 esac
3164 ])dnl
3165 dnl ---------------------------------------------------------------------------
3166 dnl CF_PATH_SYNTAX version: 18 updated: 2020/12/31 18:40:20
3167 dnl --------------
3168 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
3169 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3170 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
3171 dnl delayed evaluation of those symbols.
3172 AC_DEFUN([CF_PATH_SYNTAX],[
3173 if test "x$prefix" != xNONE; then
3174         cf_path_syntax="$prefix"
3175 else
3176         cf_path_syntax="$ac_default_prefix"
3177 fi
3178
3179 case ".[$]$1" in
3180 (.\[$]\(*\)*|.\'*\'*)
3181         ;;
3182 (..|./*|.\\*)
3183         ;;
3184 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
3185         ;;
3186 (.\[$]\{*prefix\}*|.\[$]\{*dir\}*)
3187         eval $1="[$]$1"
3188         case ".[$]$1" in
3189         (.NONE/*)
3190                 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3191                 ;;
3192         esac
3193         ;;
3194 (.no|.NONE/*)
3195         $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3196         ;;
3197 (*)
3198         ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3199         ;;
3200 esac
3201 ])dnl
3202 dnl ---------------------------------------------------------------------------
3203 dnl CF_PDCURSES_X11 version: 15 updated: 2021/01/02 09:31:20
3204 dnl ---------------
3205 dnl Configure for PDCurses' X11 library
3206 AC_DEFUN([CF_PDCURSES_X11],[
3207 AC_REQUIRE([CF_X_ATHENA])
3208
3209 CF_ACVERSION_CHECK(2.52,
3210         [AC_CHECK_TOOLS(XCURSES_CONFIG, xcurses-config, none)],
3211         [AC_PATH_PROGS(XCURSES_CONFIG, xcurses-config, none)])
3212
3213 if test "$XCURSES_CONFIG" != none ; then
3214
3215 CF_ADD_CFLAGS(`$XCURSES_CONFIG --cflags`)
3216 CF_ADD_LIBS(`$XCURSES_CONFIG --libs`)
3217
3218 cf_cv_lib_XCurses=yes
3219
3220 else
3221
3222 LDFLAGS="$LDFLAGS $X_LIBS"
3223 CF_CHECK_CFLAGS($X_CFLAGS)
3224 AC_CHECK_LIB(X11,XOpenDisplay,
3225         [CF_ADD_LIBS(-lX11)],,
3226         [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])
3227 AC_CACHE_CHECK(for XCurses library,cf_cv_lib_XCurses,[
3228 CF_ADD_LIBS(-lXCurses)
3229 AC_TRY_LINK([
3230 #include <xcurses.h>
3231 char *XCursesProgramName = "test";
3232 ],[XCursesExit();],
3233 [cf_cv_lib_XCurses=yes],
3234 [cf_cv_lib_XCurses=no])
3235 ])
3236
3237 fi
3238
3239 if test "$cf_cv_lib_XCurses" = yes ; then
3240         AC_DEFINE(UNIX,1,[Define to 1 if using PDCurses on Unix])
3241         AC_DEFINE(XCURSES,1,[Define to 1 if using PDCurses on Unix])
3242         AC_CHECK_HEADER(xcurses.h, AC_DEFINE(HAVE_XCURSES,1,[Define to 1 if using PDCurses on Unix]))
3243 else
3244         AC_MSG_ERROR(Cannot link with XCurses)
3245 fi
3246 ])dnl
3247 dnl ---------------------------------------------------------------------------
3248 dnl CF_PKG_CONFIG version: 12 updated: 2021/10/10 20:18:09
3249 dnl -------------
3250 dnl Check for the package-config program, unless disabled by command-line.
3251 dnl
3252 dnl Sets $PKG_CONFIG to the pathname of the pkg-config program.
3253 AC_DEFUN([CF_PKG_CONFIG],
3254 [
3255 AC_MSG_CHECKING(if you want to use pkg-config)
3256 AC_ARG_WITH(pkg-config,
3257         [  --with-pkg-config{=path} enable/disable use of pkg-config],
3258         [cf_pkg_config=$withval],
3259         [cf_pkg_config=yes])
3260 AC_MSG_RESULT($cf_pkg_config)
3261
3262 case "$cf_pkg_config" in
3263 (no)
3264         PKG_CONFIG=none
3265         ;;
3266 (yes)
3267         CF_ACVERSION_CHECK(2.52,
3268                 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
3269                 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
3270         ;;
3271 (*)
3272         PKG_CONFIG=$withval
3273         ;;
3274 esac
3275
3276 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3277 if test "$PKG_CONFIG" != none ; then
3278         CF_PATH_SYNTAX(PKG_CONFIG)
3279 elif test "x$cf_pkg_config" != xno ; then
3280         AC_MSG_WARN(pkg-config is not installed)
3281 fi
3282
3283 AC_SUBST(PKG_CONFIG)
3284 ])dnl
3285 dnl ---------------------------------------------------------------------------
3286 dnl CF_POSIX_C_SOURCE version: 12 updated: 2023/02/18 17:41:25
3287 dnl -----------------
3288 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3289 dnl
3290 dnl     POSIX.1-1990                            _POSIX_SOURCE
3291 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
3292 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
3293 dnl             Bindings Option
3294 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
3295 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
3296 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
3297 dnl
3298 dnl Parameters:
3299 dnl     $1 is the nominal value for _POSIX_C_SOURCE
3300 AC_DEFUN([CF_POSIX_C_SOURCE],
3301 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
3302
3303 if test "$cf_cv_posix_visible" = no; then
3304
3305 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
3306
3307 cf_save_CFLAGS="$CFLAGS"
3308 cf_save_CPPFLAGS="$CPPFLAGS"
3309
3310 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3311 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3312
3313 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3314         CF_MSG_LOG(if the symbol is already defined go no further)
3315         AC_TRY_COMPILE([#include <sys/types.h>],[
3316 #ifndef _POSIX_C_SOURCE
3317 #error _POSIX_C_SOURCE is not defined
3318 #endif],
3319         [cf_cv_posix_c_source=no],
3320         [cf_want_posix_source=no
3321          case .$cf_POSIX_C_SOURCE in
3322          (.[[12]]??*)
3323                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3324                 ;;
3325          (.2)
3326                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3327                 cf_want_posix_source=yes
3328                 ;;
3329          (.*)
3330                 cf_want_posix_source=yes
3331                 ;;
3332          esac
3333          if test "$cf_want_posix_source" = yes ; then
3334                 AC_TRY_COMPILE([#include <sys/types.h>],[
3335 #ifdef _POSIX_SOURCE
3336 #error _POSIX_SOURCE is defined
3337 #endif],[],
3338                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3339          fi
3340          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3341          CFLAGS="$cf_trim_CFLAGS"
3342          CPPFLAGS="$cf_trim_CPPFLAGS"
3343          CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
3344          CF_MSG_LOG(if the second compile does not leave our definition intact error)
3345          AC_TRY_COMPILE([#include <sys/types.h>],[
3346 #ifndef _POSIX_C_SOURCE
3347 #error _POSIX_C_SOURCE is not defined
3348 #endif],,
3349          [cf_cv_posix_c_source=no])
3350          CFLAGS="$cf_save_CFLAGS"
3351          CPPFLAGS="$cf_save_CPPFLAGS"
3352         ])
3353 ])
3354
3355 if test "$cf_cv_posix_c_source" != no ; then
3356         CFLAGS="$cf_trim_CFLAGS"
3357         CPPFLAGS="$cf_trim_CPPFLAGS"
3358         CF_ADD_CFLAGS($cf_cv_posix_c_source)
3359 fi
3360
3361 fi # cf_cv_posix_visible
3362
3363 ])dnl
3364 dnl ---------------------------------------------------------------------------
3365 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
3366 dnl ----------------
3367 dnl POSIX documents test-macros which an application may set before any system
3368 dnl headers are included to make features available.
3369 dnl
3370 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
3371 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
3372 dnl recent features visible in the system header files unless the application
3373 dnl overrides the corresponding test-macros.  Doing that introduces portability
3374 dnl problems.
3375 dnl
3376 dnl This macro makes a special check for the symbols used for this, to avoid a
3377 dnl conflicting definition.
3378 AC_DEFUN([CF_POSIX_VISIBLE],
3379 [
3380 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
3381 AC_TRY_COMPILE([#include <stdio.h>],[
3382 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
3383         && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
3384         && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
3385         && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
3386 #error conflicting symbols found
3387 #endif
3388 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
3389 ])
3390 ])dnl
3391 dnl ---------------------------------------------------------------------------
3392 dnl CF_PRG_RULES version: 2 updated: 2021/01/01 13:31:04
3393 dnl ------------
3394 dnl Append definitions and rules for the given programs to the subdirectory
3395 dnl Makefiles, and the recursion rule for the top-level Makefile.
3396 dnl
3397 dnl parameters
3398 dnl     $1 = script to run
3399 dnl     $2 = list of subdirectories
3400 dnl
3401 dnl variables
3402 dnl     $AWK
3403 AC_DEFUN([CF_PRG_RULES],
3404 [
3405 for cf_dir in $2
3406 do
3407         if test ! -d "$srcdir/$cf_dir" ; then
3408                 continue
3409         elif test -f "$srcdir/$cf_dir/programs" ; then
3410                 $AWK -f $1 "$srcdir/$cf_dir/programs" >>$cf_dir/Makefile
3411         fi
3412 done
3413
3414 ])dnl
3415 dnl ---------------------------------------------------------------------------
3416 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
3417 dnl ----------
3418 dnl standard check for CC, plus followup sanity checks
3419 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
3420 AC_DEFUN([CF_PROG_CC],[
3421 CF_ACVERSION_CHECK(2.53,
3422         [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
3423          AC_REQUIRE([AC_PROG_CC])],
3424         [])
3425 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
3426 CF_GCC_VERSION
3427 CF_ACVERSION_CHECK(2.52,
3428         [AC_PROG_CC_STDC],
3429         [CF_ANSI_CC_REQD])
3430 CF_CC_ENV_FLAGS
3431 ])dnl
3432 dnl ---------------------------------------------------------------------------
3433 dnl CF_PROG_INSTALL version: 10 updated: 2021/01/04 19:33:05
3434 dnl ---------------
3435 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
3436 dnl misc/tabset install won't work properly.  Usually this happens only when
3437 dnl using the fallback mkinstalldirs script
3438 AC_DEFUN([CF_PROG_INSTALL],
3439 [AC_PROG_INSTALL
3440 case $INSTALL in
3441 (/*)
3442         ;;
3443 (*)
3444         CF_DIRNAME(cf_dir,$INSTALL)
3445         test -z "$cf_dir" && cf_dir=.
3446         INSTALL="`cd \"$cf_dir\" && pwd`"/"`echo "$INSTALL" | sed -e 's%^.*/%%'`"
3447         ;;
3448 esac
3449 ])dnl
3450 dnl ---------------------------------------------------------------------------
3451 dnl CF_PROG_LINT version: 5 updated: 2022/08/20 15:44:13
3452 dnl ------------
3453 AC_DEFUN([CF_PROG_LINT],
3454 [
3455 AC_CHECK_PROGS(LINT, lint cppcheck splint)
3456 case "x$LINT" in
3457 (xcppcheck|x*/cppcheck)
3458         test -z "$LINT_OPTS" && LINT_OPTS="--enable=all"
3459         ;;
3460 esac
3461 AC_SUBST(LINT_OPTS)
3462 AC_SUBST(LINT_LIBS)
3463 ])dnl
3464 dnl ---------------------------------------------------------------------------
3465 dnl CF_REMOVE_CFLAGS version: 3 updated: 2021/09/05 17:25:40
3466 dnl ----------------
3467 dnl Remove a given option from CFLAGS/CPPFLAGS
3468 dnl $1 = option to remove
3469 dnl $2 = variable to update
3470 dnl $3 = nonempty to allow verbose message
3471 define([CF_REMOVE_CFLAGS],
3472 [
3473 cf_tmp_cflag=`echo "x$1" | sed -e 's/^.//' -e 's/=.*//'`
3474 while true
3475 do
3476         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'`
3477         test "[$]$2" != "$cf_old_cflag" || break
3478         ifelse([$3],,,[CF_VERBOSE(removing old option $1 from $2)])
3479         $2="$cf_old_cflag"
3480 done
3481 ])dnl
3482 dnl ---------------------------------------------------------------------------
3483 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
3484 dnl ----------------
3485 dnl Remove all -U and -D options that refer to the given symbol from a list
3486 dnl of C compiler options.  This works around the problem that not all
3487 dnl compilers process -U and -D options from left-to-right, so a -U option
3488 dnl cannot be used to cancel the effect of a preceding -D option.
3489 dnl
3490 dnl $1 = target (which could be the same as the source variable)
3491 dnl $2 = source (including '$')
3492 dnl $3 = symbol to remove
3493 define([CF_REMOVE_DEFINE],
3494 [
3495 $1=`echo "$2" | \
3496         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
3497                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
3498 ])dnl
3499 dnl ---------------------------------------------------------------------------
3500 dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45
3501 dnl ---------------------
3502 dnl Restore flags saved in CF_SAVE_XTRA_FLAGS
3503 dnl $1 = name of current macro
3504 define([CF_RESTORE_XTRA_FLAGS],
3505 [
3506 LIBS="$cf_save_LIBS_$1"
3507 CFLAGS="$cf_save_CFLAGS_$1"
3508 CPPFLAGS="$cf_save_CPPFLAGS_$1"
3509 ])dnl
3510 dnl ---------------------------------------------------------------------------
3511 dnl CF_RPATH_HACK version: 13 updated: 2021/01/03 18:30:50
3512 dnl -------------
3513 AC_DEFUN([CF_RPATH_HACK],
3514 [AC_REQUIRE([AC_PROG_FGREP])dnl
3515 AC_REQUIRE([CF_LD_RPATH_OPT])dnl
3516
3517 AC_MSG_CHECKING(for updated LDFLAGS)
3518 if test -n "$LD_RPATH_OPT" ; then
3519         AC_MSG_RESULT(maybe)
3520
3521         AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
3522         cf_rpath_list="/usr/lib /lib"
3523         if test "$cf_ldd_prog" != no
3524         then
3525                 cf_rpath_oops=
3526
3527 AC_TRY_LINK([#include <stdio.h>],
3528                 [printf("Hello");],
3529                 [cf_rpath_oops=`"$cf_ldd_prog" "conftest$ac_exeext" | ${FGREP-fgrep} ' not found' | sed -e 's% =>.*$%%' |sort | uniq`
3530                  cf_rpath_list=`"$cf_ldd_prog" "conftest$ac_exeext" | ${FGREP-fgrep} / | sed -e 's%^.*[[        ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort | uniq`])
3531
3532                 # If we passed the link-test, but get a "not found" on a given library,
3533                 # this could be due to inept reconfiguration of gcc to make it only
3534                 # partly honor /usr/local/lib (or whatever).  Sometimes this behavior
3535                 # is intentional, e.g., installing gcc in /usr/bin and suppressing the
3536                 # /usr/local libraries.
3537                 if test -n "$cf_rpath_oops"
3538                 then
3539                         for cf_rpath_src in $cf_rpath_oops
3540                         do
3541                                 for cf_rpath_dir in \
3542                                         /usr/local \
3543                                         /usr/pkg \
3544                                         /opt/sfw
3545                                 do
3546                                         if test -f "$cf_rpath_dir/lib/$cf_rpath_src"
3547                                         then
3548                                                 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
3549                                                 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
3550                                                 break
3551                                         fi
3552                                 done
3553                         done
3554                 fi
3555         fi
3556
3557         CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3558
3559         CF_RPATH_HACK_2(LDFLAGS)
3560         CF_RPATH_HACK_2(LIBS)
3561
3562         CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3563 else
3564         AC_MSG_RESULT(no)
3565 fi
3566 AC_SUBST(EXTRA_LDFLAGS)
3567 ])dnl
3568 dnl ---------------------------------------------------------------------------
3569 dnl CF_RPATH_HACK_2 version: 8 updated: 2021/01/01 13:31:04
3570 dnl ---------------
3571 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
3572 dnl EXTRA_LDFLAGS for each -L option found.
3573 dnl
3574 dnl $cf_rpath_list contains a list of directories to ignore.
3575 dnl
3576 dnl $1 = variable name to update.  The LDFLAGS variable should be the only one,
3577 dnl      but LIBS often has misplaced -L options.
3578 AC_DEFUN([CF_RPATH_HACK_2],
3579 [
3580 CF_VERBOSE(...checking $1 [$]$1)
3581
3582 cf_rpath_dst=
3583 for cf_rpath_src in [$]$1
3584 do
3585         case "$cf_rpath_src" in
3586         (-L*)
3587
3588                 # check if this refers to a directory which we will ignore
3589                 cf_rpath_skip=no
3590                 if test -n "$cf_rpath_list"
3591                 then
3592                         for cf_rpath_item in $cf_rpath_list
3593                         do
3594                                 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
3595                                 then
3596                                         cf_rpath_skip=yes
3597                                         break
3598                                 fi
3599                         done
3600                 fi
3601
3602                 if test "$cf_rpath_skip" = no
3603                 then
3604                         # transform the option
3605                         if test "$LD_RPATH_OPT" = "-R " ; then
3606                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
3607                         else
3608                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
3609                         fi
3610
3611                         # if we have not already added this, add it now
3612                         cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
3613                         if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
3614                         then
3615                                 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
3616                                 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
3617                         fi
3618                 fi
3619                 ;;
3620         esac
3621         cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
3622 done
3623 $1=$cf_rpath_dst
3624
3625 CF_VERBOSE(...checked $1 [$]$1)
3626 AC_SUBST(EXTRA_LDFLAGS)
3627 ])dnl
3628 dnl ---------------------------------------------------------------------------
3629 dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44
3630 dnl ------------------
3631 dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers
3632 dnl and libraries which do not update those variables.
3633 dnl
3634 dnl $1 = name of current macro
3635 define([CF_SAVE_XTRA_FLAGS],
3636 [
3637 cf_save_LIBS_$1="$LIBS"
3638 cf_save_CFLAGS_$1="$CFLAGS"
3639 cf_save_CPPFLAGS_$1="$CPPFLAGS"
3640 LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}"
3641 for cf_X_CFLAGS in $X_CFLAGS
3642 do
3643         case "x$cf_X_CFLAGS" in
3644         x-[[IUD]]*)
3645                 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS"
3646                 ;;
3647         *)
3648                 CFLAGS="$CFLAGS $cf_X_CFLAGS"
3649                 ;;
3650         esac
3651 done
3652 ])dnl
3653 dnl ---------------------------------------------------------------------------
3654 dnl CF_SIGWINCH version: 7 updated: 2023/02/18 17:41:25
3655 dnl -----------
3656 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
3657 dnl programs need this test).
3658 dnl
3659 dnl This is really a Mac OS X 10.4.3 workaround.  Defining _POSIX_C_SOURCE
3660 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses).  Oddly, the struct
3661 dnl winsize declaration is left alone - we may revisit this if Apple choose to
3662 dnl break that part of the interface as well.
3663 AC_DEFUN([CF_SIGWINCH],
3664 [
3665 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
3666         AC_TRY_COMPILE([
3667 #include <sys/types.h>
3668 #include <sys/signal.h>
3669 ],[int x = SIGWINCH; (void)x],
3670         [cf_cv_define_sigwinch=yes],
3671         [AC_TRY_COMPILE([
3672 #undef _XOPEN_SOURCE
3673 #undef _POSIX_SOURCE
3674 #undef _POSIX_C_SOURCE
3675 #include <sys/types.h>
3676 #include <sys/signal.h>
3677 ],[int x = SIGWINCH; (void)x],
3678         [cf_cv_define_sigwinch=maybe],
3679         [cf_cv_define_sigwinch=no])
3680 ])
3681 ])
3682
3683 if test "$cf_cv_define_sigwinch" = maybe ; then
3684 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
3685 cf_cv_fixup_sigwinch=unknown
3686 cf_sigwinch=32
3687 while test "$cf_sigwinch" != 1
3688 do
3689         AC_TRY_COMPILE([
3690 #undef _XOPEN_SOURCE
3691 #undef _POSIX_SOURCE
3692 #undef _POSIX_C_SOURCE
3693 #include <sys/types.h>
3694 #include <sys/signal.h>
3695 ],[
3696 #if SIGWINCH != $cf_sigwinch
3697 #error SIGWINCH is not $cf_sigwinch
3698 #endif
3699 int x = SIGWINCH; (void)x],
3700         [cf_cv_fixup_sigwinch=$cf_sigwinch
3701          break])
3702
3703 cf_sigwinch="`expr "$cf_sigwinch" - 1`"
3704 done
3705 ])
3706
3707         if test "$cf_cv_fixup_sigwinch" != unknown ; then
3708                 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
3709         fi
3710 fi
3711 ])dnl
3712 dnl ---------------------------------------------------------------------------
3713 dnl CF_SIG_ATOMIC_T version: 5 updated: 2020/03/10 18:53:47
3714 dnl ---------------
3715 dnl signal handler, but there are some gcc dependencies in that recommendation.
3716 dnl Try anyway.
3717 AC_DEFUN([CF_SIG_ATOMIC_T],
3718 [
3719 AC_MSG_CHECKING(for signal global datatype)
3720 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
3721         for cf_type in \
3722                 "volatile sig_atomic_t" \
3723                 "sig_atomic_t" \
3724                 "int"
3725         do
3726         AC_TRY_COMPILE([
3727 #include <sys/types.h>
3728 #include <signal.h>
3729 #include <stdio.h>
3730
3731 extern $cf_type x;
3732 $cf_type x;
3733 static void handler(int sig)
3734 {
3735         (void)sig;
3736         x = 5;
3737 }],
3738                 [signal(SIGINT, handler);
3739                  x = 1],
3740                 [cf_cv_sig_atomic_t=$cf_type],
3741                 [cf_cv_sig_atomic_t=no])
3742                 test "$cf_cv_sig_atomic_t" != no && break
3743         done
3744         ])
3745 AC_MSG_RESULT($cf_cv_sig_atomic_t)
3746 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t,[Define to signal global datatype])
3747 ])dnl
3748 dnl ---------------------------------------------------------------------------
3749 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
3750 dnl --------------
3751 dnl Construct a search-list for a nonstandard header/lib-file
3752 dnl     $1 = the variable to return as result
3753 dnl     $2 = the package name
3754 dnl     $3 = the subdirectory, e.g., bin, include or lib
3755 AC_DEFUN([CF_SUBDIR_PATH],
3756 [
3757 $1=
3758
3759 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
3760
3761 for cf_subdir_prefix in \
3762         /usr \
3763         /usr/local \
3764         /usr/pkg \
3765         /opt \
3766         /opt/local \
3767         [$]HOME
3768 do
3769         CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
3770 done
3771 ])dnl
3772 dnl ---------------------------------------------------------------------------
3773 dnl CF_SYS_TIME_SELECT version: 6 updated: 2015/04/18 08:56:57
3774 dnl ------------------
3775 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
3776 dnl older SCO configurations.
3777 AC_DEFUN([CF_SYS_TIME_SELECT],
3778 [
3779 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
3780 AC_CACHE_VAL(cf_cv_sys_time_select,[
3781 AC_TRY_COMPILE([
3782 #include <sys/types.h>
3783 #ifdef HAVE_SYS_TIME_H
3784 #include <sys/time.h>
3785 #endif
3786 #ifdef HAVE_SYS_SELECT_H
3787 #include <sys/select.h>
3788 #endif
3789 ],[],[cf_cv_sys_time_select=yes],
3790          [cf_cv_sys_time_select=no])
3791          ])
3792 AC_MSG_RESULT($cf_cv_sys_time_select)
3793 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>])
3794 ])dnl
3795 dnl ---------------------------------------------------------------------------
3796 dnl CF_TERM_HEADER version: 6 updated: 2021/01/02 09:31:20
3797 dnl --------------
3798 dnl Look for term.h, which is part of X/Open curses.  It defines the interface
3799 dnl to terminfo database.  Usually it is in the same include-path as curses.h,
3800 dnl but some packagers change this, breaking various applications.
3801 AC_DEFUN([CF_TERM_HEADER],[
3802 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
3803 case "${cf_cv_ncurses_header}" in
3804 (*/ncurses.h|*/ncursesw.h)
3805         cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
3806         ;;
3807 (*)
3808         cf_term_header=term.h
3809         ;;
3810 esac
3811
3812 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
3813 do
3814 AC_TRY_COMPILE([#include <stdio.h>
3815 #include <${cf_cv_ncurses_header:-curses.h}>
3816 #include <$cf_test>
3817 ],[int x = auto_left_margin; (void)x],[
3818         cf_cv_term_header="$cf_test"],[
3819         cf_cv_term_header=unknown
3820         ])
3821         test "$cf_cv_term_header" != unknown && break
3822 done
3823 ])
3824
3825 # Set definitions to allow ifdef'ing to accommodate subdirectories
3826
3827 case "$cf_cv_term_header" in
3828 (*term.h)
3829         AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
3830         ;;
3831 esac
3832
3833 case "$cf_cv_term_header" in
3834 (ncurses/term.h)
3835         AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
3836         ;;
3837 (ncursesw/term.h)
3838         AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
3839         ;;
3840 esac
3841 ])dnl
3842 dnl ---------------------------------------------------------------------------
3843 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
3844 dnl ---------------
3845 dnl Define a top_builddir symbol, for applications that need an absolute path.
3846 AC_DEFUN([CF_TOP_BUILDDIR],
3847 [
3848 top_builddir=ifelse($1,,`pwd`,$1)
3849 AC_SUBST(top_builddir)
3850 ])dnl
3851 dnl ---------------------------------------------------------------------------
3852 dnl CF_TPUTS_PROTO version: 4 updated: 2021/01/04 19:45:09
3853 dnl --------------
3854 dnl Check for type of function-pointer passed to tputs.  Some old
3855 dnl implementations used functions that had different prototypes, making it
3856 dnl hard to compile portable programs using tputs.
3857 AC_DEFUN([CF_TPUTS_PROTO],[
3858 CF_CURSES_FUNCS(tputs)
3859 if test "x$cf_cv_func_tputs" = xyes
3860 then
3861         cf_done=no
3862         for cf_arg in int char
3863         do
3864                 for cf_ret in int void
3865                 do
3866                         if test "$cf_ret" = void
3867                         then
3868                                 cf_return="/* nothing */"
3869                         else
3870                                 cf_return="return value"
3871                         fi
3872                         AC_TRY_COMPILE([
3873 #include <${cf_cv_ncurses_header:-curses.h}>
3874 #include <$cf_cv_term_header>
3875
3876 static $cf_ret outc($cf_arg value) { $cf_return; }
3877 ],[
3878         tputs("hello", 0, outc);
3879         ${cf_cv_main_return:-return}(0);
3880 ],[
3881                 CF_VERBOSE([prototype $cf_ret func($cf_arg value)])
3882                 cat >>confdefs.h <<EOF
3883 #define TPUTS_ARG               $cf_arg
3884 #define TPUTS_PROTO(func,value) $cf_ret func(TPUTS_ARG value)
3885 #define TPUTS_RETURN(value)     $cf_return
3886 EOF
3887                 cf_done=yes
3888                 break
3889 ])
3890                 done
3891                 test "$cf_done" = yes && break
3892         done
3893 fi
3894 ])dnl
3895 dnl ---------------------------------------------------------------------------
3896 dnl CF_TRIM_X_LIBS version: 3 updated: 2015/04/12 15:39:00
3897 dnl --------------
3898 dnl Trim extra base X libraries added as a workaround for inconsistent library
3899 dnl dependencies returned by "new" pkg-config files.
3900 AC_DEFUN([CF_TRIM_X_LIBS],[
3901         for cf_trim_lib in Xmu Xt X11
3902         do
3903                 case "$LIBS" in
3904                 (*-l$cf_trim_lib\ *-l$cf_trim_lib*)
3905                         LIBS=`echo "$LIBS " | sed -e 's/  / /g' -e 's%-l'"$cf_trim_lib"' %%' -e 's/ $//'`
3906                         CF_VERBOSE(..trimmed $LIBS)
3907                         ;;
3908                 esac
3909         done
3910 ])
3911 dnl ---------------------------------------------------------------------------
3912 dnl CF_TRY_PKG_CONFIG version: 6 updated: 2020/12/31 10:54:15
3913 dnl -----------------
3914 dnl This is a simple wrapper to use for pkg-config, for libraries which may be
3915 dnl available in that form.
3916 dnl
3917 dnl $1 = package name, which may be a shell variable
3918 dnl $2 = extra logic to use, if any, after updating CFLAGS and LIBS
3919 dnl $3 = logic to use if pkg-config does not have the package
3920 AC_DEFUN([CF_TRY_PKG_CONFIG],[
3921 AC_REQUIRE([CF_PKG_CONFIG])
3922
3923 if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists "$1"; then
3924         CF_VERBOSE(found package $1)
3925         cf_pkgconfig_incs="`$PKG_CONFIG --cflags "$1" 2>/dev/null`"
3926         cf_pkgconfig_libs="`$PKG_CONFIG --libs   "$1" 2>/dev/null`"
3927         CF_VERBOSE(package $1 CFLAGS: $cf_pkgconfig_incs)
3928         CF_VERBOSE(package $1 LIBS: $cf_pkgconfig_libs)
3929         CF_ADD_CFLAGS($cf_pkgconfig_incs)
3930         CF_ADD_LIBS($cf_pkgconfig_libs)
3931         ifelse([$2],,:,[$2])
3932 else
3933         cf_pkgconfig_incs=
3934         cf_pkgconfig_libs=
3935         ifelse([$3],,:,[$3])
3936 fi
3937 ])
3938 dnl ---------------------------------------------------------------------------
3939 dnl CF_TRY_XOPEN_SOURCE version: 4 updated: 2022/09/10 15:16:16
3940 dnl -------------------
3941 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
3942 dnl can define it successfully.
3943 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
3944 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
3945         AC_TRY_COMPILE(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY,
3946         [cf_cv_xopen_source=no],
3947         [cf_save="$CPPFLAGS"
3948          CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE)
3949          AC_TRY_COMPILE(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY,
3950                 [cf_cv_xopen_source=no],
3951                 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
3952                 CPPFLAGS="$cf_save"
3953         ])
3954 ])
3955
3956 if test "$cf_cv_xopen_source" != no ; then
3957         CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
3958         CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
3959         cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
3960         CF_APPEND_CFLAGS($cf_temp_xopen_source)
3961 fi
3962 ])
3963 dnl ---------------------------------------------------------------------------
3964 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
3965 dnl --------
3966 dnl Make an uppercase version of a variable
3967 dnl $1=uppercase($2)
3968 AC_DEFUN([CF_UPPER],
3969 [
3970 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3971 ])dnl
3972 dnl ---------------------------------------------------------------------------
3973 dnl CF_UTF8_LIB version: 10 updated: 2023/01/11 04:05:23
3974 dnl -----------
3975 dnl Check for multibyte support, and if not found, utf8 compatibility library
3976 AC_DEFUN([CF_UTF8_LIB],
3977 [
3978 AC_HAVE_HEADERS(wchar.h)
3979 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
3980         cf_save_LIBS="$LIBS"
3981         AC_TRY_LINK([
3982 $ac_includes_default
3983 #ifdef HAVE_WCHAR_H
3984 #include <wchar.h>
3985 #endif
3986 ],[putwc(0,0);],
3987         [cf_cv_utf8_lib=yes],
3988         [CF_FIND_LINKAGE([
3989 #include <libutf8.h>],[putwc(0,0);],utf8,
3990                 [cf_cv_utf8_lib=add-on],
3991                 [cf_cv_utf8_lib=no])
3992 ])])
3993
3994 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
3995 # ncurses/ncursesw:
3996 if test "$cf_cv_utf8_lib" = "add-on" ; then
3997         AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
3998         CF_ADD_INCDIR($cf_cv_header_path_utf8)
3999         CF_ADD_LIBDIR($cf_cv_library_path_utf8)
4000         CF_ADD_LIBS($cf_cv_library_file_utf8)
4001 fi
4002 ])dnl
4003 dnl ---------------------------------------------------------------------------
4004 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
4005 dnl ----------
4006 dnl Use AC_VERBOSE w/o the warnings
4007 AC_DEFUN([CF_VERBOSE],
4008 [test -n "$verbose" && echo "   $1" 1>&AC_FD_MSG
4009 CF_MSG_LOG([$1])
4010 ])dnl
4011 dnl ---------------------------------------------------------------------------
4012 dnl CF_WCHAR_TYPE version: 4 updated: 2012/10/06 16:39:58
4013 dnl -------------
4014 dnl Check if type wide-character type $1 is declared, and if so, which header
4015 dnl file is needed.  The second parameter is used to set a shell variable when
4016 dnl the type is not found.  The first parameter sets a shell variable for the
4017 dnl opposite sense.
4018 AC_DEFUN([CF_WCHAR_TYPE],
4019 [
4020 # This is needed on Tru64 5.0 to declare $1
4021 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
4022 AC_TRY_COMPILE([
4023 #include <stdlib.h>
4024 #include <stdarg.h>
4025 #include <stdio.h>
4026 #ifdef HAVE_LIBUTF8_H
4027 #include <libutf8.h>
4028 #endif],
4029         [$1 state],
4030         [cf_cv_$1=no],
4031         [AC_TRY_COMPILE([
4032 #include <stdlib.h>
4033 #include <stdarg.h>
4034 #include <stdio.h>
4035 #include <wchar.h>
4036 #ifdef HAVE_LIBUTF8_H
4037 #include <libutf8.h>
4038 #endif],
4039         [$1 value],
4040         [cf_cv_$1=yes],
4041         [cf_cv_$1=unknown])])])
4042
4043 if test "$cf_cv_$1" = yes ; then
4044         AC_DEFINE(NEED_WCHAR_H,1,[Define to 1 if we must include wchar.h])
4045         NEED_WCHAR_H=1
4046 fi
4047
4048 ifelse([$2],,,[
4049 # if we do not find $1 in either place, use substitution to provide a fallback.
4050 if test "$cf_cv_$1" = unknown ; then
4051         $2=1
4052 fi
4053 ])
4054 ifelse($3,,,[
4055 # if we find $1 in either place, use substitution to provide a fallback.
4056 if test "$cf_cv_$1" != unknown ; then
4057         $3=1
4058 fi
4059 ])
4060 ])dnl
4061 dnl ---------------------------------------------------------------------------
4062 dnl CF_WITH_CURSES_DIR version: 4 updated: 2021/01/02 19:22:58
4063 dnl ------------------
4064 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
4065 dnl libraries.
4066 AC_DEFUN([CF_WITH_CURSES_DIR],[
4067
4068 AC_MSG_CHECKING(for specific curses-directory)
4069 AC_ARG_WITH(curses-dir,
4070         [  --with-curses-dir=DIR   directory in which (n)curses is installed],
4071         [cf_cv_curses_dir=$withval],
4072         [cf_cv_curses_dir=no])
4073 AC_MSG_RESULT($cf_cv_curses_dir)
4074
4075 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
4076 then
4077         CF_PATH_SYNTAX(withval)
4078         if test -d "$cf_cv_curses_dir"
4079         then
4080                 CF_ADD_INCDIR($cf_cv_curses_dir/include)
4081                 CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
4082         fi
4083 fi
4084 ])dnl
4085 dnl ---------------------------------------------------------------------------
4086 dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
4087 dnl ----------------
4088 dnl Configure-option for dbmalloc.  The optional parameter is used to override
4089 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
4090 AC_DEFUN([CF_WITH_DBMALLOC],[
4091 CF_NO_LEAKS_OPTION(dbmalloc,
4092         [  --with-dbmalloc         test: use Conor Cahill's dbmalloc library],
4093         [USE_DBMALLOC])
4094
4095 if test "$with_dbmalloc" = yes ; then
4096         AC_CHECK_HEADER(dbmalloc.h,
4097                 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
4098 fi
4099 ])dnl
4100 dnl ---------------------------------------------------------------------------
4101 dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
4102 dnl ---------------
4103 dnl Configure-option for dmalloc.  The optional parameter is used to override
4104 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
4105 AC_DEFUN([CF_WITH_DMALLOC],[
4106 CF_NO_LEAKS_OPTION(dmalloc,
4107         [  --with-dmalloc          test: use Gray Watson's dmalloc library],
4108         [USE_DMALLOC])
4109
4110 if test "$with_dmalloc" = yes ; then
4111         AC_CHECK_HEADER(dmalloc.h,
4112                 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
4113 fi
4114 ])dnl
4115 dnl ---------------------------------------------------------------------------
4116 dnl CF_WITH_LIB_BASENAME version: 1 updated: 2020/03/07 20:05:14
4117 dnl --------------------
4118 dnl Allow for overriding the basename of a library, i.e., the part to which
4119 dnl prefixes/suffixes are attached.
4120 dnl
4121 dnl $1 = variable to set
4122 dnl $2 = option name
4123 dnl $3 = default basename for library, if omitted use $2
4124 AC_DEFUN([CF_WITH_LIB_BASENAME],
4125 [
4126 AC_MSG_CHECKING(for desired basename for $2 library)
4127 AC_ARG_WITH($2-libname,
4128         [  --with-$2-libname=XXX override ifelse($3,,$2,$3) basename of library],
4129         [with_lib_basename=$withval],
4130         [with_lib_basename=ifelse($3,,$2,$3)])
4131 $1="$with_lib_basename"
4132
4133 case "x[$]$1" in
4134 (x|xno|xnone|xyes)
4135         $1=ifelse($3,,$2,$3)
4136         ;;
4137 (*)
4138         ;;
4139 esac
4140
4141 AC_MSG_RESULT([$]$1)
4142 AC_SUBST($1)
4143 ])dnl
4144 dnl ---------------------------------------------------------------------------
4145 dnl CF_WITH_NCURSES_ETC version: 6 updated: 2023/01/16 10:10:06
4146 dnl -------------------
4147 dnl Use this macro for programs which use any variant of "curses", e.g.,
4148 dnl "ncurses", and "PDCurses".  Programs that can use curses and some unrelated
4149 dnl library (such as slang) should use a "--with-screen=XXX" option.
4150 dnl
4151 dnl This does not use AC_DEFUN, because that would tell autoconf to run each
4152 dnl of the macros inside this one - before this macro.
4153 define([CF_WITH_NCURSES_ETC],[
4154 CF_WITH_CURSES_DIR
4155
4156 cf_cv_screen=curses
4157
4158 AC_MSG_CHECKING(for specified curses library type)
4159 AC_ARG_WITH(screen,
4160         [  --with-screen=XXX       use specified curses-libraries],
4161         [cf_cv_screen=$withval],[
4162
4163 AC_ARG_WITH(ncursesw,
4164         [  --with-ncursesw         use wide ncurses-libraries],
4165         [cf_cv_screen=ncursesw],[
4166
4167 AC_ARG_WITH(ncurses,
4168         [  --with-ncurses          use ncurses-libraries],
4169         [cf_cv_screen=ncurses],[
4170
4171 AC_ARG_WITH(pdcurses,
4172         [  --with-pdcurses         compile/link with pdcurses X11 library],
4173         [cf_cv_screen=pdcurses],[
4174
4175 AC_ARG_WITH(curses-colr,
4176         [  --with-curses-colr      compile/link with HPUX 10.x color-curses],
4177         [cf_cv_screen=curses_colr],[
4178
4179 AC_ARG_WITH(curses-5lib,
4180         [  --with-curses-5lib      compile/link with SunOS 5lib curses],
4181         [cf_cv_screen=curses_5lib])])])])])])
4182
4183 AC_MSG_RESULT($cf_cv_screen)
4184
4185 case $cf_cv_screen in
4186 (curses|curses_*)
4187         CF_CURSES_CONFIG
4188         ;;
4189 (ncursesw*)
4190         CF_UTF8_LIB
4191         CF_NCURSES_CONFIG($cf_cv_screen)
4192         ;;
4193 (ncurses*)
4194         CF_NCURSES_CONFIG($cf_cv_screen)
4195         ;;
4196 (pdcurses)
4197         CF_PDCURSES_X11
4198         ;;
4199 (*)
4200         AC_MSG_ERROR(unexpected screen-value: $cf_cv_screen)
4201         ;;
4202 esac
4203
4204 CF_NCURSES_PTHREADS($cf_cv_screen)
4205 AC_SUBST(cf_cv_screen)
4206
4207 ])dnl
4208 dnl ---------------------------------------------------------------------------
4209 dnl CF_WITH_SCREEN_PDCURSES version: 1 updated: 2020/08/28 16:56:27
4210 dnl -----------------------
4211 dnl Call this macro before CF_ENABLE_WARNINGS for configure scripts which use
4212 dnl the "--with-screen=pdcurses" selection.  Doing that allows the configure
4213 dnl script to search for the X11/Xt header files to declare (or not) the
4214 dnl symbol needed to enable "const" in those header files.  If that configure
4215 dnl option is not used, then those checks are unnecessary.
4216 AC_DEFUN([CF_WITH_SCREEN_PDCURSES],[
4217 AC_PROVIDE([AC_PATH_XTRA])
4218 AC_PROVIDE([AC_PATH_X])
4219 if test -n "$with_screen" && test "x$with_screen" = "xpdcurses"
4220 then
4221         AC_PATH_X
4222         AC_PATH_XTRA
4223 fi
4224 ])dnl
4225 dnl ---------------------------------------------------------------------------
4226 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
4227 dnl ----------------
4228 AC_DEFUN([CF_WITH_VALGRIND],[
4229 CF_NO_LEAKS_OPTION(valgrind,
4230         [  --with-valgrind         test: use valgrind],
4231         [USE_VALGRIND])
4232 ])dnl
4233 dnl ---------------------------------------------------------------------------
4234 dnl CF_WITH_X11_RGB version: 2 updated: 2019/12/31 08:53:54
4235 dnl ---------------
4236 dnl Handle configure option "--with-x11-rgb", setting these shell
4237 dnl variables:
4238 dnl
4239 dnl $RGB_PATH is the option value, used for finding the X11 rgb file.
4240 dnl $no_x11_rgb is a "#" (comment) if "--without-x11-rgb" is given.
4241 dnl
4242 dnl Most Linux's use this:
4243 dnl     /usr/share/X11/rgb.txt
4244 dnl Debian uses this:
4245 dnl     /etc/X11/rgb.txt
4246 dnl DragonFlyBSD ports uses this:
4247 dnl     /usr/pkg/lib/X11/rgb.txt
4248 dnl FreeBSD ports use these:
4249 dnl     /usr/local/lib/X11/rgb.txt
4250 dnl     /usr/local/share/X11/rgb.txt
4251 dnl Mandriva has these:
4252 dnl     /usr/lib/X11/rgb.txt
4253 dnl     /usr/lib64/X11/rgb.txt
4254 dnl NetBSD has these
4255 dnl     /usr/X11R7/lib/X11/rgb.txt
4256 dnl OpenSolaris uses
4257 dnl     32-bit:
4258 dnl     /usr/X11/etc/X11/rgb.txt
4259 dnl     /usr/X11/share/X11/rgb.txt
4260 dnl     /usr/X11/lib/X11/rgb.txt
4261 dnl OSX uses
4262 dnl             /opt/local/share/X11/rgb.txt (MacPorts)
4263 dnl             /opt/X11/share/X11/rgb.txt (non-ports)
4264 dnl     64-bit:
4265 dnl     /usr/X11/etc/X11/rgb.txt
4266 dnl     /usr/X11/share/X11/rgb.txt (perhaps)
4267 dnl     /usr/X11/lib/amd64/X11/rgb.txt
4268 dnl Solaris10 uses (in this order):
4269 dnl     /usr/openwin/lib/X11/rgb.txt
4270 dnl     /usr/X11/lib/X11/rgb.txt
4271 AC_DEFUN([CF_WITH_X11_RGB],[
4272 AC_MSG_CHECKING(for X11 rgb file)
4273 AC_ARG_WITH(x11-rgb,
4274         [  --with-x11-rgb=FILE   file containing X11 rgb information (EPREFIX/lib/X11/rgb.txt)],
4275         [RGB_PATH=$withval],
4276         [RGB_PATH=auto])
4277
4278 if test "x[$]RGB_PATH" = xauto
4279 then
4280         RGB_PATH='${exec_prefix}/lib/X11/rgb.txt'
4281         for cf_path in \
4282                 /opt/local/share/X11/rgb.txt \
4283                 /opt/X11/share/X11/rgb.txt \
4284                 /usr/share/X11/rgb.txt \
4285                 /usr/X11/share/X11/rgb.txt \
4286                 /usr/X11/lib/X11/rgb.txt \
4287                 /usr/lib/X11/rgb.txt \
4288                 /etc/X11/rgb.txt \
4289                 /usr/pkg/lib/X11/rgb.txt \
4290                 /usr/X11R7/lib/X11/rgb.txt \
4291                 /usr/X11R6/lib/X11/rgb.txt \
4292                 /usr/X11R5/lib/X11/rgb.txt \
4293                 /usr/X11R4/lib/X11/rgb.txt \
4294                 /usr/local/lib/X11/rgb.txt \
4295                 /usr/local/share/X11/rgb.txt \
4296                 /usr/lib64/X11/rgb.txt
4297         do
4298                 if test -f "$cf_path" ; then
4299                         RGB_PATH="$cf_path"
4300                         break
4301                 fi
4302         done
4303 else
4304         cf_path=$RGB_PATH
4305         CF_PATH_SYNTAX(cf_path)
4306 fi
4307
4308 AC_MSG_RESULT($RGB_PATH)
4309 AC_SUBST(RGB_PATH)
4310 AC_DEFINE_UNQUOTED(RGB_PATH,"$cf_path",[Define to the full pathname of rgb.txt])
4311
4312 no_x11_rgb=
4313 if test "$RGB_PATH" = no
4314 then
4315         no_x11_rgb="#"
4316 fi
4317 AC_SUBST(no_x11_rgb)
4318 ])dnl
4319 dnl ---------------------------------------------------------------------------
4320 dnl CF_XOPEN_CURSES version: 18 updated: 2023/01/11 04:05:23
4321 dnl ---------------
4322 dnl Test if we should define X/Open source for curses, needed on Digital Unix
4323 dnl 4.x, to see the extended functions, but breaks on IRIX 6.x.
4324 dnl
4325 dnl The getbegyx() check is needed for HPUX, which omits legacy macros such
4326 dnl as getbegy().  The latter is better design, but the former is standard.
4327 AC_DEFUN([CF_XOPEN_CURSES],
4328 [
4329 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
4330 AC_CACHE_CHECK(definition to turn on extended curses functions,cf_cv_need_xopen_extension,[
4331 cf_cv_need_xopen_extension=unknown
4332 AC_TRY_LINK([
4333 $ac_includes_default
4334 #include <${cf_cv_ncurses_header:-curses.h}>],[
4335 #if defined(NCURSES_VERSION_PATCH)
4336 #if (NCURSES_VERSION_PATCH < 20100501) && (NCURSES_VERSION_PATCH >= 20100403)
4337         make an error
4338 #endif
4339 #endif
4340 #ifdef NCURSES_WIDECHAR
4341 make an error   /* prefer to fall-through on the second checks */
4342 #endif
4343         cchar_t check;
4344         int check2 = curs_set((int)sizeof(check));
4345         long x = winnstr(stdscr, "", 0);
4346         int x1, y1;
4347         (void)check2;
4348         getbegyx(stdscr, y1, x1);
4349         (void)x;
4350         (void)y1;
4351         (void)x1;
4352         ],
4353         [cf_cv_need_xopen_extension=none],
4354         [
4355         for cf_try_xopen_extension in _XOPEN_SOURCE_EXTENDED NCURSES_WIDECHAR
4356         do
4357                 AC_TRY_LINK([
4358 #define $cf_try_xopen_extension 1
4359 $ac_includes_default
4360 #include <${cf_cv_ncurses_header:-curses.h}>],[
4361                 cchar_t check;
4362                 int check2 = curs_set((int)sizeof(check));
4363                 long x = winnstr(stdscr, "", 0);
4364                 int x1, y1;
4365                 getbegyx(stdscr, y1, x1);
4366                 (void)check2;
4367                 (void)x;
4368                 (void)y1;
4369                 (void)x1;
4370                 ],
4371                 [cf_cv_need_xopen_extension=$cf_try_xopen_extension; break])
4372         done
4373         ])
4374 ])
4375
4376 case "$cf_cv_need_xopen_extension" in
4377 (*_*)
4378         CF_APPEND_TEXT(CPPFLAGS,-D$cf_cv_need_xopen_extension)
4379         ;;
4380 esac
4381
4382 ])dnl
4383 dnl ---------------------------------------------------------------------------
4384 dnl CF_XOPEN_SOURCE version: 64 updated: 2023/02/18 17:41:25
4385 dnl ---------------
4386 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
4387 dnl or adapt to the vendor's definitions to get equivalent functionality,
4388 dnl without losing the common non-POSIX features.
4389 dnl
4390 dnl Parameters:
4391 dnl     $1 is the nominal value for _XOPEN_SOURCE
4392 dnl     $2 is the nominal value for _POSIX_C_SOURCE
4393 AC_DEFUN([CF_XOPEN_SOURCE],[
4394 AC_REQUIRE([AC_CANONICAL_HOST])
4395 AC_REQUIRE([CF_POSIX_VISIBLE])
4396
4397 if test "$cf_cv_posix_visible" = no; then
4398
4399 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
4400 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
4401 cf_xopen_source=
4402
4403 case "$host_os" in
4404 (aix[[4-7]]*)
4405         cf_xopen_source="-D_ALL_SOURCE"
4406         ;;
4407 (darwin[[0-8]].*)
4408         cf_xopen_source="-D_APPLE_C_SOURCE"
4409         ;;
4410 (darwin*)
4411         cf_xopen_source="-D_DARWIN_C_SOURCE"
4412         cf_XOPEN_SOURCE=
4413         ;;
4414 (freebsd*|dragonfly*|midnightbsd*)
4415         # 5.x headers associate
4416         #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
4417         #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
4418         cf_POSIX_C_SOURCE=200112L
4419         cf_XOPEN_SOURCE=600
4420         cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
4421         ;;
4422 (hpux11*)
4423         cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
4424         ;;
4425 (hpux*)
4426         cf_xopen_source="-D_HPUX_SOURCE"
4427         ;;
4428 (irix[[56]].*)
4429         cf_xopen_source="-D_SGI_SOURCE"
4430         cf_XOPEN_SOURCE=
4431         ;;
4432 (linux*gnu|linux*gnuabi64|linux*gnuabin32|linux*gnueabi|linux*gnueabihf|linux*gnux32|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin|msys)
4433         CF_GNU_SOURCE($cf_XOPEN_SOURCE)
4434         ;;
4435 (minix*)
4436         cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
4437         ;;
4438 (mirbsd*)
4439         # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
4440         cf_XOPEN_SOURCE=
4441         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4442         ;;
4443 (netbsd*)
4444         cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
4445         ;;
4446 (openbsd[[6-9]]*)
4447         # OpenBSD 6.x has broken locale support, both compile-time and runtime.
4448         # see https://www.mail-archive.com/bugs@openbsd.org/msg13200.html
4449         # Abusing the conformance level is a workaround.
4450         AC_MSG_WARN(this system does not provide usable locale support)
4451         cf_xopen_source="-D_BSD_SOURCE"
4452         cf_XOPEN_SOURCE=700
4453         ;;
4454 (openbsd[[4-5]]*)
4455         # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
4456         cf_xopen_source="-D_BSD_SOURCE"
4457         cf_XOPEN_SOURCE=600
4458         ;;
4459 (openbsd*)
4460         # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
4461         ;;
4462 (osf[[45]]*)
4463         cf_xopen_source="-D_OSF_SOURCE"
4464         ;;
4465 (nto-qnx*)
4466         cf_xopen_source="-D_QNX_SOURCE"
4467         ;;
4468 (sco*)
4469         # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
4470         ;;
4471 (solaris2.*)
4472         cf_xopen_source="-D__EXTENSIONS__"
4473         cf_cv_xopen_source=broken
4474         ;;
4475 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
4476         cf_XOPEN_SOURCE=
4477         cf_POSIX_C_SOURCE=
4478         ;;
4479 (*)
4480         CF_TRY_XOPEN_SOURCE
4481         cf_save_xopen_cppflags="$CPPFLAGS"
4482         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4483         # Some of these niche implementations use copy/paste, double-check...
4484         if test "$cf_cv_xopen_source" != no ; then
4485                 CF_VERBOSE(checking if _POSIX_C_SOURCE inteferes)
4486                 AC_TRY_COMPILE(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY,,[
4487                         AC_MSG_WARN(_POSIX_C_SOURCE definition is not usable)
4488                         CPPFLAGS="$cf_save_xopen_cppflags"])
4489         fi
4490         ;;
4491 esac
4492
4493 if test -n "$cf_xopen_source" ; then
4494         CF_APPEND_CFLAGS($cf_xopen_source,true)
4495 fi
4496
4497 dnl In anything but the default case, we may have system-specific setting
4498 dnl which is still not guaranteed to provide all of the entrypoints that
4499 dnl _XOPEN_SOURCE would yield.
4500 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
4501         AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
4502         AC_TRY_COMPILE([#include <stdlib.h>],[
4503 #ifndef _XOPEN_SOURCE
4504 #error _XOPEN_SOURCE is not defined
4505 #endif],
4506         [cf_XOPEN_SOURCE_set=yes],
4507         [cf_XOPEN_SOURCE_set=no])
4508         AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
4509         if test "$cf_XOPEN_SOURCE_set" = yes
4510         then
4511                 AC_TRY_COMPILE([#include <stdlib.h>],[
4512 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
4513 #error (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
4514 #endif],
4515                 [cf_XOPEN_SOURCE_set_ok=yes],
4516                 [cf_XOPEN_SOURCE_set_ok=no])
4517                 if test "$cf_XOPEN_SOURCE_set_ok" = no
4518                 then
4519                         AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
4520                 fi
4521         else
4522                 CF_TRY_XOPEN_SOURCE
4523         fi
4524 fi
4525 fi # cf_cv_posix_visible
4526 ])
4527 dnl ---------------------------------------------------------------------------
4528 dnl CF_X_ATHENA version: 25 updated: 2023/01/11 04:05:23
4529 dnl -----------
4530 dnl Check for Xaw (Athena) libraries
4531 dnl
4532 dnl Sets $cf_x_athena according to the flavor of Xaw which is used.
4533 AC_DEFUN([CF_X_ATHENA],
4534 [
4535 cf_x_athena=${cf_x_athena:-Xaw}
4536
4537 AC_MSG_CHECKING(if you want to link with Xaw 3d library)
4538 withval=
4539 AC_ARG_WITH(Xaw3d,
4540         [  --with-Xaw3d            link with Xaw 3d library])
4541 if test "$withval" = yes ; then
4542         cf_x_athena=Xaw3d
4543         AC_MSG_RESULT(yes)
4544 else
4545         AC_MSG_RESULT(no)
4546 fi
4547
4548 AC_MSG_CHECKING(if you want to link with Xaw 3d xft library)
4549 withval=
4550 AC_ARG_WITH(Xaw3dxft,
4551         [  --with-Xaw3dxft         link with Xaw 3d xft library])
4552 if test "$withval" = yes ; then
4553         cf_x_athena=Xaw3dxft
4554         AC_MSG_RESULT(yes)
4555 else
4556         AC_MSG_RESULT(no)
4557 fi
4558
4559 AC_MSG_CHECKING(if you want to link with neXT Athena library)
4560 withval=
4561 AC_ARG_WITH(neXtaw,
4562         [  --with-neXtaw           link with neXT Athena library])
4563 if test "$withval" = yes ; then
4564         cf_x_athena=neXtaw
4565         AC_MSG_RESULT(yes)
4566 else
4567         AC_MSG_RESULT(no)
4568 fi
4569
4570 AC_MSG_CHECKING(if you want to link with Athena-Plus library)
4571 withval=
4572 AC_ARG_WITH(XawPlus,
4573         [  --with-XawPlus          link with Athena-Plus library])
4574 if test "$withval" = yes ; then
4575         cf_x_athena=XawPlus
4576         AC_MSG_RESULT(yes)
4577 else
4578         AC_MSG_RESULT(no)
4579 fi
4580
4581 cf_x_athena_lib=""
4582
4583 if test "$PKG_CONFIG" != none ; then
4584         cf_athena_list=
4585         test "$cf_x_athena" = Xaw && cf_athena_list="xaw8 xaw7 xaw6"
4586         for cf_athena_pkg in \
4587                 $cf_athena_list \
4588                 ${cf_x_athena} \
4589                 ${cf_x_athena}-devel \
4590                 lib${cf_x_athena} \
4591                 lib${cf_x_athena}-devel
4592         do
4593                 CF_TRY_PKG_CONFIG($cf_athena_pkg,[
4594                         cf_x_athena_lib="$cf_pkgconfig_libs"
4595                         CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
4596                         AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
4597
4598                         CF_TRIM_X_LIBS
4599
4600 AC_CACHE_CHECK(for usable $cf_x_athena/Xmu package,cf_cv_xaw_compat,[
4601 AC_TRY_LINK([
4602 $ac_includes_default
4603 #include <X11/Xmu/CharSet.h>
4604 ],[
4605 int check = XmuCompareISOLatin1("big", "small");
4606 (void)check;
4607 ],[cf_cv_xaw_compat=yes],[cf_cv_xaw_compat=no])])
4608
4609                         if test "$cf_cv_xaw_compat" = no
4610                         then
4611                                 # workaround for broken ".pc" files...
4612                                 case "$cf_x_athena_lib" in
4613                                 (*-lXmu*)
4614                                         ;;
4615                                 (*)
4616                                         CF_VERBOSE(work around broken package)
4617                                         cf_save_xmu="$LIBS"
4618                                         cf_first_lib=`echo "$cf_save_xmu" | sed -e 's/^[ ][ ]*//' -e 's/ .*//'`
4619                                         CF_TRY_PKG_CONFIG(xmu,[
4620                                                         LIBS="$cf_save_xmu"
4621                                                         CF_ADD_LIB_AFTER($cf_first_lib,$cf_pkgconfig_libs)
4622                                                 ],[
4623                                                         CF_ADD_LIB_AFTER($cf_first_lib,-lXmu)
4624                                                 ])
4625                                         CF_TRIM_X_LIBS
4626                                         ;;
4627                                 esac
4628                         fi
4629
4630                         break])
4631         done
4632 fi
4633
4634 if test -z "$cf_x_athena_lib" ; then
4635         CF_X_EXT
4636         CF_X_TOOLKIT
4637         CF_X_ATHENA_CPPFLAGS($cf_x_athena)
4638         CF_X_ATHENA_LIBS($cf_x_athena)
4639 fi
4640 ])dnl
4641 dnl ---------------------------------------------------------------------------
4642 dnl CF_X_ATHENA_CPPFLAGS version: 9 updated: 2020/12/31 10:54:15
4643 dnl --------------------
4644 dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
4645 dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
4646 AC_DEFUN([CF_X_ATHENA_CPPFLAGS],
4647 [
4648 AC_REQUIRE([AC_PATH_XTRA])
4649 cf_x_athena_root=ifelse([$1],,Xaw,[$1])
4650 cf_x_athena_inc=""
4651
4652 for cf_path in default \
4653         /usr/contrib/X11R6 \
4654         /usr/contrib/X11R5 \
4655         /usr/lib/X11R5 \
4656         /usr/local
4657 do
4658         if test -z "$cf_x_athena_inc" ; then
4659                 CF_SAVE_XTRA_FLAGS([CF_X_ATHENA_CPPFLAGS])
4660                 cf_test=X11/$cf_x_athena_root/SimpleMenu.h
4661                 if test "$cf_path" != default ; then
4662                         CF_APPEND_TEXT(CPPFLAGS,-I$cf_path/include)
4663                         AC_MSG_CHECKING(for $cf_test in $cf_path)
4664                 else
4665                         AC_MSG_CHECKING(for $cf_test)
4666                 fi
4667                 AC_TRY_COMPILE([
4668 #include <X11/Intrinsic.h>
4669 #include <$cf_test>],[],
4670                         [cf_result=yes],
4671                         [cf_result=no])
4672                 AC_MSG_RESULT($cf_result)
4673                 CF_RESTORE_XTRA_FLAGS([CF_X_ATHENA_CPPFLAGS])
4674                 if test "$cf_result" = yes ; then
4675                         test "$cf_path"  = default && cf_x_athena_inc=default
4676                         test "$cf_path" != default && cf_x_athena_inc="$cf_path/include"
4677                         break
4678                 fi
4679         fi
4680 done
4681
4682 if test -z "$cf_x_athena_inc" ; then
4683         AC_MSG_WARN([Unable to find Athena header files])
4684 elif test "$cf_x_athena_inc" != default ; then
4685         CF_APPEND_TEXT(CPPFLAGS,-I$cf_x_athena_inc)
4686 fi
4687 ])
4688 dnl ---------------------------------------------------------------------------
4689 dnl CF_X_ATHENA_LIBS version: 14 updated: 2023/01/11 04:05:23
4690 dnl ----------------
4691 dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
4692 dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
4693 AC_DEFUN([CF_X_ATHENA_LIBS],
4694 [AC_REQUIRE([CF_X_TOOLKIT])
4695 cf_x_athena_root=ifelse([$1],,Xaw,[$1])
4696 cf_x_athena_lib=""
4697
4698 for cf_path in default \
4699         /usr/contrib/X11R6 \
4700         /usr/contrib/X11R5 \
4701         /usr/lib/X11R5 \
4702         /usr/local
4703 do
4704         for cf_lib in \
4705                 ${cf_x_athena_root} \
4706                 ${cf_x_athena_root}7 \
4707                 ${cf_x_athena_root}6
4708         do
4709         for cf_libs in \
4710                 "-l$cf_lib -lXmu" \
4711                 "-l$cf_lib -lXpm -lXmu" \
4712                 "-l${cf_lib}_s -lXmu_s"
4713         do
4714                 test -n "$cf_x_athena_lib" && break
4715
4716                 CF_SAVE_XTRA_FLAGS([CF_X_ATHENA_LIBS])
4717                 cf_test=XawSimpleMenuAddGlobalActions
4718                 test "$cf_path" != default && cf_libs="-L$cf_path/lib $cf_libs"
4719                 CF_ADD_LIBS($cf_libs)
4720                 AC_MSG_CHECKING(for $cf_test in $cf_libs)
4721                 AC_TRY_LINK([
4722 $ac_includes_default
4723 #include <X11/Intrinsic.h>
4724 #include <X11/$cf_x_athena_root/SimpleMenu.h>
4725 ],[
4726 $cf_test((XtAppContext) 0)],
4727                         [cf_result=yes],
4728                         [cf_result=no])
4729                 AC_MSG_RESULT($cf_result)
4730                 CF_RESTORE_XTRA_FLAGS([CF_X_ATHENA_LIBS])
4731
4732                 if test "$cf_result" = yes ; then
4733                         cf_x_athena_lib="$cf_libs"
4734                         break
4735                 fi
4736         done # cf_libs
4737                 test -n "$cf_x_athena_lib" && break
4738         done # cf_lib
4739 done
4740
4741 if test -z "$cf_x_athena_lib" ; then
4742         AC_MSG_ERROR(
4743 [Unable to successfully link Athena library (-l$cf_x_athena_root) with test program])
4744 fi
4745
4746 CF_ADD_LIBS($cf_x_athena_lib)
4747 CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
4748 AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
4749 ])
4750 dnl ---------------------------------------------------------------------------
4751 dnl CF_X_EXT version: 3 updated: 2010/06/02 05:03:05
4752 dnl --------
4753 AC_DEFUN([CF_X_EXT],[
4754 CF_TRY_PKG_CONFIG(Xext,,[
4755         AC_CHECK_LIB(Xext,XextCreateExtension,
4756                 [CF_ADD_LIB(Xext)])])
4757 ])dnl
4758 dnl ---------------------------------------------------------------------------
4759 dnl CF_X_TOOLKIT version: 27 updated: 2023/01/11 04:05:23
4760 dnl ------------
4761 dnl Check for X Toolkit libraries
4762 AC_DEFUN([CF_X_TOOLKIT],
4763 [
4764 AC_REQUIRE([AC_PATH_XTRA])
4765 AC_REQUIRE([CF_CHECK_CACHE])
4766
4767 # OSX is schizoid about who owns /usr/X11 (old) versus /opt/X11 (new) (and
4768 # in some cases has installed dummy files in the former, other cases replaced
4769 # it with a link to the new location).  This complicates the configure script.
4770 # Check for that pitfall, and recover using pkg-config
4771 #
4772 # If none of these are set, the configuration is almost certainly broken.
4773 if test -z "${X_CFLAGS}${X_PRE_LIBS}${X_LIBS}${X_EXTRA_LIBS}"
4774 then
4775         CF_TRY_PKG_CONFIG(x11,,[AC_MSG_WARN(unable to find X11 library)])
4776         CF_TRY_PKG_CONFIG(ice,,[AC_MSG_WARN(unable to find ICE library)])
4777         CF_TRY_PKG_CONFIG(sm,,[AC_MSG_WARN(unable to find SM library)])
4778         CF_TRY_PKG_CONFIG(xt,,[AC_MSG_WARN(unable to find Xt library)])
4779 else
4780         LIBS="$X_PRE_LIBS $LIBS $X_EXTRA_LIBS"
4781 fi
4782
4783 cf_have_X_LIBS=no
4784
4785 CF_TRY_PKG_CONFIG(xt,[
4786
4787         case "x$LIBS" in
4788         (*-lX11*)
4789                 ;;
4790         (*)
4791 # we have an "xt" package, but it may omit Xt's dependency on X11
4792 AC_CACHE_CHECK(for usable X dependency,cf_cv_xt_x11_compat,[
4793 AC_TRY_LINK([
4794 $ac_includes_default
4795 #include <X11/Xlib.h>
4796 ],[
4797         int rc1 = XDrawLine((Display*) 0, (Drawable) 0, (GC) 0, 0, 0, 0, 0);
4798         int rc2 = XClearWindow((Display*) 0, (Window) 0);
4799         int rc3 = XMoveWindow((Display*) 0, (Window) 0, 0, 0);
4800         int rc4 = XMoveResizeWindow((Display*)0, (Window)0, 0, 0, 0, 0);
4801 ],[cf_cv_xt_x11_compat=yes],[cf_cv_xt_x11_compat=no])])
4802                 if test "$cf_cv_xt_x11_compat" = no
4803                 then
4804                         CF_VERBOSE(work around broken X11 dependency)
4805                         # 2010/11/19 - good enough until a working Xt on Xcb is delivered.
4806                         CF_TRY_PKG_CONFIG(x11,,[CF_ADD_LIB_AFTER(-lXt,-lX11)])
4807                 fi
4808                 ;;
4809         esac
4810
4811 AC_CACHE_CHECK(for usable X Toolkit package,cf_cv_xt_ice_compat,[
4812 AC_TRY_LINK([
4813 $ac_includes_default
4814 #include <X11/Shell.h>
4815 ],[int num = IceConnectionNumber(0); (void) num
4816 ],[cf_cv_xt_ice_compat=yes],[cf_cv_xt_ice_compat=no])])
4817
4818         if test "$cf_cv_xt_ice_compat" = no
4819         then
4820                 # workaround for broken ".pc" files used for X Toolkit.
4821                 case "x$X_PRE_LIBS" in
4822                 (*-lICE*)
4823                         case "x$LIBS" in
4824                         (*-lICE*)
4825                                 ;;
4826                         (*)
4827                                 CF_VERBOSE(work around broken ICE dependency)
4828                                 CF_TRY_PKG_CONFIG(ice,
4829                                         [CF_TRY_PKG_CONFIG(sm)],
4830                                         [CF_ADD_LIB_AFTER(-lXt,$X_PRE_LIBS)])
4831                                 ;;
4832                         esac
4833                         ;;
4834                 esac
4835         fi
4836
4837         cf_have_X_LIBS=yes
4838 ],[
4839
4840         LDFLAGS="$X_LIBS $LDFLAGS"
4841         CF_CHECK_CFLAGS($X_CFLAGS)
4842
4843         AC_CHECK_FUNC(XOpenDisplay,,[
4844         AC_CHECK_LIB(X11,XOpenDisplay,
4845                 [CF_ADD_LIB(X11)])])
4846
4847         AC_CHECK_FUNC(XtAppInitialize,,[
4848         AC_CHECK_LIB(Xt, XtAppInitialize,
4849                 [AC_DEFINE(HAVE_LIBXT,1,[Define to 1 if we can compile with the Xt library])
4850                  cf_have_X_LIBS=Xt
4851                  LIBS="-lXt $LIBS"])])
4852 ])
4853
4854 if test "$cf_have_X_LIBS" = no ; then
4855         AC_MSG_WARN(
4856 [Unable to successfully link X Toolkit library (-lXt) with
4857 test program.  You will have to check and add the proper libraries by hand
4858 to makefile.])
4859 fi
4860 ])dnl
4861 dnl ---------------------------------------------------------------------------
4862 dnl CF__CURSES_DATA version: 3 updated: 2021/01/04 19:45:09
4863 dnl ---------------
4864 dnl Attempt to make a copy of a curses data item.  This is needed in the
4865 dnl check-data configure tests when using ncurses, because the symbol may be
4866 dnl actually a function return-value.  That could happen if the linker is
4867 dnl broken (does not resolve data-only references), or if ncurses is configured
4868 dnl to support re-entrant code.
4869 dnl $1 = target
4870 dnl $2 = source
4871 define([CF__CURSES_DATA],[
4872 #if defined($2) && ((defined(NCURSES_WRAPPED_VAR) && (NCURSES_VERSION_PATCH < 20200208)) || defined(NCURSES_BROKEN_LINKER) || defined(NCURSES_REENTRANT))
4873         const void *$1 = (const void *)($2);
4874 #else
4875         const void *$1 = &($2);
4876 #endif
4877         fprintf(stderr, "testing linkage of $2:%p\\n", (const void *)$1);
4878 ])dnl
4879 dnl ---------------------------------------------------------------------------
4880 dnl CF__CURSES_HEAD version: 2 updated: 2010/10/23 15:54:49
4881 dnl ---------------
4882 dnl Define a reusable chunk which includes <curses.h> and <term.h> when they
4883 dnl are both available.
4884 define([CF__CURSES_HEAD],[
4885 #ifdef HAVE_XCURSES
4886 #include <xcurses.h>
4887 char * XCursesProgramName = "test";
4888 #else
4889 #include <${cf_cv_ncurses_header:-curses.h}>
4890 #if defined(NCURSES_VERSION) && defined(HAVE_NCURSESW_TERM_H)
4891 #include <ncursesw/term.h>
4892 #elif defined(NCURSES_VERSION) && defined(HAVE_NCURSES_TERM_H)
4893 #include <ncurses/term.h>
4894 #elif defined(HAVE_TERM_H)
4895 #include <term.h>
4896 #endif
4897 #endif
4898 ])
4899 dnl ---------------------------------------------------------------------------
4900 dnl CF__XOPEN_SOURCE_BODY version: 2 updated: 2023/02/18 17:41:25
4901 dnl ---------------------
4902 dnl body of test when test-compiling for _XOPEN_SOURCE check
4903 define([CF__XOPEN_SOURCE_BODY],
4904 [
4905 #ifndef _XOPEN_SOURCE
4906 #error _XOPEN_SOURCE is not defined
4907 #endif
4908 ])
4909 dnl ---------------------------------------------------------------------------
4910 dnl CF__XOPEN_SOURCE_HEAD version: 2 updated: 2023/02/18 17:41:25
4911 dnl ---------------------
4912 dnl headers to include when test-compiling for _XOPEN_SOURCE check
4913 define([CF__XOPEN_SOURCE_HEAD],
4914 [
4915 $ac_includes_default
4916 ])