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