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.490 2010/01/09 21:06:30 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: 5 updated: 2006/10/14 15:23:15
  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 $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_CFLAGS version: 9 updated: 2010/01/09 11:05:50
  90 dnl -------------
  91 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
  92 dnl The second parameter if given makes this macro verbose.
  93 dnl
  94 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
  95 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
  96 dnl confused by the quotes (which require backslashes to keep them usable).
  97 AC_DEFUN([CF_ADD_CFLAGS],
  98 [
  99 cf_fix_cppflags=no
 100 cf_new_cflags=
 101 cf_new_cppflags=
 102 cf_new_extra_cppflags=
 103
 104 for cf_add_cflags in $1
 105 do
 106 case $cf_fix_cppflags in
 107 no)
 108         case $cf_add_cflags in #(vi
 109         -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi
 110                 case $cf_add_cflags in
 111                 -D*)
 112                         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
 113
 114                         test "${cf_add_cflags}" != "${cf_tst_cflags}" \
 115                                 && test -z "${cf_tst_cflags}" \
 116                                 && cf_fix_cppflags=yes
 117
 118                         if test $cf_fix_cppflags = yes ; then
 119                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 120                                 continue
 121                         elif test "${cf_tst_cflags}" = "\"'" ; then
 122                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 123                                 continue
 124                         fi
 125                         ;;
 126                 esac
 127                 case "$CPPFLAGS" in
 128                 *$cf_add_cflags) #(vi
 129                         ;;
 130                 *) #(vi
 131                         case $cf_add_cflags in #(vi
 132                         -D*)
 133                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
 134                                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
 135                                 ;;
 136                         esac
 137                         cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
 138                         ;;
 139                 esac
 140                 ;;
 141         *)
 142                 cf_new_cflags="$cf_new_cflags $cf_add_cflags"
 143                 ;;
 144         esac
 145         ;;
 146 yes)
 147         cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 148
 149         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
 150
 151         test "${cf_add_cflags}" != "${cf_tst_cflags}" \
 152                 && test -z "${cf_tst_cflags}" \
 153                 && cf_fix_cppflags=no
 154         ;;
 155 esac
 156 done
 157
 158 if test -n "$cf_new_cflags" ; then
 159         ifelse($2,,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
 160         CFLAGS="$CFLAGS $cf_new_cflags"
 161 fi
 162
 163 if test -n "$cf_new_cppflags" ; then
 164         ifelse($2,,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
 165         CPPFLAGS="$CPPFLAGS $cf_new_cppflags"
 166 fi
 167
 168 if test -n "$cf_new_extra_cppflags" ; then
 169         ifelse($2,,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
 170         EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
 171 fi
 172
 173 AC_SUBST(EXTRA_CPPFLAGS)
 174
 175 ])dnl
 176 dnl ---------------------------------------------------------------------------
 177 dnl CF_ADD_INCDIR version: 12 updated: 2009/01/18 10:00:47
 178 dnl -------------
 179 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it's
 180 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
 181 dnl but old versions (and some misinstalled ones) need that.  To make things
 182 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
 183 dnl the include-path).
 184 AC_DEFUN([CF_ADD_INCDIR],
 185 [
 186 if test -n "$1" ; then
 187   for cf_add_incdir in $1
 188   do
 189         while test $cf_add_incdir != /usr/include
 190         do
 191           if test -d $cf_add_incdir
 192           then
 193                 cf_have_incdir=no
 194                 if test -n "$CFLAGS$CPPFLAGS" ; then
 195                   # a loop is needed to ensure we can add subdirs of existing dirs
 196                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
 197                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
 198                           cf_have_incdir=yes; break
 199                         fi
 200                   done
 201                 fi
 202
 203                 if test "$cf_have_incdir" = no ; then
 204                   if test "$cf_add_incdir" = /usr/local/include ; then
 205                         if test "$GCC" = yes
 206                         then
 207                           cf_save_CPPFLAGS=$CPPFLAGS
 208                           CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
 209                           AC_TRY_COMPILE([#include <stdio.h>],
 210                                   [printf("Hello")],
 211                                   [],
 212                                   [cf_have_incdir=yes])
 213                           CPPFLAGS=$cf_save_CPPFLAGS
 214                         fi
 215                   fi
 216                 fi
 217
 218                 if test "$cf_have_incdir" = no ; then
 219                   CF_VERBOSE(adding $cf_add_incdir to include-path)
 220                   ifelse($2,,CPPFLAGS,$2)="$ifelse($2,,CPPFLAGS,$2) -I$cf_add_incdir"
 221
 222                   cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
 223                   test "$cf_top_incdir" = "$cf_add_incdir" && break
 224                   cf_add_incdir="$cf_top_incdir"
 225                 else
 226                   break
 227                 fi
 228           fi
 229         done
 230   done
 231 fi
 232 ])dnl
 233 dnl ---------------------------------------------------------------------------
 234 dnl CF_ADD_LIBDIR version: 8 updated: 2009/01/18 10:01:08
 235 dnl -------------
 236 dnl     Adds to the library-path
 237 dnl
 238 dnl     Some machines have trouble with multiple -L options.
 239 dnl
 240 dnl $1 is the (list of) directory(s) to add
 241 dnl $2 is the optional name of the variable to update (default LDFLAGS)
 242 dnl
 243 AC_DEFUN([CF_ADD_LIBDIR],
 244 [
 245 if test -n "$1" ; then
 246   for cf_add_libdir in $1
 247   do
 248     if test $cf_add_libdir = /usr/lib ; then
 249       :
 250     elif test -d $cf_add_libdir
 251     then
 252       cf_have_libdir=no
 253       if test -n "$LDFLAGS$LIBS" ; then
 254         # a loop is needed to ensure we can add subdirs of existing dirs
 255         for cf_test_libdir in $LDFLAGS $LIBS ; do
 256           if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
 257             cf_have_libdir=yes; break
 258           fi
 259         done
 260       fi
 261       if test "$cf_have_libdir" = no ; then
 262         CF_VERBOSE(adding $cf_add_libdir to library-path)
 263         ifelse($2,,LDFLAGS,$2)="-L$cf_add_libdir $ifelse($2,,LDFLAGS,$2)"
 264       fi
 265     fi
 266   done
 267 fi
 268 ])dnl
 269 dnl ---------------------------------------------------------------------------
 270 dnl CF_ADD_SUBDIR_PATH version: 2 updated: 2007/07/29 10:12:59
 271 dnl ------------------
 272 dnl Append to a search-list for a nonstandard header/lib-file
 273 dnl     $1 = the variable to return as result
 274 dnl     $2 = the package name
 275 dnl     $3 = the subdirectory, e.g., bin, include or lib
 276 dnl $4 = the directory under which we will test for subdirectories
 277 dnl $5 = a directory that we do not want $4 to match
 278 AC_DEFUN([CF_ADD_SUBDIR_PATH],
 279 [
 280 test "$4" != "$5" && \
 281 test -d "$4" && \
 282 ifelse([$5],NONE,,[(test $5 = NONE || test -d $5) &&]) {
 283         test -n "$verbose" && echo "    ... testing for $3-directories under $4"
 284         test -d $4/$3 &&          $1="[$]$1 $4/$3"
 285         test -d $4/$3/$2 &&       $1="[$]$1 $4/$3/$2"
 286         test -d $4/$3/$2/$3 &&    $1="[$]$1 $4/$3/$2/$3"
 287         test -d $4/$2/$3 &&       $1="[$]$1 $4/$2/$3"
 288         test -d $4/$2/$3/$2 &&    $1="[$]$1 $4/$2/$3/$2"
 289 }
 290 ])dnl
 291 dnl ---------------------------------------------------------------------------
 292 dnl CF_ANSI_CC_CHECK version: 9 updated: 2001/12/30 17:53:34
 293 dnl ----------------
 294 dnl This is adapted from the macros 'fp_PROG_CC_STDC' and 'fp_C_PROTOTYPES'
 295 dnl in the sharutils 4.2 distribution.
 296 AC_DEFUN([CF_ANSI_CC_CHECK],
 297 [
 298 AC_CACHE_CHECK(for ${CC-cc} option to accept ANSI C, cf_cv_ansi_cc,[
 299 cf_cv_ansi_cc=no
 300 cf_save_CFLAGS="$CFLAGS"
 301 cf_save_CPPFLAGS="$CPPFLAGS"
 302 # Don't try gcc -ansi; that turns off useful extensions and
 303 # breaks some systems' header files.
 304 # AIX                   -qlanglvl=ansi
 305 # Ultrix and OSF/1      -std1
 306 # HP-UX                 -Aa -D_HPUX_SOURCE
 307 # SVR4                  -Xc
 308 # UnixWare 1.2          (cannot use -Xc, since ANSI/POSIX clashes)
 309 for cf_arg in "-DCC_HAS_PROTOS" \
 310         "" \
 311         -qlanglvl=ansi \
 312         -std1 \
 313         -Ae \
 314         "-Aa -D_HPUX_SOURCE" \
 315         -Xc
 316 do
 317         CF_ADD_CFLAGS($cf_arg)
 318         AC_TRY_COMPILE(
 319 [
 320 #ifndef CC_HAS_PROTOS
 321 #if !defined(__STDC__) || (__STDC__ != 1)
 322 choke me
 323 #endif
 324 #endif
 325 ],[
 326         int test (int i, double x);
 327         struct s1 {int (*f) (int a);};
 328         struct s2 {int (*f) (double a);};],
 329         [cf_cv_ansi_cc="$cf_arg"; break])
 330 done
 331 CFLAGS="$cf_save_CFLAGS"
 332 CPPFLAGS="$cf_save_CPPFLAGS"
 333 ])
 334
 335 if test "$cf_cv_ansi_cc" != "no"; then
 336 if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then
 337         CF_ADD_CFLAGS($cf_cv_ansi_cc)
 338 else
 339         AC_DEFINE(CC_HAS_PROTOS)
 340 fi
 341 fi
 342 ])dnl
 343 dnl ---------------------------------------------------------------------------
 344 dnl CF_ANSI_CC_REQD version: 4 updated: 2008/03/23 14:48:54
 345 dnl ---------------
 346 dnl For programs that must use an ANSI compiler, obtain compiler options that
 347 dnl will make it recognize prototypes.  We'll do preprocessor checks in other
 348 dnl macros, since tools such as unproto can fake prototypes, but only part of
 349 dnl the preprocessor.
 350 AC_DEFUN([CF_ANSI_CC_REQD],
 351 [AC_REQUIRE([CF_ANSI_CC_CHECK])
 352 if test "$cf_cv_ansi_cc" = "no"; then
 353         AC_MSG_ERROR(
 354 [Your compiler does not appear to recognize prototypes.
 355 You have the following choices:
 356         a. adjust your compiler options
 357         b. get an up-to-date compiler
 358         c. use a wrapper such as unproto])
 359 fi
 360 ])dnl
 361 dnl ---------------------------------------------------------------------------
 362 dnl CF_AR_FLAGS version: 4 updated: 2009/02/07 13:42:23
 363 dnl -----------
 364 dnl Check for suitable "ar" (archiver) options for updating an archive.
 365 AC_DEFUN([CF_AR_FLAGS],[
 366 AC_REQUIRE([CF_PROG_AR])
 367
 368 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
 369         cf_cv_ar_flags=unknown
 370         for cf_ar_flags in -curv curv -crv crv -cqv cqv -rv rv
 371         do
 372                 rm -f conftest.$ac_cv_objext
 373                 rm -f conftest.a
 374
 375                 cat >conftest.$ac_ext <<EOF
 376 #line __oline__ "configure"
 377 int     testdata[[3]] = { 123, 456, 789 };
 378 EOF
 379                 if AC_TRY_EVAL(ac_compile) ; then
 380                         $AR $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null
 381                         if test -f conftest.a ; then
 382                                 cf_cv_ar_flags=$cf_ar_flags
 383                                 break
 384                         fi
 385                 else
 386                         CF_VERBOSE(cannot compile test-program)
 387                         break
 388                 fi
 389         done
 390         rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
 391 ])
 392 test -z "$ARFLAGS" && ARFLAGS=$cf_cv_ar_flags
 393 AC_SUBST(ARFLAGS,$cf_cv_ar_flags)
 394 ])
 395 dnl ---------------------------------------------------------------------------
 396 dnl CF_AWK_BIG_PRINTF version: 3 updated: 2008/12/27 12:30:03
 397 dnl -----------------
 398 dnl Check if awk can handle big strings using printf.  Some older versions of
 399 dnl awk choke on large strings passed via "%s".
 400 dnl
 401 dnl $1 = desired string size
 402 dnl $2 = variable to set with result
 403 AC_DEFUN([CF_AWK_BIG_PRINTF],
 404 [
 405         case x$AWK in #(vi
 406         x)
 407                 eval $2=no
 408                 ;;
 409         *) #(vi
 410                 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' \
 411                         | $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
 412                         eval $2=yes
 413                 else
 414                         eval $2=no
 415                 fi
 416                 ;;
 417         esac
 418 ])dnl
 419 dnl ---------------------------------------------------------------------------
 420 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
 421 dnl ------------
 422 dnl Test if 'bool' is a builtin type in the configured C++ compiler.  Some
 423 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
 424 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
 425 dnl
 426 dnl Treat the configuration-variable specially here, since we're directly
 427 dnl substituting its value (i.e., 1/0).
 428 dnl
 429 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
 430 AC_DEFUN([CF_BOOL_DECL],
 431 [
 432 AC_MSG_CHECKING(if we should include stdbool.h)
 433
 434 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
 435         AC_TRY_COMPILE([],[bool foo = false],
 436                 [cf_cv_header_stdbool_h=0],
 437                 [AC_TRY_COMPILE([
 438 #ifndef __BEOS__
 439 #include <stdbool.h>
 440 #endif
 441 ],[bool foo = false],
 442                         [cf_cv_header_stdbool_h=1],
 443                         [cf_cv_header_stdbool_h=0])])])
 444
 445 if test "$cf_cv_header_stdbool_h" = 1
 446 then    AC_MSG_RESULT(yes)
 447 else    AC_MSG_RESULT(no)
 448 fi
 449
 450 AC_MSG_CHECKING([for builtin bool type])
 451
 452 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
 453         AC_TRY_COMPILE([
 454 #include <stdio.h>
 455 #include <sys/types.h>
 456 ],[bool x = false],
 457                 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
 458                 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
 459         ])
 460
 461 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
 462 then    AC_MSG_RESULT(yes)
 463 else    AC_MSG_RESULT(no)
 464 fi
 465 ])dnl
 466 dnl ---------------------------------------------------------------------------
 467 dnl CF_BOOL_SIZE version: 12 updated: 2006/12/16 12:33:30
 468 dnl ------------
 469 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
 470 dnl Don't bother looking for bool.h, since it's been deprecated.
 471 dnl
 472 dnl If the current compiler is C rather than C++, we get the bool definition
 473 dnl from <stdbool.h>.
 474 AC_DEFUN([CF_BOOL_SIZE],
 475 [
 476 AC_MSG_CHECKING([for size of bool])
 477 AC_CACHE_VAL(cf_cv_type_of_bool,[
 478         rm -f cf_test.out
 479         AC_TRY_RUN([
 480 #include <stdlib.h>
 481 #include <stdio.h>
 482
 483 #if defined(__cplusplus)
 484
 485 #ifdef HAVE_GXX_BUILTIN_H
 486 #include <g++/builtin.h>
 487 #elif HAVE_GPP_BUILTIN_H
 488 #include <gpp/builtin.h>
 489 #elif HAVE_BUILTIN_H
 490 #include <builtin.h>
 491 #endif
 492
 493 #else
 494
 495 #if $cf_cv_header_stdbool_h
 496 #include <stdbool.h>
 497 #endif
 498
 499 #endif
 500
 501 main()
 502 {
 503         FILE *fp = fopen("cf_test.out", "w");
 504         if (fp != 0) {
 505                 bool x = true;
 506                 if ((bool)(-x) >= 0)
 507                         fputs("unsigned ", fp);
 508                 if (sizeof(x) == sizeof(int))       fputs("int",  fp);
 509                 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
 510                 else if (sizeof(x) == sizeof(short))fputs("short",fp);
 511                 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
 512                 fclose(fp);
 513         }
 514         ${cf_cv_main_return:-return}(0);
 515 }
 516                 ],
 517                 [cf_cv_type_of_bool=`cat cf_test.out`
 518                  if test -z "$cf_cv_type_of_bool"; then
 519                    cf_cv_type_of_bool=unknown
 520                  fi],
 521                 [cf_cv_type_of_bool=unknown],
 522                 [cf_cv_type_of_bool=unknown])
 523         ])
 524         rm -f cf_test.out
 525 AC_MSG_RESULT($cf_cv_type_of_bool)
 526 if test "$cf_cv_type_of_bool" = unknown ; then
 527         case .$NCURSES_BOOL in #(vi
 528         .auto|.) NCURSES_BOOL=unsigned;;
 529         esac
 530         AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
 531         cf_cv_type_of_bool=$NCURSES_BOOL
 532 fi
 533 ])dnl
 534 dnl ---------------------------------------------------------------------------
 535 dnl CF_BUILD_CC version: 6 updated: 2006/10/14 15:23:15
 536 dnl -----------
 537 dnl If we're cross-compiling, allow the user to override the tools and their
 538 dnl options.  The configure script is oriented toward identifying the host
 539 dnl compiler, etc., but we need a build compiler to generate parts of the
 540 dnl source.
 541 dnl
 542 dnl $1 = default for $CPPFLAGS
 543 dnl $2 = default for $LIBS
 544 AC_DEFUN([CF_BUILD_CC],[
 545 AC_REQUIRE([CF_PROG_EXT])
 546 if test "$cross_compiling" = yes ; then
 547
 548         # defaults that we might want to override
 549         : ${BUILD_CFLAGS:=''}
 550         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
 551         : ${BUILD_LDFLAGS:=''}
 552         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
 553         : ${BUILD_EXEEXT:='$x'}
 554         : ${BUILD_OBJEXT:='o'}
 555
 556         AC_ARG_WITH(build-cc,
 557                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
 558                 [BUILD_CC="$withval"],
 559                 [AC_CHECK_PROGS(BUILD_CC, gcc cc cl)])
 560         AC_MSG_CHECKING(for native build C compiler)
 561         AC_MSG_RESULT($BUILD_CC)
 562
 563         AC_MSG_CHECKING(for native build C preprocessor)
 564         AC_ARG_WITH(build-cpp,
 565                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
 566                 [BUILD_CPP="$withval"],
 567                 [BUILD_CPP='${BUILD_CC} -E'])
 568         AC_MSG_RESULT($BUILD_CPP)
 569
 570         AC_MSG_CHECKING(for native build C flags)
 571         AC_ARG_WITH(build-cflags,
 572                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
 573                 [BUILD_CFLAGS="$withval"])
 574         AC_MSG_RESULT($BUILD_CFLAGS)
 575
 576         AC_MSG_CHECKING(for native build C preprocessor-flags)
 577         AC_ARG_WITH(build-cppflags,
 578                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
 579                 [BUILD_CPPFLAGS="$withval"])
 580         AC_MSG_RESULT($BUILD_CPPFLAGS)
 581
 582         AC_MSG_CHECKING(for native build linker-flags)
 583         AC_ARG_WITH(build-ldflags,
 584                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
 585                 [BUILD_LDFLAGS="$withval"])
 586         AC_MSG_RESULT($BUILD_LDFLAGS)
 587
 588         AC_MSG_CHECKING(for native build linker-libraries)
 589         AC_ARG_WITH(build-libs,
 590                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
 591                 [BUILD_LIBS="$withval"])
 592         AC_MSG_RESULT($BUILD_LIBS)
 593
 594         # this assumes we're on Unix.
 595         BUILD_EXEEXT=
 596         BUILD_OBJEXT=o
 597
 598         : ${BUILD_CC:='${CC}'}
 599
 600         if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
 601                 AC_MSG_ERROR([Cross-build requires two compilers.
 602 Use --with-build-cc to specify the native compiler.])
 603         fi
 604
 605 else
 606         : ${BUILD_CC:='${CC}'}
 607         : ${BUILD_CPP:='${CPP}'}
 608         : ${BUILD_CFLAGS:='${CFLAGS}'}
 609         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
 610         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
 611         : ${BUILD_LIBS:='${LIBS}'}
 612         : ${BUILD_EXEEXT:='$x'}
 613         : ${BUILD_OBJEXT:='o'}
 614 fi
 615
 616 AC_SUBST(BUILD_CC)
 617 AC_SUBST(BUILD_CPP)
 618 AC_SUBST(BUILD_CFLAGS)
 619 AC_SUBST(BUILD_CPPFLAGS)
 620 AC_SUBST(BUILD_LDFLAGS)
 621 AC_SUBST(BUILD_LIBS)
 622 AC_SUBST(BUILD_EXEEXT)
 623 AC_SUBST(BUILD_OBJEXT)
 624 ])dnl
 625 dnl ---------------------------------------------------------------------------
 626 dnl CF_CFG_DEFAULTS version: 7 updated: 2005/09/24 16:15:00
 627 dnl ---------------
 628 dnl Determine the default configuration into which we'll install ncurses.  This
 629 dnl can be overridden by the user's command-line options.  There's two items to
 630 dnl look for:
 631 dnl     1. the prefix (e.g., /usr)
 632 dnl     2. the header files (e.g., /usr/include/ncurses)
 633 dnl We'll look for a previous installation of ncurses and use the same defaults.
 634 dnl
 635 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
 636 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
 637 dnl programs from a vendor's.
 638 AC_DEFUN([CF_CFG_DEFAULTS],
 639 [
 640 AC_MSG_CHECKING(for prefix)
 641 if test "x$prefix" = "xNONE" ; then
 642         case "$cf_cv_system_name" in
 643                 # non-vendor systems don't have a conflict
 644         openbsd*|freebsd*|linux*|cygwin*|k*bsd*-gnu)
 645                 prefix=/usr
 646                 ;;
 647         *)      prefix=$ac_default_prefix
 648                 ;;
 649         esac
 650 fi
 651 AC_MSG_RESULT($prefix)
 652
 653 if test "x$prefix" = "xNONE" ; then
 654 AC_MSG_CHECKING(for default include-directory)
 655 test -n "$verbose" && echo 1>&AC_FD_MSG
 656 for cf_symbol in \
 657         $includedir \
 658         $includedir/ncurses \
 659         $prefix/include \
 660         $prefix/include/ncurses \
 661         /usr/local/include \
 662         /usr/local/include/ncurses \
 663         /usr/include \
 664         /usr/include/ncurses
 665 do
 666         cf_dir=`eval echo $cf_symbol`
 667         if test -f $cf_dir/curses.h ; then
 668         if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
 669                 includedir="$cf_symbol"
 670                 test -n "$verbose"  && echo $ac_n "     found " 1>&AC_FD_MSG
 671                 break
 672         fi
 673         fi
 674         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
 675 done
 676 AC_MSG_RESULT($includedir)
 677 fi
 678 ])dnl
 679 dnl ---------------------------------------------------------------------------
 680 dnl CF_CGETENT version: 3 updated: 2000/08/12 23:18:52
 681 dnl ----------
 682 dnl Check if the terminal-capability database functions are available.  If not,
 683 dnl ncurses has a much-reduced version.
 684 AC_DEFUN([CF_CGETENT],[
 685 AC_MSG_CHECKING(for terminal-capability database functions)
 686 AC_CACHE_VAL(cf_cv_cgetent,[
 687 AC_TRY_LINK([
 688 #include <stdlib.h>],[
 689         char temp[128];
 690         char *buf = temp;
 691         char *db_array = temp;
 692         cgetent(&buf, /* int *, */ &db_array, "vt100");
 693         cgetcap(buf, "tc", '=');
 694         cgetmatch(buf, "tc");
 695         ],
 696         [cf_cv_cgetent=yes],
 697         [cf_cv_cgetent=no])
 698 ])
 699 AC_MSG_RESULT($cf_cv_cgetent)
 700 test "$cf_cv_cgetent" = yes && AC_DEFINE(HAVE_BSD_CGETENT)
 701 ])dnl
 702 dnl ---------------------------------------------------------------------------
 703 dnl CF_CHECK_CACHE version: 11 updated: 2008/03/23 14:45:59
 704 dnl --------------
 705 dnl Check if we're accidentally using a cache from a different machine.
 706 dnl Derive the system name, as a check for reusing the autoconf cache.
 707 dnl
 708 dnl If we've packaged config.guess and config.sub, run that (since it does a
 709 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
 710 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
 711 dnl which is useful in cross-compiles.
 712 dnl
 713 dnl Note: we would use $ac_config_sub, but that is one of the places where
 714 dnl autoconf 2.5x broke compatibility with autoconf 2.13
 715 AC_DEFUN([CF_CHECK_CACHE],
 716 [
 717 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
 718         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
 719         system_name="$host_os"
 720 else
 721         system_name="`(uname -s -r) 2>/dev/null`"
 722         if test -z "$system_name" ; then
 723                 system_name="`(hostname) 2>/dev/null`"
 724         fi
 725 fi
 726 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name")
 727 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
 728
 729 test -z "$system_name" && system_name="$cf_cv_system_name"
 730 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
 731
 732 if test ".$system_name" != ".$cf_cv_system_name" ; then
 733         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
 734         AC_MSG_ERROR("Please remove config.cache and try again.")
 735 fi
 736 ])dnl
 737 dnl ---------------------------------------------------------------------------
 738 dnl CF_CHECK_ERRNO version: 10 updated: 2008/08/22 16:33:22
 739 dnl --------------
 740 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
 741 dnl the 'errno' variable.  Define a DECL_xxx symbol if we must declare it
 742 dnl ourselves.
 743 dnl
 744 dnl $1 = the name to check
 745 dnl $2 = the assumed type
 746 AC_DEFUN([CF_CHECK_ERRNO],
 747 [
 748 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
 749     AC_TRY_COMPILE([
 750 #ifdef HAVE_STDLIB_H
 751 #include <stdlib.h>
 752 #endif
 753 #include <stdio.h>
 754 #include <sys/types.h>
 755 #include <errno.h> ],
 756     ifelse($2,,int,$2) x = (ifelse($2,,int,$2)) $1,
 757     [cf_cv_dcl_$1=yes],
 758     [cf_cv_dcl_$1=no])
 759 ])
 760
 761 if test "$cf_cv_dcl_$1" = no ; then
 762     CF_UPPER(cf_result,decl_$1)
 763     AC_DEFINE_UNQUOTED($cf_result)
 764 fi
 765
 766 # It's possible (for near-UNIX clones) that the data doesn't exist
 767 CF_CHECK_EXTERN_DATA($1,ifelse($2,,int,$2))
 768 ])dnl
 769 dnl ---------------------------------------------------------------------------
 770 dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23
 771 dnl --------------------
 772 dnl Check for existence of external data in the current set of libraries.  If
 773 dnl we can modify it, it's real enough.
 774 dnl $1 = the name to check
 775 dnl $2 = its type
 776 AC_DEFUN([CF_CHECK_EXTERN_DATA],
 777 [
 778 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
 779     AC_TRY_LINK([
 780 #undef $1
 781 extern $2 $1;
 782 ],
 783     [$1 = 2],
 784     [cf_cv_have_$1=yes],
 785     [cf_cv_have_$1=no])
 786 ])
 787
 788 if test "$cf_cv_have_$1" = yes ; then
 789     CF_UPPER(cf_result,have_$1)
 790     AC_DEFINE_UNQUOTED($cf_result)
 791 fi
 792
 793 ])dnl
 794 dnl ---------------------------------------------------------------------------
 795 dnl CF_CHECK_GPM_WGETCH version: 1 updated: 2007/04/28 14:38:06
 796 dnl -------------------
 797 dnl Check if GPM is already linked with curses.  If so - and if the linkage
 798 dnl is not "weak" - warn about this because it can create problems linking
 799 dnl applications with ncurses.
 800 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
 801 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
 802
 803 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
 804 cf_cv_check_gpm_wgetch=unknown
 805 if test "$cross_compiling" != yes ; then
 806
 807 cat >conftest.$ac_ext <<CF_EOF
 808 #include <gpm.h>
 809 int main()
 810 {
 811         Gpm_Wgetch();
 812         ${cf_cv_main_return:-return}(0);
 813 }
 814 CF_EOF
 815
 816         cf_save_LIBS="$LIBS"
 817         # This only works if we can look at the symbol table.  If a shared
 818         # library is stripped for install, we cannot use that.  So we're forced
 819         # to rely on the static library, noting that some packagers may not
 820         # include it.
 821         LIBS="-static -lgpm -dynamic $LIBS"
 822         if AC_TRY_EVAL(ac_compile) ; then
 823                 if AC_TRY_EVAL(ac_link) ; then
 824                         cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
 825                         test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
 826                         test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
 827                 fi
 828         fi
 829         rm -f conftest*
 830         LIBS="$cf_save_LIBS"
 831 fi
 832 ])
 833
 834 if test "$cf_cv_check_gpm_wgetch" != yes ; then
 835         AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
 836 fi
 837 ])])dnl
 838 dnl ---------------------------------------------------------------------------
 839 dnl CF_CPP_PARAM_INIT version: 4 updated: 2001/04/07 22:31:18
 840 dnl -----------------
 841 dnl Check if the C++ compiler accepts duplicate parameter initialization.  This
 842 dnl is a late feature for the standard and is not in some recent compilers
 843 dnl (1999/9/11).
 844 AC_DEFUN([CF_CPP_PARAM_INIT],
 845 [
 846 if test -n "$CXX"; then
 847 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
 848         AC_LANG_SAVE
 849         AC_LANG_CPLUSPLUS
 850         AC_TRY_RUN([
 851 class TEST {
 852 private:
 853         int value;
 854 public:
 855         TEST(int x = 1);
 856         ~TEST();
 857 };
 858
 859 TEST::TEST(int x = 1)   // some compilers do not like second initializer
 860 {
 861         value = x;
 862 }
 863 void main() { }
 864 ],
 865         [cf_cv_cpp_param_init=yes],
 866         [cf_cv_cpp_param_init=no],
 867         [cf_cv_cpp_param_init=unknown])
 868         AC_LANG_RESTORE
 869 ])
 870 fi
 871 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT)
 872 ])dnl
 873 dnl ---------------------------------------------------------------------------
 874 dnl CF_CPP_STATIC_CAST version: 1 updated: 2005/07/23 16:52:43
 875 dnl ------------------
 876 dnl Check if the C++ compiler accepts static_cast in generics.  This appears to
 877 dnl not be supported in g++ before 3.0
 878 AC_DEFUN([CF_CPP_STATIC_CAST],
 879 [
 880 if test -n "$CXX"; then
 881
 882 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
 883         AC_LANG_SAVE
 884         AC_LANG_CPLUSPLUS
 885
 886         AC_TRY_COMPILE([
 887 class NCursesPanel
 888 {
 889 public:
 890   NCursesPanel(int nlines,
 891                int ncols,
 892                int begin_y = 0,
 893                int begin_x = 0)
 894   {
 895   }
 896
 897   ~NCursesPanel();
 898 };
 899
 900 template<class T> class NCursesUserPanel : public NCursesPanel
 901 {
 902 public:
 903   NCursesUserPanel (int nlines,
 904                     int ncols,
 905                     int begin_y = 0,
 906                     int begin_x = 0,
 907                     const T* p_UserData = static_cast<T*>(0))
 908     : NCursesPanel (nlines, ncols, begin_y, begin_x)
 909   {
 910   };
 911   NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
 912   {
 913   };
 914
 915   virtual ~NCursesUserPanel() {};
 916 };
 917 ],[
 918         const char* p_UserData = static_cast<char*>(0)],
 919         [cf_cv_cpp_static_cast=yes],
 920         [cf_cv_cpp_static_cast=no])
 921
 922         AC_LANG_RESTORE
 923 ])
 924
 925 fi
 926
 927 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST)
 928 ])dnl
 929 dnl ---------------------------------------------------------------------------
 930 dnl CF_C_INLINE version: 2 updated: 2007/08/11 14:09:50
 931 dnl -----------
 932 dnl Check if the C compiler supports "inline".
 933 dnl $1 is the name of a shell variable to set if inline is supported
 934 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
 935 AC_DEFUN([CF_C_INLINE],[
 936 AC_C_INLINE
 937 $1=
 938 if test "$ac_cv_c_inline" != no ; then
 939   $1=inline
 940   if test "$INTEL_COMPILER" = yes
 941   then
 942     :
 943   elif test "$GCC" = yes
 944   then
 945     AC_CACHE_CHECK(if gcc supports options to tune inlining,cf_cv_gcc_inline,[
 946       cf_save_CFLAGS=$CFLAGS
 947       CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
 948       AC_TRY_COMPILE([inline int foo(void) { return 1; }],
 949       [${cf_cv_main_return:-return} foo()],
 950       [cf_cv_gcc_inline=yes],
 951       [cf_cv_gcc_inline=no])
 952       CFLAGS=$cf_save_CFLAGS
 953     ])
 954     if test "$cf_cv_gcc_inline" = yes ; then
 955         CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
 956     fi
 957   fi
 958 fi
 959 AC_SUBST($1)
 960 ])dnl
 961 dnl ---------------------------------------------------------------------------
 962 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
 963 dnl ----------
 964 dnl "dirname" is not portable, so we fake it with a shell script.
 965 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
 966 dnl ---------------------------------------------------------------------------
 967 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
 968 dnl ---------------
 969 AC_DEFUN([CF_DIRS_TO_MAKE],
 970 [
 971 DIRS_TO_MAKE="lib"
 972 for cf_item in $cf_list_models
 973 do
 974         CF_OBJ_SUBDIR($cf_item,cf_subdir)
 975         for cf_item2 in $DIRS_TO_MAKE
 976         do
 977                 test $cf_item2 = $cf_subdir && break
 978         done
 979         test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
 980 done
 981 for cf_dir in $DIRS_TO_MAKE
 982 do
 983         test ! -d $cf_dir && mkdir $cf_dir
 984 done
 985 AC_SUBST(DIRS_TO_MAKE)
 986 ])dnl
 987 dnl ---------------------------------------------------------------------------
 988 dnl CF_DISABLE_LEAKS version: 4 updated: 2006/12/16 15:10:42
 989 dnl ----------------
 990 dnl Combine no-leak checks with the libraries or tools that are used for the
 991 dnl checks.
 992 AC_DEFUN([CF_DISABLE_LEAKS],[
 993
 994 AC_REQUIRE([CF_WITH_DMALLOC])
 995 AC_REQUIRE([CF_WITH_DBMALLOC])
 996 AC_REQUIRE([CF_WITH_VALGRIND])
 997
 998 AC_MSG_CHECKING(if you want to perform memory-leak testing)
 999 AC_ARG_ENABLE(leaks,
1000         [  --disable-leaks         test: free permanent memory, analyze leaks],
1001         [with_no_leaks=yes],
1002         : ${with_no_leaks:=no})
1003 AC_MSG_RESULT($with_no_leaks)
1004
1005 if test "$with_no_leaks" = yes ; then
1006         AC_DEFINE(NO_LEAKS)
1007 fi
1008 ])dnl
1009 dnl ---------------------------------------------------------------------------
1010 dnl CF_ENABLE_RPATH version: 1 updated: 2008/09/13 10:22:30
1011 dnl ---------------
1012 dnl Check if the rpath option should be used, setting cache variable
1013 dnl cf_cv_ld_rpath if so.
1014 AC_DEFUN([CF_ENABLE_RPATH],
1015 [
1016 AC_MSG_CHECKING(if rpath option should be used)
1017 AC_ARG_ENABLE(rpath,
1018 [  --enable-rpath          use rpath option when generating shared libraries],
1019 [cf_cv_ld_rpath=$enableval],
1020 [cf_cv_ld_rpath=no])
1021 AC_MSG_RESULT($cf_cv_ld_rpath)
1022 ])dnl
1023 dnl ---------------------------------------------------------------------------
1024 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
1025 dnl --------
1026 dnl Check if 'errno' is declared in <errno.h>
1027 AC_DEFUN([CF_ERRNO],
1028 [
1029 CF_CHECK_ERRNO(errno)
1030 ])dnl
1031 dnl ---------------------------------------------------------------------------
1032 dnl CF_ETIP_DEFINES version: 3 updated: 2003/03/22 19:13:43
1033 dnl ---------------
1034 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
1035 dnl math.h and builtin.h, only for ncurses
1036 AC_DEFUN([CF_ETIP_DEFINES],
1037 [
1038 AC_MSG_CHECKING(for special defines needed for etip.h)
1039 cf_save_CXXFLAGS="$CXXFLAGS"
1040 cf_result="none"
1041 for cf_math in "" MATH_H
1042 do
1043 for cf_excp in "" MATH_EXCEPTION
1044 do
1045         CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -I${srcdir}/include"
1046         test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
1047         test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
1048 AC_TRY_COMPILE([
1049 #include <etip.h.in>
1050 ],[],[
1051         test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
1052         test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
1053         cf_result="$cf_math $cf_excp"
1054         break
1055 ],[])
1056 done
1057 done
1058 AC_MSG_RESULT($cf_result)
1059 CXXFLAGS="$cf_save_CXXFLAGS"
1060 ])
1061 dnl ---------------------------------------------------------------------------
1062 dnl CF_FIND_LINKAGE version: 13 updated: 2008/12/24 07:59:55
1063 dnl ---------------
1064 dnl Find a library (specifically the linkage used in the code fragment),
1065 dnl searching for it if it is not already in the library path.
1066 dnl See also CF_ADD_SEARCHPATH.
1067 dnl
1068 dnl Parameters (4-on are optional):
1069 dnl     $1 = headers for library entrypoint
1070 dnl     $2 = code fragment for library entrypoint
1071 dnl     $3 = the library name without the "-l" option or ".so" suffix.
1072 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
1073 dnl     $5 = action to perform if not successful
1074 dnl     $6 = module name, if not the same as the library name
1075 dnl     $7 = extra libraries
1076 dnl
1077 dnl Sets these variables:
1078 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1079 dnl     $cf_cv_header_path_$3 - include-directory if needed
1080 dnl     $cf_cv_library_path_$3 - library-directory if needed
1081 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1082 AC_DEFUN([CF_FIND_LINKAGE],[
1083
1084 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1085 # will be set on completion of the AC_TRY_LINK below.
1086 cf_cv_header_path_$3=
1087 cf_cv_library_path_$3=
1088
1089 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1090
1091 AC_TRY_LINK([$1],[$2],
1092     cf_cv_find_linkage_$3=yes,[
1093     cf_cv_find_linkage_$3=no
1094
1095     CF_VERBOSE(find linkage for $3 library)
1096     CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1097
1098     cf_save_CPPFLAGS="$CPPFLAGS"
1099     cf_test_CPPFLAGS="$CPPFLAGS"
1100
1101     CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1102     for cf_cv_header_path_$3 in $cf_search
1103     do
1104       if test -d $cf_cv_header_path_$3 ; then
1105         CF_VERBOSE(... testing $cf_cv_header_path_$3)
1106         CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
1107         AC_TRY_COMPILE([$1],[$2],[
1108             CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1109             cf_cv_find_linkage_$3=maybe
1110             cf_test_CPPFLAGS="$CPPFLAGS"
1111             break],[
1112             CPPFLAGS="$cf_save_CPPFLAGS"
1113             ])
1114       fi
1115     done
1116
1117     if test "$cf_cv_find_linkage_$3" = maybe ; then
1118
1119       CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1120
1121       cf_save_LIBS="$LIBS"
1122       cf_save_LDFLAGS="$LDFLAGS"
1123
1124       ifelse([$6],,,[
1125         CPPFLAGS="$cf_test_CPPFLAGS"
1126         LIBS="-l$3 $7 $cf_save_LIBS"
1127         AC_TRY_LINK([$1],[$2],[
1128             CF_VERBOSE(... found $3 library in system)
1129             cf_cv_find_linkage_$3=yes])
1130             CPPFLAGS="$cf_save_CPPFLAGS"
1131             LIBS="$cf_save_LIBS"
1132             ])
1133
1134       if test "$cf_cv_find_linkage_$3" != yes ; then
1135         CF_LIBRARY_PATH(cf_search,$3)
1136         for cf_cv_library_path_$3 in $cf_search
1137         do
1138           if test -d $cf_cv_library_path_$3 ; then
1139             CF_VERBOSE(... testing $cf_cv_library_path_$3)
1140             CPPFLAGS="$cf_test_CPPFLAGS"
1141             LIBS="-l$3 $7 $cf_save_LIBS"
1142             LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1143             AC_TRY_LINK([$1],[$2],[
1144                 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1145                 cf_cv_find_linkage_$3=yes
1146                 cf_cv_library_file_$3="-l$3"
1147                 break],[
1148                 CPPFLAGS="$cf_save_CPPFLAGS"
1149                 LIBS="$cf_save_LIBS"
1150                 LDFLAGS="$cf_save_LDFLAGS"
1151                 ])
1152           fi
1153         done
1154         LIBS="$cf_save_LIBS"
1155         CPPFLAGS="$cf_save_CPPFLAGS"
1156         LDFLAGS="$cf_save_LDFLAGS"
1157       fi
1158
1159     else
1160       cf_cv_find_linkage_$3=no
1161     fi
1162     ],$7)
1163
1164 if test "$cf_cv_find_linkage_$3" = yes ; then
1165 ifelse([$4],,[
1166   CF_ADD_INCDIR($cf_cv_header_path_$3)
1167   CF_ADD_LIBDIR($cf_cv_library_path_$3)
1168   LIBS="-l$3 $LIBS"
1169 ],[$4])
1170 else
1171 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1172 fi
1173 ])dnl
1174 dnl ---------------------------------------------------------------------------
1175 dnl CF_FUNC_DLSYM version: 1 updated: 2004/06/16 20:52:45
1176 dnl -------------
1177 dnl Test for dlsym() and related functions, as well as libdl.
1178 dnl
1179 dnl Sets
1180 dnl     $cf_have_dlsym
1181 dnl     $cf_have_libdl
1182 AC_DEFUN([CF_FUNC_DLSYM],[
1183 cf_have_dlsym=no
1184 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
1185
1186 cf_have_libdl=no
1187 AC_CHECK_LIB(dl,dlsym,[
1188         cf_have_dlsym=yes
1189         cf_have_libdl=yes])])
1190
1191 if test "$cf_have_dlsym" = yes ; then
1192         test "$cf_have_libdl" = yes && LIBS="-ldl $LIBS"
1193
1194         AC_MSG_CHECKING(whether able to link to dl*() functions)
1195         AC_TRY_LINK([#include <dlfcn.h>],[
1196                 void *obj;
1197                 if ((obj = dlopen("filename", 0)) != 0) {
1198                         if (dlsym(obj, "symbolname") == 0) {
1199                         dlclose(obj);
1200                         }
1201                 }],[
1202                 AC_DEFINE(HAVE_LIBDL)],[
1203                 AC_MSG_ERROR(Cannot link test program for libdl)])
1204         AC_MSG_RESULT(ok)
1205 else
1206         AC_MSG_ERROR(Cannot find dlsym function)
1207 fi
1208 ])
1209 dnl ---------------------------------------------------------------------------
1210 dnl CF_FUNC_MEMMOVE version: 7 updated: 2006/12/16 12:33:30
1211 dnl ---------------
1212 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
1213 dnl is found, add our own version of memmove to the list of objects.
1214 AC_DEFUN([CF_FUNC_MEMMOVE],
1215 [
1216 AC_CHECK_FUNC(memmove,,[
1217 AC_CHECK_FUNC(bcopy,[
1218         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
1219                 AC_TRY_RUN([
1220 int main() {
1221         static char data[] = "abcdefghijklmnopqrstuwwxyz";
1222         char temp[40];
1223         bcopy(data, temp, sizeof(data));
1224         bcopy(temp+10, temp, 15);
1225         bcopy(temp+5, temp+15, 10);
1226         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
1227 }
1228                 ],
1229                 [cf_cv_good_bcopy=yes],
1230                 [cf_cv_good_bcopy=no],
1231                 [cf_cv_good_bcopy=unknown])
1232                 ])
1233         ],[cf_cv_good_bcopy=no])
1234         if test "$cf_cv_good_bcopy" = yes ; then
1235                 AC_DEFINE(USE_OK_BCOPY)
1236         else
1237                 AC_DEFINE(USE_MY_MEMMOVE)
1238         fi
1239 ])])dnl
1240 dnl ---------------------------------------------------------------------------
1241 dnl CF_FUNC_NANOSLEEP version: 3 updated: 2006/12/16 12:33:30
1242 dnl -----------------
1243 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
1244 dnl AIX 4.x, provide a non-working version.
1245 AC_DEFUN([CF_FUNC_NANOSLEEP],[
1246 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
1247 AC_TRY_RUN([
1248 #include <stdio.h>
1249 #include <errno.h>
1250 #include <time.h>
1251
1252 #ifdef HAVE_SYS_TIME_H
1253 #include <sys/time.h>
1254 #endif
1255
1256 int main() {
1257         struct timespec ts1, ts2;
1258         int code;
1259         ts1.tv_sec  = 0;
1260         ts1.tv_nsec = 750000000;
1261         ts2.tv_sec  = 0;
1262         ts2.tv_nsec = 0;
1263         errno = 0;
1264         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
1265         ${cf_cv_main_return:-return}(code != 0);
1266 }
1267 ],
1268         [cf_cv_func_nanosleep=yes],
1269         [cf_cv_func_nanosleep=no],
1270         [cf_cv_func_nanosleep=unknown])])
1271
1272 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP)
1273 ])
1274 dnl ---------------------------------------------------------------------------
1275 dnl CF_FUNC_OPENPTY version: 2 updated: 2008/04/12 19:49:01
1276 dnl ---------------
1277 dnl Check for openpty() function, along with <pty.h> header.  It may need the
1278 dnl "util" library as well.
1279 AC_DEFUN([CF_FUNC_OPENPTY],
1280 [
1281 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1282 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1283     cf_save_LIBS="$LIBS"
1284     test $cf_cv_lib_util = yes && LIBS="-lutil $LIBS"
1285     for cf_header in pty.h libutil.h util.h
1286     do
1287     AC_TRY_LINK([
1288 #include <$cf_header>
1289 ],[
1290     int x = openpty((int *)0, (int *)0, (char *)0,
1291                    (struct termios *)0, (struct winsize *)0);
1292 ],[
1293         cf_cv_func_openpty=$cf_header
1294         break
1295 ],[
1296         cf_cv_func_openpty=no
1297 ])
1298     done
1299     LIBS="$cf_save_LIBS"
1300 ])
1301 ])dnl
1302 dnl ---------------------------------------------------------------------------
1303 dnl CF_FUNC_POLL version: 4 updated: 2006/12/16 12:33:30
1304 dnl ------------
1305 dnl See if the poll function really works.  Some platforms have poll(), but
1306 dnl it does not work for terminals or files.
1307 AC_DEFUN([CF_FUNC_POLL],[
1308 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1309 AC_TRY_RUN([
1310 #include <stdio.h>
1311 #ifdef HAVE_POLL_H
1312 #include <poll.h>
1313 #else
1314 #include <sys/poll.h>
1315 #endif
1316 int main() {
1317         struct pollfd myfds;
1318         int ret;
1319
1320         myfds.fd = 0;
1321         myfds.events = POLLIN;
1322
1323         ret = poll(&myfds, 1, 100);
1324         ${cf_cv_main_return:-return}(ret != 0);
1325 }],
1326         [cf_cv_working_poll=yes],
1327         [cf_cv_working_poll=no],
1328         [cf_cv_working_poll=unknown])])
1329 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
1330 ])dnl
1331 dnl ---------------------------------------------------------------------------
1332 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
1333 dnl ---------------
1334 dnl Some old/broken variations define tcgetattr() only as a macro in
1335 dnl termio(s).h
1336 AC_DEFUN([CF_FUNC_TERMIOS],[
1337 AC_REQUIRE([CF_STRUCT_TERMIOS])
1338 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1339 AC_TRY_LINK([
1340 #include <sys/types.h>
1341 #ifdef HAVE_UNISTD_H
1342 #include <unistd.h>
1343 #endif
1344 #ifdef HAVE_TERMIOS_H
1345 #include <termios.h>
1346 #define TTY struct termios
1347 #else
1348 #ifdef HAVE_TERMIO_H
1349 #include <termio.h>
1350 #define TTY struct termio
1351 #endif
1352 #endif
1353 ],[
1354 TTY foo;
1355 tcgetattr(1, &foo);],
1356 [cf_cv_have_tcgetattr=yes],
1357 [cf_cv_have_tcgetattr=no])])
1358 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
1359 ])dnl
1360 dnl ---------------------------------------------------------------------------
1361 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
1362 dnl ---------------
1363 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1364 dnl versions of C.  It is in the GNU C library, and can often be simulated by
1365 dnl other functions.
1366 AC_DEFUN([CF_FUNC_VSSCANF],
1367 [
1368 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1369 AC_TRY_LINK([
1370 #include <stdarg.h>
1371 #include <stdio.h>],[
1372         va_list ap;
1373         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1374 AC_TRY_LINK([
1375 #include <stdarg.h>
1376 #include <stdio.h>],[
1377     FILE strbuf;
1378     char *str = "from";
1379
1380     strbuf._flag = _IOREAD;
1381     strbuf._ptr = strbuf._base = (unsigned char *) str;
1382     strbuf._cnt = strlen(str);
1383     strbuf._file = _NFILE;
1384     return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1385 AC_TRY_LINK([
1386 #include <stdarg.h>
1387 #include <stdio.h>],[
1388     FILE strbuf;
1389     char *str = "from";
1390
1391     strbuf._flag = _IOREAD;
1392     strbuf._ptr = strbuf._base = (unsigned char *) str;
1393     strbuf._cnt = strlen(str);
1394     strbuf._file = _NFILE;
1395     return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1396 cf_cv_func_vsscanf=no])])])])
1397
1398 case $cf_cv_func_vsscanf in #(vi
1399 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
1400 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
1401 _doscan) AC_DEFINE(HAVE__DOSCAN);;
1402 esac
1403
1404 ])dnl
1405 dnl ---------------------------------------------------------------------------
1406 dnl CF_GCC_ATTRIBUTES version: 13 updated: 2009/08/11 20:19:56
1407 dnl -----------------
1408 dnl Test for availability of useful gcc __attribute__ directives to quiet
1409 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1410 dnl to documentation, unrecognized directives cause older compilers to barf.
1411 AC_DEFUN([CF_GCC_ATTRIBUTES],
1412 [
1413 if test "$GCC" = yes
1414 then
1415 cat > conftest.i <<EOF
1416 #ifndef GCC_PRINTF
1417 #define GCC_PRINTF 0
1418 #endif
1419 #ifndef GCC_SCANF
1420 #define GCC_SCANF 0
1421 #endif
1422 #ifndef GCC_NORETURN
1423 #define GCC_NORETURN /* nothing */
1424 #endif
1425 #ifndef GCC_UNUSED
1426 #define GCC_UNUSED /* nothing */
1427 #endif
1428 EOF
1429 if test "$GCC" = yes
1430 then
1431         AC_CHECKING([for $CC __attribute__ directives])
1432 cat > conftest.$ac_ext <<EOF
1433 #line __oline__ "${as_me-configure}"
1434 #include "confdefs.h"
1435 #include "conftest.h"
1436 #include "conftest.i"
1437 #if     GCC_PRINTF
1438 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1439 #else
1440 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1441 #endif
1442 #if     GCC_SCANF
1443 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1444 #else
1445 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1446 #endif
1447 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1448 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1449 extern void foo(void) GCC_NORETURN;
1450 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1451 EOF
1452         cf_printf_attribute=no
1453         cf_scanf_attribute=no
1454         for cf_attribute in scanf printf unused noreturn
1455         do
1456                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1457                 cf_directive="__attribute__(($cf_attribute))"
1458                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1459
1460                 case $cf_attribute in #(vi
1461                 printf) #(vi
1462                         cf_printf_attribute=yes
1463                         cat >conftest.h <<EOF
1464 #define GCC_$cf_ATTRIBUTE 1
1465 EOF
1466                         ;;
1467                 scanf) #(vi
1468                         cf_scanf_attribute=yes
1469                         cat >conftest.h <<EOF
1470 #define GCC_$cf_ATTRIBUTE 1
1471 EOF
1472                         ;;
1473                 *) #(vi
1474                         cat >conftest.h <<EOF
1475 #define GCC_$cf_ATTRIBUTE $cf_directive
1476 EOF
1477                         ;;
1478                 esac
1479
1480                 if AC_TRY_EVAL(ac_compile); then
1481                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1482                         cat conftest.h >>confdefs.h
1483                         case $cf_attribute in #(vi
1484                         printf) #(vi
1485                                 if test "$cf_printf_attribute" = no ; then
1486                                         cat >>confdefs.h <<EOF
1487 #define GCC_PRINTFLIKE(fmt,var) /* nothing */
1488 EOF
1489                                 else
1490                                         cat >>confdefs.h <<EOF
1491 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1492 EOF
1493                                 fi
1494                                 ;;
1495                         scanf) #(vi
1496                                 if test "$cf_scanf_attribute" = no ; then
1497                                         cat >>confdefs.h <<EOF
1498 #define GCC_SCANFLIKE(fmt,var) /* nothing */
1499 EOF
1500                                 else
1501                                         cat >>confdefs.h <<EOF
1502 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1503 EOF
1504                                 fi
1505                                 ;;
1506                         esac
1507                 fi
1508         done
1509 else
1510         fgrep define conftest.i >>confdefs.h
1511 fi
1512 rm -rf conftest*
1513 fi
1514 ])dnl
1515 dnl ---------------------------------------------------------------------------
1516 dnl CF_GCC_VERSION version: 4 updated: 2005/08/27 09:53:42
1517 dnl --------------
1518 dnl Find version of gcc
1519 AC_DEFUN([CF_GCC_VERSION],[
1520 AC_REQUIRE([AC_PROG_CC])
1521 GCC_VERSION=none
1522 if test "$GCC" = yes ; then
1523         AC_MSG_CHECKING(version of $CC)
1524         GCC_VERSION="`${CC} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1525         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1526         AC_MSG_RESULT($GCC_VERSION)
1527 fi
1528 ])dnl
1529 dnl ---------------------------------------------------------------------------
1530 dnl CF_GCC_WARNINGS version: 24 updated: 2009/02/01 15:21:00
1531 dnl ---------------
1532 dnl Check if the compiler supports useful warning options.  There's a few that
1533 dnl we don't use, simply because they're too noisy:
1534 dnl
1535 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1536 dnl     -Wredundant-decls (system headers make this too noisy)
1537 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1538 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1539 dnl             is enabled for ncurses using "--enable-const".
1540 dnl     -pedantic
1541 dnl
1542 dnl Parameter:
1543 dnl     $1 is an optional list of gcc warning flags that a particular
1544 dnl             application might want to use, e.g., "no-unused" for
1545 dnl             -Wno-unused
1546 dnl Special:
1547 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1548 dnl
1549 AC_DEFUN([CF_GCC_WARNINGS],
1550 [
1551 AC_REQUIRE([CF_GCC_VERSION])
1552 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1553
1554 cat > conftest.$ac_ext <<EOF
1555 #line __oline__ "${as_me-configure}"
1556 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1557 EOF
1558
1559 if test "$INTEL_COMPILER" = yes
1560 then
1561 # The "-wdXXX" options suppress warnings:
1562 # remark #1419: external declaration in primary source file
1563 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1564 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1565 # remark #193: zero used for undefined preprocessing identifier
1566 # remark #593: variable "curs_sb_left_arrow" was set but never used
1567 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1568 # remark #869: parameter "tw" was never referenced
1569 # remark #981: operands are evaluated in unspecified order
1570 # warning #279: controlling expression is constant
1571
1572         AC_CHECKING([for $CC warning options])
1573         cf_save_CFLAGS="$CFLAGS"
1574         EXTRA_CFLAGS="-Wall"
1575         for cf_opt in \
1576                 wd1419 \
1577                 wd1683 \
1578                 wd1684 \
1579                 wd193 \
1580                 wd593 \
1581                 wd279 \
1582                 wd810 \
1583                 wd869 \
1584                 wd981
1585         do
1586                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1587                 if AC_TRY_EVAL(ac_compile); then
1588                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1589                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1590                 fi
1591         done
1592         CFLAGS="$cf_save_CFLAGS"
1593
1594 elif test "$GCC" = yes
1595 then
1596         AC_CHECKING([for $CC warning options])
1597         cf_save_CFLAGS="$CFLAGS"
1598         EXTRA_CFLAGS="-W -Wall"
1599         cf_warn_CONST=""
1600         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1601         for cf_opt in \
1602                 Wbad-function-cast \
1603                 Wcast-align \
1604                 Wcast-qual \
1605                 Winline \
1606                 Wmissing-declarations \
1607                 Wmissing-prototypes \
1608                 Wnested-externs \
1609                 Wpointer-arith \
1610                 Wshadow \
1611                 Wstrict-prototypes \
1612                 Wundef $cf_warn_CONST $1
1613         do
1614                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1615                 if AC_TRY_EVAL(ac_compile); then
1616                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1617                         case $cf_opt in #(vi
1618                         Wcast-qual) #(vi
1619                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1620                                 ;;
1621                         Winline) #(vi
1622                                 case $GCC_VERSION in
1623                                 [[34]].*)
1624                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1625                                         continue;;
1626                                 esac
1627                                 ;;
1628                         esac
1629                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1630                 fi
1631         done
1632         CFLAGS="$cf_save_CFLAGS"
1633 fi
1634 rm -f conftest*
1635
1636 AC_SUBST(EXTRA_CFLAGS)
1637 ])dnl
1638 dnl ---------------------------------------------------------------------------
1639 dnl CF_GNAT_TRY_LINK version: 1 updated: 2004/08/21 19:02:08
1640 dnl ----------------
1641 dnl Verify that a test program compiles/links with GNAT.
1642 dnl $cf_ada_make is set to the program that compiles/links
1643 dnl $ADAFLAGS may be set to the GNAT flags.
1644 dnl
1645 dnl $1 is the text of the spec
1646 dnl $2 is the text of the body
1647 dnl $3 is the shell command to execute if successful
1648 dnl $4 is the shell command to execute if not successful
1649 AC_DEFUN([CF_GNAT_TRY_LINK],
1650 [
1651 rm -f conftest*
1652 cat >>conftest.ads <<CF_EOF
1653 $1
1654 CF_EOF
1655 cat >>conftest.adb <<CF_EOF
1656 $2
1657 CF_EOF
1658 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1659 ifelse($3,,      :,[      $3])
1660 ifelse($4,,,[else
1661    $4])
1662 fi
1663 rm -f conftest*
1664 ])dnl
1665 dnl ---------------------------------------------------------------------------
1666 dnl CF_GNAT_TRY_RUN version: 3 updated: 2004/08/21 19:02:08
1667 dnl ---------------
1668 dnl Verify that a test program compiles and runs with GNAT
1669 dnl $cf_ada_make is set to the program that compiles/links
1670 dnl $ADAFLAGS may be set to the GNAT flags.
1671 dnl
1672 dnl $1 is the text of the spec
1673 dnl $2 is the text of the body
1674 dnl $3 is the shell command to execute if successful
1675 dnl $4 is the shell command to execute if not successful
1676 AC_DEFUN([CF_GNAT_TRY_RUN],
1677 [
1678 rm -f conftest*
1679 cat >>conftest.ads <<CF_EOF
1680 $1
1681 CF_EOF
1682 cat >>conftest.adb <<CF_EOF
1683 $2
1684 CF_EOF
1685 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1686    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1687 ifelse($3,,      :,[      $3])
1688 ifelse($4,,,[   else
1689       $4])
1690    fi
1691 ifelse($4,,,[else
1692    $4])
1693 fi
1694 rm -f conftest*
1695 ])dnl
1696 dnl ---------------------------------------------------------------------------
1697 dnl CF_GNAT_VERSION version: 12 updated: 2006/10/14 15:23:15
1698 dnl ---------------
1699 dnl Verify version of GNAT.
1700 AC_DEFUN([CF_GNAT_VERSION],
1701 [
1702 AC_MSG_CHECKING(for gnat version)
1703 cf_gnat_version=`${cf_ada_make-gnatmake} -v 2>&1 | grep '[[0-9]].[[0-9]][[0-9]]*' |\
1704   sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1705 AC_MSG_RESULT($cf_gnat_version)
1706
1707 case $cf_gnat_version in
1708   3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*)
1709     cf_cv_prog_gnat_correct=yes
1710     ;;
1711   *) echo Unsupported GNAT version $cf_gnat_version. Required is 3.11 or better. Disabling Ada95 binding.
1712      cf_cv_prog_gnat_correct=no
1713      ;;
1714 esac
1715 case $cf_gnat_version in
1716   3.[[1-9]]*|[[4-9]].*)
1717       cf_compile_generics=generics
1718       cf_generic_objects="\${GENOBJS}"
1719       ;;
1720   *)  cf_compile_generics=
1721       cf_generic_objects=
1722       ;;
1723 esac
1724 ])
1725 dnl ---------------------------------------------------------------------------
1726 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1727 dnl -------------
1728 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1729 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1730 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1731 dnl since it is interwoven with GNU extensions.
1732 dnl
1733 dnl Well, yes we could work around it...
1734 AC_DEFUN([CF_GNU_SOURCE],
1735 [
1736 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1737 AC_TRY_COMPILE([#include <sys/types.h>],[
1738 #ifndef _XOPEN_SOURCE
1739 make an error
1740 #endif],
1741         [cf_cv_gnu_source=no],
1742         [cf_save="$CPPFLAGS"
1743          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1744          AC_TRY_COMPILE([#include <sys/types.h>],[
1745 #ifdef _XOPEN_SOURCE
1746 make an error
1747 #endif],
1748         [cf_cv_gnu_source=no],
1749         [cf_cv_gnu_source=yes])
1750         CPPFLAGS="$cf_save"
1751         ])
1752 ])
1753 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1754 ])dnl
1755 dnl ---------------------------------------------------------------------------
1756 dnl CF_GPP_LIBRARY version: 9 updated: 2009/12/19 13:46:49
1757 dnl --------------
1758 dnl If we're trying to use g++, test if libg++ is installed (a rather common
1759 dnl problem :-).  If we have the compiler but no library, we'll be able to
1760 dnl configure, but won't be able to build the c++ demo program.
1761 AC_DEFUN([CF_GPP_LIBRARY],
1762 [
1763 cf_cxx_library=unknown
1764 case $cf_cv_system_name in #(vi
1765 os2*) #(vi
1766         cf_gpp_libname=gpp
1767         ;;
1768 *)
1769         cf_gpp_libname=g++
1770         ;;
1771 esac
1772 if test "$GXX" = yes; then
1773         AC_MSG_CHECKING([for lib$cf_gpp_libname])
1774         cf_save="$LIBS"
1775         LIBS="-l$cf_gpp_libname $LIBS"
1776         AC_TRY_LINK([
1777 #include <$cf_gpp_libname/builtin.h>
1778         ],
1779         [two_arg_error_handler_t foo2 = lib_error_handler],
1780         [cf_cxx_library=yes
1781          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1782          if test "$cf_gpp_libname" = cpp ; then
1783             AC_DEFINE(HAVE_GPP_BUILTIN_H)
1784          else
1785             AC_DEFINE(HAVE_GXX_BUILTIN_H)
1786          fi],
1787         [AC_TRY_LINK([
1788 #include <builtin.h>
1789         ],
1790         [two_arg_error_handler_t foo2 = lib_error_handler],
1791         [cf_cxx_library=yes
1792          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1793          AC_DEFINE(HAVE_BUILTIN_H)],
1794         [cf_cxx_library=no])])
1795         LIBS="$cf_save"
1796         AC_MSG_RESULT($cf_cxx_library)
1797 fi
1798 ])dnl
1799 dnl ---------------------------------------------------------------------------
1800 dnl CF_GXX_VERSION version: 5 updated: 2005/08/27 09:53:42
1801 dnl --------------
1802 dnl Check for version of g++
1803 AC_DEFUN([CF_GXX_VERSION],[
1804 AC_REQUIRE([AC_PROG_CPP])
1805 GXX_VERSION=none
1806 if test "$GXX" = yes; then
1807         AC_MSG_CHECKING(version of g++)
1808         GXX_VERSION="`${CXX-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1809         test -z "$GXX_VERSION" && GXX_VERSION=unknown
1810         AC_MSG_RESULT($GXX_VERSION)
1811 fi
1812 ])dnl
1813 dnl ---------------------------------------------------------------------------
1814 dnl CF_GXX_WARNINGS version: 5 updated: 2005/08/13 14:54:38
1815 dnl ---------------
1816 dnl Check if the compiler supports useful warning options.
1817 dnl
1818 dnl Most of gcc's options apply to g++, except:
1819 dnl     -Wbad-function-cast
1820 dnl     -Wmissing-declarations
1821 dnl     -Wnested-externs
1822 dnl
1823 dnl Omit a few (for now):
1824 dnl     -Winline
1825 dnl
1826 dnl Parameter:
1827 dnl     $1 is an optional list of g++ warning flags that a particular
1828 dnl             application might want to use, e.g., "no-unused" for
1829 dnl             -Wno-unused
1830 dnl Special:
1831 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1832 dnl
1833 AC_DEFUN([CF_GXX_WARNINGS],
1834 [
1835
1836 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
1837
1838 AC_REQUIRE([CF_GXX_VERSION])
1839
1840 AC_LANG_SAVE
1841 AC_LANG_CPLUSPLUS
1842
1843 cat > conftest.$ac_ext <<EOF
1844 #line __oline__ "configure"
1845 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1846 EOF
1847
1848 if test "$INTEL_CPLUSPLUS" = yes
1849 then
1850 # The "-wdXXX" options suppress warnings:
1851 # remark #1419: external declaration in primary source file
1852 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1853 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1854 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1855 # remark #193: zero used for undefined preprocessing identifier
1856 # remark #593: variable "curs_sb_left_arrow" was set but never used
1857 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1858 # remark #869: parameter "tw" was never referenced
1859 # remark #981: operands are evaluated in unspecified order
1860 # warning #269: invalid format string conversion
1861
1862         AC_CHECKING([for $CC warning options])
1863         cf_save_CXXFLAGS="$CXXFLAGS"
1864         EXTRA_CXXFLAGS="-Wall"
1865         for cf_opt in \
1866                 wd1419 \
1867                 wd1682 \
1868                 wd1683 \
1869                 wd1684 \
1870                 wd193 \
1871                 wd279 \
1872                 wd593 \
1873                 wd810 \
1874                 wd869 \
1875                 wd981
1876         do
1877                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
1878                 if AC_TRY_EVAL(ac_compile); then
1879                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1880                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1881                 fi
1882         done
1883         CXXFLAGS="$cf_save_CXXFLAGS"
1884
1885 elif test "$GXX" = yes
1886 then
1887         AC_CHECKING([for $CXX warning options])
1888         cf_save_CXXFLAGS="$CXXFLAGS"
1889         EXTRA_CXXFLAGS="-W -Wall"
1890         cf_gxx_extra_warnings=""
1891         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
1892         case "$GCC_VERSION" in
1893         [[1-2]].*)
1894                 ;;
1895         *)
1896                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
1897                 ;;
1898         esac
1899         for cf_opt in \
1900                 Wabi \
1901                 fabi-version=0 \
1902                 Woverloaded-virtual \
1903                 Wsign-promo \
1904                 Wsynth \
1905                 Wold-style-cast \
1906                 Wcast-align \
1907                 Wcast-qual \
1908                 Wmissing-prototypes \
1909                 Wpointer-arith \
1910                 Wshadow \
1911                 Wstrict-prototypes \
1912                 Wundef $cf_gxx_extra_warnings $1
1913         do
1914                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
1915                 if AC_TRY_EVAL(ac_compile); then
1916                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1917                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1918                 else
1919                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
1920                 fi
1921         done
1922         CXXFLAGS="$cf_save_CXXFLAGS"
1923 fi
1924
1925 rm -f conftest*
1926 AC_LANG_RESTORE
1927 AC_SUBST(EXTRA_CXXFLAGS)
1928 ])dnl
1929 dnl ---------------------------------------------------------------------------
1930 dnl CF_HASHED_DB version: 3 updated: 2007/11/24 17:43:37
1931 dnl ------------
1932 dnl Look for an instance of the Berkeley hashed database.
1933 dnl
1934 dnl $1 = optional parameter, to specify install-prefix for the database.
1935 AC_DEFUN([CF_HASHED_DB],
1936 [
1937 ifelse([$1],,,[
1938 case $1 in #(vi
1939 yes|*able*) #(vi
1940     ;;
1941 *)
1942     if test -d "$1" ; then
1943         CF_ADD_INCDIR($1/include)
1944         CF_ADD_LIBDIR($1/lib)
1945     fi
1946 esac
1947 ])
1948 AC_CHECK_HEADER(db.h,[
1949 CF_HASHED_DB_VERSION
1950 if test "$cf_cv_hashed_db_version" = unknown ; then
1951         AC_MSG_ERROR(Cannot determine version of db)
1952 else
1953         CF_HASHED_DB_LIBS
1954         if test "$cf_cv_hashed_db_libs" = unknown ; then
1955                 AC_MSG_ERROR(Cannot determine library for db)
1956         elif test "$cf_cv_hashed_db_libs" != default ; then
1957                 LIBS="-l$cf_cv_hashed_db_libs $LIBS"
1958         fi
1959 fi
1960 ],[
1961         AC_MSG_ERROR(Cannot find db.h)
1962 ])
1963 ])dnl
1964 dnl ---------------------------------------------------------------------------
1965 dnl CF_HASHED_DB_LIBS version: 8 updated: 2008/08/04 06:18:06
1966 dnl -----------------
1967 dnl Given that we have the header and version for hashed database, find the
1968 dnl library information.
1969 AC_DEFUN([CF_HASHED_DB_LIBS],
1970 [
1971 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
1972 cf_cv_hashed_db_libs=unknown
1973 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
1974 do
1975         cf_save_libs="$LIBS"
1976         if test -n "$cf_db_libs"; then
1977                 LIBS="-l$cf_db_libs $LIBS"
1978         fi
1979         CF_MSG_LOG(checking for library "$cf_db_libs")
1980         AC_TRY_LINK([
1981 $ac_includes_default
1982 #include <db.h>
1983 ],[
1984         char *path = "/tmp/foo";
1985 #ifdef DB_VERSION_MAJOR
1986 #if DB_VERSION_MAJOR >= 4
1987         DB *result = 0;
1988         db_create(&result, NULL, 0);
1989         result->open(result,
1990                 NULL,
1991                 path,
1992                 path,
1993                 DB_HASH,
1994                 DB_CREATE,
1995                 0644);
1996 #elif DB_VERSION_MAJOR >= 3
1997         DB *result = 0;
1998         db_create(&result, NULL, 0);
1999         result->open(result,
2000                 path,
2001                 path,
2002                 DB_HASH,
2003                 DB_CREATE,
2004                 0644);
2005 #elif DB_VERSION_MAJOR >= 2
2006         DB *result = 0;
2007         db_open(path,
2008                 DB_HASH,
2009                 DB_CREATE,
2010                 0644,
2011                 (DB_ENV *) 0,
2012                 (DB_INFO *) 0,
2013                 &result);
2014 #endif /* DB_VERSION_MAJOR */
2015 #else
2016         DB *result = dbopen(path,
2017                      2,
2018                      0644,
2019                      DB_HASH,
2020                      0);
2021 #endif
2022         ${cf_cv_main_return:-return}(result != 0)
2023 ],[
2024         if test -n "$cf_db_libs" ; then
2025                 cf_cv_hashed_db_libs=$cf_db_libs
2026         else
2027                 cf_cv_hashed_db_libs=default
2028         fi
2029         LIBS="$cf_save_libs"
2030         break
2031 ])
2032         LIBS="$cf_save_libs"
2033 done
2034 ])
2035 ])dnl
2036 dnl ---------------------------------------------------------------------------
2037 dnl CF_HASHED_DB_VERSION version: 3 updated: 2007/12/01 15:01:37
2038 dnl --------------------
2039 dnl Given that we have the header file for hashed database, find the version
2040 dnl information.
2041 AC_DEFUN([CF_HASHED_DB_VERSION],
2042 [
2043 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
2044 cf_cv_hashed_db_version=unknown
2045
2046 for cf_db_version in 1 2 3 4 5
2047 do
2048         CF_MSG_LOG(checking for db version $cf_db_version)
2049         AC_TRY_COMPILE([
2050 $ac_includes_default
2051 #include <db.h>
2052
2053 #ifdef DB_VERSION_MAJOR
2054         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
2055 #if $cf_db_version == DB_VERSION_MAJOR
2056         /* ok */
2057 #else
2058         make an error
2059 #endif
2060 #else
2061 #if $cf_db_version == 1
2062         /* ok: assuming this is DB 1.8.5 */
2063 #else
2064         make an error
2065 #endif
2066 #endif
2067 ],[DBT *foo = 0],[
2068         cf_cv_hashed_db_version=$cf_db_version
2069         break
2070         ])
2071 done
2072 ])
2073 ])dnl
2074 dnl ---------------------------------------------------------------------------
2075 dnl CF_HEADER_PATH version: 9 updated: 2008/12/07 19:38:31
2076 dnl --------------
2077 dnl Construct a search-list of directories for a nonstandard header-file
2078 dnl
2079 dnl Parameters
2080 dnl     $1 = the variable to return as result
2081 dnl     $2 = the package name
2082 AC_DEFUN([CF_HEADER_PATH],
2083 [
2084 cf_header_path_list=""
2085 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2086         for cf_header_path in $CPPFLAGS $CFLAGS
2087         do
2088                 case $cf_header_path in #(vi
2089                 -I*)
2090                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2091                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2092                         cf_header_path_list="$cf_header_path_list [$]$1"
2093                         ;;
2094                 esac
2095         done
2096 fi
2097
2098 CF_SUBDIR_PATH($1,$2,include)
2099
2100 test "$includedir" != NONE && \
2101 test "$includedir" != "/usr/include" && \
2102 test -d "$includedir" && {
2103         test -d $includedir &&    $1="[$]$1 $includedir"
2104         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
2105 }
2106
2107 test "$oldincludedir" != NONE && \
2108 test "$oldincludedir" != "/usr/include" && \
2109 test -d "$oldincludedir" && {
2110         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
2111         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
2112 }
2113
2114 $1="$cf_header_path_list [$]$1"
2115 ])dnl
2116 dnl ---------------------------------------------------------------------------
2117 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
2118 dnl ---------------
2119 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2120 AC_DEFUN([CF_HELP_MESSAGE],
2121 [AC_DIVERT_HELP([$1])dnl
2122 ])dnl
2123 dnl ---------------------------------------------------------------------------
2124 dnl CF_INCLUDE_DIRS version: 6 updated: 2009/01/06 19:37:40
2125 dnl ---------------
2126 dnl Construct the list of include-options according to whether we're building
2127 dnl in the source directory or using '--srcdir=DIR' option.  If we're building
2128 dnl with gcc, don't append the includedir if it happens to be /usr/include,
2129 dnl since that usually breaks gcc's shadow-includes.
2130 AC_DEFUN([CF_INCLUDE_DIRS],
2131 [
2132 CPPFLAGS="$CPPFLAGS -I. -I../include"
2133 if test "$srcdir" != "."; then
2134         CPPFLAGS="$CPPFLAGS -I\${srcdir}/../include"
2135 fi
2136 if test "$GCC" != yes; then
2137         CPPFLAGS="$CPPFLAGS -I\${includedir}"
2138 elif test "$includedir" != "/usr/include"; then
2139         if test "$includedir" = '${prefix}/include' ; then
2140                 if test $prefix != /usr ; then
2141                         CPPFLAGS="$CPPFLAGS -I\${includedir}"
2142                 fi
2143         else
2144                 CPPFLAGS="$CPPFLAGS -I\${includedir}"
2145         fi
2146 fi
2147 AC_SUBST(CPPFLAGS)
2148 ])dnl
2149 dnl ---------------------------------------------------------------------------
2150 dnl CF_INTEL_COMPILER version: 3 updated: 2005/08/06 18:37:29
2151 dnl -----------------
2152 dnl Check if the given compiler is really the Intel compiler for Linux.  It
2153 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2154 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2155 dnl
2156 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2157 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
2158 dnl the wrappers for gcc and g++ warnings.
2159 dnl
2160 dnl $1 = GCC (default) or GXX
2161 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2162 dnl $3 = CFLAGS (default) or CXXFLAGS
2163 AC_DEFUN([CF_INTEL_COMPILER],[
2164 ifelse($2,,INTEL_COMPILER,[$2])=no
2165
2166 if test "$ifelse($1,,[$1],GCC)" = yes ; then
2167         case $host_os in
2168         linux*|gnu*)
2169                 AC_MSG_CHECKING(if this is really Intel ifelse($1,GXX,C++,C) compiler)
2170                 cf_save_CFLAGS="$ifelse($3,,CFLAGS,[$3])"
2171                 ifelse($3,,CFLAGS,[$3])="$ifelse($3,,CFLAGS,[$3]) -no-gcc"
2172                 AC_TRY_COMPILE([],[
2173 #ifdef __INTEL_COMPILER
2174 #else
2175 make an error
2176 #endif
2177 ],[ifelse($2,,INTEL_COMPILER,[$2])=yes
2178 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
2179 ],[])
2180                 ifelse($3,,CFLAGS,[$3])="$cf_save_CFLAGS"
2181                 AC_MSG_RESULT($ifelse($2,,INTEL_COMPILER,[$2]))
2182                 ;;
2183         esac
2184 fi
2185 ])dnl
2186 dnl ---------------------------------------------------------------------------
2187 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
2188 dnl ----------
2189 dnl Check if we have either a function or macro for 'isascii()'.
2190 AC_DEFUN([CF_ISASCII],
2191 [
2192 AC_MSG_CHECKING(for isascii)
2193 AC_CACHE_VAL(cf_cv_have_isascii,[
2194         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
2195         [cf_cv_have_isascii=yes],
2196         [cf_cv_have_isascii=no])
2197 ])dnl
2198 AC_MSG_RESULT($cf_cv_have_isascii)
2199 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
2200 ])dnl
2201 dnl ---------------------------------------------------------------------------
2202 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
2203 dnl ------------
2204 dnl Add checks for large file support.
2205 AC_DEFUN([CF_LARGEFILE],[
2206 ifdef([AC_FUNC_FSEEKO],[
2207     AC_SYS_LARGEFILE
2208     if test "$enable_largefile" != no ; then
2209         AC_FUNC_FSEEKO
2210
2211         # Normally we would collect these definitions in the config.h,
2212         # but (like _XOPEN_SOURCE), some environments rely on having these
2213         # defined before any of the system headers are included.  Another
2214         # case comes up with C++, e.g., on AIX the compiler compiles the
2215         # header files by themselves before looking at the body files it is
2216         # told to compile.  For ncurses, those header files do not include
2217         # the config.h
2218         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
2219         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
2220         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
2221
2222         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2223                 AC_TRY_COMPILE([
2224 #include <sys/types.h>
2225 #include <dirent.h>
2226                 ],[
2227                 /* if transitional largefile support is setup, this is true */
2228                 extern struct dirent64 * readdir(DIR *);
2229                 struct dirent64 *x = readdir((DIR *)0);
2230                 struct dirent *y = readdir((DIR *)0);
2231                 int z = x - y;
2232                 ],
2233                 [cf_cv_struct_dirent64=yes],
2234                 [cf_cv_struct_dirent64=no])
2235         ])
2236         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
2237     fi
2238 ])
2239 ])
2240 dnl ---------------------------------------------------------------------------
2241 dnl CF_LDFLAGS_STATIC version: 7 updated: 2009/04/04 18:31:04
2242 dnl -----------------
2243 dnl Check for compiler/linker flags used to temporarily force usage of static
2244 dnl libraries.  This depends on the compiler and platform.  Use this to help
2245 dnl ensure that the linker picks up a given library based on its position in
2246 dnl the list of linker options and libraries.
2247 AC_DEFUN([CF_LDFLAGS_STATIC],[
2248
2249 if test "$GCC" = yes ; then
2250         case $cf_cv_system_name in #(
2251         OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*)         #( vi
2252                 LDFLAGS_STATIC=
2253                 LDFLAGS_SHARED=
2254                 ;;
2255     *)  #( normally, except when broken
2256         LDFLAGS_STATIC=-static
2257         LDFLAGS_SHARED=-dynamic
2258         ;;
2259     esac
2260 else
2261         case $cf_cv_system_name in #(
2262         aix[[456]]*)    #( from ld manpage
2263                 LDFLAGS_STATIC=-bstatic
2264                 LDFLAGS_SHARED=-bdynamic
2265                 ;;
2266         hpux*)          #( from ld manpage for hpux10.20, hpux11.11
2267                 # We could also use just "archive" and "shared".
2268                 LDFLAGS_STATIC=-Wl,-a,archive_shared
2269                 LDFLAGS_SHARED=-Wl,-a,shared_archive
2270                 ;;
2271         irix*)          #( from ld manpage IRIX64
2272                 LDFLAGS_STATIC=-Bstatic
2273                 LDFLAGS_SHARED=-Bdynamic
2274                 ;;
2275         osf[[45]]*)     #( from ld manpage osf4.0d, osf5.1
2276                 # alternative "-oldstyle_liblookup" (not in cc manpage)
2277                 LDFLAGS_STATIC=-noso
2278                 LDFLAGS_SHARED=-so_archive
2279                 ;;
2280         solaris2*)
2281                 LDFLAGS_STATIC=-Bstatic
2282                 LDFLAGS_SHARED=-Bdynamic
2283                 ;;
2284         esac
2285 fi
2286
2287 AC_SUBST(LDFLAGS_STATIC)
2288 AC_SUBST(LDFLAGS_SHARED)
2289 ])
2290 dnl ---------------------------------------------------------------------------
2291 dnl CF_LIBRARY_PATH version: 8 updated: 2008/12/07 19:38:31
2292 dnl ---------------
2293 dnl Construct a search-list of directories for a nonstandard library-file
2294 dnl
2295 dnl Parameters
2296 dnl     $1 = the variable to return as result
2297 dnl     $2 = the package name
2298 AC_DEFUN([CF_LIBRARY_PATH],
2299 [
2300 cf_library_path_list=""
2301 if test -n "${LDFLAGS}${LIBS}" ; then
2302         for cf_library_path in $LDFLAGS $LIBS
2303         do
2304                 case $cf_library_path in #(vi
2305                 -L*)
2306                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2307                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2308                         cf_library_path_list="$cf_library_path_list [$]$1"
2309                         ;;
2310                 esac
2311         done
2312 fi
2313
2314 CF_SUBDIR_PATH($1,$2,lib)
2315
2316 $1="$cf_library_path_list [$]$1"
2317 ])dnl
2318 dnl ---------------------------------------------------------------------------
2319 dnl CF_LIB_PREFIX version: 8 updated: 2008/09/13 11:34:16
2320 dnl -------------
2321 dnl Compute the library-prefix for the given host system
2322 dnl $1 = variable to set
2323 AC_DEFUN([CF_LIB_PREFIX],
2324 [
2325         case $cf_cv_system_name in #(vi
2326         OS/2*|os2*) #(vi
2327         LIB_PREFIX=''
2328         ;;
2329         *)      LIB_PREFIX='lib'
2330         ;;
2331         esac
2332 ifelse($1,,,[$1=$LIB_PREFIX])
2333         AC_SUBST(LIB_PREFIX)
2334 ])dnl
2335 dnl ---------------------------------------------------------------------------
2336 dnl CF_LIB_RULES version: 55 updated: 2008/12/13 16:17:38
2337 dnl ------------
2338 dnl Append definitions and rules for the given models to the subdirectory
2339 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
2340 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
2341 dnl the corresponding makefile to list the models that we'll generate.
2342 dnl
2343 dnl For shared libraries, make a list of symbolic links to construct when
2344 dnl generating each library.  The convention used for Linux is the simplest
2345 dnl one:
2346 dnl     lib<name>.so    ->
2347 dnl     lib<name>.so.<major>    ->
2348 dnl     lib<name>.so.<maj>.<minor>
2349 AC_DEFUN([CF_LIB_RULES],
2350 [
2351 CF_LIB_PREFIX(cf_prefix)
2352 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2353
2354 if test $cf_cv_shlib_version = cygdll ; then
2355         TINFO_NAME=$TINFO_ARG_SUFFIX
2356         TINFO_SUFFIX=.dll
2357 fi
2358
2359 for cf_dir in $SRC_SUBDIRS
2360 do
2361         if test ! -d $srcdir/$cf_dir ; then
2362                 continue
2363         elif test -f $srcdir/$cf_dir/modules; then
2364
2365                 SHARED_LIB=
2366                 LIBS_TO_MAKE=
2367                 for cf_item in $cf_LIST_MODELS
2368                 do
2369                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2370                         if test $cf_item = shared ; then
2371                         if test "$cf_cv_do_symlinks" = yes ; then
2372                                 case "$cf_cv_shlib_version" in #(vi
2373                                 rel) #(vi
2374                                         case "$cf_cv_system_name" in #(vi
2375                                         darwin*)
2376                                         case .${LIB_SUFFIX} in
2377                                         .w*)
2378                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2379                                                 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
2380                                                 ;;
2381                                         *)
2382                                                 cf_suffix='.${REL_VERSION}'"$cf_suffix"
2383                                                 ;;
2384                                         esac
2385                                         ;; #(vi
2386                                         *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
2387                                         esac
2388                                         ;;
2389                                 abi)
2390                                         case "$cf_cv_system_name" in #(vi
2391                                         darwin*)
2392                                         case .${LIB_SUFFIX} in
2393                                         .w*)
2394                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2395                                                 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
2396                                                 ;;
2397                                         *)
2398                                                 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
2399                                                 ;;
2400                                         esac
2401                                         ;; #(vi
2402                                         *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
2403                                         esac
2404                                         ;;
2405                                 esac
2406                         fi
2407                         # cygwin needs import library, and has unique naming convention
2408                         # use autodetected ${cf_prefix} for import lib and static lib, but
2409                         # use 'cyg' prefix for shared lib.
2410                         if test $cf_cv_shlib_version = cygdll ; then
2411                                 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
2412                                 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}${cf_cygsuf}"
2413                                 continue
2414                         fi
2415                         fi
2416                         LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
2417                 done
2418
2419                 if test $cf_dir = ncurses ; then
2420                         cf_subsets="$LIB_SUBSETS"
2421                         cf_r_parts="$cf_subsets"
2422                         cf_liblist="$LIBS_TO_MAKE"
2423
2424                         while test -n "$cf_r_parts"
2425                         do
2426                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
2427                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
2428                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
2429                                         cf_item=
2430                                         case $cf_l_parts in #(vi
2431                                         *termlib*) #(vi
2432                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
2433                                                 ;;
2434                                         *ticlib*)
2435                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
2436                                                 ;;
2437                                         *)
2438                                                 break
2439                                                 ;;
2440                                         esac
2441                                         if test -n "$cf_item"; then
2442                                                 LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
2443                                         fi
2444                                 else
2445                                         break
2446                                 fi
2447                         done
2448                 else
2449                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
2450                 fi
2451
2452                 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
2453                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
2454                         $cf_dir/Makefile >$cf_dir/Makefile.out
2455                 mv $cf_dir/Makefile.out $cf_dir/Makefile
2456
2457                 $AWK -f $srcdir/mk-0th.awk \
2458                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
2459                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2460
2461                 for cf_subset in $cf_subsets
2462                 do
2463                         cf_subdirs=
2464                         for cf_item in $cf_LIST_MODELS
2465                         do
2466                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
2467                         CF_UPPER(cf_ITEM,$cf_item)
2468                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2469                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
2470
2471                         # Test for case where we build libtinfo with a different name.
2472                         cf_libname=$cf_dir
2473                         if test $cf_dir = ncurses ; then
2474                                 case $cf_subset in
2475                                 *base*)
2476                                         cf_libname=${cf_libname}$LIB_SUFFIX
2477                                         ;;
2478                                 *termlib*)
2479                                         cf_libname=$TINFO_LIB_SUFFIX
2480                                         ;;
2481                                 ticlib*)
2482                                         cf_libname=$TICS_LIB_SUFFIX
2483                                         ;;
2484                                 esac
2485                         else
2486                                 cf_libname=${cf_libname}$LIB_SUFFIX
2487                         fi
2488                         if test -n "${DFT_ARG_SUFFIX}" ; then
2489                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2490                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2491                         fi
2492
2493                         # These dependencies really are for development, not
2494                         # builds, but they are useful in porting, too.
2495                         cf_depend="../include/ncurses_cfg.h"
2496                         if test "$srcdir" = "."; then
2497                                 cf_reldir="."
2498                         else
2499                                 cf_reldir="\${srcdir}"
2500                         fi
2501
2502                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
2503                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
2504                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
2505                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
2506                         fi
2507
2508                         cf_dir_suffix=
2509                         old_cf_suffix="$cf_suffix"
2510                         if test "$cf_cv_shlib_version_infix" = yes ; then
2511                         if test -n "$LIB_SUFFIX" ; then
2512                                 case $LIB_SUFFIX in
2513                                 w*)
2514                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
2515                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2516                                         cf_dir_suffix=w
2517                                         ;;
2518                                 esac
2519                         fi
2520                         fi
2521
2522                         $AWK -f $srcdir/mk-1st.awk \
2523                                 name=${cf_libname}${cf_dir_suffix} \
2524                                 traces=$LIB_TRACING \
2525                                 MODEL=$cf_ITEM \
2526                                 model=$cf_subdir \
2527                                 prefix=$cf_prefix \
2528                                 suffix=$cf_suffix \
2529                                 subset=$cf_subset \
2530                                 TermlibRoot=$TINFO_NAME \
2531                                 TermlibSuffix=$TINFO_SUFFIX \
2532                                 ShlibVer=$cf_cv_shlib_version \
2533                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
2534                                 ReLink=${cf_cv_do_relink-no} \
2535                                 DoLinks=$cf_cv_do_symlinks \
2536                                 rmSoLocs=$cf_cv_rm_so_locs \
2537                                 ldconfig="$LDCONFIG" \
2538                                 overwrite=$WITH_OVERWRITE \
2539                                 depend="$cf_depend" \
2540                                 host="$host" \
2541                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2542
2543                         cf_suffix="$old_cf_suffix"
2544
2545                         for cf_subdir2 in $cf_subdirs lib
2546                         do
2547                                 test $cf_subdir = $cf_subdir2 && break
2548                         done
2549                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
2550                         $AWK -f $srcdir/mk-2nd.awk \
2551                                 name=$cf_dir \
2552                                 traces=$LIB_TRACING \
2553                                 MODEL=$cf_ITEM \
2554                                 model=$cf_subdir \
2555                                 subset=$cf_subset \
2556                                 srcdir=$srcdir \
2557                                 echo=$WITH_ECHO \
2558                                 crenames=$cf_cv_prog_CC_c_o \
2559                                 cxxrenames=$cf_cv_prog_CXX_c_o \
2560                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2561                         cf_subdirs="$cf_subdirs $cf_subdir"
2562                         done
2563                 done
2564         fi
2565
2566         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
2567 done
2568
2569 for cf_dir in $SRC_SUBDIRS
2570 do
2571         if test ! -d $srcdir/$cf_dir ; then
2572                 continue
2573         fi
2574
2575         if test -f $cf_dir/Makefile ; then
2576                 case "$cf_dir" in
2577                 Ada95) #(vi
2578                         echo 'libs \' >> Makefile
2579                         echo 'install.libs \' >> Makefile
2580                         echo 'uninstall.libs ::' >> Makefile
2581                         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
2582                         ;;
2583                 esac
2584         fi
2585
2586         if test -f $srcdir/$cf_dir/modules; then
2587                 echo >> Makefile
2588                 if test -f $srcdir/$cf_dir/headers; then
2589 cat >> Makefile <<CF_EOF
2590 install.includes \\
2591 uninstall.includes \\
2592 CF_EOF
2593                 fi
2594 if test "$cf_dir" != "c++" ; then
2595 echo 'lint \' >> Makefile
2596 fi
2597 cat >> Makefile <<CF_EOF
2598 libs \\
2599 lintlib \\
2600 install.libs \\
2601 uninstall.libs \\
2602 install.$cf_dir \\
2603 uninstall.$cf_dir ::
2604         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2605 CF_EOF
2606         elif test -f $srcdir/$cf_dir/headers; then
2607 cat >> Makefile <<CF_EOF
2608
2609 libs \\
2610 install.libs \\
2611 uninstall.libs \\
2612 install.includes \\
2613 uninstall.includes ::
2614         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2615 CF_EOF
2616 fi
2617 done
2618
2619 cat >> Makefile <<CF_EOF
2620
2621 install.libs uninstall.libs \\
2622 install.data uninstall.data ::
2623 $MAKE_TERMINFO  cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
2624 CF_EOF
2625
2626 if test "x$cf_with_manpages" = xyes; then
2627 cat >> Makefile <<CF_EOF
2628
2629 install.man \\
2630 uninstall.man ::
2631         cd man && \${MAKE} \${CF_MFLAGS} \[$]@
2632 CF_EOF
2633 fi
2634
2635 cat >> Makefile <<CF_EOF
2636
2637 distclean ::
2638         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
2639         rm -f headers.sh headers.sed mk_shared_lib.sh
2640         rm -f edit_man.* man_alias.*
2641         rm -rf \${DIRS_TO_MAKE}
2642 CF_EOF
2643
2644 # Special case: tack's manpage lives in its own directory.
2645 if test "x$cf_with_manpages" = xyes; then
2646 if test -d tack ; then
2647 if test -f $srcdir/$tack.h; then
2648 cat >> Makefile <<CF_EOF
2649
2650 install.man \\
2651 uninstall.man ::
2652         cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
2653 CF_EOF
2654 fi
2655 fi
2656 fi
2657
2658 dnl If we're installing into a subdirectory of /usr/include, etc., we should
2659 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
2660 dnl anything, and will make it more standardized.  It's awkward to decide this
2661 dnl at configuration because of quoting, so we'll simply make all headers
2662 dnl installed via a script that can do the right thing.
2663
2664 rm -f headers.sed headers.sh
2665
2666 dnl ( generating this script makes the makefiles a little tidier :-)
2667 echo creating headers.sh
2668 cat >headers.sh <<CF_EOF
2669 #! /bin/sh
2670 # This shell script is generated by the 'configure' script.  It is invoked in a
2671 # subdirectory of the build tree.  It generates a sed-script in the parent
2672 # directory that is used to adjust includes for header files that reside in a
2673 # subdirectory of /usr/include, etc.
2674 PRG=""
2675 while test \[$]# != 3
2676 do
2677 PRG="\$PRG \[$]1"; shift
2678 done
2679 DST=\[$]1
2680 REF=\[$]2
2681 SRC=\[$]3
2682 TMPSRC=\${TMPDIR-/tmp}/\`basename \$SRC\`\$\$
2683 TMPSED=\${TMPDIR-/tmp}/headers.sed\$\$
2684 echo installing \$SRC in \$DST
2685 CF_EOF
2686
2687 if test $WITH_CURSES_H = yes; then
2688         cat >>headers.sh <<CF_EOF
2689 case \$DST in
2690 /*/include/*)
2691         END=\`basename \$DST\`
2692         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2693         do
2694                 NAME=\`basename \$i\`
2695                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2696         done
2697         ;;
2698 *)
2699         echo "" >> \$TMPSED
2700         ;;
2701 esac
2702 CF_EOF
2703
2704 else
2705         cat >>headers.sh <<CF_EOF
2706 case \$DST in
2707 /*/include/*)
2708         END=\`basename \$DST\`
2709         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2710         do
2711                 NAME=\`basename \$i\`
2712                 if test "\$NAME" = "curses.h"
2713                 then
2714                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2715                         NAME=ncurses.h
2716                 fi
2717                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2718         done
2719         ;;
2720 *)
2721         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2722         ;;
2723 esac
2724 CF_EOF
2725 fi
2726 cat >>headers.sh <<CF_EOF
2727 rm -f \$TMPSRC
2728 sed -f \$TMPSED \$SRC > \$TMPSRC
2729 NAME=\`basename \$SRC\`
2730 CF_EOF
2731 if test $WITH_CURSES_H != yes; then
2732         cat >>headers.sh <<CF_EOF
2733 test "\$NAME" = "curses.h" && NAME=ncurses.h
2734 CF_EOF
2735 fi
2736 cat >>headers.sh <<CF_EOF
2737 # Just in case someone gzip'd manpages, remove the conflicting copy.
2738 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
2739
2740 eval \$PRG \$TMPSRC \$DST/\$NAME
2741 rm -f \$TMPSRC \$TMPSED
2742 CF_EOF
2743
2744 chmod 0755 headers.sh
2745
2746 for cf_dir in $SRC_SUBDIRS
2747 do
2748         if test ! -d $srcdir/$cf_dir ; then
2749                 continue
2750         fi
2751
2752         if test -f $srcdir/$cf_dir/headers; then
2753                 $AWK -f $srcdir/mk-hdr.awk \
2754                         subset="$LIB_SUBSETS" \
2755                         compat="$WITH_CURSES_H" \
2756                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
2757         fi
2758
2759         if test -f $srcdir/$cf_dir/modules; then
2760                 if test "$cf_dir" != "c++" ; then
2761                         cat >>$cf_dir/Makefile <<"CF_EOF"
2762 depend : ${AUTO_SRC}
2763         makedepend -- ${CPPFLAGS} -- ${C_SRC}
2764
2765 # DO NOT DELETE THIS LINE -- make depend depends on it.
2766 CF_EOF
2767                 fi
2768         fi
2769 done
2770
2771 ])dnl
2772 dnl ---------------------------------------------------------------------------
2773 dnl CF_LIB_SONAME version: 3 updated: 2006/12/16 15:55:46
2774 dnl -------------
2775 dnl Find the and soname for the given shared library.  Set the cache variable
2776 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
2777 dnl variable to "unknown".
2778 dnl
2779 dnl $1 = headers
2780 dnl $2 = code
2781 dnl $3 = library name
2782 AC_DEFUN([CF_LIB_SONAME],
2783 [
2784 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
2785
2786 cf_cv_$3_soname=unknown
2787 if test "$cross_compiling" != yes ; then
2788 cat >conftest.$ac_ext <<CF_EOF
2789 $1
2790 int main()
2791 {
2792 $2
2793         ${cf_cv_main_return:-return}(0);
2794 }
2795 CF_EOF
2796 cf_save_LIBS="$LIBS"
2797         LIBS="-l$3 $LIBS"
2798         if AC_TRY_EVAL(ac_compile) ; then
2799                 if AC_TRY_EVAL(ac_link) ; then
2800                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
2801                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
2802                 fi
2803         fi
2804 rm -f conftest*
2805 LIBS="$cf_save_LIBS"
2806 fi
2807 ])
2808 ])
2809 dnl ---------------------------------------------------------------------------
2810 dnl CF_LIB_SUFFIX version: 16 updated: 2008/12/27 12:30:03
2811 dnl -------------
2812 dnl Compute the library file-suffix from the given model name
2813 dnl $1 = model name
2814 dnl $2 = variable to set (the nominal library suffix)
2815 dnl $3 = dependency variable to set (actual filename)
2816 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2817 AC_DEFUN([CF_LIB_SUFFIX],
2818 [
2819         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2820         case $1 in #(vi
2821         libtool) #(vi
2822                 $2='.la'
2823                 $3=[$]$2
2824                 ;;
2825         normal) #(vi
2826                 $2='.a'
2827                 $3=[$]$2
2828                 ;;
2829         debug) #(vi
2830                 $2='_g.a'
2831                 $3=[$]$2
2832                 ;;
2833         profile) #(vi
2834                 $2='_p.a'
2835                 $3=[$]$2
2836                 ;;
2837         shared) #(vi
2838                 case $cf_cv_system_name in
2839                 aix[[56]]*) #(vi
2840                         $2='.a'
2841                         $3=[$]$2
2842                         ;;
2843                 cygwin*) #(vi
2844                         $2='.dll'
2845                         $3='.dll.a'
2846                         ;;
2847                 darwin*) #(vi
2848                         $2='.dylib'
2849                         $3=[$]$2
2850                         ;;
2851                 hpux*) #(vi
2852                         case $target in
2853                         ia64*) #(vi
2854                                 $2='.so'
2855                                 $3=[$]$2
2856                                 ;;
2857                         *) #(vi
2858                                 $2='.sl'
2859                                 $3=[$]$2
2860                                 ;;
2861                         esac
2862                         ;;
2863                 *)      $2='.so'
2864                         $3=[$]$2
2865                         ;;
2866                 esac
2867         esac
2868         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2869         test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
2870 ])dnl
2871 dnl ---------------------------------------------------------------------------
2872 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
2873 dnl -----------
2874 dnl Compute the string to append to -library from the given model name
2875 dnl $1 = model name
2876 dnl $2 = variable to set
2877 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2878 AC_DEFUN([CF_LIB_TYPE],
2879 [
2880         case $1 in
2881         libtool) $2=''   ;;
2882         normal)  $2=''   ;;
2883         debug)   $2='_g' ;;
2884         profile) $2='_p' ;;
2885         shared)  $2=''   ;;
2886         esac
2887         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2888 ])dnl
2889 dnl ---------------------------------------------------------------------------
2890 dnl CF_LINK_DATAONLY version: 9 updated: 2009/01/01 20:21:38
2891 dnl ----------------
2892 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2893 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
2894 dnl have to provide wrappers for global tables to ensure they're linked
2895 dnl properly.
2896 AC_DEFUN([CF_LINK_DATAONLY],
2897 [
2898 AC_MSG_CHECKING([if data-only library module links])
2899 AC_CACHE_VAL(cf_cv_link_dataonly,[
2900         rm -f conftest.a
2901         cat >conftest.$ac_ext <<EOF
2902 #line __oline__ "configure"
2903 int     testdata[[3]] = { 123, 456, 789 };
2904 EOF
2905         if AC_TRY_EVAL(ac_compile) ; then
2906                 mv conftest.o data.o && \
2907                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2908         fi
2909         rm -f conftest.$ac_ext data.o
2910         cat >conftest.$ac_ext <<EOF
2911 #line __oline__ "configure"
2912 int     testfunc()
2913 {
2914 #if defined(NeXT)
2915         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
2916 #else
2917         extern int testdata[[3]];
2918         return testdata[[0]] == 123
2919            &&  testdata[[1]] == 456
2920            &&  testdata[[2]] == 789;
2921 #endif
2922 }
2923 EOF
2924         if AC_TRY_EVAL(ac_compile); then
2925                 mv conftest.o func.o && \
2926                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2927         fi
2928         rm -f conftest.$ac_ext func.o
2929         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2930         cf_saveLIBS="$LIBS"
2931         LIBS="conftest.a $LIBS"
2932         AC_TRY_RUN([
2933         int main()
2934         {
2935                 extern int testfunc();
2936                 ${cf_cv_main_return:-return} (!testfunc());
2937         }
2938         ],
2939         [cf_cv_link_dataonly=yes],
2940         [cf_cv_link_dataonly=no],
2941         [cf_cv_link_dataonly=unknown])
2942         LIBS="$cf_saveLIBS"
2943         ])
2944 AC_MSG_RESULT($cf_cv_link_dataonly)
2945
2946 if test "$cf_cv_link_dataonly" = no ; then
2947         AC_DEFINE(BROKEN_LINKER)
2948         BROKEN_LINKER=1
2949 fi
2950
2951 ])dnl
2952 dnl ---------------------------------------------------------------------------
2953 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
2954 dnl -------------
2955 dnl Most Unix systems have both link and symlink, a few don't have symlink.
2956 dnl A few non-Unix systems implement symlink, but not link.
2957 dnl A few non-systems implement neither (or have nonfunctional versions).
2958 AC_DEFUN([CF_LINK_FUNCS],
2959 [
2960 AC_CHECK_FUNCS( \
2961         remove \
2962         unlink )
2963
2964 if test "$cross_compiling" = yes ; then
2965         AC_CHECK_FUNCS( \
2966                 link \
2967                 symlink )
2968 else
2969         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
2970                 cf_cv_link_funcs=
2971                 for cf_func in link symlink ; do
2972                         AC_TRY_RUN([
2973 #include <sys/types.h>
2974 #include <sys/stat.h>
2975 #ifdef HAVE_UNISTD_H
2976 #include <unistd.h>
2977 #endif
2978 int main()
2979 {
2980         int fail = 0;
2981         char *src = "config.log";
2982         char *dst = "conftest.chk";
2983         struct stat src_sb;
2984         struct stat dst_sb;
2985
2986         stat(src, &src_sb);
2987         fail = ($cf_func("config.log", "conftest.chk") < 0)
2988             || (stat(dst, &dst_sb) < 0)
2989             || (dst_sb.st_mtime != src_sb.st_mtime);
2990 #ifdef HAVE_UNLINK
2991         unlink(dst);
2992 #else
2993         remove(dst);
2994 #endif
2995         ${cf_cv_main_return:-return} (fail);
2996 }
2997                         ],[
2998                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
2999                         eval 'ac_cv_func_'$cf_func'=yes'],[
3000                         eval 'ac_cv_func_'$cf_func'=no'],[
3001                         eval 'ac_cv_func_'$cf_func'=error'])
3002                 done
3003                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
3004         ])
3005         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
3006         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
3007 fi
3008 ])dnl
3009 dnl ---------------------------------------------------------------------------
3010 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
3011 dnl --------------
3012 dnl Check if a return from main to the shell actually returns the same exit
3013 dnl code.  This is true for almost any POSIX environment.
3014 dnl
3015 dnl Some very old environments did not flush stdout, etc., on an exit.  That
3016 dnl would be a useful case to test for also.
3017 AC_DEFUN([CF_MAIN_RETURN],
3018 [
3019 cf_cv_main_return=return
3020 ])dnl
3021 dnl ---------------------------------------------------------------------------
3022 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
3023 dnl ------------
3024 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
3025 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
3026 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
3027 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
3028 AC_DEFUN([CF_MAKEFLAGS],
3029 [
3030 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
3031         cf_cv_makeflags=''
3032         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
3033         do
3034                 cat >cf_makeflags.tmp <<CF_EOF
3035 SHELL = /bin/sh
3036 all :
3037         @ echo '.$cf_option'
3038 CF_EOF
3039                 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[       ]]*$,,'`
3040                 case "$cf_result" in
3041                 .*k)
3042                         cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
3043                         case "$cf_result" in
3044                         .*CC=*) cf_cv_makeflags=
3045                                 ;;
3046                         *)      cf_cv_makeflags=$cf_option
3047                                 ;;
3048                         esac
3049                         break
3050                         ;;
3051                 .-)     ;;
3052                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
3053                         ;;
3054                 esac
3055         done
3056         rm -f cf_makeflags.tmp
3057 ])
3058
3059 AC_SUBST(cf_cv_makeflags)
3060 ])dnl
3061 dnl ---------------------------------------------------------------------------
3062 dnl CF_MAKE_TAGS version: 2 updated: 2000/10/04 09:18:40
3063 dnl ------------
3064 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
3065 dnl a monocase filesystem.
3066 AC_DEFUN([CF_MAKE_TAGS],[
3067 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
3068 AC_CHECK_PROG(MAKE_LOWER_TAGS, ctags, yes, no)
3069
3070 if test "$cf_cv_mixedcase" = yes ; then
3071         AC_CHECK_PROG(MAKE_UPPER_TAGS, etags, yes, no)
3072 else
3073         MAKE_UPPER_TAGS=no
3074 fi
3075
3076 if test "$MAKE_UPPER_TAGS" = yes ; then
3077         MAKE_UPPER_TAGS=
3078 else
3079         MAKE_UPPER_TAGS="#"
3080 fi
3081 AC_SUBST(MAKE_UPPER_TAGS)
3082
3083 if test "$MAKE_LOWER_TAGS" = yes ; then
3084         MAKE_LOWER_TAGS=
3085 else
3086         MAKE_LOWER_TAGS="#"
3087 fi
3088 AC_SUBST(MAKE_LOWER_TAGS)
3089 ])dnl
3090 dnl ---------------------------------------------------------------------------
3091 dnl CF_MANPAGE_FORMAT version: 8 updated: 2009/01/11 20:30:50
3092 dnl -----------------
3093 dnl Option to allow user to override automatic configuration of manpage format.
3094 dnl There are several special cases:
3095 dnl
3096 dnl     gzip - man checks for, can display gzip'd files
3097 dnl     compress - man checks for, can display compressed files
3098 dnl     BSDI - files in the cat-directories are suffixed ".0"
3099 dnl     formatted - installer should format (put files in cat-directory)
3100 dnl     catonly - installer should only format, e.g., for a turnkey system.
3101 dnl
3102 dnl There are other configurations which this macro does not test, e.g., HPUX's
3103 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
3104 dnl convention would not match our use).
3105 AC_DEFUN([CF_MANPAGE_FORMAT],
3106 [
3107 AC_REQUIRE([CF_PATHSEP])
3108 AC_MSG_CHECKING(format of man-pages)
3109
3110 AC_ARG_WITH(manpage-format,
3111         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
3112                           optionally formatted/catonly, e.g., gzip,formatted],
3113         [MANPAGE_FORMAT=$withval],
3114         [MANPAGE_FORMAT=unknown])
3115
3116 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
3117 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
3118
3119 cf_unknown=
3120
3121 case $MANPAGE_FORMAT in
3122 unknown)
3123   if test -z "$MANPATH" ; then
3124     MANPATH="/usr/man:/usr/share/man"
3125   fi
3126
3127   # look for the 'date' man-page (it's most likely to be installed!)
3128   MANPAGE_FORMAT=
3129   cf_preform=no
3130   cf_catonly=yes
3131   cf_example=date
3132
3133   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
3134   for cf_dir in $MANPATH; do
3135     test -z "$cf_dir" && cf_dir=/usr/man
3136     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
3137     do
3138       cf_test=`echo $cf_name | sed -e 's/*//'`
3139       if test "x$cf_test" = "x$cf_name" ; then
3140
3141         case "$cf_name" in
3142         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
3143         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
3144         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
3145         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
3146         esac
3147
3148         case "$cf_name" in
3149         $cf_dir/man*)
3150           cf_catonly=no
3151           ;;
3152         $cf_dir/cat*)
3153           cf_preform=yes
3154           ;;
3155         esac
3156         break
3157       fi
3158
3159       # if we found a match in either man* or cat*, stop looking
3160       if test -n "$MANPAGE_FORMAT" ; then
3161         cf_found=no
3162         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
3163         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
3164         case "$cf_name" in
3165         $cf_dir/cat*)
3166           cf_found=yes
3167           ;;
3168         esac
3169         test $cf_found=yes && break
3170       fi
3171     done
3172     # only check the first directory in $MANPATH where we find manpages
3173     if test -n "$MANPAGE_FORMAT" ; then
3174        break
3175     fi
3176   done
3177   # if we did not find the example, just assume it is normal
3178   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
3179   IFS="$ac_save_ifs"
3180   ;;
3181 *)
3182   for cf_option in $MANPAGE_FORMAT; do
3183      case $cf_option in #(vi
3184      gzip|compress|BSDI|normal|formatted|catonly)
3185        ;;
3186      *)
3187        cf_unknown="$cf_unknown $cf_option"
3188        ;;
3189      esac
3190   done
3191   ;;
3192 esac
3193
3194 AC_MSG_RESULT($MANPAGE_FORMAT)
3195 if test -n "$cf_unknown" ; then
3196   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
3197 fi
3198 ])dnl
3199 dnl ---------------------------------------------------------------------------
3200 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
3201 dnl ------------------
3202 dnl The Debian people have their own naming convention for manpages.  This
3203 dnl option lets us override the name of the file containing renaming, or
3204 dnl disable it altogether.
3205 AC_DEFUN([CF_MANPAGE_RENAMES],
3206 [
3207 AC_MSG_CHECKING(for manpage renaming)
3208
3209 AC_ARG_WITH(manpage-renames,
3210         [  --with-manpage-renames  specify manpage-renaming],
3211         [MANPAGE_RENAMES=$withval],
3212         [MANPAGE_RENAMES=yes])
3213
3214 case ".$MANPAGE_RENAMES" in #(vi
3215 .no) #(vi
3216   ;;
3217 .|.yes)
3218   # Debian 'man' program?
3219   if test -f /etc/debian_version ; then
3220     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
3221   else
3222     MANPAGE_RENAMES=no
3223   fi
3224   ;;
3225 esac
3226
3227 if test "$MANPAGE_RENAMES" != no ; then
3228   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
3229     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
3230   elif test ! -f $MANPAGE_RENAMES ; then
3231     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
3232   fi
3233
3234   test ! -d man && mkdir man
3235
3236   # Construct a sed-script to perform renaming within man-pages
3237   if test -n "$MANPAGE_RENAMES" ; then
3238     test ! -d man && mkdir man
3239     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
3240   fi
3241 fi
3242
3243 AC_MSG_RESULT($MANPAGE_RENAMES)
3244 AC_SUBST(MANPAGE_RENAMES)
3245 ])dnl
3246 dnl ---------------------------------------------------------------------------
3247 dnl CF_MANPAGE_SYMLINKS version: 4 updated: 2003/12/13 18:01:58
3248 dnl -------------------
3249 dnl Some people expect each tool to make all aliases for manpages in the
3250 dnl man-directory.  This accommodates the older, less-capable implementations
3251 dnl of 'man', and is optional.
3252 AC_DEFUN([CF_MANPAGE_SYMLINKS],
3253 [
3254 AC_MSG_CHECKING(if manpage aliases will be installed)
3255
3256 AC_ARG_WITH(manpage-aliases,
3257         [  --with-manpage-aliases  specify manpage-aliases using .so],
3258         [MANPAGE_ALIASES=$withval],
3259         [MANPAGE_ALIASES=yes])
3260
3261 AC_MSG_RESULT($MANPAGE_ALIASES)
3262
3263 if test "$LN_S" = "ln -s"; then
3264         cf_use_symlinks=yes
3265 else
3266         cf_use_symlinks=no
3267 fi
3268
3269 MANPAGE_SYMLINKS=no
3270 if test "$MANPAGE_ALIASES" = yes ; then
3271 AC_MSG_CHECKING(if manpage symlinks should be used)
3272
3273 AC_ARG_WITH(manpage-symlinks,
3274         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
3275         [MANPAGE_SYMLINKS=$withval],
3276         [MANPAGE_SYMLINKS=$cf_use_symlinks])
3277
3278 if test "$$cf_use_symlinks" = no; then
3279 if test "$MANPAGE_SYMLINKS" = yes ; then
3280         AC_MSG_WARN(cannot make symlinks, will use .so files)
3281         MANPAGE_SYMLINKS=no
3282 fi
3283 fi
3284
3285 AC_MSG_RESULT($MANPAGE_SYMLINKS)
3286 fi
3287
3288 ])dnl
3289 dnl ---------------------------------------------------------------------------
3290 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
3291 dnl --------------
3292 dnl This option causes manpages to be run through tbl(1) to generate tables
3293 dnl correctly.
3294 AC_DEFUN([CF_MANPAGE_TBL],
3295 [
3296 AC_MSG_CHECKING(for manpage tbl)
3297
3298 AC_ARG_WITH(manpage-tbl,
3299         [  --with-manpage-tbl      specify manpage processing with tbl],
3300         [MANPAGE_TBL=$withval],
3301         [MANPAGE_TBL=no])
3302
3303 AC_MSG_RESULT($MANPAGE_TBL)
3304 ])dnl
3305 dnl ---------------------------------------------------------------------------
3306 dnl CF_MAN_PAGES version: 35 updated: 2007/03/31 11:47:29
3307 dnl ------------
3308 dnl Try to determine if the man-pages on the system are compressed, and if
3309 dnl so, what format is used.  Use this information to construct a script that
3310 dnl will install man-pages.
3311 AC_DEFUN([CF_MAN_PAGES],
3312 [
3313 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
3314 CF_MANPAGE_FORMAT
3315 CF_MANPAGE_RENAMES
3316 CF_MANPAGE_SYMLINKS
3317 CF_MANPAGE_TBL
3318
3319   if test "$prefix" = "NONE" ; then
3320      cf_prefix="$ac_default_prefix"
3321   else
3322      cf_prefix="$prefix"
3323   fi
3324
3325   case "$MANPAGE_FORMAT" in # (vi
3326   *catonly*) # (vi
3327     cf_format=yes
3328     cf_inboth=no
3329     ;;
3330   *formatted*) # (vi
3331     cf_format=yes
3332     cf_inboth=yes
3333     ;;
3334   *)
3335     cf_format=no
3336     cf_inboth=no
3337     ;;
3338   esac
3339
3340 test ! -d man && mkdir man
3341
3342 cf_so_strip=
3343 cf_compress=
3344 case "$MANPAGE_FORMAT" in #(vi
3345 *compress*) #(vi
3346         cf_so_strip="Z"
3347         cf_compress=compress
3348   ;;
3349 *gzip*) #(vi
3350         cf_so_strip="gz"
3351         cf_compress=gzip
3352   ;;
3353 esac
3354
3355 cf_edit_man=./edit_man.sh
3356 cf_man_alias=`pwd`/man_alias.sed
3357
3358 cat >$cf_edit_man <<CF_EOF
3359 #! /bin/sh
3360 # this script is generated by the configure-script CF_MAN_PAGES macro.
3361
3362 prefix="$cf_prefix"
3363 datadir="$datadir"
3364
3365 NCURSES_MAJOR="$NCURSES_MAJOR"
3366 NCURSES_MINOR="$NCURSES_MINOR"
3367 NCURSES_PATCH="$NCURSES_PATCH"
3368
3369 NCURSES_OSPEED="$NCURSES_OSPEED"
3370 TERMINFO="$TERMINFO"
3371
3372 MKDIRS="sh `cd $srcdir && pwd`/mkdirs.sh"
3373
3374 INSTALL="$INSTALL"
3375 INSTALL_DATA="$INSTALL_DATA"
3376
3377 transform="$program_transform_name"
3378
3379 TMP=\${TMPDIR-/tmp}/man\$\$
3380 trap "rm -f \$TMP" 0 1 2 5 15
3381
3382 form=\[$]1
3383 shift || exit 1
3384
3385 verb=\[$]1
3386 shift || exit 1
3387
3388 mandir=\[$]1
3389 shift || exit 1
3390
3391 srcdir=\[$]1
3392 top_srcdir=\[$]srcdir/..
3393 shift || exit 1
3394
3395 if test "\$form" = normal ; then
3396         if test "$cf_format" = yes ; then
3397         if test "$cf_inboth" = no ; then
3398                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3399                 exit $?
3400         fi
3401         fi
3402         cf_subdir=\$mandir/man
3403         cf_tables=$MANPAGE_TBL
3404 else
3405         cf_subdir=\$mandir/cat
3406         cf_tables=yes
3407 fi
3408
3409 # process the list of source-files
3410 for i in \[$]* ; do
3411 case \$i in #(vi
3412 *.orig|*.rej) ;; #(vi
3413 *.[[0-9]]*)
3414         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
3415         if test \$verb = installing ; then
3416         if test ! -d \$cf_subdir\${section} ; then
3417                 \$MKDIRS \$cf_subdir\$section
3418         fi
3419         fi
3420
3421         # replace variables in man page
3422         if test ! -f $cf_man_alias ; then
3423 cat >>$cf_man_alias <<-CF_EOF2
3424                 s,@DATADIR@,\$datadir,g
3425                 s,@TERMINFO@,\$TERMINFO,g
3426                 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
3427                 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
3428                 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
3429                 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
3430 CF_EOF
3431         ifelse($1,,,[
3432         for cf_name in $1
3433         do
3434                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3435                 cf_name=`echo $cf_name|sed "$program_transform_name"`
3436 cat >>$cf_edit_man <<-CF_EOF
3437                 s,@$cf_NAME@,$cf_name,
3438 CF_EOF
3439         done
3440         ])
3441 cat >>$cf_edit_man <<CF_EOF
3442 CF_EOF2
3443                 echo "...made $cf_man_alias"
3444         fi
3445
3446         aliases=
3447         cf_source=\`basename \$i\`
3448         inalias=\$cf_source
3449         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
3450         if test ! -f \$inalias ; then
3451                 echo .. skipped \$cf_source
3452                 continue
3453         fi
3454 CF_EOF
3455
3456 if test "$MANPAGE_ALIASES" != no ; then
3457 cat >>$cf_edit_man <<CF_EOF
3458         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
3459 CF_EOF
3460 fi
3461
3462 if test "$MANPAGE_RENAMES" = no ; then
3463 cat >>$cf_edit_man <<CF_EOF
3464         # perform program transformations for section 1 man pages
3465         if test \$section = 1 ; then
3466                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
3467         else
3468                 cf_target=\$cf_subdir\${section}/\$cf_source
3469         fi
3470 CF_EOF
3471 else
3472 cat >>$cf_edit_man <<CF_EOF
3473         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
3474         if test -z "\$cf_target" ; then
3475                 echo '? missing rename for '\$cf_source
3476                 cf_target="\$cf_source"
3477         fi
3478         cf_target="\$cf_subdir\${section}/\${cf_target}"
3479
3480 CF_EOF
3481 fi
3482
3483 cat >>$cf_edit_man <<CF_EOF
3484         sed     -f $cf_man_alias \\
3485 CF_EOF
3486
3487 if test -f $MANPAGE_RENAMES ; then
3488 cat >>$cf_edit_man <<CF_EOF
3489                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
3490 CF_EOF
3491 else
3492 cat >>$cf_edit_man <<CF_EOF
3493                 < \$i >\$TMP
3494 CF_EOF
3495 fi
3496
3497 cat >>$cf_edit_man <<CF_EOF
3498 if test \$cf_tables = yes ; then
3499         tbl \$TMP >\$TMP.out
3500         mv \$TMP.out \$TMP
3501 fi
3502 CF_EOF
3503
3504 if test $with_curses_h != yes ; then
3505 cat >>$cf_edit_man <<CF_EOF
3506         sed -e "/\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
3507         mv \$TMP.out \$TMP
3508 CF_EOF
3509 fi
3510
3511 cat >>$cf_edit_man <<CF_EOF
3512         if test \$form = format ; then
3513                 nroff -man \$TMP >\$TMP.out
3514                 mv \$TMP.out \$TMP
3515         fi
3516 CF_EOF
3517
3518 if test -n "$cf_compress" ; then
3519 cat >>$cf_edit_man <<CF_EOF
3520         if test \$verb = installing ; then
3521         if ( $cf_compress -f \$TMP )
3522         then
3523                 mv \$TMP.$cf_so_strip \$TMP
3524         fi
3525         fi
3526         cf_target="\$cf_target.$cf_so_strip"
3527 CF_EOF
3528 fi
3529
3530 case "$MANPAGE_FORMAT" in #(vi
3531 *BSDI*)
3532 cat >>$cf_edit_man <<CF_EOF
3533         if test \$form = format ; then
3534                 # BSDI installs only .0 suffixes in the cat directories
3535                 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
3536         fi
3537 CF_EOF
3538   ;;
3539 esac
3540
3541 cat >>$cf_edit_man <<CF_EOF
3542         suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
3543         if test \$verb = installing ; then
3544                 echo \$verb \$cf_target
3545                 \$INSTALL_DATA \$TMP \$cf_target
3546                 test -d \$cf_subdir\${section} &&
3547                 test -n "\$aliases" && (
3548                         cd \$cf_subdir\${section} && (
3549                                 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
3550                                 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
3551                                 cf_target=\`basename \$cf_target\`
3552                                 for cf_alias in \$aliases
3553                                 do
3554                                         if test \$section = 1 ; then
3555                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3556                                         fi
3557
3558                                         if test "$MANPAGE_SYMLINKS" = yes ; then
3559                                                 if test -f \$cf_alias\${suffix} ; then
3560                                                         if ( cmp -s \$cf_target \$cf_alias\${suffix} )
3561                                                         then
3562                                                                 continue
3563                                                         fi
3564                                                 fi
3565                                                 echo .. \$verb alias \$cf_alias\${suffix}
3566                                                 rm -f \$cf_alias\${suffix}
3567                                                 $LN_S \$cf_target \$cf_alias\${suffix}
3568                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
3569                                                 echo ".so \$cf_source" >\$TMP
3570 CF_EOF
3571 if test -n "$cf_compress" ; then
3572 cat >>$cf_edit_man <<CF_EOF
3573                                                 if test -n "$cf_so_strip" ; then
3574                                                         $cf_compress -f \$TMP
3575                                                         mv \$TMP.$cf_so_strip \$TMP
3576                                                 fi
3577 CF_EOF
3578 fi
3579 cat >>$cf_edit_man <<CF_EOF
3580                                                 echo .. \$verb alias \$cf_alias\${suffix}
3581                                                 rm -f \$cf_alias\${suffix}
3582                                                 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
3583                                         fi
3584                                 done
3585                         )
3586                 )
3587         elif test \$verb = removing ; then
3588                 test -f \$cf_target && (
3589                         echo \$verb \$cf_target
3590                         rm -f \$cf_target
3591                 )
3592                 test -d \$cf_subdir\${section} &&
3593                 test -n "\$aliases" && (
3594                         cd \$cf_subdir\${section} && (
3595                                 for cf_alias in \$aliases
3596                                 do
3597                                         if test \$section = 1 ; then
3598                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3599                                         fi
3600
3601                                         echo .. \$verb alias \$cf_alias\${suffix}
3602                                         rm -f \$cf_alias\${suffix}
3603                                 done
3604                         )
3605                 )
3606         else
3607 #               echo ".hy 0"
3608                 cat \$TMP
3609         fi
3610         ;;
3611 esac
3612 done
3613
3614 if test $cf_inboth = yes ; then
3615 if test \$form != format ; then
3616         sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3617 fi
3618 fi
3619
3620 exit 0
3621 CF_EOF
3622 chmod 755 $cf_edit_man
3623
3624 ])dnl
3625 dnl ---------------------------------------------------------------------------
3626 dnl CF_MATH_LIB version: 6 updated: 2009/12/19 13:46:49
3627 dnl -----------
3628 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
3629 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
3630 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
3631 AC_DEFUN([CF_MATH_LIB],
3632 [
3633 AC_CACHE_CHECK(if -lm needed for math functions,
3634         cf_cv_need_libm,[
3635         AC_TRY_LINK([
3636         #include <stdio.h>
3637         #include <math.h>
3638         ],
3639         [double x = rand(); printf("result = %g\n", ]ifelse($2,,sin(x),$2)[)],
3640         [cf_cv_need_libm=no],
3641         [cf_cv_need_libm=yes])])
3642 if test "$cf_cv_need_libm" = yes
3643 then
3644 ifelse($1,,[
3645         LIBS="-lm $LIBS"
3646 ],[$1=-lm])
3647 fi
3648 ])
3649 dnl ---------------------------------------------------------------------------
3650 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
3651 dnl ----------------------
3652 dnl Check if the file-system supports mixed-case filenames.  If we're able to
3653 dnl create a lowercase name and see it as uppercase, it doesn't support that.
3654 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
3655 [
3656 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
3657 if test "$cross_compiling" = yes ; then
3658         case $target_alias in #(vi
3659         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
3660                 cf_cv_mixedcase=no
3661                 ;;
3662         *)
3663                 cf_cv_mixedcase=yes
3664                 ;;
3665         esac
3666 else
3667         rm -f conftest CONFTEST
3668         echo test >conftest
3669         if test -f CONFTEST ; then
3670                 cf_cv_mixedcase=no
3671         else
3672                 cf_cv_mixedcase=yes
3673         fi
3674         rm -f conftest CONFTEST
3675 fi
3676 ])
3677 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
3678 ])dnl
3679 dnl ---------------------------------------------------------------------------
3680 dnl CF_MKSTEMP version: 5 updated: 2006/12/16 12:33:30
3681 dnl ----------
3682 dnl Check for a working mkstemp.  This creates two files, checks that they are
3683 dnl successfully created and distinct (AmigaOS apparently fails on the last).
3684 AC_DEFUN([CF_MKSTEMP],[
3685 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
3686 rm -f conftest*
3687 AC_TRY_RUN([
3688 #include <sys/types.h>
3689 #include <stdlib.h>
3690 #include <stdio.h>
3691 #include <string.h>
3692 #include <sys/stat.h>
3693 int main()
3694 {
3695         char *tmpl = "conftestXXXXXX";
3696         char name[2][80];
3697         int n;
3698         int result = 0;
3699         int fd;
3700         struct stat sb;
3701
3702         umask(077);
3703         for (n = 0; n < 2; ++n) {
3704                 strcpy(name[n], tmpl);
3705                 if ((fd = mkstemp(name[n])) >= 0) {
3706                         if (!strcmp(name[n], tmpl)
3707                          || stat(name[n], &sb) != 0
3708                          || (sb.st_mode & S_IFMT) != S_IFREG
3709                          || (sb.st_mode & 077) != 0) {
3710                                 result = 1;
3711                         }
3712                         close(fd);
3713                 }
3714         }
3715         if (result == 0
3716          && !strcmp(name[0], name[1]))
3717                 result = 1;
3718         ${cf_cv_main_return:-return}(result);
3719 }
3720 ],[cf_cv_func_mkstemp=yes
3721 ],[cf_cv_func_mkstemp=no
3722 ],[AC_CHECK_FUNC(mkstemp)
3723 ])
3724 ])
3725 if test "$cf_cv_func_mkstemp" = yes ; then
3726         AC_DEFINE(HAVE_MKSTEMP)
3727 fi
3728 ])dnl
3729 dnl ---------------------------------------------------------------------------
3730 dnl CF_MSG_LOG version: 4 updated: 2007/07/29 09:55:12
3731 dnl ----------
3732 dnl Write a debug message to config.log, along with the line number in the
3733 dnl configure script.
3734 AC_DEFUN([CF_MSG_LOG],[
3735 echo "${as_me-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
3736 ])dnl
3737 dnl ---------------------------------------------------------------------------
3738 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
3739 dnl ----------------
3740 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
3741 dnl warn about this.
3742 AC_DEFUN([CF_NCURSES_ABI_6],[
3743 if test "${with_abi_version+set}" != set; then
3744         case $cf_cv_rel_version in
3745         5.*)
3746                 cf_cv_rel_version=6.0
3747                 cf_cv_abi_version=6
3748                 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
3749                 ;;
3750         esac
3751 fi
3752 ])dnl
3753 dnl ---------------------------------------------------------------------------
3754 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
3755 dnl ------------------
3756 dnl see CF_WITH_NO_LEAKS
3757 AC_DEFUN([CF_NO_LEAKS_OPTION],[
3758 AC_MSG_CHECKING(if you want to use $1 for testing)
3759 AC_ARG_WITH($1,
3760         [$2],
3761         [AC_DEFINE($3)ifelse([$4],,[
3762          $4
3763 ])
3764         : ${with_cflags:=-g}
3765         : ${with_no_leaks:=yes}
3766          with_$1=yes],
3767         [with_$1=])
3768 AC_MSG_RESULT(${with_$1:-no})
3769
3770 case .$with_cflags in #(vi
3771 .*-g*)
3772         case .$CFLAGS in #(vi
3773         .*-g*) #(vi
3774                 ;;
3775         *)
3776                 CF_ADD_CFLAGS([-g])
3777                 ;;
3778         esac
3779         ;;
3780 esac
3781 ])dnl
3782 dnl ---------------------------------------------------------------------------
3783 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
3784 dnl ----------------
3785 dnl Check if the given variable is a number.  If not, report an error.
3786 dnl $1 is the variable
3787 dnl $2 is the message
3788 AC_DEFUN([CF_NUMBER_SYNTAX],[
3789 if test -n "$1" ; then
3790   case $1 in #(vi
3791   [[0-9]]*) #(vi
3792         ;;
3793   *)
3794         AC_MSG_ERROR($2 is not a number: $1)
3795         ;;
3796   esac
3797 else
3798   AC_MSG_ERROR($2 value is empty)
3799 fi
3800 ])dnl
3801 dnl ---------------------------------------------------------------------------
3802 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
3803 dnl -------------
3804 dnl Compute the object-directory name from the given model name
3805 AC_DEFUN([CF_OBJ_SUBDIR],
3806 [
3807         case $1 in
3808         libtool) $2='obj_lo'  ;;
3809         normal)  $2='objects' ;;
3810         debug)   $2='obj_g' ;;
3811         profile) $2='obj_p' ;;
3812         shared)
3813                 case $cf_cv_system_name in #(vi
3814                 cygwin) #(vi
3815                         $2='objects' ;;
3816                 *)
3817                         $2='obj_s' ;;
3818                 esac
3819         esac
3820 ])dnl
3821 dnl ---------------------------------------------------------------------------
3822 dnl CF_PATHSEP version: 4 updated: 2009/01/11 20:30:23
3823 dnl ----------
3824 dnl Provide a value for the $PATH and similar separator
3825 AC_DEFUN([CF_PATHSEP],
3826 [
3827         case $cf_cv_system_name in
3828         os2*)   PATH_SEPARATOR=';'  ;;
3829         *)      PATH_SEPARATOR=':'  ;;
3830         esac
3831 ifelse($1,,,[$1=$PATH_SEPARATOR])
3832         AC_SUBST(PATH_SEPARATOR)
3833 ])dnl
3834 dnl ---------------------------------------------------------------------------
3835 dnl CF_PATH_SYNTAX version: 12 updated: 2008/03/23 14:45:59
3836 dnl --------------
3837 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
3838 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3839 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
3840 dnl delayed evaluation of those symbols.
3841 AC_DEFUN([CF_PATH_SYNTAX],[
3842 if test "x$prefix" != xNONE; then
3843   cf_path_syntax="$prefix"
3844 else
3845   cf_path_syntax="$ac_default_prefix"
3846 fi
3847
3848 case ".[$]$1" in #(vi
3849 .\[$]\(*\)*|.\'*\'*) #(vi
3850   ;;
3851 ..|./*|.\\*) #(vi
3852   ;;
3853 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
3854   ;;
3855 .\[$]{*prefix}*) #(vi
3856   eval $1="[$]$1"
3857   case ".[$]$1" in #(vi
3858   .NONE/*)
3859     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3860     ;;
3861   esac
3862   ;; #(vi
3863 .no|.NONE/*)
3864   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3865   ;;
3866 *)
3867   ifelse($2,,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3868   ;;
3869 esac
3870 ])dnl
3871 dnl ---------------------------------------------------------------------------
3872 dnl CF_PKG_CONFIG version: 3 updated: 2009/01/25 10:55:09
3873 dnl -------------
3874 dnl Check for the package-config program, unless disabled by command-line.
3875 AC_DEFUN([CF_PKG_CONFIG],
3876 [
3877 AC_MSG_CHECKING(if you want to use pkg-config)
3878 AC_ARG_WITH(pkg-config,
3879         [  --with-pkg-config{=path} enable/disable use of pkg-config],
3880         [cf_pkg_config=$withval],
3881         [cf_pkg_config=yes])
3882 AC_MSG_RESULT($cf_pkg_config)
3883
3884 case $cf_pkg_config in #(vi
3885 no) #(vi
3886         PKG_CONFIG=none
3887         ;;
3888 yes) #(vi
3889         AC_PATH_PROG(PKG_CONFIG, pkg-config, none)
3890         ;;
3891 *)
3892         PKG_CONFIG=$withval
3893         ;;
3894 esac
3895
3896 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3897 if test "$PKG_CONFIG" != none ; then
3898         CF_PATH_SYNTAX(PKG_CONFIG)
3899 fi
3900
3901 AC_SUBST(PKG_CONFIG)
3902 ])dnl
3903 dnl ---------------------------------------------------------------------------
3904 dnl CF_POSIX_C_SOURCE version: 7 updated: 2010/01/09 11:05:50
3905 dnl -----------------
3906 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3907 dnl
3908 dnl     POSIX.1-1990                            _POSIX_SOURCE
3909 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
3910 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
3911 dnl             Bindings Option
3912 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
3913 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
3914 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
3915 dnl
3916 dnl Parameters:
3917 dnl     $1 is the nominal value for _POSIX_C_SOURCE
3918 AC_DEFUN([CF_POSIX_C_SOURCE],
3919 [
3920 cf_POSIX_C_SOURCE=ifelse($1,,199506L,$1)
3921
3922 cf_save_CFLAGS="$CFLAGS"
3923 cf_save_CPPFLAGS="$CPPFLAGS"
3924
3925 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3926 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3927
3928 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3929         CF_MSG_LOG(if the symbol is already defined go no further)
3930         AC_TRY_COMPILE([#include <sys/types.h>],[
3931 #ifndef _POSIX_C_SOURCE
3932 make an error
3933 #endif],
3934         [cf_cv_posix_c_source=no],
3935         [cf_want_posix_source=no
3936          case .$cf_POSIX_C_SOURCE in #(vi
3937          .[[12]]??*) #(vi
3938                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3939                 ;;
3940          .2) #(vi
3941                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3942                 cf_want_posix_source=yes
3943                 ;;
3944          .*)
3945                 cf_want_posix_source=yes
3946                 ;;
3947          esac
3948          if test "$cf_want_posix_source" = yes ; then
3949                 AC_TRY_COMPILE([#include <sys/types.h>],[
3950 #ifdef _POSIX_SOURCE
3951 make an error
3952 #endif],[],
3953                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3954          fi
3955          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3956          CFLAGS="$cf_trim_CFLAGS"
3957          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
3958          CF_MSG_LOG(if the second compile does not leave our definition intact error)
3959          AC_TRY_COMPILE([#include <sys/types.h>],[
3960 #ifndef _POSIX_C_SOURCE
3961 make an error
3962 #endif],,
3963          [cf_cv_posix_c_source=no])
3964          CFLAGS="$cf_save_CFLAGS"
3965          CPPFLAGS="$cf_save_CPPFLAGS"
3966         ])
3967 ])
3968
3969 if test "$cf_cv_posix_c_source" != no ; then
3970         CFLAGS="$cf_trim_CFLAGS"
3971         CPPFLAGS="$cf_trim_CPPFLAGS"
3972         CF_ADD_CFLAGS($cf_cv_posix_c_source)
3973 fi
3974
3975 ])dnl
3976 dnl ---------------------------------------------------------------------------
3977 dnl CF_PREDEFINE version: 1 updated: 2003/07/26 17:53:56
3978 dnl ------------
3979 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
3980 dnl
3981 dnl $1 = symbol to test
3982 dnl $2 = value (if any) to use for a predefinition
3983 AC_DEFUN([CF_PREDEFINE],
3984 [
3985 AC_MSG_CHECKING(if we must define $1)
3986 AC_TRY_COMPILE([#include <sys/types.h>
3987 ],[
3988 #ifndef $1
3989 make an error
3990 #endif],[cf_result=no],[cf_result=yes])
3991 AC_MSG_RESULT($cf_result)
3992
3993 if test "$cf_result" = yes ; then
3994         CPPFLAGS="$CPPFLAGS ifelse($2,,-D$1,[-D$1=$2])"
3995 elif test "x$2" != "x" ; then
3996         AC_MSG_CHECKING(checking for compatible value versus $2)
3997         AC_TRY_COMPILE([#include <sys/types.h>
3998 ],[
3999 #if $1-$2 < 0
4000 make an error
4001 #endif],[cf_result=yes],[cf_result=no])
4002         AC_MSG_RESULT($cf_result)
4003         if test "$cf_result" = no ; then
4004                 # perhaps we can override it - try...
4005                 CPPFLAGS="$CPPFLAGS -D$1=$2"
4006         fi
4007 fi
4008 ])dnl
4009 dnl ---------------------------------------------------------------------------
4010 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
4011 dnl ------------
4012 dnl Append definitions and rules for the given programs to the subdirectory
4013 dnl Makefiles, and the recursion rule for the top-level Makefile.
4014 dnl
4015 dnl parameters
4016 dnl     $1 = script to run
4017 dnl     $2 = list of subdirectories
4018 dnl
4019 dnl variables
4020 dnl     $AWK
4021 AC_DEFUN([CF_PRG_RULES],
4022 [
4023 for cf_dir in $2
4024 do
4025         if test ! -d $srcdir/$cf_dir; then
4026                 continue
4027         elif test -f $srcdir/$cf_dir/programs; then
4028                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
4029         fi
4030 done
4031
4032 ])dnl
4033 dnl ---------------------------------------------------------------------------
4034 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
4035 dnl ----------
4036 dnl Check for archiver "ar".
4037 AC_DEFUN([CF_PROG_AR],[
4038 AC_CHECK_TOOL(AR, ar, ar)
4039 ])
4040 dnl ---------------------------------------------------------------------------
4041 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
4042 dnl -----------
4043 dnl Check for awk, ensure that the check found something.
4044 AC_DEFUN([CF_PROG_AWK],
4045 [
4046 AC_PROG_AWK
4047 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
4048 ])dnl
4049 dnl ---------------------------------------------------------------------------
4050 dnl CF_PROG_CC_C_O version: 2 updated: 2006/12/16 15:55:46
4051 dnl --------------
4052 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
4053 dnl the output file can be renamed, and allows for a shell variable that can
4054 dnl be used later.  The parameter is either CC or CXX.  The result is the
4055 dnl cache variable:
4056 dnl     $cf_cv_prog_CC_c_o
4057 dnl     $cf_cv_prog_CXX_c_o
4058 AC_DEFUN([CF_PROG_CC_C_O],
4059 [AC_REQUIRE([AC_PROG_CC])dnl
4060 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
4061 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
4062 [
4063 cat > conftest.$ac_ext <<CF_EOF
4064 #include <stdio.h>
4065 int main()
4066 {
4067         ${cf_cv_main_return:-return}(0);
4068 }
4069 CF_EOF
4070 # We do the test twice because some compilers refuse to overwrite an
4071 # existing .o file with -o, though they will create one.
4072 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
4073 if AC_TRY_EVAL(ac_try) &&
4074   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
4075 then
4076   eval cf_cv_prog_$1_c_o=yes
4077 else
4078   eval cf_cv_prog_$1_c_o=no
4079 fi
4080 rm -f conftest*
4081 ])dnl
4082 if test $cf_cv_prog_$1_c_o = yes; then
4083   AC_MSG_RESULT([yes])
4084 else
4085   AC_MSG_RESULT([no])
4086 fi
4087 ])dnl
4088 dnl ---------------------------------------------------------------------------
4089 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
4090 dnl --------------
4091 dnl Check if C (preprocessor) -U and -D options are processed in the order
4092 dnl given rather than by type of option.  Some compilers insist on apply all
4093 dnl of the -U options after all of the -D options.  Others allow mixing them,
4094 dnl and may predefine symbols that conflict with those we define.
4095 AC_DEFUN([CF_PROG_CC_U_D],
4096 [
4097 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
4098         cf_save_CPPFLAGS="$CPPFLAGS"
4099         CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
4100         AC_TRY_COMPILE([],[
4101 #ifndef U_D_OPTIONS
4102 make an undefined-error
4103 #endif
4104 #ifdef  D_U_OPTIONS
4105 make a defined-error
4106 #endif
4107         ],[
4108         cf_cv_cc_u_d_options=yes],[
4109         cf_cv_cc_u_d_options=no])
4110         CPPFLAGS="$cf_save_CPPFLAGS"
4111 ])
4112 ])dnl
4113 dnl ---------------------------------------------------------------------------
4114 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
4115 dnl -------------
4116 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
4117 dnl This macro adds a check to ensure the script found something.
4118 AC_DEFUN([CF_PROG_EGREP],
4119 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
4120    [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4121     then ac_cv_prog_egrep='grep -E'
4122     else ac_cv_prog_egrep='egrep'
4123     fi])
4124  EGREP=$ac_cv_prog_egrep
4125  AC_SUBST([EGREP])
4126 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
4127 ])dnl
4128 dnl ---------------------------------------------------------------------------
4129 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
4130 dnl -----------
4131 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
4132 AC_DEFUN([CF_PROG_EXT],
4133 [
4134 AC_REQUIRE([CF_CHECK_CACHE])
4135 case $cf_cv_system_name in
4136 os2*)
4137     CFLAGS="$CFLAGS -Zmt"
4138     CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
4139     CXXFLAGS="$CXXFLAGS -Zmt"
4140     # autoconf's macro sets -Zexe and suffix both, which conflict:w
4141     LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
4142     ac_cv_exeext=.exe
4143     ;;
4144 esac
4145
4146 AC_EXEEXT
4147 AC_OBJEXT
4148
4149 PROG_EXT="$EXEEXT"
4150 AC_SUBST(PROG_EXT)
4151 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
4152 ])dnl
4153 dnl ---------------------------------------------------------------------------
4154 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
4155 dnl ---------------
4156 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
4157 dnl misc/tabset install won't work properly.  Usually this happens only when
4158 dnl using the fallback mkinstalldirs script
4159 AC_DEFUN([CF_PROG_INSTALL],
4160 [AC_PROG_INSTALL
4161 case $INSTALL in
4162 /*)
4163   ;;
4164 *)
4165   CF_DIRNAME(cf_dir,$INSTALL)
4166   test -z "$cf_dir" && cf_dir=.
4167   INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
4168   ;;
4169 esac
4170 ])dnl
4171 dnl ---------------------------------------------------------------------------
4172 dnl CF_PROG_LDCONFIG version: 2 updated: 2008/12/13 14:08:40
4173 dnl ----------------
4174 dnl Check for ldconfig, needed to fixup shared libraries that would be built
4175 dnl and then used in the install.
4176 AC_DEFUN([CF_PROG_LDCONFIG],[
4177 if test "$cross_compiling" = yes ; then
4178   LDCONFIG=:
4179 else
4180 case "$cf_cv_system_name" in #(vi
4181 dragonfly*|freebsd*) #(vi
4182   test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
4183   ;;
4184 *) LDPATH=$PATH:/sbin:/usr/sbin
4185   AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
4186   ;;
4187 esac
4188 fi
4189 AC_SUBST(LDCONFIG)
4190 ])dnl
4191 dnl ---------------------------------------------------------------------------
4192 dnl CF_PROG_LINT version: 2 updated: 2009/08/12 04:43:14
4193 dnl ------------
4194 AC_DEFUN([CF_PROG_LINT],
4195 [
4196 AC_CHECK_PROGS(LINT, tdlint lint alint splint lclint)
4197 AC_SUBST(LINT_OPTS)
4198 ])dnl
4199 dnl ---------------------------------------------------------------------------
4200 dnl CF_REGEX version: 3 updated: 1997/11/01 14:26:01
4201 dnl --------
4202 dnl Attempt to determine if we've got one of the flavors of regular-expression
4203 dnl code that we can support.
4204 AC_DEFUN([CF_REGEX],
4205 [
4206 AC_MSG_CHECKING([for regular-expression headers])
4207 AC_CACHE_VAL(cf_cv_regex,[
4208 AC_TRY_LINK([#include <sys/types.h>
4209 #include <regex.h>],[
4210         regex_t *p;
4211         int x = regcomp(p, "", 0);
4212         int y = regexec(p, "", 0, 0, 0);
4213         regfree(p);
4214         ],[cf_cv_regex="regex.h"],[
4215         AC_TRY_LINK([#include <regexp.h>],[
4216                 char *p = compile("", "", "", 0);
4217                 int x = step("", "");
4218         ],[cf_cv_regex="regexp.h"],[
4219                 cf_save_LIBS="$LIBS"
4220                 LIBS="-lgen $LIBS"
4221                 AC_TRY_LINK([#include <regexpr.h>],[
4222                         char *p = compile("", "", "");
4223                         int x = step("", "");
4224                 ],[cf_cv_regex="regexpr.h"],[LIBS="$cf_save_LIBS"])])])
4225 ])
4226 AC_MSG_RESULT($cf_cv_regex)
4227 case $cf_cv_regex in
4228         regex.h)   AC_DEFINE(HAVE_REGEX_H_FUNCS) ;;
4229         regexp.h)  AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;;
4230         regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;;
4231 esac
4232 ])dnl
4233 dnl ---------------------------------------------------------------------------
4234 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
4235 dnl ----------------
4236 dnl Remove all -U and -D options that refer to the given symbol from a list
4237 dnl of C compiler options.  This works around the problem that not all
4238 dnl compilers process -U and -D options from left-to-right, so a -U option
4239 dnl cannot be used to cancel the effect of a preceding -D option.
4240 dnl
4241 dnl $1 = target (which could be the same as the source variable)
4242 dnl $2 = source (including '$')
4243 dnl $3 = symbol to remove
4244 define([CF_REMOVE_DEFINE],
4245 [
4246 $1=`echo "$2" | \
4247         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
4248                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
4249 ])dnl
4250 dnl ---------------------------------------------------------------------------
4251 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
4252 dnl -------------
4253 dnl Remove the given library from the symbol
4254 dnl
4255 dnl $1 = target (which could be the same as the source variable)
4256 dnl $2 = source (including '$')
4257 dnl $3 = library to remove
4258 define([CF_REMOVE_LIB],
4259 [
4260 # remove $3 library from $2
4261 $1=`echo "$2" | sed -e 's/-l$3[[        ]]//g' -e 's/-l$3[$]//'`
4262 ])dnl
4263 dnl ---------------------------------------------------------------------------
4264 dnl CF_RPATH_HACK version: 4 updated: 2008/09/13 12:53:26
4265 dnl -------------
4266 AC_DEFUN([CF_RPATH_HACK],
4267 [
4268 AC_REQUIRE([CF_SHARED_OPTS])
4269 AC_MSG_CHECKING(for updated LDFLAGS)
4270 if test -n "$LDFLAGS" ; then
4271 AC_MSG_RESULT(maybe)
4272 CF_VERBOSE(...checking LDFLAGS $LDFLAGS)
4273 CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
4274 case "$EXTRA_LDFLAGS" in #(vi
4275 -Wl,-rpath,*) #(vi
4276         cf_rpath_hack="-Wl,-rpath,"
4277         ;;
4278 -R\ *)
4279         cf_rpath_hack="-R "
4280         ;;
4281 -R*)
4282         cf_rpath_hack="-R"
4283         ;;
4284 *)
4285         cf_rpath_hack=
4286         ;;
4287 esac
4288 if test -n "$cf_rpath_hack" ; then
4289         cf_rpath_dst=
4290         for cf_rpath_src in $LDFLAGS
4291         do
4292                 CF_VERBOSE(Filtering $cf_rpath_src)
4293                 case $cf_rpath_src in #(vi
4294                 -L*) #(vi
4295                         if test "$cf_rpath_hack" = "-R " ; then
4296                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e 's%-L%-R %'`
4297                         else
4298                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e s%-L%$cf_rpath_hack%`
4299                         fi
4300                         CF_VERBOSE(...Filter $cf_rpath_tmp)
4301                         EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
4302                         ;;
4303                 esac
4304                 cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
4305         done
4306         LDFLAGS=$cf_rpath_dst
4307         CF_VERBOSE(...checked LDFLAGS $LDFLAGS)
4308         CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
4309 fi
4310 else
4311 AC_MSG_RESULT(no)
4312 fi
4313 ])dnl
4314 dnl ---------------------------------------------------------------------------
4315 dnl CF_SHARED_OPTS version: 58 updated: 2009/12/19 13:46:49
4316 dnl --------------
4317 dnl --------------
4318 dnl Attempt to determine the appropriate CC/LD options for creating a shared
4319 dnl library.
4320 dnl
4321 dnl Note: ${LOCAL_LDFLAGS} is used to link executables that will run within the
4322 dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib
4323 dnl We avoid compiling-in a ../lib path for the shared library since that can
4324 dnl lead to unexpected results at runtime.
4325 dnl ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared libraries
4326 dnl are compiled in ../../lib
4327 dnl
4328 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
4329 dnl to install symbolic links to the rel/abi versions of shared libraries.
4330 dnl
4331 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
4332 dnl version when making symbolic links.
4333 dnl
4334 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
4335 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
4336 dnl (ex: libncurses.so.<ver>).
4337 dnl
4338 dnl Some loaders leave 'so_locations' lying around.  It's nice to clean up.
4339 AC_DEFUN([CF_SHARED_OPTS],
4340 [
4341         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
4342         LOCAL_LDFLAGS=
4343         LOCAL_LDFLAGS2=
4344         LD_RPATH_OPT=
4345         LD_SHARED_OPTS=
4346         INSTALL_LIB="-m 644"
4347
4348         cf_cv_do_symlinks=no
4349
4350         AC_MSG_CHECKING(if release/abi version should be used for shared libs)
4351         AC_ARG_WITH(shlib-version,
4352         [  --with-shlib-version=X  Specify rel or abi version for shared libs],
4353         [test -z "$withval" && withval=auto
4354         case $withval in #(vi
4355         yes) #(vi
4356                 cf_cv_shlib_version=auto
4357                 ;;
4358         rel|abi|auto|no) #(vi
4359                 cf_cv_shlib_version=$withval
4360                 ;;
4361         *)
4362                 AC_MSG_ERROR([option value must be one of: rel, abi, auto or no])
4363                 ;;
4364         esac
4365         ],[cf_cv_shlib_version=auto])
4366         AC_MSG_RESULT($cf_cv_shlib_version)
4367
4368         cf_cv_rm_so_locs=no
4369
4370         # Some less-capable ports of gcc support only -fpic
4371         CC_SHARED_OPTS=
4372         if test "$GCC" = yes
4373         then
4374                 AC_MSG_CHECKING(which $CC option to use)
4375                 cf_save_CFLAGS="$CFLAGS"
4376                 for CC_SHARED_OPTS in -fPIC -fpic ''
4377                 do
4378                         CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
4379                         AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
4380                 done
4381                 AC_MSG_RESULT($CC_SHARED_OPTS)
4382                 CFLAGS="$cf_save_CFLAGS"
4383         fi
4384
4385         cf_cv_shlib_version_infix=no
4386
4387         case $cf_cv_system_name in
4388         aix[[56]]*)
4389                 if test "$GCC" = yes; then
4390                         CC_SHARED_OPTS=
4391                         MK_SHARED_LIB="$(CC) -shared"
4392                 fi
4393                 ;;
4394         beos*)
4395                 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
4396                 ;;
4397         cygwin*)
4398                 CC_SHARED_OPTS=
4399                 MK_SHARED_LIB='sh ../mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
4400                 cf_cv_shlib_version=cygdll
4401                 cf_cv_shlib_version_infix=cygdll
4402                 cat >mk_shared_lib.sh <<-CF_EOF
4403                 #!/bin/sh
4404                 SHARED_LIB=\[$]1
4405                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
4406                 shift
4407                 cat <<-EOF
4408                 Linking shared library
4409                 ** SHARED_LIB \[$]SHARED_LIB
4410                 ** IMPORT_LIB \[$]IMPORT_LIB
4411 EOF
4412                 exec \[$]* -shared -Wl,--out-implib=../lib/\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o ../lib/\[$]{SHARED_LIB}
4413 CF_EOF
4414                 chmod +x mk_shared_lib.sh
4415                 ;;
4416         darwin*)
4417                 EXTRA_CFLAGS="-no-cpp-precomp"
4418                 CC_SHARED_OPTS="-dynamic"
4419                 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
4420                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
4421                 cf_cv_shlib_version_infix=yes
4422                 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
4423                         cf_save_LDFLAGS=$LDFLAGS
4424                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4425                         AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
4426                                 LDFLAGS=$cf_save_LDFLAGS])
4427                 if test $cf_cv_ldflags_search_paths_first = yes; then
4428                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4429                 fi
4430                 ;;
4431         hpux*)
4432                 # (tested with gcc 2.7.2 -- I don't have c89)
4433                 if test "$GCC" = yes; then
4434                         LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
4435                 else
4436                         CC_SHARED_OPTS='+Z'
4437                         LD_SHARED_OPTS='-Wl,+b,${libdir}'
4438                 fi
4439                 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
4440                 # HP-UX shared libraries must be executable, and should be
4441                 # readonly to exploit a quirk in the memory manager.
4442                 INSTALL_LIB="-m 555"
4443                 ;;
4444         irix*)
4445                 if test "$cf_cv_ld_rpath" = yes ; then
4446                         if test "$GCC" = yes; then
4447                                 LD_RPATH_OPT="-Wl,-rpath,"
4448                                 EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
4449                         else
4450                                 LD_RPATH_OPT="-rpath "
4451                                 EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
4452                         fi
4453                 fi
4454                 # tested with IRIX 5.2 and 'cc'.
4455                 if test "$GCC" != yes; then
4456                         CC_SHARED_OPTS='-KPIC'
4457                         MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
4458                 else
4459                         MK_SHARED_LIB='${CC} -shared -Wl,-soname,`basename $[@]` -o $[@]'
4460                 fi
4461                 cf_cv_rm_so_locs=yes
4462                 ;;
4463         linux*|gnu*|k*bsd*-gnu)
4464                 if test "$DFT_LWR_MODEL" = "shared" ; then
4465                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
4466                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4467                 fi