test/aclocal.m4

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