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