Ada95/aclocal.m4

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