Ada95/aclocal.m4

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