Ada95/aclocal.m4

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