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