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