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