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