aclocal.m4

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