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