Ada95/aclocal.m4

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