Ada95/aclocal.m4

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