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.727 2015/01/03 20:48:02 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: 3 updated: 2002/10/27 23:21:42
  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_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49
  66 dnl ------------------
  67 dnl Conditionally generate script according to whether we're using a given autoconf.
  68 dnl
  69 dnl $1 = version to compare against
  70 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
  71 dnl $3 = code to use if AC_ACVERSION is older than $1.
  72 define([CF_ACVERSION_CHECK],
  73 [
  74 ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
  75 ifdef([m4_version_compare],
  76 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
  77 [CF_ACVERSION_COMPARE(
  78 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
  79 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
  80 dnl ---------------------------------------------------------------------------
  81 dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
  82 dnl --------------------
  83 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
  84 dnl                      MAJOR2, MINOR2, TERNARY2,
  85 dnl                      PRINTABLE2, not FOUND, FOUND)
  86 define([CF_ACVERSION_COMPARE],
  87 [ifelse(builtin([eval], [$2 < $5]), 1,
  88 [ifelse([$8], , ,[$8])],
  89 [ifelse([$9], , ,[$9])])])dnl
  90 dnl ---------------------------------------------------------------------------
  91 dnl CF_ADA_INCLUDE_DIRS version: 8 updated: 2013/10/14 04:24:07
  92 dnl -------------------
  93 dnl Construct the list of include-options for the C programs in the Ada95
  94 dnl binding.
  95 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
  96 [
  97 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
  98 if test "$srcdir" != "."; then
  99         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
 100 fi
 101 if test "$GCC" != yes; then
 102         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 103 elif test "$includedir" != "/usr/include"; then
 104         if test "$includedir" = '${prefix}/include' ; then
 105                 if test x$prefix != x/usr ; then
 106                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 107                 fi
 108         else
 109                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 110         fi
 111 fi
 112 AC_SUBST(ACPPFLAGS)
 113 ])dnl
 114 dnl ---------------------------------------------------------------------------
 115 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
 116 dnl ---------------
 117 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
 118 AC_DEFUN([CF_ADD_ADAFLAGS],[
 119         ADAFLAGS="$ADAFLAGS $1"
 120         AC_SUBST(ADAFLAGS)
 121 ])dnl
 122 dnl ---------------------------------------------------------------------------
 123 dnl CF_ADD_CFLAGS version: 11 updated: 2014/07/22 05:32:57
 124 dnl -------------
 125 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
 126 dnl The second parameter if given makes this macro verbose.
 127 dnl
 128 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
 129 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
 130 dnl confused by the quotes (which require backslashes to keep them usable).
 131 AC_DEFUN([CF_ADD_CFLAGS],
 132 [
 133 cf_fix_cppflags=no
 134 cf_new_cflags=
 135 cf_new_cppflags=
 136 cf_new_extra_cppflags=
 137
 138 for cf_add_cflags in $1
 139 do
 140 case $cf_fix_cppflags in
 141 no)
 142         case $cf_add_cflags in #(vi
 143         -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi
 144                 case $cf_add_cflags in
 145                 -D*)
 146                         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
 147
 148                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
 149                                 && test -z "${cf_tst_cflags}" \
 150                                 && cf_fix_cppflags=yes
 151
 152                         if test $cf_fix_cppflags = yes ; then
 153                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 154                                 continue
 155                         elif test "${cf_tst_cflags}" = "\"'" ; then
 156                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 157                                 continue
 158                         fi
 159                         ;;
 160                 esac
 161                 case "$CPPFLAGS" in
 162                 *$cf_add_cflags) #(vi
 163                         ;;
 164                 *) #(vi
 165                         case $cf_add_cflags in #(vi
 166                         -D*)
 167                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
 168                                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
 169                                 ;;
 170                         esac
 171                         cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
 172                         ;;
 173                 esac
 174                 ;;
 175         *)
 176                 cf_new_cflags="$cf_new_cflags $cf_add_cflags"
 177                 ;;
 178         esac
 179         ;;
 180 yes)
 181         cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 182
 183         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
 184
 185         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
 186                 && test -z "${cf_tst_cflags}" \
 187                 && cf_fix_cppflags=no
 188         ;;
 189 esac
 190 done
 191
 192 if test -n "$cf_new_cflags" ; then
 193         ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
 194         CFLAGS="$CFLAGS $cf_new_cflags"
 195 fi
 196
 197 if test -n "$cf_new_cppflags" ; then
 198         ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
 199         CPPFLAGS="$CPPFLAGS $cf_new_cppflags"
 200 fi
 201
 202 if test -n "$cf_new_extra_cppflags" ; then
 203         ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
 204         EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
 205 fi
 206
 207 AC_SUBST(EXTRA_CPPFLAGS)
 208
 209 ])dnl
 210 dnl ---------------------------------------------------------------------------
 211 dnl CF_ADD_INCDIR version: 13 updated: 2010/05/26 16:44:57
 212 dnl -------------
 213 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it's
 214 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
 215 dnl but old versions (and some misinstalled ones) need that.  To make things
 216 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
 217 dnl the include-path).
 218 AC_DEFUN([CF_ADD_INCDIR],
 219 [
 220 if test -n "$1" ; then
 221   for cf_add_incdir in $1
 222   do
 223         while test $cf_add_incdir != /usr/include
 224         do
 225           if test -d $cf_add_incdir
 226           then
 227                 cf_have_incdir=no
 228                 if test -n "$CFLAGS$CPPFLAGS" ; then
 229                   # a loop is needed to ensure we can add subdirs of existing dirs
 230                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
 231                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
 232                           cf_have_incdir=yes; break
 233                         fi
 234                   done
 235                 fi
 236
 237                 if test "$cf_have_incdir" = no ; then
 238                   if test "$cf_add_incdir" = /usr/local/include ; then
 239                         if test "$GCC" = yes
 240                         then
 241                           cf_save_CPPFLAGS=$CPPFLAGS
 242                           CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
 243                           AC_TRY_COMPILE([#include <stdio.h>],
 244                                   [printf("Hello")],
 245                                   [],
 246                                   [cf_have_incdir=yes])
 247                           CPPFLAGS=$cf_save_CPPFLAGS
 248                         fi
 249                   fi
 250                 fi
 251
 252                 if test "$cf_have_incdir" = no ; then
 253                   CF_VERBOSE(adding $cf_add_incdir to include-path)
 254                   ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
 255
 256                   cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
 257                   test "$cf_top_incdir" = "$cf_add_incdir" && break
 258                   cf_add_incdir="$cf_top_incdir"
 259                 else
 260                   break
 261                 fi
 262           fi
 263         done
 264   done
 265 fi
 266 ])dnl
 267 dnl ---------------------------------------------------------------------------
 268 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
 269 dnl ----------
 270 dnl Add a library, used to enforce consistency.
 271 dnl
 272 dnl $1 = library to add, without the "-l"
 273 dnl $2 = variable to update (default $LIBS)
 274 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
 275 dnl ---------------------------------------------------------------------------
 276 dnl CF_ADD_LIBDIR version: 9 updated: 2010/05/26 16:44:57
 277 dnl -------------
 278 dnl     Adds to the library-path
 279 dnl
 280 dnl     Some machines have trouble with multiple -L options.
 281 dnl
 282 dnl $1 is the (list of) directory(s) to add
 283 dnl $2 is the optional name of the variable to update (default LDFLAGS)
 284 dnl
 285 AC_DEFUN([CF_ADD_LIBDIR],
 286 [
 287 if test -n "$1" ; then
 288   for cf_add_libdir in $1
 289   do
 290     if test $cf_add_libdir = /usr/lib ; then
 291       :
 292     elif test -d $cf_add_libdir
 293     then
 294       cf_have_libdir=no
 295       if test -n "$LDFLAGS$LIBS" ; then
 296         # a loop is needed to ensure we can add subdirs of existing dirs
 297         for cf_test_libdir in $LDFLAGS $LIBS ; do
 298           if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
 299             cf_have_libdir=yes; break
 300           fi
 301         done
 302       fi
 303       if test "$cf_have_libdir" = no ; then
 304         CF_VERBOSE(adding $cf_add_libdir to library-path)
 305         ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
 306       fi
 307     fi
 308   done
 309 fi
 310 ])dnl
 311 dnl ---------------------------------------------------------------------------
 312 dnl CF_ADD_LIBS version: 2 updated: 2014/07/13 14:33:27
 313 dnl -----------
 314 dnl Add one or more libraries, used to enforce consistency.  Libraries are
 315 dnl prepended to an existing list, since their dependencies are assumed to
 316 dnl already exist in the list.
 317 dnl
 318 dnl $1 = libraries to add, with the "-l", etc.
 319 dnl $2 = variable to update (default $LIBS)
 320 AC_DEFUN([CF_ADD_LIBS],[
 321 cf_add_libs="$1"
 322 # Filter out duplicates - this happens with badly-designed ".pc" files...
 323 for cf_add_1lib in [$]ifelse($2,,LIBS,[$2])
 324 do
 325         for cf_add_2lib in $cf_add_libs
 326         do
 327                 if test "x$cf_add_1lib" = "x$cf_add_2lib"
 328                 then
 329                         cf_add_1lib=
 330                         break
 331                 fi
 332         done
 333         test -n "$cf_add_1lib" && cf_add_libs="$cf_add_libs $cf_add_1lib"
 334 done
 335 ifelse($2,,LIBS,[$2])="$cf_add_libs"
 336 ])dnl
 337 dnl ---------------------------------------------------------------------------
 338 dnl CF_ADD_SUBDIR_PATH version: 4 updated: 2013/10/08 17:47:05
 339 dnl ------------------
 340 dnl Append to a search-list for a nonstandard header/lib-file
 341 dnl     $1 = the variable to return as result
 342 dnl     $2 = the package name
 343 dnl     $3 = the subdirectory, e.g., bin, include or lib
 344 dnl $4 = the directory under which we will test for subdirectories
 345 dnl $5 = a directory that we do not want $4 to match
 346 AC_DEFUN([CF_ADD_SUBDIR_PATH],
 347 [
 348 test "x$4" != "x$5" && \
 349 test -d "$4" && \
 350 ifelse([$5],NONE,,[(test -z "$5" || test x$5 = xNONE || test "x$4" != "x$5") &&]) {
 351         test -n "$verbose" && echo "    ... testing for $3-directories under $4"
 352         test -d $4/$3 &&          $1="[$]$1 $4/$3"
 353         test -d $4/$3/$2 &&       $1="[$]$1 $4/$3/$2"
 354         test -d $4/$3/$2/$3 &&    $1="[$]$1 $4/$3/$2/$3"
 355         test -d $4/$2/$3 &&       $1="[$]$1 $4/$2/$3"
 356         test -d $4/$2/$3/$2 &&    $1="[$]$1 $4/$2/$3/$2"
 357 }
 358 ])dnl
 359 dnl ---------------------------------------------------------------------------
 360 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
 361 dnl --------------
 362 dnl Allow user to disable a normally-on option.
 363 AC_DEFUN([CF_ARG_DISABLE],
 364 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
 365 dnl ---------------------------------------------------------------------------
 366 dnl CF_ARG_OPTION version: 4 updated: 2010/05/26 05:38:42
 367 dnl -------------
 368 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
 369 dnl values.
 370 dnl
 371 dnl Parameters:
 372 dnl $1 = option name
 373 dnl $2 = help-string
 374 dnl $3 = action to perform if option is not default
 375 dnl $4 = action if perform if option is default
 376 dnl $5 = default option value (either 'yes' or 'no')
 377 AC_DEFUN([CF_ARG_OPTION],
 378 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
 379   if test "$enableval" != "$5" ; then
 380 ifelse([$3],,[    :]dnl
 381 ,[    $3]) ifelse([$4],,,[
 382   else
 383     $4])
 384   fi],[enableval=$5 ifelse([$4],,,[
 385   $4
 386 ])dnl
 387   ])])dnl
 388 dnl ---------------------------------------------------------------------------
 389 dnl CF_AR_FLAGS version: 5 updated: 2010/05/20 20:24:29
 390 dnl -----------
 391 dnl Check for suitable "ar" (archiver) options for updating an archive.
 392 AC_DEFUN([CF_AR_FLAGS],[
 393 AC_REQUIRE([CF_PROG_AR])
 394
 395 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
 396         cf_cv_ar_flags=unknown
 397         for cf_ar_flags in -curv curv -crv crv -cqv cqv -rv rv
 398         do
 399
 400                 # check if $ARFLAGS already contains this choice
 401                 if test "x$ARFLAGS" != "x" ; then
 402                         cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
 403                         if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
 404                                 cf_cv_ar_flags=
 405                                 break
 406                         fi
 407                 fi
 408
 409                 rm -f conftest.$ac_cv_objext
 410                 rm -f conftest.a
 411
 412                 cat >conftest.$ac_ext <<EOF
 413 #line __oline__ "configure"
 414 int     testdata[[3]] = { 123, 456, 789 };
 415 EOF
 416                 if AC_TRY_EVAL(ac_compile) ; then
 417                         echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
 418                         $AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null
 419                         if test -f conftest.a ; then
 420                                 cf_cv_ar_flags=$cf_ar_flags
 421                                 break
 422                         fi
 423                 else
 424                         CF_VERBOSE(cannot compile test-program)
 425                         break
 426                 fi
 427         done
 428         rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
 429 ])
 430
 431 if test -n "$ARFLAGS" ; then
 432         if test -n "$cf_cv_ar_flags" ; then
 433                 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
 434         fi
 435 else
 436         ARFLAGS=$cf_cv_ar_flags
 437 fi
 438
 439 AC_SUBST(ARFLAGS)
 440 ])
 441 dnl ---------------------------------------------------------------------------
 442 dnl CF_AWK_BIG_PRINTF version: 4 updated: 2011/10/30 17:09:50
 443 dnl -----------------
 444 dnl Check if awk can handle big strings using printf.  Some older versions of
 445 dnl awk choke on large strings passed via "%s".
 446 dnl
 447 dnl $1 = desired string size
 448 dnl $2 = variable to set with result
 449 AC_DEFUN([CF_AWK_BIG_PRINTF],
 450 [
 451         case x$AWK in #(vi
 452         x)
 453                 eval $2=no
 454                 ;;
 455         *) #(vi
 456                 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' 2>/dev/null \
 457                         | $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
 458                         eval $2=yes
 459                 else
 460                         eval $2=no
 461                 fi
 462                 ;;
 463         esac
 464 ])dnl
 465 dnl ---------------------------------------------------------------------------
 466 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
 467 dnl ------------
 468 dnl Test if 'bool' is a builtin type in the configured C++ compiler.  Some
 469 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
 470 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
 471 dnl
 472 dnl Treat the configuration-variable specially here, since we're directly
 473 dnl substituting its value (i.e., 1/0).
 474 dnl
 475 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
 476 AC_DEFUN([CF_BOOL_DECL],
 477 [
 478 AC_MSG_CHECKING(if we should include stdbool.h)
 479
 480 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
 481         AC_TRY_COMPILE([],[bool foo = false],
 482                 [cf_cv_header_stdbool_h=0],
 483                 [AC_TRY_COMPILE([
 484 #ifndef __BEOS__
 485 #include <stdbool.h>
 486 #endif
 487 ],[bool foo = false],
 488                         [cf_cv_header_stdbool_h=1],
 489                         [cf_cv_header_stdbool_h=0])])])
 490
 491 if test "$cf_cv_header_stdbool_h" = 1
 492 then    AC_MSG_RESULT(yes)
 493 else    AC_MSG_RESULT(no)
 494 fi
 495
 496 AC_MSG_CHECKING([for builtin bool type])
 497
 498 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
 499         AC_TRY_COMPILE([
 500 #include <stdio.h>
 501 #include <sys/types.h>
 502 ],[bool x = false],
 503                 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
 504                 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
 505         ])
 506
 507 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
 508 then    AC_MSG_RESULT(yes)
 509 else    AC_MSG_RESULT(no)
 510 fi
 511 ])dnl
 512 dnl ---------------------------------------------------------------------------
 513 dnl CF_BOOL_SIZE version: 13 updated: 2013/04/13 18:03:21
 514 dnl ------------
 515 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
 516 dnl Don't bother looking for bool.h, since it's been deprecated.
 517 dnl
 518 dnl If the current compiler is C rather than C++, we get the bool definition
 519 dnl from <stdbool.h>.
 520 AC_DEFUN([CF_BOOL_SIZE],
 521 [
 522 AC_MSG_CHECKING([for size of bool])
 523 AC_CACHE_VAL(cf_cv_type_of_bool,[
 524         rm -f cf_test.out
 525         AC_TRY_RUN([
 526 #include <stdlib.h>
 527 #include <stdio.h>
 528
 529 #if defined(__cplusplus)
 530
 531 #ifdef HAVE_GXX_BUILTIN_H
 532 #include <g++/builtin.h>
 533 #elif HAVE_GPP_BUILTIN_H
 534 #include <gpp/builtin.h>
 535 #elif HAVE_BUILTIN_H
 536 #include <builtin.h>
 537 #endif
 538
 539 #else
 540
 541 #if $cf_cv_header_stdbool_h
 542 #include <stdbool.h>
 543 #endif
 544
 545 #endif
 546
 547 int main()
 548 {
 549         FILE *fp = fopen("cf_test.out", "w");
 550         if (fp != 0) {
 551                 bool x = true;
 552                 if ((bool)(-x) >= 0)
 553                         fputs("unsigned ", fp);
 554                 if (sizeof(x) == sizeof(int))       fputs("int",  fp);
 555                 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
 556                 else if (sizeof(x) == sizeof(short))fputs("short",fp);
 557                 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
 558                 fclose(fp);
 559         }
 560         ${cf_cv_main_return:-return}(0);
 561 }
 562                 ],
 563                 [cf_cv_type_of_bool=`cat cf_test.out`
 564                  if test -z "$cf_cv_type_of_bool"; then
 565                    cf_cv_type_of_bool=unknown
 566                  fi],
 567                 [cf_cv_type_of_bool=unknown],
 568                 [cf_cv_type_of_bool=unknown])
 569         ])
 570         rm -f cf_test.out
 571 AC_MSG_RESULT($cf_cv_type_of_bool)
 572 if test "$cf_cv_type_of_bool" = unknown ; then
 573         case .$NCURSES_BOOL in #(vi
 574         .auto|.) NCURSES_BOOL=unsigned;;
 575         esac
 576         AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
 577         cf_cv_type_of_bool=$NCURSES_BOOL
 578 fi
 579 ])dnl
 580 dnl ---------------------------------------------------------------------------
 581 dnl CF_BUILD_CC version: 7 updated: 2012/10/06 15:31:55
 582 dnl -----------
 583 dnl If we're cross-compiling, allow the user to override the tools and their
 584 dnl options.  The configure script is oriented toward identifying the host
 585 dnl compiler, etc., but we need a build compiler to generate parts of the
 586 dnl source.
 587 dnl
 588 dnl $1 = default for $CPPFLAGS
 589 dnl $2 = default for $LIBS
 590 AC_DEFUN([CF_BUILD_CC],[
 591 CF_ACVERSION_CHECK(2.52,,
 592         [AC_REQUIRE([CF_PROG_EXT])])
 593 if test "$cross_compiling" = yes ; then
 594
 595         # defaults that we might want to override
 596         : ${BUILD_CFLAGS:=''}
 597         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
 598         : ${BUILD_LDFLAGS:=''}
 599         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
 600         : ${BUILD_EXEEXT:='$x'}
 601         : ${BUILD_OBJEXT:='o'}
 602
 603         AC_ARG_WITH(build-cc,
 604                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
 605                 [BUILD_CC="$withval"],
 606                 [AC_CHECK_PROGS(BUILD_CC, gcc cc cl)])
 607         AC_MSG_CHECKING(for native build C compiler)
 608         AC_MSG_RESULT($BUILD_CC)
 609
 610         AC_MSG_CHECKING(for native build C preprocessor)
 611         AC_ARG_WITH(build-cpp,
 612                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
 613                 [BUILD_CPP="$withval"],
 614                 [BUILD_CPP='${BUILD_CC} -E'])
 615         AC_MSG_RESULT($BUILD_CPP)
 616
 617         AC_MSG_CHECKING(for native build C flags)
 618         AC_ARG_WITH(build-cflags,
 619                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
 620                 [BUILD_CFLAGS="$withval"])
 621         AC_MSG_RESULT($BUILD_CFLAGS)
 622
 623         AC_MSG_CHECKING(for native build C preprocessor-flags)
 624         AC_ARG_WITH(build-cppflags,
 625                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
 626                 [BUILD_CPPFLAGS="$withval"])
 627         AC_MSG_RESULT($BUILD_CPPFLAGS)
 628
 629         AC_MSG_CHECKING(for native build linker-flags)
 630         AC_ARG_WITH(build-ldflags,
 631                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
 632                 [BUILD_LDFLAGS="$withval"])
 633         AC_MSG_RESULT($BUILD_LDFLAGS)
 634
 635         AC_MSG_CHECKING(for native build linker-libraries)
 636         AC_ARG_WITH(build-libs,
 637                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
 638                 [BUILD_LIBS="$withval"])
 639         AC_MSG_RESULT($BUILD_LIBS)
 640
 641         # this assumes we're on Unix.
 642         BUILD_EXEEXT=
 643         BUILD_OBJEXT=o
 644
 645         : ${BUILD_CC:='${CC}'}
 646
 647         if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
 648                 AC_MSG_ERROR([Cross-build requires two compilers.
 649 Use --with-build-cc to specify the native compiler.])
 650         fi
 651
 652 else
 653         : ${BUILD_CC:='${CC}'}
 654         : ${BUILD_CPP:='${CPP}'}
 655         : ${BUILD_CFLAGS:='${CFLAGS}'}
 656         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
 657         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
 658         : ${BUILD_LIBS:='${LIBS}'}
 659         : ${BUILD_EXEEXT:='$x'}
 660         : ${BUILD_OBJEXT:='o'}
 661 fi
 662
 663 AC_SUBST(BUILD_CC)
 664 AC_SUBST(BUILD_CPP)
 665 AC_SUBST(BUILD_CFLAGS)
 666 AC_SUBST(BUILD_CPPFLAGS)
 667 AC_SUBST(BUILD_LDFLAGS)
 668 AC_SUBST(BUILD_LIBS)
 669 AC_SUBST(BUILD_EXEEXT)
 670 AC_SUBST(BUILD_OBJEXT)
 671 ])dnl
 672 dnl ---------------------------------------------------------------------------
 673 dnl CF_CC_ENV_FLAGS version: 1 updated: 2012/10/03 05:25:49
 674 dnl ---------------
 675 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
 676 dnl into CC.  This will not help with broken scripts that wrap the compiler with
 677 dnl options, but eliminates a more common category of user confusion.
 678 AC_DEFUN([CF_CC_ENV_FLAGS],
 679 [
 680 # This should have been defined by AC_PROG_CC
 681 : ${CC:=cc}
 682
 683 AC_MSG_CHECKING(\$CC variable)
 684 case "$CC" in #(vi
 685 *[[\ \  ]]-[[IUD]]*)
 686         AC_MSG_RESULT(broken)
 687         AC_MSG_WARN(your environment misuses the CC variable to hold CFLAGS/CPPFLAGS options)
 688         # humor him...
 689         cf_flags=`echo "$CC" | sed -e 's/^[[^   ]]*[[   ]]//'`
 690         CC=`echo "$CC" | sed -e 's/[[   ]].*//'`
 691         CF_ADD_CFLAGS($cf_flags)
 692         ;;
 693 *)
 694         AC_MSG_RESULT(ok)
 695         ;;
 696 esac
 697 ])dnl
 698 dnl ---------------------------------------------------------------------------
 699 dnl CF_CFG_DEFAULTS version: 10 updated: 2013/09/07 13:54:05
 700 dnl ---------------
 701 dnl Determine the default configuration into which we'll install ncurses.  This
 702 dnl can be overridden by the user's command-line options.  There's two items to
 703 dnl look for:
 704 dnl     1. the prefix (e.g., /usr)
 705 dnl     2. the header files (e.g., /usr/include/ncurses)
 706 dnl We'll look for a previous installation of ncurses and use the same defaults.
 707 dnl
 708 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
 709 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
 710 dnl programs from a vendor's.
 711 AC_DEFUN([CF_CFG_DEFAULTS],
 712 [
 713 AC_MSG_CHECKING(for prefix)
 714 if test "x$prefix" = "xNONE" ; then
 715         case "$cf_cv_system_name" in
 716                 # non-vendor systems don't have a conflict
 717         openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
 718                 prefix=/usr
 719                 ;;
 720         *)      prefix=$ac_default_prefix
 721                 ;;
 722         esac
 723 fi
 724 AC_MSG_RESULT($prefix)
 725
 726 if test "x$prefix" = "xNONE" ; then
 727 AC_MSG_CHECKING(for default include-directory)
 728 test -n "$verbose" && echo 1>&AC_FD_MSG
 729 for cf_symbol in \
 730         $includedir \
 731         $includedir/ncurses \
 732         $prefix/include \
 733         $prefix/include/ncurses \
 734         /usr/local/include \
 735         /usr/local/include/ncurses \
 736         /usr/include \
 737         /usr/include/ncurses
 738 do
 739         cf_dir=`eval echo $cf_symbol`
 740         if test -f $cf_dir/curses.h ; then
 741         if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
 742                 includedir="$cf_symbol"
 743                 test -n "$verbose"  && echo $ac_n "     found " 1>&AC_FD_MSG
 744                 break
 745         fi
 746         fi
 747         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
 748 done
 749 AC_MSG_RESULT($includedir)
 750 fi
 751 ])dnl
 752 dnl ---------------------------------------------------------------------------
 753 dnl CF_CGETENT version: 5 updated: 2012/10/06 17:56:13
 754 dnl ----------
 755 dnl Check if the terminal-capability database functions are available.  If not,
 756 dnl ncurses has a much-reduced version.
 757 AC_DEFUN([CF_CGETENT],[
 758 AC_CACHE_CHECK(for terminal-capability database functions,cf_cv_cgetent,[
 759 AC_TRY_LINK([
 760 #include <stdlib.h>],[
 761         char temp[128];
 762         char *buf = temp;
 763         char *db_array = temp;
 764         cgetent(&buf, &db_array, "vt100");
 765         cgetcap(buf, "tc", '=');
 766         cgetmatch(buf, "tc");
 767         ],
 768         [cf_cv_cgetent=yes],
 769         [cf_cv_cgetent=no])
 770 ])
 771
 772 if test "$cf_cv_cgetent" = yes
 773 then
 774         AC_DEFINE(HAVE_BSD_CGETENT,1,[Define to 1 if we have BSD cgetent])
 775 AC_CACHE_CHECK(if cgetent uses const parameter,cf_cv_cgetent_const,[
 776 AC_TRY_LINK([
 777 #include <stdlib.h>],[
 778         char temp[128];
 779         char *buf = temp;
 780 #ifndef _NETBSD_SOURCE                  /* given, since April 2004 in stdlib.h */
 781         const char *db_array = temp;
 782         cgetent(&buf, &db_array, "vt100");
 783 #endif
 784         cgetcap(buf, "tc", '=');
 785         cgetmatch(buf, "tc");
 786         ],
 787         [cf_cv_cgetent_const=yes],
 788         [cf_cv_cgetent_const=no])
 789 ])
 790         if test "$cf_cv_cgetent_const" = yes
 791         then
 792                 AC_DEFINE_UNQUOTED(CGETENT_CONST,const,[Define to const if needed for some BSD cgetent variations])
 793         fi
 794 fi
 795 ])dnl
 796 dnl ---------------------------------------------------------------------------
 797 dnl CF_CHECK_CACHE version: 12 updated: 2012/10/02 20:55:03
 798 dnl --------------
 799 dnl Check if we're accidentally using a cache from a different machine.
 800 dnl Derive the system name, as a check for reusing the autoconf cache.
 801 dnl
 802 dnl If we've packaged config.guess and config.sub, run that (since it does a
 803 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
 804 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
 805 dnl which is useful in cross-compiles.
 806 dnl
 807 dnl Note: we would use $ac_config_sub, but that is one of the places where
 808 dnl autoconf 2.5x broke compatibility with autoconf 2.13
 809 AC_DEFUN([CF_CHECK_CACHE],
 810 [
 811 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
 812         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
 813         system_name="$host_os"
 814 else
 815         system_name="`(uname -s -r) 2>/dev/null`"
 816         if test -z "$system_name" ; then
 817                 system_name="`(hostname) 2>/dev/null`"
 818         fi
 819 fi
 820 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
 821 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
 822
 823 test -z "$system_name" && system_name="$cf_cv_system_name"
 824 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
 825
 826 if test ".$system_name" != ".$cf_cv_system_name" ; then
 827         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
 828         AC_MSG_ERROR("Please remove config.cache and try again.")
 829 fi
 830 ])dnl
 831 dnl ---------------------------------------------------------------------------
 832 dnl CF_CHECK_ERRNO version: 11 updated: 2010/05/26 05:38:42
 833 dnl --------------
 834 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
 835 dnl the 'errno' variable.  Define a DECL_xxx symbol if we must declare it
 836 dnl ourselves.
 837 dnl
 838 dnl $1 = the name to check
 839 dnl $2 = the assumed type
 840 AC_DEFUN([CF_CHECK_ERRNO],
 841 [
 842 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
 843     AC_TRY_COMPILE([
 844 #ifdef HAVE_STDLIB_H
 845 #include <stdlib.h>
 846 #endif
 847 #include <stdio.h>
 848 #include <sys/types.h>
 849 #include <errno.h> ],
 850     ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1,
 851     [cf_cv_dcl_$1=yes],
 852     [cf_cv_dcl_$1=no])
 853 ])
 854
 855 if test "$cf_cv_dcl_$1" = no ; then
 856     CF_UPPER(cf_result,decl_$1)
 857     AC_DEFINE_UNQUOTED($cf_result)
 858 fi
 859
 860 # It's possible (for near-UNIX clones) that the data doesn't exist
 861 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
 862 ])dnl
 863 dnl ---------------------------------------------------------------------------
 864 dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23
 865 dnl --------------------
 866 dnl Check for existence of external data in the current set of libraries.  If
 867 dnl we can modify it, it's real enough.
 868 dnl $1 = the name to check
 869 dnl $2 = its type
 870 AC_DEFUN([CF_CHECK_EXTERN_DATA],
 871 [
 872 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
 873     AC_TRY_LINK([
 874 #undef $1
 875 extern $2 $1;
 876 ],
 877     [$1 = 2],
 878     [cf_cv_have_$1=yes],
 879     [cf_cv_have_$1=no])
 880 ])
 881
 882 if test "$cf_cv_have_$1" = yes ; then
 883     CF_UPPER(cf_result,have_$1)
 884     AC_DEFINE_UNQUOTED($cf_result)
 885 fi
 886
 887 ])dnl
 888 dnl ---------------------------------------------------------------------------
 889 dnl CF_CHECK_GPM_WGETCH version: 2 updated: 2010/08/14 18:25:37
 890 dnl -------------------
 891 dnl Check if GPM is already linked with curses.  If so - and if the linkage
 892 dnl is not "weak" - warn about this because it can create problems linking
 893 dnl applications with ncurses.
 894 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
 895 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
 896
 897 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
 898 cf_cv_check_gpm_wgetch=unknown
 899 if test "$cross_compiling" != yes ; then
 900
 901 cat >conftest.$ac_ext <<CF_EOF
 902 #include <gpm.h>
 903 int main()
 904 {
 905         Gpm_Wgetch();
 906         ${cf_cv_main_return:-return}(0);
 907 }
 908 CF_EOF
 909
 910         cf_save_LIBS="$LIBS"
 911         # This only works if we can look at the symbol table.  If a shared
 912         # library is stripped for install, we cannot use that.  So we're forced
 913         # to rely on the static library, noting that some packagers may not
 914         # include it.
 915         LIBS="-static -lgpm -dynamic $LIBS"
 916         if AC_TRY_EVAL(ac_compile) ; then
 917                 if AC_TRY_EVAL(ac_link) ; then
 918                         cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
 919                         test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
 920                         test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
 921                 fi
 922         fi
 923         rm -rf conftest*
 924         LIBS="$cf_save_LIBS"
 925 fi
 926 ])
 927
 928 if test "$cf_cv_check_gpm_wgetch" != yes ; then
 929         AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
 930 fi
 931 ])])dnl
 932 dnl ---------------------------------------------------------------------------
 933 dnl CF_CHECK_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09
 934 dnl ------------------------
 935 dnl Show the version of libtool
 936 dnl
 937 dnl Save the version in a cache variable - this is not entirely a good thing,
 938 dnl but the version string from libtool is very ugly, and for bug reports it
 939 dnl might be useful to have the original string.
 940 AC_DEFUN([CF_CHECK_LIBTOOL_VERSION],[
 941 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
 942 then
 943         AC_MSG_CHECKING(version of $LIBTOOL)
 944         CF_LIBTOOL_VERSION
 945         AC_MSG_RESULT($cf_cv_libtool_version)
 946         if test -z "$cf_cv_libtool_version" ; then
 947                 AC_MSG_ERROR(This is not GNU libtool)
 948         fi
 949 else
 950         AC_MSG_ERROR(GNU libtool has not been found)
 951 fi
 952 ])dnl
 953 dnl ---------------------------------------------------------------------------
 954 dnl CF_CHECK_WCHAR_H version: 1 updated: 2011/10/29 15:01:05
 955 dnl ----------------
 956 dnl Check if wchar.h can be used, i.e., without defining _XOPEN_SOURCE_EXTENDED
 957 AC_DEFUN([CF_CHECK_WCHAR_H],[
 958 AC_CACHE_CHECK(if wchar.h can be used as is,cf_cv_wchar_h_okay,[
 959 AC_TRY_COMPILE(
 960 [
 961 #include <stdlib.h>
 962 #include <wchar.h>
 963 ],[
 964         wint_t foo = 0;
 965         int bar = iswpunct(foo)],
 966         [cf_cv_wchar_h_okay=yes],
 967         [cf_cv_wchar_h_okay=no])])
 968
 969 if test $cf_cv_wchar_h_okay = no
 970 then
 971         CF_PREDEFINE(_XOPEN_SOURCE_EXTENDED)
 972 fi
 973 ])dnl
 974 dnl ---------------------------------------------------------------------------
 975 dnl CF_CLANG_COMPILER version: 2 updated: 2013/11/19 19:23:35
 976 dnl -----------------
 977 dnl Check if the given compiler is really clang.  clang's C driver defines
 978 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
 979 dnl not ignore some gcc options.
 980 dnl
 981 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
 982 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
 983 dnl the wrappers for gcc and g++ warnings.
 984 dnl
 985 dnl $1 = GCC (default) or GXX
 986 dnl $2 = CLANG_COMPILER (default)
 987 dnl $3 = CFLAGS (default) or CXXFLAGS
 988 AC_DEFUN([CF_CLANG_COMPILER],[
 989 ifelse([$2],,CLANG_COMPILER,[$2])=no
 990
 991 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
 992         AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
 993         cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
 994         ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -Qunused-arguments"
 995         AC_TRY_COMPILE([],[
 996 #ifdef __clang__
 997 #else
 998 make an error
 999 #endif
1000 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
1001 cf_save_CFLAGS="$cf_save_CFLAGS -Qunused-arguments"
1002 ],[])
1003         ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
1004         AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
1005 fi
1006 ])
1007 dnl ---------------------------------------------------------------------------
1008 dnl CF_CPP_PARAM_INIT version: 6 updated: 2012/10/06 17:56:13
1009 dnl -----------------
1010 dnl Check if the C++ compiler accepts duplicate parameter initialization.  This
1011 dnl is a late feature for the standard and is not in some recent compilers
1012 dnl (1999/9/11).
1013 AC_DEFUN([CF_CPP_PARAM_INIT],
1014 [
1015 if test -n "$CXX"; then
1016 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
1017         AC_LANG_SAVE
1018         AC_LANG_CPLUSPLUS
1019         AC_TRY_RUN([
1020 class TEST {
1021 private:
1022         int value;
1023 public:
1024         TEST(int x = 1);
1025         ~TEST();
1026 };
1027
1028 TEST::TEST(int x = 1)   // some compilers do not like second initializer
1029 {
1030         value = x;
1031 }
1032 int main() { }
1033 ],
1034         [cf_cv_cpp_param_init=yes],
1035         [cf_cv_cpp_param_init=no],
1036         [cf_cv_cpp_param_init=unknown])
1037         AC_LANG_RESTORE
1038 ])
1039 fi
1040 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT,1,[Define to 1 if C++ has parameter initialization])
1041 ])dnl
1042 dnl ---------------------------------------------------------------------------
1043 dnl CF_CPP_STATIC_CAST version: 3 updated: 2013/04/13 18:03:21
1044 dnl ------------------
1045 dnl Check if the C++ compiler accepts static_cast in generics.  This appears to
1046 dnl not be supported in g++ before 3.0
1047 AC_DEFUN([CF_CPP_STATIC_CAST],
1048 [
1049 if test -n "$CXX"; then
1050
1051 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
1052         AC_LANG_SAVE
1053         AC_LANG_CPLUSPLUS
1054
1055         AC_TRY_COMPILE([
1056 class NCursesPanel
1057 {
1058 public:
1059   NCursesPanel(int nlines,
1060                int ncols,
1061                int begin_y = 0,
1062                int begin_x = 0)
1063   {
1064   }
1065   NCursesPanel();
1066   ~NCursesPanel();
1067 };
1068
1069 template<class T> class NCursesUserPanel : public NCursesPanel
1070 {
1071 public:
1072   NCursesUserPanel (int nlines,
1073                     int ncols,
1074                     int begin_y = 0,
1075                     int begin_x = 0,
1076                     const T* p_UserData = static_cast<T*>(0))
1077     : NCursesPanel (nlines, ncols, begin_y, begin_x)
1078   {
1079   };
1080   NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
1081   {
1082   };
1083
1084   virtual ~NCursesUserPanel() {};
1085 };
1086 ],[
1087         const char* p_UserData = static_cast<char*>(0)],
1088         [cf_cv_cpp_static_cast=yes],
1089         [cf_cv_cpp_static_cast=no])
1090
1091         AC_LANG_RESTORE
1092 ])
1093
1094 fi
1095
1096 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST,1,[Define to 1 if C++ has static_cast])
1097 ])dnl
1098 dnl ---------------------------------------------------------------------------
1099 dnl CF_CXX_AR_FLAGS version: 1 updated: 2011/10/29 08:35:34
1100 dnl ---------------
1101 dnl Setup special archiver flags for given compilers.
1102 AC_DEFUN([CF_CXX_AR_FLAGS],[
1103         CXX_AR='$(AR)'
1104         CXX_ARFLAGS='$(ARFLAGS)'
1105         case $cf_cv_system_name in #(vi
1106         irix*) #(vi
1107             if test "$GXX" != yes ; then
1108                 CXX_AR='$(CXX)'
1109                 CXX_ARFLAGS='-ar -o'
1110             fi
1111             ;;
1112         sco3.2v5*) #(vi
1113             CXXLDFLAGS="-u main"
1114             ;;
1115         solaris2*)
1116             if test "$GXX" != yes ; then
1117                 CXX_AR='$(CXX)'
1118                 CXX_ARFLAGS='-xar -o'
1119             fi
1120             ;;
1121         esac
1122         AC_SUBST(CXXLDFLAGS)
1123         AC_SUBST(CXX_AR)
1124         AC_SUBST(CXX_ARFLAGS)
1125 ])dnl
1126 dnl ---------------------------------------------------------------------------
1127 dnl CF_CXX_IOSTREAM_NAMESPACE version: 2 updated: 2012/10/06 17:56:13
1128 dnl -------------------------
1129 dnl For c++, check if iostream uses "std::" namespace.
1130 AC_DEFUN([CF_CXX_IOSTREAM_NAMESPACE],[
1131 AC_CHECK_HEADERS(iostream)
1132 if test x"$ac_cv_header_iostream" = xyes ; then
1133         AC_MSG_CHECKING(if iostream uses std-namespace)
1134         AC_TRY_COMPILE([
1135 #include <iostream>
1136 using std::endl;
1137 using std::cerr;],[
1138 cerr << "testing" << endl;
1139 ],[cf_iostream_namespace=yes],[cf_iostream_namespace=no])
1140         AC_MSG_RESULT($cf_iostream_namespace)
1141         if test "$cf_iostream_namespace" = yes ; then
1142                 AC_DEFINE(IOSTREAM_NAMESPACE,1,[Define to 1 if C++ has namespace iostream])
1143         fi
1144 fi
1145 ])dnl
1146 dnl ---------------------------------------------------------------------------
1147 dnl CF_C_INLINE version: 4 updated: 2012/06/16 14:55:39
1148 dnl -----------
1149 dnl Check if the C compiler supports "inline".
1150 dnl $1 is the name of a shell variable to set if inline is supported
1151 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
1152 AC_DEFUN([CF_C_INLINE],[
1153 AC_C_INLINE
1154 $1=
1155 if test "$ac_cv_c_inline" != no ; then
1156   $1=inline
1157   if test "$INTEL_COMPILER" = yes
1158   then
1159     :
1160   elif test "$CLANG_COMPILER" = yes
1161   then
1162     :
1163   elif test "$GCC" = yes
1164   then
1165     AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[
1166       cf_save_CFLAGS=$CFLAGS
1167       CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
1168       AC_TRY_COMPILE([inline int foo(void) { return 1; }],
1169       [${cf_cv_main_return:-return} foo()],
1170       [cf_cv_gcc_inline=yes],
1171       [cf_cv_gcc_inline=no])
1172       CFLAGS=$cf_save_CFLAGS
1173     ])
1174     if test "$cf_cv_gcc_inline" = yes ; then
1175         CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
1176     fi
1177   fi
1178 fi
1179 AC_SUBST($1)
1180 ])dnl
1181 dnl ---------------------------------------------------------------------------
1182 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
1183 dnl ----------
1184 dnl "dirname" is not portable, so we fake it with a shell script.
1185 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
1186 dnl ---------------------------------------------------------------------------
1187 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
1188 dnl ---------------
1189 AC_DEFUN([CF_DIRS_TO_MAKE],
1190 [
1191 DIRS_TO_MAKE="lib"
1192 for cf_item in $cf_list_models
1193 do
1194         CF_OBJ_SUBDIR($cf_item,cf_subdir)
1195         for cf_item2 in $DIRS_TO_MAKE
1196         do
1197                 test $cf_item2 = $cf_subdir && break
1198         done
1199         test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
1200 done
1201 for cf_dir in $DIRS_TO_MAKE
1202 do
1203         test ! -d $cf_dir && mkdir $cf_dir
1204 done
1205 AC_SUBST(DIRS_TO_MAKE)
1206 ])dnl
1207 dnl ---------------------------------------------------------------------------
1208 dnl CF_DISABLE_ECHO version: 12 updated: 2012/10/06 16:30:28
1209 dnl ---------------
1210 dnl You can always use "make -n" to see the actual options, but it's hard to
1211 dnl pick out/analyze warning messages when the compile-line is long.
1212 dnl
1213 dnl Sets:
1214 dnl     ECHO_LT - symbol to control if libtool is verbose
1215 dnl     ECHO_LD - symbol to prefix "cc -o" lines
1216 dnl     RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1217 dnl     SHOW_CC - symbol to put before explicit "cc -c" lines
1218 dnl     ECHO_CC - symbol to put before any "cc" line
1219 dnl
1220 AC_DEFUN([CF_DISABLE_ECHO],[
1221 AC_MSG_CHECKING(if you want to see long compiling messages)
1222 CF_ARG_DISABLE(echo,
1223         [  --disable-echo          do not display "compiling" commands],
1224         [
1225     ECHO_LT='--silent'
1226     ECHO_LD='@echo linking [$]@;'
1227     RULE_CC='@echo compiling [$]<'
1228     SHOW_CC='@echo compiling [$]@'
1229     ECHO_CC='@'
1230 ],[
1231     ECHO_LT=''
1232     ECHO_LD=''
1233     RULE_CC=''
1234     SHOW_CC=''
1235     ECHO_CC=''
1236 ])
1237 AC_MSG_RESULT($enableval)
1238 AC_SUBST(ECHO_LT)
1239 AC_SUBST(ECHO_LD)
1240 AC_SUBST(RULE_CC)
1241 AC_SUBST(SHOW_CC)
1242 AC_SUBST(ECHO_CC)
1243 ])dnl
1244 dnl ---------------------------------------------------------------------------
1245 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
1246 dnl ------------------------
1247 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
1248 AC_MSG_CHECKING(if we want to use GNAT projects)
1249 CF_ARG_DISABLE(gnat-projects,
1250         [  --disable-gnat-projects test: disable GNAT projects even if usable],
1251         [enable_gnat_projects=no],
1252         [enable_gnat_projects=yes])
1253 AC_MSG_RESULT($enable_gnat_projects)
1254 ])dnl
1255 dnl ---------------------------------------------------------------------------
1256 dnl CF_DISABLE_LEAKS version: 7 updated: 2012/10/02 20:55:03
1257 dnl ----------------
1258 dnl Combine no-leak checks with the libraries or tools that are used for the
1259 dnl checks.
1260 AC_DEFUN([CF_DISABLE_LEAKS],[
1261
1262 AC_REQUIRE([CF_WITH_DMALLOC])
1263 AC_REQUIRE([CF_WITH_DBMALLOC])
1264 AC_REQUIRE([CF_WITH_VALGRIND])
1265
1266 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1267 AC_ARG_ENABLE(leaks,
1268         [  --disable-leaks         test: free permanent memory, analyze leaks],
1269         [if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi],
1270         : ${with_no_leaks:=no})
1271 AC_MSG_RESULT($with_no_leaks)
1272
1273 if test "$with_no_leaks" = yes ; then
1274         AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1275         AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1276 fi
1277 ])dnl
1278 dnl ---------------------------------------------------------------------------
1279 dnl CF_DISABLE_LIBTOOL_VERSION version: 2 updated: 2014/11/15 19:05:29
1280 dnl --------------------------
1281 dnl Check if we should use the libtool 1.5 feature "-version-number" instead of
1282 dnl the older "-version-info" feature.  The newer feature allows us to use
1283 dnl version numbering on shared libraries which make them compatible with
1284 dnl various systems.
1285 AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION],
1286 [
1287 AC_MSG_CHECKING(if libtool -version-number should be used)
1288 CF_ARG_DISABLE(libtool-version,
1289         [  --disable-libtool-version  enable to use libtool's incompatible naming scheme],
1290         [cf_libtool_version=no],
1291         [cf_libtool_version=yes])
1292 AC_MSG_RESULT($cf_libtool_version)
1293
1294 if test "$cf_libtool_version" = yes ; then
1295         LIBTOOL_VERSION="-version-number"
1296 else
1297         LIBTOOL_VERSION="-version-info"
1298         case "x$VERSION" in #(vi
1299         x) #(vi
1300                 AC_MSG_WARN(VERSION was not set)
1301                 ;;
1302         x*.*.*)
1303                 ABI_VERSION="$VERSION"
1304                 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
1305                 ;;
1306         x*:*:*)
1307                 ABI_VERSION=`echo "$VERSION" | sed -e 's/:/./g'`
1308                 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
1309                 ;;
1310         *)
1311                 AC_MSG_WARN(unexpected VERSION value: $VERSION)
1312                 ;;
1313         esac
1314 fi
1315
1316 AC_SUBST(ABI_VERSION)
1317 AC_SUBST(LIBTOOL_VERSION)
1318 ])dnl
1319 dnl ---------------------------------------------------------------------------
1320 dnl CF_DISABLE_RPATH_HACK version: 2 updated: 2011/02/13 13:31:33
1321 dnl ---------------------
1322 dnl The rpath-hack makes it simpler to build programs, particularly with the
1323 dnl *BSD ports which may have essential libraries in unusual places.  But it
1324 dnl can interfere with building an executable for the base system.  Use this
1325 dnl option in that case.
1326 AC_DEFUN([CF_DISABLE_RPATH_HACK],
1327 [
1328 AC_MSG_CHECKING(if rpath-hack should be disabled)
1329 CF_ARG_DISABLE(rpath-hack,
1330         [  --disable-rpath-hack    don't add rpath options for additional libraries],
1331         [cf_disable_rpath_hack=yes],
1332         [cf_disable_rpath_hack=no])
1333 AC_MSG_RESULT($cf_disable_rpath_hack)
1334 if test "$cf_disable_rpath_hack" = no ; then
1335         CF_RPATH_HACK
1336 fi
1337 ])
1338 dnl ---------------------------------------------------------------------------
1339 dnl CF_ENABLE_PC_FILES version: 10 updated: 2014/12/13 18:48:46
1340 dnl ------------------
1341 dnl This is the "--enable-pc-files" option, which is available if there is a
1342 dnl pkg-config configuration on the local machine.
1343 AC_DEFUN([CF_ENABLE_PC_FILES],[
1344 AC_REQUIRE([CF_PKG_CONFIG])
1345 AC_REQUIRE([CF_WITH_PKG_CONFIG_LIBDIR])
1346
1347 if test "x$PKG_CONFIG" != xnone
1348 then
1349         AC_MSG_CHECKING(if we should install .pc files for $PKG_CONFIG)
1350 else
1351         AC_MSG_CHECKING(if we should install .pc files)
1352 fi
1353
1354 AC_ARG_ENABLE(pc-files,
1355         [  --enable-pc-files       generate and install .pc files for pkg-config],
1356         [enable_pc_files=$enableval],
1357         [enable_pc_files=no])
1358 AC_MSG_RESULT($enable_pc_files)
1359 if test "x$enable_pc_files" != xno
1360 then
1361         CF_PATH_SYNTAX(PKG_CONFIG_LIBDIR)
1362         MAKE_PC_FILES=
1363 else
1364         MAKE_PC_FILES="#"
1365 fi
1366 AC_SUBST(MAKE_PC_FILES)
1367 ])dnl
1368 dnl ---------------------------------------------------------------------------
1369 dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
1370 dnl ---------------
1371 dnl Check if the rpath option should be used, setting cache variable
1372 dnl cf_cv_enable_rpath if so.
1373 AC_DEFUN([CF_ENABLE_RPATH],
1374 [
1375 AC_MSG_CHECKING(if rpath option should be used)
1376 AC_ARG_ENABLE(rpath,
1377 [  --enable-rpath          use rpath option when generating shared libraries],
1378 [cf_cv_enable_rpath=$enableval],
1379 [cf_cv_enable_rpath=no])
1380 AC_MSG_RESULT($cf_cv_enable_rpath)
1381 ])dnl
1382 dnl ---------------------------------------------------------------------------
1383 dnl CF_ENABLE_STRING_HACKS version: 3 updated: 2013/01/26 16:26:12
1384 dnl ----------------------
1385 dnl On a few platforms, the compiler and/or loader nags with untruthful
1386 dnl comments stating that "most" uses of strcat/strcpy/sprintf are incorrect,
1387 dnl and implying that most uses of the recommended alternatives are correct.
1388 dnl
1389 dnl Factually speaking, no one has actually counted the number of uses of these
1390 dnl functions versus the total of incorrect uses.  Samples of a few thousand
1391 dnl instances are meaningless compared to the hundreds of millions of lines of
1392 dnl existing C code.
1393 dnl
1394 dnl strlcat/strlcpy are (as of 2012) non-standard, and are available on some
1395 dnl platforms, in implementations of varying quality.  Likewise, snprintf is
1396 dnl standard - but evolved through phases, and older implementations are likely
1397 dnl to yield surprising results, as documented in manpages on various systems.
1398 AC_DEFUN([CF_ENABLE_STRING_HACKS],
1399 [
1400 AC_MSG_CHECKING(if you want to work around bogus compiler/loader warnings)
1401 AC_ARG_ENABLE(string-hacks,
1402         [  --enable-string-hacks   work around bogus compiler/loader warnings],
1403         [with_string_hacks=$enableval],
1404         [with_string_hacks=no])
1405 AC_MSG_RESULT($with_string_hacks)
1406
1407 if test "x$with_string_hacks" = "xyes"; then
1408         AC_DEFINE(USE_STRING_HACKS,1,[Define to 1 to work around bogus compiler/loader warnings])
1409         AC_MSG_WARN(enabling string-hacks to work around bogus compiler/loader warnings)
1410         AC_CHECK_FUNCS( strlcat strlcpy snprintf )
1411 fi
1412 ])dnl
1413 dnl ---------------------------------------------------------------------------
1414 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
1415 dnl --------
1416 dnl Check if 'errno' is declared in <errno.h>
1417 AC_DEFUN([CF_ERRNO],
1418 [
1419 CF_CHECK_ERRNO(errno)
1420 ])dnl
1421 dnl ---------------------------------------------------------------------------
1422 dnl CF_ETIP_DEFINES version: 5 updated: 2012/02/18 17:51:07
1423 dnl ---------------
1424 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
1425 dnl math.h and builtin.h, only for ncurses
1426 AC_DEFUN([CF_ETIP_DEFINES],
1427 [
1428 AC_MSG_CHECKING(for special defines needed for etip.h)
1429 cf_save_CXXFLAGS="$CXXFLAGS"
1430 cf_result="none"
1431
1432 # etip.h includes ncurses.h which includes ncurses_dll.h
1433 # But ncurses_dll.h is generated - fix here.
1434 test -d include || mkdir include
1435 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
1436
1437 for cf_math in "" MATH_H
1438 do
1439 for cf_excp in "" MATH_EXCEPTION
1440 do
1441         CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -Iinclude -I${srcdir}/include"
1442         test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
1443         test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
1444 AC_TRY_COMPILE([
1445 #include <etip.h.in>
1446 ],[],[
1447         test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
1448         test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
1449         cf_result="$cf_math $cf_excp"
1450         break 2
1451 ],[])
1452 done
1453 done
1454 AC_MSG_RESULT($cf_result)
1455 CXXFLAGS="$cf_save_CXXFLAGS"
1456 ])
1457 dnl ---------------------------------------------------------------------------
1458 dnl CF_FIND_LINKAGE version: 19 updated: 2010/05/29 16:31:02
1459 dnl ---------------
1460 dnl Find a library (specifically the linkage used in the code fragment),
1461 dnl searching for it if it is not already in the library path.
1462 dnl See also CF_ADD_SEARCHPATH.
1463 dnl
1464 dnl Parameters (4-on are optional):
1465 dnl     $1 = headers for library entrypoint
1466 dnl     $2 = code fragment for library entrypoint
1467 dnl     $3 = the library name without the "-l" option or ".so" suffix.
1468 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
1469 dnl     $5 = action to perform if not successful
1470 dnl     $6 = module name, if not the same as the library name
1471 dnl     $7 = extra libraries
1472 dnl
1473 dnl Sets these variables:
1474 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1475 dnl     $cf_cv_header_path_$3 - include-directory if needed
1476 dnl     $cf_cv_library_path_$3 - library-directory if needed
1477 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1478 AC_DEFUN([CF_FIND_LINKAGE],[
1479
1480 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1481 # will be set on completion of the AC_TRY_LINK below.
1482 cf_cv_header_path_$3=
1483 cf_cv_library_path_$3=
1484
1485 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1486
1487 cf_save_LIBS="$LIBS"
1488
1489 AC_TRY_LINK([$1],[$2],[
1490         cf_cv_find_linkage_$3=yes
1491         cf_cv_header_path_$3=/usr/include
1492         cf_cv_library_path_$3=/usr/lib
1493 ],[
1494
1495 LIBS="-l$3 $7 $cf_save_LIBS"
1496
1497 AC_TRY_LINK([$1],[$2],[
1498         cf_cv_find_linkage_$3=yes
1499         cf_cv_header_path_$3=/usr/include
1500         cf_cv_library_path_$3=/usr/lib
1501         cf_cv_library_file_$3="-l$3"
1502 ],[
1503         cf_cv_find_linkage_$3=no
1504         LIBS="$cf_save_LIBS"
1505
1506     CF_VERBOSE(find linkage for $3 library)
1507     CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1508
1509     cf_save_CPPFLAGS="$CPPFLAGS"
1510     cf_test_CPPFLAGS="$CPPFLAGS"
1511
1512     CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1513     for cf_cv_header_path_$3 in $cf_search
1514     do
1515       if test -d $cf_cv_header_path_$3 ; then
1516         CF_VERBOSE(... testing $cf_cv_header_path_$3)
1517         CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
1518         AC_TRY_COMPILE([$1],[$2],[
1519             CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1520             cf_cv_find_linkage_$3=maybe
1521             cf_test_CPPFLAGS="$CPPFLAGS"
1522             break],[
1523             CPPFLAGS="$cf_save_CPPFLAGS"
1524             ])
1525       fi
1526     done
1527
1528     if test "$cf_cv_find_linkage_$3" = maybe ; then
1529
1530       CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1531
1532       cf_save_LIBS="$LIBS"
1533       cf_save_LDFLAGS="$LDFLAGS"
1534
1535       ifelse([$6],,,[
1536         CPPFLAGS="$cf_test_CPPFLAGS"
1537         LIBS="-l$3 $7 $cf_save_LIBS"
1538         AC_TRY_LINK([$1],[$2],[
1539             CF_VERBOSE(... found $3 library in system)
1540             cf_cv_find_linkage_$3=yes])
1541             CPPFLAGS="$cf_save_CPPFLAGS"
1542             LIBS="$cf_save_LIBS"
1543             ])
1544
1545       if test "$cf_cv_find_linkage_$3" != yes ; then
1546         CF_LIBRARY_PATH(cf_search,$3)
1547         for cf_cv_library_path_$3 in $cf_search
1548         do
1549           if test -d $cf_cv_library_path_$3 ; then
1550             CF_VERBOSE(... testing $cf_cv_library_path_$3)
1551             CPPFLAGS="$cf_test_CPPFLAGS"
1552             LIBS="-l$3 $7 $cf_save_LIBS"
1553             LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1554             AC_TRY_LINK([$1],[$2],[
1555                 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1556                 cf_cv_find_linkage_$3=yes
1557                 cf_cv_library_file_$3="-l$3"
1558                 break],[
1559                 CPPFLAGS="$cf_save_CPPFLAGS"
1560                 LIBS="$cf_save_LIBS"
1561                 LDFLAGS="$cf_save_LDFLAGS"
1562                 ])
1563           fi
1564         done
1565         CPPFLAGS="$cf_save_CPPFLAGS"
1566         LDFLAGS="$cf_save_LDFLAGS"
1567       fi
1568
1569     else
1570       cf_cv_find_linkage_$3=no
1571     fi
1572     ],$7)
1573 ])
1574
1575 LIBS="$cf_save_LIBS"
1576
1577 if test "$cf_cv_find_linkage_$3" = yes ; then
1578 ifelse([$4],,[
1579         CF_ADD_INCDIR($cf_cv_header_path_$3)
1580         CF_ADD_LIBDIR($cf_cv_library_path_$3)
1581         CF_ADD_LIB($3)
1582 ],[$4])
1583 else
1584 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1585 fi
1586 ])dnl
1587 dnl ---------------------------------------------------------------------------
1588 dnl CF_FIND_SUB_INCDIR version: 1 updated: 2014/04/12 16:47:01
1589 dnl ------------------
1590 dnl Find an include-directory with the given leaf-name.  This is useful for
1591 dnl example with FreeBSD ports, which use this convention to distinguish
1592 dnl different versions of the same port.
1593 AC_DEFUN([CF_FIND_SUB_INCDIR],[
1594         CF_SUBDIR_PATH(cf_search,$1,include)
1595         for cf_item in $cf_search
1596         do
1597                 case $cf_item in #(vi
1598                 */$1)
1599                         CF_ADD_INCDIR($cf_item)
1600                         ;;
1601                 esac
1602         done
1603 ])dnl
1604 dnl ---------------------------------------------------------------------------
1605 dnl CF_FIND_SUB_LIBDIR version: 1 updated: 2014/04/12 16:47:01
1606 dnl ------------------
1607 dnl Find a library-directory with the given leaf-name.  This is useful for
1608 dnl example with FreeBSD ports, which use this convention to distinguish
1609 dnl different versions of the same port.
1610 AC_DEFUN([CF_FIND_SUB_LIBDIR],[
1611         CF_SUBDIR_PATH(cf_search,$1,lib)
1612         for cf_item in $cf_search
1613         do
1614                 case $cf_item in #(vi
1615                 */$1)
1616                         CF_ADD_LIBDIR($cf_item)
1617                         ;;
1618                 esac
1619         done
1620 ])dnl
1621 dnl ---------------------------------------------------------------------------
1622 dnl CF_FIXUP_ADAFLAGS version: 1 updated: 2012/03/31 18:48:10
1623 dnl -----------------
1624 dnl make ADAFLAGS consistent with CFLAGS
1625 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
1626         AC_MSG_CHECKING(optimization options for ADAFLAGS)
1627         case "$CFLAGS" in
1628         *-g*)
1629                 CF_ADD_ADAFLAGS(-g)
1630                 ;;
1631         esac
1632         case "$CFLAGS" in
1633         *-O*)
1634                 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[        ]].*//'`
1635                 CF_ADD_ADAFLAGS($cf_O_flag)
1636                 ;;
1637         esac
1638         AC_MSG_RESULT($ADAFLAGS)
1639 ])dnl
1640 dnl ---------------------------------------------------------------------------
1641 dnl CF_FORGET_TOOL version: 1 updated: 2013/04/06 18:03:09
1642 dnl --------------
1643 dnl Forget that we saw the given tool.
1644 AC_DEFUN([CF_FORGET_TOOL],[
1645 unset ac_cv_prog_ac_ct_$1
1646 unset ac_ct_$1
1647 unset $1
1648 ])dnl
1649 dnl ---------------------------------------------------------------------------
1650 dnl CF_FUNC_DLSYM version: 3 updated: 2012/10/06 11:17:15
1651 dnl -------------
1652 dnl Test for dlsym() and related functions, as well as libdl.
1653 dnl
1654 dnl Sets
1655 dnl     $cf_have_dlsym
1656 dnl     $cf_have_libdl
1657 AC_DEFUN([CF_FUNC_DLSYM],[
1658 cf_have_dlsym=no
1659 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
1660
1661 cf_have_libdl=no
1662 AC_CHECK_LIB(dl,dlsym,[
1663         cf_have_dlsym=yes
1664         cf_have_libdl=yes])])
1665
1666 if test "$cf_have_dlsym" = yes ; then
1667         test "$cf_have_libdl" = yes && CF_ADD_LIB(dl)
1668
1669         AC_MSG_CHECKING(whether able to link to dl*() functions)
1670         AC_TRY_LINK([#include <dlfcn.h>],[
1671                 void *obj;
1672                 if ((obj = dlopen("filename", 0)) != 0) {
1673                         if (dlsym(obj, "symbolname") == 0) {
1674                         dlclose(obj);
1675                         }
1676                 }],[
1677                 AC_DEFINE(HAVE_LIBDL,1,[Define to 1 if we have dl library])],[
1678                 AC_MSG_ERROR(Cannot link test program for libdl)])
1679         AC_MSG_RESULT(ok)
1680 else
1681         AC_MSG_ERROR(Cannot find dlsym function)
1682 fi
1683 ])
1684 dnl ---------------------------------------------------------------------------
1685 dnl CF_FUNC_MEMMOVE version: 8 updated: 2012/10/04 20:12:20
1686 dnl ---------------
1687 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
1688 dnl is found, add our own version of memmove to the list of objects.
1689 AC_DEFUN([CF_FUNC_MEMMOVE],
1690 [
1691 AC_CHECK_FUNC(memmove,,[
1692 AC_CHECK_FUNC(bcopy,[
1693         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
1694                 AC_TRY_RUN([
1695 int main() {
1696         static char data[] = "abcdefghijklmnopqrstuwwxyz";
1697         char temp[40];
1698         bcopy(data, temp, sizeof(data));
1699         bcopy(temp+10, temp, 15);
1700         bcopy(temp+5, temp+15, 10);
1701         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
1702 }
1703                 ],
1704                 [cf_cv_good_bcopy=yes],
1705                 [cf_cv_good_bcopy=no],
1706                 [cf_cv_good_bcopy=unknown])
1707                 ])
1708         ],[cf_cv_good_bcopy=no])
1709         if test "$cf_cv_good_bcopy" = yes ; then
1710                 AC_DEFINE(USE_OK_BCOPY,1,[Define to 1 to use bcopy when memmove is unavailable])
1711         else
1712                 AC_DEFINE(USE_MY_MEMMOVE,1,[Define to 1 to use replacement function when memmove is unavailable])
1713         fi
1714 ])])dnl
1715 dnl ---------------------------------------------------------------------------
1716 dnl CF_FUNC_NANOSLEEP version: 4 updated: 2012/10/06 17:56:13
1717 dnl -----------------
1718 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
1719 dnl AIX 4.x, provide a non-working version.
1720 AC_DEFUN([CF_FUNC_NANOSLEEP],[
1721 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
1722 AC_TRY_RUN([
1723 #include <stdio.h>
1724 #include <errno.h>
1725 #include <time.h>
1726
1727 #ifdef HAVE_SYS_TIME_H
1728 #include <sys/time.h>
1729 #endif
1730
1731 int main() {
1732         struct timespec ts1, ts2;
1733         int code;
1734         ts1.tv_sec  = 0;
1735         ts1.tv_nsec = 750000000;
1736         ts2.tv_sec  = 0;
1737         ts2.tv_nsec = 0;
1738         errno = 0;
1739         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
1740         ${cf_cv_main_return:-return}(code != 0);
1741 }
1742 ],
1743         [cf_cv_func_nanosleep=yes],
1744         [cf_cv_func_nanosleep=no],
1745         [cf_cv_func_nanosleep=unknown])])
1746
1747 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP,1,[Define to 1 if we have nanosleep()])
1748 ])
1749 dnl ---------------------------------------------------------------------------
1750 dnl CF_FUNC_OPENPTY version: 3 updated: 2010/05/29 16:31:02
1751 dnl ---------------
1752 dnl Check for openpty() function, along with <pty.h> header.  It may need the
1753 dnl "util" library as well.
1754 AC_DEFUN([CF_FUNC_OPENPTY],
1755 [
1756 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1757 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1758     cf_save_LIBS="$LIBS"
1759     test $cf_cv_lib_util = yes && CF_ADD_LIB(util)
1760     for cf_header in pty.h libutil.h util.h
1761     do
1762     AC_TRY_LINK([
1763 #include <$cf_header>
1764 ],[
1765     int x = openpty((int *)0, (int *)0, (char *)0,
1766                    (struct termios *)0, (struct winsize *)0);
1767 ],[
1768         cf_cv_func_openpty=$cf_header
1769         break
1770 ],[
1771         cf_cv_func_openpty=no
1772 ])
1773     done
1774     LIBS="$cf_save_LIBS"
1775 ])
1776 ])dnl
1777 dnl ---------------------------------------------------------------------------
1778 dnl CF_FUNC_POLL version: 8 updated: 2012/10/04 05:24:07
1779 dnl ------------
1780 dnl See if the poll function really works.  Some platforms have poll(), but
1781 dnl it does not work for terminals or files.
1782 AC_DEFUN([CF_FUNC_POLL],[
1783 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1784 AC_TRY_RUN([
1785 #include <stdlib.h>
1786 #include <stdio.h>
1787 #include <unistd.h>
1788 #include <fcntl.h>
1789 #ifdef HAVE_POLL_H
1790 #include <poll.h>
1791 #else
1792 #include <sys/poll.h>
1793 #endif
1794 int main() {
1795         struct pollfd myfds;
1796         int ret;
1797
1798         /* check for Darwin bug with respect to "devices" */
1799         myfds.fd = open("/dev/null", 1);        /* O_WRONLY */
1800         if (myfds.fd < 0)
1801                 myfds.fd = 0;
1802         myfds.events = POLLIN;
1803         myfds.revents = 0;
1804
1805         ret = poll(&myfds, 1, 100);
1806
1807         if (ret < 0 || (myfds.revents & POLLNVAL)) {
1808                 ret = -1;
1809         } else {
1810                 int fd = 0;
1811                 if (!isatty(fd)) {
1812                         fd = open("/dev/tty", 2);       /* O_RDWR */
1813                 }
1814
1815                 if (fd >= 0) {
1816                         /* also check with standard input */
1817                         myfds.fd = fd;
1818                         myfds.events = POLLIN;
1819                         myfds.revents = 0;
1820                         ret = poll(&myfds, 1, 100);
1821                 } else {
1822                         ret = -1;
1823                 }
1824         }
1825         ${cf_cv_main_return:-return}(ret < 0);
1826 }],
1827         [cf_cv_working_poll=yes],
1828         [cf_cv_working_poll=no],
1829         [cf_cv_working_poll=unknown])])
1830 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL,1,[Define to 1 if the poll function seems to work])
1831 ])dnl
1832 dnl ---------------------------------------------------------------------------
1833 dnl CF_FUNC_TERMIOS version: 3 updated: 2012/10/06 17:56:13
1834 dnl ---------------
1835 dnl Some old/broken variations define tcgetattr() only as a macro in
1836 dnl termio(s).h
1837 AC_DEFUN([CF_FUNC_TERMIOS],[
1838 AC_REQUIRE([CF_STRUCT_TERMIOS])
1839 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1840 AC_TRY_LINK([
1841 #include <sys/types.h>
1842 #ifdef HAVE_UNISTD_H
1843 #include <unistd.h>
1844 #endif
1845 #ifdef HAVE_TERMIOS_H
1846 #include <termios.h>
1847 #define TTY struct termios
1848 #else
1849 #ifdef HAVE_TERMIO_H
1850 #include <termio.h>
1851 #define TTY struct termio
1852 #endif
1853 #endif
1854 ],[
1855 TTY foo;
1856 tcgetattr(1, &foo);],
1857 [cf_cv_have_tcgetattr=yes],
1858 [cf_cv_have_tcgetattr=no])])
1859 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR,1,[Define to 1 if we have tcgetattr])
1860 ])dnl
1861 dnl ---------------------------------------------------------------------------
1862 dnl CF_FUNC_VSSCANF version: 4 updated: 2012/10/06 17:56:13
1863 dnl ---------------
1864 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1865 dnl versions of C.  It is in the GNU C library, and can often be simulated by
1866 dnl other functions.
1867 AC_DEFUN([CF_FUNC_VSSCANF],
1868 [
1869 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1870 AC_TRY_LINK([
1871 #include <stdarg.h>
1872 #include <stdio.h>],[
1873         va_list ap;
1874         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1875 AC_TRY_LINK([
1876 #include <stdarg.h>
1877 #include <stdio.h>],[
1878     FILE strbuf;
1879     char *str = "from";
1880
1881     strbuf._flag = _IOREAD;
1882     strbuf._ptr = strbuf._base = (unsigned char *) str;
1883     strbuf._cnt = strlen(str);
1884     strbuf._file = _NFILE;
1885     return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1886 AC_TRY_LINK([
1887 #include <stdarg.h>
1888 #include <stdio.h>],[
1889     FILE strbuf;
1890     char *str = "from";
1891
1892     strbuf._flag = _IOREAD;
1893     strbuf._ptr = strbuf._base = (unsigned char *) str;
1894     strbuf._cnt = strlen(str);
1895     strbuf._file = _NFILE;
1896     return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1897 cf_cv_func_vsscanf=no])])])])
1898
1899 case $cf_cv_func_vsscanf in #(vi
1900 vsscanf) AC_DEFINE(HAVE_VSSCANF,1,[Define to 1 if we have vsscanf]);; #(vi
1901 vfscanf) AC_DEFINE(HAVE_VFSCANF,1,[Define to 1 if we have vfscanf]);; #(vi
1902 _doscan) AC_DEFINE(HAVE__DOSCAN,1,[Define to 1 if we have _doscan]);;
1903 esac
1904
1905 ])dnl
1906 dnl ---------------------------------------------------------------------------
1907 dnl CF_GCC_ATTRIBUTES version: 16 updated: 2012/10/02 20:55:03
1908 dnl -----------------
1909 dnl Test for availability of useful gcc __attribute__ directives to quiet
1910 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1911 dnl to documentation, unrecognized directives cause older compilers to barf.
1912 AC_DEFUN([CF_GCC_ATTRIBUTES],
1913 [
1914 if test "$GCC" = yes
1915 then
1916 cat > conftest.i <<EOF
1917 #ifndef GCC_PRINTF
1918 #define GCC_PRINTF 0
1919 #endif
1920 #ifndef GCC_SCANF
1921 #define GCC_SCANF 0
1922 #endif
1923 #ifndef GCC_NORETURN
1924 #define GCC_NORETURN /* nothing */
1925 #endif
1926 #ifndef GCC_UNUSED
1927 #define GCC_UNUSED /* nothing */
1928 #endif
1929 EOF
1930 if test "$GCC" = yes
1931 then
1932         AC_CHECKING([for $CC __attribute__ directives])
1933 cat > conftest.$ac_ext <<EOF
1934 #line __oline__ "${as_me:-configure}"
1935 #include "confdefs.h"
1936 #include "conftest.h"
1937 #include "conftest.i"
1938 #if     GCC_PRINTF
1939 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1940 #else
1941 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1942 #endif
1943 #if     GCC_SCANF
1944 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1945 #else
1946 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1947 #endif
1948 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1949 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1950 extern void foo(void) GCC_NORETURN;
1951 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1952 EOF
1953         cf_printf_attribute=no
1954         cf_scanf_attribute=no
1955         for cf_attribute in scanf printf unused noreturn
1956         do
1957                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1958                 cf_directive="__attribute__(($cf_attribute))"
1959                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1960
1961                 case $cf_attribute in #(vi
1962                 printf) #(vi
1963                         cf_printf_attribute=yes
1964                         cat >conftest.h <<EOF
1965 #define GCC_$cf_ATTRIBUTE 1
1966 EOF
1967                         ;;
1968                 scanf) #(vi
1969                         cf_scanf_attribute=yes
1970                         cat >conftest.h <<EOF
1971 #define GCC_$cf_ATTRIBUTE 1
1972 EOF
1973                         ;;
1974                 *) #(vi
1975                         cat >conftest.h <<EOF
1976 #define GCC_$cf_ATTRIBUTE $cf_directive
1977 EOF
1978                         ;;
1979                 esac
1980
1981                 if AC_TRY_EVAL(ac_compile); then
1982                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1983                         cat conftest.h >>confdefs.h
1984                         case $cf_attribute in #(vi
1985                         noreturn) #(vi
1986                                 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1987                                 ;;
1988                         printf) #(vi
1989                                 cf_value='/* nothing */'
1990                                 if test "$cf_printf_attribute" != no ; then
1991                                         cf_value='__attribute__((format(printf,fmt,var)))'
1992                                         AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1993                                 fi
1994                                 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1995                                 ;;
1996                         scanf) #(vi
1997                                 cf_value='/* nothing */'
1998                                 if test "$cf_scanf_attribute" != no ; then
1999                                         cf_value='__attribute__((format(scanf,fmt,var)))'
2000                                         AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
2001                                 fi
2002                                 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
2003                                 ;;
2004                         unused) #(vi
2005                                 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
2006                                 ;;
2007                         esac
2008                 fi
2009         done
2010 else
2011         fgrep define conftest.i >>confdefs.h
2012 fi
2013 rm -rf conftest*
2014 fi
2015 ])dnl
2016 dnl ---------------------------------------------------------------------------
2017 dnl CF_GCC_VERSION version: 7 updated: 2012/10/18 06:46:33
2018 dnl --------------
2019 dnl Find version of gcc
2020 AC_DEFUN([CF_GCC_VERSION],[
2021 AC_REQUIRE([AC_PROG_CC])
2022 GCC_VERSION=none
2023 if test "$GCC" = yes ; then
2024         AC_MSG_CHECKING(version of $CC)
2025         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.]].*//'`"
2026         test -z "$GCC_VERSION" && GCC_VERSION=unknown
2027         AC_MSG_RESULT($GCC_VERSION)
2028 fi
2029 ])dnl
2030 dnl ---------------------------------------------------------------------------
2031 dnl CF_GCC_WARNINGS version: 31 updated: 2013/11/19 19:23:35
2032 dnl ---------------
2033 dnl Check if the compiler supports useful warning options.  There's a few that
2034 dnl we don't use, simply because they're too noisy:
2035 dnl
2036 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
2037 dnl     -Wredundant-decls (system headers make this too noisy)
2038 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
2039 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
2040 dnl             is enabled for ncurses using "--enable-const".
2041 dnl     -pedantic
2042 dnl
2043 dnl Parameter:
2044 dnl     $1 is an optional list of gcc warning flags that a particular
2045 dnl             application might want to use, e.g., "no-unused" for
2046 dnl             -Wno-unused
2047 dnl Special:
2048 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
2049 dnl
2050 AC_DEFUN([CF_GCC_WARNINGS],
2051 [
2052 AC_REQUIRE([CF_GCC_VERSION])
2053 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
2054 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
2055
2056 cat > conftest.$ac_ext <<EOF
2057 #line __oline__ "${as_me:-configure}"
2058 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2059 EOF
2060
2061 if test "$INTEL_COMPILER" = yes
2062 then
2063 # The "-wdXXX" options suppress warnings:
2064 # remark #1419: external declaration in primary source file
2065 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2066 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2067 # remark #193: zero used for undefined preprocessing identifier
2068 # remark #593: variable "curs_sb_left_arrow" was set but never used
2069 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2070 # remark #869: parameter "tw" was never referenced
2071 # remark #981: operands are evaluated in unspecified order
2072 # warning #279: controlling expression is constant
2073
2074         AC_CHECKING([for $CC warning options])
2075         cf_save_CFLAGS="$CFLAGS"
2076         EXTRA_CFLAGS="-Wall"
2077         for cf_opt in \
2078                 wd1419 \
2079                 wd1683 \
2080                 wd1684 \
2081                 wd193 \
2082                 wd593 \
2083                 wd279 \
2084                 wd810 \
2085                 wd869 \
2086                 wd981
2087         do
2088                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
2089                 if AC_TRY_EVAL(ac_compile); then
2090                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2091                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
2092                 fi
2093         done
2094         CFLAGS="$cf_save_CFLAGS"
2095
2096 elif test "$GCC" = yes
2097 then
2098         AC_CHECKING([for $CC warning options])
2099         cf_save_CFLAGS="$CFLAGS"
2100         EXTRA_CFLAGS=
2101         cf_warn_CONST=""
2102         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
2103         cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
2104         test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
2105         for cf_opt in W Wall \
2106                 Wbad-function-cast \
2107                 Wcast-align \
2108                 Wcast-qual \
2109                 Wdeclaration-after-statement \
2110                 Wextra \
2111                 Winline \
2112                 Wmissing-declarations \
2113                 Wmissing-prototypes \
2114                 Wnested-externs \
2115                 Wpointer-arith \
2116                 Wshadow \
2117                 Wstrict-prototypes \
2118                 Wundef $cf_gcc_warnings $cf_warn_CONST $1
2119         do
2120                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
2121                 if AC_TRY_EVAL(ac_compile); then
2122                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2123                         case $cf_opt in #(vi
2124                         Wcast-qual) #(vi
2125                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
2126                                 ;;
2127                         Winline) #(vi
2128                                 case $GCC_VERSION in
2129                                 [[34]].*)
2130                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
2131                                         continue;;
2132                                 esac
2133                                 ;;
2134                         Wpointer-arith) #(vi
2135                                 case $GCC_VERSION in
2136                                 [[12]].*)
2137                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
2138                                         continue;;
2139                                 esac
2140                                 ;;
2141                         esac
2142                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
2143                 fi
2144         done
2145         CFLAGS="$cf_save_CFLAGS"
2146 fi
2147 rm -rf conftest*
2148
2149 AC_SUBST(EXTRA_CFLAGS)
2150 ])dnl
2151 dnl ---------------------------------------------------------------------------
2152 dnl CF_GETOPT_HEADER version: 6 updated: 2014/07/22 14:45:54
2153 dnl ----------------
2154 dnl Check for getopt's variables which are commonly defined in stdlib.h,
2155 dnl unistd.h or (nonstandard) in getopt.h
2156 AC_DEFUN([CF_GETOPT_HEADER],
2157 [
2158 AC_HAVE_HEADERS(unistd.h getopt.h)
2159 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
2160 cf_cv_getopt_header=none
2161 for cf_header in stdio.h stdlib.h unistd.h getopt.h
2162 do
2163 AC_TRY_COMPILE([
2164 #include <$cf_header>],
2165 [int x = optind; char *y = optarg],
2166 [cf_cv_getopt_header=$cf_header
2167  break])
2168 done
2169 ])
2170 if test $cf_cv_getopt_header != none ; then
2171         AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
2172 fi
2173 if test $cf_cv_getopt_header = getopt.h ; then
2174         AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
2175 fi
2176 ])dnl
2177 dnl ---------------------------------------------------------------------------
2178 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
2179 dnl -----------------
2180 AC_DEFUN([CF_GNATPREP_OPT_T],[
2181 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
2182 cf_cv_gnatprep_opt_t=no
2183 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
2184 ])
2185 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
2186 AC_SUBST(GNATPREP_OPTS)
2187 ])dnl
2188 dnl ---------------------------------------------------------------------------
2189 dnl CF_GNAT_GENERICS version: 2 updated: 2011/03/23 20:24:41
2190 dnl ----------------
2191 AC_DEFUN([CF_GNAT_GENERICS],
2192 [
2193 AC_REQUIRE([CF_GNAT_VERSION])
2194
2195 AC_MSG_CHECKING(if GNAT supports generics)
2196 case $cf_gnat_version in #(vi
2197 3.[[1-9]]*|[[4-9]].*) #(vi
2198         cf_gnat_generics=yes
2199         ;;
2200 *)
2201         cf_gnat_generics=no
2202         ;;
2203 esac
2204 AC_MSG_RESULT($cf_gnat_generics)
2205
2206 if test "$cf_gnat_generics" = yes
2207 then
2208         cf_compile_generics=generics
2209         cf_generic_objects="\${GENOBJS}"
2210 else
2211         cf_compile_generics=
2212         cf_generic_objects=
2213 fi
2214
2215 AC_SUBST(cf_compile_generics)
2216 AC_SUBST(cf_generic_objects)
2217 ])dnl
2218 dnl ---------------------------------------------------------------------------
2219 dnl CF_GNAT_PROJECTS version: 7 updated: 2014/06/01 10:46:34
2220 dnl ----------------
2221 dnl GNAT projects are configured with ".gpr" project files.
2222 dnl GNAT libraries are a further development, using the project feature.
2223 AC_DEFUN([CF_GNAT_PROJECTS],
2224 [
2225 AC_REQUIRE([CF_GNAT_VERSION])
2226 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
2227
2228 cf_gnat_libraries=no
2229 cf_gnat_projects=no
2230
2231 if test "$enable_gnat_projects" != no ; then
2232 AC_MSG_CHECKING(if GNAT supports project files)
2233 case $cf_gnat_version in #(vi
2234 3.[[0-9]]*) #(vi
2235         ;;
2236 *)
2237         case $cf_cv_system_name in #(vi
2238         cygwin*|msys*) #(vi
2239                 ;;
2240         *)
2241                 mkdir conftest.src conftest.bin conftest.lib
2242                 cd conftest.src
2243                 rm -rf conftest* *~conftest*
2244                 cat >>library.gpr <<CF_EOF
2245 project Library is
2246   Kind := External ("LIB_KIND");
2247   for Library_Name use "ConfTest";
2248   for Object_Dir use ".";
2249   for Library_ALI_Dir use External("LIBRARY_DIR");
2250   for Library_Version use External ("SONAME");
2251   for Library_Kind use Kind;
2252   for Library_Dir use External("BUILD_DIR");
2253   Source_Dir := External ("SOURCE_DIR");
2254   for Source_Dirs use (Source_Dir);
2255 end Library;
2256 CF_EOF
2257                 cat >>confpackage.ads <<CF_EOF
2258 package ConfPackage is
2259    procedure conftest;
2260 end ConfPackage;
2261 CF_EOF
2262                 cat >>confpackage.adb <<CF_EOF
2263 with Text_IO;
2264 package body ConfPackage is
2265    procedure conftest is
2266    begin
2267       Text_IO.Put ("Hello World");
2268       Text_IO.New_Line;
2269    end conftest;
2270 end ConfPackage;
2271 CF_EOF
2272                 if ( $cf_ada_make $ADAFLAGS \
2273                                 -Plibrary.gpr \
2274                                 -XBUILD_DIR=`cd ../conftest.bin;pwd` \
2275                                 -XLIBRARY_DIR=`cd ../conftest.lib;pwd` \
2276                                 -XSOURCE_DIR=`pwd` \
2277                                 -XSONAME=libConfTest.so.1 \
2278                                 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
2279                         cf_gnat_projects=yes
2280                 fi
2281                 cd ..
2282                 if test -f conftest.lib/confpackage.ali
2283                 then
2284                         cf_gnat_libraries=yes
2285                 fi
2286                 rm -rf conftest* *~conftest*
2287                 ;;
2288         esac
2289         ;;
2290 esac
2291 AC_MSG_RESULT($cf_gnat_projects)
2292 fi # enable_gnat_projects
2293
2294 if test $cf_gnat_projects = yes
2295 then
2296         AC_MSG_CHECKING(if GNAT supports libraries)
2297         AC_MSG_RESULT($cf_gnat_libraries)
2298 fi
2299
2300 if test "$cf_gnat_projects" = yes
2301 then
2302         USE_OLD_MAKERULES="#"
2303         USE_GNAT_PROJECTS=""
2304 else
2305         USE_OLD_MAKERULES=""
2306         USE_GNAT_PROJECTS="#"
2307 fi
2308
2309 if test "$cf_gnat_libraries" = yes
2310 then
2311         USE_GNAT_LIBRARIES=""
2312 else
2313         USE_GNAT_LIBRARIES="#"
2314 fi
2315
2316 AC_SUBST(USE_OLD_MAKERULES)
2317 AC_SUBST(USE_GNAT_PROJECTS)
2318 AC_SUBST(USE_GNAT_LIBRARIES)
2319 ])dnl
2320 dnl ---------------------------------------------------------------------------
2321 dnl CF_GNAT_SIGINT version: 1 updated: 2011/03/27 20:07:59
2322 dnl --------------
2323 dnl Check if gnat supports SIGINT, and presumably tasking.  For the latter, it
2324 dnl is noted that gnat may compile a tasking unit even for configurations which
2325 dnl fail at runtime.
2326 AC_DEFUN([CF_GNAT_SIGINT],[
2327 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
2328 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
2329
2330 package ConfTest is
2331
2332    pragma Warnings (Off);  --  the next pragma exists since 3.11p
2333    pragma Unreserve_All_Interrupts;
2334    pragma Warnings (On);
2335
2336    protected Process is
2337       procedure Stop;
2338       function Continue return Boolean;
2339       pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
2340    private
2341       Done : Boolean := False;
2342    end Process;
2343
2344 end ConfTest;],
2345 [package body ConfTest is
2346    protected body Process is
2347       procedure Stop is
2348       begin
2349          Done := True;
2350       end Stop;
2351       function Continue return Boolean is
2352       begin
2353          return not Done;
2354       end Continue;
2355    end Process;
2356 end ConfTest;],
2357         [cf_cv_gnat_sigint=yes],
2358         [cf_cv_gnat_sigint=no])])
2359
2360 if test $cf_cv_gnat_sigint = yes ; then
2361         USE_GNAT_SIGINT=""
2362 else
2363         USE_GNAT_SIGINT="#"
2364 fi
2365 AC_SUBST(USE_GNAT_SIGINT)
2366 ])dnl
2367 dnl ---------------------------------------------------------------------------
2368 dnl CF_GNAT_TRY_LINK version: 3 updated: 2011/03/19 14:47:45
2369 dnl ----------------
2370 dnl Verify that a test program compiles/links with GNAT.
2371 dnl $cf_ada_make is set to the program that compiles/links
2372 dnl $ADAFLAGS may be set to the GNAT flags.
2373 dnl
2374 dnl $1 is the text of the spec
2375 dnl $2 is the text of the body
2376 dnl $3 is the shell command to execute if successful
2377 dnl $4 is the shell command to execute if not successful
2378 AC_DEFUN([CF_GNAT_TRY_LINK],
2379 [
2380 rm -rf conftest* *~conftest*
2381 cat >>conftest.ads <<CF_EOF
2382 $1
2383 CF_EOF
2384 cat >>conftest.adb <<CF_EOF
2385 $2
2386 CF_EOF
2387 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
2388 ifelse($3,,      :,[      $3])
2389 ifelse($4,,,[else
2390    $4])
2391 fi
2392 rm -rf conftest* *~conftest*
2393 ])dnl
2394 dnl ---------------------------------------------------------------------------
2395 dnl CF_GNAT_TRY_RUN version: 5 updated: 2011/03/19 14:47:45
2396 dnl ---------------
2397 dnl Verify that a test program compiles and runs with GNAT
2398 dnl $cf_ada_make is set to the program that compiles/links
2399 dnl $ADAFLAGS may be set to the GNAT flags.
2400 dnl
2401 dnl $1 is the text of the spec
2402 dnl $2 is the text of the body
2403 dnl $3 is the shell command to execute if successful
2404 dnl $4 is the shell command to execute if not successful
2405 AC_DEFUN([CF_GNAT_TRY_RUN],
2406 [
2407 rm -rf conftest* *~conftest*
2408 cat >>conftest.ads <<CF_EOF
2409 $1
2410 CF_EOF
2411 cat >>conftest.adb <<CF_EOF
2412 $2
2413 CF_EOF
2414 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
2415    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
2416 ifelse($3,,      :,[      $3])
2417 ifelse($4,,,[   else
2418       $4])
2419    fi
2420 ifelse($4,,,[else
2421    $4])
2422 fi
2423 rm -rf conftest* *~conftest*
2424 ])dnl
2425 dnl ---------------------------------------------------------------------------
2426 dnl CF_GNAT_VERSION version: 18 updated: 2012/01/21 19:28:10
2427 dnl ---------------
2428 dnl Verify version of GNAT.
2429 AC_DEFUN([CF_GNAT_VERSION],
2430 [
2431 AC_MSG_CHECKING(for gnat version)
2432 cf_gnat_version=`${cf_ada_make:-gnatmake} -v 2>&1 | \
2433         grep '[[0-9]].[[0-9]][[0-9]]*' |\
2434     sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
2435 AC_MSG_RESULT($cf_gnat_version)
2436
2437 case $cf_gnat_version in #(vi
2438 3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|20[[0-9]][[0-9]]) #(vi
2439         cf_cv_prog_gnat_correct=yes
2440         ;;
2441 *)
2442         AC_MSG_WARN(Unsupported GNAT version $cf_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
2443         cf_cv_prog_gnat_correct=no
2444         ;;
2445 esac
2446 ])
2447 dnl ---------------------------------------------------------------------------
2448 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
2449 dnl -------------
2450 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
2451 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
2452 dnl (or misfeature) of glibc2, which breaks portability of many applications,
2453 dnl since it is interwoven with GNU extensions.
2454 dnl
2455 dnl Well, yes we could work around it...
2456 AC_DEFUN([CF_GNU_SOURCE],
2457 [
2458 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
2459 AC_TRY_COMPILE([#include <sys/types.h>],[
2460 #ifndef _XOPEN_SOURCE
2461 make an error
2462 #endif],
2463         [cf_cv_gnu_source=no],
2464         [cf_save="$CPPFLAGS"
2465          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
2466          AC_TRY_COMPILE([#include <sys/types.h>],[
2467 #ifdef _XOPEN_SOURCE
2468 make an error
2469 #endif],
2470         [cf_cv_gnu_source=no],
2471         [cf_cv_gnu_source=yes])
2472         CPPFLAGS="$cf_save"
2473         ])
2474 ])
2475 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
2476 ])dnl
2477 dnl ---------------------------------------------------------------------------
2478 dnl CF_GPP_LIBRARY version: 11 updated: 2012/10/06 17:56:13
2479 dnl --------------
2480 dnl If we're trying to use g++, test if libg++ is installed (a rather common
2481 dnl problem :-).  If we have the compiler but no library, we'll be able to
2482 dnl configure, but won't be able to build the c++ demo program.
2483 AC_DEFUN([CF_GPP_LIBRARY],
2484 [
2485 cf_cxx_library=unknown
2486 case $cf_cv_system_name in #(vi
2487 os2*) #(vi
2488         cf_gpp_libname=gpp
2489         ;;
2490 *)
2491         cf_gpp_libname=g++
2492         ;;
2493 esac
2494 if test "$GXX" = yes; then
2495         AC_MSG_CHECKING([for lib$cf_gpp_libname])
2496         cf_save="$LIBS"
2497         CF_ADD_LIB($cf_gpp_libname)
2498         AC_TRY_LINK([
2499 #include <$cf_gpp_libname/builtin.h>
2500         ],
2501         [two_arg_error_handler_t foo2 = lib_error_handler],
2502         [cf_cxx_library=yes
2503          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
2504          if test "$cf_gpp_libname" = cpp ; then
2505             AC_DEFINE(HAVE_GPP_BUILTIN_H,1,[Define to 1 if we have gpp builtin.h])
2506          else
2507             AC_DEFINE(HAVE_GXX_BUILTIN_H,1,[Define to 1 if we have g++ builtin.h])
2508          fi],
2509         [AC_TRY_LINK([
2510 #include <builtin.h>
2511         ],
2512         [two_arg_error_handler_t foo2 = lib_error_handler],
2513         [cf_cxx_library=yes
2514          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
2515          AC_DEFINE(HAVE_BUILTIN_H,1,[Define to 1 if we have builtin.h])],
2516         [cf_cxx_library=no])])
2517         LIBS="$cf_save"
2518         AC_MSG_RESULT($cf_cxx_library)
2519 fi
2520 ])dnl
2521 dnl ---------------------------------------------------------------------------
2522 dnl CF_GXX_VERSION version: 7 updated: 2012/06/16 14:55:39
2523 dnl --------------
2524 dnl Check for version of g++
2525 AC_DEFUN([CF_GXX_VERSION],[
2526 AC_REQUIRE([AC_PROG_CPP])
2527 GXX_VERSION=none
2528 if test "$GXX" = yes; then
2529         AC_MSG_CHECKING(version of ${CXX:-g++})
2530         GXX_VERSION="`${CXX:-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
2531         test -z "$GXX_VERSION" && GXX_VERSION=unknown
2532         AC_MSG_RESULT($GXX_VERSION)
2533 fi
2534 ])dnl
2535 dnl ---------------------------------------------------------------------------
2536 dnl CF_GXX_WARNINGS version: 8 updated: 2013/11/16 14:27:53
2537 dnl ---------------
2538 dnl Check if the compiler supports useful warning options.
2539 dnl
2540 dnl Most of gcc's options apply to g++, except:
2541 dnl     -Wbad-function-cast
2542 dnl     -Wmissing-declarations
2543 dnl     -Wnested-externs
2544 dnl
2545 dnl Omit a few (for now):
2546 dnl     -Winline
2547 dnl
2548 dnl Parameter:
2549 dnl     $1 is an optional list of g++ warning flags that a particular
2550 dnl             application might want to use, e.g., "no-unused" for
2551 dnl             -Wno-unused
2552 dnl Special:
2553 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
2554 dnl
2555 AC_DEFUN([CF_GXX_WARNINGS],
2556 [
2557
2558 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
2559 CF_CLANG_COMPILER(GXX,CLANG_CPLUSPLUS,CXXFLAGS)
2560
2561 AC_REQUIRE([CF_GXX_VERSION])
2562
2563 AC_LANG_SAVE
2564 AC_LANG_CPLUSPLUS
2565
2566 cat > conftest.$ac_ext <<EOF
2567 #line __oline__ "configure"
2568 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2569 EOF
2570
2571 if test "$INTEL_CPLUSPLUS" = yes
2572 then
2573 # The "-wdXXX" options suppress warnings:
2574 # remark #1419: external declaration in primary source file
2575 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2576 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2577 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2578 # remark #193: zero used for undefined preprocessing identifier
2579 # remark #593: variable "curs_sb_left_arrow" was set but never used
2580 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2581 # remark #869: parameter "tw" was never referenced
2582 # remark #981: operands are evaluated in unspecified order
2583 # warning #269: invalid format string conversion
2584
2585         AC_CHECKING([for $CC warning options])
2586         cf_save_CXXFLAGS="$CXXFLAGS"
2587         EXTRA_CXXFLAGS="-Wall"
2588         for cf_opt in \
2589                 wd1419 \
2590                 wd1682 \
2591                 wd1683 \
2592                 wd1684 \
2593                 wd193 \
2594                 wd279 \
2595                 wd593 \
2596                 wd810 \
2597                 wd869 \
2598                 wd981
2599         do
2600                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
2601                 if AC_TRY_EVAL(ac_compile); then
2602                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2603                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2604                 fi
2605         done
2606         CXXFLAGS="$cf_save_CXXFLAGS"
2607
2608 elif test "$GXX" = yes
2609 then
2610         AC_CHECKING([for $CXX warning options])
2611         cf_save_CXXFLAGS="$CXXFLAGS"
2612         EXTRA_CXXFLAGS="-W -Wall"
2613         cf_gxx_extra_warnings=""
2614         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
2615         case "$GCC_VERSION" in
2616         [[1-2]].*)
2617                 ;;
2618         *)
2619                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
2620                 ;;
2621         esac
2622         for cf_opt in \
2623                 Wabi \
2624                 fabi-version=0 \
2625                 Wextra \
2626                 Wignored-qualifiers \
2627                 Wlogical-op \
2628                 Woverloaded-virtual \
2629                 Wsign-promo \
2630                 Wsynth \
2631                 Wold-style-cast \
2632                 Wcast-align \
2633                 Wcast-qual \
2634                 Wpointer-arith \
2635                 Wshadow \
2636                 Wundef $cf_gxx_extra_warnings $1
2637         do
2638                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
2639                 if AC_TRY_EVAL(ac_compile); then
2640                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2641                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2642                 else
2643                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
2644                 fi
2645         done
2646         CXXFLAGS="$cf_save_CXXFLAGS"
2647 fi
2648
2649 rm -rf conftest*
2650 AC_LANG_RESTORE
2651 AC_SUBST(EXTRA_CXXFLAGS)
2652 ])dnl
2653 dnl ---------------------------------------------------------------------------
2654 dnl CF_HASHED_DB version: 5 updated: 2014/04/12 16:47:01
2655 dnl ------------
2656 dnl Look for an instance of the Berkeley hashed database.
2657 dnl
2658 dnl $1 = optional parameter, to specify install-prefix for the database.
2659 AC_DEFUN([CF_HASHED_DB],
2660 [
2661 ifelse([$1],,,[
2662 case $1 in #(vi
2663 yes|*able*) #(vi
2664     ;;
2665 *)
2666     if test -d "$1" ; then
2667         CF_ADD_INCDIR($1/include)
2668         CF_ADD_LIBDIR($1/lib)
2669         else
2670                 case "$1" in #(vi
2671                 ./*|../*|/*)
2672                         AC_MSG_WARN(no such directory $1)
2673                         ;; #(vi
2674                 *)
2675                         CF_FIND_SUB_INCDIR($1)
2676                         CF_FIND_SUB_LIBDIR($1)
2677                         ;;
2678                 esac
2679     fi
2680 esac
2681 ])
2682 AC_CHECK_HEADER(db.h,[
2683 CF_HASHED_DB_VERSION
2684 if test "$cf_cv_hashed_db_version" = unknown ; then
2685         AC_MSG_ERROR(Cannot determine version of db)
2686 else
2687         CF_HASHED_DB_LIBS
2688         if test "$cf_cv_hashed_db_libs" = unknown ; then
2689                 AC_MSG_ERROR(Cannot determine library for db)
2690         elif test "$cf_cv_hashed_db_libs" != default ; then
2691                 CF_ADD_LIB($cf_cv_hashed_db_libs)
2692         fi
2693 fi
2694 ],[
2695         AC_MSG_ERROR(Cannot find db.h)
2696 ])
2697 ])dnl
2698 dnl ---------------------------------------------------------------------------
2699 dnl CF_HASHED_DB_LIBS version: 9 updated: 2010/05/29 16:31:02
2700 dnl -----------------
2701 dnl Given that we have the header and version for hashed database, find the
2702 dnl library information.
2703 AC_DEFUN([CF_HASHED_DB_LIBS],
2704 [
2705 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
2706 cf_cv_hashed_db_libs=unknown
2707 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
2708 do
2709         cf_save_libs="$LIBS"
2710         if test -n "$cf_db_libs"; then
2711                 CF_ADD_LIB($cf_db_libs)
2712         fi
2713         CF_MSG_LOG(checking for library "$cf_db_libs")
2714         AC_TRY_LINK([
2715 $ac_includes_default
2716 #include <db.h>
2717 ],[
2718         char *path = "/tmp/foo";
2719 #ifdef DB_VERSION_MAJOR
2720 #if DB_VERSION_MAJOR >= 4
2721         DB *result = 0;
2722         db_create(&result, NULL, 0);
2723         result->open(result,
2724                 NULL,
2725                 path,
2726                 path,
2727                 DB_HASH,
2728                 DB_CREATE,
2729                 0644);
2730 #elif DB_VERSION_MAJOR >= 3
2731         DB *result = 0;
2732         db_create(&result, NULL, 0);
2733         result->open(result,
2734                 path,
2735                 path,
2736                 DB_HASH,
2737                 DB_CREATE,
2738                 0644);
2739 #elif DB_VERSION_MAJOR >= 2
2740         DB *result = 0;
2741         db_open(path,
2742                 DB_HASH,
2743                 DB_CREATE,
2744                 0644,
2745                 (DB_ENV *) 0,
2746                 (DB_INFO *) 0,
2747                 &result);
2748 #endif /* DB_VERSION_MAJOR */
2749 #else
2750         DB *result = dbopen(path,
2751                      2,
2752                      0644,
2753                      DB_HASH,
2754                      0);
2755 #endif
2756         ${cf_cv_main_return:-return}(result != 0)
2757 ],[
2758         if test -n "$cf_db_libs" ; then
2759                 cf_cv_hashed_db_libs=$cf_db_libs
2760         else
2761                 cf_cv_hashed_db_libs=default
2762         fi
2763         LIBS="$cf_save_libs"
2764         break
2765 ])
2766         LIBS="$cf_save_libs"
2767 done
2768 ])
2769 ])dnl
2770 dnl ---------------------------------------------------------------------------
2771 dnl CF_HASHED_DB_VERSION version: 4 updated: 2014/04/12 16:47:01
2772 dnl --------------------
2773 dnl Given that we have the header file for hashed database, find the version
2774 dnl information.
2775 AC_DEFUN([CF_HASHED_DB_VERSION],
2776 [
2777 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
2778 cf_cv_hashed_db_version=unknown
2779
2780 for cf_db_version in 1 2 3 4 5 6
2781 do
2782         CF_MSG_LOG(checking for db version $cf_db_version)
2783         AC_TRY_COMPILE([
2784 $ac_includes_default
2785 #include <db.h>
2786
2787 #ifdef DB_VERSION_MAJOR
2788         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
2789 #if $cf_db_version == DB_VERSION_MAJOR
2790         /* ok */
2791 #else
2792         make an error
2793 #endif
2794 #else
2795 #if $cf_db_version == 1
2796         /* ok: assuming this is DB 1.8.5 */
2797 #else
2798         make an error
2799 #endif
2800 #endif
2801 ],[DBT *foo = 0],[
2802         cf_cv_hashed_db_version=$cf_db_version
2803         break
2804         ])
2805 done
2806 ])
2807 ])dnl
2808 dnl ---------------------------------------------------------------------------
2809 dnl CF_HEADER_PATH version: 12 updated: 2010/05/05 05:22:40
2810 dnl --------------
2811 dnl Construct a search-list of directories for a nonstandard header-file
2812 dnl
2813 dnl Parameters
2814 dnl     $1 = the variable to return as result
2815 dnl     $2 = the package name
2816 AC_DEFUN([CF_HEADER_PATH],
2817 [
2818 $1=
2819
2820 # collect the current set of include-directories from compiler flags
2821 cf_header_path_list=""
2822 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2823         for cf_header_path in $CPPFLAGS $CFLAGS
2824         do
2825                 case $cf_header_path in #(vi
2826                 -I*)
2827                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2828                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2829                         cf_header_path_list="$cf_header_path_list [$]$1"
2830                         ;;
2831                 esac
2832         done
2833 fi
2834
2835 # add the variations for the package we are looking for
2836 CF_SUBDIR_PATH($1,$2,include)
2837
2838 test "$includedir" != NONE && \
2839 test "$includedir" != "/usr/include" && \
2840 test -d "$includedir" && {
2841         test -d $includedir &&    $1="[$]$1 $includedir"
2842         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
2843 }
2844
2845 test "$oldincludedir" != NONE && \
2846 test "$oldincludedir" != "/usr/include" && \
2847 test -d "$oldincludedir" && {
2848         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
2849         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
2850 }
2851
2852 $1="[$]$1 $cf_header_path_list"
2853 ])dnl
2854 dnl ---------------------------------------------------------------------------
2855 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
2856 dnl ---------------
2857 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2858 AC_DEFUN([CF_HELP_MESSAGE],
2859 [AC_DIVERT_HELP([$1])dnl
2860 ])dnl
2861 dnl ---------------------------------------------------------------------------
2862 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
2863 dnl ---------------
2864 dnl Construct the list of include-options according to whether we're building
2865 dnl in the source directory or using '--srcdir=DIR' option.
2866 AC_DEFUN([CF_INCLUDE_DIRS],
2867 [
2868 if test "$srcdir" != "."; then
2869         CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
2870 fi
2871 CPPFLAGS="-I../include $CPPFLAGS"
2872 if test "$srcdir" != "."; then
2873         CPPFLAGS="-I\${srcdir} $CPPFLAGS"
2874 fi
2875 CPPFLAGS="-I. $CPPFLAGS"
2876 AC_SUBST(CPPFLAGS)
2877 ])dnl
2878 dnl ---------------------------------------------------------------------------
2879 dnl CF_INTEL_COMPILER version: 6 updated: 2014/03/17 13:13:07
2880 dnl -----------------
2881 dnl Check if the given compiler is really the Intel compiler for Linux.  It
2882 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2883 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2884 dnl
2885 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2886 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
2887 dnl the wrappers for gcc and g++ warnings.
2888 dnl
2889 dnl $1 = GCC (default) or GXX
2890 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2891 dnl $3 = CFLAGS (default) or CXXFLAGS
2892 AC_DEFUN([CF_INTEL_COMPILER],[
2893 AC_REQUIRE([AC_CANONICAL_HOST])
2894 ifelse([$2],,INTEL_COMPILER,[$2])=no
2895
2896 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2897         case $host_os in
2898         linux*|gnu*)
2899                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2900                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2901                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2902                 AC_TRY_COMPILE([],[
2903 #ifdef __INTEL_COMPILER
2904 #else
2905 make an error
2906 #endif
2907 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2908 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2909 ],[])
2910                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2911                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2912                 ;;
2913         esac
2914 fi
2915 ])dnl
2916 dnl ---------------------------------------------------------------------------
2917 dnl CF_ISASCII version: 4 updated: 2012/10/06 17:56:13
2918 dnl ----------
2919 dnl Check if we have either a function or macro for 'isascii()'.
2920 AC_DEFUN([CF_ISASCII],
2921 [
2922 AC_MSG_CHECKING(for isascii)
2923 AC_CACHE_VAL(cf_cv_have_isascii,[
2924         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
2925         [cf_cv_have_isascii=yes],
2926         [cf_cv_have_isascii=no])
2927 ])dnl
2928 AC_MSG_RESULT($cf_cv_have_isascii)
2929 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII,1,[Define to 1 if we have isascii()])
2930 ])dnl
2931 dnl ---------------------------------------------------------------------------
2932 dnl CF_LARGEFILE version: 8 updated: 2012/10/06 08:57:51
2933 dnl ------------
2934 dnl Add checks for large file support.
2935 AC_DEFUN([CF_LARGEFILE],[
2936 ifdef([AC_FUNC_FSEEKO],[
2937     AC_SYS_LARGEFILE
2938     if test "$enable_largefile" != no ; then
2939         AC_FUNC_FSEEKO
2940
2941         # Normally we would collect these definitions in the config.h,
2942         # but (like _XOPEN_SOURCE), some environments rely on having these
2943         # defined before any of the system headers are included.  Another
2944         # case comes up with C++, e.g., on AIX the compiler compiles the
2945         # header files by themselves before looking at the body files it is
2946         # told to compile.  For ncurses, those header files do not include
2947         # the config.h
2948         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
2949         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
2950         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
2951
2952         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2953                 AC_TRY_COMPILE([
2954 #include <sys/types.h>
2955 #include <dirent.h>
2956                 ],[
2957                 /* if transitional largefile support is setup, this is true */
2958                 extern struct dirent64 * readdir(DIR *);
2959                 struct dirent64 *x = readdir((DIR *)0);
2960                 struct dirent *y = readdir((DIR *)0);
2961                 int z = x - y;
2962                 ],
2963                 [cf_cv_struct_dirent64=yes],
2964                 [cf_cv_struct_dirent64=no])
2965         ])
2966         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64])
2967     fi
2968 ])
2969 ])
2970 dnl ---------------------------------------------------------------------------
2971 dnl CF_LDFLAGS_STATIC version: 10 updated: 2011/09/24 12:51:48
2972 dnl -----------------
2973 dnl Check for compiler/linker flags used to temporarily force usage of static
2974 dnl libraries.  This depends on the compiler and platform.  Use this to help
2975 dnl ensure that the linker picks up a given library based on its position in
2976 dnl the list of linker options and libraries.
2977 AC_DEFUN([CF_LDFLAGS_STATIC],[
2978
2979 if test "$GCC" = yes ; then
2980         case $cf_cv_system_name in #(
2981         OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*)         #( vi
2982                 LDFLAGS_STATIC=
2983                 LDFLAGS_SHARED=
2984                 ;;
2985     *)  #( normally, except when broken
2986         LDFLAGS_STATIC=-static
2987         LDFLAGS_SHARED=-dynamic
2988         ;;
2989     esac
2990 else
2991         case $cf_cv_system_name in #(
2992         aix[[4-7]]*)    #( from ld manpage
2993                 LDFLAGS_STATIC=-bstatic
2994                 LDFLAGS_SHARED=-bdynamic
2995                 ;;
2996         hpux*)          #( from ld manpage for hpux10.20, hpux11.11
2997                 # We could also use just "archive" and "shared".
2998                 LDFLAGS_STATIC=-Wl,-a,archive_shared
2999                 LDFLAGS_SHARED=-Wl,-a,shared_archive
3000                 ;;
3001         irix*)          #( from ld manpage IRIX64
3002                 LDFLAGS_STATIC=-Bstatic
3003                 LDFLAGS_SHARED=-Bdynamic
3004                 ;;
3005         osf[[45]]*)     #( from ld manpage osf4.0d, osf5.1
3006                 # alternative "-oldstyle_liblookup" (not in cc manpage)
3007                 LDFLAGS_STATIC=-noso
3008                 LDFLAGS_SHARED=-so_archive
3009                 ;;
3010         solaris2*)
3011                 LDFLAGS_STATIC=-Bstatic
3012                 LDFLAGS_SHARED=-Bdynamic
3013                 ;;
3014         esac
3015 fi
3016
3017 if test -n "$LDFLAGS_STATIC" && test -n "$LDFLAGS_SHARED"
3018 then
3019         AC_MSG_CHECKING(if linker supports switching between static/dynamic)
3020
3021         rm -f libconftest.a
3022         cat >conftest.$ac_ext <<EOF
3023 #line __oline__ "configure"
3024 #include <stdio.h>
3025 int cf_ldflags_static(FILE *fp) { return fflush(fp); }
3026 EOF
3027         if AC_TRY_EVAL(ac_compile) ; then
3028                 ( $AR $ARFLAGS libconftest.a conftest.o ) 2>&AC_FD_CC 1>/dev/null
3029                 ( eval $RANLIB libconftest.a ) 2>&AC_FD_CC >/dev/null
3030         fi
3031         rm -f conftest.*
3032
3033         cf_save_LIBS="$LIBS"
3034
3035         LIBS="$LDFLAGS_STATIC -L`pwd` -lconftest $LDFLAGS_DYNAMIC $LIBS"
3036         AC_TRY_LINK([
3037 #line __oline__ "configure"
3038 #include <stdio.h>
3039 int cf_ldflags_static(FILE *fp);
3040 ],[
3041         return cf_ldflags_static(stdin);
3042 ],[
3043         # some linkers simply ignore the -dynamic
3044         case x`file conftest$ac_exeext 2>/dev/null` in #(vi
3045         *static*) # (vi
3046                 cf_ldflags_static=no
3047                 ;;
3048         *)
3049                 cf_ldflags_static=yes
3050                 ;;
3051         esac
3052 ],[cf_ldflags_static=no])
3053
3054         rm -f libconftest.*
3055         LIBS="$cf_save_LIBS"
3056
3057         AC_MSG_RESULT($cf_ldflags_static)
3058
3059         if test $cf_ldflags_static != yes
3060         then
3061                 LDFLAGS_STATIC=
3062                 LDFLAGS_SHARED=
3063         fi
3064 else
3065         LDFLAGS_STATIC=
3066         LDFLAGS_SHARED=
3067 fi
3068
3069 AC_SUBST(LDFLAGS_STATIC)
3070 AC_SUBST(LDFLAGS_SHARED)
3071 ])
3072 dnl ---------------------------------------------------------------------------
3073 dnl CF_LD_RPATH_OPT version: 5 updated: 2011/07/17 14:48:41
3074 dnl ---------------
3075 dnl For the given system and compiler, find the compiler flags to pass to the
3076 dnl loader to use the "rpath" feature.
3077 AC_DEFUN([CF_LD_RPATH_OPT],
3078 [
3079 AC_REQUIRE([CF_CHECK_CACHE])
3080
3081 LD_RPATH_OPT=
3082 AC_MSG_CHECKING(for an rpath option)
3083 case $cf_cv_system_name in #(vi
3084 irix*) #(vi
3085         if test "$GCC" = yes; then
3086                 LD_RPATH_OPT="-Wl,-rpath,"
3087         else
3088                 LD_RPATH_OPT="-rpath "
3089         fi
3090         ;;
3091 linux*|gnu*|k*bsd*-gnu) #(vi
3092         LD_RPATH_OPT="-Wl,-rpath,"
3093         ;;
3094 openbsd[[2-9]].*|mirbsd*) #(vi
3095         LD_RPATH_OPT="-Wl,-rpath,"
3096         ;;
3097 dragonfly*|freebsd*) #(vi
3098         LD_RPATH_OPT="-rpath "
3099         ;;
3100 netbsd*) #(vi
3101         LD_RPATH_OPT="-Wl,-rpath,"
3102         ;;
3103 osf*|mls+*) #(vi
3104         LD_RPATH_OPT="-rpath "
3105         ;;
3106 solaris2*) #(vi
3107         LD_RPATH_OPT="-R"
3108         ;;
3109 *)
3110         ;;
3111 esac
3112 AC_MSG_RESULT($LD_RPATH_OPT)
3113
3114 case "x$LD_RPATH_OPT" in #(vi
3115 x-R*)
3116         AC_MSG_CHECKING(if we need a space after rpath option)
3117         cf_save_LIBS="$LIBS"
3118         CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
3119         AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
3120         LIBS="$cf_save_LIBS"
3121         AC_MSG_RESULT($cf_rpath_space)
3122         test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
3123         ;;
3124 esac
3125 ])dnl
3126 dnl ---------------------------------------------------------------------------
3127 dnl CF_LIBRARY_PATH version: 9 updated: 2010/03/28 12:52:50
3128 dnl ---------------
3129 dnl Construct a search-list of directories for a nonstandard library-file
3130 dnl
3131 dnl Parameters
3132 dnl     $1 = the variable to return as result
3133 dnl     $2 = the package name
3134 AC_DEFUN([CF_LIBRARY_PATH],
3135 [
3136 $1=
3137 cf_library_path_list=""
3138 if test -n "${LDFLAGS}${LIBS}" ; then
3139         for cf_library_path in $LDFLAGS $LIBS
3140         do
3141                 case $cf_library_path in #(vi
3142                 -L*)
3143                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
3144                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
3145                         cf_library_path_list="$cf_library_path_list [$]$1"
3146                         ;;
3147                 esac
3148         done
3149 fi
3150
3151 CF_SUBDIR_PATH($1,$2,lib)
3152
3153 $1="$cf_library_path_list [$]$1"
3154 ])dnl
3155 dnl ---------------------------------------------------------------------------
3156 dnl CF_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09
3157 dnl ------------------
3158 AC_DEFUN([CF_LIBTOOL_VERSION],[
3159 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
3160 then
3161         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.]].*//'`
3162 else
3163         cf_cv_libtool_version=
3164 fi
3165 test -z "$cf_cv_libtool_version" && unset cf_cv_libtool_version
3166 ])dnl
3167 dnl ---------------------------------------------------------------------------
3168 dnl CF_LIB_PREFIX version: 9 updated: 2012/01/21 19:28:10
3169 dnl -------------
3170 dnl Compute the library-prefix for the given host system
3171 dnl $1 = variable to set
3172 define([CF_LIB_PREFIX],
3173 [
3174         case $cf_cv_system_name in #(vi
3175         OS/2*|os2*) #(vi
3176         LIB_PREFIX=''
3177         ;;
3178         *)      LIB_PREFIX='lib'
3179         ;;
3180         esac
3181 ifelse($1,,,[$1=$LIB_PREFIX])
3182         AC_SUBST(LIB_PREFIX)
3183 ])dnl
3184 dnl ---------------------------------------------------------------------------
3185 dnl CF_LIB_RULES version: 77 updated: 2015/01/03 11:49:39
3186 dnl ------------
3187 dnl Append definitions and rules for the given models to the subdirectory
3188 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
3189 dnl subdirectory is a library-source directory, modify the Libs_To_Make list in
3190 dnl the corresponding makefile to list the models that we'll generate.
3191 dnl
3192 dnl For shared libraries, make a list of symbolic links to construct when
3193 dnl generating each library.  The convention used for Linux is the simplest
3194 dnl one:
3195 dnl     lib<name>.so    ->
3196 dnl     lib<name>.so.<major>    ->
3197 dnl     lib<name>.so.<maj>.<minor>
3198 dnl
3199 dnl Note: Libs_To_Make is mixed case, since it is not a pure autoconf variable.
3200 AC_DEFUN([CF_LIB_RULES],
3201 [
3202 cf_prefix=$LIB_PREFIX
3203 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
3204
3205 case $cf_cv_shlib_version in #(vi
3206 cygdll|msysdll|mingw)
3207         TINFO_NAME=$TINFO_ARG_SUFFIX
3208         TINFO_SUFFIX=.dll
3209         ;;
3210 esac
3211
3212 if test -n "$TINFO_SUFFIX" ; then
3213         case $TINFO_SUFFIX in
3214         tw*)
3215                 TINFO_NAME="${TINFO_NAME}tw"
3216                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^tw//'`
3217                 ;;
3218         t*)
3219                 TINFO_NAME="${TINFO_NAME}t"
3220                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^t//'`
3221                 ;;
3222         w*)
3223                 TINFO_NAME="${TINFO_NAME}w"
3224                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^w//'`
3225                 ;;
3226         esac
3227 fi
3228
3229 for cf_dir in $SRC_SUBDIRS
3230 do
3231         if test ! -d $srcdir/$cf_dir ; then
3232                 continue
3233         elif test -f $srcdir/$cf_dir/modules; then
3234
3235                 SHARED_LIB=
3236                 Libs_To_Make=
3237
3238                 if test -n "${cf_cv_abi_version}" && test "x${cf_cv_abi_version}" != "x5"
3239                 then
3240                         cat >>$cf_dir/Makefile <<CF_EOF
3241
3242 # Generated by CF_LIB_RULES
3243 resulting.map: $UNALTERED_SYMS
3244         sed -e "s/NCURSES\\([[WT]]\\+\\)\?_/NCURSES\\1${cf_cv_abi_version}_/g" < $UNALTERED_SYMS >\[$]@
3245
3246 clean::
3247         rm -f resulting.map
3248 CF_EOF
3249                 fi
3250
3251                 for cf_item in $cf_LIST_MODELS
3252                 do
3253                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
3254                         cf_libname=$cf_dir
3255                         test "$cf_dir" = c++ && cf_libname=ncurses++
3256                         if test $cf_item = shared ; then
3257                                 if test -n "${LIB_SUFFIX}"
3258                                 then
3259                                         cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${LIB_SUFFIX}"'//'`
3260                                 else
3261                                         cf_shared_suffix="$cf_suffix"
3262                                 fi
3263                                 if test "$cf_cv_do_symlinks" = yes ; then
3264                                         cf_version_name=
3265
3266                                         case "$cf_cv_shlib_version" in #(vi
3267                                         rel) #(vi
3268                                                 cf_version_name=REL_VERSION
3269                                                 ;;
3270                                         abi)
3271                                                 cf_version_name=ABI_VERSION
3272                                                 ;;
3273                                         esac
3274
3275                                         if test -n "$cf_version_name"
3276                                         then
3277                                                 case "$cf_cv_system_name" in #(vi
3278                                                 darwin*)
3279                                                         # "w", etc?
3280                                                         cf_suffix="${LIB_SUFFIX}"'.${'$cf_version_name'}'"$cf_shared_suffix"
3281                                                         ;; #(vi
3282                                                 *)
3283                                                         cf_suffix="$cf_suffix"'.${'$cf_version_name'}'
3284                                                         ;;
3285                                                 esac
3286                                         fi
3287                                         if test -n "${LIB_SUFFIX}"
3288                                         then
3289                                                 cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${LIB_SUFFIX}"'//'`
3290                                         else
3291                                                 cf_shared_suffix="$cf_suffix"
3292                                         fi
3293                                 fi
3294                                 # cygwin needs import library, and has unique naming convention
3295                                 # use autodetected ${cf_prefix} for import lib and static lib, but
3296                                 # use 'cyg' prefix for shared lib.
3297                                 case $cf_cv_shlib_version in #(vi
3298                                 cygdll) #(vi
3299                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
3300                                         Libs_To_Make="$Libs_To_Make ../lib/cyg${cf_libname}${cf_cygsuf}"
3301                                         continue
3302                                         ;;
3303                                 msysdll) #(vi
3304                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
3305                                         Libs_To_Make="$Libs_To_Make ../lib/msys-${cf_libname}${cf_cygsuf}"
3306                                         continue
3307                                         ;;
3308                                 mingw)
3309                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
3310                                         Libs_To_Make="$Libs_To_Make ../lib/lib${cf_libname}${cf_cygsuf}"
3311                                         continue
3312                                         ;;
3313                                 esac
3314                         fi
3315                         Libs_To_Make="$Libs_To_Make ../lib/${cf_prefix}${cf_libname}${cf_suffix}"
3316                 done
3317
3318                 if test $cf_dir = ncurses ; then
3319                         cf_subsets="$LIB_SUBSETS"
3320                         cf_r_parts="$cf_subsets"
3321                         cf_liblist="$Libs_To_Make"
3322
3323                         while test -n "$cf_r_parts"
3324                         do
3325                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
3326                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
3327                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
3328                                         cf_item=
3329                                         case $cf_l_parts in #(vi
3330                                         *termlib*) #(vi
3331                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
3332                                                 ;;
3333                                         *ticlib*)
3334                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
3335                                                 ;;
3336                                         *)
3337                                                 break
3338                                                 ;;
3339                                         esac
3340                                         if test -n "$cf_item"; then
3341                                                 Libs_To_Make="$cf_item $Libs_To_Make"
3342                                         fi
3343                                 else
3344                                         break
3345                                 fi
3346                         done
3347                 else
3348                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
3349                 fi
3350
3351                 if test $cf_dir = c++; then
3352                         if test "x$with_shared_cxx" != xyes && test -n "$cf_shared_suffix"; then
3353                                 cf_list=
3354                                 for cf_item in $Libs_To_Make
3355                                 do
3356                                         case $cf_item in
3357                                         *.a)
3358                                                 ;;
3359                                         *)
3360                                                 cf_item=`echo "$cf_item" | sed -e "s,"$cf_shared_suffix",.a,"`
3361                                                 ;;
3362                                         esac
3363                                         for cf_test in $cf_list
3364                                         do
3365                                                 if test "$cf_test" = "$cf_item"
3366                                                 then
3367                                                         cf_LIST_MODELS=`echo "$cf_LIST_MODELS" | sed -e 's/normal//'`
3368                                                         cf_item=
3369                                                         break
3370                                                 fi
3371                                         done
3372                                         test -n "$cf_item" && cf_list="$cf_list $cf_item"
3373                                 done
3374                                 Libs_To_Make="$cf_list"
3375                         fi
3376                 fi
3377
3378                 sed -e "s%@Libs_To_Make@%$Libs_To_Make%" \
3379                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
3380                         $cf_dir/Makefile >$cf_dir/Makefile.out
3381                 mv $cf_dir/Makefile.out $cf_dir/Makefile
3382
3383                 $AWK -f $srcdir/mk-0th.awk \
3384                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" ticlib="$TICS_LIB_SUFFIX" termlib="$TINFO_LIB_SUFFIX" \
3385                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3386
3387                 for cf_subset in $cf_subsets
3388                 do
3389                         cf_subdirs=
3390                         for cf_item in $cf_LIST_MODELS
3391                         do
3392
3393                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
3394                         CF_UPPER(cf_ITEM,$cf_item)
3395
3396                         CXX_MODEL=$cf_ITEM
3397                         if test "$CXX_MODEL" = SHARED; then
3398                                 case $cf_cv_shlib_version in #(vi
3399                                 cygdll|msysdll|mingw) #(vi
3400                                         test "x$with_shared_cxx" = xno && CF_VERBOSE(overriding CXX_MODEL to SHARED)
3401                                         with_shared_cxx=yes
3402                                         ;;
3403                                 *)
3404                                         test "x$with_shared_cxx" = xno && CXX_MODEL=NORMAL
3405                                         ;;
3406                                 esac
3407                         fi
3408
3409                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
3410                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
3411
3412                         # Test for case where we build libtinfo with a different name.
3413                         cf_libname=$cf_dir
3414                         if test $cf_dir = ncurses ; then
3415                                 case $cf_subset in
3416                                 *base*)
3417                                         cf_libname=${cf_libname}$LIB_SUFFIX
3418                                         ;;
3419                                 *termlib*)
3420                                         cf_libname=$TINFO_LIB_SUFFIX
3421                                         ;;
3422                                 ticlib*)
3423                                         cf_libname=$TICS_LIB_SUFFIX
3424                                         ;;
3425                                 esac
3426                         elif test $cf_dir = c++ ; then
3427                                 cf_libname=ncurses++$LIB_SUFFIX
3428                         else
3429                                 cf_libname=${cf_libname}$LIB_SUFFIX
3430                         fi
3431                         if test -n "${DFT_ARG_SUFFIX}" ; then
3432                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
3433                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
3434                         fi
3435
3436                         # These dependencies really are for development, not
3437                         # builds, but they are useful in porting, too.
3438                         cf_depend="../include/ncurses_cfg.h"
3439                         if test "$srcdir" = "."; then
3440                                 cf_reldir="."
3441                         else
3442                                 cf_reldir="\${srcdir}"
3443                         fi
3444
3445                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
3446                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
3447                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
3448                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
3449                         fi
3450
3451                         cf_dir_suffix=
3452                         old_cf_suffix="$cf_suffix"
3453                         if test "$cf_cv_shlib_version_infix" = yes ; then
3454                         if test -n "$LIB_SUFFIX" ; then
3455                                 case $LIB_SUFFIX in
3456                                 tw*)
3457                                         cf_libname=`echo $cf_libname | sed 's/tw$//'`
3458                                         cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
3459                                         cf_dir_suffix=tw
3460                                         ;;
3461                                 t*)
3462                                         cf_libname=`echo $cf_libname | sed 's/t$//'`
3463                                         cf_suffix=`echo $cf_suffix | sed 's/^t//'`
3464                                         cf_dir_suffix=t
3465                                         ;;
3466                                 w*)
3467                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
3468                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
3469                                         cf_dir_suffix=w
3470                                         ;;
3471                                 esac
3472                         fi
3473                         fi
3474
3475                         $AWK -f $srcdir/mk-1st.awk \
3476                                 name=${cf_libname}${cf_dir_suffix} \
3477                                 traces=$LIB_TRACING \
3478                                 MODEL=$cf_ITEM \
3479                                 CXX_MODEL=$CXX_MODEL \
3480                                 model=$cf_subdir \
3481                                 prefix=$cf_prefix \
3482                                 suffix=$cf_suffix \
3483                                 subset=$cf_subset \
3484                                 driver=$cf_cv_term_driver \
3485                                 SymLink="$LN_S" \
3486                                 TermlibRoot=$TINFO_NAME \
3487                                 TermlibSuffix=$TINFO_SUFFIX \
3488                                 ShlibVer=$cf_cv_shlib_version \
3489                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
3490                                 ReLink=${cf_cv_do_relink:-no} \
3491                                 DoLinks=$cf_cv_do_symlinks \
3492                                 rmSoLocs=$cf_cv_rm_so_locs \
3493                                 ldconfig="$LDCONFIG" \
3494                                 overwrite=$WITH_OVERWRITE \
3495                                 depend="$cf_depend" \
3496                                 host="$host" \
3497                                 libtool_version="$LIBTOOL_VERSION" \
3498                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3499
3500                         cf_suffix="$old_cf_suffix"
3501
3502                         for cf_subdir2 in $cf_subdirs lib
3503                         do
3504                                 test $cf_subdir = $cf_subdir2 && break
3505                         done
3506                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
3507                         $AWK -f $srcdir/mk-2nd.awk \
3508                                 name=$cf_dir \
3509                                 traces=$LIB_TRACING \
3510                                 MODEL=$cf_ITEM \
3511                                 model=$cf_subdir \
3512                                 subset=$cf_subset \
3513                                 srcdir=$srcdir \
3514                                 echo=$WITH_ECHO \
3515                                 crenames=$cf_cv_prog_CC_c_o \
3516                                 cxxrenames=$cf_cv_prog_CXX_c_o \
3517                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3518                         cf_subdirs="$cf_subdirs $cf_subdir"
3519                         done
3520                 done
3521         fi
3522
3523         echo '  cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@' >>Makefile
3524 done
3525
3526 for cf_dir in $SRC_SUBDIRS
3527 do
3528         if test ! -d $srcdir/$cf_dir ; then
3529                 continue
3530         fi
3531
3532         if test -f $cf_dir/Makefile ; then
3533                 case "$cf_dir" in
3534                 Ada95) #(vi
3535                         echo 'libs \' >> Makefile
3536                         echo 'install.libs \' >> Makefile
3537                         echo 'uninstall.libs ::' >> Makefile
3538                         echo '  cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@' >> Makefile
3539                         ;;
3540                 esac
3541         fi
3542
3543         if test -f $srcdir/$cf_dir/modules; then
3544                 echo >> Makefile
3545                 if test -f $srcdir/$cf_dir/headers; then
3546 cat >> Makefile <<CF_EOF
3547 install.includes \\
3548 uninstall.includes \\
3549 CF_EOF
3550                 fi
3551 if test "$cf_dir" != "c++" ; then
3552 echo 'lint \' >> Makefile
3553 fi
3554 cat >> Makefile <<CF_EOF
3555 libs \\
3556 lintlib \\
3557 install.libs \\
3558 uninstall.libs \\
3559 install.$cf_dir \\
3560 uninstall.$cf_dir ::
3561         cd $cf_dir && \${MAKE} \${TOP_MFLAGS} \[$]@
3562 CF_EOF
3563         elif test -f $srcdir/$cf_dir/headers; then
3564 cat >> Makefile <<CF_EOF
3565
3566 libs \\
3567 install.libs \\
3568 uninstall.libs \\
3569 install.includes \\
3570 uninstall.includes ::
3571         cd $cf_dir && \${MAKE} \${TOP_MFLAGS} \[$]@
3572 CF_EOF
3573 fi
3574 done
3575
3576 if test "x$cf_with_db_install" = xyes; then
3577 cat >> Makefile <<CF_EOF
3578
3579 install.libs uninstall.libs \\
3580 install.data uninstall.data ::
3581 $MAKE_TERMINFO  cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@
3582 CF_EOF
3583 else
3584 cat >> Makefile <<CF_EOF
3585
3586 install.libs uninstall.libs ::
3587         cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@
3588 CF_EOF
3589 fi
3590
3591 if test "x$cf_with_manpages" = xyes; then
3592 cat >> Makefile <<CF_EOF
3593
3594 install.man \\
3595 uninstall.man ::
3596         cd man && \${MAKE} \${TOP_MFLAGS} \[$]@
3597 CF_EOF
3598 fi
3599
3600 cat >> Makefile <<CF_EOF
3601
3602 distclean ::
3603         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
3604         rm -f headers.sh headers.sed mk_shared_lib.sh
3605         rm -f edit_man.* man_alias.*
3606         rm -rf \${DIRS_TO_MAKE}
3607 CF_EOF
3608
3609 # Special case: tack's manpage lives in its own directory.
3610 if test "x$cf_with_manpages" = xyes; then
3611 if test -d tack ; then
3612 if test -f $srcdir/$tack.h; then
3613 cat >> Makefile <<CF_EOF
3614
3615 install.man \\
3616 uninstall.man ::
3617         cd tack && \${MAKE} \${TOP_MFLAGS} \[$]@
3618 CF_EOF
3619 fi
3620 fi
3621 fi
3622
3623 dnl If we're installing into a subdirectory of /usr/include, etc., we should
3624 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
3625 dnl anything, and will make it more standardized.  It's awkward to decide this
3626 dnl at configuration because of quoting, so we'll simply make all headers
3627 dnl installed via a script that can do the right thing.
3628
3629 rm -f headers.sed headers.sh
3630
3631 dnl ( generating this script makes the makefiles a little tidier :-)
3632 echo creating headers.sh
3633 cat >headers.sh <<CF_EOF
3634 #! /bin/sh
3635 # This shell script is generated by the 'configure' script.  It is invoked in a
3636 # subdirectory of the build tree.  It generates a sed-script in the parent
3637 # directory that is used to adjust includes for header files that reside in a
3638 # subdirectory of /usr/include, etc.
3639 PRG=""
3640 while test \[$]# != 3
3641 do
3642 PRG="\$PRG \[$]1"; shift
3643 done
3644 DST=\[$]1
3645 REF=\[$]2
3646 SRC=\[$]3
3647 TMPSRC=\${TMPDIR:-/tmp}/\`basename \$SRC\`\$\$
3648 TMPSED=\${TMPDIR:-/tmp}/headers.sed\$\$
3649 echo installing \$SRC in \$DST
3650 CF_EOF
3651
3652 if test $WITH_CURSES_H = yes; then
3653         cat >>headers.sh <<CF_EOF
3654 case \$DST in
3655 /*/include/*)
3656         END=\`basename \$DST\`
3657         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
3658         do
3659                 NAME=\`basename \$i\`
3660                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
3661         done
3662         ;;
3663 *)
3664         echo "" >> \$TMPSED
3665         ;;
3666 esac
3667 CF_EOF
3668
3669 else
3670         cat >>headers.sh <<CF_EOF
3671 case \$DST in
3672 /*/include/*)
3673         END=\`basename \$DST\`
3674         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
3675         do
3676                 NAME=\`basename \$i\`
3677                 if test "\$NAME" = "curses.h"
3678                 then
3679                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
3680                         NAME=ncurses.h
3681                 fi
3682                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
3683         done
3684         ;;
3685 *)
3686         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
3687         ;;
3688 esac
3689 CF_EOF
3690 fi
3691 cat >>headers.sh <<CF_EOF
3692 rm -f \$TMPSRC
3693 sed -f \$TMPSED \$SRC > \$TMPSRC
3694 NAME=\`basename \$SRC\`
3695 CF_EOF
3696 if test $WITH_CURSES_H != yes; then
3697         cat >>headers.sh <<CF_EOF
3698 test "\$NAME" = "curses.h" && NAME=ncurses.h
3699 CF_EOF
3700 fi
3701 cat >>headers.sh <<CF_EOF
3702 # Just in case someone gzip'd manpages, remove the conflicting copy.
3703 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
3704
3705 eval \$PRG \$TMPSRC \$DST/\$NAME
3706 rm -f \$TMPSRC \$TMPSED
3707 CF_EOF
3708
3709 chmod 0755 headers.sh
3710
3711 for cf_dir in $SRC_SUBDIRS
3712 do
3713         if test ! -d $srcdir/$cf_dir ; then
3714                 continue
3715         fi
3716
3717         if test -f $srcdir/$cf_dir/headers; then
3718                 $AWK -f $srcdir/mk-hdr.awk \
3719                         subset="$LIB_SUBSETS" \
3720                         compat="$WITH_CURSES_H" \
3721                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
3722         fi
3723
3724         if test -f $srcdir/$cf_dir/modules; then
3725                 if test "$cf_dir" != "c++" ; then
3726                         cat >>$cf_dir/Makefile <<"CF_EOF"
3727 depend : ${AUTO_SRC}
3728         makedepend -- ${CPPFLAGS} -- ${C_SRC}
3729
3730 # DO NOT DELETE THIS LINE -- make depend depends on it.
3731 CF_EOF
3732                 fi
3733         fi
3734 done
3735 AC_SUBST(Libs_To_Make)
3736 ])dnl
3737 dnl ---------------------------------------------------------------------------
3738 dnl CF_LIB_SONAME version: 5 updated: 2010/08/14 18:25:37
3739 dnl -------------
3740 dnl Find the and soname for the given shared library.  Set the cache variable
3741 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
3742 dnl variable to "unknown".
3743 dnl
3744 dnl $1 = headers
3745 dnl $2 = code
3746 dnl $3 = library name
3747 AC_DEFUN([CF_LIB_SONAME],
3748 [
3749 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
3750
3751 cf_cv_$3_soname=unknown
3752 if test "$cross_compiling" != yes ; then
3753 cat >conftest.$ac_ext <<CF_EOF
3754 $1
3755 int main()
3756 {
3757 $2
3758         ${cf_cv_main_return:-return}(0);
3759 }
3760 CF_EOF
3761 cf_save_LIBS="$LIBS"
3762         CF_ADD_LIB($3)
3763         if AC_TRY_EVAL(ac_compile) ; then
3764                 if AC_TRY_EVAL(ac_link) ; then
3765                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
3766                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
3767                 fi
3768         fi
3769 rm -rf conftest*
3770 LIBS="$cf_save_LIBS"
3771 fi
3772 ])
3773 ])
3774 dnl ---------------------------------------------------------------------------
3775 dnl CF_LIB_SUFFIX version: 23 updated: 2014/06/21 17:47:12
3776 dnl -------------
3777 dnl Compute the library file-suffix from the given model name
3778 dnl $1 = model name
3779 dnl $2 = variable to set (the nominal library suffix)
3780 dnl $3 = dependency variable to set (actual filename)
3781 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
3782 AC_DEFUN([CF_LIB_SUFFIX],
3783 [
3784         case X$1 in #(vi
3785         Xlibtool) #(vi
3786                 $2='.la'
3787                 $3=[$]$2
3788                 ;;
3789         Xdebug) #(vi
3790                 $2='_g.a'
3791                 $3=[$]$2
3792                 ;;
3793         Xprofile) #(vi
3794                 $2='_p.a'
3795                 $3=[$]$2
3796                 ;;
3797         Xshared) #(vi
3798                 case $cf_cv_system_name in
3799                 aix[[5-7]]*) #(vi
3800                         $2='.so'
3801                         $3=[$]$2
3802                         ;;
3803                 cygwin*|msys*|mingw*) #(vi
3804                         $2='.dll'
3805                         $3='.dll.a'
3806                         ;;
3807                 darwin*) #(vi
3808                         $2='.dylib'
3809                         $3=[$]$2
3810                         ;;
3811                 hpux*) #(vi
3812                         case $target in
3813                         ia64*) #(vi
3814                                 $2='.so'
3815                                 $3=[$]$2
3816                                 ;;
3817                         *) #(vi
3818                                 $2='.sl'
3819                                 $3=[$]$2
3820                                 ;;
3821                         esac
3822                         ;;
3823                 *) #(vi
3824                         $2='.so'
3825                         $3=[$]$2
3826                         ;;
3827                 esac
3828                 ;;
3829         *)
3830                 $2='.a'
3831                 $3=[$]$2
3832                 ;;
3833         esac
3834         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3835         test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
3836 ])dnl
3837 dnl ---------------------------------------------------------------------------
3838 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
3839 dnl -----------
3840 dnl Compute the string to append to -library from the given model name
3841 dnl $1 = model name
3842 dnl $2 = variable to set
3843 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
3844 AC_DEFUN([CF_LIB_TYPE],
3845 [
3846         case $1 in
3847         libtool) $2=''   ;;
3848         normal)  $2=''   ;;
3849         debug)   $2='_g' ;;
3850         profile) $2='_p' ;;
3851         shared)  $2=''   ;;
3852         esac
3853         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3854 ])dnl
3855 dnl ---------------------------------------------------------------------------
3856 dnl CF_LINK_DATAONLY version: 10 updated: 2012/10/06 17:41:51
3857 dnl ----------------
3858 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
3859 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
3860 dnl have to provide wrappers for global tables to ensure they're linked
3861 dnl properly.
3862 AC_DEFUN([CF_LINK_DATAONLY],
3863 [
3864 AC_MSG_CHECKING([if data-only library module links])
3865 AC_CACHE_VAL(cf_cv_link_dataonly,[
3866         rm -f conftest.a
3867         cat >conftest.$ac_ext <<EOF
3868 #line __oline__ "configure"
3869 int     testdata[[3]] = { 123, 456, 789 };
3870 EOF
3871         if AC_TRY_EVAL(ac_compile) ; then
3872                 mv conftest.o data.o && \
3873                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
3874         fi
3875         rm -f conftest.$ac_ext data.o
3876         cat >conftest.$ac_ext <<EOF
3877 #line __oline__ "configure"
3878 int     testfunc()
3879 {
3880 #if defined(NeXT)
3881         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
3882 #else
3883         extern int testdata[[3]];
3884         return testdata[[0]] == 123
3885            &&  testdata[[1]] == 456
3886            &&  testdata[[2]] == 789;
3887 #endif
3888 }
3889 EOF
3890         if AC_TRY_EVAL(ac_compile); then
3891                 mv conftest.o func.o && \
3892                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
3893         fi
3894         rm -f conftest.$ac_ext func.o
3895         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
3896         cf_saveLIBS="$LIBS"
3897         LIBS="conftest.a $LIBS"
3898         AC_TRY_RUN([
3899         int main()
3900         {
3901                 extern int testfunc();
3902                 ${cf_cv_main_return:-return} (!testfunc());
3903         }
3904         ],
3905         [cf_cv_link_dataonly=yes],
3906         [cf_cv_link_dataonly=no],
3907         [cf_cv_link_dataonly=unknown])
3908         LIBS="$cf_saveLIBS"
3909         ])
3910 AC_MSG_RESULT($cf_cv_link_dataonly)
3911
3912 if test "$cf_cv_link_dataonly" = no ; then
3913         AC_DEFINE(BROKEN_LINKER,1,[if data-only library module does not link])
3914         BROKEN_LINKER=1
3915 fi
3916
3917 ])dnl
3918 dnl ---------------------------------------------------------------------------
3919 dnl CF_LINK_FUNCS version: 8 updated: 2012/10/06 17:56:13
3920 dnl -------------
3921 dnl Most Unix systems have both link and symlink, a few don't have symlink.
3922 dnl A few non-Unix systems implement symlink, but not link.
3923 dnl A few non-systems implement neither (or have nonfunctional versions).
3924 AC_DEFUN([CF_LINK_FUNCS],
3925 [
3926 AC_CHECK_FUNCS( \
3927         remove \
3928         unlink )
3929
3930 if test "$cross_compiling" = yes ; then
3931         AC_CHECK_FUNCS( \
3932                 link \
3933                 symlink )
3934 else
3935         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
3936                 cf_cv_link_funcs=
3937                 for cf_func in link symlink ; do
3938                         AC_TRY_RUN([
3939 #include <sys/types.h>
3940 #include <sys/stat.h>
3941 #ifdef HAVE_UNISTD_H
3942 #include <unistd.h>
3943 #endif
3944 int main()
3945 {
3946         int fail = 0;
3947         char *src = "config.log";
3948         char *dst = "conftest.chk";
3949         struct stat src_sb;
3950         struct stat dst_sb;
3951
3952         stat(src, &src_sb);
3953         fail = ($cf_func("config.log", "conftest.chk") < 0)
3954             || (stat(dst, &dst_sb) < 0)
3955             || (dst_sb.st_mtime != src_sb.st_mtime);
3956 #ifdef HAVE_UNLINK
3957         unlink(dst);
3958 #else
3959         remove(dst);
3960 #endif
3961         ${cf_cv_main_return:-return} (fail);
3962 }
3963                         ],[
3964                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
3965                         eval 'ac_cv_func_'$cf_func'=yes'],[
3966                         eval 'ac_cv_func_'$cf_func'=no'],[
3967                         eval 'ac_cv_func_'$cf_func'=error'])
3968                 done
3969                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
3970         ])
3971         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK,1,[Define to 1 if we have link() function])
3972         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK,1,[Define to 1 if we have symlink() function])
3973 fi
3974 ])dnl
3975 dnl ---------------------------------------------------------------------------
3976 dnl CF_MAKEFLAGS version: 15 updated: 2014/05/10 16:43:23
3977 dnl ------------
3978 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
3979 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
3980 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
3981 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
3982 AC_DEFUN([CF_MAKEFLAGS],
3983 [
3984 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
3985         cf_cv_makeflags=''
3986         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
3987         do
3988                 cat >cf_makeflags.tmp <<CF_EOF
3989 SHELL = /bin/sh
3990 all :
3991         @ echo '.$cf_option'
3992 CF_EOF
3993                 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | fgrep -v "ing directory" | sed -e 's,[[   ]]*$,,'`
3994                 case "$cf_result" in
3995                 .*k|.*kw)
3996                         cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
3997                         case "$cf_result" in
3998                         .*CC=*) cf_cv_makeflags=
3999                                 ;;
4000                         *)      cf_cv_makeflags=$cf_option
4001                                 ;;
4002                         esac
4003                         break
4004                         ;;
4005                 .-)     ;;
4006                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
4007                         ;;
4008                 esac
4009         done
4010         rm -f cf_makeflags.tmp
4011 ])
4012
4013 AC_SUBST(cf_cv_makeflags)
4014 ])dnl
4015 dnl ---------------------------------------------------------------------------
4016 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
4017 dnl ------------
4018 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
4019 dnl a monocase filesystem.
4020 AC_DEFUN([CF_MAKE_TAGS],[
4021 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
4022
4023 AC_CHECK_PROGS(CTAGS, exctags ctags)
4024 AC_CHECK_PROGS(ETAGS, exetags etags)
4025
4026 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
4027
4028 if test "$cf_cv_mixedcase" = yes ; then
4029         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
4030 else
4031         MAKE_UPPER_TAGS=no
4032 fi
4033
4034 if test "$MAKE_UPPER_TAGS" = yes ; then
4035         MAKE_UPPER_TAGS=
4036 else
4037         MAKE_UPPER_TAGS="#"
4038 fi
4039
4040 if test "$MAKE_LOWER_TAGS" = yes ; then
4041         MAKE_LOWER_TAGS=
4042 else
4043         MAKE_LOWER_TAGS="#"
4044 fi
4045
4046 AC_SUBST(CTAGS)
4047 AC_SUBST(ETAGS)
4048
4049 AC_SUBST(MAKE_UPPER_TAGS)
4050 AC_SUBST(MAKE_LOWER_TAGS)
4051 ])dnl
4052 dnl ---------------------------------------------------------------------------
4053 dnl CF_MANPAGE_FORMAT version: 9 updated: 2010/10/23 16:10:30
4054 dnl -----------------
4055 dnl Option to allow user to override automatic configuration of manpage format.
4056 dnl There are several special cases:
4057 dnl
4058 dnl     gzip - man checks for, can display gzip'd files
4059 dnl     compress - man checks for, can display compressed files
4060 dnl     BSDI - files in the cat-directories are suffixed ".0"
4061 dnl     formatted - installer should format (put files in cat-directory)
4062 dnl     catonly - installer should only format, e.g., for a turnkey system.
4063 dnl
4064 dnl There are other configurations which this macro does not test, e.g., HPUX's
4065 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
4066 dnl convention would not match our use).
4067 AC_DEFUN([CF_MANPAGE_FORMAT],
4068 [
4069 AC_REQUIRE([CF_PATHSEP])
4070 AC_MSG_CHECKING(format of man-pages)
4071
4072 AC_ARG_WITH(manpage-format,
4073         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
4074                           optionally formatted/catonly, e.g., gzip,formatted],
4075         [MANPAGE_FORMAT=$withval],
4076         [MANPAGE_FORMAT=unknown])
4077
4078 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
4079 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
4080
4081 cf_unknown=
4082
4083 case $MANPAGE_FORMAT in
4084 unknown)
4085   if test -z "$MANPATH" ; then
4086     MANPATH="/usr/man:/usr/share/man"
4087   fi
4088
4089   # look for the 'date' man-page (it's most likely to be installed!)
4090   MANPAGE_FORMAT=
4091   cf_preform=no
4092   cf_catonly=yes
4093   cf_example=date
4094
4095   IFS="${IFS:-  }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
4096   for cf_dir in $MANPATH; do
4097     test -z "$cf_dir" && cf_dir=/usr/man
4098     for cf_name in $cf_dir/man*/$cf_example.[[01]]* $cf_dir/cat*/$cf_example.[[01]]* $cf_dir/man*/$cf_example $cf_dir/cat*/$cf_example
4099     do
4100       cf_test=`echo $cf_name | sed -e 's/*//'`
4101       if test "x$cf_test" = "x$cf_name" ; then
4102
4103         case "$cf_name" in
4104         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
4105         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
4106         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
4107         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
4108         esac
4109
4110         case "$cf_name" in
4111         $cf_dir/man*)
4112           cf_catonly=no
4113           ;;
4114         $cf_dir/cat*)
4115           cf_preform=yes
4116           ;;
4117         esac
4118         break
4119       fi
4120
4121       # if we found a match in either man* or cat*, stop looking
4122       if test -n "$MANPAGE_FORMAT" ; then
4123         cf_found=no
4124         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
4125         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
4126         case "$cf_name" in
4127         $cf_dir/cat*)
4128           cf_found=yes
4129           ;;
4130         esac
4131         test $cf_found=yes && break
4132       fi
4133     done
4134     # only check the first directory in $MANPATH where we find manpages
4135     if test -n "$MANPAGE_FORMAT" ; then
4136        break
4137     fi
4138   done
4139   # if we did not find the example, just assume it is normal
4140   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
4141   IFS="$ac_save_ifs"
4142   ;;
4143 *)
4144   for cf_option in $MANPAGE_FORMAT; do
4145      case $cf_option in #(vi
4146      gzip|compress|BSDI|normal|formatted|catonly)
4147        ;;
4148      *)
4149        cf_unknown="$cf_unknown $cf_option"
4150        ;;
4151      esac
4152   done
4153   ;;
4154 esac
4155
4156 AC_MSG_RESULT($MANPAGE_FORMAT)
4157 if test -n "$cf_unknown" ; then
4158   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
4159 fi
4160 ])dnl
4161 dnl ---------------------------------------------------------------------------
4162 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
4163 dnl ------------------
4164 dnl The Debian people have their own naming convention for manpages.  This
4165 dnl option lets us override the name of the file containing renaming, or
4166 dnl disable it altogether.
4167 AC_DEFUN([CF_MANPAGE_RENAMES],
4168 [
4169 AC_MSG_CHECKING(for manpage renaming)
4170
4171 AC_ARG_WITH(manpage-renames,
4172         [  --with-manpage-renames  specify manpage-renaming],
4173         [MANPAGE_RENAMES=$withval],
4174         [MANPAGE_RENAMES=yes])
4175
4176 case ".$MANPAGE_RENAMES" in #(vi
4177 .no) #(vi
4178   ;;
4179 .|.yes)
4180   # Debian 'man' program?
4181   if test -f /etc/debian_version ; then
4182     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
4183   else
4184     MANPAGE_RENAMES=no
4185   fi
4186   ;;
4187 esac
4188
4189 if test "$MANPAGE_RENAMES" != no ; then
4190   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
4191     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
4192   elif test ! -f $MANPAGE_RENAMES ; then
4193     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
4194   fi
4195
4196   test ! -d man && mkdir man
4197
4198   # Construct a sed-script to perform renaming within man-pages
4199   if test -n "$MANPAGE_RENAMES" ; then
4200     test ! -d man && mkdir man
4201     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
4202   fi
4203 fi
4204
4205 AC_MSG_RESULT($MANPAGE_RENAMES)
4206 AC_SUBST(MANPAGE_RENAMES)
4207 ])dnl
4208 dnl ---------------------------------------------------------------------------
4209 dnl CF_MANPAGE_SYMLINKS version: 5 updated: 2010/07/24 17:12:40
4210 dnl -------------------
4211 dnl Some people expect each tool to make all aliases for manpages in the
4212 dnl man-directory.  This accommodates the older, less-capable implementations
4213 dnl of 'man', and is optional.
4214 AC_DEFUN([CF_MANPAGE_SYMLINKS],
4215 [
4216 AC_MSG_CHECKING(if manpage aliases will be installed)
4217
4218 AC_ARG_WITH(manpage-aliases,
4219         [  --with-manpage-aliases  specify manpage-aliases using .so],
4220         [MANPAGE_ALIASES=$withval],
4221         [MANPAGE_ALIASES=yes])
4222
4223 AC_MSG_RESULT($MANPAGE_ALIASES)
4224
4225 case "x$LN_S" in #(vi
4226 xln*) #(vi
4227         cf_use_symlinks=yes
4228         ;;
4229 *)
4230         cf_use_symlinks=no
4231         ;;
4232 esac
4233
4234 MANPAGE_SYMLINKS=no
4235 if test "$MANPAGE_ALIASES" = yes ; then
4236 AC_MSG_CHECKING(if manpage symlinks should be used)
4237
4238 AC_ARG_WITH(manpage-symlinks,
4239         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
4240         [MANPAGE_SYMLINKS=$withval],
4241         [MANPAGE_SYMLINKS=$cf_use_symlinks])
4242
4243 if test "$$cf_use_symlinks" = no; then
4244 if test "$MANPAGE_SYMLINKS" = yes ; then
4245         AC_MSG_WARN(cannot make symlinks, will use .so files)
4246         MANPAGE_SYMLINKS=no
4247 fi
4248 fi
4249
4250 AC_MSG_RESULT($MANPAGE_SYMLINKS)
4251 fi
4252
4253 ])dnl
4254 dnl ---------------------------------------------------------------------------
4255 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
4256 dnl --------------
4257 dnl This option causes manpages to be run through tbl(1) to generate tables
4258 dnl correctly.
4259 AC_DEFUN([CF_MANPAGE_TBL],
4260 [
4261 AC_MSG_CHECKING(for manpage tbl)
4262
4263 AC_ARG_WITH(manpage-tbl,
4264         [  --with-manpage-tbl      specify manpage processing with tbl],
4265         [MANPAGE_TBL=$withval],
4266         [MANPAGE_TBL=no])
4267
4268 AC_MSG_RESULT($MANPAGE_TBL)
4269 ])dnl
4270 dnl ---------------------------------------------------------------------------
4271 dnl CF_MAN_PAGES version: 43 updated: 2013/02/09 12:53:45
4272 dnl ------------
4273 dnl Try to determine if the man-pages on the system are compressed, and if
4274 dnl so, what format is used.  Use this information to construct a script that
4275 dnl will install man-pages.
4276 AC_DEFUN([CF_MAN_PAGES],
4277 [
4278 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
4279 CF_MANPAGE_FORMAT
4280 CF_MANPAGE_RENAMES
4281 CF_MANPAGE_SYMLINKS
4282 CF_MANPAGE_TBL
4283
4284   if test "$prefix" = "NONE" ; then
4285      cf_prefix="$ac_default_prefix"
4286   else
4287      cf_prefix="$prefix"
4288   fi
4289
4290   case "$MANPAGE_FORMAT" in # (vi
4291   *catonly*) # (vi
4292     cf_format=yes
4293     cf_inboth=no
4294     ;;
4295   *formatted*) # (vi
4296     cf_format=yes
4297     cf_inboth=yes
4298     ;;
4299   *)
4300     cf_format=no
4301     cf_inboth=no
4302     ;;
4303   esac
4304
4305 test ! -d man && mkdir man
4306
4307 cf_so_strip=
4308 cf_compress=
4309 case "$MANPAGE_FORMAT" in #(vi
4310 *compress*) #(vi
4311         cf_so_strip="Z"
4312         cf_compress=compress
4313   ;;
4314 *gzip*)
4315         cf_so_strip="gz"
4316         cf_compress=gzip
4317   ;;
4318 esac
4319
4320 cf_edit_man=./edit_man.sh
4321 cf_man_alias=`pwd`/man_alias.sed
4322
4323 cat >$cf_edit_man <<CF_EOF
4324 #! /bin/sh
4325 # this script is generated by the configure-script CF_MAN_PAGES macro.
4326
4327 prefix="$cf_prefix"
4328 datarootdir="$datarootdir"
4329 datadir="$datadir"
4330
4331 NCURSES_MAJOR="$NCURSES_MAJOR"
4332 NCURSES_MINOR="$NCURSES_MINOR"
4333 NCURSES_PATCH="$NCURSES_PATCH"
4334
4335 NCURSES_OSPEED="$NCURSES_OSPEED"
4336 TERMINFO="$TERMINFO"
4337
4338 INSTALL="$INSTALL"
4339 INSTALL_DATA="$INSTALL_DATA"
4340
4341 transform="$program_transform_name"
4342
4343 TMP=\${TMPDIR:=/tmp}/man\$\$
4344 trap "rm -f \$TMP" 0 1 2 5 15
4345
4346 form=\[$]1
4347 shift || exit 1
4348
4349 verb=\[$]1
4350 shift || exit 1
4351
4352 mandir=\[$]1
4353 shift || exit 1
4354
4355 srcdir=\[$]1
4356 top_srcdir=\[$]srcdir/..
4357 shift || exit 1
4358
4359 if test "\$form" = normal ; then
4360         if test "$cf_format" = yes ; then
4361         if test "$cf_inboth" = no ; then
4362                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
4363                 exit $?
4364         fi
4365         fi
4366         cf_subdir=\$mandir/man
4367         cf_tables=$MANPAGE_TBL
4368 else
4369         cf_subdir=\$mandir/cat
4370         cf_tables=yes
4371 fi
4372
4373 # process the list of source-files
4374 for i in \[$]* ; do
4375 case \$i in #(vi
4376 *.orig|*.rej) ;; #(vi
4377 *.[[0-9]]*)
4378         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
4379         if test \$verb = installing ; then
4380         if test ! -d \$cf_subdir\${section} ; then
4381                 mkdir -p \$cf_subdir\$section
4382         fi
4383         fi
4384
4385         # replace variables in man page
4386         if test ! -f $cf_man_alias ; then
4387 cat >>$cf_man_alias <<-CF_EOF2
4388                 s,@DATADIR@,\$datadir,g
4389                 s,@TERMINFO@,\${TERMINFO:="no default value"},g
4390                 s,@TERMINFO_DIRS@,\${TERMINFO_DIRS:="no default value"},g
4391                 s,@NCURSES_MAJOR@,\${NCURSES_MAJOR:="no default value"},g
4392                 s,@NCURSES_MINOR@,\${NCURSES_MINOR:="no default value"},g
4393                 s,@NCURSES_PATCH@,\${NCURSES_PATCH:="no default value"},g
4394                 s,@NCURSES_OSPEED@,\${NCURSES_OSPEED:="no default value"},g
4395 CF_EOF
4396         ifelse($1,,,[
4397         for cf_name in $1
4398         do
4399                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
4400                 cf_name=`echo $cf_name|sed "$program_transform_name"`
4401 cat >>$cf_edit_man <<-CF_EOF
4402                 s,@$cf_NAME@,$cf_name,g
4403 CF_EOF
4404         done
4405         ])
4406 cat >>$cf_edit_man <<CF_EOF
4407 CF_EOF2
4408                 echo "...made $cf_man_alias"
4409         fi
4410
4411         aliases=
4412         cf_source=\`basename \$i\`
4413         inalias=\$cf_source
4414         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
4415         if test ! -f \$inalias ; then
4416                 echo .. skipped \$cf_source
4417                 continue
4418         fi
4419 CF_EOF
4420
4421 if test "$MANPAGE_ALIASES" != no ; then
4422 cat >>$cf_edit_man <<CF_EOF
4423         nCurses=ignore.3x
4424         test $with_curses_h = yes && nCurses=ncurses.3x
4425         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u; test \$inalias = \$nCurses && echo curses\`
4426 CF_EOF
4427 fi
4428
4429 if test "$MANPAGE_RENAMES" = no ; then
4430 cat >>$cf_edit_man <<CF_EOF
4431         # perform program transformations for section 1 man pages
4432         if test \$section = 1 ; then
4433                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
4434         else
4435                 cf_target=\$cf_subdir\${section}/\$cf_source
4436         fi
4437 CF_EOF
4438 else
4439 cat >>$cf_edit_man <<CF_EOF
4440         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
4441         if test -z "\$cf_target" ; then
4442                 echo '? missing rename for '\$cf_source
4443                 cf_target="\$cf_source"
4444         fi
4445         cf_target="\$cf_subdir\${section}/\${cf_target}"
4446
4447 CF_EOF
4448 fi
4449
4450 cat >>$cf_edit_man <<CF_EOF
4451         sed     -f $cf_man_alias \\
4452 CF_EOF
4453
4454 if test -f $MANPAGE_RENAMES ; then
4455 cat >>$cf_edit_man <<CF_EOF
4456                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
4457 CF_EOF
4458 else
4459 cat >>$cf_edit_man <<CF_EOF
4460                 < \$i >\$TMP
4461 CF_EOF
4462 fi
4463
4464 cat >>$cf_edit_man <<CF_EOF
4465 if test \$cf_tables = yes ; then
4466         tbl \$TMP >\$TMP.out
4467         mv \$TMP.out \$TMP
4468 fi
4469 CF_EOF
4470
4471 if test $with_overwrite != yes ; then
4472 cat >>$cf_edit_man <<CF_EOF
4473         sed -e "/\#[    ]*include/s,<curses.h,<ncurses$LIB_SUFFIX/curses.h," < \$TMP >\$TMP.out
4474         mv \$TMP.out \$TMP
4475 CF_EOF
4476 fi
4477
4478 if test $with_curses_h != yes ; then
4479 cat >>$cf_edit_man <<CF_EOF
4480         sed -e "/\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
4481         mv \$TMP.out \$TMP
4482 CF_EOF
4483 fi
4484
4485 cat >>$cf_edit_man <<CF_EOF
4486         if test \$form = format ; then
4487                 nroff -man \$TMP >\$TMP.out
4488                 mv \$TMP.out \$TMP
4489         fi
4490 CF_EOF
4491
4492 if test -n "$cf_compress" ; then
4493 cat >>$cf_edit_man <<CF_EOF
4494         if test \$verb = installing ; then
4495         if ( $cf_compress -f \$TMP )
4496         then
4497                 mv \$TMP.$cf_so_strip \$TMP
4498         fi
4499         fi
4500         cf_target="\$cf_target.$cf_so_strip"
4501 CF_EOF
4502 fi
4503
4504 case "$MANPAGE_FORMAT" in #(vi
4505 *BSDI*)
4506 cat >>$cf_edit_man <<CF_EOF
4507         if test \$form = format ; then
4508                 # BSDI installs only .0 suffixes in the cat directories
4509                 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
4510         fi
4511 CF_EOF
4512   ;;
4513 esac
4514
4515 cat >>$cf_edit_man <<CF_EOF
4516         suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
4517         if test \$verb = installing ; then
4518                 echo \$verb \$cf_target
4519                 \$INSTALL_DATA \$TMP \$cf_target
4520                 test -d \$cf_subdir\${section} &&
4521                 test -n "\$aliases" && (
4522                         cd \$cf_subdir\${section} && (
4523                                 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
4524                                 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
4525                                 cf_target=\`basename \$cf_target\`
4526                                 for cf_alias in \$aliases
4527                                 do
4528                                         if test \$section = 1 ; then
4529                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
4530                                         fi
4531
4532                                         if test "$MANPAGE_SYMLINKS" = yes ; then
4533                                                 if test -f \$cf_alias\${suffix} ; then
4534                                                         if ( cmp -s \$cf_target \$cf_alias\${suffix} )
4535                                                         then
4536                                                                 continue
4537                                                         fi
4538                                                 fi
4539                                                 echo .. \$verb alias \$cf_alias\${suffix}
4540 CF_EOF
4541 case "x$LN_S" in #(vi
4542 *-f) #(vi
4543 cat >>$cf_edit_man <<CF_EOF
4544                                                 $LN_S \$cf_target \$cf_alias\${suffix}
4545 CF_EOF
4546         ;;
4547 *)
4548 cat >>$cf_edit_man <<CF_EOF
4549                                                 rm -f \$cf_alias\${suffix}
4550                                                 $LN_S \$cf_target \$cf_alias\${suffix}
4551 CF_EOF
4552         ;;
4553 esac
4554 cat >>$cf_edit_man <<CF_EOF
4555                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
4556                                                 echo ".so \$cf_source" >\$TMP
4557 CF_EOF
4558 if test -n "$cf_compress" ; then
4559 cat >>$cf_edit_man <<CF_EOF
4560                                                 if test -n "$cf_so_strip" ; then
4561                                                         $cf_compress -f \$TMP
4562                                                         mv \$TMP.$cf_so_strip \$TMP
4563                                                 fi
4564 CF_EOF
4565 fi
4566 cat >>$cf_edit_man <<CF_EOF
4567                                                 echo .. \$verb alias \$cf_alias\${suffix}
4568                                                 rm -f \$cf_alias\${suffix}
4569                                                 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
4570                                         fi
4571                                 done
4572                         )
4573                 )
4574         elif test \$verb = removing ; then
4575                 test -f \$cf_target && (
4576                         echo \$verb \$cf_target
4577                         rm -f \$cf_target
4578                 )
4579                 test -d \$cf_subdir\${section} &&
4580                 test -n "\$aliases" && (
4581                         cd \$cf_subdir\${section} && (
4582                                 for cf_alias in \$aliases
4583                                 do
4584                                         if test \$section = 1 ; then
4585                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
4586                                         fi
4587
4588                                         echo .. \$verb alias \$cf_alias\${suffix}
4589                                         rm -f \$cf_alias\${suffix}
4590                                 done
4591                         )
4592                 )
4593         else
4594 #               echo ".hy 0"
4595                 cat \$TMP
4596         fi
4597         ;;
4598 esac
4599 done
4600
4601 if test $cf_inboth = yes ; then
4602 if test \$form != format ; then
4603         sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
4604 fi
4605 fi
4606
4607 exit 0
4608 CF_EOF
4609 chmod 755 $cf_edit_man
4610
4611 ])dnl
4612 dnl ---------------------------------------------------------------------------
4613 dnl CF_MATH_LIB version: 8 updated: 2010/05/29 16:31:02
4614 dnl -----------
4615 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
4616 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
4617 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
4618 AC_DEFUN([CF_MATH_LIB],
4619 [
4620 AC_CACHE_CHECK(if -lm needed for math functions,
4621         cf_cv_need_libm,[
4622         AC_TRY_LINK([
4623         #include <stdio.h>
4624         #include <math.h>
4625         ],
4626         [double x = rand(); printf("result = %g\n", ]ifelse([$2],,sin(x),$2)[)],
4627         [cf_cv_need_libm=no],
4628         [cf_cv_need_libm=yes])])
4629 if test "$cf_cv_need_libm" = yes
4630 then
4631 ifelse($1,,[
4632         CF_ADD_LIB(m)
4633 ],[$1=-lm])
4634 fi
4635 ])
4636 dnl ---------------------------------------------------------------------------
4637 dnl CF_MIXEDCASE_FILENAMES version: 6 updated: 2013/10/08 17:47:05
4638 dnl ----------------------
4639 dnl Check if the file-system supports mixed-case filenames.  If we're able to
4640 dnl create a lowercase name and see it as uppercase, it doesn't support that.
4641 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
4642 [
4643 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
4644 if test "$cross_compiling" = yes ; then
4645         case $target_alias in #(vi
4646         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*) #(vi
4647                 cf_cv_mixedcase=no
4648                 ;;
4649         *)
4650                 cf_cv_mixedcase=yes
4651                 ;;
4652         esac
4653 else
4654         rm -f conftest CONFTEST
4655         echo test >conftest
4656         if test -f CONFTEST ; then
4657                 cf_cv_mixedcase=no
4658         else
4659                 cf_cv_mixedcase=yes
4660         fi
4661         rm -f conftest CONFTEST
4662 fi
4663 ])
4664 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
4665 ])dnl
4666 dnl ---------------------------------------------------------------------------
4667 dnl CF_MKSTEMP version: 9 updated: 2012/10/03 04:34:49
4668 dnl ----------
4669 dnl Check for a working mkstemp.  This creates two files, checks that they are
4670 dnl successfully created and distinct (AmigaOS apparently fails on the last).
4671 AC_DEFUN([CF_MKSTEMP],[
4672 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
4673 rm -rf conftest*
4674 AC_TRY_RUN([
4675 #include <sys/types.h>
4676 #include <stdlib.h>
4677 #include <stdio.h>
4678 #include <string.h>
4679 #include <sys/stat.h>
4680 int main()
4681 {
4682         char *tmpl = "conftestXXXXXX";
4683         char name[2][80];
4684         int n;
4685         int result = 0;
4686         int fd;
4687         struct stat sb;
4688
4689         umask(077);
4690         for (n = 0; n < 2; ++n) {
4691                 strcpy(name[n], tmpl);
4692                 if ((fd = mkstemp(name[n])) >= 0) {
4693                         if (!strcmp(name[n], tmpl)
4694                          || stat(name[n], &sb) != 0
4695                          || (sb.st_mode & S_IFMT) != S_IFREG
4696                          || (sb.st_mode & 077) != 0) {
4697                                 result = 1;
4698                         }
4699                         close(fd);
4700                 }
4701         }
4702         if (result == 0
4703          && !strcmp(name[0], name[1]))
4704                 result = 1;
4705         ${cf_cv_main_return:-return}(result);
4706 }
4707 ],[cf_cv_func_mkstemp=yes
4708 ],[cf_cv_func_mkstemp=no
4709 ],[cf_cv_func_mkstemp=maybe])
4710 ])
4711 if test "x$cf_cv_func_mkstemp" = xmaybe ; then
4712         AC_CHECK_FUNC(mkstemp)
4713 fi
4714 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
4715         AC_DEFINE(HAVE_MKSTEMP,1,[Define to 1 if mkstemp() is available and working.])
4716 fi
4717 ])dnl
4718 dnl ---------------------------------------------------------------------------
4719 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
4720 dnl ----------
4721 dnl Write a debug message to config.log, along with the line number in the
4722 dnl configure script.
4723 AC_DEFUN([CF_MSG_LOG],[
4724 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
4725 ])dnl
4726 dnl ---------------------------------------------------------------------------
4727 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
4728 dnl ----------------
4729 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
4730 dnl warn about this.
4731 AC_DEFUN([CF_NCURSES_ABI_6],[
4732 if test "${with_abi_version+set}" != set; then
4733         case $cf_cv_rel_version in
4734         5.*)
4735                 cf_cv_rel_version=6.0
4736                 cf_cv_abi_version=6
4737                 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
4738                 ;;
4739         esac
4740 fi
4741 ])dnl
4742 dnl ---------------------------------------------------------------------------
4743 dnl CF_NO_LEAKS_OPTION version: 5 updated: 2012/10/02 20:55:03
4744 dnl ------------------
4745 dnl see CF_WITH_NO_LEAKS
4746 AC_DEFUN([CF_NO_LEAKS_OPTION],[
4747 AC_MSG_CHECKING(if you want to use $1 for testing)
4748 AC_ARG_WITH($1,
4749         [$2],
4750         [AC_DEFINE_UNQUOTED($3,1,"Define to 1 if you want to use $1 for testing.")ifelse([$4],,[
4751          $4
4752 ])
4753         : ${with_cflags:=-g}
4754         : ${with_no_leaks:=yes}
4755          with_$1=yes],
4756         [with_$1=])
4757 AC_MSG_RESULT(${with_$1:-no})
4758
4759 case .$with_cflags in #(vi
4760 .*-g*)
4761         case .$CFLAGS in #(vi
4762         .*-g*) #(vi
4763                 ;;
4764         *)
4765                 CF_ADD_CFLAGS([-g])
4766                 ;;
4767         esac
4768         ;;
4769 esac
4770 ])dnl
4771 dnl ---------------------------------------------------------------------------
4772 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
4773 dnl ----------------
4774 dnl Check if the given variable is a number.  If not, report an error.
4775 dnl $1 is the variable
4776 dnl $2 is the message
4777 AC_DEFUN([CF_NUMBER_SYNTAX],[
4778 if test -n "$1" ; then
4779   case $1 in #(vi
4780   [[0-9]]*) #(vi
4781         ;;
4782   *)
4783         AC_MSG_ERROR($2 is not a number: $1)
4784         ;;
4785   esac
4786 else
4787   AC_MSG_ERROR($2 value is empty)
4788 fi
4789 ])dnl
4790 dnl ---------------------------------------------------------------------------
4791 dnl CF_OBJ_SUBDIR version: 6 updated: 2013/09/07 14:06:10
4792 dnl -------------
4793 dnl Compute the object-directory name from the given model name
4794 AC_DEFUN([CF_OBJ_SUBDIR],
4795 [
4796         case $1 in
4797         libtool) $2='obj_lo'  ;;
4798         normal)  $2='objects' ;;
4799         debug)   $2='obj_g' ;;
4800         profile) $2='obj_p' ;;
4801         shared)
4802                 case $cf_cv_system_name in #(vi
4803                 cygwin|msys) #(vi
4804                         $2='objects' ;;
4805                 *)
4806                         $2='obj_s' ;;
4807                 esac
4808         esac
4809 ])dnl
4810 dnl ---------------------------------------------------------------------------
4811 dnl CF_PATHSEP version: 6 updated: 2012/09/29 18:38:12
4812 dnl ----------
4813 dnl Provide a value for the $PATH and similar separator (or amend the value
4814 dnl as provided in autoconf 2.5x).
4815 AC_DEFUN([CF_PATHSEP],
4816 [
4817         AC_MSG_CHECKING(for PATH separator)
4818         case $cf_cv_system_name in
4819         os2*)   PATH_SEPARATOR=';'  ;;
4820         *)      ${PATH_SEPARATOR:=':'}  ;;
4821         esac
4822 ifelse([$1],,,[$1=$PATH_SEPARATOR])
4823         AC_SUBST(PATH_SEPARATOR)
4824         AC_MSG_RESULT($PATH_SEPARATOR)
4825 ])dnl
4826 dnl ---------------------------------------------------------------------------
4827 dnl CF_PATH_SYNTAX version: 14 updated: 2012/06/19 20:58:54
4828 dnl --------------
4829 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
4830 dnl begins with one of the prefix/exec_prefix variables, and then again if the
4831 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
4832 dnl delayed evaluation of those symbols.
4833 AC_DEFUN([CF_PATH_SYNTAX],[
4834 if test "x$prefix" != xNONE; then
4835   cf_path_syntax="$prefix"
4836 else
4837   cf_path_syntax="$ac_default_prefix"
4838 fi
4839
4840 case ".[$]$1" in #(vi
4841 .\[$]\(*\)*|.\'*\'*) #(vi
4842   ;;
4843 ..|./*|.\\*) #(vi
4844   ;;
4845 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
4846   ;;
4847 .\[$]{*prefix}*|.\[$]{*dir}*) #(vi
4848   eval $1="[$]$1"
4849   case ".[$]$1" in #(vi
4850   .NONE/*)
4851     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
4852     ;;
4853   esac
4854   ;; #(vi
4855 .no|.NONE/*)
4856   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
4857   ;;
4858 *)
4859   ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
4860   ;;
4861 esac
4862 ])dnl
4863 dnl ---------------------------------------------------------------------------
4864 dnl CF_PKG_CONFIG version: 8 updated: 2014/12/13 18:48:46
4865 dnl -------------
4866 dnl Check for the package-config program, unless disabled by command-line.
4867 AC_DEFUN([CF_PKG_CONFIG],
4868 [
4869 AC_MSG_CHECKING(if you want to use pkg-config)
4870 AC_ARG_WITH(pkg-config,
4871         [  --with-pkg-config{=path} enable/disable use of pkg-config],
4872         [cf_pkg_config=$withval],
4873         [cf_pkg_config=yes])
4874 AC_MSG_RESULT($cf_pkg_config)
4875
4876 case $cf_pkg_config in #(vi
4877 no) #(vi
4878         PKG_CONFIG=none
4879         ;;
4880 yes) #(vi
4881         CF_ACVERSION_CHECK(2.52,
4882                 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
4883                 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
4884         ;;
4885 *)
4886         PKG_CONFIG=$withval
4887         ;;
4888 esac
4889
4890 test -z "$PKG_CONFIG" && PKG_CONFIG=none
4891 if test "$PKG_CONFIG" != none ; then
4892         CF_PATH_SYNTAX(PKG_CONFIG)
4893 else
4894         AC_MSG_WARN(pkg-config is not installed)
4895 fi
4896
4897 AC_SUBST(PKG_CONFIG)
4898 ])dnl
4899 dnl ---------------------------------------------------------------------------
4900 dnl CF_POSIX_C_SOURCE version: 8 updated: 2010/05/26 05:38:42
4901 dnl -----------------
4902 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
4903 dnl
4904 dnl     POSIX.1-1990                            _POSIX_SOURCE
4905 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
4906 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
4907 dnl             Bindings Option
4908 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
4909 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
4910 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
4911 dnl
4912 dnl Parameters:
4913 dnl     $1 is the nominal value for _POSIX_C_SOURCE
4914 AC_DEFUN([CF_POSIX_C_SOURCE],
4915 [
4916 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
4917
4918 cf_save_CFLAGS="$CFLAGS"
4919 cf_save_CPPFLAGS="$CPPFLAGS"
4920
4921 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
4922 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
4923
4924 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
4925         CF_MSG_LOG(if the symbol is already defined go no further)
4926         AC_TRY_COMPILE([#include <sys/types.h>],[
4927 #ifndef _POSIX_C_SOURCE
4928 make an error
4929 #endif],
4930         [cf_cv_posix_c_source=no],
4931         [cf_want_posix_source=no
4932          case .$cf_POSIX_C_SOURCE in #(vi
4933          .[[12]]??*) #(vi
4934                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
4935                 ;;
4936          .2) #(vi
4937                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
4938                 cf_want_posix_source=yes
4939                 ;;
4940          .*)
4941                 cf_want_posix_source=yes
4942                 ;;
4943          esac
4944          if test "$cf_want_posix_source" = yes ; then
4945                 AC_TRY_COMPILE([#include <sys/types.h>],[
4946 #ifdef _POSIX_SOURCE
4947 make an error
4948 #endif],[],
4949                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
4950          fi
4951          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
4952          CFLAGS="$cf_trim_CFLAGS"
4953          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
4954          CF_MSG_LOG(if the second compile does not leave our definition intact error)
4955          AC_TRY_COMPILE([#include <sys/types.h>],[
4956 #ifndef _POSIX_C_SOURCE
4957 make an error
4958 #endif],,
4959          [cf_cv_posix_c_source=no])
4960          CFLAGS="$cf_save_CFLAGS"
4961          CPPFLAGS="$cf_save_CPPFLAGS"
4962         ])
4963 ])
4964
4965 if test "$cf_cv_posix_c_source" != no ; then
4966         CFLAGS="$cf_trim_CFLAGS"
4967         CPPFLAGS="$cf_trim_CPPFLAGS"
4968         CF_ADD_CFLAGS($cf_cv_posix_c_source)
4969 fi
4970
4971 ])dnl
4972 dnl ---------------------------------------------------------------------------
4973 dnl CF_PREDEFINE version: 2 updated: 2010/05/26 16:44:57
4974 dnl ------------
4975 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
4976 dnl
4977 dnl $1 = symbol to test
4978 dnl $2 = value (if any) to use for a predefinition
4979 AC_DEFUN([CF_PREDEFINE],
4980 [
4981 AC_MSG_CHECKING(if we must define $1)
4982 AC_TRY_COMPILE([#include <sys/types.h>
4983 ],[
4984 #ifndef $1
4985 make an error
4986 #endif],[cf_result=no],[cf_result=yes])
4987 AC_MSG_RESULT($cf_result)
4988
4989 if test "$cf_result" = yes ; then
4990         CPPFLAGS="$CPPFLAGS ifelse([$2],,-D$1,[-D$1=$2])"
4991 elif test "x$2" != "x" ; then
4992         AC_MSG_CHECKING(checking for compatible value versus $2)
4993         AC_TRY_COMPILE([#include <sys/types.h>
4994 ],[
4995 #if $1-$2 < 0
4996 make an error
4997 #endif],[cf_result=yes],[cf_result=no])
4998         AC_MSG_RESULT($cf_result)
4999         if test "$cf_result" = no ; then
5000                 # perhaps we can override it - try...
5001                 CPPFLAGS="$CPPFLAGS -D$1=$2"
5002         fi
5003 fi
5004 ])dnl
5005 dnl ---------------------------------------------------------------------------
5006 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
5007 dnl ------------
5008 dnl Append definitions and rules for the given programs to the subdirectory
5009 dnl Makefiles, and the recursion rule for the top-level Makefile.
5010 dnl
5011 dnl parameters
5012 dnl     $1 = script to run
5013 dnl     $2 = list of subdirectories
5014 dnl
5015 dnl variables
5016 dnl     $AWK
5017 AC_DEFUN([CF_PRG_RULES],
5018 [
5019 for cf_dir in $2
5020 do
5021         if test ! -d $srcdir/$cf_dir; then
5022                 continue
5023         elif test -f $srcdir/$cf_dir/programs; then
5024                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
5025         fi
5026 done
5027
5028 ])dnl
5029 dnl ---------------------------------------------------------------------------
5030 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
5031 dnl ----------
5032 dnl Check for archiver "ar".
5033 AC_DEFUN([CF_PROG_AR],[
5034 AC_CHECK_TOOL(AR, ar, ar)
5035 ])
5036 dnl ---------------------------------------------------------------------------
5037 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
5038 dnl -----------
5039 dnl Check for awk, ensure that the check found something.
5040 AC_DEFUN([CF_PROG_AWK],
5041 [
5042 AC_PROG_AWK
5043 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
5044 ])dnl
5045 dnl ---------------------------------------------------------------------------
5046 dnl CF_PROG_CC version: 4 updated: 2014/07/12 18:57:58
5047 dnl ----------
5048 dnl standard check for CC, plus followup sanity checks
5049 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
5050 AC_DEFUN([CF_PROG_CC],[
5051 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
5052 CF_GCC_VERSION
5053 CF_ACVERSION_CHECK(2.52,
5054         [AC_PROG_CC_STDC],
5055         [CF_ANSI_CC_REQD])
5056 CF_CC_ENV_FLAGS
5057 ])dnl
5058 dnl ---------------------------------------------------------------------------
5059 dnl CF_PROG_CC_C_O version: 3 updated: 2010/08/14 18:25:37
5060 dnl --------------
5061 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
5062 dnl the output file can be renamed, and allows for a shell variable that can
5063 dnl be used later.  The parameter is either CC or CXX.  The result is the
5064 dnl cache variable:
5065 dnl     $cf_cv_prog_CC_c_o
5066 dnl     $cf_cv_prog_CXX_c_o
5067 AC_DEFUN([CF_PROG_CC_C_O],
5068 [AC_REQUIRE([AC_PROG_CC])dnl
5069 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
5070 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
5071 [
5072 cat > conftest.$ac_ext <<CF_EOF
5073 #include <stdio.h>
5074 int main()
5075 {
5076         ${cf_cv_main_return:-return}(0);
5077 }
5078 CF_EOF
5079 # We do the test twice because some compilers refuse to overwrite an
5080 # existing .o file with -o, though they will create one.
5081 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
5082 if AC_TRY_EVAL(ac_try) &&
5083   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
5084 then
5085   eval cf_cv_prog_$1_c_o=yes
5086 else
5087   eval cf_cv_prog_$1_c_o=no
5088 fi
5089 rm -rf conftest*
5090 ])dnl
5091 if test $cf_cv_prog_$1_c_o = yes; then
5092   AC_MSG_RESULT([yes])
5093 else
5094   AC_MSG_RESULT([no])
5095 fi
5096 ])dnl
5097 dnl ---------------------------------------------------------------------------
5098 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
5099 dnl -------------
5100 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
5101 dnl This macro adds a check to ensure the script found something.
5102 AC_DEFUN([CF_PROG_EGREP],
5103 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
5104    [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
5105     then ac_cv_prog_egrep='grep -E'
5106     else ac_cv_prog_egrep='egrep'
5107     fi])
5108  EGREP=$ac_cv_prog_egrep
5109  AC_SUBST([EGREP])
5110 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
5111 ])dnl
5112 dnl ---------------------------------------------------------------------------
5113 dnl CF_PROG_GNAT version: 2 updated: 2011/10/22 14:01:47
5114 dnl ------------
5115 dnl Check for gnatmake, ensure that it is complete.
5116 AC_DEFUN([CF_PROG_GNAT],[
5117 cf_ada_make=gnatmake
5118 AC_CHECK_PROG(gnat_exists, $cf_ada_make, yes, no)
5119 if test "$ac_cv_prog_gnat_exists" = no; then
5120    cf_ada_make=
5121    cf_cv_prog_gnat_correct=no
5122 else
5123    CF_GNAT_VERSION
5124    AC_CHECK_PROG(M4_exists, m4, yes, no)
5125    if test "$ac_cv_prog_M4_exists" = no; then
5126       cf_cv_prog_gnat_correct=no
5127       echo Ada95 binding required program m4 not found. Ada95 binding disabled.
5128    fi
5129    if test "$cf_cv_prog_gnat_correct" = yes; then
5130       AC_MSG_CHECKING(if GNAT works)
5131       CF_GNAT_TRY_RUN([procedure conftest;],
5132 [with Text_IO;
5133 with GNAT.OS_Lib;
5134 procedure conftest is
5135 begin
5136    Text_IO.Put ("Hello World");
5137    Text_IO.New_Line;
5138    GNAT.OS_Lib.OS_Exit (0);
5139 end conftest;],[cf_cv_prog_gnat_correct=yes],[cf_cv_prog_gnat_correct=no])
5140       AC_MSG_RESULT($cf_cv_prog_gnat_correct)
5141    fi
5142 fi
5143
5144 AC_SUBST(cf_ada_make)
5145 ])dnl
5146 dnl ---------------------------------------------------------------------------
5147 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
5148 dnl ---------------
5149 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
5150 dnl misc/tabset install won't work properly.  Usually this happens only when
5151 dnl using the fallback mkinstalldirs script
5152 AC_DEFUN([CF_PROG_INSTALL],
5153 [AC_PROG_INSTALL
5154 case $INSTALL in
5155 /*)
5156   ;;
5157 *)
5158   CF_DIRNAME(cf_dir,$INSTALL)
5159   test -z "$cf_dir" && cf_dir=.
5160   INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
5161   ;;
5162 esac
5163 ])dnl
5164 dnl ---------------------------------------------------------------------------
5165 dnl CF_PROG_LDCONFIG version: 3 updated: 2011/06/04 20:09:13
5166 dnl ----------------
5167 dnl Check for ldconfig, needed to fixup shared libraries that would be built
5168 dnl and then used in the install.
5169 AC_DEFUN([CF_PROG_LDCONFIG],[
5170 if test "$cross_compiling" = yes ; then
5171   LDCONFIG=:
5172 else
5173 case "$cf_cv_system_name" in #(vi
5174 dragonfly*|mirbsd*|freebsd*) #(vi
5175   test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
5176   ;;
5177 *) LDPATH=$PATH:/sbin:/usr/sbin
5178   AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
5179   ;;
5180 esac
5181 fi
5182 AC_SUBST(LDCONFIG)
5183 ])dnl
5184 dnl ---------------------------------------------------------------------------
5185 dnl CF_PROG_LINT version: 2 updated: 2009/08/12 04:43:14
5186 dnl ------------
5187 AC_DEFUN([CF_PROG_LINT],
5188 [
5189 AC_CHECK_PROGS(LINT, tdlint lint alint splint lclint)
5190 AC_SUBST(LINT_OPTS)
5191 ])dnl
5192 dnl ---------------------------------------------------------------------------
5193 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
5194 dnl ------------
5195 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
5196 dnl option if it is supported.
5197 AC_DEFUN([CF_PROG_LN_S],[
5198 AC_PROG_LN_S
5199 AC_MSG_CHECKING(if $LN_S -f options work)
5200
5201 rm -f conf$$.src conf$$dst
5202 echo >conf$$.dst
5203 echo first >conf$$.src
5204 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
5205         cf_prog_ln_sf=yes
5206 else
5207         cf_prog_ln_sf=no
5208 fi
5209 rm -f conf$$.dst conf$$src
5210 AC_MSG_RESULT($cf_prog_ln_sf)
5211
5212 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
5213 ])dnl
5214 dnl ---------------------------------------------------------------------------
5215 dnl CF_REGEX version: 10 updated: 2012/10/04 20:12:20
5216 dnl --------
5217 dnl Attempt to determine if we've got one of the flavors of regular-expression
5218 dnl code that we can support.
5219 AC_DEFUN([CF_REGEX],
5220 [
5221
5222 cf_regex_func=no
5223
5224 cf_regex_libs="regex re"
5225 case $host_os in #(vi
5226 mingw*)
5227         cf_regex_libs="gnurx $cf_regex_libs"
5228         ;;
5229 esac
5230
5231 AC_CHECK_FUNC(regcomp,[cf_regex_func=regcomp],[
5232         for cf_regex_lib in $cf_regex_libs
5233         do
5234                 AC_CHECK_LIB($cf_regex_lib,regcomp,[
5235                                 CF_ADD_LIB($cf_regex_lib)
5236                                 cf_regex_func=regcomp
5237                                 break])
5238         done
5239 ])
5240
5241 if test "$cf_regex_func" = no ; then
5242         AC_CHECK_FUNC(compile,[cf_regex_func=compile],[
5243                 AC_CHECK_LIB(gen,compile,[
5244                                 CF_ADD_LIB(gen)
5245                                 cf_regex_func=compile])])
5246 fi
5247
5248 if test "$cf_regex_func" = no ; then
5249         AC_MSG_WARN(cannot find regular expression library)
5250 fi
5251
5252 AC_CACHE_CHECK(for regular-expression headers,cf_cv_regex_hdrs,[
5253
5254 cf_cv_regex_hdrs=no
5255 case $cf_regex_func in #(vi
5256 compile) #(vi
5257         for cf_regex_hdr in regexp.h regexpr.h
5258         do
5259                 AC_TRY_LINK([#include <$cf_regex_hdr>],[
5260                         char *p = compile("", "", "", 0);
5261                         int x = step("", "");
5262                 ],[
5263                         cf_cv_regex_hdrs=$cf_regex_hdr
5264                         break
5265                 ])
5266         done
5267         ;;
5268 *)
5269         for cf_regex_hdr in regex.h
5270         do
5271                 AC_TRY_LINK([#include <sys/types.h>
5272 #include <$cf_regex_hdr>],[
5273                         regex_t *p;
5274                         int x = regcomp(p, "", 0);
5275                         int y = regexec(p, "", 0, 0, 0);
5276                         regfree(p);
5277                 ],[
5278                         cf_cv_regex_hdrs=$cf_regex_hdr
5279                         break
5280                 ])
5281         done
5282         ;;
5283 esac
5284
5285 ])
5286
5287 case $cf_cv_regex_hdrs in #(vi
5288     no)        AC_MSG_WARN(no regular expression header found) ;; #(vi
5289     regex.h)   AC_DEFINE(HAVE_REGEX_H_FUNCS,1,[Define to 1 to include regex.h for regular expressions]) ;; #(vi
5290     regexp.h)  AC_DEFINE(HAVE_REGEXP_H_FUNCS,1,[Define to 1 to include regexp.h for regular expressions]) ;; #(vi
5291     regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS,1,[Define to 1 to include regexpr.h for regular expressions]) ;;
5292 esac
5293 ])dnl
5294 dnl ---------------------------------------------------------------------------
5295 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
5296 dnl ----------------
5297 dnl Remove all -U and -D options that refer to the given symbol from a list
5298 dnl of C compiler options.  This works around the problem that not all
5299 dnl compilers process -U and -D options from left-to-right, so a -U option
5300 dnl cannot be used to cancel the effect of a preceding -D option.
5301 dnl
5302 dnl $1 = target (which could be the same as the source variable)
5303 dnl $2 = source (including '$')
5304 dnl $3 = symbol to remove
5305 define([CF_REMOVE_DEFINE],
5306 [
5307 $1=`echo "$2" | \
5308         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
5309                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
5310 ])dnl
5311 dnl ---------------------------------------------------------------------------
5312 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
5313 dnl -------------
5314 dnl Remove the given library from the symbol
5315 dnl
5316 dnl $1 = target (which could be the same as the source variable)
5317 dnl $2 = source (including '$')
5318 dnl $3 = library to remove
5319 define([CF_REMOVE_LIB],
5320 [
5321 # remove $3 library from $2
5322 $1=`echo "$2" | sed -e 's/-l$3[[        ]]//g' -e 's/-l$3[$]//'`
5323 ])dnl
5324 dnl ---------------------------------------------------------------------------
5325 dnl CF_RPATH_HACK version: 11 updated: 2013/09/01 13:02:00
5326 dnl -------------
5327 AC_DEFUN([CF_RPATH_HACK],
5328 [
5329 AC_REQUIRE([CF_LD_RPATH_OPT])
5330 AC_MSG_CHECKING(for updated LDFLAGS)
5331 if test -n "$LD_RPATH_OPT" ; then
5332         AC_MSG_RESULT(maybe)
5333
5334         AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
5335         cf_rpath_list="/usr/lib /lib"
5336         if test "$cf_ldd_prog" != no
5337         then
5338                 cf_rpath_oops=
5339
5340 AC_TRY_LINK([#include <stdio.h>],
5341                 [printf("Hello");],
5342                 [cf_rpath_oops=`$cf_ldd_prog conftest$ac_exeext | fgrep ' not found' | sed -e 's% =>.*$%%' |sort | uniq`
5343                  cf_rpath_list=`$cf_ldd_prog conftest$ac_exeext | fgrep / | sed -e 's%^.*[[     ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort | uniq`])
5344
5345                 # If we passed the link-test, but get a "not found" on a given library,
5346                 # this could be due to inept reconfiguration of gcc to make it only
5347                 # partly honor /usr/local/lib (or whatever).  Sometimes this behavior
5348                 # is intentional, e.g., installing gcc in /usr/bin and suppressing the
5349                 # /usr/local libraries.
5350                 if test -n "$cf_rpath_oops"
5351                 then
5352                         for cf_rpath_src in $cf_rpath_oops
5353                         do
5354                                 for cf_rpath_dir in \
5355                                         /usr/local \
5356                                         /usr/pkg \
5357                                         /opt/sfw
5358                                 do
5359                                         if test -f $cf_rpath_dir/lib/$cf_rpath_src
5360                                         then
5361                                                 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
5362                                                 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
5363                                                 break
5364                                         fi
5365                                 done
5366                         done
5367                 fi
5368         fi
5369
5370         CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
5371
5372         CF_RPATH_HACK_2(LDFLAGS)
5373         CF_RPATH_HACK_2(LIBS)
5374
5375         CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
5376 else
5377         AC_MSG_RESULT(no)
5378 fi
5379 AC_SUBST(EXTRA_LDFLAGS)
5380 ])dnl
5381 dnl ---------------------------------------------------------------------------
5382 dnl CF_RPATH_HACK_2 version: 6 updated: 2010/04/17 16:31:24
5383 dnl ---------------
5384 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
5385 dnl EXTRA_LDFLAGS for each -L option found.
5386 dnl
5387 dnl $cf_rpath_list contains a list of directories to ignore.
5388 dnl
5389 dnl $1 = variable name to update.  The LDFLAGS variable should be the only one,
5390 dnl      but LIBS often has misplaced -L options.
5391 AC_DEFUN([CF_RPATH_HACK_2],
5392 [
5393 CF_VERBOSE(...checking $1 [$]$1)
5394
5395 cf_rpath_dst=
5396 for cf_rpath_src in [$]$1
5397 do
5398         case $cf_rpath_src in #(vi
5399         -L*) #(vi
5400
5401                 # check if this refers to a directory which we will ignore
5402                 cf_rpath_skip=no
5403                 if test -n "$cf_rpath_list"
5404                 then
5405                         for cf_rpath_item in $cf_rpath_list
5406                         do
5407                                 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
5408                                 then
5409                                         cf_rpath_skip=yes
5410                                         break
5411                                 fi
5412                         done
5413                 fi
5414
5415                 if test "$cf_rpath_skip" = no
5416                 then
5417                         # transform the option
5418                         if test "$LD_RPATH_OPT" = "-R " ; then
5419                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
5420                         else
5421                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
5422                         fi
5423
5424                         # if we have not already added this, add it now
5425                         cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
5426                         if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
5427                         then
5428                                 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
5429                                 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
5430                         fi
5431                 fi
5432                 ;;
5433         esac
5434         cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
5435 done
5436 $1=$cf_rpath_dst
5437
5438 CF_VERBOSE(...checked $1 [$]$1)
5439 AC_SUBST(EXTRA_LDFLAGS)
5440 ])dnl
5441 dnl ---------------------------------------------------------------------------
5442 dnl CF_SHARED_OPTS version: 84 updated: 2013/11/03 06:26:10
5443 dnl --------------
5444 dnl --------------
5445 dnl Attempt to determine the appropriate CC/LD options for creating a shared
5446 dnl library.
5447 dnl
5448 dnl Notes:
5449 dnl a) ${LOCAL_LDFLAGS} is used to link executables that will run within
5450 dnl the build-tree, i.e., by making use of the libraries that are compiled in
5451 dnl $rel_builddir/lib We avoid compiling-in a $rel_builddir/lib path for the
5452 dnl shared library since that can lead to unexpected results at runtime.
5453 dnl b) ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared
5454 dnl libraries are compiled in ../../lib
5455 dnl
5456 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
5457 dnl to install symbolic links to the rel/abi versions of shared libraries.
5458 dnl
5459 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
5460 dnl version when making symbolic links.
5461 dnl
5462 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
5463 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
5464 dnl (ex: libncurses.so.<ver>).
5465 dnl
5466 dnl Some loaders leave 'so_locations' lying around.  It's nice to clean up.
5467 AC_DEFUN([CF_SHARED_OPTS],
5468 [
5469         AC_REQUIRE([CF_LD_RPATH_OPT])
5470         RM_SHARED_OPTS=
5471         LOCAL_LDFLAGS=
5472         LOCAL_LDFLAGS2=
5473         LD_SHARED_OPTS=
5474         INSTALL_LIB="-m 644"
5475         : ${rel_builddir:=.}
5476
5477         shlibdir=$libdir
5478         AC_SUBST(shlibdir)
5479
5480         MAKE_DLLS="#"
5481         AC_SUBST(MAKE_DLLS)
5482
5483         cf_cv_do_symlinks=no
5484         cf_ld_rpath_opt=
5485         test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
5486
5487         AC_MSG_CHECKING(if release/abi version should be used for shared libs)
5488         AC_ARG_WITH(shlib-version,
5489         [  --with-shlib-version=X  Specify rel or abi version for shared libs],
5490         [test -z "$withval" && withval=auto
5491         case $withval in #(vi
5492         yes) #(vi
5493                 cf_cv_shlib_version=auto
5494                 ;;
5495         rel|abi|auto|no) #(vi
5496                 cf_cv_shlib_version=$withval
5497                 ;;
5498         *)
5499                 AC_MSG_ERROR([option value must be one of: rel, abi, auto or no])
5500                 ;;
5501         esac
5502         ],[cf_cv_shlib_version=auto])
5503         AC_MSG_RESULT($cf_cv_shlib_version)
5504
5505         cf_cv_rm_so_locs=no
5506         cf_try_cflags=
5507
5508         # Some less-capable ports of gcc support only -fpic
5509         CC_SHARED_OPTS=
5510         if test "$GCC" = yes
5511         then
5512                 AC_MSG_CHECKING(which $CC option to use)
5513                 cf_save_CFLAGS="$CFLAGS"
5514                 for CC_SHARED_OPTS in -fPIC -fpic ''
5515                 do
5516                         CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
5517                         AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
5518                 done
5519                 AC_MSG_RESULT($CC_SHARED_OPTS)
5520                 CFLAGS="$cf_save_CFLAGS"
5521         fi
5522
5523         cf_cv_shlib_version_infix=no
5524
5525         case $cf_cv_system_name in #(vi
5526         aix4.[3-9]*|aix[[5-7]]*) #(vi
5527                 if test "$GCC" = yes; then
5528                         CC_SHARED_OPTS=
5529                         MK_SHARED_LIB='${CC} -shared -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
5530                 else
5531                         # CC_SHARED_OPTS='-qpic=large -G'
5532                         # perhaps "-bM:SRE -bnoentry -bexpall"
5533                         MK_SHARED_LIB='${CC} -G -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
5534                 fi
5535                 ;;
5536         beos*) #(vi
5537                 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
5538                 ;;
5539         cygwin*) #(vi
5540                 CC_SHARED_OPTS=
5541                 MK_SHARED_LIB='sh '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
5542                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
5543                 cf_cv_shlib_version=cygdll
5544                 cf_cv_shlib_version_infix=cygdll
5545                 shlibdir=$bindir
5546                 MAKE_DLLS=
5547                 cat >mk_shared_lib.sh <<-CF_EOF
5548                 #!/bin/sh
5549                 SHARED_LIB=\[$]1
5550                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
5551                 shift
5552                 cat <<-EOF
5553                 Linking shared library
5554                 ** SHARED_LIB \[$]SHARED_LIB
5555                 ** IMPORT_LIB \[$]IMPORT_LIB
5556 EOF
5557                 exec \[$]* -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
5558 CF_EOF
5559                 chmod +x mk_shared_lib.sh
5560                 ;;
5561         msys*) #(vi
5562                 CC_SHARED_OPTS=
5563                 MK_SHARED_LIB='sh '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
5564                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
5565                 cf_cv_shlib_version=msysdll
5566                 cf_cv_shlib_version_infix=msysdll
5567                 shlibdir=$bindir
5568                 MAKE_DLLS=
5569                 cat >mk_shared_lib.sh <<-CF_EOF
5570                 #!/bin/sh
5571                 SHARED_LIB=\[$]1
5572                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/msys-/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
5573                 shift
5574                 cat <<-EOF
5575                 Linking shared library
5576                 ** SHARED_LIB \[$]SHARED_LIB
5577                 ** IMPORT_LIB \[$]IMPORT_LIB
5578 EOF
5579                 exec \[$]* -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
5580 CF_EOF
5581                 chmod +x mk_shared_lib.sh
5582                 ;;
5583         darwin*) #(vi
5584                 cf_try_cflags="no-cpp-precomp"
5585                 CC_SHARED_OPTS="-dynamic"
5586                 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
5587                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
5588                 cf_cv_shlib_version_infix=yes
5589                 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
5590                         cf_save_LDFLAGS=$LDFLAGS
5591                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
5592                         AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
5593                                 LDFLAGS=$cf_save_LDFLAGS])
5594                 if test $cf_cv_ldflags_search_paths_first = yes; then
5595                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
5596                 fi
5597                 ;;
5598         hpux[[7-8]]*) #(vi
5599                 # HP-UX 8.07 ld lacks "+b" option used for libdir search-list
5600                 if test "$GCC" != yes; then
5601                         CC_SHARED_OPTS='+Z'
5602                 fi
5603                 MK_SHARED_LIB='${LD} -b -o $[@]'
5604                 INSTALL_LIB="-m 555"
5605                 ;;
5606         hpux*) #(vi
5607                 # (tested with gcc 2.7.2 -- I don't have c89)
5608                 if test "$GCC" = yes; then
5609                         LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
5610                 else
5611                         CC_SHARED_OPTS='+Z'
5612                         LD_SHARED_OPTS='-Wl,+b,${libdir}'
5613                 fi
5614                 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
5615                 # HP-UX shared libraries must be executable, and should be
5616                 # readonly to exploit a quirk in the memory manager.
5617                 INSTALL_LIB="-m 555"
5618                 ;;
5619         interix*)
5620                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5621                 if test "$cf_cv_shlib_version" = rel; then
5622                         cf_shared_soname='`basename $@ .${REL_VERSION}`.${ABI_VERSION}'
5623                 else
5624                         cf_shared_soname='`basename $@`'
5625                 fi
5626                 CC_SHARED_OPTS=
5627                 MK_SHARED_LIB='${CC} -shared -Wl,-rpath,${RPATH_LIST} -Wl,-h,'$cf_shared_soname' -o $@'
5628                 ;;
5629         irix*) #(vi
5630                 if test "$cf_cv_enable_rpath" = yes ; then
5631                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
5632                 fi
5633                 # tested with IRIX 5.2 and 'cc'.
5634                 if test "$GCC" != yes; then
5635                         CC_SHARED_OPTS='-KPIC'
5636                         MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
5637                 else
5638                         MK_SHARED_LIB='${CC} -shared -Wl,-soname,`basename $[@]` -o $[@]'
5639                 fi
5640                 cf_cv_rm_so_locs=yes
5641                 ;;
5642         linux*|gnu*|k*bsd*-gnu) #(vi
5643                 if test "$DFT_LWR_MODEL" = "shared" ; then
5644                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
5645                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5646                 fi
5647                 if test "$cf_cv_enable_rpath" = yes ; then
5648                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
5649                 fi
5650                 CF_SHARED_SONAME
5651                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
5652                 ;;
5653         mingw*) #(vi
5654                 cf_cv_shlib_version=mingw
5655                 cf_cv_shlib_version_infix=mingw
5656                 shlibdir=$bindir
5657                 MAKE_DLLS=
5658                 if test "$DFT_LWR_MODEL" = "shared" ; then
5659                         LOCAL_LDFLAGS="-Wl,--enable-auto-import"
5660                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5661                         EXTRA_LDFLAGS="-Wl,--enable-auto-import $EXTRA_LDFLAGS"
5662                 fi
5663                 CC_SHARED_OPTS=
5664                 MK_SHARED_LIB='sh '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
5665                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
5666                 cat >mk_shared_lib.sh <<-CF_EOF
5667                 #!/bin/sh
5668                 SHARED_LIB=\[$]1
5669                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
5670                 shift
5671                 cat <<-EOF
5672                 Linking shared library
5673                 ** SHARED_LIB \[$]SHARED_LIB
5674                 ** IMPORT_LIB \[$]IMPORT_LIB
5675 EOF
5676                 exec \[$]* -shared -Wl,--enable-auto-import,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
5677 CF_EOF
5678                 chmod +x mk_shared_lib.sh
5679                 ;;
5680         openbsd[[2-9]].*|mirbsd*) #(vi
5681                 if test "$DFT_LWR_MODEL" = "shared" ; then
5682                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
5683                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5684                 fi
5685                 if test "$cf_cv_enable_rpath" = yes ; then
5686                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
5687                 fi
5688                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5689                 CF_SHARED_SONAME
5690                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
5691                 ;;
5692         nto-qnx*|openbsd*|freebsd[[12]].*) #(vi
5693                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5694                 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
5695                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5696                 ;;
5697         dragonfly*|freebsd*) #(vi
5698                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5699                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
5700                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
5701                         LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${RPATH_LIST} $LOCAL_LDFLAGS"
5702                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
5703                 fi
5704                 CF_SHARED_SONAME
5705                 MK_SHARED_LIB='${LD} -shared -Bshareable -soname=`basename $[@]` -o $[@]'
5706                 ;;
5707         netbsd*) #(vi
5708                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5709                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
5710                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
5711                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5712                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
5713                         if test "$cf_cv_shlib_version" = auto; then
5714                         if test -f /usr/libexec/ld.elf_so; then
5715                                 cf_cv_shlib_version=abi
5716                         else
5717                                 cf_cv_shlib_version=rel
5718                         fi
5719                         fi
5720                         CF_SHARED_SONAME
5721                         MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
5722                 else
5723                         MK_SHARED_LIB='${CC} -Wl,-shared -Wl,-Bshareable -o $[@]'
5724                 fi
5725                 ;;
5726         osf*|mls+*) #(vi
5727                 # tested with OSF/1 V3.2 and 'cc'
5728                 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
5729                 # link with shared libs).
5730                 MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
5731                 case $host_os in #(vi
5732                 osf4*)
5733                         MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
5734                         ;;
5735                 esac
5736                 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
5737                 if test "$DFT_LWR_MODEL" = "shared" ; then
5738                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
5739                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5740                 fi
5741                 cf_cv_rm_so_locs=yes
5742                 ;;
5743         sco3.2v5*)  # (also uw2* and UW7: hops 13-Apr-98
5744                 # tested with osr5.0.5
5745                 if test "$GCC" != yes; then
5746                         CC_SHARED_OPTS='-belf -KPIC'
5747                 fi
5748                 MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
5749                 if test "$cf_cv_enable_rpath" = yes ; then
5750                         # only way is to set LD_RUN_PATH but no switch for it
5751                         RUN_PATH=$libdir
5752                 fi
5753                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5754                 LINK_PROGS='LD_RUN_PATH=${libdir}'
5755                 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
5756                 ;;
5757         sunos4*) #(vi
5758                 # tested with SunOS 4.1.1 and gcc 2.7.0
5759                 if test "$GCC" != yes; then
5760                         CC_SHARED_OPTS='-KPIC'
5761                 fi
5762                 MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
5763                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5764                 ;;
5765         solaris2*) #(vi
5766                 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
5767                 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
5768                 if test "$DFT_LWR_MODEL" = "shared" ; then
5769                         LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
5770                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5771                 fi
5772                 if test "$cf_cv_enable_rpath" = yes ; then
5773                         EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
5774                 fi
5775                 CF_SHARED_SONAME
5776                 if test "$GCC" != yes; then
5777                         cf_save_CFLAGS="$CFLAGS"
5778                         for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
5779                         do
5780                                 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
5781                                 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\n");],[break])
5782                         done
5783                         CFLAGS="$cf_save_CFLAGS"
5784                         CC_SHARED_OPTS=$cf_shared_opts
5785                         MK_SHARED_LIB='${CC} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
5786                 else
5787                         MK_SHARED_LIB='${CC} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
5788                 fi
5789                 ;;
5790         sysv5uw7*|unix_sv*) #(vi
5791                 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
5792                 if test "$GCC" != yes; then
5793                         CC_SHARED_OPTS='-KPIC'
5794                 fi
5795                 MK_SHARED_LIB='${LD} -d y -G -o [$]@'
5796                 ;;
5797         *)
5798                 CC_SHARED_OPTS='unknown'
5799                 MK_SHARED_LIB='echo unknown'
5800                 ;;
5801         esac
5802
5803         # This works if the last tokens in $MK_SHARED_LIB are the -o target.
5804         case "$cf_cv_shlib_version" in #(vi
5805         rel|abi)
5806                 case "$MK_SHARED_LIB" in #(vi
5807                 *'-o $[@]') #(vi
5808                         test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
5809                         ;;
5810                 *)
5811                         AC_MSG_WARN(ignored --with-shlib-version)
5812                         ;;
5813                 esac
5814                 ;;
5815         esac
5816
5817         if test -n "$cf_try_cflags"
5818         then
5819 cat > conftest.$ac_ext <<EOF
5820 #line __oline__ "${as_me:-configure}"
5821 #include <stdio.h>
5822 int main(int argc, char *argv[[]])
5823 {
5824         printf("hello\n");
5825         return (argv[[argc-1]] == 0) ;
5826 }
5827 EOF
5828                 cf_save_CFLAGS="$CFLAGS"
5829                 for cf_opt in $cf_try_cflags
5830                 do
5831                         CFLAGS="$cf_save_CFLAGS -$cf_opt"
5832                         AC_MSG_CHECKING(if CFLAGS option -$cf_opt works)
5833                         if AC_TRY_EVAL(ac_compile); then
5834                                 AC_MSG_RESULT(yes)
5835                                 cf_save_CFLAGS="$CFLAGS"
5836                         else
5837                                 AC_MSG_RESULT(no)
5838                         fi
5839                 done
5840                 CFLAGS="$cf_save_CFLAGS"
5841         fi
5842
5843
5844         # RPATH_LIST is a colon-separated list of directories
5845         test -n "$cf_ld_rpath_opt" && MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${RPATH_LIST}"
5846         test -z "$RPATH_LIST" && RPATH_LIST="\${libdir}"
5847
5848         test $cf_cv_rm_so_locs = yes && RM_SHARED_OPTS="$RM_SHARED_OPTS so_locations"
5849
5850         CF_VERBOSE(CC_SHARED_OPTS: $CC_SHARED_OPTS)
5851         CF_VERBOSE(MK_SHARED_LIB:  $MK_SHARED_LIB)
5852
5853         AC_SUBST(CC_SHARED_OPTS)
5854         AC_SUBST(LD_RPATH_OPT)
5855         AC_SUBST(LD_SHARED_OPTS)
5856         AC_SUBST(MK_SHARED_LIB)
5857         AC_SUBST(RM_SHARED_OPTS)
5858
5859         AC_SUBST(LINK_PROGS)
5860         AC_SUBST(LINK_TESTS)
5861
5862         AC_SUBST(EXTRA_LDFLAGS)
5863         AC_SUBST(LOCAL_LDFLAGS)
5864         AC_SUBST(LOCAL_LDFLAGS2)
5865
5866         AC_SUBST(INSTALL_LIB)
5867         AC_SUBST(RPATH_LIST)
5868 ])dnl
5869 dnl ---------------------------------------------------------------------------
5870 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
5871 dnl ----------------
5872 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
5873 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
5874 dnl option.
5875 dnl
5876 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
5877 dnl If missing, use "rel".
5878 define([CF_SHARED_SONAME],
5879 [
5880         test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
5881         if test "$cf_cv_shlib_version" = rel; then
5882                 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
5883         else
5884                 cf_cv_shared_soname='`basename $[@]`'
5885         fi
5886 ])
5887 dnl ---------------------------------------------------------------------------
5888 dnl CF_SIGWINCH version: 1 updated: 2006/04/02 16:41:09
5889 dnl -----------
5890 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
5891 dnl programs need this test).
5892 dnl
5893 dnl This is really a MacOS X 10.4.3 workaround.  Defining _POSIX_C_SOURCE
5894 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses).  Oddly, the struct
5895 dnl winsize declaration is left alone - we may revisit this if Apple choose to
5896 dnl break that part of the interface as well.
5897 AC_DEFUN([CF_SIGWINCH],
5898 [
5899 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
5900         AC_TRY_COMPILE([
5901 #include <sys/types.h>
5902 #include <sys/signal.h>
5903 ],[int x = SIGWINCH],
5904         [cf_cv_define_sigwinch=yes],
5905         [AC_TRY_COMPILE([
5906 #undef _XOPEN_SOURCE
5907 #undef _POSIX_SOURCE
5908 #undef _POSIX_C_SOURCE
5909 #include <sys/types.h>
5910 #include <sys/signal.h>
5911 ],[int x = SIGWINCH],
5912         [cf_cv_define_sigwinch=maybe],
5913         [cf_cv_define_sigwinch=no])
5914 ])
5915 ])
5916
5917 if test "$cf_cv_define_sigwinch" = maybe ; then
5918 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
5919 cf_cv_fixup_sigwinch=unknown
5920 cf_sigwinch=32
5921 while test $cf_sigwinch != 1
5922 do
5923         AC_TRY_COMPILE([
5924 #undef _XOPEN_SOURCE
5925 #undef _POSIX_SOURCE
5926 #undef _POSIX_C_SOURCE
5927 #include <sys/types.h>
5928 #include <sys/signal.h>
5929 ],[
5930 #if SIGWINCH != $cf_sigwinch
5931 make an error
5932 #endif
5933 int x = SIGWINCH],
5934         [cf_cv_fixup_sigwinch=$cf_sigwinch
5935          break])
5936
5937 cf_sigwinch=`expr $cf_sigwinch - 1`
5938 done
5939 ])
5940
5941         if test "$cf_cv_fixup_sigwinch" != unknown ; then
5942                 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
5943         fi
5944 fi
5945 ])dnl
5946 dnl ---------------------------------------------------------------------------
5947 dnl CF_SIG_ATOMIC_T version: 3 updated: 2012/10/04 20:12:20
5948 dnl ---------------
5949 dnl signal handler, but there are some gcc depedencies in that recommendation.
5950 dnl Try anyway.
5951 AC_DEFUN([CF_SIG_ATOMIC_T],
5952 [
5953 AC_MSG_CHECKING(for signal global datatype)
5954 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
5955         for cf_type in \
5956                 "volatile sig_atomic_t" \
5957                 "sig_atomic_t" \
5958                 "int"
5959         do
5960         AC_TRY_COMPILE([
5961 #include <sys/types.h>
5962 #include <signal.h>
5963 #include <stdio.h>
5964
5965 extern $cf_type x;
5966 $cf_type x;
5967 static void handler(int sig)
5968 {
5969         x = 5;
5970 }],
5971                 [signal(SIGINT, handler);
5972                  x = 1],
5973                 [cf_cv_sig_atomic_t=$cf_type],
5974                 [cf_cv_sig_atomic_t=no])
5975                 test "$cf_cv_sig_atomic_t" != no && break
5976         done
5977         ])
5978 AC_MSG_RESULT($cf_cv_sig_atomic_t)
5979 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t,[Define to signal global datatype])
5980 ])dnl
5981 dnl ---------------------------------------------------------------------------
5982 dnl CF_SIZECHANGE version: 9 updated: 2012/10/06 11:17:15
5983 dnl -------------
5984 dnl Check for definitions & structures needed for window size-changing
5985 dnl FIXME: check that this works with "snake" (HP-UX 10.x)
5986 AC_DEFUN([CF_SIZECHANGE],
5987 [
5988 AC_REQUIRE([CF_STRUCT_TERMIOS])
5989 AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[
5990     cf_cv_sizechange=unknown
5991     cf_save_CPPFLAGS="$CPPFLAGS"
5992
5993 for cf_opts in "" "NEED_PTEM_H"
5994 do
5995
5996     CPPFLAGS="$cf_save_CPPFLAGS"
5997     test -n "$cf_opts" && CPPFLAGS="$CPPFLAGS -D$cf_opts"
5998     AC_TRY_COMPILE([#include <sys/types.h>
5999 #ifdef HAVE_TERMIOS_H
6000 #include <termios.h>
6001 #else
6002 #ifdef HAVE_TERMIO_H
6003 #include <termio.h>
6004 #endif
6005 #endif
6006 #ifdef NEED_PTEM_H
6007 /* This is a workaround for SCO:  they neglected to define struct winsize in
6008  * termios.h -- it's only in termio.h and ptem.h
6009  */
6010 #include        <sys/stream.h>
6011 #include        <sys/ptem.h>
6012 #endif
6013 #if !defined(sun) || !defined(HAVE_TERMIOS_H)
6014 #include <sys/ioctl.h>
6015 #endif
6016 ],[
6017 #ifdef TIOCGSIZE
6018         struct ttysize win;     /* FIXME: what system is this? */
6019         int y = win.ts_lines;
6020         int x = win.ts_cols;
6021 #else
6022 #ifdef TIOCGWINSZ
6023         struct winsize win;
6024         int y = win.ws_row;
6025         int x = win.ws_col;
6026 #else
6027         no TIOCGSIZE or TIOCGWINSZ
6028 #endif /* TIOCGWINSZ */
6029 #endif /* TIOCGSIZE */
6030         ],
6031         [cf_cv_sizechange=yes],
6032         [cf_cv_sizechange=no])
6033
6034         CPPFLAGS="$cf_save_CPPFLAGS"
6035         if test "$cf_cv_sizechange" = yes ; then
6036                 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC
6037                 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts"
6038                 break
6039         fi
6040 done
6041 ])
6042 if test "$cf_cv_sizechange" != no ; then
6043         AC_DEFINE(HAVE_SIZECHANGE,1,[Define to 1 if sizechar declarations are provided])
6044         case $cf_cv_sizechange in #(vi
6045         NEED*)
6046                 AC_DEFINE_UNQUOTED($cf_cv_sizechange )
6047                 ;;
6048         esac
6049 fi
6050 ])dnl
6051 dnl ---------------------------------------------------------------------------
6052 dnl CF_SRC_MODULES version: 28 updated: 2014/09/20 20:16:32
6053 dnl --------------
6054 dnl For each parameter, test if the source-directory exists, and if it contains
6055 dnl a 'modules' file.  If so, add to the list $cf_cv_src_modules which we'll
6056 dnl use in CF_LIB_RULES.
6057 dnl
6058 dnl This uses the configured value to make the lists SRC_SUBDIRS and
6059 dnl SUB_MAKEFILES which are used in the makefile-generation scheme.
6060 AC_DEFUN([CF_SRC_MODULES],
6061 [
6062 AC_MSG_CHECKING(for src modules)
6063
6064 # dependencies and linker-arguments for test-programs
6065 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS"
6066 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2"
6067 if test "$DFT_LWR_MODEL" = "libtool"; then
6068         TEST_ARGS="${TEST_DEPS}"
6069         TEST_ARG2="${TEST_DEP2}"
6070 else
6071         TEST_ARGS="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARGS"
6072         TEST_ARG2="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARG2"
6073 fi
6074
6075 PC_MODULES_TO_MAKE="ncurses${DFT_ARG_SUFFIX}"
6076 cf_cv_src_modules=
6077 for cf_dir in $1
6078 do
6079         if test -f $srcdir/$cf_dir/modules; then
6080
6081                 # We may/may not have tack in the distribution, though the
6082                 # makefile is.
6083                 if test $cf_dir = tack ; then
6084                         if test ! -f $srcdir/${cf_dir}/${cf_dir}.h; then
6085                                 continue
6086                         fi
6087                 fi
6088
6089                 if test -z "$cf_cv_src_modules"; then
6090                         cf_cv_src_modules=$cf_dir
6091                 else
6092                         cf_cv_src_modules="$cf_cv_src_modules $cf_dir"
6093                 fi
6094
6095                 # Make the ncurses_cfg.h file record the library interface files as
6096                 # well.  These are header files that are the same name as their
6097                 # directory.  Ncurses is the only library that does not follow
6098                 # that pattern.
6099                 if test $cf_dir = tack ; then
6100                         continue
6101                 elif test -f $srcdir/${cf_dir}/${cf_dir}.h; then
6102                         CF_UPPER(cf_have_include,$cf_dir)
6103                         AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H)
6104                         AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include})
6105                         TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEPS"
6106                         TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEP2"
6107                         if test "$DFT_LWR_MODEL" = "libtool"; then
6108                                 TEST_ARGS="${TEST_DEPS}"
6109                                 TEST_ARG2="${TEST_DEP2}"
6110                         else
6111                                 TEST_ARGS="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARGS"
6112                                 TEST_ARG2="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARG2"
6113                         fi
6114                         PC_MODULES_TO_MAKE="${PC_MODULES_TO_MAKE} ${cf_dir}${DFT_ARG_SUFFIX}"
6115                 fi
6116         fi
6117 done
6118 AC_MSG_RESULT($cf_cv_src_modules)
6119
6120 TEST_ARGS="-L${LIB_DIR} $TEST_ARGS"
6121 TEST_ARG2="-L${LIB_2ND} $TEST_ARG2"
6122
6123 AC_SUBST(TEST_ARGS)
6124 AC_SUBST(TEST_DEPS)
6125
6126 AC_SUBST(TEST_ARG2)
6127 AC_SUBST(TEST_DEP2)
6128
6129 SRC_SUBDIRS=
6130 if test "x$cf_with_manpages" != xno ; then
6131         SRC_SUBDIRS="$SRC_SUBDIRS man"
6132 fi
6133 SRC_SUBDIRS="$SRC_SUBDIRS include"
6134 for cf_dir in $cf_cv_src_modules
6135 do
6136         SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir"
6137 done
6138 if test "x$cf_with_tests" != "xno" ; then
6139         SRC_SUBDIRS="$SRC_SUBDIRS test"
6140 fi
6141 # always make this, to install the ncurses-config script
6142 SRC_SUBDIRS="$SRC_SUBDIRS misc"
6143 if test "$cf_with_cxx_binding" != no; then
6144         PC_MODULES_TO_MAKE="${PC_MODULES_TO_MAKE} ncurses++${DFT_ARG_SUFFIX}"
6145         SRC_SUBDIRS="$SRC_SUBDIRS c++"
6146 fi
6147
6148 test "x$with_termlib" != xno && PC_MODULES_TO_MAKE="$PC_MODULES_TO_MAKE $TINFO_ARG_SUFFIX"
6149 test "x$with_ticlib" != xno && PC_MODULES_TO_MAKE="$PC_MODULES_TO_MAKE $TICS_ARG_SUFFIX"
6150
6151 AC_SUBST(PC_MODULES_TO_MAKE)
6152
6153 ADA_SUBDIRS=
6154 if test "x$cf_with_ada" = "xyes" && test "x$cf_cv_prog_gnat_correct" = xyes && test -f $srcdir/Ada95/Makefile.in; then
6155         SRC_SUBDIRS="$SRC_SUBDIRS Ada95"
6156         ADA_SUBDIRS="gen src"
6157         if test "x$cf_with_tests" != "xno" ; then
6158                 ADA_SUBDIRS="$ADA_SUBDIRS samples"
6159         fi
6160 fi
6161
6162 SUB_MAKEFILES=
6163 for cf_dir in $SRC_SUBDIRS
6164 do
6165         SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile"
6166 done
6167
6168 if test -n "$ADA_SUBDIRS"; then
6169         for cf_dir in $ADA_SUBDIRS
6170         do
6171                 SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile"
6172         done
6173         AC_SUBST(ADA_SUBDIRS)
6174 fi
6175 ])dnl
6176 dnl ---------------------------------------------------------------------------
6177 dnl CF_STDCPP_LIBRARY version: 7 updated: 2010/05/29 16:31:02
6178 dnl -----------------
6179 dnl Check for -lstdc++, which is GNU's standard C++ library.
6180 AC_DEFUN([CF_STDCPP_LIBRARY],
6181 [
6182 if test -n "$GXX" ; then
6183 case $cf_cv_system_name in #(vi
6184 os2*) #(vi
6185         cf_stdcpp_libname=stdcpp
6186         ;;
6187 *)
6188         cf_stdcpp_libname=stdc++
6189         ;;
6190 esac
6191 AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[
6192         cf_save="$LIBS"
6193         CF_ADD_LIB($cf_stdcpp_libname)
6194 AC_TRY_LINK([
6195 #include <strstream.h>],[
6196 char buf[80];
6197 strstreambuf foo(buf, sizeof(buf))
6198 ],
6199         [cf_cv_libstdcpp=yes],
6200         [cf_cv_libstdcpp=no])
6201         LIBS="$cf_save"
6202 ])
6203 test "$cf_cv_libstdcpp" = yes && CF_ADD_LIB($cf_stdcpp_libname,CXXLIBS)
6204 fi
6205 ])dnl
6206 dnl ---------------------------------------------------------------------------
6207 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
6208 dnl --------------
6209 dnl     Remove "-g" option from the compiler options
6210 AC_DEFUN([CF_STRIP_G_OPT],
6211 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
6212 dnl ---------------------------------------------------------------------------
6213 dnl CF_STRUCT_SIGACTION version: 5 updated: 2012/10/06 17:56:13
6214 dnl -------------------
6215 dnl Check if we need _POSIX_SOURCE defined to use struct sigaction.  We'll only
6216 dnl do this if we've found the sigaction function.
6217 AC_DEFUN([CF_STRUCT_SIGACTION],[
6218 AC_REQUIRE([CF_XOPEN_SOURCE])
6219
6220 if test "$ac_cv_func_sigaction" = yes; then
6221 AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE)
6222 AC_TRY_COMPILE([
6223 #include <sys/types.h>
6224 #include <signal.h>],
6225         [struct sigaction act],
6226         [sigact_bad=no],
6227         [
6228 AC_TRY_COMPILE([
6229 #define _POSIX_SOURCE
6230 #include <sys/types.h>
6231 #include <signal.h>],
6232         [struct sigaction act],
6233         [sigact_bad=yes
6234          AC_DEFINE(_POSIX_SOURCE,1,[Define to 1 if we must define _POSIX_SOURCE])],
6235          [sigact_bad=unknown])])
6236 AC_MSG_RESULT($sigact_bad)
6237 fi
6238 ])dnl
6239 dnl ---------------------------------------------------------------------------
6240 dnl CF_STRUCT_TERMIOS version: 7 updated: 2012/10/06 17:56:13
6241 dnl -----------------
6242 dnl Some machines require _POSIX_SOURCE to completely define struct termios.
6243 AC_DEFUN([CF_STRUCT_TERMIOS],[
6244 AC_REQUIRE([CF_XOPEN_SOURCE])
6245
6246 AC_CHECK_HEADERS( \
6247 termio.h \
6248 termios.h \
6249 unistd.h \
6250 )
6251
6252 if test "$ISC" = yes ; then
6253         AC_CHECK_HEADERS( sys/termio.h )
6254 fi
6255 if test "$ac_cv_header_termios_h" = yes ; then
6256         case "$CFLAGS $CPPFLAGS" in
6257         *-D_POSIX_SOURCE*)
6258                 termios_bad=dunno ;;
6259         *)      termios_bad=maybe ;;
6260         esac
6261         if test "$termios_bad" = maybe ; then
6262         AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE)
6263         AC_TRY_COMPILE([#include <termios.h>],
6264                 [struct termios foo; int x = foo.c_iflag],
6265                 termios_bad=no, [
6266                 AC_TRY_COMPILE([
6267 #define _POSIX_SOURCE
6268 #include <termios.h>],
6269                         [struct termios foo; int x = foo.c_iflag],
6270                         termios_bad=unknown,
6271                         termios_bad=yes AC_DEFINE(_POSIX_SOURCE,1,[Define to 1 if we must define _POSIX_SOURCE]))
6272                         ])
6273         AC_MSG_RESULT($termios_bad)
6274         fi
6275 fi
6276 ])dnl
6277 dnl ---------------------------------------------------------------------------
6278 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
6279 dnl --------------
6280 dnl Construct a search-list for a nonstandard header/lib-file
6281 dnl     $1 = the variable to return as result
6282 dnl     $2 = the package name
6283 dnl     $3 = the subdirectory, e.g., bin, include or lib
6284 AC_DEFUN([CF_SUBDIR_PATH],
6285 [
6286 $1=
6287
6288 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
6289
6290 for cf_subdir_prefix in \
6291         /usr \
6292         /usr/local \
6293         /usr/pkg \
6294         /opt \
6295         /opt/local \
6296         [$]HOME
6297 do
6298         CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
6299 done
6300 ])dnl
6301 dnl ---------------------------------------------------------------------------
6302 dnl CF_SUBST_IF version: 2 updated: 2006/06/17 12:33:03
6303 dnl -----------
6304 dnl     Shorthand macro for substituting things that the user may override
6305 dnl     with an environment variable.
6306 dnl
6307 dnl     $1 = condition to pass to "test"
6308 dnl     $2 = environment variable
6309 dnl     $3 = value if the test succeeds
6310 dnl     $4 = value if the test fails
6311 AC_DEFUN([CF_SUBST_IF],
6312 [
6313 if test $1 ; then
6314         $2=$3
6315 ifelse($4,,,[else
6316         $2=$4])
6317 fi
6318 AC_SUBST($2)
6319 ])dnl
6320 dnl ---------------------------------------------------------------------------
6321 dnl CF_SUBST_NCURSES_VERSION version: 8 updated: 2006/09/16 11:40:59
6322 dnl ------------------------
6323 dnl Get the version-number for use in shared-library naming, etc.
6324 AC_DEFUN([CF_SUBST_NCURSES_VERSION],
6325 [
6326 AC_REQUIRE([CF_PROG_EGREP])
6327 NCURSES_MAJOR="`$ac_cv_prog_egrep '^NCURSES_MAJOR[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
6328 NCURSES_MINOR="`$ac_cv_prog_egrep '^NCURSES_MINOR[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
6329 NCURSES_PATCH="`$ac_cv_prog_egrep '^NCURSES_PATCH[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
6330 cf_cv_abi_version=${NCURSES_MAJOR}
6331 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
6332 dnl Show the computed version, for logging
6333 cf_cv_timestamp=`date`
6334 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
6335 dnl We need these values in the generated headers
6336 AC_SUBST(NCURSES_MAJOR)
6337 AC_SUBST(NCURSES_MINOR)
6338 AC_SUBST(NCURSES_PATCH)
6339 dnl We need these values in the generated makefiles
6340 AC_SUBST(cf_cv_rel_version)
6341 AC_SUBST(cf_cv_abi_version)
6342 AC_SUBST(cf_cv_builtin_bool)
6343 AC_SUBST(cf_cv_header_stdbool_h)
6344 AC_SUBST(cf_cv_type_of_bool)dnl
6345 ])dnl
6346 dnl ---------------------------------------------------------------------------
6347 dnl CF_SYS_TIME_SELECT version: 5 updated: 2012/10/04 05:24:07
6348 dnl ------------------
6349 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
6350 dnl older SCO configurations.
6351 AC_DEFUN([CF_SYS_TIME_SELECT],
6352 [
6353 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
6354 AC_CACHE_VAL(cf_cv_sys_time_select,[
6355 AC_TRY_COMPILE([
6356 #include <sys/types.h>
6357 #ifdef HAVE_SYS_TIME_H
6358 #include <sys/time.h>
6359 #endif
6360 #ifdef HAVE_SYS_SELECT_H
6361 #include <sys/select.h>
6362 #endif
6363 ],[],[cf_cv_sys_time_select=yes],
6364      [cf_cv_sys_time_select=no])
6365      ])
6366 AC_MSG_RESULT($cf_cv_sys_time_select)
6367 test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT,1,[Define to 1 if we can include <sys/time.h> with <sys/select.h>])
6368 ])dnl
6369 dnl ---------------------------------------------------------------------------
6370 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
6371 dnl ---------------
6372 dnl Define a top_builddir symbol, for applications that need an absolute path.
6373 AC_DEFUN([CF_TOP_BUILDDIR],
6374 [
6375 top_builddir=ifelse($1,,`pwd`,$1)
6376 AC_SUBST(top_builddir)
6377 ])dnl
6378 dnl ---------------------------------------------------------------------------
6379 dnl CF_TRY_XOPEN_SOURCE version: 1 updated: 2011/10/30 17:09:50
6380 dnl -------------------
6381 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
6382 dnl can define it successfully.
6383 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
6384 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
6385         AC_TRY_COMPILE([
6386 #include <stdlib.h>
6387 #include <string.h>
6388 #include <sys/types.h>
6389 ],[
6390 #ifndef _XOPEN_SOURCE
6391 make an error
6392 #endif],
6393         [cf_cv_xopen_source=no],
6394         [cf_save="$CPPFLAGS"
6395          CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
6396          AC_TRY_COMPILE([
6397 #include <stdlib.h>
6398 #include <string.h>
6399 #include <sys/types.h>
6400 ],[
6401 #ifdef _XOPEN_SOURCE
6402 make an error
6403 #endif],
6404         [cf_cv_xopen_source=no],
6405         [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
6406         CPPFLAGS="$cf_save"
6407         ])
6408 ])
6409
6410 if test "$cf_cv_xopen_source" != no ; then
6411         CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
6412         CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
6413         cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
6414         CF_ADD_CFLAGS($cf_temp_xopen_source)
6415 fi
6416 ])
6417 dnl ---------------------------------------------------------------------------
6418 dnl CF_TYPEOF_CHTYPE version: 9 updated: 2012/10/06 17:56:13
6419 dnl ----------------
6420 dnl Determine the type we should use for chtype (and attr_t, which is treated
6421 dnl as the same thing).  We want around 32 bits, so on most machines want a
6422 dnl long, but on newer 64-bit machines, probably want an int.  If we're using
6423 dnl wide characters, we have to have a type compatible with that, as well.
6424 AC_DEFUN([CF_TYPEOF_CHTYPE],
6425 [
6426 AC_MSG_CHECKING([for type of chtype])
6427 AC_CACHE_VAL(cf_cv_typeof_chtype,[
6428                 AC_TRY_RUN([
6429 #define WANT_BITS 31
6430 #include <stdio.h>
6431 int main()
6432 {
6433         FILE *fp = fopen("cf_test.out", "w");
6434         if (fp != 0) {
6435                 char *result = "long";
6436                 if (sizeof(unsigned long) > sizeof(unsigned int)) {
6437                         int n;
6438                         unsigned int x, y;
6439                         for (n = 0; n < WANT_BITS; n++) {
6440                                 x = (1 << n);
6441                                 y = (x >> n);
6442                                 if (y != 1 || x == 0) {
6443                                         x = 0;
6444                                         break;
6445                                 }
6446                         }
6447                         /*
6448                          * If x is nonzero, an int is big enough for the bits
6449                          * that we want.
6450                          */
6451                         result = (x != 0) ? "int" : "long";
6452                 }
6453                 fputs(result, fp);
6454                 fclose(fp);
6455         }
6456         ${cf_cv_main_return:-return}(0);
6457 }
6458                 ],
6459                 [cf_cv_typeof_chtype=`cat cf_test.out`],
6460                 [cf_cv_typeof_chtype=long],
6461                 [cf_cv_typeof_chtype=long])
6462                 rm -f cf_test.out
6463         ])
6464 AC_MSG_RESULT($cf_cv_typeof_chtype)
6465
6466 AC_SUBST(cf_cv_typeof_chtype)
6467 AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype,[Define to actual type if needed for chtype])
6468 ])dnl
6469 dnl ---------------------------------------------------------------------------
6470 dnl CF_TYPE_SIGACTION version: 4 updated: 2012/10/06 17:56:13
6471 dnl -----------------
6472 dnl
6473 AC_DEFUN([CF_TYPE_SIGACTION],
6474 [
6475 AC_MSG_CHECKING([for type sigaction_t])
6476 AC_CACHE_VAL(cf_cv_type_sigaction,[
6477         AC_TRY_COMPILE([
6478 #include <signal.h>],
6479                 [sigaction_t x],
6480                 [cf_cv_type_sigaction=yes],
6481                 [cf_cv_type_sigaction=no])])
6482 AC_MSG_RESULT($cf_cv_type_sigaction)
6483 test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION,1,[Define to 1 if we have the sigaction_t type])
6484 ])dnl
6485 dnl ---------------------------------------------------------------------------
6486 dnl CF_UNSIGNED_LITERALS version: 2 updated: 1998/02/07 22:10:16
6487 dnl --------------------
6488 dnl Test if the compiler supports 'U' and 'L' suffixes.  Only old compilers
6489 dnl won't, but they're still there.
6490 AC_DEFUN([CF_UNSIGNED_LITERALS],
6491 [
6492 AC_MSG_CHECKING([if unsigned literals are legal])
6493 AC_CACHE_VAL(cf_cv_unsigned_literals,[
6494         AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1],
6495                 [cf_cv_unsigned_literals=yes],
6496                 [cf_cv_unsigned_literals=no])
6497         ])
6498 AC_MSG_RESULT($cf_cv_unsigned_literals)
6499 ])dnl
6500 dnl ---------------------------------------------------------------------------
6501 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
6502 dnl --------
6503 dnl Make an uppercase version of a variable
6504 dnl $1=uppercase($2)
6505 AC_DEFUN([CF_UPPER],
6506 [
6507 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
6508 ])dnl
6509 dnl ---------------------------------------------------------------------------
6510 dnl CF_UTF8_LIB version: 8 updated: 2012/10/06 08:57:51
6511 dnl -----------
6512 dnl Check for multibyte support, and if not found, utf8 compatibility library
6513 AC_DEFUN([CF_UTF8_LIB],
6514 [
6515 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
6516         cf_save_LIBS="$LIBS"
6517         AC_TRY_LINK([
6518 #include <stdlib.h>],[putwc(0,0);],
6519         [cf_cv_utf8_lib=yes],
6520         [CF_FIND_LINKAGE([
6521 #include <libutf8.h>],[putwc(0,0);],utf8,
6522                 [cf_cv_utf8_lib=add-on],
6523                 [cf_cv_utf8_lib=no])
6524 ])])
6525
6526 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
6527 # ncurses/ncursesw:
6528 if test "$cf_cv_utf8_lib" = "add-on" ; then
6529         AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
6530         CF_ADD_INCDIR($cf_cv_header_path_utf8)
6531         CF_ADD_LIBDIR($cf_cv_library_path_utf8)
6532         CF_ADD_LIBS($cf_cv_library_file_utf8)
6533 fi
6534 ])dnl
6535 dnl ---------------------------------------------------------------------------
6536 dnl CF_VA_COPY version: 3 updated: 2012/10/06 11:17:15
6537 dnl ----------
6538 dnl check for va_copy, part of stdarg.h
6539 dnl Also, workaround for glibc's __va_copy, by checking for both.
6540 AC_DEFUN([CF_VA_COPY],[
6541 AC_CACHE_CHECK(for va_copy, cf_cv_have_va_copy,[
6542 AC_TRY_LINK([
6543 #include <stdarg.h>
6544 ],[
6545         static va_list dst;
6546         static va_list src;
6547         va_copy(dst, src)],
6548         cf_cv_have_va_copy=yes,
6549         cf_cv_have_va_copy=no)])
6550
6551 test "$cf_cv_have_va_copy" = yes && AC_DEFINE(HAVE_VA_COPY,1,[Define to 1 if we have va_copy])
6552
6553 AC_CACHE_CHECK(for __va_copy, cf_cv_have___va_copy,[
6554 AC_TRY_LINK([
6555 #include <stdarg.h>
6556 ],[
6557         static va_list dst;
6558         static va_list src;
6559         __va_copy(dst, src)],
6560         cf_cv_have___va_copy=yes,
6561         cf_cv_have___va_copy=no)])
6562
6563 test "$cf_cv_have___va_copy" = yes && AC_DEFINE(HAVE___VA_COPY,1,[Define to 1 if we have __va_copy])
6564 ])
6565 dnl ---------------------------------------------------------------------------
6566 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
6567 dnl ----------
6568 dnl Use AC_VERBOSE w/o the warnings
6569 AC_DEFUN([CF_VERBOSE],
6570 [test -n "$verbose" && echo "   $1" 1>&AC_FD_MSG
6571 CF_MSG_LOG([$1])
6572 ])dnl
6573 dnl ---------------------------------------------------------------------------
6574 dnl CF_VERSION_INFO version: 6 updated: 2013/06/16 10:25:53
6575 dnl ---------------
6576 dnl Define several useful symbols derived from the VERSION file.  A separate
6577 dnl file is preferred to embedding the version numbers in various scripts.
6578 dnl (automake is a textbook-example of why the latter is a bad idea, but there
6579 dnl are others).
6580 dnl
6581 dnl The file contents are:
6582 dnl     libtool-version release-version patch-version
6583 dnl or
6584 dnl     release-version
6585 dnl where
6586 dnl     libtool-version (see ?) consists of 3 integers separated by '.'
6587 dnl     release-version consists of a major version and minor version
6588 dnl             separated by '.', optionally followed by a patch-version
6589 dnl             separated by '-'.  The minor version need not be an
6590 dnl             integer (but it is preferred).
6591 dnl     patch-version is an integer in the form yyyymmdd, so ifdef's and
6592 dnl             scripts can easily compare versions.
6593 dnl
6594 dnl If libtool is used, the first form is required, since CF_WITH_LIBTOOL
6595 dnl simply extracts the first field using 'cut -f1'.
6596 dnl
6597 dnl Optional parameters:
6598 dnl $1 = internal name for package
6599 dnl $2 = external name for package
6600 AC_DEFUN([CF_VERSION_INFO],
6601 [
6602 if test -f $srcdir/VERSION ; then
6603         AC_MSG_CHECKING(for package version)
6604
6605         # if there are not enough fields, cut returns the last one...
6606         cf_field1=`sed -e '2,$d' $srcdir/VERSION|cut -f1`
6607         cf_field2=`sed -e '2,$d' $srcdir/VERSION|cut -f2`
6608         cf_field3=`sed -e '2,$d' $srcdir/VERSION|cut -f3`
6609
6610         # this is how CF_BUNDLED_INTL uses $VERSION:
6611         VERSION="$cf_field1"
6612
6613         VERSION_MAJOR=`echo "$cf_field2" | sed -e 's/\..*//'`
6614         test -z "$VERSION_MAJOR" && AC_MSG_ERROR(missing major-version)
6615
6616         VERSION_MINOR=`echo "$cf_field2" | sed -e 's/^[[^.]]*\.//' -e 's/-.*//'`
6617         test -z "$VERSION_MINOR" && AC_MSG_ERROR(missing minor-version)
6618
6619         AC_MSG_RESULT(${VERSION_MAJOR}.${VERSION_MINOR})
6620
6621         AC_MSG_CHECKING(for package patch date)
6622         VERSION_PATCH=`echo "$cf_field3" | sed -e 's/^[[^-]]*-//'`
6623         case .$VERSION_PATCH in
6624         .)
6625                 AC_MSG_ERROR(missing patch-date $VERSION_PATCH)
6626                 ;;
6627         .[[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]])
6628                 ;;
6629         *)
6630                 AC_MSG_ERROR(illegal patch-date $VERSION_PATCH)
6631                 ;;
6632         esac
6633         AC_MSG_RESULT($VERSION_PATCH)
6634 else
6635         AC_MSG_ERROR(did not find $srcdir/VERSION)
6636 fi
6637
6638 # show the actual data that we have for versions:
6639 CF_VERBOSE(ABI VERSION $VERSION)
6640 CF_VERBOSE(VERSION_MAJOR $VERSION_MAJOR)
6641 CF_VERBOSE(VERSION_MINOR $VERSION_MINOR)
6642 CF_VERBOSE(VERSION_PATCH $VERSION_PATCH)
6643
6644 AC_SUBST(VERSION)
6645 AC_SUBST(VERSION_MAJOR)
6646 AC_SUBST(VERSION_MINOR)
6647 AC_SUBST(VERSION_PATCH)
6648
6649 dnl if a package name is given, define its corresponding version info.  We
6650 dnl need the package name to ensure that the defined symbols are unique.
6651 ifelse($1,,,[
6652         cf_PACKAGE=$1
6653         PACKAGE=ifelse($2,,$1,$2)
6654         AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE",[Define to the package-name])
6655         AC_SUBST(PACKAGE)
6656         CF_UPPER(cf_PACKAGE,$cf_PACKAGE)
6657         AC_DEFINE_UNQUOTED(${cf_PACKAGE}_VERSION,"${VERSION_MAJOR}.${VERSION_MINOR}")
6658         AC_DEFINE_UNQUOTED(${cf_PACKAGE}_PATCHDATE,${VERSION_PATCH})
6659 ])
6660 ])dnl
6661 dnl ---------------------------------------------------------------------------
6662 dnl CF_WCHAR_TYPE version: 4 updated: 2012/10/06 16:39:58
6663 dnl -------------
6664 dnl Check if type wide-character type $1 is declared, and if so, which header
6665 dnl file is needed.  The second parameter is used to set a shell variable when
6666 dnl the type is not found.  The first parameter sets a shell variable for the
6667 dnl opposite sense.
6668 AC_DEFUN([CF_WCHAR_TYPE],
6669 [
6670 # This is needed on Tru64 5.0 to declare $1
6671 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
6672 AC_TRY_COMPILE([
6673 #include <stdlib.h>
6674 #include <stdarg.h>
6675 #include <stdio.h>
6676 #ifdef HAVE_LIBUTF8_H
6677 #include <libutf8.h>
6678 #endif],
6679         [$1 state],
6680         [cf_cv_$1=no],
6681         [AC_TRY_COMPILE([
6682 #include <stdlib.h>
6683 #include <stdarg.h>
6684 #include <stdio.h>
6685 #include <wchar.h>
6686 #ifdef HAVE_LIBUTF8_H
6687 #include <libutf8.h>
6688 #endif],
6689         [$1 value],
6690         [cf_cv_$1=yes],
6691         [cf_cv_$1=unknown])])])
6692
6693 if test "$cf_cv_$1" = yes ; then
6694         AC_DEFINE(NEED_WCHAR_H,1,[Define to 1 if we must include wchar.h])
6695         NEED_WCHAR_H=1
6696 fi
6697
6698 ifelse([$2],,,[
6699 # if we do not find $1 in either place, use substitution to provide a fallback.
6700 if test "$cf_cv_$1" = unknown ; then
6701         $2=1
6702 fi
6703 ])
6704 ifelse($3,,,[
6705 # if we find $1 in either place, use substitution to provide a fallback.
6706 if test "$cf_cv_$1" != unknown ; then
6707         $3=1
6708 fi
6709 ])
6710 ])dnl
6711 dnl ---------------------------------------------------------------------------
6712 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
6713 dnl ---------------
6714 dnl Check for compiler-support for weak symbols.
6715 dnl This works with "recent" gcc.
6716 AC_DEFUN([CF_WEAK_SYMBOLS],[
6717 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
6718
6719 AC_TRY_COMPILE([
6720 #include <stdio.h>],
6721 [
6722 #if defined(__GNUC__)
6723 #  if defined __USE_ISOC99
6724 #    define _cat_pragma(exp)    _Pragma(#exp)
6725 #    define _weak_pragma(exp)   _cat_pragma(weak name)
6726 #  else
6727 #    define _weak_pragma(exp)
6728 #  endif
6729 #  define _declare(name)        __extension__ extern __typeof__(name) name
6730 #  define weak_symbol(name)     _weak_pragma(name) _declare(name) __attribute__((weak))
6731 #endif
6732
6733 weak_symbol(fopen);
6734 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
6735 ])
6736 ])dnl
6737 dnl ---------------------------------------------------------------------------
6738 dnl CF_WITH_ABI_VERSION version: 1 updated: 2003/09/20 18:12:49
6739 dnl -------------------
6740 dnl Allow library's ABI to be overridden.  Generally this happens when a
6741 dnl packager has incremented the ABI past that used in the original package,
6742 dnl and wishes to keep doing this.
6743 dnl
6744 dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
6745 dnl symbol.
6746 AC_DEFUN([CF_WITH_ABI_VERSION],[
6747 test -z "$cf_cv_abi_version" && cf_cv_abi_version=0
6748 AC_ARG_WITH(abi-version,
6749 [  --with-abi-version=XXX  override derived ABI version],
6750 [AC_MSG_WARN(overriding ABI version $cf_cv_abi_version to $withval)
6751  cf_cv_abi_version=$withval])
6752  CF_NUMBER_SYNTAX($cf_cv_abi_version,ABI version)
6753 ifelse($1,,,[
6754 $1_ABI=$cf_cv_abi_version
6755 ])
6756 ])dnl
6757 dnl ---------------------------------------------------------------------------
6758 dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58
6759 dnl --------------------
6760 dnl Command-line option to specify the Ada95 compiler.
6761 AC_DEFUN([CF_WITH_ADA_COMPILER],[
6762 AC_MSG_CHECKING(for ada-compiler)
6763 AC_ARG_WITH(ada-compiler,
6764         [  --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
6765         [cf_ada_compiler=$withval],
6766         [cf_ada_compiler=gnatmake])
6767 AC_SUBST(cf_ada_compiler)
6768 AC_MSG_RESULT($cf_ada_compiler)
6769 ])dnl
6770 dnl ---------------------------------------------------------------------------
6771 dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58
6772 dnl -------------------
6773 dnl Command-line option to specify where Ada includes will install.
6774 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
6775 AC_MSG_CHECKING(for ada-include)
6776 CF_WITH_PATH(ada-include,
6777    [  --with-ada-include=DIR  Ada includes are in DIR],
6778    ADA_INCLUDE,
6779    PREFIX/share/ada/adainclude,
6780    [$]prefix/share/ada/adainclude)
6781 AC_SUBST(ADA_INCLUDE)
6782 AC_MSG_RESULT($ADA_INCLUDE)
6783 ])dnl
6784 dnl ---------------------------------------------------------------------------
6785 dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58
6786 dnl -------------------
6787 dnl Command-line option to specify where Ada objects will install.
6788 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
6789 AC_MSG_CHECKING(for ada-objects)
6790 CF_WITH_PATH(ada-objects,
6791    [  --with-ada-objects=DIR  Ada objects are in DIR],
6792    ADA_OBJECTS,
6793    PREFIX/lib/ada/adalib,
6794    [$]prefix/lib/ada/adalib)
6795 AC_SUBST(ADA_OBJECTS)
6796 AC_MSG_RESULT($ADA_OBJECTS)
6797 ])dnl
6798 dnl ---------------------------------------------------------------------------
6799 dnl CF_WITH_ADA_SHAREDLIB version: 4 updated: 2014/05/31 21:08:37
6800 dnl ---------------------
6801 dnl Command-line option to specify if an Ada95 shared-library should be built,
6802 dnl and optionally what its soname should be.
6803 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
6804 AC_MSG_CHECKING(if an Ada95 shared-library should be built)
6805 AC_ARG_WITH(ada-sharedlib,
6806         [  --with-ada-sharedlib=soname build shared-library (requires GNAT projects)],
6807         [with_ada_sharedlib=$withval],
6808         [with_ada_sharedlib=no])
6809 AC_MSG_RESULT($with_ada_sharedlib)
6810
6811 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
6812 MAKE_ADA_SHAREDLIB="#"
6813
6814 if test "x$with_ada_sharedlib" != xno
6815 then
6816         MAKE_ADA_SHAREDLIB=
6817         if test "x$with_ada_sharedlib" != xyes
6818         then
6819                 ADA_SHAREDLIB="$with_ada_sharedlib"
6820         fi
6821 fi
6822
6823 AC_SUBST(ADA_SHAREDLIB)
6824 AC_SUBST(MAKE_ADA_SHAREDLIB)
6825 ])dnl
6826 dnl ---------------------------------------------------------------------------
6827 dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
6828 dnl ----------------
6829 dnl Configure-option for dbmalloc.  The optional parameter is used to override
6830 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
6831 AC_DEFUN([CF_WITH_DBMALLOC],[
6832 CF_NO_LEAKS_OPTION(dbmalloc,
6833         [  --with-dbmalloc         test: use Conor Cahill's dbmalloc library],
6834         [USE_DBMALLOC])
6835
6836 if test "$with_dbmalloc" = yes ; then
6837         AC_CHECK_HEADER(dbmalloc.h,
6838                 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
6839 fi
6840 ])dnl
6841 dnl ---------------------------------------------------------------------------
6842 dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
6843 dnl ---------------
6844 dnl Configure-option for dmalloc.  The optional parameter is used to override
6845 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
6846 AC_DEFUN([CF_WITH_DMALLOC],[
6847 CF_NO_LEAKS_OPTION(dmalloc,
6848         [  --with-dmalloc          test: use Gray Watson's dmalloc library],
6849         [USE_DMALLOC])
6850
6851 if test "$with_dmalloc" = yes ; then
6852         AC_CHECK_HEADER(dmalloc.h,
6853                 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
6854 fi
6855 ])dnl
6856 dnl ---------------------------------------------------------------------------
6857 dnl CF_WITH_EXPORT_SYMS version: 3 updated: 2014/12/20 19:16:08
6858 dnl -------------------
6859 dnl Use this with libtool to specify the list of symbols that may be exported.
6860 dnl The input file contains one symbol per line; comments work with "#".
6861 dnl
6862 dnl $1 = basename of the ".sym" file (default $PACKAGE)
6863 AC_DEFUN([CF_WITH_EXPORT_SYMS],
6864 [
6865 AC_MSG_CHECKING(if exported-symbols file should be used)
6866 AC_ARG_WITH(export-syms,
6867         [  --with-export-syms=XXX  limit exported symbols using libtool],
6868         [with_export_syms=$withval],
6869         [with_export_syms=no])
6870 if test "x$with_export_syms" = xyes
6871 then
6872         with_export_syms='${top_srcdir}/package/ifelse($1,,${PACKAGE},[$1]).sym'
6873         AC_SUBST(PACKAGE)
6874 fi
6875 AC_MSG_RESULT($with_export_syms)
6876 if test "x$with_export_syms" != xno
6877 then
6878         EXPORT_SYMS="-export-symbols $with_export_syms"
6879         AC_SUBST(EXPORT_SYMS)
6880 fi
6881 ])dnl
6882 dnl ---------------------------------------------------------------------------
6883 dnl CF_WITH_GPM version: 8 updated: 2012/10/06 17:56:13
6884 dnl -----------
6885 dnl
6886 dnl The option parameter (if neither yes/no) is assumed to be the name of
6887 dnl the gpm library, e.g., for dynamic loading.
6888 AC_DEFUN([CF_WITH_GPM],
6889 [
6890 AC_MSG_CHECKING(if you want to link with the GPM mouse library)
6891 AC_ARG_WITH(gpm,
6892         [  --with-gpm              use Alessandro Rubini's GPM library],
6893         [with_gpm=$withval],
6894         [with_gpm=maybe])
6895 AC_MSG_RESULT($with_gpm)
6896
6897 if test "$with_gpm" != no ; then
6898         AC_CHECK_HEADER(gpm.h,[
6899                 AC_DEFINE(HAVE_GPM_H,1,[Define to 1 if we have gpm.h header])
6900                 if test "$with_gpm" != yes && test "$with_gpm" != maybe ; then
6901                         CF_VERBOSE(assuming we really have GPM library)
6902                         AC_DEFINE(HAVE_LIBGPM,1,[Define to 1 if we have the gpm library])
6903                 else
6904                         AC_CHECK_LIB(gpm,Gpm_Open,[:],[
6905                                 AC_MSG_ERROR(Cannot link with GPM library)
6906                 fi
6907                 with_gpm=yes
6908                 ])
6909         ],[
6910                 test "$with_gpm" != maybe && AC_MSG_WARN(Cannot find GPM header)
6911                 with_gpm=no
6912         ])
6913 fi
6914 ])
6915 dnl ---------------------------------------------------------------------------
6916 dnl CF_WITH_LIBTOOL version: 31 updated: 2014/11/15 19:05:29
6917 dnl ---------------
6918 dnl Provide a configure option to incorporate libtool.  Define several useful
6919 dnl symbols for the makefile rules.
6920 dnl
6921 dnl The reference to AC_PROG_LIBTOOL does not normally work, since it uses
6922 dnl macros from libtool.m4 which is in the aclocal directory of automake.
6923 dnl Following is a simple script which turns on the AC_PROG_LIBTOOL macro.
6924 dnl But that still does not work properly since the macro is expanded outside
6925 dnl the CF_WITH_LIBTOOL macro:
6926 dnl
6927 dnl     #!/bin/sh
6928 dnl     ACLOCAL=`aclocal --print-ac-dir`
6929 dnl     if test -z "$ACLOCAL" ; then
6930 dnl             echo cannot find aclocal directory
6931 dnl             exit 1
6932 dnl     elif test ! -f $ACLOCAL/libtool.m4 ; then
6933 dnl             echo cannot find libtool.m4 file
6934 dnl             exit 1
6935 dnl     fi
6936 dnl
6937 dnl     LOCAL=aclocal.m4
6938 dnl     ORIG=aclocal.m4.orig
6939 dnl
6940 dnl     trap "mv $ORIG $LOCAL" 0 1 2 5 15
6941 dnl     rm -f $ORIG
6942 dnl     mv $LOCAL $ORIG
6943 dnl
6944 dnl     # sed the LIBTOOL= assignment to omit the current directory?
6945 dnl     sed -e 's/^LIBTOOL=.*/LIBTOOL=${LIBTOOL:-libtool}/' $ACLOCAL/libtool.m4 >>$LOCAL
6946 dnl     cat $ORIG >>$LOCAL
6947 dnl
6948 dnl     autoconf-257 $*
6949 dnl
6950 AC_DEFUN([CF_WITH_LIBTOOL],
6951 [
6952 AC_REQUIRE([CF_DISABLE_LIBTOOL_VERSION])
6953 ifdef([AC_PROG_LIBTOOL],,[
6954 LIBTOOL=
6955 ])
6956 # common library maintenance symbols that are convenient for libtool scripts:
6957 LIB_CREATE='${AR} -cr'
6958 LIB_OBJECT='${OBJECTS}'
6959 LIB_SUFFIX=.a
6960 LIB_PREP="$RANLIB"
6961
6962 # symbols used to prop libtool up to enable it to determine what it should be
6963 # doing:
6964 LIB_CLEAN=
6965 LIB_COMPILE=
6966 LIB_LINK='${CC}'
6967 LIB_INSTALL=
6968 LIB_UNINSTALL=
6969
6970 AC_MSG_CHECKING(if you want to build libraries with libtool)
6971 AC_ARG_WITH(libtool,
6972         [  --with-libtool          generate libraries with libtool],
6973         [with_libtool=$withval],
6974         [with_libtool=no])
6975 AC_MSG_RESULT($with_libtool)
6976 if test "$with_libtool" != "no"; then
6977 ifdef([AC_PROG_LIBTOOL],[
6978         # missing_content_AC_PROG_LIBTOOL{{
6979         AC_PROG_LIBTOOL
6980         # missing_content_AC_PROG_LIBTOOL}}
6981 ],[
6982         if test "$with_libtool" != "yes" ; then
6983                 CF_PATH_SYNTAX(with_libtool)
6984                 LIBTOOL=$with_libtool
6985         else
6986                 AC_CHECK_TOOLS(LIBTOOL,[libtool glibtool],none)
6987                 CF_LIBTOOL_VERSION
6988                 if test -z "$cf_cv_libtool_version" && test "$LIBTOOL" = libtool
6989                 then
6990                         CF_FORGET_TOOL(LIBTOOL)
6991                         AC_CHECK_TOOLS(LIBTOOL,[glibtool],none)
6992                         CF_LIBTOOL_VERSION
6993                 fi
6994         fi
6995         if test -z "$LIBTOOL" ; then
6996                 AC_MSG_ERROR(Cannot find libtool)
6997         fi
6998 ])dnl
6999         LIB_CREATE='${LIBTOOL} --mode=link ${CC} -rpath ${DESTDIR}${libdir} ${LIBTOOL_VERSION} `cut -f1 ${top_srcdir}/VERSION` ${LIBTOOL_OPTS} ${LT_UNDEF} $(LIBS) -o'
7000         LIB_OBJECT='${OBJECTS:.o=.lo}'
7001         LIB_SUFFIX=.la
7002         LIB_CLEAN='${LIBTOOL} --mode=clean'
7003         LIB_COMPILE='${LIBTOOL} --mode=compile'
7004         LIB_LINK='${LIBTOOL} --mode=link ${CC} ${LIBTOOL_OPTS}'
7005         LIB_INSTALL='${LIBTOOL} --mode=install'
7006         LIB_UNINSTALL='${LIBTOOL} --mode=uninstall'
7007         LIB_PREP=:
7008
7009         CF_CHECK_LIBTOOL_VERSION
7010
7011         # special hack to add -no-undefined (which libtool should do for itself)
7012         LT_UNDEF=
7013         case "$cf_cv_system_name" in #(vi
7014         cygwin*|msys*|mingw32*|uwin*|aix[[4-7]]) #(vi
7015                 LT_UNDEF=-no-undefined
7016                 ;;
7017         esac
7018         AC_SUBST([LT_UNDEF])
7019
7020         # special hack to add --tag option for C++ compiler
7021         case $cf_cv_libtool_version in #(vi
7022         1.[[5-9]]*|[[2-9]].[[0-9.a-z]]*) #(vi
7023                 LIBTOOL_CXX="$LIBTOOL --tag=CXX"
7024                 LIBTOOL="$LIBTOOL --tag=CC"
7025                 ;;
7026         *)
7027                 LIBTOOL_CXX="$LIBTOOL"
7028                 ;;
7029         esac
7030 else
7031         LIBTOOL=""
7032         LIBTOOL_CXX=""
7033 fi
7034
7035 test -z "$LIBTOOL" && ECHO_LT=
7036
7037 AC_SUBST(LIBTOOL)
7038 AC_SUBST(LIBTOOL_CXX)
7039 AC_SUBST(LIBTOOL_OPTS)
7040
7041 AC_SUBST(LIB_CREATE)
7042 AC_SUBST(LIB_OBJECT)
7043 AC_SUBST(LIB_SUFFIX)
7044 AC_SUBST(LIB_PREP)
7045
7046 AC_SUBST(LIB_CLEAN)
7047 AC_SUBST(LIB_COMPILE)
7048 AC_SUBST(LIB_LINK)
7049 AC_SUBST(LIB_INSTALL)
7050 AC_SUBST(LIB_UNINSTALL)
7051
7052 ])dnl
7053 dnl ---------------------------------------------------------------------------
7054 dnl CF_WITH_LIBTOOL_OPTS version: 3 updated: 2014/11/02 16:11:49
7055 dnl --------------------
7056 dnl Allow user to pass additional libtool options into the library creation
7057 dnl and link steps.  The main use for this is to do something like
7058 dnl     ./configure --with-libtool-opts=-static
7059 dnl to get the same behavior as automake-flavored
7060 dnl     ./configure --enable-static
7061 AC_DEFUN([CF_WITH_LIBTOOL_OPTS],[
7062 AC_MSG_CHECKING(for additional libtool options)
7063 AC_ARG_WITH(libtool-opts,
7064         [  --with-libtool-opts=XXX specify additional libtool options],
7065         [with_libtool_opts=$withval],
7066         [with_libtool_opts=no])
7067 AC_MSG_RESULT($with_libtool_opts)
7068
7069 case .$with_libtool_opts in
7070 .yes|.no|.)
7071         ;;
7072 *)
7073         LIBTOOL_OPTS="$LIBTOOL_OPTS $with_libtool_opts"
7074         ;;
7075 esac
7076
7077 AC_SUBST(LIBTOOL_OPTS)
7078 ])dnl
7079 dnl ---------------------------------------------------------------------------
7080 dnl CF_WITH_LIB_PREFIX version: 1 updated: 2012/01/21 19:28:10
7081 dnl ------------------
7082 dnl Allow the library-prefix to be overridden.  OS/2 EMX originally had no
7083 dnl "lib" prefix, e.g., because it used the dll naming convention.
7084 dnl
7085 dnl $1 = variable to set
7086 AC_DEFUN([CF_WITH_LIB_PREFIX],
7087 [
7088 AC_MSG_CHECKING(if you want to have a library-prefix)
7089 AC_ARG_WITH(lib-prefix,
7090         [  --with-lib-prefix       override library-prefix],
7091         [with_lib_prefix=$withval],
7092         [with_lib_prefix=auto])
7093 AC_MSG_RESULT($with_lib_prefix)
7094
7095 if test $with_lib_prefix = auto
7096 then
7097         CF_LIB_PREFIX($1)
7098 elif test $with_lib_prefix = no
7099 then
7100         LIB_PREFIX=
7101 else
7102         LIB_PREFIX=$with_lib_prefix
7103 fi
7104 ])dnl
7105 dnl ---------------------------------------------------------------------------
7106 dnl CF_WITH_PATH version: 11 updated: 2012/09/29 15:04:19
7107 dnl ------------
7108 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
7109 dnl defaulting to yes/no.
7110 dnl
7111 dnl $1 = option name
7112 dnl $2 = help-text
7113 dnl $3 = environment variable to set
7114 dnl $4 = default value, shown in the help-message, must be a constant
7115 dnl $5 = default value, if it's an expression & cannot be in the help-message
7116 dnl
7117 AC_DEFUN([CF_WITH_PATH],
7118 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
7119 ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
7120 if ifelse([$5],,true,[test -n "$5"]) ; then
7121 CF_PATH_SYNTAX(withval)
7122 fi
7123 eval $3="$withval"
7124 AC_SUBST($3)dnl
7125 ])dnl
7126 dnl ---------------------------------------------------------------------------
7127 dnl CF_WITH_PATHLIST version: 9 updated: 2012/10/18 05:05:24
7128 dnl ----------------
7129 dnl Process an option specifying a list of colon-separated paths.
7130 dnl
7131 dnl $1 = option name
7132 dnl $2 = help-text
7133 dnl $3 = environment variable to set
7134 dnl $4 = default value, shown in the help-message, must be a constant
7135 dnl $5 = default value, if it's an expression & cannot be in the help-message
7136 dnl $6 = flag to tell if we want to define or substitute
7137 dnl
7138 AC_DEFUN([CF_WITH_PATHLIST],[
7139 AC_REQUIRE([CF_PATHSEP])
7140 AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
7141 ifelse($4,,[withval=${$3}],[withval=${$3:-ifelse($5,,$4,$5)}]))dnl
7142
7143 IFS="${IFS:-    }"; ac_save_ifs="$IFS"; IFS="${PATH_SEPARATOR}"
7144 cf_dst_path=
7145 for cf_src_path in $withval
7146 do
7147   CF_PATH_SYNTAX(cf_src_path)
7148   test -n "$cf_dst_path" && cf_dst_path="${cf_dst_path}$PATH_SEPARATOR"
7149   cf_dst_path="${cf_dst_path}${cf_src_path}"
7150 done
7151 IFS="$ac_save_ifs"
7152
7153 ifelse($6,define,[
7154 # Strip single quotes from the value, e.g., when it was supplied as a literal
7155 # for $4 or $5.
7156 case $cf_dst_path in #(vi
7157 \'*)
7158   cf_dst_path=`echo $cf_dst_path |sed -e s/\'// -e s/\'\$//`
7159   ;;
7160 esac
7161 cf_dst_path=`echo "$cf_dst_path" | sed -e 's/\\\\/\\\\\\\\/g'`
7162 ])
7163
7164 # This may use the prefix/exec_prefix symbols which will only yield "NONE"
7165 # so we have to check/work around.  We do prefer the result of "eval"...
7166 eval cf_dst_eval="$cf_dst_path"
7167 case "x$cf_dst_eval" in #(vi
7168 xNONE*) #(vi
7169         $3=$cf_dst_path
7170         ;;
7171 *)
7172         $3="$cf_dst_eval"
7173         ;;
7174 esac
7175 AC_SUBST($3)dnl
7176
7177 ])dnl
7178 dnl ---------------------------------------------------------------------------
7179 dnl CF_WITH_PKG_CONFIG_LIBDIR version: 3 updated: 2014/12/13 18:48:46
7180 dnl -------------------------
7181 dnl Allow the choice of the pkg-config library directory to be overridden.
7182 AC_DEFUN([CF_WITH_PKG_CONFIG_LIBDIR],[
7183 AC_MSG_CHECKING(for $PKG_CONFIG library directory)
7184 AC_ARG_WITH(pkg-config-libdir,
7185         [  --with-pkg-config-libdir=XXX use given directory for installing pc-files],
7186         [PKG_CONFIG_LIBDIR=$withval],
7187         [PKG_CONFIG_LIBDIR=yes])
7188
7189 case x$PKG_CONFIG_LIBDIR in #(vi
7190 x/*) #(vi
7191         ;;
7192 xyes) #(vi
7193         # Look for the library directory using the same prefix as the executable
7194         if test "x$PKG_CONFIG" = xnone
7195         then
7196                 cf_path=$prefix
7197         else
7198                 cf_path=`echo "$PKG_CONFIG" | sed -e 's,/[[^/]]*/[[^/]]*$,,'`
7199         fi
7200
7201         # If you don't like using the default architecture, you have to specify the
7202         # intended library directory and corresponding compiler/linker options.
7203         #
7204         # This case allows for Debian's 2014-flavor of multiarch, along with the
7205         # most common variations before that point.  Some other variants spell the
7206         # directory differently, e.g., "pkg-config", and put it in unusual places.
7207         # pkg-config has always been poorly standardized, which is ironic...
7208         case x`(arch) 2>/dev/null` in #(vi
7209         *64) #(vi
7210                 cf_search_path="\
7211                         $cf_path/lib/*64-linux-gnu \
7212                         $cf_path/share \
7213                         $cf_path/lib64 \
7214                         $cf_path/lib32 \
7215                         $cf_path/lib"
7216                 ;;
7217         *)
7218                 cf_search_path="\
7219                         $cf_path/lib/*-linux-gnu \
7220                         $cf_path/share \
7221                         $cf_path/lib32 \
7222                         $cf_path/lib"
7223                 ;;
7224         esac
7225
7226         CF_VERBOSE(list...)
7227         for cf_config in $cf_search_path
7228         do
7229                 CF_VERBOSE(checking $cf_config/pkgconfig)
7230                 if test -d $cf_config/pkgconfig
7231                 then
7232                         PKG_CONFIG_LIBDIR=$cf_config/pkgconfig
7233                         AC_MSG_CHECKING(done)
7234                         break
7235                 fi
7236         done
7237         ;;
7238 *)
7239         ;;
7240 esac
7241
7242 AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
7243
7244 AC_SUBST(PKG_CONFIG_LIBDIR)
7245 ])dnl
7246 dnl ---------------------------------------------------------------------------
7247 dnl CF_WITH_PTHREAD version: 6 updated: 2012/10/06 17:41:51
7248 dnl ---------------
7249 dnl Check for POSIX thread library.
7250 AC_DEFUN([CF_WITH_PTHREAD],
7251 [
7252 AC_MSG_CHECKING(if you want to link with the pthread library)
7253 AC_ARG_WITH(pthread,
7254     [  --with-pthread          use POSIX thread library],
7255     [with_pthread=$withval],
7256     [with_pthread=no])
7257 AC_MSG_RESULT($with_pthread)
7258
7259 if test "$with_pthread" != no ; then
7260     AC_CHECK_HEADER(pthread.h,[
7261         AC_DEFINE(HAVE_PTHREADS_H,1,[Define to 1 if we have pthreads.h header])
7262
7263         for cf_lib_pthread in pthread c_r
7264         do
7265             AC_MSG_CHECKING(if we can link with the $cf_lib_pthread library)
7266             cf_save_LIBS="$LIBS"
7267             CF_ADD_LIB($cf_lib_pthread)
7268             AC_TRY_LINK([
7269 #include <pthread.h>
7270 ],[
7271                 int rc = pthread_create(0,0,0,0);
7272                 int r2 = pthread_mutexattr_settype(0, 0);
7273 ],[with_pthread=yes],[with_pthread=no])
7274             LIBS="$cf_save_LIBS"
7275             AC_MSG_RESULT($with_pthread)
7276             test "$with_pthread" = yes && break
7277         done
7278
7279         if test "$with_pthread" = yes ; then
7280             CF_ADD_LIB($cf_lib_pthread)
7281             AC_DEFINE(HAVE_LIBPTHREADS,1,[Define to 1 if we have pthreads library])
7282         else
7283             AC_MSG_ERROR(Cannot link with pthread library)
7284         fi
7285     ])
7286 fi
7287 ])
7288 dnl ---------------------------------------------------------------------------
7289 dnl CF_WITH_REL_VERSION version: 1 updated: 2003/09/20 18:12:49
7290 dnl -------------------
7291 dnl Allow library's release-version to be overridden.  Generally this happens when a
7292 dnl packager has incremented the release-version past that used in the original package,
7293 dnl and wishes to keep doing this.
7294 dnl
7295 dnl $1 is the package name, if any, to derive corresponding {package}_MAJOR
7296 dnl and {package}_MINOR symbols
7297 dnl symbol.
7298 AC_DEFUN([CF_WITH_REL_VERSION],[
7299 test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0
7300 AC_ARG_WITH(rel-version,
7301 [  --with-rel-version=XXX  override derived release version],
7302 [AC_MSG_WARN(overriding release version $cf_cv_rel_version to $withval)
7303  cf_cv_rel_version=$withval])
7304 ifelse($1,,[
7305  CF_NUMBER_SYNTAX($cf_cv_rel_version,Release version)
7306 ],[
7307  $1_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'`
7308  $1_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[[^.]]*//' -e 's/^\.//' -e 's/\..*//'`
7309  CF_NUMBER_SYNTAX([$]$1_MAJOR,Release major-version)
7310  CF_NUMBER_SYNTAX([$]$1_MINOR,Release minor-version)
7311 ])
7312 ])dnl
7313 dnl ---------------------------------------------------------------------------
7314 dnl CF_WITH_SYSMOUSE version: 3 updated: 2012/10/06 17:56:13
7315 dnl ----------------
7316 dnl If we can compile with sysmouse, make it available unless it is not wanted.
7317 AC_DEFUN([CF_WITH_SYSMOUSE],[
7318 # not everyone has "test -c"
7319 if test -c /dev/sysmouse 2>/dev/null ; then
7320 AC_MSG_CHECKING(if you want to use sysmouse)
7321 AC_ARG_WITH(sysmouse,
7322         [  --with-sysmouse         use sysmouse (FreeBSD console)],
7323         [cf_with_sysmouse=$withval],
7324         [cf_with_sysmouse=maybe])
7325         if test "$cf_with_sysmouse" != no ; then
7326         AC_TRY_COMPILE([
7327 #include <osreldate.h>
7328 #if (__FreeBSD_version >= 400017)
7329 #include <sys/consio.h>
7330 #include <sys/fbio.h>
7331 #else
7332 #include <machine/console.h>
7333 #endif
7334 ],[
7335         struct mouse_info the_mouse;
7336         ioctl(0, CONS_MOUSECTL, &the_mouse);
7337 ],[cf_with_sysmouse=yes],[cf_with_sysmouse=no])
7338         fi
7339 AC_MSG_RESULT($cf_with_sysmouse)
7340 test "$cf_with_sysmouse" = yes && AC_DEFINE(USE_SYSMOUSE,1,[Define to 1 if we can/should use the sysmouse interface])
7341 fi
7342 ])dnl
7343 dnl ---------------------------------------------------------------------------
7344 dnl CF_WITH_SYSTYPE version: 1 updated: 2013/01/26 16:26:12
7345 dnl ---------------
7346 dnl For testing, override the derived host system-type which is used to decide
7347 dnl things such as the linker commands used to build shared libraries.  This is
7348 dnl normally chosen automatically based on the type of system which you are
7349 dnl building on.  We use it for testing the configure script.
7350 dnl
7351 dnl This is different from the --host option: it is used only for testing parts
7352 dnl of the configure script which would not be reachable with --host since that
7353 dnl relies on the build environment being real, rather than mocked up.
7354 AC_DEFUN([CF_WITH_SYSTYPE],[
7355 CF_CHECK_CACHE([AC_CANONICAL_SYSTEM])
7356 AC_ARG_WITH(system-type,
7357         [  --with-system-type=XXX  test: override derived host system-type],
7358 [AC_MSG_WARN(overriding system type to $withval)
7359         cf_cv_system_name=$withval
7360         host_os=$withval
7361 ])
7362 ])dnl
7363 dnl ---------------------------------------------------------------------------
7364 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
7365 dnl ----------------
7366 AC_DEFUN([CF_WITH_VALGRIND],[
7367 CF_NO_LEAKS_OPTION(valgrind,
7368         [  --with-valgrind         test: use valgrind],
7369         [USE_VALGRIND])
7370 ])dnl
7371 dnl ---------------------------------------------------------------------------
7372 dnl CF_WITH_VERSIONED_SYMS version: 3 updated: 2014/12/20 19:16:08
7373 dnl ----------------------
7374 dnl Use this when building shared library with ELF, to markup symbols with the
7375 dnl version identifier from the given input file.  Generally that identifier is
7376 dnl the same as the SONAME at which the symbol was first introduced.
7377 dnl
7378 dnl $1 = basename of the ".map" file (default $PACKAGE)
7379 AC_DEFUN([CF_WITH_VERSIONED_SYMS],
7380 [
7381 AC_MSG_CHECKING(if versioned-symbols file should be used)
7382 AC_ARG_WITH(versioned-syms,
7383         [  --with-versioned-syms=X markup versioned symbols using ld],
7384         [with_versioned_syms=$withval],
7385         [with_versioned_syms=no])
7386 if test "x$with_versioned_syms" = xyes
7387 then
7388         with_versioned_syms='${top_srcdir}/package/ifelse($1,,${PACKAGE},[$1]).map'
7389         AC_SUBST(PACKAGE)
7390 fi
7391 AC_MSG_RESULT($with_versioned_syms)
7392
7393 RESULTING_SYMS=
7394 VERSIONED_SYMS=
7395
7396 if test "x$with_versioned_syms" != xno
7397 then
7398         RESULTING_SYMS=$with_versioned_syms
7399         case "x$MK_SHARED_LIB" in
7400         *-Wl,*) #(vi
7401                 VERSIONED_SYMS="-Wl,--version-script,\$(RESULTING_SYMS)"
7402                 MK_SHARED_LIB=`echo "$MK_SHARED_LIB" | sed -e "s%-Wl,%\\[$]{VERSIONED_SYMS} -Wl,%"`
7403                 CF_VERBOSE(MK_SHARED_LIB:  $MK_SHARED_LIB)
7404                 ;;
7405         *-dy*) #(vi
7406                 VERSIONED_SYMS="-Wl,-M,\$(RESULTING_SYMS)"
7407                 MK_SHARED_LIB=`echo "$MK_SHARED_LIB" | sed -e "s%-dy%\\[$]{VERSIONED_SYMS} -dy%"`
7408                 CF_VERBOSE(MK_SHARED_LIB:  $MK_SHARED_LIB)
7409                 ;;
7410         *)
7411                 AC_MSG_WARN(this system does not support versioned-symbols)
7412                 ;;
7413         esac
7414 fi
7415 AC_SUBST(RESULTING_SYMS)
7416 AC_SUBST(VERSIONED_SYMS)
7417 ])dnl
7418 dnl ---------------------------------------------------------------------------
7419 dnl CF_XOPEN_SOURCE version: 48 updated: 2014/09/01 12:29:14
7420 dnl ---------------
7421 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
7422 dnl or adapt to the vendor's definitions to get equivalent functionality,
7423 dnl without losing the common non-POSIX features.
7424 dnl
7425 dnl Parameters:
7426 dnl     $1 is the nominal value for _XOPEN_SOURCE
7427 dnl     $2 is the nominal value for _POSIX_C_SOURCE
7428 AC_DEFUN([CF_XOPEN_SOURCE],[
7429 AC_REQUIRE([AC_CANONICAL_HOST])
7430
7431 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
7432 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
7433 cf_xopen_source=
7434
7435 case $host_os in #(vi
7436 aix[[4-7]]*) #(vi
7437         cf_xopen_source="-D_ALL_SOURCE"
7438         ;;
7439 cygwin|msys) #(vi
7440         cf_XOPEN_SOURCE=600
7441         ;;
7442 darwin[[0-8]].*) #(vi
7443         cf_xopen_source="-D_APPLE_C_SOURCE"
7444         ;;
7445 darwin*) #(vi
7446         cf_xopen_source="-D_DARWIN_C_SOURCE"
7447         cf_XOPEN_SOURCE=
7448         ;;
7449 freebsd*|dragonfly*) #(vi
7450         # 5.x headers associate
7451         #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
7452         #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
7453         cf_POSIX_C_SOURCE=200112L
7454         cf_XOPEN_SOURCE=600
7455         cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
7456         ;;
7457 hpux11*) #(vi
7458         cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
7459         ;;
7460 hpux*) #(vi
7461         cf_xopen_source="-D_HPUX_SOURCE"
7462         ;;
7463 irix[[56]].*) #(vi
7464         cf_xopen_source="-D_SGI_SOURCE"
7465         cf_XOPEN_SOURCE=
7466         ;;
7467 linux*|gnu*|mint*|k*bsd*-gnu) #(vi
7468         CF_GNU_SOURCE
7469         ;;
7470 minix*) #(vi
7471         cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
7472         ;;
7473 mirbsd*) #(vi
7474         # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
7475         cf_XOPEN_SOURCE=
7476         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
7477         ;;
7478 netbsd*) #(vi
7479         cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
7480         ;;
7481 openbsd[[4-9]]*) #(vi
7482         # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
7483         cf_xopen_source="-D_BSD_SOURCE"
7484         cf_XOPEN_SOURCE=600
7485         ;;
7486 openbsd*) #(vi
7487         # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
7488         ;;
7489 osf[[45]]*) #(vi
7490         cf_xopen_source="-D_OSF_SOURCE"
7491         ;;
7492 nto-qnx*) #(vi
7493         cf_xopen_source="-D_QNX_SOURCE"
7494         ;;
7495 sco*) #(vi
7496         # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
7497         ;;
7498 solaris2.*) #(vi
7499         cf_xopen_source="-D__EXTENSIONS__"
7500         cf_cv_xopen_source=broken
7501         ;;
7502 sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
7503         cf_XOPEN_SOURCE=
7504         cf_POSIX_C_SOURCE=
7505         ;;
7506 *)
7507         CF_TRY_XOPEN_SOURCE
7508         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
7509         ;;
7510 esac
7511
7512 if test -n "$cf_xopen_source" ; then
7513         CF_ADD_CFLAGS($cf_xopen_source,true)
7514 fi
7515
7516 dnl In anything but the default case, we may have system-specific setting
7517 dnl which is still not guaranteed to provide all of the entrypoints that
7518 dnl _XOPEN_SOURCE would yield.
7519 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
7520         AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
7521         AC_TRY_COMPILE([#include <stdlib.h>],[
7522 #ifndef _XOPEN_SOURCE
7523 make an error
7524 #endif],
7525         [cf_XOPEN_SOURCE_set=yes],
7526         [cf_XOPEN_SOURCE_set=no])
7527         AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
7528         if test $cf_XOPEN_SOURCE_set = yes
7529         then
7530                 AC_TRY_COMPILE([#include <stdlib.h>],[
7531 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
7532 make an error
7533 #endif],
7534                 [cf_XOPEN_SOURCE_set_ok=yes],
7535                 [cf_XOPEN_SOURCE_set_ok=no])
7536                 if test $cf_XOPEN_SOURCE_set_ok = no
7537                 then
7538                         AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
7539                 fi
7540         else
7541                 CF_TRY_XOPEN_SOURCE
7542         fi
7543 fi
7544 ])