Ada95/aclocal.m4

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