Ada95/aclocal.m4

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