Ada95/aclocal.m4

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