Ada95/aclocal.m4

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