aclocal.m4

   1 dnl***************************************************************************
   2 dnl Copyright (c) 1998-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 1995-on
  30 dnl
  31 dnl $Id: aclocal.m4,v 1.748 2015/05/02 21:22:41 tom Exp $
  32 dnl Macros used in NCURSES 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 AM_LANGINFO_CODESET version: 4 updated: 2015/04/18 08:56:57
  43 dnl -------------------
  44 dnl Inserted as requested by gettext 0.10.40
  45 dnl File from /usr/share/aclocal
  46 dnl codeset.m4
  47 dnl ====================
  48 dnl serial AM1
  49 dnl
  50 dnl From Bruno Haible.
  51 AC_DEFUN([AM_LANGINFO_CODESET],
  52 [
  53 AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset,
  54         [AC_TRY_LINK([#include <langinfo.h>],
  55         [char* cs = nl_langinfo(CODESET);],
  56         am_cv_langinfo_codeset=yes,
  57         am_cv_langinfo_codeset=no)
  58         ])
  59         if test $am_cv_langinfo_codeset = yes; then
  60                 AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
  61                 [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
  62         fi
  63 ])dnl
  64 dnl ---------------------------------------------------------------------------
  65 dnl CF_ABI_DEFAULTS version: 1 updated: 2015/05/02 17:21:13
  66 dnl ---------------
  67 dnl Provide configure-script defaults for different ncurses ABIs.
  68 AC_DEFUN([CF_ABI_DEFAULTS],[
  69 AC_REQUIRE([CF_WITH_ABI_VERSION])
  70 case x$cf_cv_abi_version in
  71 (x6)
  72         cf_dft_ext_colors=yes
  73         cf_dft_ext_const=yes
  74         cf_dft_ext_mouse=yes
  75         cf_dft_ext_putwin=yes
  76         cf_dft_ext_spfuncs=yes
  77         cf_dft_chtype=uint32_t
  78         cf_dft_mmask_t=uint32_t
  79         cf_dft_interop=yes
  80         cf_dft_tparm_arg=intptr_t
  81         ;;
  82 (*)
  83         cf_dft_ext_colors=no
  84         cf_dft_ext_const=no
  85         cf_dft_ext_mouse=no
  86         cf_dft_ext_putwin=no
  87         cf_dft_ext_spfuncs=no
  88         cf_dft_chtype=auto
  89         cf_dft_mmask_t=auto
  90         cf_dft_interop=no
  91         cf_dft_tparm_arg=long
  92         ;;
  93 esac
  94 ])dnl
  95 dnl ---------------------------------------------------------------------------
  96 dnl CF_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49
  97 dnl ------------------
  98 dnl Conditionally generate script according to whether we're using a given autoconf.
  99 dnl
 100 dnl $1 = version to compare against
 101 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
 102 dnl $3 = code to use if AC_ACVERSION is older than $1.
 103 define([CF_ACVERSION_CHECK],
 104 [
 105 ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
 106 ifdef([m4_version_compare],
 107 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
 108 [CF_ACVERSION_COMPARE(
 109 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
 110 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
 111 dnl ---------------------------------------------------------------------------
 112 dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
 113 dnl --------------------
 114 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
 115 dnl                      MAJOR2, MINOR2, TERNARY2,
 116 dnl                      PRINTABLE2, not FOUND, FOUND)
 117 define([CF_ACVERSION_COMPARE],
 118 [ifelse(builtin([eval], [$2 < $5]), 1,
 119 [ifelse([$8], , ,[$8])],
 120 [ifelse([$9], , ,[$9])])])dnl
 121 dnl ---------------------------------------------------------------------------
 122 dnl CF_ADA_INCLUDE_DIRS version: 8 updated: 2013/10/14 04:24:07
 123 dnl -------------------
 124 dnl Construct the list of include-options for the C programs in the Ada95
 125 dnl binding.
 126 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
 127 [
 128 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
 129 if test "$srcdir" != "."; then
 130         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
 131 fi
 132 if test "$GCC" != yes; then
 133         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 134 elif test "$includedir" != "/usr/include"; then
 135         if test "$includedir" = '${prefix}/include' ; then
 136                 if test x$prefix != x/usr ; then
 137                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 138                 fi
 139         else
 140                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 141         fi
 142 fi
 143 AC_SUBST(ACPPFLAGS)
 144 ])dnl
 145 dnl ---------------------------------------------------------------------------
 146 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
 147 dnl ---------------
 148 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
 149 AC_DEFUN([CF_ADD_ADAFLAGS],[
 150         ADAFLAGS="$ADAFLAGS $1"
 151         AC_SUBST(ADAFLAGS)
 152 ])dnl
 153 dnl ---------------------------------------------------------------------------
 154 dnl CF_ADD_CFLAGS version: 12 updated: 2015/04/12 15:39:00
 155 dnl -------------
 156 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
 157 dnl The second parameter if given makes this macro verbose.
 158 dnl
 159 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
 160 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
 161 dnl confused by the quotes (which require backslashes to keep them usable).
 162 AC_DEFUN([CF_ADD_CFLAGS],
 163 [
 164 cf_fix_cppflags=no
 165 cf_new_cflags=
 166 cf_new_cppflags=
 167 cf_new_extra_cppflags=
 168
 169 for cf_add_cflags in $1
 170 do
 171 case $cf_fix_cppflags in
 172 (no)
 173         case $cf_add_cflags in
 174         (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
 175                 case $cf_add_cflags in
 176                 (-D*)
 177                         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
 178
 179                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
 180                                 && test -z "${cf_tst_cflags}" \
 181                                 && cf_fix_cppflags=yes
 182
 183                         if test $cf_fix_cppflags = yes ; then
 184                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 185                                 continue
 186                         elif test "${cf_tst_cflags}" = "\"'" ; then
 187                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 188                                 continue
 189                         fi
 190                         ;;
 191                 esac
 192                 case "$CPPFLAGS" in
 193                 (*$cf_add_cflags)
 194                         ;;
 195                 (*)
 196                         case $cf_add_cflags in
 197                         (-D*)
 198                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
 199                                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
 200                                 ;;
 201                         esac
 202                         cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
 203                         ;;
 204                 esac
 205                 ;;
 206         (*)
 207                 cf_new_cflags="$cf_new_cflags $cf_add_cflags"
 208                 ;;
 209         esac
 210         ;;
 211 (yes)
 212         cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 213
 214         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
 215
 216         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
 217                 && test -z "${cf_tst_cflags}" \
 218                 && cf_fix_cppflags=no
 219         ;;
 220 esac
 221 done
 222
 223 if test -n "$cf_new_cflags" ; then
 224         ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
 225         CFLAGS="$CFLAGS $cf_new_cflags"
 226 fi
 227
 228 if test -n "$cf_new_cppflags" ; then
 229         ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
 230         CPPFLAGS="$CPPFLAGS $cf_new_cppflags"
 231 fi
 232
 233 if test -n "$cf_new_extra_cppflags" ; then
 234         ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
 235         EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
 236 fi
 237
 238 AC_SUBST(EXTRA_CPPFLAGS)
 239
 240 ])dnl
 241 dnl ---------------------------------------------------------------------------
 242 dnl CF_ADD_INCDIR version: 13 updated: 2010/05/26 16:44:57
 243 dnl -------------
 244 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it's
 245 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
 246 dnl but old versions (and some misinstalled ones) need that.  To make things
 247 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
 248 dnl the include-path).
 249 AC_DEFUN([CF_ADD_INCDIR],
 250 [
 251 if test -n "$1" ; then
 252   for cf_add_incdir in $1
 253   do
 254         while test $cf_add_incdir != /usr/include
 255         do
 256           if test -d $cf_add_incdir
 257           then
 258                 cf_have_incdir=no
 259                 if test -n "$CFLAGS$CPPFLAGS" ; then
 260                   # a loop is needed to ensure we can add subdirs of existing dirs
 261                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
 262                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
 263                           cf_have_incdir=yes; break
 264                         fi
 265                   done
 266                 fi
 267
 268                 if test "$cf_have_incdir" = no ; then
 269                   if test "$cf_add_incdir" = /usr/local/include ; then
 270                         if test "$GCC" = yes
 271                         then
 272                           cf_save_CPPFLAGS=$CPPFLAGS
 273                           CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
 274                           AC_TRY_COMPILE([#include <stdio.h>],
 275                                   [printf("Hello")],
 276                                   [],
 277                                   [cf_have_incdir=yes])
 278                           CPPFLAGS=$cf_save_CPPFLAGS
 279                         fi
 280                   fi
 281                 fi
 282
 283                 if test "$cf_have_incdir" = no ; then
 284                   CF_VERBOSE(adding $cf_add_incdir to include-path)
 285                   ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
 286
 287                   cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
 288                   test "$cf_top_incdir" = "$cf_add_incdir" && break
 289                   cf_add_incdir="$cf_top_incdir"
 290                 else
 291                   break
 292                 fi
 293           fi
 294         done
 295   done
 296 fi
 297 ])dnl
 298 dnl ---------------------------------------------------------------------------
 299 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
 300 dnl ----------
 301 dnl Add a library, used to enforce consistency.
 302 dnl
 303 dnl $1 = library to add, without the "-l"
 304 dnl $2 = variable to update (default $LIBS)
 305 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
 306 dnl ---------------------------------------------------------------------------
 307 dnl CF_ADD_LIBDIR version: 10 updated: 2015/04/18 08:56:57
 308 dnl -------------
 309 dnl     Adds to the library-path
 310 dnl
 311 dnl     Some machines have trouble with multiple -L options.
 312 dnl
 313 dnl $1 is the (list of) directory(s) to add
 314 dnl $2 is the optional name of the variable to update (default LDFLAGS)
 315 dnl
 316 AC_DEFUN([CF_ADD_LIBDIR],
 317 [
 318 if test -n "$1" ; then
 319         for cf_add_libdir in $1
 320         do
 321                 if test $cf_add_libdir = /usr/lib ; then
 322                         :
 323                 elif test -d $cf_add_libdir
 324                 then
 325                         cf_have_libdir=no
 326                         if test -n "$LDFLAGS$LIBS" ; then
 327                                 # a loop is needed to ensure we can add subdirs of existing dirs
 328                                 for cf_test_libdir in $LDFLAGS $LIBS ; do
 329                                         if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
 330                                                 cf_have_libdir=yes; break
 331                                         fi
 332                                 done
 333                         fi
 334                         if test "$cf_have_libdir" = no ; then
 335                                 CF_VERBOSE(adding $cf_add_libdir to library-path)
 336                                 ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
 337                         fi
 338                 fi
 339         done
 340 fi
 341 ])dnl
 342 dnl ---------------------------------------------------------------------------
 343 dnl CF_ADD_LIBS version: 2 updated: 2014/07/13 14:33:27
 344 dnl -----------
 345 dnl Add one or more libraries, used to enforce consistency.  Libraries are
 346 dnl prepended to an existing list, since their dependencies are assumed to
 347 dnl already exist in the list.
 348 dnl
 349 dnl $1 = libraries to add, with the "-l", etc.
 350 dnl $2 = variable to update (default $LIBS)
 351 AC_DEFUN([CF_ADD_LIBS],[
 352 cf_add_libs="$1"
 353 # Filter out duplicates - this happens with badly-designed ".pc" files...
 354 for cf_add_1lib in [$]ifelse($2,,LIBS,[$2])
 355 do
 356         for cf_add_2lib in $cf_add_libs
 357         do
 358                 if test "x$cf_add_1lib" = "x$cf_add_2lib"
 359                 then
 360                         cf_add_1lib=
 361                         break
 362                 fi
 363         done
 364         test -n "$cf_add_1lib" && cf_add_libs="$cf_add_libs $cf_add_1lib"
 365 done
 366 ifelse($2,,LIBS,[$2])="$cf_add_libs"
 367 ])dnl
 368 dnl ---------------------------------------------------------------------------
 369 dnl CF_ADD_SUBDIR_PATH version: 4 updated: 2013/10/08 17:47:05
 370 dnl ------------------
 371 dnl Append to a search-list for a nonstandard header/lib-file
 372 dnl     $1 = the variable to return as result
 373 dnl     $2 = the package name
 374 dnl     $3 = the subdirectory, e.g., bin, include or lib
 375 dnl $4 = the directory under which we will test for subdirectories
 376 dnl $5 = a directory that we do not want $4 to match
 377 AC_DEFUN([CF_ADD_SUBDIR_PATH],
 378 [
 379 test "x$4" != "x$5" && \
 380 test -d "$4" && \
 381 ifelse([$5],NONE,,[(test -z "$5" || test x$5 = xNONE || test "x$4" != "x$5") &&]) {
 382         test -n "$verbose" && echo "    ... testing for $3-directories under $4"
 383         test -d $4/$3 &&          $1="[$]$1 $4/$3"
 384         test -d $4/$3/$2 &&       $1="[$]$1 $4/$3/$2"
 385         test -d $4/$3/$2/$3 &&    $1="[$]$1 $4/$3/$2/$3"
 386         test -d $4/$2/$3 &&       $1="[$]$1 $4/$2/$3"
 387         test -d $4/$2/$3/$2 &&    $1="[$]$1 $4/$2/$3/$2"
 388 }
 389 ])dnl
 390 dnl ---------------------------------------------------------------------------
 391 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
 392 dnl --------------
 393 dnl Allow user to disable a normally-on option.
 394 AC_DEFUN([CF_ARG_DISABLE],
 395 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
 396 dnl ---------------------------------------------------------------------------
 397 dnl CF_ARG_OPTION version: 4 updated: 2010/05/26 05:38:42
 398 dnl -------------
 399 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
 400 dnl values.
 401 dnl
 402 dnl Parameters:
 403 dnl $1 = option name
 404 dnl $2 = help-string
 405 dnl $3 = action to perform if option is not default
 406 dnl $4 = action if perform if option is default
 407 dnl $5 = default option value (either 'yes' or 'no')
 408 AC_DEFUN([CF_ARG_OPTION],
 409 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
 410   if test "$enableval" != "$5" ; then
 411 ifelse([$3],,[    :]dnl
 412 ,[    $3]) ifelse([$4],,,[
 413   else
 414     $4])
 415   fi],[enableval=$5 ifelse([$4],,,[
 416   $4
 417 ])dnl
 418   ])])dnl
 419 dnl ---------------------------------------------------------------------------
 420 dnl CF_AR_FLAGS version: 5 updated: 2010/05/20 20:24:29
 421 dnl -----------
 422 dnl Check for suitable "ar" (archiver) options for updating an archive.
 423 AC_DEFUN([CF_AR_FLAGS],[
 424 AC_REQUIRE([CF_PROG_AR])
 425
 426 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
 427         cf_cv_ar_flags=unknown
 428         for cf_ar_flags in -curv curv -crv crv -cqv cqv -rv rv
 429         do
 430
 431                 # check if $ARFLAGS already contains this choice
 432                 if test "x$ARFLAGS" != "x" ; then
 433                         cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
 434                         if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
 435                                 cf_cv_ar_flags=
 436                                 break
 437                         fi
 438                 fi
 439
 440                 rm -f conftest.$ac_cv_objext
 441                 rm -f conftest.a
 442
 443                 cat >conftest.$ac_ext <<EOF
 444 #line __oline__ "configure"
 445 int     testdata[[3]] = { 123, 456, 789 };
 446 EOF
 447                 if AC_TRY_EVAL(ac_compile) ; then
 448                         echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
 449                         $AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null
 450                         if test -f conftest.a ; then
 451                                 cf_cv_ar_flags=$cf_ar_flags
 452                                 break
 453                         fi
 454                 else
 455                         CF_VERBOSE(cannot compile test-program)
 456                         break
 457                 fi
 458         done
 459         rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
 460 ])
 461
 462 if test -n "$ARFLAGS" ; then
 463         if test -n "$cf_cv_ar_flags" ; then
 464                 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
 465         fi
 466 else
 467         ARFLAGS=$cf_cv_ar_flags
 468 fi
 469
 470 AC_SUBST(ARFLAGS)
 471 ])
 472 dnl ---------------------------------------------------------------------------
 473 dnl CF_AWK_BIG_PRINTF version: 5 updated: 2015/04/17 21:13:04
 474 dnl -----------------
 475 dnl Check if awk can handle big strings using printf.  Some older versions of
 476 dnl awk choke on large strings passed via "%s".
 477 dnl
 478 dnl $1 = desired string size
 479 dnl $2 = variable to set with result
 480 AC_DEFUN([CF_AWK_BIG_PRINTF],
 481 [
 482         case x$AWK in
 483         (x)
 484                 eval $2=no
 485                 ;;
 486         (*)
 487                 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' 2>/dev/null \
 488                         | $AWK '{ printf "%d\n", length([$]0); }' 2>/dev/null | $AWK 'BEGIN { eqls=0; recs=0; } { recs++; if ([$]0 == 12000) eqls++; } END { if (recs != 1 || eqls != 1) exit 1; }' 2>/dev/null >/dev/null ) ; then
 489                         eval $2=yes
 490                 else
 491                         eval $2=no
 492                 fi
 493                 ;;
 494         esac
 495 ])dnl
 496 dnl ---------------------------------------------------------------------------
 497 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
 498 dnl ------------
 499 dnl Test if 'bool' is a builtin type in the configured C++ compiler.  Some
 500 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
 501 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
 502 dnl
 503 dnl Treat the configuration-variable specially here, since we're directly
 504 dnl substituting its value (i.e., 1/0).
 505 dnl
 506 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
 507 AC_DEFUN([CF_BOOL_DECL],
 508 [
 509 AC_MSG_CHECKING(if we should include stdbool.h)
 510
 511 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
 512         AC_TRY_COMPILE([],[bool foo = false],
 513                 [cf_cv_header_stdbool_h=0],
 514                 [AC_TRY_COMPILE([
 515 #ifndef __BEOS__
 516 #include <stdbool.h>
 517 #endif
 518 ],[bool foo = false],
 519                         [cf_cv_header_stdbool_h=1],
 520                         [cf_cv_header_stdbool_h=0])])])
 521
 522 if test "$cf_cv_header_stdbool_h" = 1
 523 then    AC_MSG_RESULT(yes)
 524 else    AC_MSG_RESULT(no)
 525 fi
 526
 527 AC_MSG_CHECKING([for builtin bool type])
 528
 529 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
 530         AC_TRY_COMPILE([
 531 #include <stdio.h>
 532 #include <sys/types.h>
 533 ],[bool x = false],
 534                 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
 535                 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
 536         ])
 537
 538 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
 539 then    AC_MSG_RESULT(yes)
 540 else    AC_MSG_RESULT(no)
 541 fi
 542 ])dnl
 543 dnl ---------------------------------------------------------------------------
 544 dnl CF_BOOL_SIZE version: 14 updated: 2015/04/17 21:13:04
 545 dnl ------------
 546 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
 547 dnl Don't bother looking for bool.h, since it's been deprecated.
 548 dnl
 549 dnl If the current compiler is C rather than C++, we get the bool definition
 550 dnl from <stdbool.h>.
 551 AC_DEFUN([CF_BOOL_SIZE],
 552 [
 553 AC_MSG_CHECKING([for size of bool])
 554 AC_CACHE_VAL(cf_cv_type_of_bool,[
 555         rm -f cf_test.out
 556         AC_TRY_RUN([
 557 #include <stdlib.h>
 558 #include <stdio.h>
 559
 560 #if defined(__cplusplus)
 561
 562 #ifdef HAVE_GXX_BUILTIN_H
 563 #include <g++/builtin.h>
 564 #elif HAVE_GPP_BUILTIN_H
 565 #include <gpp/builtin.h>
 566 #elif HAVE_BUILTIN_H
 567 #include <builtin.h>
 568 #endif
 569
 570 #else
 571
 572 #if $cf_cv_header_stdbool_h
 573 #include <stdbool.h>
 574 #endif
 575
 576 #endif
 577
 578 int main()
 579 {
 580         FILE *fp = fopen("cf_test.out", "w");
 581         if (fp != 0) {
 582                 bool x = true;
 583                 if ((bool)(-x) >= 0)
 584                         fputs("unsigned ", fp);
 585                 if (sizeof(x) == sizeof(int))       fputs("int",  fp);
 586                 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
 587                 else if (sizeof(x) == sizeof(short))fputs("short",fp);
 588                 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
 589                 fclose(fp);
 590         }
 591         ${cf_cv_main_return:-return}(0);
 592 }
 593                 ],
 594                 [cf_cv_type_of_bool=`cat cf_test.out`
 595                  if test -z "$cf_cv_type_of_bool"; then
 596                    cf_cv_type_of_bool=unknown
 597                  fi],
 598                 [cf_cv_type_of_bool=unknown],
 599                 [cf_cv_type_of_bool=unknown])
 600         ])
 601         rm -f cf_test.out
 602 AC_MSG_RESULT($cf_cv_type_of_bool)
 603 if test "$cf_cv_type_of_bool" = unknown ; then
 604         case .$NCURSES_BOOL in
 605         (.auto|.) NCURSES_BOOL=unsigned;;
 606         esac
 607         AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
 608         cf_cv_type_of_bool=$NCURSES_BOOL
 609 fi
 610 ])dnl
 611 dnl ---------------------------------------------------------------------------
 612 dnl CF_BUILD_CC version: 7 updated: 2012/10/06 15:31:55
 613 dnl -----------
 614 dnl If we're cross-compiling, allow the user to override the tools and their
 615 dnl options.  The configure script is oriented toward identifying the host
 616 dnl compiler, etc., but we need a build compiler to generate parts of the
 617 dnl source.
 618 dnl
 619 dnl $1 = default for $CPPFLAGS
 620 dnl $2 = default for $LIBS
 621 AC_DEFUN([CF_BUILD_CC],[
 622 CF_ACVERSION_CHECK(2.52,,
 623         [AC_REQUIRE([CF_PROG_EXT])])
 624 if test "$cross_compiling" = yes ; then
 625
 626         # defaults that we might want to override
 627         : ${BUILD_CFLAGS:=''}
 628         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
 629         : ${BUILD_LDFLAGS:=''}
 630         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
 631         : ${BUILD_EXEEXT:='$x'}
 632         : ${BUILD_OBJEXT:='o'}
 633
 634         AC_ARG_WITH(build-cc,
 635                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
 636                 [BUILD_CC="$withval"],
 637                 [AC_CHECK_PROGS(BUILD_CC, gcc cc cl)])
 638         AC_MSG_CHECKING(for native build C compiler)
 639         AC_MSG_RESULT($BUILD_CC)
 640
 641         AC_MSG_CHECKING(for native build C preprocessor)
 642         AC_ARG_WITH(build-cpp,
 643                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
 644                 [BUILD_CPP="$withval"],
 645                 [BUILD_CPP='${BUILD_CC} -E'])
 646         AC_MSG_RESULT($BUILD_CPP)
 647
 648         AC_MSG_CHECKING(for native build C flags)
 649         AC_ARG_WITH(build-cflags,
 650                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
 651                 [BUILD_CFLAGS="$withval"])
 652         AC_MSG_RESULT($BUILD_CFLAGS)
 653
 654         AC_MSG_CHECKING(for native build C preprocessor-flags)
 655         AC_ARG_WITH(build-cppflags,
 656                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
 657                 [BUILD_CPPFLAGS="$withval"])
 658         AC_MSG_RESULT($BUILD_CPPFLAGS)
 659
 660         AC_MSG_CHECKING(for native build linker-flags)
 661         AC_ARG_WITH(build-ldflags,
 662                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
 663                 [BUILD_LDFLAGS="$withval"])
 664         AC_MSG_RESULT($BUILD_LDFLAGS)
 665
 666         AC_MSG_CHECKING(for native build linker-libraries)
 667         AC_ARG_WITH(build-libs,
 668                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
 669                 [BUILD_LIBS="$withval"])
 670         AC_MSG_RESULT($BUILD_LIBS)
 671
 672         # this assumes we're on Unix.
 673         BUILD_EXEEXT=
 674         BUILD_OBJEXT=o
 675
 676         : ${BUILD_CC:='${CC}'}
 677
 678         if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
 679                 AC_MSG_ERROR([Cross-build requires two compilers.
 680 Use --with-build-cc to specify the native compiler.])
 681         fi
 682
 683 else
 684         : ${BUILD_CC:='${CC}'}
 685         : ${BUILD_CPP:='${CPP}'}
 686         : ${BUILD_CFLAGS:='${CFLAGS}'}
 687         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
 688         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
 689         : ${BUILD_LIBS:='${LIBS}'}
 690         : ${BUILD_EXEEXT:='$x'}
 691         : ${BUILD_OBJEXT:='o'}
 692 fi
 693
 694 AC_SUBST(BUILD_CC)
 695 AC_SUBST(BUILD_CPP)
 696 AC_SUBST(BUILD_CFLAGS)
 697 AC_SUBST(BUILD_CPPFLAGS)
 698 AC_SUBST(BUILD_LDFLAGS)
 699 AC_SUBST(BUILD_LIBS)
 700 AC_SUBST(BUILD_EXEEXT)
 701 AC_SUBST(BUILD_OBJEXT)
 702 ])dnl
 703 dnl ---------------------------------------------------------------------------
 704 dnl CF_CC_ENV_FLAGS version: 2 updated: 2015/04/12 15:39:00
 705 dnl ---------------
 706 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
 707 dnl into CC.  This will not help with broken scripts that wrap the compiler with
 708 dnl options, but eliminates a more common category of user confusion.
 709 AC_DEFUN([CF_CC_ENV_FLAGS],
 710 [
 711 # This should have been defined by AC_PROG_CC
 712 : ${CC:=cc}
 713
 714 AC_MSG_CHECKING(\$CC variable)
 715 case "$CC" in
 716 (*[[\ \ ]]-[[IUD]]*)
 717         AC_MSG_RESULT(broken)
 718         AC_MSG_WARN(your environment misuses the CC variable to hold CFLAGS/CPPFLAGS options)
 719         # humor him...
 720         cf_flags=`echo "$CC" | sed -e 's/^[[^   ]]*[[   ]]//'`
 721         CC=`echo "$CC" | sed -e 's/[[   ]].*//'`
 722         CF_ADD_CFLAGS($cf_flags)
 723         ;;
 724 (*)
 725         AC_MSG_RESULT(ok)
 726         ;;
 727 esac
 728 ])dnl
 729 dnl ---------------------------------------------------------------------------
 730 dnl CF_CFG_DEFAULTS version: 11 updated: 2015/04/17 21:13:04
 731 dnl ---------------
 732 dnl Determine the default configuration into which we'll install ncurses.  This
 733 dnl can be overridden by the user's command-line options.  There's two items to
 734 dnl look for:
 735 dnl     1. the prefix (e.g., /usr)
 736 dnl     2. the header files (e.g., /usr/include/ncurses)
 737 dnl We'll look for a previous installation of ncurses and use the same defaults.
 738 dnl
 739 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
 740 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
 741 dnl programs from a vendor's.
 742 AC_DEFUN([CF_CFG_DEFAULTS],
 743 [
 744 AC_MSG_CHECKING(for prefix)
 745 if test "x$prefix" = "xNONE" ; then
 746         case "$cf_cv_system_name" in
 747                 # non-vendor systems don't have a conflict
 748         (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
 749                 prefix=/usr
 750                 ;;
 751         (*)     prefix=$ac_default_prefix
 752                 ;;
 753         esac
 754 fi
 755 AC_MSG_RESULT($prefix)
 756
 757 if test "x$prefix" = "xNONE" ; then
 758 AC_MSG_CHECKING(for default include-directory)
 759 test -n "$verbose" && echo 1>&AC_FD_MSG
 760 for cf_symbol in \
 761         $includedir \
 762         $includedir/ncurses \
 763         $prefix/include \
 764         $prefix/include/ncurses \
 765         /usr/local/include \
 766         /usr/local/include/ncurses \
 767         /usr/include \
 768         /usr/include/ncurses
 769 do
 770         cf_dir=`eval echo $cf_symbol`
 771         if test -f $cf_dir/curses.h ; then
 772         if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
 773                 includedir="$cf_symbol"
 774                 test -n "$verbose"  && echo $ac_n "     found " 1>&AC_FD_MSG
 775                 break
 776         fi
 777         fi
 778         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
 779 done
 780 AC_MSG_RESULT($includedir)
 781 fi
 782 ])dnl
 783 dnl ---------------------------------------------------------------------------
 784 dnl CF_CGETENT version: 5 updated: 2012/10/06 17:56:13
 785 dnl ----------
 786 dnl Check if the terminal-capability database functions are available.  If not,
 787 dnl ncurses has a much-reduced version.
 788 AC_DEFUN([CF_CGETENT],[
 789 AC_CACHE_CHECK(for terminal-capability database functions,cf_cv_cgetent,[
 790 AC_TRY_LINK([
 791 #include <stdlib.h>],[
 792         char temp[128];
 793         char *buf = temp;
 794         char *db_array = temp;
 795         cgetent(&buf, &db_array, "vt100");
 796         cgetcap(buf, "tc", '=');
 797         cgetmatch(buf, "tc");
 798         ],
 799         [cf_cv_cgetent=yes],
 800         [cf_cv_cgetent=no])
 801 ])
 802
 803 if test "$cf_cv_cgetent" = yes
 804 then
 805         AC_DEFINE(HAVE_BSD_CGETENT,1,[Define to 1 if we have BSD cgetent])
 806 AC_CACHE_CHECK(if cgetent uses const parameter,cf_cv_cgetent_const,[
 807 AC_TRY_LINK([
 808 #include <stdlib.h>],[
 809         char temp[128];
 810         char *buf = temp;
 811 #ifndef _NETBSD_SOURCE                  /* given, since April 2004 in stdlib.h */
 812         const char *db_array = temp;
 813         cgetent(&buf, &db_array, "vt100");
 814 #endif
 815         cgetcap(buf, "tc", '=');
 816         cgetmatch(buf, "tc");
 817         ],
 818         [cf_cv_cgetent_const=yes],
 819         [cf_cv_cgetent_const=no])
 820 ])
 821         if test "$cf_cv_cgetent_const" = yes
 822         then
 823                 AC_DEFINE_UNQUOTED(CGETENT_CONST,const,[Define to const if needed for some BSD cgetent variations])
 824         fi
 825 fi
 826 ])dnl
 827 dnl ---------------------------------------------------------------------------
 828 dnl CF_CHECK_CACHE version: 12 updated: 2012/10/02 20:55:03
 829 dnl --------------
 830 dnl Check if we're accidentally using a cache from a different machine.
 831 dnl Derive the system name, as a check for reusing the autoconf cache.
 832 dnl
 833 dnl If we've packaged config.guess and config.sub, run that (since it does a
 834 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
 835 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
 836 dnl which is useful in cross-compiles.
 837 dnl
 838 dnl Note: we would use $ac_config_sub, but that is one of the places where
 839 dnl autoconf 2.5x broke compatibility with autoconf 2.13
 840 AC_DEFUN([CF_CHECK_CACHE],
 841 [
 842 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
 843         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
 844         system_name="$host_os"
 845 else
 846         system_name="`(uname -s -r) 2>/dev/null`"
 847         if test -z "$system_name" ; then
 848                 system_name="`(hostname) 2>/dev/null`"
 849         fi
 850 fi
 851 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
 852 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
 853
 854 test -z "$system_name" && system_name="$cf_cv_system_name"
 855 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
 856
 857 if test ".$system_name" != ".$cf_cv_system_name" ; then
 858         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
 859         AC_MSG_ERROR("Please remove config.cache and try again.")
 860 fi
 861 ])dnl
 862 dnl ---------------------------------------------------------------------------
 863 dnl CF_CHECK_ERRNO version: 12 updated: 2015/04/18 08:56:57
 864 dnl --------------
 865 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
 866 dnl the 'errno' variable.  Define a DECL_xxx symbol if we must declare it
 867 dnl ourselves.
 868 dnl
 869 dnl $1 = the name to check
 870 dnl $2 = the assumed type
 871 AC_DEFUN([CF_CHECK_ERRNO],
 872 [
 873 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
 874         AC_TRY_COMPILE([
 875 #ifdef HAVE_STDLIB_H
 876 #include <stdlib.h>
 877 #endif
 878 #include <stdio.h>
 879 #include <sys/types.h>
 880 #include <errno.h> ],
 881         ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1,
 882         [cf_cv_dcl_$1=yes],
 883         [cf_cv_dcl_$1=no])
 884 ])
 885
 886 if test "$cf_cv_dcl_$1" = no ; then
 887         CF_UPPER(cf_result,decl_$1)
 888         AC_DEFINE_UNQUOTED($cf_result)
 889 fi
 890
 891 # It's possible (for near-UNIX clones) that the data doesn't exist
 892 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
 893 ])dnl
 894 dnl ---------------------------------------------------------------------------
 895 dnl CF_CHECK_EXTERN_DATA version: 4 updated: 2015/04/18 08:56:57
 896 dnl --------------------
 897 dnl Check for existence of external data in the current set of libraries.  If
 898 dnl we can modify it, it's real enough.
 899 dnl $1 = the name to check
 900 dnl $2 = its type
 901 AC_DEFUN([CF_CHECK_EXTERN_DATA],
 902 [
 903 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
 904         AC_TRY_LINK([
 905 #undef $1
 906 extern $2 $1;
 907 ],
 908         [$1 = 2],
 909         [cf_cv_have_$1=yes],
 910         [cf_cv_have_$1=no])
 911 ])
 912
 913 if test "$cf_cv_have_$1" = yes ; then
 914         CF_UPPER(cf_result,have_$1)
 915         AC_DEFINE_UNQUOTED($cf_result)
 916 fi
 917
 918 ])dnl
 919 dnl ---------------------------------------------------------------------------
 920 dnl CF_CHECK_GPM_WGETCH version: 2 updated: 2010/08/14 18:25:37
 921 dnl -------------------
 922 dnl Check if GPM is already linked with curses.  If so - and if the linkage
 923 dnl is not "weak" - warn about this because it can create problems linking
 924 dnl applications with ncurses.
 925 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
 926 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
 927
 928 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
 929 cf_cv_check_gpm_wgetch=unknown
 930 if test "$cross_compiling" != yes ; then
 931
 932 cat >conftest.$ac_ext <<CF_EOF
 933 #include <gpm.h>
 934 int main()
 935 {
 936         Gpm_Wgetch();
 937         ${cf_cv_main_return:-return}(0);
 938 }
 939 CF_EOF
 940
 941         cf_save_LIBS="$LIBS"
 942         # This only works if we can look at the symbol table.  If a shared
 943         # library is stripped for install, we cannot use that.  So we're forced
 944         # to rely on the static library, noting that some packagers may not
 945         # include it.
 946         LIBS="-static -lgpm -dynamic $LIBS"
 947         if AC_TRY_EVAL(ac_compile) ; then
 948                 if AC_TRY_EVAL(ac_link) ; then
 949                         cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
 950                         test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
 951                         test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
 952                 fi
 953         fi
 954         rm -rf conftest*
 955         LIBS="$cf_save_LIBS"
 956 fi
 957 ])
 958
 959 if test "$cf_cv_check_gpm_wgetch" != yes ; then
 960         AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
 961 fi
 962 ])])dnl
 963 dnl ---------------------------------------------------------------------------
 964 dnl CF_CHECK_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09
 965 dnl ------------------------
 966 dnl Show the version of libtool
 967 dnl
 968 dnl Save the version in a cache variable - this is not entirely a good thing,
 969 dnl but the version string from libtool is very ugly, and for bug reports it
 970 dnl might be useful to have the original string.
 971 AC_DEFUN([CF_CHECK_LIBTOOL_VERSION],[
 972 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
 973 then
 974         AC_MSG_CHECKING(version of $LIBTOOL)
 975         CF_LIBTOOL_VERSION
 976         AC_MSG_RESULT($cf_cv_libtool_version)
 977         if test -z "$cf_cv_libtool_version" ; then
 978                 AC_MSG_ERROR(This is not GNU libtool)
 979         fi
 980 else
 981         AC_MSG_ERROR(GNU libtool has not been found)
 982 fi
 983 ])dnl
 984 dnl ---------------------------------------------------------------------------
 985 dnl CF_CHECK_WCHAR_H version: 1 updated: 2011/10/29 15:01:05
 986 dnl ----------------
 987 dnl Check if wchar.h can be used, i.e., without defining _XOPEN_SOURCE_EXTENDED
 988 AC_DEFUN([CF_CHECK_WCHAR_H],[
 989 AC_CACHE_CHECK(if wchar.h can be used as is,cf_cv_wchar_h_okay,[
 990 AC_TRY_COMPILE(
 991 [
 992 #include <stdlib.h>
 993 #include <wchar.h>
 994 ],[
 995         wint_t foo = 0;
 996         int bar = iswpunct(foo)],
 997         [cf_cv_wchar_h_okay=yes],
 998         [cf_cv_wchar_h_okay=no])])
 999
1000 if test $cf_cv_wchar_h_okay = no
1001 then
1002         CF_PREDEFINE(_XOPEN_SOURCE_EXTENDED)
1003 fi
1004 ])dnl
1005 dnl ---------------------------------------------------------------------------
1006 dnl CF_CLANG_COMPILER version: 2 updated: 2013/11/19 19:23:35
1007 dnl -----------------
1008 dnl Check if the given compiler is really clang.  clang's C driver defines
1009 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
1010 dnl not ignore some gcc options.
1011 dnl
1012 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1013 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
1014 dnl the wrappers for gcc and g++ warnings.
1015 dnl
1016 dnl $1 = GCC (default) or GXX
1017 dnl $2 = CLANG_COMPILER (default)
1018 dnl $3 = CFLAGS (default) or CXXFLAGS
1019 AC_DEFUN([CF_CLANG_COMPILER],[
1020 ifelse([$2],,CLANG_COMPILER,[$2])=no
1021
1022 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
1023         AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
1024         cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
1025         ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -Qunused-arguments"
1026         AC_TRY_COMPILE([],[
1027 #ifdef __clang__
1028 #else
1029 make an error
1030 #endif
1031 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
1032 cf_save_CFLAGS="$cf_save_CFLAGS -Qunused-arguments"
1033 ],[])
1034         ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
1035         AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
1036 fi
1037 ])
1038 dnl ---------------------------------------------------------------------------
1039 dnl CF_CPP_PARAM_INIT version: 6 updated: 2012/10/06 17:56:13
1040 dnl -----------------
1041 dnl Check if the C++ compiler accepts duplicate parameter initialization.  This
1042 dnl is a late feature for the standard and is not in some recent compilers
1043 dnl (1999/9/11).
1044 AC_DEFUN([CF_CPP_PARAM_INIT],
1045 [
1046 if test -n "$CXX"; then
1047 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
1048         AC_LANG_SAVE
1049         AC_LANG_CPLUSPLUS
1050         AC_TRY_RUN([
1051 class TEST {
1052 private:
1053         int value;
1054 public:
1055         TEST(int x = 1);
1056         ~TEST();
1057 };
1058
1059 TEST::TEST(int x = 1)   // some compilers do not like second initializer
1060 {
1061         value = x;
1062 }
1063 int main() { }
1064 ],
1065         [cf_cv_cpp_param_init=yes],
1066         [cf_cv_cpp_param_init=no],
1067         [cf_cv_cpp_param_init=unknown])
1068         AC_LANG_RESTORE
1069 ])
1070 fi
1071 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT,1,[Define to 1 if C++ has parameter initialization])
1072 ])dnl
1073 dnl ---------------------------------------------------------------------------
1074 dnl CF_CPP_STATIC_CAST version: 3 updated: 2013/04/13 18:03:21
1075 dnl ------------------
1076 dnl Check if the C++ compiler accepts static_cast in generics.  This appears to
1077 dnl not be supported in g++ before 3.0
1078 AC_DEFUN([CF_CPP_STATIC_CAST],
1079 [
1080 if test -n "$CXX"; then
1081
1082 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
1083         AC_LANG_SAVE
1084         AC_LANG_CPLUSPLUS
1085
1086         AC_TRY_COMPILE([
1087 class NCursesPanel
1088 {
1089 public:
1090   NCursesPanel(int nlines,
1091                int ncols,
1092                int begin_y = 0,
1093                int begin_x = 0)
1094   {
1095   }
1096   NCursesPanel();
1097   ~NCursesPanel();
1098 };
1099
1100 template<class T> class NCursesUserPanel : public NCursesPanel
1101 {
1102 public:
1103   NCursesUserPanel (int nlines,
1104                     int ncols,
1105                     int begin_y = 0,
1106                     int begin_x = 0,
1107                     const T* p_UserData = static_cast<T*>(0))
1108     : NCursesPanel (nlines, ncols, begin_y, begin_x)
1109   {
1110   };
1111   NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
1112   {
1113   };
1114
1115   virtual ~NCursesUserPanel() {};
1116 };
1117 ],[
1118         const char* p_UserData = static_cast<char*>(0)],
1119         [cf_cv_cpp_static_cast=yes],
1120         [cf_cv_cpp_static_cast=no])
1121
1122         AC_LANG_RESTORE
1123 ])
1124
1125 fi
1126
1127 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST,1,[Define to 1 if C++ has static_cast])
1128 ])dnl
1129 dnl ---------------------------------------------------------------------------
1130 dnl CF_CXX_AR_FLAGS version: 2 updated: 2015/04/17 21:13:04
1131 dnl ---------------
1132 dnl Setup special archiver flags for given compilers.
1133 AC_DEFUN([CF_CXX_AR_FLAGS],[
1134         CXX_AR='$(AR)'
1135         CXX_ARFLAGS='$(ARFLAGS)'
1136         case $cf_cv_system_name in
1137         (irix*)
1138             if test "$GXX" != yes ; then
1139                 CXX_AR='$(CXX)'
1140                 CXX_ARFLAGS='-ar -o'
1141             fi
1142             ;;
1143         (sco3.2v5*)
1144             CXXLDFLAGS="-u main"
1145             ;;
1146         (solaris2*)
1147             if test "$GXX" != yes ; then
1148                 CXX_AR='$(CXX)'
1149                 CXX_ARFLAGS='-xar -o'
1150             fi
1151             ;;
1152         esac
1153         AC_SUBST(CXXLDFLAGS)
1154         AC_SUBST(CXX_AR)
1155         AC_SUBST(CXX_ARFLAGS)
1156 ])dnl
1157 dnl ---------------------------------------------------------------------------
1158 dnl CF_CXX_IOSTREAM_NAMESPACE version: 2 updated: 2012/10/06 17:56:13
1159 dnl -------------------------
1160 dnl For c++, check if iostream uses "std::" namespace.
1161 AC_DEFUN([CF_CXX_IOSTREAM_NAMESPACE],[
1162 AC_CHECK_HEADERS(iostream)
1163 if test x"$ac_cv_header_iostream" = xyes ; then
1164         AC_MSG_CHECKING(if iostream uses std-namespace)
1165         AC_TRY_COMPILE([
1166 #include <iostream>
1167 using std::endl;
1168 using std::cerr;],[
1169 cerr << "testing" << endl;
1170 ],[cf_iostream_namespace=yes],[cf_iostream_namespace=no])
1171         AC_MSG_RESULT($cf_iostream_namespace)
1172         if test "$cf_iostream_namespace" = yes ; then
1173                 AC_DEFINE(IOSTREAM_NAMESPACE,1,[Define to 1 if C++ has namespace iostream])
1174         fi
1175 fi
1176 ])dnl
1177 dnl ---------------------------------------------------------------------------
1178 dnl CF_C_INLINE version: 5 updated: 2015/04/18 08:56:57
1179 dnl -----------
1180 dnl Check if the C compiler supports "inline".
1181 dnl $1 is the name of a shell variable to set if inline is supported
1182 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
1183 AC_DEFUN([CF_C_INLINE],[
1184 AC_C_INLINE
1185 $1=
1186 if test "$ac_cv_c_inline" != no ; then
1187         $1=inline
1188         if test "$INTEL_COMPILER" = yes
1189         then
1190                 :
1191         elif test "$CLANG_COMPILER" = yes
1192         then
1193                 :
1194         elif test "$GCC" = yes
1195         then
1196                 AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[
1197                 cf_save_CFLAGS=$CFLAGS
1198                 CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
1199                 AC_TRY_COMPILE([inline int foo(void) { return 1; }],
1200                 [${cf_cv_main_return:-return} foo()],
1201                 [cf_cv_gcc_inline=yes],
1202                 [cf_cv_gcc_inline=no])
1203                 CFLAGS=$cf_save_CFLAGS
1204                 ])
1205                 if test "$cf_cv_gcc_inline" = yes ; then
1206                         CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
1207                 fi
1208         fi
1209 fi
1210 AC_SUBST($1)
1211 ])dnl
1212 dnl ---------------------------------------------------------------------------
1213 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
1214 dnl ----------
1215 dnl "dirname" is not portable, so we fake it with a shell script.
1216 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
1217 dnl ---------------------------------------------------------------------------
1218 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
1219 dnl ---------------
1220 AC_DEFUN([CF_DIRS_TO_MAKE],
1221 [
1222 DIRS_TO_MAKE="lib"
1223 for cf_item in $cf_list_models
1224 do
1225         CF_OBJ_SUBDIR($cf_item,cf_subdir)
1226         for cf_item2 in $DIRS_TO_MAKE
1227         do
1228                 test $cf_item2 = $cf_subdir && break
1229         done
1230         test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
1231 done
1232 for cf_dir in $DIRS_TO_MAKE
1233 do
1234         test ! -d $cf_dir && mkdir $cf_dir
1235 done
1236 AC_SUBST(DIRS_TO_MAKE)
1237 ])dnl
1238 dnl ---------------------------------------------------------------------------
1239 dnl CF_DISABLE_ECHO version: 13 updated: 2015/04/18 08:56:57
1240 dnl ---------------
1241 dnl You can always use "make -n" to see the actual options, but it's hard to
1242 dnl pick out/analyze warning messages when the compile-line is long.
1243 dnl
1244 dnl Sets:
1245 dnl     ECHO_LT - symbol to control if libtool is verbose
1246 dnl     ECHO_LD - symbol to prefix "cc -o" lines
1247 dnl     RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1248 dnl     SHOW_CC - symbol to put before explicit "cc -c" lines
1249 dnl     ECHO_CC - symbol to put before any "cc" line
1250 dnl
1251 AC_DEFUN([CF_DISABLE_ECHO],[
1252 AC_MSG_CHECKING(if you want to see long compiling messages)
1253 CF_ARG_DISABLE(echo,
1254         [  --disable-echo          do not display "compiling" commands],
1255         [
1256         ECHO_LT='--silent'
1257         ECHO_LD='@echo linking [$]@;'
1258         RULE_CC='@echo compiling [$]<'
1259         SHOW_CC='@echo compiling [$]@'
1260         ECHO_CC='@'
1261 ],[
1262         ECHO_LT=''
1263         ECHO_LD=''
1264         RULE_CC=''
1265         SHOW_CC=''
1266         ECHO_CC=''
1267 ])
1268 AC_MSG_RESULT($enableval)
1269 AC_SUBST(ECHO_LT)
1270 AC_SUBST(ECHO_LD)
1271 AC_SUBST(RULE_CC)
1272 AC_SUBST(SHOW_CC)
1273 AC_SUBST(ECHO_CC)
1274 ])dnl
1275 dnl ---------------------------------------------------------------------------
1276 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
1277 dnl ------------------------
1278 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
1279 AC_MSG_CHECKING(if we want to use GNAT projects)
1280 CF_ARG_DISABLE(gnat-projects,
1281         [  --disable-gnat-projects test: disable GNAT projects even if usable],
1282         [enable_gnat_projects=no],
1283         [enable_gnat_projects=yes])
1284 AC_MSG_RESULT($enable_gnat_projects)
1285 ])dnl
1286 dnl ---------------------------------------------------------------------------
1287 dnl CF_DISABLE_LEAKS version: 7 updated: 2012/10/02 20:55:03
1288 dnl ----------------
1289 dnl Combine no-leak checks with the libraries or tools that are used for the
1290 dnl checks.
1291 AC_DEFUN([CF_DISABLE_LEAKS],[
1292
1293 AC_REQUIRE([CF_WITH_DMALLOC])
1294 AC_REQUIRE([CF_WITH_DBMALLOC])
1295 AC_REQUIRE([CF_WITH_VALGRIND])
1296
1297 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1298 AC_ARG_ENABLE(leaks,
1299         [  --disable-leaks         test: free permanent memory, analyze leaks],
1300         [if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi],
1301         : ${with_no_leaks:=no})
1302 AC_MSG_RESULT($with_no_leaks)
1303
1304 if test "$with_no_leaks" = yes ; then
1305         AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1306         AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1307 fi
1308 ])dnl
1309 dnl ---------------------------------------------------------------------------
1310 dnl CF_DISABLE_LIBTOOL_VERSION version: 3 updated: 2015/04/17 21:13:04
1311 dnl --------------------------
1312 dnl Check if we should use the libtool 1.5 feature "-version-number" instead of
1313 dnl the older "-version-info" feature.  The newer feature allows us to use
1314 dnl version numbering on shared libraries which make them compatible with
1315 dnl various systems.
1316 AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION],
1317 [
1318 AC_MSG_CHECKING(if libtool -version-number should be used)
1319 CF_ARG_DISABLE(libtool-version,
1320         [  --disable-libtool-version  enable to use libtool's incompatible naming scheme],
1321         [cf_libtool_version=no],
1322         [cf_libtool_version=yes])
1323 AC_MSG_RESULT($cf_libtool_version)
1324
1325 if test "$cf_libtool_version" = yes ; then
1326         LIBTOOL_VERSION="-version-number"
1327 else
1328         LIBTOOL_VERSION="-version-info"
1329         case "x$VERSION" in
1330         (x)
1331                 AC_MSG_WARN(VERSION was not set)
1332                 ;;
1333         (x*.*.*)
1334                 ABI_VERSION="$VERSION"
1335                 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
1336                 ;;
1337         (x*:*:*)
1338                 ABI_VERSION=`echo "$VERSION" | sed -e 's/:/./g'`
1339                 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
1340                 ;;
1341         (*)
1342                 AC_MSG_WARN(unexpected VERSION value: $VERSION)
1343                 ;;
1344         esac
1345 fi
1346
1347 AC_SUBST(ABI_VERSION)
1348 AC_SUBST(LIBTOOL_VERSION)
1349 ])dnl
1350 dnl ---------------------------------------------------------------------------
1351 dnl CF_DISABLE_RPATH_HACK version: 2 updated: 2011/02/13 13:31:33
1352 dnl ---------------------
1353 dnl The rpath-hack makes it simpler to build programs, particularly with the
1354 dnl *BSD ports which may have essential libraries in unusual places.  But it
1355 dnl can interfere with building an executable for the base system.  Use this
1356 dnl option in that case.
1357 AC_DEFUN([CF_DISABLE_RPATH_HACK],
1358 [
1359 AC_MSG_CHECKING(if rpath-hack should be disabled)
1360 CF_ARG_DISABLE(rpath-hack,
1361         [  --disable-rpath-hack    don't add rpath options for additional libraries],
1362         [cf_disable_rpath_hack=yes],
1363         [cf_disable_rpath_hack=no])
1364 AC_MSG_RESULT($cf_disable_rpath_hack)
1365 if test "$cf_disable_rpath_hack" = no ; then
1366         CF_RPATH_HACK
1367 fi
1368 ])
1369 dnl ---------------------------------------------------------------------------
1370 dnl CF_ENABLE_PC_FILES version: 12 updated: 2015/04/17 21:13:04
1371 dnl ------------------
1372 dnl This is the "--enable-pc-files" option, which is available if there is a
1373 dnl pkg-config configuration on the local machine.
1374 AC_DEFUN([CF_ENABLE_PC_FILES],[
1375 AC_REQUIRE([CF_PKG_CONFIG])
1376 AC_REQUIRE([CF_WITH_PKG_CONFIG_LIBDIR])
1377
1378 if test "x$PKG_CONFIG" != xnone
1379 then
1380         AC_MSG_CHECKING(if we should install .pc files for $PKG_CONFIG)
1381 else
1382         AC_MSG_CHECKING(if we should install .pc files)
1383 fi
1384
1385 AC_ARG_ENABLE(pc-files,
1386         [  --enable-pc-files       generate and install .pc files for pkg-config],
1387         [enable_pc_files=$enableval],
1388         [enable_pc_files=no])
1389 AC_MSG_RESULT($enable_pc_files)
1390
1391 if test "x$enable_pc_files" != xno
1392 then
1393         case "x$PKG_CONFIG_LIBDIR" in
1394         (xno|xyes)
1395                 AC_MSG_WARN(no PKG_CONFIG_LIBDIR was found)
1396                 MAKE_PC_FILES="#"
1397                 ;;
1398         (*)
1399                 CF_PATH_SYNTAX(PKG_CONFIG_LIBDIR)
1400                 MAKE_PC_FILES=
1401                 ;;
1402         esac
1403 else
1404         MAKE_PC_FILES="#"
1405 fi
1406 AC_SUBST(MAKE_PC_FILES)
1407 ])dnl
1408 dnl ---------------------------------------------------------------------------
1409 dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
1410 dnl ---------------
1411 dnl Check if the rpath option should be used, setting cache variable
1412 dnl cf_cv_enable_rpath if so.
1413 AC_DEFUN([CF_ENABLE_RPATH],
1414 [
1415 AC_MSG_CHECKING(if rpath option should be used)
1416 AC_ARG_ENABLE(rpath,
1417 [  --enable-rpath          use rpath option when generating shared libraries],
1418 [cf_cv_enable_rpath=$enableval],
1419 [cf_cv_enable_rpath=no])
1420 AC_MSG_RESULT($cf_cv_enable_rpath)
1421 ])dnl
1422 dnl ---------------------------------------------------------------------------
1423 dnl CF_ENABLE_STRING_HACKS version: 3 updated: 2013/01/26 16:26:12
1424 dnl ----------------------
1425 dnl On a few platforms, the compiler and/or loader nags with untruthful
1426 dnl comments stating that "most" uses of strcat/strcpy/sprintf are incorrect,
1427 dnl and implying that most uses of the recommended alternatives are correct.
1428 dnl
1429 dnl Factually speaking, no one has actually counted the number of uses of these
1430 dnl functions versus the total of incorrect uses.  Samples of a few thousand
1431 dnl instances are meaningless compared to the hundreds of millions of lines of
1432 dnl existing C code.
1433 dnl
1434 dnl strlcat/strlcpy are (as of 2012) non-standard, and are available on some
1435 dnl platforms, in implementations of varying quality.  Likewise, snprintf is
1436 dnl standard - but evolved through phases, and older implementations are likely
1437 dnl to yield surprising results, as documented in manpages on various systems.
1438 AC_DEFUN([CF_ENABLE_STRING_HACKS],
1439 [
1440 AC_MSG_CHECKING(if you want to work around bogus compiler/loader warnings)
1441 AC_ARG_ENABLE(string-hacks,
1442         [  --enable-string-hacks   work around bogus compiler/loader warnings],
1443         [with_string_hacks=$enableval],
1444         [with_string_hacks=no])
1445 AC_MSG_RESULT($with_string_hacks)
1446
1447 if test "x$with_string_hacks" = "xyes"; then
1448         AC_DEFINE(USE_STRING_HACKS,1,[Define to 1 to work around bogus compiler/loader warnings])
1449         AC_MSG_WARN(enabling string-hacks to work around bogus compiler/loader warnings)
1450         AC_CHECK_FUNCS( strlcat strlcpy snprintf )
1451 fi
1452 ])dnl
1453 dnl ---------------------------------------------------------------------------
1454 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
1455 dnl --------
1456 dnl Check if 'errno' is declared in <errno.h>
1457 AC_DEFUN([CF_ERRNO],
1458 [
1459 CF_CHECK_ERRNO(errno)
1460 ])dnl
1461 dnl ---------------------------------------------------------------------------
1462 dnl CF_ETIP_DEFINES version: 5 updated: 2012/02/18 17:51:07
1463 dnl ---------------
1464 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
1465 dnl math.h and builtin.h, only for ncurses
1466 AC_DEFUN([CF_ETIP_DEFINES],
1467 [
1468 AC_MSG_CHECKING(for special defines needed for etip.h)
1469 cf_save_CXXFLAGS="$CXXFLAGS"
1470 cf_result="none"
1471
1472 # etip.h includes ncurses.h which includes ncurses_dll.h
1473 # But ncurses_dll.h is generated - fix here.
1474 test -d include || mkdir include
1475 test -f include/ncurses_dll.h || sed -e 's/@NCURSES_WRAP_PREFIX@/'$NCURSES_WRAP_PREFIX'/g' ${srcdir}/include/ncurses_dll.h.in >include/ncurses_dll.h
1476
1477 for cf_math in "" MATH_H
1478 do
1479 for cf_excp in "" MATH_EXCEPTION
1480 do
1481         CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -Iinclude -I${srcdir}/include"
1482         test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
1483         test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
1484 AC_TRY_COMPILE([
1485 #include <etip.h.in>
1486 ],[],[
1487         test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
1488         test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
1489         cf_result="$cf_math $cf_excp"
1490         break 2
1491 ],[])
1492 done
1493 done
1494 AC_MSG_RESULT($cf_result)
1495 CXXFLAGS="$cf_save_CXXFLAGS"
1496 ])
1497 dnl ---------------------------------------------------------------------------
1498 dnl CF_FIND_LINKAGE version: 20 updated: 2015/04/18 08:56:57
1499 dnl ---------------
1500 dnl Find a library (specifically the linkage used in the code fragment),
1501 dnl searching for it if it is not already in the library path.
1502 dnl See also CF_ADD_SEARCHPATH.
1503 dnl
1504 dnl Parameters (4-on are optional):
1505 dnl     $1 = headers for library entrypoint
1506 dnl     $2 = code fragment for library entrypoint
1507 dnl     $3 = the library name without the "-l" option or ".so" suffix.
1508 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
1509 dnl     $5 = action to perform if not successful
1510 dnl     $6 = module name, if not the same as the library name
1511 dnl     $7 = extra libraries
1512 dnl
1513 dnl Sets these variables:
1514 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1515 dnl     $cf_cv_header_path_$3 - include-directory if needed
1516 dnl     $cf_cv_library_path_$3 - library-directory if needed
1517 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1518 AC_DEFUN([CF_FIND_LINKAGE],[
1519
1520 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1521 # will be set on completion of the AC_TRY_LINK below.
1522 cf_cv_header_path_$3=
1523 cf_cv_library_path_$3=
1524
1525 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1526
1527 cf_save_LIBS="$LIBS"
1528
1529 AC_TRY_LINK([$1],[$2],[
1530         cf_cv_find_linkage_$3=yes
1531         cf_cv_header_path_$3=/usr/include
1532         cf_cv_library_path_$3=/usr/lib
1533 ],[
1534
1535 LIBS="-l$3 $7 $cf_save_LIBS"
1536
1537 AC_TRY_LINK([$1],[$2],[
1538         cf_cv_find_linkage_$3=yes
1539         cf_cv_header_path_$3=/usr/include
1540         cf_cv_library_path_$3=/usr/lib
1541         cf_cv_library_file_$3="-l$3"
1542 ],[
1543         cf_cv_find_linkage_$3=no
1544         LIBS="$cf_save_LIBS"
1545
1546         CF_VERBOSE(find linkage for $3 library)
1547         CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1548
1549         cf_save_CPPFLAGS="$CPPFLAGS"
1550         cf_test_CPPFLAGS="$CPPFLAGS"
1551
1552         CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1553         for cf_cv_header_path_$3 in $cf_search
1554         do
1555                 if test -d $cf_cv_header_path_$3 ; then
1556                         CF_VERBOSE(... testing $cf_cv_header_path_$3)
1557                         CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
1558                         AC_TRY_COMPILE([$1],[$2],[
1559                                 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1560                                 cf_cv_find_linkage_$3=maybe
1561                                 cf_test_CPPFLAGS="$CPPFLAGS"
1562                                 break],[
1563                                 CPPFLAGS="$cf_save_CPPFLAGS"
1564                                 ])
1565                 fi
1566         done
1567
1568         if test "$cf_cv_find_linkage_$3" = maybe ; then
1569
1570                 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1571
1572                 cf_save_LIBS="$LIBS"
1573                 cf_save_LDFLAGS="$LDFLAGS"
1574
1575                 ifelse([$6],,,[
1576                 CPPFLAGS="$cf_test_CPPFLAGS"
1577                 LIBS="-l$3 $7 $cf_save_LIBS"
1578                 AC_TRY_LINK([$1],[$2],[
1579                         CF_VERBOSE(... found $3 library in system)
1580                         cf_cv_find_linkage_$3=yes])
1581                         CPPFLAGS="$cf_save_CPPFLAGS"
1582                         LIBS="$cf_save_LIBS"
1583                         ])
1584
1585                 if test "$cf_cv_find_linkage_$3" != yes ; then
1586                         CF_LIBRARY_PATH(cf_search,$3)
1587                         for cf_cv_library_path_$3 in $cf_search
1588                         do
1589                                 if test -d $cf_cv_library_path_$3 ; then
1590                                         CF_VERBOSE(... testing $cf_cv_library_path_$3)
1591                                         CPPFLAGS="$cf_test_CPPFLAGS"
1592                                         LIBS="-l$3 $7 $cf_save_LIBS"
1593                                         LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1594                                         AC_TRY_LINK([$1],[$2],[
1595                                         CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1596                                         cf_cv_find_linkage_$3=yes
1597                                         cf_cv_library_file_$3="-l$3"
1598                                         break],[
1599                                         CPPFLAGS="$cf_save_CPPFLAGS"
1600                                         LIBS="$cf_save_LIBS"
1601                                         LDFLAGS="$cf_save_LDFLAGS"
1602                                         ])
1603                                 fi
1604                         done
1605                         CPPFLAGS="$cf_save_CPPFLAGS"
1606                         LDFLAGS="$cf_save_LDFLAGS"
1607                 fi
1608
1609         else
1610                 cf_cv_find_linkage_$3=no
1611         fi
1612         ],$7)
1613 ])
1614
1615 LIBS="$cf_save_LIBS"
1616
1617 if test "$cf_cv_find_linkage_$3" = yes ; then
1618 ifelse([$4],,[
1619         CF_ADD_INCDIR($cf_cv_header_path_$3)
1620         CF_ADD_LIBDIR($cf_cv_library_path_$3)
1621         CF_ADD_LIB($3)
1622 ],[$4])
1623 else
1624 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1625 fi
1626 ])dnl
1627 dnl ---------------------------------------------------------------------------
1628 dnl CF_FIND_SUB_INCDIR version: 2 updated: 2015/04/17 21:13:04
1629 dnl ------------------
1630 dnl Find an include-directory with the given leaf-name.  This is useful for
1631 dnl example with FreeBSD ports, which use this convention to distinguish
1632 dnl different versions of the same port.
1633 AC_DEFUN([CF_FIND_SUB_INCDIR],[
1634         CF_SUBDIR_PATH(cf_search,$1,include)
1635         for cf_item in $cf_search
1636         do
1637                 case $cf_item in
1638                 (*/$1)
1639                         CF_ADD_INCDIR($cf_item)
1640                         ;;
1641                 esac
1642         done
1643 ])dnl
1644 dnl ---------------------------------------------------------------------------
1645 dnl CF_FIND_SUB_LIBDIR version: 2 updated: 2015/04/17 21:13:04
1646 dnl ------------------
1647 dnl Find a library-directory with the given leaf-name.  This is useful for
1648 dnl example with FreeBSD ports, which use this convention to distinguish
1649 dnl different versions of the same port.
1650 AC_DEFUN([CF_FIND_SUB_LIBDIR],[
1651         CF_SUBDIR_PATH(cf_search,$1,lib)
1652         for cf_item in $cf_search
1653         do
1654                 case $cf_item in
1655                 (*/$1)
1656                         CF_ADD_LIBDIR($cf_item)
1657                         ;;
1658                 esac
1659         done
1660 ])dnl
1661 dnl ---------------------------------------------------------------------------
1662 dnl CF_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04
1663 dnl -----------------
1664 dnl make ADAFLAGS consistent with CFLAGS
1665 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
1666         AC_MSG_CHECKING(optimization options for ADAFLAGS)
1667         case "$CFLAGS" in
1668         (*-g*)
1669                 CF_ADD_ADAFLAGS(-g)
1670                 ;;
1671         esac
1672         case "$CFLAGS" in
1673         (*-O*)
1674                 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[        ]].*//'`
1675                 CF_ADD_ADAFLAGS($cf_O_flag)
1676                 ;;
1677         esac
1678         AC_MSG_RESULT($ADAFLAGS)
1679 ])dnl
1680 dnl ---------------------------------------------------------------------------
1681 dnl CF_FORGET_TOOL version: 1 updated: 2013/04/06 18:03:09
1682 dnl --------------
1683 dnl Forget that we saw the given tool.
1684 AC_DEFUN([CF_FORGET_TOOL],[
1685 unset ac_cv_prog_ac_ct_$1
1686 unset ac_ct_$1
1687 unset $1
1688 ])dnl
1689 dnl ---------------------------------------------------------------------------
1690 dnl CF_FUNC_DLSYM version: 3 updated: 2012/10/06 11:17:15
1691 dnl -------------
1692 dnl Test for dlsym() and related functions, as well as libdl.
1693 dnl
1694 dnl Sets
1695 dnl     $cf_have_dlsym
1696 dnl     $cf_have_libdl
1697 AC_DEFUN([CF_FUNC_DLSYM],[
1698 cf_have_dlsym=no
1699 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
1700
1701 cf_have_libdl=no
1702 AC_CHECK_LIB(dl,dlsym,[
1703         cf_have_dlsym=yes
1704         cf_have_libdl=yes])])
1705
1706 if test "$cf_have_dlsym" = yes ; then
1707         test "$cf_have_libdl" = yes && CF_ADD_LIB(dl)
1708
1709         AC_MSG_CHECKING(whether able to link to dl*() functions)
1710         AC_TRY_LINK([#include <dlfcn.h>],[
1711                 void *obj;
1712                 if ((obj = dlopen("filename", 0)) != 0) {
1713                         if (dlsym(obj, "symbolname") == 0) {
1714                         dlclose(obj);
1715                         }
1716                 }],[
1717                 AC_DEFINE(HAVE_LIBDL,1,[Define to 1 if we have dl library])],[
1718                 AC_MSG_ERROR(Cannot link test program for libdl)])
1719         AC_MSG_RESULT(ok)
1720 else
1721         AC_MSG_ERROR(Cannot find dlsym function)
1722 fi
1723 ])
1724 dnl ---------------------------------------------------------------------------
1725 dnl CF_FUNC_MEMMOVE version: 8 updated: 2012/10/04 20:12:20
1726 dnl ---------------
1727 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
1728 dnl is found, add our own version of memmove to the list of objects.
1729 AC_DEFUN([CF_FUNC_MEMMOVE],
1730 [
1731 AC_CHECK_FUNC(memmove,,[
1732 AC_CHECK_FUNC(bcopy,[
1733         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
1734                 AC_TRY_RUN([
1735 int main() {
1736         static char data[] = "abcdefghijklmnopqrstuwwxyz";
1737         char temp[40];
1738         bcopy(data, temp, sizeof(data));
1739         bcopy(temp+10, temp, 15);
1740         bcopy(temp+5, temp+15, 10);
1741         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
1742 }
1743                 ],
1744                 [cf_cv_good_bcopy=yes],
1745                 [cf_cv_good_bcopy=no],
1746                 [cf_cv_good_bcopy=unknown])
1747                 ])
1748         ],[cf_cv_good_bcopy=no])
1749         if test "$cf_cv_good_bcopy" = yes ; then
1750                 AC_DEFINE(USE_OK_BCOPY,1,[Define to 1 to use bcopy when memmove is unavailable])
1751         else
1752                 AC_DEFINE(USE_MY_MEMMOVE,1,[Define to 1 to use replacement function when memmove is unavailable])
1753         fi
1754 ])])dnl
1755 dnl ---------------------------------------------------------------------------
1756 dnl CF_FUNC_NANOSLEEP version: 4 updated: 2012/10/06 17:56:13
1757 dnl -----------------
1758 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
1759 dnl AIX 4.x, provide a non-working version.
1760 AC_DEFUN([CF_FUNC_NANOSLEEP],[
1761 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
1762 AC_TRY_RUN([
1763 #include <stdio.h>
1764 #include <errno.h>
1765 #include <time.h>
1766
1767 #ifdef HAVE_SYS_TIME_H
1768 #include <sys/time.h>
1769 #endif
1770
1771 int main() {
1772         struct timespec ts1, ts2;
1773         int code;
1774         ts1.tv_sec  = 0;
1775         ts1.tv_nsec = 750000000;
1776         ts2.tv_sec  = 0;
1777         ts2.tv_nsec = 0;
1778         errno = 0;
1779         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
1780         ${cf_cv_main_return:-return}(code != 0);
1781 }
1782 ],
1783         [cf_cv_func_nanosleep=yes],
1784         [cf_cv_func_nanosleep=no],
1785         [cf_cv_func_nanosleep=unknown])])
1786
1787 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP,1,[Define to 1 if we have nanosleep()])
1788 ])
1789 dnl ---------------------------------------------------------------------------
1790 dnl CF_FUNC_OPENPTY version: 4 updated: 2015/04/18 08:56:57
1791 dnl ---------------
1792 dnl Check for openpty() function, along with <pty.h> header.  It may need the
1793 dnl "util" library as well.
1794 AC_DEFUN([CF_FUNC_OPENPTY],
1795 [
1796 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1797 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1798         cf_save_LIBS="$LIBS"
1799         test $cf_cv_lib_util = yes && CF_ADD_LIB(util)
1800         for cf_header in pty.h libutil.h util.h
1801         do
1802         AC_TRY_LINK([
1803 #include <$cf_header>
1804 ],[
1805         int x = openpty((int *)0, (int *)0, (char *)0,
1806                                    (struct termios *)0, (struct winsize *)0);
1807 ],[
1808                 cf_cv_func_openpty=$cf_header
1809                 break
1810 ],[
1811                 cf_cv_func_openpty=no
1812 ])
1813         done
1814         LIBS="$cf_save_LIBS"
1815 ])
1816 ])dnl
1817 dnl ---------------------------------------------------------------------------
1818 dnl CF_FUNC_POLL version: 8 updated: 2012/10/04 05:24:07
1819 dnl ------------
1820 dnl See if the poll function really works.  Some platforms have poll(), but
1821 dnl it does not work for terminals or files.
1822 AC_DEFUN([CF_FUNC_POLL],[
1823 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1824 AC_TRY_RUN([
1825 #include <stdlib.h>
1826 #include <stdio.h>
1827 #include <unistd.h>
1828 #include <fcntl.h>
1829 #ifdef HAVE_POLL_H
1830 #include <poll.h>
1831 #else
1832 #include <sys/poll.h>
1833 #endif
1834 int main() {
1835         struct pollfd myfds;
1836         int ret;
1837
1838         /* check for Darwin bug with respect to "devices" */
1839         myfds.fd = open("/dev/null", 1);        /* O_WRONLY */
1840         if (myfds.fd < 0)
1841                 myfds.fd = 0;
1842         myfds.events = POLLIN;
1843         myfds.revents = 0;
1844
1845         ret = poll(&myfds, 1, 100);
1846
1847         if (ret < 0 || (myfds.revents & POLLNVAL)) {
1848                 ret = -1;
1849         } else {
1850                 int fd = 0;
1851                 if (!isatty(fd)) {
1852                         fd = open("/dev/tty", 2);       /* O_RDWR */
1853                 }
1854
1855                 if (fd >= 0) {
1856                         /* also check with standard input */
1857                         myfds.fd = fd;
1858                         myfds.events = POLLIN;
1859                         myfds.revents = 0;
1860                         ret = poll(&myfds, 1, 100);
1861                 } else {
1862                         ret = -1;
1863                 }
1864         }
1865         ${cf_cv_main_return:-return}(ret < 0);
1866 }],
1867         [cf_cv_working_poll=yes],
1868         [cf_cv_working_poll=no],
1869         [cf_cv_working_poll=unknown])])
1870 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL,1,[Define to 1 if the poll function seems to work])
1871 ])dnl
1872 dnl ---------------------------------------------------------------------------
1873 dnl CF_FUNC_TERMIOS version: 3 updated: 2012/10/06 17:56:13
1874 dnl ---------------
1875 dnl Some old/broken variations define tcgetattr() only as a macro in
1876 dnl termio(s).h
1877 AC_DEFUN([CF_FUNC_TERMIOS],[
1878 AC_REQUIRE([CF_STRUCT_TERMIOS])
1879 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1880 AC_TRY_LINK([
1881 #include <sys/types.h>
1882 #ifdef HAVE_UNISTD_H
1883 #include <unistd.h>
1884 #endif
1885 #ifdef HAVE_TERMIOS_H
1886 #include <termios.h>
1887 #define TTY struct termios
1888 #else
1889 #ifdef HAVE_TERMIO_H
1890 #include <termio.h>
1891 #define TTY struct termio
1892 #endif
1893 #endif
1894 ],[
1895 TTY foo;
1896 tcgetattr(1, &foo);],
1897 [cf_cv_have_tcgetattr=yes],
1898 [cf_cv_have_tcgetattr=no])])
1899 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR,1,[Define to 1 if we have tcgetattr])
1900 ])dnl
1901 dnl ---------------------------------------------------------------------------
1902 dnl CF_FUNC_VSSCANF version: 6 updated: 2015/04/18 08:56:57
1903 dnl ---------------
1904 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1905 dnl versions of C.  It is in the GNU C library, and can often be simulated by
1906 dnl other functions.
1907 AC_DEFUN([CF_FUNC_VSSCANF],
1908 [
1909 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1910 AC_TRY_LINK([
1911 #include <stdarg.h>
1912 #include <stdio.h>],[
1913         va_list ap;
1914         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1915 AC_TRY_LINK([
1916 #include <stdarg.h>
1917 #include <stdio.h>],[
1918         FILE strbuf;
1919         char *str = "from";
1920
1921         strbuf._flag = _IOREAD;
1922         strbuf._ptr = strbuf._base = (unsigned char *) str;
1923         strbuf._cnt = strlen(str);
1924         strbuf._file = _NFILE;
1925         return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1926 AC_TRY_LINK([
1927 #include <stdarg.h>
1928 #include <stdio.h>],[
1929         FILE strbuf;
1930         char *str = "from";
1931
1932         strbuf._flag = _IOREAD;
1933         strbuf._ptr = strbuf._base = (unsigned char *) str;
1934         strbuf._cnt = strlen(str);
1935         strbuf._file = _NFILE;
1936         return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1937 cf_cv_func_vsscanf=no])])])])
1938
1939 case $cf_cv_func_vsscanf in
1940 (vsscanf) AC_DEFINE(HAVE_VSSCANF,1,[Define to 1 if we have vsscanf]);;
1941 (vfscanf) AC_DEFINE(HAVE_VFSCANF,1,[Define to 1 if we have vfscanf]);;
1942 (_doscan) AC_DEFINE(HAVE__DOSCAN,1,[Define to 1 if we have _doscan]);;
1943 esac
1944
1945 ])dnl
1946 dnl ---------------------------------------------------------------------------
1947 dnl CF_GCC_ATTRIBUTES version: 17 updated: 2015/04/12 15:39:00
1948 dnl -----------------
1949 dnl Test for availability of useful gcc __attribute__ directives to quiet
1950 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1951 dnl to documentation, unrecognized directives cause older compilers to barf.
1952 AC_DEFUN([CF_GCC_ATTRIBUTES],
1953 [
1954 if test "$GCC" = yes
1955 then
1956 cat > conftest.i <<EOF
1957 #ifndef GCC_PRINTF
1958 #define GCC_PRINTF 0
1959 #endif
1960 #ifndef GCC_SCANF
1961 #define GCC_SCANF 0
1962 #endif
1963 #ifndef GCC_NORETURN
1964 #define GCC_NORETURN /* nothing */
1965 #endif
1966 #ifndef GCC_UNUSED
1967 #define GCC_UNUSED /* nothing */
1968 #endif
1969 EOF
1970 if test "$GCC" = yes
1971 then
1972         AC_CHECKING([for $CC __attribute__ directives])
1973 cat > conftest.$ac_ext <<EOF
1974 #line __oline__ "${as_me:-configure}"
1975 #include "confdefs.h"
1976 #include "conftest.h"
1977 #include "conftest.i"
1978 #if     GCC_PRINTF
1979 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1980 #else
1981 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1982 #endif
1983 #if     GCC_SCANF
1984 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1985 #else
1986 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1987 #endif
1988 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1989 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1990 extern void foo(void) GCC_NORETURN;
1991 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1992 EOF
1993         cf_printf_attribute=no
1994         cf_scanf_attribute=no
1995         for cf_attribute in scanf printf unused noreturn
1996         do
1997                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1998                 cf_directive="__attribute__(($cf_attribute))"
1999                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
2000
2001                 case $cf_attribute in
2002                 (printf)
2003                         cf_printf_attribute=yes
2004                         cat >conftest.h <<EOF
2005 #define GCC_$cf_ATTRIBUTE 1
2006 EOF
2007                         ;;
2008                 (scanf)
2009                         cf_scanf_attribute=yes
2010                         cat >conftest.h <<EOF
2011 #define GCC_$cf_ATTRIBUTE 1
2012 EOF
2013                         ;;
2014                 (*)
2015                         cat >conftest.h <<EOF
2016 #define GCC_$cf_ATTRIBUTE $cf_directive
2017 EOF
2018                         ;;
2019                 esac
2020
2021                 if AC_TRY_EVAL(ac_compile); then
2022                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
2023                         cat conftest.h >>confdefs.h
2024                         case $cf_attribute in
2025                         (noreturn)
2026                                 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
2027                                 ;;
2028                         (printf)
2029                                 cf_value='/* nothing */'
2030                                 if test "$cf_printf_attribute" != no ; then
2031                                         cf_value='__attribute__((format(printf,fmt,var)))'
2032                                         AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
2033                                 fi
2034                                 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
2035                                 ;;
2036                         (scanf)
2037                                 cf_value='/* nothing */'
2038                                 if test "$cf_scanf_attribute" != no ; then
2039                                         cf_value='__attribute__((format(scanf,fmt,var)))'
2040                                         AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
2041                                 fi
2042                                 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
2043                                 ;;
2044                         (unused)
2045                                 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
2046                                 ;;
2047                         esac
2048                 fi
2049         done
2050 else
2051         fgrep define conftest.i >>confdefs.h
2052 fi
2053 rm -rf conftest*
2054 fi
2055 ])dnl
2056 dnl ---------------------------------------------------------------------------
2057 dnl CF_GCC_VERSION version: 7 updated: 2012/10/18 06:46:33
2058 dnl --------------
2059 dnl Find version of gcc
2060 AC_DEFUN([CF_GCC_VERSION],[
2061 AC_REQUIRE([AC_PROG_CC])
2062 GCC_VERSION=none
2063 if test "$GCC" = yes ; then
2064         AC_MSG_CHECKING(version of $CC)
2065         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.]].*//'`"
2066         test -z "$GCC_VERSION" && GCC_VERSION=unknown
2067         AC_MSG_RESULT($GCC_VERSION)
2068 fi
2069 ])dnl
2070 dnl ---------------------------------------------------------------------------
2071 dnl CF_GCC_WARNINGS version: 32 updated: 2015/04/12 15:39:00
2072 dnl ---------------
2073 dnl Check if the compiler supports useful warning options.  There's a few that
2074 dnl we don't use, simply because they're too noisy:
2075 dnl
2076 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
2077 dnl     -Wredundant-decls (system headers make this too noisy)
2078 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
2079 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
2080 dnl             is enabled for ncurses using "--enable-const".
2081 dnl     -pedantic
2082 dnl
2083 dnl Parameter:
2084 dnl     $1 is an optional list of gcc warning flags that a particular
2085 dnl             application might want to use, e.g., "no-unused" for
2086 dnl             -Wno-unused
2087 dnl Special:
2088 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
2089 dnl
2090 AC_DEFUN([CF_GCC_WARNINGS],
2091 [
2092 AC_REQUIRE([CF_GCC_VERSION])
2093 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
2094 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
2095
2096 cat > conftest.$ac_ext <<EOF
2097 #line __oline__ "${as_me:-configure}"
2098 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2099 EOF
2100
2101 if test "$INTEL_COMPILER" = yes
2102 then
2103 # The "-wdXXX" options suppress warnings:
2104 # remark #1419: external declaration in primary source file
2105 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2106 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2107 # remark #193: zero used for undefined preprocessing identifier
2108 # remark #593: variable "curs_sb_left_arrow" was set but never used
2109 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2110 # remark #869: parameter "tw" was never referenced
2111 # remark #981: operands are evaluated in unspecified order
2112 # warning #279: controlling expression is constant
2113
2114         AC_CHECKING([for $CC warning options])
2115         cf_save_CFLAGS="$CFLAGS"
2116         EXTRA_CFLAGS="-Wall"
2117         for cf_opt in \
2118                 wd1419 \
2119                 wd1683 \
2120                 wd1684 \
2121                 wd193 \
2122                 wd593 \
2123                 wd279 \
2124                 wd810 \
2125                 wd869 \
2126                 wd981
2127         do
2128                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
2129                 if AC_TRY_EVAL(ac_compile); then
2130                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2131                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
2132                 fi
2133         done
2134         CFLAGS="$cf_save_CFLAGS"
2135
2136 elif test "$GCC" = yes
2137 then
2138         AC_CHECKING([for $CC warning options])
2139         cf_save_CFLAGS="$CFLAGS"
2140         EXTRA_CFLAGS=
2141         cf_warn_CONST=""
2142         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
2143         cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
2144         test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
2145         for cf_opt in W Wall \
2146                 Wbad-function-cast \
2147                 Wcast-align \
2148                 Wcast-qual \
2149                 Wdeclaration-after-statement \
2150                 Wextra \
2151                 Winline \
2152                 Wmissing-declarations \
2153                 Wmissing-prototypes \
2154                 Wnested-externs \
2155                 Wpointer-arith \
2156                 Wshadow \
2157                 Wstrict-prototypes \
2158                 Wundef $cf_gcc_warnings $cf_warn_CONST $1
2159         do
2160                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
2161                 if AC_TRY_EVAL(ac_compile); then
2162                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2163                         case $cf_opt in
2164                         (Wcast-qual)
2165                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
2166                                 ;;
2167                         (Winline)
2168                                 case $GCC_VERSION in
2169                                 ([[34]].*)
2170                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
2171                                         continue;;
2172                                 esac
2173                                 ;;
2174                         (Wpointer-arith)
2175                                 case $GCC_VERSION in
2176                                 ([[12]].*)
2177                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
2178                                         continue;;
2179                                 esac
2180                                 ;;
2181                         esac
2182                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
2183                 fi
2184         done
2185         CFLAGS="$cf_save_CFLAGS"
2186 fi
2187 rm -rf conftest*
2188
2189 AC_SUBST(EXTRA_CFLAGS)
2190 ])dnl
2191 dnl ---------------------------------------------------------------------------
2192 dnl CF_GETOPT_HEADER version: 6 updated: 2014/07/22 14:45:54
2193 dnl ----------------
2194 dnl Check for getopt's variables which are commonly defined in stdlib.h,
2195 dnl unistd.h or (nonstandard) in getopt.h
2196 AC_DEFUN([CF_GETOPT_HEADER],
2197 [
2198 AC_HAVE_HEADERS(unistd.h getopt.h)
2199 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
2200 cf_cv_getopt_header=none
2201 for cf_header in stdio.h stdlib.h unistd.h getopt.h
2202 do
2203 AC_TRY_COMPILE([
2204 #include <$cf_header>],
2205 [int x = optind; char *y = optarg],
2206 [cf_cv_getopt_header=$cf_header
2207  break])
2208 done
2209 ])
2210 if test $cf_cv_getopt_header != none ; then
2211         AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
2212 fi
2213 if test $cf_cv_getopt_header = getopt.h ; then
2214         AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
2215 fi
2216 ])dnl
2217 dnl ---------------------------------------------------------------------------
2218 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
2219 dnl -----------------
2220 AC_DEFUN([CF_GNATPREP_OPT_T],[
2221 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
2222 cf_cv_gnatprep_opt_t=no
2223 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
2224 ])
2225 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
2226 AC_SUBST(GNATPREP_OPTS)
2227 ])dnl
2228 dnl ---------------------------------------------------------------------------
2229 dnl CF_GNAT_GENERICS version: 3 updated: 2015/04/17 21:13:04
2230 dnl ----------------
2231 AC_DEFUN([CF_GNAT_GENERICS],
2232 [
2233 AC_REQUIRE([CF_GNAT_VERSION])
2234
2235 AC_MSG_CHECKING(if GNAT supports generics)
2236 case $cf_gnat_version in
2237 (3.[[1-9]]*|[[4-9]].*)
2238         cf_gnat_generics=yes
2239         ;;
2240 (*)
2241         cf_gnat_generics=no
2242         ;;
2243 esac
2244 AC_MSG_RESULT($cf_gnat_generics)
2245
2246 if test "$cf_gnat_generics" = yes
2247 then
2248         cf_compile_generics=generics
2249         cf_generic_objects="\${GENOBJS}"
2250 else
2251         cf_compile_generics=
2252         cf_generic_objects=
2253 fi
2254
2255 AC_SUBST(cf_compile_generics)
2256 AC_SUBST(cf_generic_objects)
2257 ])dnl
2258 dnl ---------------------------------------------------------------------------
2259 dnl CF_GNAT_PROJECTS version: 8 updated: 2015/04/17 21:13:04
2260 dnl ----------------
2261 dnl GNAT projects are configured with ".gpr" project files.
2262 dnl GNAT libraries are a further development, using the project feature.
2263 AC_DEFUN([CF_GNAT_PROJECTS],
2264 [
2265 AC_REQUIRE([CF_GNAT_VERSION])
2266 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
2267
2268 cf_gnat_libraries=no
2269 cf_gnat_projects=no
2270
2271 if test "$enable_gnat_projects" != no ; then
2272 AC_MSG_CHECKING(if GNAT supports project files)
2273 case $cf_gnat_version in
2274 (3.[[0-9]]*)
2275         ;;
2276 (*)
2277         case $cf_cv_system_name in
2278         (cygwin*|msys*)
2279                 ;;
2280         (*)
2281                 mkdir conftest.src conftest.bin conftest.lib
2282                 cd conftest.src
2283                 rm -rf conftest* *~conftest*
2284                 cat >>library.gpr <<CF_EOF
2285 project Library is
2286   Kind := External ("LIB_KIND");
2287   for Library_Name use "ConfTest";
2288   for Object_Dir use ".";
2289   for Library_ALI_Dir use External("LIBRARY_DIR");
2290   for Library_Version use External ("SONAME");
2291   for Library_Kind use Kind;
2292   for Library_Dir use External("BUILD_DIR");
2293   Source_Dir := External ("SOURCE_DIR");
2294   for Source_Dirs use (Source_Dir);
2295 end Library;
2296 CF_EOF
2297                 cat >>confpackage.ads <<CF_EOF
2298 package ConfPackage is
2299    procedure conftest;
2300 end ConfPackage;
2301 CF_EOF
2302                 cat >>confpackage.adb <<CF_EOF
2303 with Text_IO;
2304 package body ConfPackage is
2305    procedure conftest is
2306    begin
2307       Text_IO.Put ("Hello World");
2308       Text_IO.New_Line;
2309    end conftest;
2310 end ConfPackage;
2311 CF_EOF
2312                 if ( $cf_ada_make $ADAFLAGS \
2313                                 -Plibrary.gpr \
2314                                 -XBUILD_DIR=`cd ../conftest.bin;pwd` \
2315                                 -XLIBRARY_DIR=`cd ../conftest.lib;pwd` \
2316                                 -XSOURCE_DIR=`pwd` \
2317                                 -XSONAME=libConfTest.so.1 \
2318                                 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
2319                         cf_gnat_projects=yes
2320                 fi
2321                 cd ..
2322                 if test -f conftest.lib/confpackage.ali
2323                 then
2324                         cf_gnat_libraries=yes
2325                 fi
2326                 rm -rf conftest* *~conftest*
2327                 ;;
2328         esac
2329         ;;
2330 esac
2331 AC_MSG_RESULT($cf_gnat_projects)
2332 fi # enable_gnat_projects
2333
2334 if test $cf_gnat_projects = yes
2335 then
2336         AC_MSG_CHECKING(if GNAT supports libraries)
2337         AC_MSG_RESULT($cf_gnat_libraries)
2338 fi
2339
2340 if test "$cf_gnat_projects" = yes
2341 then
2342         USE_OLD_MAKERULES="#"
2343         USE_GNAT_PROJECTS=""
2344 else
2345         USE_OLD_MAKERULES=""
2346         USE_GNAT_PROJECTS="#"
2347 fi
2348
2349 if test "$cf_gnat_libraries" = yes
2350 then
2351         USE_GNAT_LIBRARIES=""
2352 else
2353         USE_GNAT_LIBRARIES="#"
2354 fi
2355
2356 AC_SUBST(USE_OLD_MAKERULES)
2357 AC_SUBST(USE_GNAT_PROJECTS)
2358 AC_SUBST(USE_GNAT_LIBRARIES)
2359 ])dnl
2360 dnl ---------------------------------------------------------------------------
2361 dnl CF_GNAT_SIGINT version: 1 updated: 2011/03/27 20:07:59
2362 dnl --------------
2363 dnl Check if gnat supports SIGINT, and presumably tasking.  For the latter, it
2364 dnl is noted that gnat may compile a tasking unit even for configurations which
2365 dnl fail at runtime.
2366 AC_DEFUN([CF_GNAT_SIGINT],[
2367 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
2368 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
2369
2370 package ConfTest is
2371
2372    pragma Warnings (Off);  --  the next pragma exists since 3.11p
2373    pragma Unreserve_All_Interrupts;
2374    pragma Warnings (On);
2375
2376    protected Process is
2377       procedure Stop;
2378       function Continue return Boolean;
2379       pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
2380    private
2381       Done : Boolean := False;
2382    end Process;
2383
2384 end ConfTest;],
2385 [package body ConfTest is
2386    protected body Process is
2387       procedure Stop is
2388       begin
2389          Done := True;
2390       end Stop;
2391       function Continue return Boolean is
2392       begin
2393          return not Done;
2394       end Continue;
2395    end Process;
2396 end ConfTest;],
2397         [cf_cv_gnat_sigint=yes],
2398         [cf_cv_gnat_sigint=no])])
2399
2400 if test $cf_cv_gnat_sigint = yes ; then
2401         USE_GNAT_SIGINT=""
2402 else
2403         USE_GNAT_SIGINT="#"
2404 fi
2405 AC_SUBST(USE_GNAT_SIGINT)
2406 ])dnl
2407 dnl ---------------------------------------------------------------------------
2408 dnl CF_GNAT_TRY_LINK version: 3 updated: 2011/03/19 14:47:45
2409 dnl ----------------
2410 dnl Verify that a test program compiles/links with GNAT.
2411 dnl $cf_ada_make is set to the program that compiles/links
2412 dnl $ADAFLAGS may be set to the GNAT flags.
2413 dnl
2414 dnl $1 is the text of the spec
2415 dnl $2 is the text of the body
2416 dnl $3 is the shell command to execute if successful
2417 dnl $4 is the shell command to execute if not successful
2418 AC_DEFUN([CF_GNAT_TRY_LINK],
2419 [
2420 rm -rf conftest* *~conftest*
2421 cat >>conftest.ads <<CF_EOF
2422 $1
2423 CF_EOF
2424 cat >>conftest.adb <<CF_EOF
2425 $2
2426 CF_EOF
2427 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
2428 ifelse($3,,      :,[      $3])
2429 ifelse($4,,,[else
2430    $4])
2431 fi
2432 rm -rf conftest* *~conftest*
2433 ])dnl
2434 dnl ---------------------------------------------------------------------------
2435 dnl CF_GNAT_TRY_RUN version: 5 updated: 2011/03/19 14:47:45
2436 dnl ---------------
2437 dnl Verify that a test program compiles and runs with GNAT
2438 dnl $cf_ada_make is set to the program that compiles/links
2439 dnl $ADAFLAGS may be set to the GNAT flags.
2440 dnl
2441 dnl $1 is the text of the spec
2442 dnl $2 is the text of the body
2443 dnl $3 is the shell command to execute if successful
2444 dnl $4 is the shell command to execute if not successful
2445 AC_DEFUN([CF_GNAT_TRY_RUN],
2446 [
2447 rm -rf conftest* *~conftest*
2448 cat >>conftest.ads <<CF_EOF
2449 $1
2450 CF_EOF
2451 cat >>conftest.adb <<CF_EOF
2452 $2
2453 CF_EOF
2454 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
2455    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
2456 ifelse($3,,      :,[      $3])
2457 ifelse($4,,,[   else
2458       $4])
2459    fi
2460 ifelse($4,,,[else
2461    $4])
2462 fi
2463 rm -rf conftest* *~conftest*
2464 ])dnl
2465 dnl ---------------------------------------------------------------------------
2466 dnl CF_GNAT_VERSION version: 20 updated: 2015/04/18 08:56:57
2467 dnl ---------------
2468 dnl Verify version of GNAT.
2469 AC_DEFUN([CF_GNAT_VERSION],
2470 [
2471 AC_MSG_CHECKING(for gnat version)
2472 cf_gnat_version=`${cf_ada_make:-gnatmake} -v 2>&1 | \
2473         grep '[[0-9]].[[0-9]][[0-9]]*' |\
2474         sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
2475 AC_MSG_RESULT($cf_gnat_version)
2476
2477 case $cf_gnat_version in
2478 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|20[[0-9]][[0-9]])
2479         cf_cv_prog_gnat_correct=yes
2480         ;;
2481 (*)
2482         AC_MSG_WARN(Unsupported GNAT version $cf_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
2483         cf_cv_prog_gnat_correct=no
2484         ;;
2485 esac
2486 ])
2487 dnl ---------------------------------------------------------------------------
2488 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
2489 dnl -------------
2490 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
2491 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
2492 dnl (or misfeature) of glibc2, which breaks portability of many applications,
2493 dnl since it is interwoven with GNU extensions.
2494 dnl
2495 dnl Well, yes we could work around it...
2496 AC_DEFUN([CF_GNU_SOURCE],
2497 [
2498 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
2499 AC_TRY_COMPILE([#include <sys/types.h>],[
2500 #ifndef _XOPEN_SOURCE
2501 make an error
2502 #endif],
2503         [cf_cv_gnu_source=no],
2504         [cf_save="$CPPFLAGS"
2505          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
2506          AC_TRY_COMPILE([#include <sys/types.h>],[
2507 #ifdef _XOPEN_SOURCE
2508 make an error
2509 #endif],
2510         [cf_cv_gnu_source=no],
2511         [cf_cv_gnu_source=yes])
2512         CPPFLAGS="$cf_save"
2513         ])
2514 ])
2515 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
2516 ])dnl
2517 dnl ---------------------------------------------------------------------------
2518 dnl CF_GPP_LIBRARY version: 12 updated: 2015/04/17 21:13:04
2519 dnl --------------
2520 dnl If we're trying to use g++, test if libg++ is installed (a rather common
2521 dnl problem :-).  If we have the compiler but no library, we'll be able to
2522 dnl configure, but won't be able to build the c++ demo program.
2523 AC_DEFUN([CF_GPP_LIBRARY],
2524 [
2525 cf_cxx_library=unknown
2526 case $cf_cv_system_name in
2527 (os2*)
2528         cf_gpp_libname=gpp
2529         ;;
2530 (*)
2531         cf_gpp_libname=g++
2532         ;;
2533 esac
2534 if test "$GXX" = yes; then
2535         AC_MSG_CHECKING([for lib$cf_gpp_libname])
2536         cf_save="$LIBS"
2537         CF_ADD_LIB($cf_gpp_libname)
2538         AC_TRY_LINK([
2539 #include <$cf_gpp_libname/builtin.h>
2540         ],
2541         [two_arg_error_handler_t foo2 = lib_error_handler],
2542         [cf_cxx_library=yes
2543          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
2544          if test "$cf_gpp_libname" = cpp ; then
2545             AC_DEFINE(HAVE_GPP_BUILTIN_H,1,[Define to 1 if we have gpp builtin.h])
2546          else
2547             AC_DEFINE(HAVE_GXX_BUILTIN_H,1,[Define to 1 if we have g++ builtin.h])
2548          fi],
2549         [AC_TRY_LINK([
2550 #include <builtin.h>
2551         ],
2552         [two_arg_error_handler_t foo2 = lib_error_handler],
2553         [cf_cxx_library=yes
2554          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
2555          AC_DEFINE(HAVE_BUILTIN_H,1,[Define to 1 if we have builtin.h])],
2556         [cf_cxx_library=no])])
2557         LIBS="$cf_save"
2558         AC_MSG_RESULT($cf_cxx_library)
2559 fi
2560 ])dnl
2561 dnl ---------------------------------------------------------------------------
2562 dnl CF_GXX_VERSION version: 7 updated: 2012/06/16 14:55:39
2563 dnl --------------
2564 dnl Check for version of g++
2565 AC_DEFUN([CF_GXX_VERSION],[
2566 AC_REQUIRE([AC_PROG_CPP])
2567 GXX_VERSION=none
2568 if test "$GXX" = yes; then
2569         AC_MSG_CHECKING(version of ${CXX:-g++})
2570         GXX_VERSION="`${CXX:-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
2571         test -z "$GXX_VERSION" && GXX_VERSION=unknown
2572         AC_MSG_RESULT($GXX_VERSION)
2573 fi
2574 ])dnl
2575 dnl ---------------------------------------------------------------------------
2576 dnl CF_GXX_WARNINGS version: 9 updated: 2015/04/17 21:13:04
2577 dnl ---------------
2578 dnl Check if the compiler supports useful warning options.
2579 dnl
2580 dnl Most of gcc's options apply to g++, except:
2581 dnl     -Wbad-function-cast
2582 dnl     -Wmissing-declarations
2583 dnl     -Wnested-externs
2584 dnl
2585 dnl Omit a few (for now):
2586 dnl     -Winline
2587 dnl
2588 dnl Parameter:
2589 dnl     $1 is an optional list of g++ warning flags that a particular
2590 dnl             application might want to use, e.g., "no-unused" for
2591 dnl             -Wno-unused
2592 dnl Special:
2593 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
2594 dnl
2595 AC_DEFUN([CF_GXX_WARNINGS],
2596 [
2597
2598 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
2599 CF_CLANG_COMPILER(GXX,CLANG_CPLUSPLUS,CXXFLAGS)
2600
2601 AC_REQUIRE([CF_GXX_VERSION])
2602
2603 AC_LANG_SAVE
2604 AC_LANG_CPLUSPLUS
2605
2606 cat > conftest.$ac_ext <<EOF
2607 #line __oline__ "configure"
2608 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2609 EOF
2610
2611 if test "$INTEL_CPLUSPLUS" = yes
2612 then
2613 # The "-wdXXX" options suppress warnings:
2614 # remark #1419: external declaration in primary source file
2615 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2616 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2617 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2618 # remark #193: zero used for undefined preprocessing identifier
2619 # remark #593: variable "curs_sb_left_arrow" was set but never used
2620 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2621 # remark #869: parameter "tw" was never referenced
2622 # remark #981: operands are evaluated in unspecified order
2623 # warning #269: invalid format string conversion
2624
2625         AC_CHECKING([for $CC warning options])
2626         cf_save_CXXFLAGS="$CXXFLAGS"
2627         EXTRA_CXXFLAGS="-Wall"
2628         for cf_opt in \
2629                 wd1419 \
2630                 wd1682 \
2631                 wd1683 \
2632                 wd1684 \
2633                 wd193 \
2634                 wd279 \
2635                 wd593 \
2636                 wd810 \
2637                 wd869 \
2638                 wd981
2639         do
2640                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
2641                 if AC_TRY_EVAL(ac_compile); then
2642                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2643                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2644                 fi
2645         done
2646         CXXFLAGS="$cf_save_CXXFLAGS"
2647
2648 elif test "$GXX" = yes
2649 then
2650         AC_CHECKING([for $CXX warning options])
2651         cf_save_CXXFLAGS="$CXXFLAGS"
2652         EXTRA_CXXFLAGS="-W -Wall"
2653         cf_gxx_extra_warnings=""
2654         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
2655         case "$GCC_VERSION" in
2656         ([[1-2]].*)
2657                 ;;
2658         (*)
2659                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
2660                 ;;
2661         esac
2662         for cf_opt in \
2663                 Wabi \
2664                 fabi-version=0 \
2665                 Wextra \
2666                 Wignored-qualifiers \
2667                 Wlogical-op \
2668                 Woverloaded-virtual \
2669                 Wsign-promo \
2670                 Wsynth \
2671                 Wold-style-cast \
2672                 Wcast-align \
2673                 Wcast-qual \
2674                 Wpointer-arith \
2675                 Wshadow \
2676                 Wundef $cf_gxx_extra_warnings $1
2677         do
2678                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
2679                 if AC_TRY_EVAL(ac_compile); then
2680                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2681                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2682                 else
2683                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
2684                 fi
2685         done
2686         CXXFLAGS="$cf_save_CXXFLAGS"
2687 fi
2688
2689 rm -rf conftest*
2690 AC_LANG_RESTORE
2691 AC_SUBST(EXTRA_CXXFLAGS)
2692 ])dnl
2693 dnl ---------------------------------------------------------------------------
2694 dnl CF_HASHED_DB version: 7 updated: 2015/04/18 08:56:57
2695 dnl ------------
2696 dnl Look for an instance of the Berkeley hashed database.
2697 dnl
2698 dnl $1 = optional parameter, to specify install-prefix for the database.
2699 AC_DEFUN([CF_HASHED_DB],
2700 [
2701 ifelse([$1],,,[
2702 case $1 in
2703 (yes|*able*)
2704         ;;
2705 (*)
2706         if test -d "$1" ; then
2707                 CF_ADD_INCDIR($1/include)
2708                 CF_ADD_LIBDIR($1/lib)
2709         else
2710                 case "$1" in
2711                 (./*|../*|/*)
2712                         AC_MSG_WARN(no such directory $1)
2713                         ;;
2714                 (*)
2715                         CF_FIND_SUB_INCDIR($1)
2716                         CF_FIND_SUB_LIBDIR($1)
2717                         ;;
2718                 esac
2719         fi
2720 esac
2721 ])
2722 AC_CHECK_HEADER(db.h,[
2723 CF_HASHED_DB_VERSION
2724 if test "$cf_cv_hashed_db_version" = unknown ; then
2725         AC_MSG_ERROR(Cannot determine version of db)
2726 else
2727         CF_HASHED_DB_LIBS
2728         if test "$cf_cv_hashed_db_libs" = unknown ; then
2729                 AC_MSG_ERROR(Cannot determine library for db)
2730         elif test "$cf_cv_hashed_db_libs" != default ; then
2731                 CF_ADD_LIB($cf_cv_hashed_db_libs)
2732         fi
2733 fi
2734 ],[
2735         AC_MSG_ERROR(Cannot find db.h)
2736 ])
2737 ])dnl
2738 dnl ---------------------------------------------------------------------------
2739 dnl CF_HASHED_DB_LIBS version: 9 updated: 2010/05/29 16:31:02
2740 dnl -----------------
2741 dnl Given that we have the header and version for hashed database, find the
2742 dnl library information.
2743 AC_DEFUN([CF_HASHED_DB_LIBS],
2744 [
2745 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
2746 cf_cv_hashed_db_libs=unknown
2747 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
2748 do
2749         cf_save_libs="$LIBS"
2750         if test -n "$cf_db_libs"; then
2751                 CF_ADD_LIB($cf_db_libs)
2752         fi
2753         CF_MSG_LOG(checking for library "$cf_db_libs")
2754         AC_TRY_LINK([
2755 $ac_includes_default
2756 #include <db.h>
2757 ],[
2758         char *path = "/tmp/foo";
2759 #ifdef DB_VERSION_MAJOR
2760 #if DB_VERSION_MAJOR >= 4
2761         DB *result = 0;
2762         db_create(&result, NULL, 0);
2763         result->open(result,
2764                 NULL,
2765                 path,
2766                 path,
2767                 DB_HASH,
2768                 DB_CREATE,
2769                 0644);
2770 #elif DB_VERSION_MAJOR >= 3
2771         DB *result = 0;
2772         db_create(&result, NULL, 0);
2773         result->open(result,
2774                 path,
2775                 path,
2776                 DB_HASH,
2777                 DB_CREATE,
2778                 0644);
2779 #elif DB_VERSION_MAJOR >= 2
2780         DB *result = 0;
2781         db_open(path,
2782                 DB_HASH,
2783                 DB_CREATE,
2784                 0644,
2785                 (DB_ENV *) 0,
2786                 (DB_INFO *) 0,
2787                 &result);
2788 #endif /* DB_VERSION_MAJOR */
2789 #else
2790         DB *result = dbopen(path,
2791                      2,
2792                      0644,
2793                      DB_HASH,
2794                      0);
2795 #endif
2796         ${cf_cv_main_return:-return}(result != 0)
2797 ],[
2798         if test -n "$cf_db_libs" ; then
2799                 cf_cv_hashed_db_libs=$cf_db_libs
2800         else
2801                 cf_cv_hashed_db_libs=default
2802         fi
2803         LIBS="$cf_save_libs"
2804         break
2805 ])
2806         LIBS="$cf_save_libs"
2807 done
2808 ])
2809 ])dnl
2810 dnl ---------------------------------------------------------------------------
2811 dnl CF_HASHED_DB_VERSION version: 4 updated: 2014/04/12 16:47:01
2812 dnl --------------------
2813 dnl Given that we have the header file for hashed database, find the version
2814 dnl information.
2815 AC_DEFUN([CF_HASHED_DB_VERSION],
2816 [
2817 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
2818 cf_cv_hashed_db_version=unknown
2819
2820 for cf_db_version in 1 2 3 4 5 6
2821 do
2822         CF_MSG_LOG(checking for db version $cf_db_version)
2823         AC_TRY_COMPILE([
2824 $ac_includes_default
2825 #include <db.h>
2826
2827 #ifdef DB_VERSION_MAJOR
2828         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
2829 #if $cf_db_version == DB_VERSION_MAJOR
2830         /* ok */
2831 #else
2832         make an error
2833 #endif
2834 #else
2835 #if $cf_db_version == 1
2836         /* ok: assuming this is DB 1.8.5 */
2837 #else
2838         make an error
2839 #endif
2840 #endif
2841 ],[DBT *foo = 0],[
2842         cf_cv_hashed_db_version=$cf_db_version
2843         break
2844         ])
2845 done
2846 ])
2847 ])dnl
2848 dnl ---------------------------------------------------------------------------
2849 dnl CF_HEADER_PATH version: 13 updated: 2015/04/15 19:08:48
2850 dnl --------------
2851 dnl Construct a search-list of directories for a nonstandard header-file
2852 dnl
2853 dnl Parameters
2854 dnl     $1 = the variable to return as result
2855 dnl     $2 = the package name
2856 AC_DEFUN([CF_HEADER_PATH],
2857 [
2858 $1=
2859
2860 # collect the current set of include-directories from compiler flags
2861 cf_header_path_list=""
2862 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2863         for cf_header_path in $CPPFLAGS $CFLAGS
2864         do
2865                 case $cf_header_path in
2866                 (-I*)
2867                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2868                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2869                         cf_header_path_list="$cf_header_path_list [$]$1"
2870                         ;;
2871                 esac
2872         done
2873 fi
2874
2875 # add the variations for the package we are looking for
2876 CF_SUBDIR_PATH($1,$2,include)
2877
2878 test "$includedir" != NONE && \
2879 test "$includedir" != "/usr/include" && \
2880 test -d "$includedir" && {
2881         test -d $includedir &&    $1="[$]$1 $includedir"
2882         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
2883 }
2884
2885 test "$oldincludedir" != NONE && \
2886 test "$oldincludedir" != "/usr/include" && \
2887 test -d "$oldincludedir" && {
2888         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
2889         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
2890 }
2891
2892 $1="[$]$1 $cf_header_path_list"
2893 ])dnl
2894 dnl ---------------------------------------------------------------------------
2895 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
2896 dnl ---------------
2897 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2898 AC_DEFUN([CF_HELP_MESSAGE],
2899 [AC_DIVERT_HELP([$1])dnl
2900 ])dnl
2901 dnl ---------------------------------------------------------------------------
2902 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
2903 dnl ---------------
2904 dnl Construct the list of include-options according to whether we're building
2905 dnl in the source directory or using '--srcdir=DIR' option.
2906 AC_DEFUN([CF_INCLUDE_DIRS],
2907 [
2908 if test "$srcdir" != "."; then
2909         CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
2910 fi
2911 CPPFLAGS="-I../include $CPPFLAGS"
2912 if test "$srcdir" != "."; then
2913         CPPFLAGS="-I\${srcdir} $CPPFLAGS"
2914 fi
2915 CPPFLAGS="-I. $CPPFLAGS"
2916 AC_SUBST(CPPFLAGS)
2917 ])dnl
2918 dnl ---------------------------------------------------------------------------
2919 dnl CF_INTEL_COMPILER version: 7 updated: 2015/04/12 15:39:00
2920 dnl -----------------
2921 dnl Check if the given compiler is really the Intel compiler for Linux.  It
2922 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2923 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2924 dnl
2925 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2926 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
2927 dnl the wrappers for gcc and g++ warnings.
2928 dnl
2929 dnl $1 = GCC (default) or GXX
2930 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2931 dnl $3 = CFLAGS (default) or CXXFLAGS
2932 AC_DEFUN([CF_INTEL_COMPILER],[
2933 AC_REQUIRE([AC_CANONICAL_HOST])
2934 ifelse([$2],,INTEL_COMPILER,[$2])=no
2935
2936 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2937         case $host_os in
2938         (linux*|gnu*)
2939                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2940                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2941                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2942                 AC_TRY_COMPILE([],[
2943 #ifdef __INTEL_COMPILER
2944 #else
2945 make an error
2946 #endif
2947 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2948 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2949 ],[])
2950                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2951                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2952                 ;;
2953         esac
2954 fi
2955 ])dnl
2956 dnl ---------------------------------------------------------------------------
2957 dnl CF_ISASCII version: 4 updated: 2012/10/06 17:56:13
2958 dnl ----------
2959 dnl Check if we have either a function or macro for 'isascii()'.
2960 AC_DEFUN([CF_ISASCII],
2961 [
2962 AC_MSG_CHECKING(for isascii)
2963 AC_CACHE_VAL(cf_cv_have_isascii,[
2964         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
2965         [cf_cv_have_isascii=yes],
2966         [cf_cv_have_isascii=no])
2967 ])dnl
2968 AC_MSG_RESULT($cf_cv_have_isascii)
2969 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII,1,[Define to 1 if we have isascii()])
2970 ])dnl
2971 dnl ---------------------------------------------------------------------------
2972 dnl CF_LARGEFILE version: 9 updated: 2015/04/18 08:56:57
2973 dnl ------------
2974 dnl Add checks for large file support.
2975 AC_DEFUN([CF_LARGEFILE],[
2976 ifdef([AC_FUNC_FSEEKO],[
2977         AC_SYS_LARGEFILE
2978         if test "$enable_largefile" != no ; then
2979         AC_FUNC_FSEEKO
2980
2981         # Normally we would collect these definitions in the config.h,
2982         # but (like _XOPEN_SOURCE), some environments rely on having these
2983         # defined before any of the system headers are included.  Another
2984         # case comes up with C++, e.g., on AIX the compiler compiles the
2985         # header files by themselves before looking at the body files it is
2986         # told to compile.  For ncurses, those header files do not include
2987         # the config.h
2988         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
2989         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
2990         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
2991
2992         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2993                 AC_TRY_COMPILE([
2994 #include <sys/types.h>
2995 #include <dirent.h>
2996                 ],[
2997                 /* if transitional largefile support is setup, this is true */
2998                 extern struct dirent64 * readdir(DIR *);
2999                 struct dirent64 *x = readdir((DIR *)0);
3000                 struct dirent *y = readdir((DIR *)0);
3001                 int z = x - y;
3002                 ],
3003                 [cf_cv_struct_dirent64=yes],
3004                 [cf_cv_struct_dirent64=no])
3005         ])
3006         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64])
3007         fi
3008 ])
3009 ])
3010 dnl ---------------------------------------------------------------------------
3011 dnl CF_LDFLAGS_STATIC version: 12 updated: 2015/04/18 08:56:57
3012 dnl -----------------
3013 dnl Check for compiler/linker flags used to temporarily force usage of static
3014 dnl libraries.  This depends on the compiler and platform.  Use this to help
3015 dnl ensure that the linker picks up a given library based on its position in
3016 dnl the list of linker options and libraries.
3017 AC_DEFUN([CF_LDFLAGS_STATIC],[
3018
3019 if test "$GCC" = yes ; then
3020         case $cf_cv_system_name in
3021         (OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*)
3022                 LDFLAGS_STATIC=
3023                 LDFLAGS_SHARED=
3024                 ;;
3025         (*)     # normally, except when broken
3026                 LDFLAGS_STATIC=-static
3027                 LDFLAGS_SHARED=-dynamic
3028                 ;;
3029         esac
3030 else
3031         case $cf_cv_system_name in
3032         (aix[[4-7]]*)   # from ld manpage
3033                 LDFLAGS_STATIC=-bstatic
3034                 LDFLAGS_SHARED=-bdynamic
3035                 ;;
3036         (hpux*)         # from ld manpage for hpux10.20, hpux11.11
3037                 # We could also use just "archive" and "shared".
3038                 LDFLAGS_STATIC=-Wl,-a,archive_shared
3039                 LDFLAGS_SHARED=-Wl,-a,shared_archive
3040                 ;;
3041         (irix*)         # from ld manpage IRIX64
3042                 LDFLAGS_STATIC=-Bstatic
3043                 LDFLAGS_SHARED=-Bdynamic
3044                 ;;
3045         (osf[[45]]*)    # from ld manpage osf4.0d, osf5.1
3046                 # alternative "-oldstyle_liblookup" (not in cc manpage)
3047                 LDFLAGS_STATIC=-noso
3048                 LDFLAGS_SHARED=-so_archive
3049                 ;;
3050         (solaris2*)
3051                 LDFLAGS_STATIC=-Bstatic
3052                 LDFLAGS_SHARED=-Bdynamic
3053                 ;;
3054         esac
3055 fi
3056
3057 if test -n "$LDFLAGS_STATIC" && test -n "$LDFLAGS_SHARED"
3058 then
3059         AC_MSG_CHECKING(if linker supports switching between static/dynamic)
3060
3061         rm -f libconftest.a
3062         cat >conftest.$ac_ext <<EOF
3063 #line __oline__ "configure"
3064 #include <stdio.h>
3065 int cf_ldflags_static(FILE *fp) { return fflush(fp); }
3066 EOF
3067         if AC_TRY_EVAL(ac_compile) ; then
3068                 ( $AR $ARFLAGS libconftest.a conftest.o ) 2>&AC_FD_CC 1>/dev/null
3069                 ( eval $RANLIB libconftest.a ) 2>&AC_FD_CC >/dev/null
3070         fi
3071         rm -f conftest.*
3072
3073         cf_save_LIBS="$LIBS"
3074
3075         LIBS="$LDFLAGS_STATIC -L`pwd` -lconftest $LDFLAGS_DYNAMIC $LIBS"
3076         AC_TRY_LINK([
3077 #line __oline__ "configure"
3078 #include <stdio.h>
3079 int cf_ldflags_static(FILE *fp);
3080 ],[
3081         return cf_ldflags_static(stdin);
3082 ],[
3083         # some linkers simply ignore the -dynamic
3084         case x`file conftest$ac_exeext 2>/dev/null` in
3085         (*static*)
3086                 cf_ldflags_static=no
3087                 ;;
3088         (*)
3089                 cf_ldflags_static=yes
3090                 ;;
3091         esac
3092 ],[cf_ldflags_static=no])
3093
3094         rm -f libconftest.*
3095         LIBS="$cf_save_LIBS"
3096
3097         AC_MSG_RESULT($cf_ldflags_static)
3098
3099         if test $cf_ldflags_static != yes
3100         then
3101                 LDFLAGS_STATIC=
3102                 LDFLAGS_SHARED=
3103         fi
3104 else
3105         LDFLAGS_STATIC=
3106         LDFLAGS_SHARED=
3107 fi
3108
3109 AC_SUBST(LDFLAGS_STATIC)
3110 AC_SUBST(LDFLAGS_SHARED)
3111 ])
3112 dnl ---------------------------------------------------------------------------
3113 dnl CF_LD_RPATH_OPT version: 6 updated: 2015/04/12 15:39:00
3114 dnl ---------------
3115 dnl For the given system and compiler, find the compiler flags to pass to the
3116 dnl loader to use the "rpath" feature.
3117 AC_DEFUN([CF_LD_RPATH_OPT],
3118 [
3119 AC_REQUIRE([CF_CHECK_CACHE])
3120
3121 LD_RPATH_OPT=
3122 AC_MSG_CHECKING(for an rpath option)
3123 case $cf_cv_system_name in
3124 (irix*)
3125         if test "$GCC" = yes; then
3126                 LD_RPATH_OPT="-Wl,-rpath,"
3127         else
3128                 LD_RPATH_OPT="-rpath "
3129         fi
3130         ;;
3131 (linux*|gnu*|k*bsd*-gnu)
3132         LD_RPATH_OPT="-Wl,-rpath,"
3133         ;;
3134 (openbsd[[2-9]].*|mirbsd*)
3135         LD_RPATH_OPT="-Wl,-rpath,"
3136         ;;
3137 (dragonfly*|freebsd*)
3138         LD_RPATH_OPT="-rpath "
3139         ;;
3140 (netbsd*)
3141         LD_RPATH_OPT="-Wl,-rpath,"
3142         ;;
3143 (osf*|mls+*)
3144         LD_RPATH_OPT="-rpath "
3145         ;;
3146 (solaris2*)
3147         LD_RPATH_OPT="-R"
3148         ;;
3149 (*)
3150         ;;
3151 esac
3152 AC_MSG_RESULT($LD_RPATH_OPT)
3153
3154 case "x$LD_RPATH_OPT" in
3155 (x-R*)
3156         AC_MSG_CHECKING(if we need a space after rpath option)
3157         cf_save_LIBS="$LIBS"
3158         CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
3159         AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
3160         LIBS="$cf_save_LIBS"
3161         AC_MSG_RESULT($cf_rpath_space)
3162         test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
3163         ;;
3164 esac
3165 ])dnl
3166 dnl ---------------------------------------------------------------------------
3167 dnl CF_LIBRARY_PATH version: 10 updated: 2015/04/15 19:08:48
3168 dnl ---------------
3169 dnl Construct a search-list of directories for a nonstandard library-file
3170 dnl
3171 dnl Parameters
3172 dnl     $1 = the variable to return as result
3173 dnl     $2 = the package name
3174 AC_DEFUN([CF_LIBRARY_PATH],
3175 [
3176 $1=
3177 cf_library_path_list=""
3178 if test -n "${LDFLAGS}${LIBS}" ; then
3179         for cf_library_path in $LDFLAGS $LIBS
3180         do
3181                 case $cf_library_path in
3182                 (-L*)
3183                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
3184                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
3185                         cf_library_path_list="$cf_library_path_list [$]$1"
3186                         ;;
3187                 esac
3188         done
3189 fi
3190
3191 CF_SUBDIR_PATH($1,$2,lib)
3192
3193 $1="$cf_library_path_list [$]$1"
3194 ])dnl
3195 dnl ---------------------------------------------------------------------------
3196 dnl CF_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09
3197 dnl ------------------
3198 AC_DEFUN([CF_LIBTOOL_VERSION],[
3199 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
3200 then
3201         cf_cv_libtool_version=`$LIBTOOL --version 2>&1 | sed -e '/^$/d' |sed -e '2,$d' -e 's/([[^)]]*)//g' -e 's/^[[^1-9]]*//' -e 's/[[^0-9.]].*//'`
3202 else
3203         cf_cv_libtool_version=
3204 fi
3205 test -z "$cf_cv_libtool_version" && unset cf_cv_libtool_version
3206 ])dnl
3207 dnl ---------------------------------------------------------------------------
3208 dnl CF_LIB_PREFIX version: 11 updated: 2015/04/18 08:56:57
3209 dnl -------------
3210 dnl Compute the library-prefix for the given host system
3211 dnl $1 = variable to set
3212 define([CF_LIB_PREFIX],
3213 [
3214         case $cf_cv_system_name in
3215         (OS/2*|os2*)
3216                 LIB_PREFIX=''
3217                 ;;
3218         (*)     LIB_PREFIX='lib'
3219                 ;;
3220         esac
3221 ifelse($1,,,[$1=$LIB_PREFIX])
3222         AC_SUBST(LIB_PREFIX)
3223 ])dnl
3224 dnl ---------------------------------------------------------------------------
3225 dnl CF_LIB_RULES version: 81 updated: 2015/04/30 20:30:18
3226 dnl ------------
3227 dnl Append definitions and rules for the given models to the subdirectory
3228 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
3229 dnl subdirectory is a library-source directory, modify the Libs_To_Make list in
3230 dnl the corresponding makefile to list the models that we'll generate.
3231 dnl
3232 dnl For shared libraries, make a list of symbolic links to construct when
3233 dnl generating each library.  The convention used for Linux is the simplest
3234 dnl one:
3235 dnl     lib<name>.so    ->
3236 dnl     lib<name>.so.<major>    ->
3237 dnl     lib<name>.so.<maj>.<minor>
3238 dnl
3239 dnl Note: Libs_To_Make is mixed case, since it is not a pure autoconf variable.
3240 AC_DEFUN([CF_LIB_RULES],
3241 [
3242 cf_prefix=$LIB_PREFIX
3243 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
3244
3245 case $cf_cv_shlib_version in
3246 (cygdll|msysdll|mingw)
3247         TINFO_NAME=$TINFO_ARG_SUFFIX
3248         TINFO_SUFFIX=.dll
3249         ;;
3250 esac
3251
3252 if test -n "$TINFO_SUFFIX" ; then
3253         case $TINFO_SUFFIX in
3254         (tw*)
3255                 TINFO_NAME="${TINFO_NAME}tw${EXTRA_SUFFIX}"
3256                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^tw'$EXTRA_SUFFIX'//'`
3257                 ;;
3258         (t*)
3259                 TINFO_NAME="${TINFO_NAME}t${EXTRA_SUFFIX}"
3260                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^t'$EXTRA_SUFFIX'//'`
3261                 ;;
3262         (w*)
3263                 TINFO_NAME="${TINFO_NAME}w${EXTRA_SUFFIX}"
3264                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^w'$EXTRA_SUFFIX'//'`
3265                 ;;
3266         esac
3267 fi
3268
3269 for cf_dir in $SRC_SUBDIRS
3270 do
3271         if test ! -d $srcdir/$cf_dir ; then
3272                 continue
3273         elif test -f $srcdir/$cf_dir/modules; then
3274
3275                 SHARED_LIB=
3276                 Libs_To_Make=
3277
3278                 cf_sed_options=
3279                 if test -n "${cf_cv_abi_version}" && test "x${cf_cv_abi_version}" != "x5"
3280                 then
3281                         cf_sed_options="$cf_sed_options -e \"s/NCURSES\\([[WT]]\\+\\)\?_/NCURSES\\1${cf_cv_abi_version}_/g\""
3282                 fi
3283
3284                 if test "x$WILDCARD_SYMS" = xno
3285                 then
3286                         cf_sed_options="$cf_sed_options -e \"s/_\*;//g\""
3287                 fi
3288
3289                 if test "x$cf_sed_options" != "x"
3290                 then
3291                         cat >>$cf_dir/Makefile <<CF_EOF
3292
3293 # Generated by CF_LIB_RULES
3294 resulting.map: $UNALTERED_SYMS
3295         sed $cf_sed_options < $UNALTERED_SYMS >\[$]@
3296
3297 clean::
3298         rm -f resulting.map
3299 CF_EOF
3300                 fi
3301
3302                 for cf_item in $cf_LIST_MODELS
3303                 do
3304                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
3305                         cf_libname=$cf_dir
3306                         test "$cf_dir" = c++ && cf_libname=ncurses++
3307                         if test $cf_item = shared ; then
3308                                 if test -n "${LIB_SUFFIX}"
3309                                 then
3310                                         cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${USE_LIB_SUFFIX}"'//'`
3311                                 else
3312                                         cf_shared_suffix="$cf_suffix"
3313                                 fi
3314                                 if test "$cf_cv_do_symlinks" = yes ; then
3315                                         cf_version_name=
3316
3317                                         case "$cf_cv_shlib_version" in
3318                                         (rel)
3319                                                 cf_version_name=REL_VERSION
3320                                                 ;;
3321                                         (abi)
3322                                                 cf_version_name=ABI_VERSION
3323                                                 ;;
3324                                         esac
3325
3326                                         if test -n "$cf_version_name"
3327                                         then
3328                                                 case "$cf_cv_system_name" in
3329                                                 (darwin*)
3330                                                         # "w", etc?
3331                                                         cf_suffix="${USE_LIB_SUFFIX}"'.${'$cf_version_name'}'"$cf_shared_suffix"
3332                                                         ;;
3333                                                 (*)
3334                                                         cf_suffix="$cf_suffix"'.${'$cf_version_name'}'
3335                                                         ;;
3336                                                 esac
3337                                         fi
3338                                         if test -n "${USE_LIB_SUFFIX}"
3339                                         then
3340                                                 cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${USE_LIB_SUFFIX}"'//'`
3341                                         else
3342                                                 cf_shared_suffix="$cf_suffix"
3343                                         fi
3344                                 fi
3345                                 # cygwin needs import library, and has unique naming convention
3346                                 # use autodetected ${cf_prefix} for import lib and static lib, but
3347                                 # use 'cyg' prefix for shared lib.
3348                                 case $cf_cv_shlib_version in
3349                                 (cygdll)
3350                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
3351                                         cf_add_lib="../lib/cyg${cf_libname}${cf_cygsuf}"
3352                                         ;;
3353                                 (msysdll)
3354                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
3355                                         cf_add_lib="../lib/msys-${cf_libname}${cf_cygsuf}"
3356                                         ;;
3357                                 (mingw)
3358                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
3359                                         cf_add_lib="../lib/lib${cf_libname}${cf_cygsuf}"
3360                                         ;;
3361                                 (*)
3362                                         cf_add_lib=
3363                                         ;;
3364                                 esac
3365                                 if test -n "$cf_add_lib"
3366                                 then
3367                                         Libs_To_Make="$Libs_To_Make $cf_add_lib"
3368                                         continue
3369                                 fi
3370                         fi
3371                         cf_add_lib="../lib/${cf_prefix}${cf_libname}${cf_suffix}"
3372                         Libs_To_Make="$Libs_To_Make $cf_add_lib"
3373                 done
3374
3375                 if test $cf_dir = ncurses ; then
3376                         cf_subsets="$LIB_SUBSETS"
3377                         cf_r_parts="$cf_subsets"
3378                         cf_liblist="$Libs_To_Make"
3379
3380                         while test -n "$cf_r_parts"
3381                         do
3382                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
3383                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
3384                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
3385                                         cf_add_lib=
3386                                         case $cf_l_parts in
3387                                         (*termlib*)
3388                                                 cf_add_lib=`echo $cf_liblist |sed -e s%${LIB_NAME}${USE_LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
3389                                                 ;;
3390                                         (*ticlib*)
3391                                                 cf_add_lib=`echo $cf_liblist |sed -e s%${LIB_NAME}${USE_LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
3392                                                 ;;
3393                                         (*)
3394                                                 break
3395                                                 ;;
3396                                         esac
3397                                         if test -n "$cf_add_lib"; then
3398                                                 Libs_To_Make="$cf_add_lib $Libs_To_Make"
3399                                         fi
3400                                 else
3401                                         break
3402                                 fi
3403                         done
3404                 else
3405                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
3406                 fi
3407
3408                 if test $cf_dir = c++; then
3409                         if test "x$with_shared_cxx" != xyes && test -n "$cf_shared_suffix"; then
3410                                 cf_list=
3411                                 for cf_item in $Libs_To_Make
3412                                 do
3413                                         case $cf_item in
3414                                         (*.a)
3415                                                 ;;
3416                                         (*)
3417                                                 cf_item=`echo "$cf_item" | sed -e "s,"$cf_shared_suffix",.a,"`
3418                                                 ;;
3419                                         esac
3420                                         for cf_test in $cf_list
3421                                         do
3422                                                 if test "$cf_test" = "$cf_item"
3423                                                 then
3424                                                         cf_LIST_MODELS=`echo "$cf_LIST_MODELS" | sed -e 's/normal//'`
3425                                                         cf_item=
3426                                                         break
3427                                                 fi
3428                                         done
3429                                         test -n "$cf_item" && cf_list="$cf_list $cf_item"
3430                                 done
3431                                 Libs_To_Make="$cf_list"
3432                         fi
3433                 fi
3434
3435                 sed -e "s%@Libs_To_Make@%$Libs_To_Make%" \
3436                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
3437                         $cf_dir/Makefile >$cf_dir/Makefile.out
3438                 mv $cf_dir/Makefile.out $cf_dir/Makefile
3439
3440                 $AWK -f $srcdir/mk-0th.awk \
3441                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" ticlib="$TICS_LIB_SUFFIX" termlib="$TINFO_LIB_SUFFIX" \
3442                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3443
3444                 for cf_subset in $cf_subsets
3445                 do
3446                         cf_subdirs=
3447                         for cf_item in $cf_LIST_MODELS
3448                         do
3449
3450                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
3451                         CF_UPPER(cf_ITEM,$cf_item)
3452
3453                         CXX_MODEL=$cf_ITEM
3454                         if test "$CXX_MODEL" = SHARED; then
3455                                 case $cf_cv_shlib_version in
3456                                 (cygdll|msysdll|mingw)
3457                                         test "x$with_shared_cxx" = xno && CF_VERBOSE(overriding CXX_MODEL to SHARED)
3458                                         with_shared_cxx=yes
3459                                         ;;
3460                                 (*)
3461                                         test "x$with_shared_cxx" = xno && CXX_MODEL=NORMAL
3462                                         ;;
3463                                 esac
3464                         fi
3465
3466                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
3467                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
3468
3469                         # Test for case where we build libtinfo with a different name.
3470                         cf_libname=$cf_dir
3471                         if test $cf_dir = ncurses ; then
3472                                 case $cf_subset in
3473                                 (*base*)
3474                                         cf_libname=${cf_libname}$USE_LIB_SUFFIX
3475                                         ;;
3476                                 (*termlib*)
3477                                         cf_libname=$TINFO_LIB_SUFFIX
3478                                         ;;
3479                                 (ticlib*)
3480                                         cf_libname=$TICS_LIB_SUFFIX
3481                                         ;;
3482                                 esac
3483                         elif test $cf_dir = c++ ; then
3484                                 cf_libname=ncurses++$USE_LIB_SUFFIX
3485                         else
3486                                 cf_libname=${cf_libname}$USE_LIB_SUFFIX
3487                         fi
3488                         if test -n "${USE_ARG_SUFFIX}" ; then
3489                                 # undo $USE_LIB_SUFFIX add-on in CF_LIB_SUFFIX
3490                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${USE_LIB_SUFFIX}%%"`
3491                         fi
3492
3493                         # These dependencies really are for development, not
3494                         # builds, but they are useful in porting, too.
3495                         cf_depend="../include/ncurses_cfg.h"
3496                         if test "$srcdir" = "."; then
3497                                 cf_reldir="."
3498                         else
3499                                 cf_reldir="\${srcdir}"
3500                         fi
3501
3502                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
3503                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
3504                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
3505                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
3506                         fi
3507
3508                         cf_dir_suffix=
3509                         old_cf_suffix="$cf_suffix"
3510                         if test "$cf_cv_shlib_version_infix" = yes ; then
3511                         if test -n "$USE_LIB_SUFFIX" ; then
3512                                 case $USE_LIB_SUFFIX in
3513                                 (tw*)
3514                                         cf_libname=`echo $cf_libname | sed 's/tw'$EXTRA_SUFFIX'$//'`
3515                                         cf_suffix=`echo $cf_suffix | sed 's/^tw'$EXTRA_SUFFIX'//'`
3516                                         cf_dir_suffix=tw$EXTRA_SUFFIX
3517                                         ;;
3518                                 (t*)
3519                                         cf_libname=`echo $cf_libname | sed 's/t'$EXTRA_SUFFIX'$//'`
3520                                         cf_suffix=`echo $cf_suffix | sed 's/^t'$EXTRA_SUFFIX'//'`
3521                                         cf_dir_suffix=t$EXTRA_SUFFIX
3522                                         ;;
3523                                 (w*)
3524                                         cf_libname=`echo $cf_libname | sed 's/w'$EXTRA_SUFFIX'$//'`
3525                                         cf_suffix=`echo $cf_suffix | sed 's/^w'$EXTRA_SUFFIX'//'`
3526                                         cf_dir_suffix=w$EXTRA_SUFFIX
3527                                         ;;
3528                                 (*)
3529                                         cf_libname=`echo $cf_libname | sed 's/'$EXTRA_SUFFIX'$//'`
3530                                         cf_suffix=`echo $cf_suffix | sed 's/^'$EXTRA_SUFFIX'//'`
3531                                         cf_dir_suffix=$EXTRA_SUFFIX
3532                                         ;;
3533                                 esac
3534                         fi
3535                         fi
3536
3537                         $AWK -f $srcdir/mk-1st.awk \
3538                                 name=${cf_libname}${cf_dir_suffix} \
3539                                 traces=$LIB_TRACING \
3540                                 MODEL=$cf_ITEM \
3541                                 CXX_MODEL=$CXX_MODEL \
3542                                 model=$cf_subdir \
3543                                 prefix=$cf_prefix \
3544                                 suffix=$cf_suffix \
3545                                 subset=$cf_subset \
3546                                 driver=$cf_cv_term_driver \
3547                                 SymLink="$LN_S" \
3548                                 TermlibRoot=$TINFO_NAME \
3549                                 TermlibSuffix=$TINFO_SUFFIX \
3550                                 ShlibVer=$cf_cv_shlib_version \
3551                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
3552                                 ReLink=${cf_cv_do_relink:-no} \
3553                                 DoLinks=$cf_cv_do_symlinks \
3554                                 rmSoLocs=$cf_cv_rm_so_locs \
3555                                 ldconfig="$LDCONFIG" \
3556                                 overwrite=$WITH_OVERWRITE \
3557                                 depend="$cf_depend" \
3558                                 host="$host" \
3559                                 libtool_version="$LIBTOOL_VERSION" \
3560                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3561
3562                         cf_suffix="$old_cf_suffix"
3563
3564                         for cf_subdir2 in $cf_subdirs lib
3565                         do
3566                                 test $cf_subdir = $cf_subdir2 && break
3567                         done
3568                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
3569                         $AWK -f $srcdir/mk-2nd.awk \
3570                                 name=$cf_dir \
3571                                 traces=$LIB_TRACING \
3572                                 MODEL=$cf_ITEM \
3573                                 model=$cf_subdir \
3574                                 subset=$cf_subset \
3575                                 srcdir=$srcdir \
3576                                 echo=$WITH_ECHO \
3577                                 crenames=$cf_cv_prog_CC_c_o \
3578                                 cxxrenames=$cf_cv_prog_CXX_c_o \
3579                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3580                         cf_subdirs="$cf_subdirs $cf_subdir"
3581                         done
3582                 done
3583         fi
3584
3585         echo '  cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@' >>Makefile
3586 done
3587
3588 for cf_dir in $SRC_SUBDIRS
3589 do
3590         if test ! -d $srcdir/$cf_dir ; then
3591                 continue
3592         fi
3593
3594         if test -f $cf_dir/Makefile ; then
3595                 case "$cf_dir" in
3596                 (Ada95)
3597                         echo 'libs \' >> Makefile
3598                         echo 'install.libs \' >> Makefile
3599                         echo 'uninstall.libs ::' >> Makefile
3600                         echo '  cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@' >> Makefile
3601                         ;;
3602                 esac
3603         fi
3604
3605         if test -f $srcdir/$cf_dir/modules; then
3606                 echo >> Makefile
3607                 if test -f $srcdir/$cf_dir/headers; then
3608 cat >> Makefile <<CF_EOF
3609 install.includes \\
3610 uninstall.includes \\
3611 CF_EOF
3612                 fi
3613 if test "$cf_dir" != "c++" ; then
3614 echo 'lint \' >> Makefile
3615 fi
3616 cat >> Makefile <<CF_EOF
3617 libs \\
3618 lintlib \\
3619 install.libs \\
3620 uninstall.libs \\
3621 install.$cf_dir \\
3622 uninstall.$cf_dir ::
3623         cd $cf_dir && \${MAKE} \${TOP_MFLAGS} \[$]@
3624 CF_EOF
3625         elif test -f $srcdir/$cf_dir/headers; then
3626 cat >> Makefile <<CF_EOF
3627
3628 libs \\
3629 install.libs \\
3630 uninstall.libs \\
3631 install.includes \\
3632 uninstall.includes ::
3633         cd $cf_dir && \${MAKE} \${TOP_MFLAGS} \[$]@
3634 CF_EOF
3635 fi
3636 done
3637
3638 if test "x$cf_with_db_install" = xyes; then
3639 cat >> Makefile <<CF_EOF
3640
3641 install.libs uninstall.libs \\
3642 install.data uninstall.data ::
3643 $MAKE_TERMINFO  cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@
3644 CF_EOF
3645 else
3646 cat >> Makefile <<CF_EOF
3647
3648 install.libs uninstall.libs ::
3649         cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@
3650 CF_EOF
3651 fi
3652
3653 if test "x$cf_with_manpages" = xyes; then
3654 cat >> Makefile <<CF_EOF
3655
3656 install.man \\
3657 uninstall.man ::
3658         cd man && \${MAKE} \${TOP_MFLAGS} \[$]@
3659 CF_EOF
3660 fi
3661
3662 cat >> Makefile <<CF_EOF
3663
3664 distclean ::
3665         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
3666         rm -f headers.sh headers.sed mk_shared_lib.sh
3667         rm -f edit_man.* man_alias.*
3668         rm -rf \${DIRS_TO_MAKE}
3669 CF_EOF