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&n