1 dnl***************************************************************************
2 dnl Copyright (c) 1998-2010,2011 Free Software Foundation, Inc. *
4 dnl Permission is hereby granted, free of charge, to any person obtaining a *
5 dnl copy of this software and associated documentation files (the *
6 dnl "Software"), to deal in the Software without restriction, including *
7 dnl without limitation the rights to use, copy, modify, merge, publish, *
8 dnl distribute, distribute with modifications, sublicense, and/or sell *
9 dnl copies of the Software, and to permit persons to whom the Software is *
10 dnl furnished to do so, subject to the following conditions: *
12 dnl The above copyright notice and this permission notice shall be included *
13 dnl in all copies or substantial portions of the Software. *
15 dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS *
16 dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF *
17 dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. *
18 dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
19 dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
20 dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR *
21 dnl THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
23 dnl Except as contained in this notice, the name(s) of the above copyright *
24 dnl holders shall not be used in advertising or otherwise to promote the *
25 dnl sale, use or other dealings in this Software without prior written *
27 dnl***************************************************************************
29 dnl Author: Thomas E. Dickey 1995-on
31 dnl $Id: aclocal.m4,v 1.554 2011/04/16 16:37:26 tom Exp $
32 dnl Macros used in NCURSES auto-configuration script.
34 dnl These macros are maintained separately from NCURSES. The copyright on
35 dnl this file applies to the aggregation of macros and does not affect use of
36 dnl these macros in other applications.
38 dnl See http://invisible-island.net/autoconf/ for additional information.
40 dnl ---------------------------------------------------------------------------
41 dnl ---------------------------------------------------------------------------
42 dnl AM_LANGINFO_CODESET version: 3 updated: 2002/10/27 23:21:42
43 dnl -------------------
44 dnl Inserted as requested by gettext 0.10.40
45 dnl File from /usr/share/aclocal
47 dnl ====================
50 dnl From Bruno Haible.
51 AC_DEFUN([AM_LANGINFO_CODESET],
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)
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).])
64 dnl ---------------------------------------------------------------------------
65 dnl CF_ADA_INCLUDE_DIRS version: 6 updated: 2010/02/26 19:52:07
66 dnl -------------------
67 dnl Construct the list of include-options for the C programs in the Ada95
69 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
71 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
72 if test "$srcdir" != "."; then
73 ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
75 if test "$GCC" != yes; then
76 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
77 elif test "$includedir" != "/usr/include"; then
78 if test "$includedir" = '${prefix}/include' ; then
79 if test $prefix != /usr ; then
80 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
83 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
88 dnl ---------------------------------------------------------------------------
89 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
91 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
92 AC_DEFUN([CF_ADD_ADAFLAGS],[
93 ADAFLAGS="$ADAFLAGS $1"
96 dnl ---------------------------------------------------------------------------
97 dnl CF_ADD_CFLAGS version: 10 updated: 2010/05/26 05:38:42
99 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
100 dnl The second parameter if given makes this macro verbose.
102 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
103 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
104 dnl confused by the quotes (which require backslashes to keep them usable).
105 AC_DEFUN([CF_ADD_CFLAGS],
110 cf_new_extra_cppflags=
112 for cf_add_cflags in $1
114 case $cf_fix_cppflags in
116 case $cf_add_cflags in #(vi
117 -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi
118 case $cf_add_cflags in
120 cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
122 test "${cf_add_cflags}" != "${cf_tst_cflags}" \
123 && test -z "${cf_tst_cflags}" \
124 && cf_fix_cppflags=yes
126 if test $cf_fix_cppflags = yes ; then
127 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
129 elif test "${cf_tst_cflags}" = "\"'" ; then
130 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
136 *$cf_add_cflags) #(vi
139 case $cf_add_cflags in #(vi
141 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
142 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
145 cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
150 cf_new_cflags="$cf_new_cflags $cf_add_cflags"
155 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
157 cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
159 test "${cf_add_cflags}" != "${cf_tst_cflags}" \
160 && test -z "${cf_tst_cflags}" \
161 && cf_fix_cppflags=no
166 if test -n "$cf_new_cflags" ; then
167 ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
168 CFLAGS="$CFLAGS $cf_new_cflags"
171 if test -n "$cf_new_cppflags" ; then
172 ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
173 CPPFLAGS="$CPPFLAGS $cf_new_cppflags"
176 if test -n "$cf_new_extra_cppflags" ; then
177 ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
178 EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
181 AC_SUBST(EXTRA_CPPFLAGS)
184 dnl ---------------------------------------------------------------------------
185 dnl CF_ADD_INCDIR version: 13 updated: 2010/05/26 16:44:57
187 dnl Add an include-directory to $CPPFLAGS. Don't add /usr/include, since it's
188 dnl redundant. We don't normally need to add -I/usr/local/include for gcc,
189 dnl but old versions (and some misinstalled ones) need that. To make things
190 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
191 dnl the include-path).
192 AC_DEFUN([CF_ADD_INCDIR],
194 if test -n "$1" ; then
195 for cf_add_incdir in $1
197 while test $cf_add_incdir != /usr/include
199 if test -d $cf_add_incdir
202 if test -n "$CFLAGS$CPPFLAGS" ; then
203 # a loop is needed to ensure we can add subdirs of existing dirs
204 for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
205 if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
206 cf_have_incdir=yes; break
211 if test "$cf_have_incdir" = no ; then
212 if test "$cf_add_incdir" = /usr/local/include ; then
215 cf_save_CPPFLAGS=$CPPFLAGS
216 CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
217 AC_TRY_COMPILE([#include <stdio.h>],
220 [cf_have_incdir=yes])
221 CPPFLAGS=$cf_save_CPPFLAGS
226 if test "$cf_have_incdir" = no ; then
227 CF_VERBOSE(adding $cf_add_incdir to include-path)
228 ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
230 cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
231 test "$cf_top_incdir" = "$cf_add_incdir" && break
232 cf_add_incdir="$cf_top_incdir"
241 dnl ---------------------------------------------------------------------------
242 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
244 dnl Add a library, used to enforce consistency.
246 dnl $1 = library to add, without the "-l"
247 dnl $2 = variable to update (default $LIBS)
248 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
249 dnl ---------------------------------------------------------------------------
250 dnl CF_ADD_LIBDIR version: 9 updated: 2010/05/26 16:44:57
252 dnl Adds to the library-path
254 dnl Some machines have trouble with multiple -L options.
256 dnl $1 is the (list of) directory(s) to add
257 dnl $2 is the optional name of the variable to update (default LDFLAGS)
259 AC_DEFUN([CF_ADD_LIBDIR],
261 if test -n "$1" ; then
262 for cf_add_libdir in $1
264 if test $cf_add_libdir = /usr/lib ; then
266 elif test -d $cf_add_libdir
269 if test -n "$LDFLAGS$LIBS" ; then
270 # a loop is needed to ensure we can add subdirs of existing dirs
271 for cf_test_libdir in $LDFLAGS $LIBS ; do
272 if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
273 cf_have_libdir=yes; break
277 if test "$cf_have_libdir" = no ; then
278 CF_VERBOSE(adding $cf_add_libdir to library-path)
279 ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
285 dnl ---------------------------------------------------------------------------
286 dnl CF_ADD_LIBS version: 1 updated: 2010/06/02 05:03:05
288 dnl Add one or more libraries, used to enforce consistency.
290 dnl $1 = libraries to add, with the "-l", etc.
291 dnl $2 = variable to update (default $LIBS)
292 AC_DEFUN([CF_ADD_LIBS],[ifelse($2,,LIBS,[$2])="$1 [$]ifelse($2,,LIBS,[$2])"])dnl
293 dnl ---------------------------------------------------------------------------
294 dnl CF_ADD_SUBDIR_PATH version: 3 updated: 2010/07/03 20:58:12
295 dnl ------------------
296 dnl Append to a search-list for a nonstandard header/lib-file
297 dnl $1 = the variable to return as result
298 dnl $2 = the package name
299 dnl $3 = the subdirectory, e.g., bin, include or lib
300 dnl $4 = the directory under which we will test for subdirectories
301 dnl $5 = a directory that we do not want $4 to match
302 AC_DEFUN([CF_ADD_SUBDIR_PATH],
304 test "$4" != "$5" && \
306 ifelse([$5],NONE,,[(test $5 = NONE || test "$4" != "$5") &&]) {
307 test -n "$verbose" && echo " ... testing for $3-directories under $4"
308 test -d $4/$3 && $1="[$]$1 $4/$3"
309 test -d $4/$3/$2 && $1="[$]$1 $4/$3/$2"
310 test -d $4/$3/$2/$3 && $1="[$]$1 $4/$3/$2/$3"
311 test -d $4/$2/$3 && $1="[$]$1 $4/$2/$3"
312 test -d $4/$2/$3/$2 && $1="[$]$1 $4/$2/$3/$2"
315 dnl ---------------------------------------------------------------------------
316 dnl CF_ANSI_CC_CHECK version: 10 updated: 2010/10/23 15:52:32
318 dnl This is adapted from the macros 'fp_PROG_CC_STDC' and 'fp_C_PROTOTYPES'
319 dnl in the sharutils 4.2 distribution.
320 AC_DEFUN([CF_ANSI_CC_CHECK],
322 AC_CACHE_CHECK(for ${CC:-cc} option to accept ANSI C, cf_cv_ansi_cc,[
324 cf_save_CFLAGS="$CFLAGS"
325 cf_save_CPPFLAGS="$CPPFLAGS"
326 # Don't try gcc -ansi; that turns off useful extensions and
327 # breaks some systems' header files.
329 # Ultrix and OSF/1 -std1
330 # HP-UX -Aa -D_HPUX_SOURCE
332 # UnixWare 1.2 (cannot use -Xc, since ANSI/POSIX clashes)
333 for cf_arg in "-DCC_HAS_PROTOS" \
338 "-Aa -D_HPUX_SOURCE" \
341 CF_ADD_CFLAGS($cf_arg)
344 #ifndef CC_HAS_PROTOS
345 #if !defined(__STDC__) || (__STDC__ != 1)
350 int test (int i, double x);
351 struct s1 {int (*f) (int a);};
352 struct s2 {int (*f) (double a);};],
353 [cf_cv_ansi_cc="$cf_arg"; break])
355 CFLAGS="$cf_save_CFLAGS"
356 CPPFLAGS="$cf_save_CPPFLAGS"
359 if test "$cf_cv_ansi_cc" != "no"; then
360 if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then
361 CF_ADD_CFLAGS($cf_cv_ansi_cc)
363 AC_DEFINE(CC_HAS_PROTOS)
367 dnl ---------------------------------------------------------------------------
368 dnl CF_ANSI_CC_REQD version: 4 updated: 2008/03/23 14:48:54
370 dnl For programs that must use an ANSI compiler, obtain compiler options that
371 dnl will make it recognize prototypes. We'll do preprocessor checks in other
372 dnl macros, since tools such as unproto can fake prototypes, but only part of
373 dnl the preprocessor.
374 AC_DEFUN([CF_ANSI_CC_REQD],
375 [AC_REQUIRE([CF_ANSI_CC_CHECK])
376 if test "$cf_cv_ansi_cc" = "no"; then
378 [Your compiler does not appear to recognize prototypes.
379 You have the following choices:
380 a. adjust your compiler options
381 b. get an up-to-date compiler
382 c. use a wrapper such as unproto])
385 dnl ---------------------------------------------------------------------------
386 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
388 dnl Allow user to disable a normally-on option.
389 AC_DEFUN([CF_ARG_DISABLE],
390 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
391 dnl ---------------------------------------------------------------------------
392 dnl CF_ARG_OPTION version: 4 updated: 2010/05/26 05:38:42
394 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
400 dnl $3 = action to perform if option is not default
401 dnl $4 = action if perform if option is default
402 dnl $5 = default option value (either 'yes' or 'no')
403 AC_DEFUN([CF_ARG_OPTION],
404 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
405 if test "$enableval" != "$5" ; then
407 ,[ $3]) ifelse([$4],,,[
410 fi],[enableval=$5 ifelse([$4],,,[
414 dnl ---------------------------------------------------------------------------
415 dnl CF_AR_FLAGS version: 5 updated: 2010/05/20 20:24:29
417 dnl Check for suitable "ar" (archiver) options for updating an archive.
418 AC_DEFUN([CF_AR_FLAGS],[
419 AC_REQUIRE([CF_PROG_AR])
421 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
422 cf_cv_ar_flags=unknown
423 for cf_ar_flags in -curv curv -crv crv -cqv cqv -rv rv
426 # check if $ARFLAGS already contains this choice
427 if test "x$ARFLAGS" != "x" ; then
428 cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
429 if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
435 rm -f conftest.$ac_cv_objext
438 cat >conftest.$ac_ext <<EOF
439 #line __oline__ "configure"
440 int testdata[[3]] = { 123, 456, 789 };
442 if AC_TRY_EVAL(ac_compile) ; then
443 echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
444 $AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null
445 if test -f conftest.a ; then
446 cf_cv_ar_flags=$cf_ar_flags
450 CF_VERBOSE(cannot compile test-program)
454 rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
457 if test -n "$ARFLAGS" ; then
458 if test -n "$cf_cv_ar_flags" ; then
459 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
462 ARFLAGS=$cf_cv_ar_flags
467 dnl ---------------------------------------------------------------------------
468 dnl CF_AWK_BIG_PRINTF version: 3 updated: 2008/12/27 12:30:03
469 dnl -----------------
470 dnl Check if awk can handle big strings using printf. Some older versions of
471 dnl awk choke on large strings passed via "%s".
473 dnl $1 = desired string size
474 dnl $2 = variable to set with result
475 AC_DEFUN([CF_AWK_BIG_PRINTF],
482 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' \
483 | $AWK '{ printf "%d\n", length([$]0); }' | $AWK 'BEGIN { eqls=0; recs=0; } { recs++; if ([$]0 == 12000) eqls++; } END { if (recs != 1 || eqls != 1) exit 1; }' 2>/dev/null >/dev/null ) ; then
491 dnl ---------------------------------------------------------------------------
492 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
494 dnl Test if 'bool' is a builtin type in the configured C++ compiler. Some
495 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
496 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
498 dnl Treat the configuration-variable specially here, since we're directly
499 dnl substituting its value (i.e., 1/0).
501 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
502 AC_DEFUN([CF_BOOL_DECL],
504 AC_MSG_CHECKING(if we should include stdbool.h)
506 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
507 AC_TRY_COMPILE([],[bool foo = false],
508 [cf_cv_header_stdbool_h=0],
513 ],[bool foo = false],
514 [cf_cv_header_stdbool_h=1],
515 [cf_cv_header_stdbool_h=0])])])
517 if test "$cf_cv_header_stdbool_h" = 1
518 then AC_MSG_RESULT(yes)
519 else AC_MSG_RESULT(no)
522 AC_MSG_CHECKING([for builtin bool type])
524 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
527 #include <sys/types.h>
529 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
530 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
533 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
534 then AC_MSG_RESULT(yes)
535 else AC_MSG_RESULT(no)
538 dnl ---------------------------------------------------------------------------
539 dnl CF_BOOL_SIZE version: 12 updated: 2006/12/16 12:33:30
541 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
542 dnl Don't bother looking for bool.h, since it's been deprecated.
544 dnl If the current compiler is C rather than C++, we get the bool definition
545 dnl from <stdbool.h>.
546 AC_DEFUN([CF_BOOL_SIZE],
548 AC_MSG_CHECKING([for size of bool])
549 AC_CACHE_VAL(cf_cv_type_of_bool,[
555 #if defined(__cplusplus)
557 #ifdef HAVE_GXX_BUILTIN_H
558 #include <g++/builtin.h>
559 #elif HAVE_GPP_BUILTIN_H
560 #include <gpp/builtin.h>
567 #if $cf_cv_header_stdbool_h
575 FILE *fp = fopen("cf_test.out", "w");
579 fputs("unsigned ", fp);
580 if (sizeof(x) == sizeof(int)) fputs("int", fp);
581 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
582 else if (sizeof(x) == sizeof(short))fputs("short",fp);
583 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
586 ${cf_cv_main_return:-return}(0);
589 [cf_cv_type_of_bool=`cat cf_test.out`
590 if test -z "$cf_cv_type_of_bool"; then
591 cf_cv_type_of_bool=unknown
593 [cf_cv_type_of_bool=unknown],
594 [cf_cv_type_of_bool=unknown])
597 AC_MSG_RESULT($cf_cv_type_of_bool)
598 if test "$cf_cv_type_of_bool" = unknown ; then
599 case .$NCURSES_BOOL in #(vi
600 .auto|.) NCURSES_BOOL=unsigned;;
602 AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
603 cf_cv_type_of_bool=$NCURSES_BOOL
606 dnl ---------------------------------------------------------------------------
607 dnl CF_BUILD_CC version: 6 updated: 2006/10/14 15:23:15
609 dnl If we're cross-compiling, allow the user to override the tools and their
610 dnl options. The configure script is oriented toward identifying the host
611 dnl compiler, etc., but we need a build compiler to generate parts of the
614 dnl $1 = default for $CPPFLAGS
615 dnl $2 = default for $LIBS
616 AC_DEFUN([CF_BUILD_CC],[
617 AC_REQUIRE([CF_PROG_EXT])
618 if test "$cross_compiling" = yes ; then
620 # defaults that we might want to override
621 : ${BUILD_CFLAGS:=''}
622 : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
623 : ${BUILD_LDFLAGS:=''}
624 : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
625 : ${BUILD_EXEEXT:='$x'}
626 : ${BUILD_OBJEXT:='o'}
628 AC_ARG_WITH(build-cc,
629 [ --with-build-cc=XXX the build C compiler ($BUILD_CC)],
630 [BUILD_CC="$withval"],
631 [AC_CHECK_PROGS(BUILD_CC, gcc cc cl)])
632 AC_MSG_CHECKING(for native build C compiler)
633 AC_MSG_RESULT($BUILD_CC)
635 AC_MSG_CHECKING(for native build C preprocessor)
636 AC_ARG_WITH(build-cpp,
637 [ --with-build-cpp=XXX the build C preprocessor ($BUILD_CPP)],
638 [BUILD_CPP="$withval"],
639 [BUILD_CPP='${BUILD_CC} -E'])
640 AC_MSG_RESULT($BUILD_CPP)
642 AC_MSG_CHECKING(for native build C flags)
643 AC_ARG_WITH(build-cflags,
644 [ --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
645 [BUILD_CFLAGS="$withval"])
646 AC_MSG_RESULT($BUILD_CFLAGS)
648 AC_MSG_CHECKING(for native build C preprocessor-flags)
649 AC_ARG_WITH(build-cppflags,
650 [ --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
651 [BUILD_CPPFLAGS="$withval"])
652 AC_MSG_RESULT($BUILD_CPPFLAGS)
654 AC_MSG_CHECKING(for native build linker-flags)
655 AC_ARG_WITH(build-ldflags,
656 [ --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
657 [BUILD_LDFLAGS="$withval"])
658 AC_MSG_RESULT($BUILD_LDFLAGS)
660 AC_MSG_CHECKING(for native build linker-libraries)
661 AC_ARG_WITH(build-libs,
662 [ --with-build-libs=XXX the build libraries (${BUILD_LIBS})],
663 [BUILD_LIBS="$withval"])
664 AC_MSG_RESULT($BUILD_LIBS)
666 # this assumes we're on Unix.
670 : ${BUILD_CC:='${CC}'}
672 if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
673 AC_MSG_ERROR([Cross-build requires two compilers.
674 Use --with-build-cc to specify the native compiler.])
678 : ${BUILD_CC:='${CC}'}
679 : ${BUILD_CPP:='${CPP}'}
680 : ${BUILD_CFLAGS:='${CFLAGS}'}
681 : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
682 : ${BUILD_LDFLAGS:='${LDFLAGS}'}
683 : ${BUILD_LIBS:='${LIBS}'}
684 : ${BUILD_EXEEXT:='$x'}
685 : ${BUILD_OBJEXT:='o'}
690 AC_SUBST(BUILD_CFLAGS)
691 AC_SUBST(BUILD_CPPFLAGS)
692 AC_SUBST(BUILD_LDFLAGS)
694 AC_SUBST(BUILD_EXEEXT)
695 AC_SUBST(BUILD_OBJEXT)
697 dnl ---------------------------------------------------------------------------
698 dnl CF_CFG_DEFAULTS version: 7 updated: 2005/09/24 16:15:00
700 dnl Determine the default configuration into which we'll install ncurses. This
701 dnl can be overridden by the user's command-line options. There's two items to
703 dnl 1. the prefix (e.g., /usr)
704 dnl 2. the header files (e.g., /usr/include/ncurses)
705 dnl We'll look for a previous installation of ncurses and use the same defaults.
707 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
708 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
709 dnl programs from a vendor's.
710 AC_DEFUN([CF_CFG_DEFAULTS],
712 AC_MSG_CHECKING(for prefix)
713 if test "x$prefix" = "xNONE" ; then
714 case "$cf_cv_system_name" in
715 # non-vendor systems don't have a conflict
716 openbsd*|freebsd*|linux*|cygwin*|k*bsd*-gnu)
719 *) prefix=$ac_default_prefix
723 AC_MSG_RESULT($prefix)
725 if test "x$prefix" = "xNONE" ; then
726 AC_MSG_CHECKING(for default include-directory)
727 test -n "$verbose" && echo 1>&AC_FD_MSG
730 $includedir/ncurses \
732 $prefix/include/ncurses \
734 /usr/local/include/ncurses \
738 cf_dir=`eval echo $cf_symbol`
739 if test -f $cf_dir/curses.h ; then
740 if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
741 includedir="$cf_symbol"
742 test -n "$verbose" && echo $ac_n " found " 1>&AC_FD_MSG
746 test -n "$verbose" && echo " tested $cf_dir" 1>&AC_FD_MSG
748 AC_MSG_RESULT($includedir)
751 dnl ---------------------------------------------------------------------------
752 dnl CF_CGETENT version: 3 updated: 2000/08/12 23:18:52
754 dnl Check if the terminal-capability database functions are available. If not,
755 dnl ncurses has a much-reduced version.
756 AC_DEFUN([CF_CGETENT],[
757 AC_MSG_CHECKING(for terminal-capability database functions)
758 AC_CACHE_VAL(cf_cv_cgetent,[
760 #include <stdlib.h>],[
763 char *db_array = temp;
764 cgetent(&buf, /* int *, */ &db_array, "vt100");
765 cgetcap(buf, "tc", '=');
766 cgetmatch(buf, "tc");
771 AC_MSG_RESULT($cf_cv_cgetent)
772 test "$cf_cv_cgetent" = yes && AC_DEFINE(HAVE_BSD_CGETENT)
774 dnl ---------------------------------------------------------------------------
775 dnl CF_CHECK_CACHE version: 11 updated: 2008/03/23 14:45:59
777 dnl Check if we're accidentally using a cache from a different machine.
778 dnl Derive the system name, as a check for reusing the autoconf cache.
780 dnl If we've packaged config.guess and config.sub, run that (since it does a
781 dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
782 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
783 dnl which is useful in cross-compiles.
785 dnl Note: we would use $ac_config_sub, but that is one of the places where
786 dnl autoconf 2.5x broke compatibility with autoconf 2.13
787 AC_DEFUN([CF_CHECK_CACHE],
789 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
790 ifelse([$1],,[AC_CANONICAL_HOST],[$1])
791 system_name="$host_os"
793 system_name="`(uname -s -r) 2>/dev/null`"
794 if test -z "$system_name" ; then
795 system_name="`(hostname) 2>/dev/null`"
798 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name")
799 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
801 test -z "$system_name" && system_name="$cf_cv_system_name"
802 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
804 if test ".$system_name" != ".$cf_cv_system_name" ; then
805 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
806 AC_MSG_ERROR("Please remove config.cache and try again.")
809 dnl ---------------------------------------------------------------------------
810 dnl CF_CHECK_ERRNO version: 11 updated: 2010/05/26 05:38:42
812 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
813 dnl the 'errno' variable. Define a DECL_xxx symbol if we must declare it
816 dnl $1 = the name to check
817 dnl $2 = the assumed type
818 AC_DEFUN([CF_CHECK_ERRNO],
820 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
826 #include <sys/types.h>
827 #include <errno.h> ],
828 ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1,
833 if test "$cf_cv_dcl_$1" = no ; then
834 CF_UPPER(cf_result,decl_$1)
835 AC_DEFINE_UNQUOTED($cf_result)
838 # It's possible (for near-UNIX clones) that the data doesn't exist
839 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
841 dnl ---------------------------------------------------------------------------
842 dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23
843 dnl --------------------
844 dnl Check for existence of external data in the current set of libraries. If
845 dnl we can modify it, it's real enough.
846 dnl $1 = the name to check
848 AC_DEFUN([CF_CHECK_EXTERN_DATA],
850 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
860 if test "$cf_cv_have_$1" = yes ; then
861 CF_UPPER(cf_result,have_$1)
862 AC_DEFINE_UNQUOTED($cf_result)
866 dnl ---------------------------------------------------------------------------
867 dnl CF_CHECK_GPM_WGETCH version: 2 updated: 2010/08/14 18:25:37
868 dnl -------------------
869 dnl Check if GPM is already linked with curses. If so - and if the linkage
870 dnl is not "weak" - warn about this because it can create problems linking
871 dnl applications with ncurses.
872 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
873 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
875 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
876 cf_cv_check_gpm_wgetch=unknown
877 if test "$cross_compiling" != yes ; then
879 cat >conftest.$ac_ext <<CF_EOF
884 ${cf_cv_main_return:-return}(0);
889 # This only works if we can look at the symbol table. If a shared
890 # library is stripped for install, we cannot use that. So we're forced
891 # to rely on the static library, noting that some packagers may not
893 LIBS="-static -lgpm -dynamic $LIBS"
894 if AC_TRY_EVAL(ac_compile) ; then
895 if AC_TRY_EVAL(ac_link) ; then
896 cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
897 test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
898 test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
906 if test "$cf_cv_check_gpm_wgetch" != yes ; then
907 AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
910 dnl ---------------------------------------------------------------------------
911 dnl CF_CPP_PARAM_INIT version: 4 updated: 2001/04/07 22:31:18
912 dnl -----------------
913 dnl Check if the C++ compiler accepts duplicate parameter initialization. This
914 dnl is a late feature for the standard and is not in some recent compilers
916 AC_DEFUN([CF_CPP_PARAM_INIT],
918 if test -n "$CXX"; then
919 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
931 TEST::TEST(int x = 1) // some compilers do not like second initializer
937 [cf_cv_cpp_param_init=yes],
938 [cf_cv_cpp_param_init=no],
939 [cf_cv_cpp_param_init=unknown])
943 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT)
945 dnl ---------------------------------------------------------------------------
946 dnl CF_CPP_STATIC_CAST version: 1 updated: 2005/07/23 16:52:43
947 dnl ------------------
948 dnl Check if the C++ compiler accepts static_cast in generics. This appears to
949 dnl not be supported in g++ before 3.0
950 AC_DEFUN([CF_CPP_STATIC_CAST],
952 if test -n "$CXX"; then
954 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
962 NCursesPanel(int nlines,
972 template<class T> class NCursesUserPanel : public NCursesPanel
975 NCursesUserPanel (int nlines,
979 const T* p_UserData = static_cast<T*>(0))
980 : NCursesPanel (nlines, ncols, begin_y, begin_x)
983 NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
987 virtual ~NCursesUserPanel() {};
990 const char* p_UserData = static_cast<char*>(0)],
991 [cf_cv_cpp_static_cast=yes],
992 [cf_cv_cpp_static_cast=no])
999 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST)
1001 dnl ---------------------------------------------------------------------------
1002 dnl CF_C_INLINE version: 3 updated: 2010/05/01 15:14:41
1004 dnl Check if the C compiler supports "inline".
1005 dnl $1 is the name of a shell variable to set if inline is supported
1006 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
1007 AC_DEFUN([CF_C_INLINE],[
1010 if test "$ac_cv_c_inline" != no ; then
1012 if test "$INTEL_COMPILER" = yes
1015 elif test "$GCC" = yes
1017 AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[
1018 cf_save_CFLAGS=$CFLAGS
1019 CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
1020 AC_TRY_COMPILE([inline int foo(void) { return 1; }],
1021 [${cf_cv_main_return:-return} foo()],
1022 [cf_cv_gcc_inline=yes],
1023 [cf_cv_gcc_inline=no])
1024 CFLAGS=$cf_save_CFLAGS
1026 if test "$cf_cv_gcc_inline" = yes ; then
1027 CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
1033 dnl ---------------------------------------------------------------------------
1034 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
1036 dnl "dirname" is not portable, so we fake it with a shell script.
1037 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
1038 dnl ---------------------------------------------------------------------------
1039 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
1041 AC_DEFUN([CF_DIRS_TO_MAKE],
1044 for cf_item in $cf_list_models
1046 CF_OBJ_SUBDIR($cf_item,cf_subdir)
1047 for cf_item2 in $DIRS_TO_MAKE
1049 test $cf_item2 = $cf_subdir && break
1051 test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
1053 for cf_dir in $DIRS_TO_MAKE
1055 test ! -d $cf_dir && mkdir $cf_dir
1057 AC_SUBST(DIRS_TO_MAKE)
1059 dnl ---------------------------------------------------------------------------
1060 dnl CF_DISABLE_LEAKS version: 6 updated: 2010/07/23 04:14:32
1061 dnl ----------------
1062 dnl Combine no-leak checks with the libraries or tools that are used for the
1064 AC_DEFUN([CF_DISABLE_LEAKS],[
1066 AC_REQUIRE([CF_WITH_DMALLOC])
1067 AC_REQUIRE([CF_WITH_DBMALLOC])
1068 AC_REQUIRE([CF_WITH_VALGRIND])
1070 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1071 AC_ARG_ENABLE(leaks,
1072 [ --disable-leaks test: free permanent memory, analyze leaks],
1073 [if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi],
1074 : ${with_no_leaks:=no})
1075 AC_MSG_RESULT($with_no_leaks)
1077 if test "$with_no_leaks" = yes ; then
1079 AC_DEFINE(YY_NO_LEAKS)
1082 dnl ---------------------------------------------------------------------------
1083 dnl CF_DISABLE_LIBTOOL_VERSION version: 1 updated: 2010/05/15 15:45:59
1084 dnl --------------------------
1085 dnl Check if we should use the libtool 1.5 feature "-version-number" instead of
1086 dnl the older "-version-info" feature. The newer feature allows us to use
1087 dnl version numbering on shared libraries which make them compatible with
1088 dnl various systems.
1089 AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION],
1091 AC_MSG_CHECKING(if libtool -version-number should be used)
1092 CF_ARG_DISABLE(libtool-version,
1093 [ --disable-libtool-version enable to use libtool's incompatible naming scheme],
1094 [cf_libtool_version=no],
1095 [cf_libtool_version=yes])
1096 AC_MSG_RESULT($cf_libtool_version)
1098 if test "$cf_libtool_version" = yes ; then
1099 LIBTOOL_VERSION="-version-number"
1101 LIBTOOL_VERSION="-version-info"
1104 AC_SUBST(LIBTOOL_VERSION)
1106 dnl ---------------------------------------------------------------------------
1107 dnl CF_DISABLE_RPATH_HACK version: 2 updated: 2011/02/13 13:31:33
1108 dnl ---------------------
1109 dnl The rpath-hack makes it simpler to build programs, particularly with the
1110 dnl *BSD ports which may have essential libraries in unusual places. But it
1111 dnl can interfere with building an executable for the base system. Use this
1112 dnl option in that case.
1113 AC_DEFUN([CF_DISABLE_RPATH_HACK],
1115 AC_MSG_CHECKING(if rpath-hack should be disabled)
1116 CF_ARG_DISABLE(rpath-hack,
1117 [ --disable-rpath-hack don't add rpath options for additional libraries],
1118 [cf_disable_rpath_hack=yes],
1119 [cf_disable_rpath_hack=no])
1120 AC_MSG_RESULT($cf_disable_rpath_hack)
1121 if test "$cf_disable_rpath_hack" = no ; then
1125 dnl ---------------------------------------------------------------------------
1126 dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
1128 dnl Check if the rpath option should be used, setting cache variable
1129 dnl cf_cv_enable_rpath if so.
1130 AC_DEFUN([CF_ENABLE_RPATH],
1132 AC_MSG_CHECKING(if rpath option should be used)
1133 AC_ARG_ENABLE(rpath,
1134 [ --enable-rpath use rpath option when generating shared libraries],
1135 [cf_cv_enable_rpath=$enableval],
1136 [cf_cv_enable_rpath=no])
1137 AC_MSG_RESULT($cf_cv_enable_rpath)
1139 dnl ---------------------------------------------------------------------------
1140 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
1142 dnl Check if 'errno' is declared in <errno.h>
1143 AC_DEFUN([CF_ERRNO],
1145 CF_CHECK_ERRNO(errno)
1147 dnl ---------------------------------------------------------------------------
1148 dnl CF_ETIP_DEFINES version: 3 updated: 2003/03/22 19:13:43
1150 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
1151 dnl math.h and builtin.h, only for ncurses
1152 AC_DEFUN([CF_ETIP_DEFINES],
1154 AC_MSG_CHECKING(for special defines needed for etip.h)
1155 cf_save_CXXFLAGS="$CXXFLAGS"
1157 for cf_math in "" MATH_H
1159 for cf_excp in "" MATH_EXCEPTION
1161 CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -I${srcdir}/include"
1162 test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
1163 test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
1165 #include <etip.h.in>
1167 test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
1168 test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
1169 cf_result="$cf_math $cf_excp"
1174 AC_MSG_RESULT($cf_result)
1175 CXXFLAGS="$cf_save_CXXFLAGS"
1177 dnl ---------------------------------------------------------------------------
1178 dnl CF_FIND_LINKAGE version: 19 updated: 2010/05/29 16:31:02
1180 dnl Find a library (specifically the linkage used in the code fragment),
1181 dnl searching for it if it is not already in the library path.
1182 dnl See also CF_ADD_SEARCHPATH.
1184 dnl Parameters (4-on are optional):
1185 dnl $1 = headers for library entrypoint
1186 dnl $2 = code fragment for library entrypoint
1187 dnl $3 = the library name without the "-l" option or ".so" suffix.
1188 dnl $4 = action to perform if successful (default: update CPPFLAGS, etc)
1189 dnl $5 = action to perform if not successful
1190 dnl $6 = module name, if not the same as the library name
1191 dnl $7 = extra libraries
1193 dnl Sets these variables:
1194 dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1195 dnl $cf_cv_header_path_$3 - include-directory if needed
1196 dnl $cf_cv_library_path_$3 - library-directory if needed
1197 dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1198 AC_DEFUN([CF_FIND_LINKAGE],[
1200 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1201 # will be set on completion of the AC_TRY_LINK below.
1202 cf_cv_header_path_$3=
1203 cf_cv_library_path_$3=
1205 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1207 cf_save_LIBS="$LIBS"
1209 AC_TRY_LINK([$1],[$2],[
1210 cf_cv_find_linkage_$3=yes
1211 cf_cv_header_path_$3=/usr/include
1212 cf_cv_library_path_$3=/usr/lib
1215 LIBS="-l$3 $7 $cf_save_LIBS"
1217 AC_TRY_LINK([$1],[$2],[
1218 cf_cv_find_linkage_$3=yes
1219 cf_cv_header_path_$3=/usr/include
1220 cf_cv_library_path_$3=/usr/lib
1221 cf_cv_library_file_$3="-l$3"
1223 cf_cv_find_linkage_$3=no
1224 LIBS="$cf_save_LIBS"
1226 CF_VERBOSE(find linkage for $3 library)
1227 CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1229 cf_save_CPPFLAGS="$CPPFLAGS"
1230 cf_test_CPPFLAGS="$CPPFLAGS"
1232 CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1233 for cf_cv_header_path_$3 in $cf_search
1235 if test -d $cf_cv_header_path_$3 ; then
1236 CF_VERBOSE(... testing $cf_cv_header_path_$3)
1237 CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
1238 AC_TRY_COMPILE([$1],[$2],[
1239 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1240 cf_cv_find_linkage_$3=maybe
1241 cf_test_CPPFLAGS="$CPPFLAGS"
1243 CPPFLAGS="$cf_save_CPPFLAGS"
1248 if test "$cf_cv_find_linkage_$3" = maybe ; then
1250 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1252 cf_save_LIBS="$LIBS"
1253 cf_save_LDFLAGS="$LDFLAGS"
1256 CPPFLAGS="$cf_test_CPPFLAGS"
1257 LIBS="-l$3 $7 $cf_save_LIBS"
1258 AC_TRY_LINK([$1],[$2],[
1259 CF_VERBOSE(... found $3 library in system)
1260 cf_cv_find_linkage_$3=yes])
1261 CPPFLAGS="$cf_save_CPPFLAGS"
1262 LIBS="$cf_save_LIBS"
1265 if test "$cf_cv_find_linkage_$3" != yes ; then
1266 CF_LIBRARY_PATH(cf_search,$3)
1267 for cf_cv_library_path_$3 in $cf_search
1269 if test -d $cf_cv_library_path_$3 ; then
1270 CF_VERBOSE(... testing $cf_cv_library_path_$3)
1271 CPPFLAGS="$cf_test_CPPFLAGS"
1272 LIBS="-l$3 $7 $cf_save_LIBS"
1273 LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1274 AC_TRY_LINK([$1],[$2],[
1275 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1276 cf_cv_find_linkage_$3=yes
1277 cf_cv_library_file_$3="-l$3"
1279 CPPFLAGS="$cf_save_CPPFLAGS"
1280 LIBS="$cf_save_LIBS"
1281 LDFLAGS="$cf_save_LDFLAGS"
1285 CPPFLAGS="$cf_save_CPPFLAGS"
1286 LDFLAGS="$cf_save_LDFLAGS"
1290 cf_cv_find_linkage_$3=no
1295 LIBS="$cf_save_LIBS"
1297 if test "$cf_cv_find_linkage_$3" = yes ; then
1299 CF_ADD_INCDIR($cf_cv_header_path_$3)
1300 CF_ADD_LIBDIR($cf_cv_library_path_$3)
1304 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1307 dnl ---------------------------------------------------------------------------
1308 dnl CF_FUNC_DLSYM version: 2 updated: 2010/05/29 16:31:02
1310 dnl Test for dlsym() and related functions, as well as libdl.
1315 AC_DEFUN([CF_FUNC_DLSYM],[
1317 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
1320 AC_CHECK_LIB(dl,dlsym,[
1322 cf_have_libdl=yes])])
1324 if test "$cf_have_dlsym" = yes ; then
1325 test "$cf_have_libdl" = yes && CF_ADD_LIB(dl)
1327 AC_MSG_CHECKING(whether able to link to dl*() functions)
1328 AC_TRY_LINK([#include <dlfcn.h>],[
1330 if ((obj = dlopen("filename", 0)) != 0) {
1331 if (dlsym(obj, "symbolname") == 0) {
1335 AC_DEFINE(HAVE_LIBDL)],[
1336 AC_MSG_ERROR(Cannot link test program for libdl)])
1339 AC_MSG_ERROR(Cannot find dlsym function)
1342 dnl ---------------------------------------------------------------------------
1343 dnl CF_FUNC_MEMMOVE version: 7 updated: 2006/12/16 12:33:30
1345 dnl Check for memmove, or a bcopy that can handle overlapping copy. If neither
1346 dnl is found, add our own version of memmove to the list of objects.
1347 AC_DEFUN([CF_FUNC_MEMMOVE],
1349 AC_CHECK_FUNC(memmove,,[
1350 AC_CHECK_FUNC(bcopy,[
1351 AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
1354 static char data[] = "abcdefghijklmnopqrstuwwxyz";
1356 bcopy(data, temp, sizeof(data));
1357 bcopy(temp+10, temp, 15);
1358 bcopy(temp+5, temp+15, 10);
1359 ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
1362 [cf_cv_good_bcopy=yes],
1363 [cf_cv_good_bcopy=no],
1364 [cf_cv_good_bcopy=unknown])
1366 ],[cf_cv_good_bcopy=no])
1367 if test "$cf_cv_good_bcopy" = yes ; then
1368 AC_DEFINE(USE_OK_BCOPY)
1370 AC_DEFINE(USE_MY_MEMMOVE)
1373 dnl ---------------------------------------------------------------------------
1374 dnl CF_FUNC_NANOSLEEP version: 3 updated: 2006/12/16 12:33:30
1375 dnl -----------------
1376 dnl Check for existence of workable nanosleep() function. Some systems, e.g.,
1377 dnl AIX 4.x, provide a non-working version.
1378 AC_DEFUN([CF_FUNC_NANOSLEEP],[
1379 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
1385 #ifdef HAVE_SYS_TIME_H
1386 #include <sys/time.h>
1390 struct timespec ts1, ts2;
1393 ts1.tv_nsec = 750000000;
1397 code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
1398 ${cf_cv_main_return:-return}(code != 0);
1401 [cf_cv_func_nanosleep=yes],
1402 [cf_cv_func_nanosleep=no],
1403 [cf_cv_func_nanosleep=unknown])])
1405 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP)
1407 dnl ---------------------------------------------------------------------------
1408 dnl CF_FUNC_OPENPTY version: 3 updated: 2010/05/29 16:31:02
1410 dnl Check for openpty() function, along with <pty.h> header. It may need the
1411 dnl "util" library as well.
1412 AC_DEFUN([CF_FUNC_OPENPTY],
1414 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1415 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1416 cf_save_LIBS="$LIBS"
1417 test $cf_cv_lib_util = yes && CF_ADD_LIB(util)
1418 for cf_header in pty.h libutil.h util.h
1421 #include <$cf_header>
1423 int x = openpty((int *)0, (int *)0, (char *)0,
1424 (struct termios *)0, (struct winsize *)0);
1426 cf_cv_func_openpty=$cf_header
1429 cf_cv_func_openpty=no
1432 LIBS="$cf_save_LIBS"
1435 dnl ---------------------------------------------------------------------------
1436 dnl CF_FUNC_POLL version: 4 updated: 2006/12/16 12:33:30
1438 dnl See if the poll function really works. Some platforms have poll(), but
1439 dnl it does not work for terminals or files.
1440 AC_DEFUN([CF_FUNC_POLL],[
1441 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1447 #include <sys/poll.h>
1450 struct pollfd myfds;
1454 myfds.events = POLLIN;
1456 ret = poll(&myfds, 1, 100);
1457 ${cf_cv_main_return:-return}(ret != 0);
1459 [cf_cv_working_poll=yes],
1460 [cf_cv_working_poll=no],
1461 [cf_cv_working_poll=unknown])])
1462 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
1464 dnl ---------------------------------------------------------------------------
1465 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
1467 dnl Some old/broken variations define tcgetattr() only as a macro in
1469 AC_DEFUN([CF_FUNC_TERMIOS],[
1470 AC_REQUIRE([CF_STRUCT_TERMIOS])
1471 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1473 #include <sys/types.h>
1474 #ifdef HAVE_UNISTD_H
1477 #ifdef HAVE_TERMIOS_H
1478 #include <termios.h>
1479 #define TTY struct termios
1481 #ifdef HAVE_TERMIO_H
1483 #define TTY struct termio
1488 tcgetattr(1, &foo);],
1489 [cf_cv_have_tcgetattr=yes],
1490 [cf_cv_have_tcgetattr=no])])
1491 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
1493 dnl ---------------------------------------------------------------------------
1494 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
1496 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1497 dnl versions of C. It is in the GNU C library, and can often be simulated by
1498 dnl other functions.
1499 AC_DEFUN([CF_FUNC_VSSCANF],
1501 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1504 #include <stdio.h>],[
1506 vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1509 #include <stdio.h>],[
1513 strbuf._flag = _IOREAD;
1514 strbuf._ptr = strbuf._base = (unsigned char *) str;
1515 strbuf._cnt = strlen(str);
1516 strbuf._file = _NFILE;
1517 return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1520 #include <stdio.h>],[
1524 strbuf._flag = _IOREAD;
1525 strbuf._ptr = strbuf._base = (unsigned char *) str;
1526 strbuf._cnt = strlen(str);
1527 strbuf._file = _NFILE;
1528 return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1529 cf_cv_func_vsscanf=no])])])])
1531 case $cf_cv_func_vsscanf in #(vi
1532 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
1533 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
1534 _doscan) AC_DEFINE(HAVE__DOSCAN);;
1538 dnl ---------------------------------------------------------------------------
1539 dnl CF_GCC_ATTRIBUTES version: 14 updated: 2010/10/23 15:52:32
1540 dnl -----------------
1541 dnl Test for availability of useful gcc __attribute__ directives to quiet
1542 dnl compiler warnings. Though useful, not all are supported -- and contrary
1543 dnl to documentation, unrecognized directives cause older compilers to barf.
1544 AC_DEFUN([CF_GCC_ATTRIBUTES],
1546 if test "$GCC" = yes
1548 cat > conftest.i <<EOF
1550 #define GCC_PRINTF 0
1555 #ifndef GCC_NORETURN
1556 #define GCC_NORETURN /* nothing */
1559 #define GCC_UNUSED /* nothing */
1562 if test "$GCC" = yes
1564 AC_CHECKING([for $CC __attribute__ directives])
1565 cat > conftest.$ac_ext <<EOF
1566 #line __oline__ "${as_me:-configure}"
1567 #include "confdefs.h"
1568 #include "conftest.h"
1569 #include "conftest.i"
1571 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1573 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1576 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1578 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
1580 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1581 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1582 extern void foo(void) GCC_NORETURN;
1583 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1585 cf_printf_attribute=no
1586 cf_scanf_attribute=no
1587 for cf_attribute in scanf printf unused noreturn
1589 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1590 cf_directive="__attribute__(($cf_attribute))"
1591 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1593 case $cf_attribute in #(vi
1595 cf_printf_attribute=yes
1596 cat >conftest.h <<EOF
1597 #define GCC_$cf_ATTRIBUTE 1
1601 cf_scanf_attribute=yes
1602 cat >conftest.h <<EOF
1603 #define GCC_$cf_ATTRIBUTE 1
1607 cat >conftest.h <<EOF
1608 #define GCC_$cf_ATTRIBUTE $cf_directive
1613 if AC_TRY_EVAL(ac_compile); then
1614 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1615 cat conftest.h >>confdefs.h
1616 case $cf_attribute in #(vi
1618 if test "$cf_printf_attribute" = no ; then
1619 cat >>confdefs.h <<EOF
1620 #define GCC_PRINTFLIKE(fmt,var) /* nothing */
1623 cat >>confdefs.h <<EOF
1624 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1629 if test "$cf_scanf_attribute" = no ; then
1630 cat >>confdefs.h <<EOF
1631 #define GCC_SCANFLIKE(fmt,var) /* nothing */
1634 cat >>confdefs.h <<EOF
1635 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1643 fgrep define conftest.i >>confdefs.h
1648 dnl ---------------------------------------------------------------------------
1649 dnl CF_GCC_VERSION version: 5 updated: 2010/04/24 11:02:31
1651 dnl Find version of gcc
1652 AC_DEFUN([CF_GCC_VERSION],[
1653 AC_REQUIRE([AC_PROG_CC])
1655 if test "$GCC" = yes ; then
1656 AC_MSG_CHECKING(version of $CC)
1657 GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1658 test -z "$GCC_VERSION" && GCC_VERSION=unknown
1659 AC_MSG_RESULT($GCC_VERSION)
1662 dnl ---------------------------------------------------------------------------
1663 dnl CF_GCC_WARNINGS version: 27 updated: 2010/10/23 15:52:32
1665 dnl Check if the compiler supports useful warning options. There's a few that
1666 dnl we don't use, simply because they're too noisy:
1668 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1669 dnl -Wredundant-decls (system headers make this too noisy)
1670 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
1671 dnl -Wwrite-strings (too noisy, but should review occasionally). This
1672 dnl is enabled for ncurses using "--enable-const".
1676 dnl $1 is an optional list of gcc warning flags that a particular
1677 dnl application might want to use, e.g., "no-unused" for
1680 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1682 AC_DEFUN([CF_GCC_WARNINGS],
1684 AC_REQUIRE([CF_GCC_VERSION])
1685 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1687 cat > conftest.$ac_ext <<EOF
1688 #line __oline__ "${as_me:-configure}"
1689 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1692 if test "$INTEL_COMPILER" = yes
1694 # The "-wdXXX" options suppress warnings:
1695 # remark #1419: external declaration in primary source file
1696 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1697 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1698 # remark #193: zero used for undefined preprocessing identifier
1699 # remark #593: variable "curs_sb_left_arrow" was set but never used
1700 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1701 # remark #869: parameter "tw" was never referenced
1702 # remark #981: operands are evaluated in unspecified order
1703 # warning #279: controlling expression is constant
1705 AC_CHECKING([for $CC warning options])
1706 cf_save_CFLAGS="$CFLAGS"
1707 EXTRA_CFLAGS="-Wall"
1719 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1720 if AC_TRY_EVAL(ac_compile); then
1721 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1722 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1725 CFLAGS="$cf_save_CFLAGS"
1727 elif test "$GCC" = yes
1729 AC_CHECKING([for $CC warning options])
1730 cf_save_CFLAGS="$CFLAGS"
1733 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1734 for cf_opt in W Wall \
1735 Wbad-function-cast \
1739 Wmissing-declarations \
1740 Wmissing-prototypes \
1744 Wstrict-prototypes \
1745 Wundef $cf_warn_CONST $1
1747 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1748 if AC_TRY_EVAL(ac_compile); then
1749 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1750 case $cf_opt in #(vi
1752 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1755 case $GCC_VERSION in
1757 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1762 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1765 CFLAGS="$cf_save_CFLAGS"
1769 AC_SUBST(EXTRA_CFLAGS)
1771 dnl ---------------------------------------------------------------------------
1772 dnl CF_GNAT_GENERICS version: 2 updated: 2011/03/23 20:24:41
1773 dnl ----------------
1774 AC_DEFUN([CF_GNAT_GENERICS],
1776 AC_REQUIRE([CF_GNAT_VERSION])
1778 AC_MSG_CHECKING(if GNAT supports generics)
1779 case $cf_gnat_version in #(vi
1780 3.[[1-9]]*|[[4-9]].*) #(vi
1781 cf_gnat_generics=yes
1787 AC_MSG_RESULT($cf_gnat_generics)
1789 if test "$cf_gnat_generics" = yes
1791 cf_compile_generics=generics
1792 cf_generic_objects="\${GENOBJS}"
1794 cf_compile_generics=
1798 AC_SUBST(cf_compile_generics)
1799 AC_SUBST(cf_generic_objects)
1801 dnl ---------------------------------------------------------------------------
1802 dnl CF_GNAT_PRAGMA_UNREF version: 1 updated: 2010/06/19 15:22:18
1803 dnl --------------------
1804 dnl Check if the gnat pragma "Unreferenced" works.
1805 AC_DEFUN([CF_GNAT_PRAGMA_UNREF],[
1806 AC_CACHE_CHECK(if GNAT pragma Unreferenced works,cf_cv_pragma_unreferenced,[
1807 CF_GNAT_TRY_LINK([procedure conftest;],
1810 procedure conftest is
1812 pragma Unreferenced (test);
1815 Text_IO.Put ("Hello World");
1817 GNAT.OS_Lib.OS_Exit (0);
1819 [cf_cv_pragma_unreferenced=yes],
1820 [cf_cv_pragma_unreferenced=no])])
1822 # if the pragma is supported, use it (needed in the Trace code).
1823 if test $cf_cv_pragma_unreferenced = yes ; then
1828 AC_SUBST(PRAGMA_UNREF)
1830 dnl ---------------------------------------------------------------------------
1831 dnl CF_GNAT_PROJECTS version: 2 updated: 2011/03/23 20:24:41
1832 dnl ----------------
1833 dnl GNAT projects are configured with ".gpr" project files.
1834 dnl GNAT libraries are a further development, using the project feature.
1835 AC_DEFUN([CF_GNAT_PROJECTS],
1837 AC_REQUIRE([CF_GNAT_VERSION])
1839 cf_gnat_libraries=no
1842 AC_MSG_CHECKING(if GNAT supports project files)
1843 case $cf_gnat_version in #(vi
1847 case $cf_cv_system_name in #(vi
1851 mkdir conftest.src conftest.bin conftest.lib
1853 rm -rf conftest* *~conftest*
1854 cat >>library.gpr <<CF_EOF
1856 Kind := External ("LIB_KIND");
1857 for Library_Name use "ConfTest";
1858 for Object_Dir use ".";
1859 for Library_ALI_Dir use External("LIBRARY_DIR");
1860 for Library_Version use External ("SONAME");
1861 for Library_Kind use Kind;
1862 for Library_Dir use External("BUILD_DIR");
1863 Source_Dir := External ("SOURCE_DIR");
1864 for Source_Dirs use (Source_Dir);
1866 for Default_Switches ("Ada") use
1870 "-gnatVa", -- All validity checks
1871 "-gnatwa"); -- Activate all optional errors
1875 cat >>confpackage.ads <<CF_EOF
1876 package ConfPackage is
1880 cat >>confpackage.adb <<CF_EOF
1882 package body ConfPackage is
1883 procedure conftest is
1885 Text_IO.Put ("Hello World");
1890 if ( $cf_ada_make $ADAFLAGS \
1892 -XBUILD_DIR=`cd ../conftest.bin;pwd` \
1893 -XLIBRARY_DIR=`cd ../conftest.lib;pwd` \
1894 -XSOURCE_DIR=`pwd` \
1895 -XSONAME=libConfTest.so.1 \
1896 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
1897 cf_gnat_projects=yes
1900 if test -f conftest.lib/confpackage.ali
1902 cf_gnat_libraries=yes
1904 rm -rf conftest* *~conftest*
1909 AC_MSG_RESULT($cf_gnat_projects)
1911 if test $cf_gnat_projects = yes
1913 AC_MSG_CHECKING(if GNAT supports libraries)
1914 AC_MSG_RESULT($cf_gnat_libraries)
1917 if test "$cf_gnat_projects" = yes
1919 USE_OLD_MAKERULES="#"
1920 USE_GNAT_PROJECTS=""
1922 USE_OLD_MAKERULES=""
1923 USE_GNAT_PROJECTS="#"
1926 if test "$cf_gnat_libraries" = yes
1928 USE_GNAT_LIBRARIES=""
1930 USE_GNAT_LIBRARIES="#"
1933 AC_SUBST(USE_OLD_MAKERULES)
1934 AC_SUBST(USE_GNAT_PROJECTS)
1935 AC_SUBST(USE_GNAT_LIBRARIES)
1937 dnl ---------------------------------------------------------------------------
1938 dnl CF_GNAT_SIGINT version: 1 updated: 2011/03/27 20:07:59
1940 dnl Check if gnat supports SIGINT, and presumably tasking. For the latter, it
1941 dnl is noted that gnat may compile a tasking unit even for configurations which
1942 dnl fail at runtime.
1943 AC_DEFUN([CF_GNAT_SIGINT],[
1944 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
1945 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
1949 pragma Warnings (Off); -- the next pragma exists since 3.11p
1950 pragma Unreserve_All_Interrupts;
1951 pragma Warnings (On);
1953 protected Process is
1955 function Continue return Boolean;
1956 pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
1958 Done : Boolean := False;
1962 [package body ConfTest is
1963 protected body Process is
1968 function Continue return Boolean is
1974 [cf_cv_gnat_sigint=yes],
1975 [cf_cv_gnat_sigint=no])])
1977 if test $cf_cv_gnat_sigint = yes ; then
1982 AC_SUBST(USE_GNAT_SIGINT)
1984 dnl ---------------------------------------------------------------------------
1985 dnl CF_GNAT_TRY_LINK version: 3 updated: 2011/03/19 14:47:45
1986 dnl ----------------
1987 dnl Verify that a test program compiles/links with GNAT.
1988 dnl $cf_ada_make is set to the program that compiles/links
1989 dnl $ADAFLAGS may be set to the GNAT flags.
1991 dnl $1 is the text of the spec
1992 dnl $2 is the text of the body
1993 dnl $3 is the shell command to execute if successful
1994 dnl $4 is the shell command to execute if not successful
1995 AC_DEFUN([CF_GNAT_TRY_LINK],
1997 rm -rf conftest* *~conftest*
1998 cat >>conftest.ads <<CF_EOF
2001 cat >>conftest.adb <<CF_EOF
2004 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
2005 ifelse($3,, :,[ $3])
2009 rm -rf conftest* *~conftest*
2011 dnl ---------------------------------------------------------------------------
2012 dnl CF_GNAT_TRY_RUN version: 5 updated: 2011/03/19 14:47:45
2014 dnl Verify that a test program compiles and runs with GNAT
2015 dnl $cf_ada_make is set to the program that compiles/links
2016 dnl $ADAFLAGS may be set to the GNAT flags.
2018 dnl $1 is the text of the spec
2019 dnl $2 is the text of the body
2020 dnl $3 is the shell command to execute if successful
2021 dnl $4 is the shell command to execute if not successful
2022 AC_DEFUN([CF_GNAT_TRY_RUN],
2024 rm -rf conftest* *~conftest*
2025 cat >>conftest.ads <<CF_EOF
2028 cat >>conftest.adb <<CF_EOF
2031 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
2032 if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
2033 ifelse($3,, :,[ $3])
2040 rm -rf conftest* *~conftest*
2042 dnl ---------------------------------------------------------------------------
2043 dnl CF_GNAT_VERSION version: 17 updated: 2011/03/23 20:24:41
2045 dnl Verify version of GNAT.
2046 AC_DEFUN([CF_GNAT_VERSION],
2048 AC_MSG_CHECKING(for gnat version)
2049 cf_gnat_version=`${cf_ada_make:-gnatmake} -v 2>&1 | \
2050 grep '[[0-9]].[[0-9]][[0-9]]*' |\
2051 sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
2052 AC_MSG_RESULT($cf_gnat_version)
2054 case $cf_gnat_version in #(vi
2055 3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*) #(vi
2056 cf_cv_prog_gnat_correct=yes
2059 AC_MSG_WARN(Unsupported GNAT version $cf_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
2060 cf_cv_prog_gnat_correct=no
2064 dnl ---------------------------------------------------------------------------
2065 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
2067 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
2068 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
2069 dnl (or misfeature) of glibc2, which breaks portability of many applications,
2070 dnl since it is interwoven with GNU extensions.
2072 dnl Well, yes we could work around it...
2073 AC_DEFUN([CF_GNU_SOURCE],
2075 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
2076 AC_TRY_COMPILE([#include <sys/types.h>],[
2077 #ifndef _XOPEN_SOURCE
2080 [cf_cv_gnu_source=no],
2081 [cf_save="$CPPFLAGS"
2082 CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
2083 AC_TRY_COMPILE([#include <sys/types.h>],[
2084 #ifdef _XOPEN_SOURCE
2087 [cf_cv_gnu_source=no],
2088 [cf_cv_gnu_source=yes])
2092 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
2094 dnl ---------------------------------------------------------------------------
2095 dnl CF_GPP_LIBRARY version: 10 updated: 2010/05/29 16:31:02
2097 dnl If we're trying to use g++, test if libg++ is installed (a rather common
2098 dnl problem :-). If we have the compiler but no library, we'll be able to
2099 dnl configure, but won't be able to build the c++ demo program.
2100 AC_DEFUN([CF_GPP_LIBRARY],
2102 cf_cxx_library=unknown
2103 case $cf_cv_system_name in #(vi
2111 if test "$GXX" = yes; then
2112 AC_MSG_CHECKING([for lib$cf_gpp_libname])
2114 CF_ADD_LIB($cf_gpp_libname)
2116 #include <$cf_gpp_libname/builtin.h>
2118 [two_arg_error_handler_t foo2 = lib_error_handler],
2120 CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
2121 if test "$cf_gpp_libname" = cpp ; then
2122 AC_DEFINE(HAVE_GPP_BUILTIN_H)
2124 AC_DEFINE(HAVE_GXX_BUILTIN_H)
2127 #include <builtin.h>
2129 [two_arg_error_handler_t foo2 = lib_error_handler],
2131 CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
2132 AC_DEFINE(HAVE_BUILTIN_H)],
2133 [cf_cxx_library=no])])
2135 AC_MSG_RESULT($cf_cxx_library)
2138 dnl ---------------------------------------------------------------------------
2139 dnl CF_GXX_VERSION version: 6 updated: 2010/10/23 15:44:18
2141 dnl Check for version of g++
2142 AC_DEFUN([CF_GXX_VERSION],[
2143 AC_REQUIRE([AC_PROG_CPP])
2145 if test "$GXX" = yes; then
2146 AC_MSG_CHECKING(version of g++)
2147 GXX_VERSION="`${CXX:-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
2148 test -z "$GXX_VERSION" && GXX_VERSION=unknown
2149 AC_MSG_RESULT($GXX_VERSION)
2152 dnl ---------------------------------------------------------------------------
2153 dnl CF_GXX_WARNINGS version: 6 updated: 2010/08/14 18:25:37
2155 dnl Check if the compiler supports useful warning options.
2157 dnl Most of gcc's options apply to g++, except:
2158 dnl -Wbad-function-cast
2159 dnl -Wmissing-declarations
2160 dnl -Wnested-externs
2162 dnl Omit a few (for now):
2166 dnl $1 is an optional list of g++ warning flags that a particular
2167 dnl application might want to use, e.g., "no-unused" for
2170 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
2172 AC_DEFUN([CF_GXX_WARNINGS],
2175 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
2177 AC_REQUIRE([CF_GXX_VERSION])
2182 cat > conftest.$ac_ext <<EOF
2183 #line __oline__ "configure"
2184 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2187 if test "$INTEL_CPLUSPLUS" = yes
2189 # The "-wdXXX" options suppress warnings:
2190 # remark #1419: external declaration in primary source file
2191 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2192 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2193 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2194 # remark #193: zero used for undefined preprocessing identifier
2195 # remark #593: variable "curs_sb_left_arrow" was set but never used
2196 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2197 # remark #869: parameter "tw" was never referenced
2198 # remark #981: operands are evaluated in unspecified order
2199 # warning #269: invalid format string conversion
2201 AC_CHECKING([for $CC warning options])
2202 cf_save_CXXFLAGS="$CXXFLAGS"
2203 EXTRA_CXXFLAGS="-Wall"
2216 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
2217 if AC_TRY_EVAL(ac_compile); then
2218 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2219 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2222 CXXFLAGS="$cf_save_CXXFLAGS"
2224 elif test "$GXX" = yes
2226 AC_CHECKING([for $CXX warning options])
2227 cf_save_CXXFLAGS="$CXXFLAGS"
2228 EXTRA_CXXFLAGS="-W -Wall"
2229 cf_gxx_extra_warnings=""
2230 test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
2231 case "$GCC_VERSION" in
2235 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
2241 Woverloaded-virtual \
2247 Wmissing-prototypes \
2250 Wstrict-prototypes \
2251 Wundef $cf_gxx_extra_warnings $1
2253 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
2254 if AC_TRY_EVAL(ac_compile); then
2255 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2256 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2258 test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
2261 CXXFLAGS="$cf_save_CXXFLAGS"
2266 AC_SUBST(EXTRA_CXXFLAGS)
2268 dnl ---------------------------------------------------------------------------
2269 dnl CF_HASHED_DB version: 4 updated: 2010/05/29 16:31:02
2271 dnl Look for an instance of the Berkeley hashed database.
2273 dnl $1 = optional parameter, to specify install-prefix for the database.
2274 AC_DEFUN([CF_HASHED_DB],
2281 if test -d "$1" ; then
2282 CF_ADD_INCDIR($1/include)
2283 CF_ADD_LIBDIR($1/lib)
2287 AC_CHECK_HEADER(db.h,[
2288 CF_HASHED_DB_VERSION
2289 if test "$cf_cv_hashed_db_version" = unknown ; then
2290 AC_MSG_ERROR(Cannot determine version of db)
2293 if test "$cf_cv_hashed_db_libs" = unknown ; then
2294 AC_MSG_ERROR(Cannot determine library for db)
2295 elif test "$cf_cv_hashed_db_libs" != default ; then
2296 CF_ADD_LIB($cf_cv_hashed_db_libs)
2300 AC_MSG_ERROR(Cannot find db.h)
2303 dnl ---------------------------------------------------------------------------
2304 dnl CF_HASHED_DB_LIBS version: 9 updated: 2010/05/29 16:31:02
2305 dnl -----------------
2306 dnl Given that we have the header and version for hashed database, find the
2307 dnl library information.
2308 AC_DEFUN([CF_HASHED_DB_LIBS],
2310 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
2311 cf_cv_hashed_db_libs=unknown
2312 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
2314 cf_save_libs="$LIBS"
2315 if test -n "$cf_db_libs"; then
2316 CF_ADD_LIB($cf_db_libs)
2318 CF_MSG_LOG(checking for library "$cf_db_libs")
2320 $ac_includes_default
2323 char *path = "/tmp/foo";
2324 #ifdef DB_VERSION_MAJOR
2325 #if DB_VERSION_MAJOR >= 4
2327 db_create(&result, NULL, 0);
2328 result->open(result,
2335 #elif DB_VERSION_MAJOR >= 3
2337 db_create(&result, NULL, 0);
2338 result->open(result,
2344 #elif DB_VERSION_MAJOR >= 2
2353 #endif /* DB_VERSION_MAJOR */
2355 DB *result = dbopen(path,
2361 ${cf_cv_main_return:-return}(result != 0)
2363 if test -n "$cf_db_libs" ; then
2364 cf_cv_hashed_db_libs=$cf_db_libs
2366 cf_cv_hashed_db_libs=default
2368 LIBS="$cf_save_libs"
2371 LIBS="$cf_save_libs"
2375 dnl ---------------------------------------------------------------------------
2376 dnl CF_HASHED_DB_VERSION version: 3 updated: 2007/12/01 15:01:37
2377 dnl --------------------
2378 dnl Given that we have the header file for hashed database, find the version
2380 AC_DEFUN([CF_HASHED_DB_VERSION],
2382 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
2383 cf_cv_hashed_db_version=unknown
2385 for cf_db_version in 1 2 3 4 5
2387 CF_MSG_LOG(checking for db version $cf_db_version)
2389 $ac_includes_default
2392 #ifdef DB_VERSION_MAJOR
2393 /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
2394 #if $cf_db_version == DB_VERSION_MAJOR
2400 #if $cf_db_version == 1
2401 /* ok: assuming this is DB 1.8.5 */
2407 cf_cv_hashed_db_version=$cf_db_version
2413 dnl ---------------------------------------------------------------------------
2414 dnl CF_HEADER_PATH version: 12 updated: 2010/05/05 05:22:40
2416 dnl Construct a search-list of directories for a nonstandard header-file
2419 dnl $1 = the variable to return as result
2420 dnl $2 = the package name
2421 AC_DEFUN([CF_HEADER_PATH],
2425 # collect the current set of include-directories from compiler flags
2426 cf_header_path_list=""
2427 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2428 for cf_header_path in $CPPFLAGS $CFLAGS
2430 case $cf_header_path in #(vi
2432 cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2433 CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2434 cf_header_path_list="$cf_header_path_list [$]$1"
2440 # add the variations for the package we are looking for
2441 CF_SUBDIR_PATH($1,$2,include)
2443 test "$includedir" != NONE && \
2444 test "$includedir" != "/usr/include" && \
2445 test -d "$includedir" && {
2446 test -d $includedir && $1="[$]$1 $includedir"
2447 test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
2450 test "$oldincludedir" != NONE && \
2451 test "$oldincludedir" != "/usr/include" && \
2452 test -d "$oldincludedir" && {
2453 test -d $oldincludedir && $1="[$]$1 $oldincludedir"
2454 test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
2457 $1="[$]$1 $cf_header_path_list"
2459 dnl ---------------------------------------------------------------------------
2460 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
2462 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2463 AC_DEFUN([CF_HELP_MESSAGE],
2464 [AC_DIVERT_HELP([$1])dnl
2466 dnl ---------------------------------------------------------------------------
2467 dnl CF_INCLUDE_DIRS version: 6 updated: 2009/01/06 19:37:40
2469 dnl Construct the list of include-options according to whether we're building
2470 dnl in the source directory or using '--srcdir=DIR' option. If we're building
2471 dnl with gcc, don't append the includedir if it happens to be /usr/include,
2472 dnl since that usually breaks gcc's shadow-includes.
2473 AC_DEFUN([CF_INCLUDE_DIRS],
2475 CPPFLAGS="$CPPFLAGS -I. -I../include"
2476 if test "$srcdir" != "."; then
2477 CPPFLAGS="$CPPFLAGS -I\${srcdir}/../include"
2479 if test "$GCC" != yes; then
2480 CPPFLAGS="$CPPFLAGS -I\${includedir}"
2481 elif test "$includedir" != "/usr/include"; then
2482 if test "$includedir" = '${prefix}/include' ; then
2483 if test $prefix != /usr ; then
2484 CPPFLAGS="$CPPFLAGS -I\${includedir}"
2487 CPPFLAGS="$CPPFLAGS -I\${includedir}"
2492 dnl ---------------------------------------------------------------------------
2493 dnl CF_INTEL_COMPILER version: 4 updated: 2010/05/26 05:38:42
2494 dnl -----------------
2495 dnl Check if the given compiler is really the Intel compiler for Linux. It
2496 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2497 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2499 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2500 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
2501 dnl the wrappers for gcc and g++ warnings.
2503 dnl $1 = GCC (default) or GXX
2504 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2505 dnl $3 = CFLAGS (default) or CXXFLAGS
2506 AC_DEFUN([CF_INTEL_COMPILER],[
2507 ifelse([$2],,INTEL_COMPILER,[$2])=no
2509 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2512 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2513 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2514 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2516 #ifdef __INTEL_COMPILER
2520 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2521 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
2523 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2524 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2529 dnl ---------------------------------------------------------------------------
2530 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
2532 dnl Check if we have either a function or macro for 'isascii()'.
2533 AC_DEFUN([CF_ISASCII],
2535 AC_MSG_CHECKING(for isascii)
2536 AC_CACHE_VAL(cf_cv_have_isascii,[
2537 AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
2538 [cf_cv_have_isascii=yes],
2539 [cf_cv_have_isascii=no])
2541 AC_MSG_RESULT($cf_cv_have_isascii)
2542 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
2544 dnl ---------------------------------------------------------------------------
2545 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
2547 dnl Add checks for large file support.
2548 AC_DEFUN([CF_LARGEFILE],[
2549 ifdef([AC_FUNC_FSEEKO],[
2551 if test "$enable_largefile" != no ; then
2554 # Normally we would collect these definitions in the config.h,
2555 # but (like _XOPEN_SOURCE), some environments rely on having these
2556 # defined before any of the system headers are included. Another
2557 # case comes up with C++, e.g., on AIX the compiler compiles the
2558 # header files by themselves before looking at the body files it is
2559 # told to compile. For ncurses, those header files do not include
2561 test "$ac_cv_sys_large_files" != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
2562 test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
2563 test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
2565 AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2567 #include <sys/types.h>
2570 /* if transitional largefile support is setup, this is true */
2571 extern struct dirent64 * readdir(DIR *);
2572 struct dirent64 *x = readdir((DIR *)0);
2573 struct dirent *y = readdir((DIR *)0);
2576 [cf_cv_struct_dirent64=yes],
2577 [cf_cv_struct_dirent64=no])
2579 test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
2583 dnl ---------------------------------------------------------------------------
2584 dnl CF_LDFLAGS_STATIC version: 8 updated: 2010/10/23 14:39:56
2585 dnl -----------------
2586 dnl Check for compiler/linker flags used to temporarily force usage of static
2587 dnl libraries. This depends on the compiler and platform. Use this to help
2588 dnl ensure that the linker picks up a given library based on its position in
2589 dnl the list of linker options and libraries.
2590 AC_DEFUN([CF_LDFLAGS_STATIC],[
2592 if test "$GCC" = yes ; then
2593 case $cf_cv_system_name in #(
2594 OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*) #( vi
2598 *) #( normally, except when broken
2599 LDFLAGS_STATIC=-static
2600 LDFLAGS_SHARED=-dynamic
2604 case $cf_cv_system_name in #(
2605 aix[[456]]*) #( from ld manpage
2606 LDFLAGS_STATIC=-bstatic
2607 LDFLAGS_SHARED=-bdynamic
2609 hpux*) #( from ld manpage for hpux10.20, hpux11.11
2610 # We could also use just "archive" and "shared".
2611 LDFLAGS_STATIC=-Wl,-a,archive_shared
2612 LDFLAGS_SHARED=-Wl,-a,shared_archive
2614 irix*) #( from ld manpage IRIX64
2615 LDFLAGS_STATIC=-Bstatic
2616 LDFLAGS_SHARED=-Bdynamic
2618 osf[[45]]*) #( from ld manpage osf4.0d, osf5.1
2619 # alternative "-oldstyle_liblookup" (not in cc manpage)
2620 LDFLAGS_STATIC=-noso
2621 LDFLAGS_SHARED=-so_archive
2624 LDFLAGS_STATIC=-Bstatic
2625 LDFLAGS_SHARED=-Bdynamic
2630 if test -n "$LDFLAGS_STATIC" && test -n "$LDFLAGS_SHARED"
2632 AC_MSG_CHECKING(if linker supports switching between static/dynamic)
2635 cat >conftest.$ac_ext <<EOF
2636 #line __oline__ "configure"
2638 int cf_ldflags_static(FILE *fp) { return fflush(fp); }
2640 if AC_TRY_EVAL(ac_compile) ; then
2641 ( $AR $ARFLAGS libconftest.a conftest.o ) 2>&AC_FD_CC 1>/dev/null
2642 ( eval $RANLIB libconftest.a ) 2>&AC_FD_CC >/dev/null
2646 cf_save_LIBS="$LIBS"
2648 LIBS="$LDFLAGS_STATIC -L`pwd` -lconftest $LDFLAGS_DYNAMIC $LIBS"
2650 #line __oline__ "configure"
2652 int cf_ldflags_static(FILE *fp);
2654 return cf_ldflags_static(stdin);
2655 ],[cf_ldflags_static=yes],[cf_ldflags_static=no])
2658 LIBS="$cf_save_LIBS"
2660 AC_MSG_RESULT($cf_ldflags_static)
2662 if test $cf_ldflags_static != yes
2672 AC_SUBST(LDFLAGS_STATIC)
2673 AC_SUBST(LDFLAGS_SHARED)
2675 dnl ---------------------------------------------------------------------------
2676 dnl CF_LD_RPATH_OPT version: 3 updated: 2010/06/02 05:03:05
2678 dnl For the given system and compiler, find the compiler flags to pass to the
2679 dnl loader to use the "rpath" feature.
2680 AC_DEFUN([CF_LD_RPATH_OPT],
2682 AC_REQUIRE([CF_CHECK_CACHE])
2685 AC_MSG_CHECKING(for an rpath option)
2686 case $cf_cv_system_name in #(vi
2688 if test "$GCC" = yes; then
2689 LD_RPATH_OPT="-Wl,-rpath,"
2691 LD_RPATH_OPT="-rpath "
2694 linux*|gnu*|k*bsd*-gnu) #(vi
2695 LD_RPATH_OPT="-Wl,-rpath,"
2697 openbsd[[2-9]].*) #(vi
2698 LD_RPATH_OPT="-Wl,-rpath,"
2701 LD_RPATH_OPT="-rpath "
2704 LD_RPATH_OPT="-Wl,-rpath,"
2707 LD_RPATH_OPT="-rpath "
2715 AC_MSG_RESULT($LD_RPATH_OPT)
2717 case "x$LD_RPATH_OPT" in #(vi
2719 AC_MSG_CHECKING(if we need a space after rpath option)
2720 cf_save_LIBS="$LIBS"
2721 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2722 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2723 LIBS="$cf_save_LIBS"
2724 AC_MSG_RESULT($cf_rpath_space)
2725 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2729 dnl ---------------------------------------------------------------------------
2730 dnl CF_LIBRARY_PATH version: 9 updated: 2010/03/28 12:52:50
2732 dnl Construct a search-list of directories for a nonstandard library-file
2735 dnl $1 = the variable to return as result
2736 dnl $2 = the package name
2737 AC_DEFUN([CF_LIBRARY_PATH],
2740 cf_library_path_list=""
2741 if test -n "${LDFLAGS}${LIBS}" ; then
2742 for cf_library_path in $LDFLAGS $LIBS
2744 case $cf_library_path in #(vi
2746 cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2747 CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2748 cf_library_path_list="$cf_library_path_list [$]$1"
2754 CF_SUBDIR_PATH($1,$2,lib)
2756 $1="$cf_library_path_list [$]$1"
2758 dnl ---------------------------------------------------------------------------
2759 dnl CF_LIB_PREFIX version: 8 updated: 2008/09/13 11:34:16
2761 dnl Compute the library-prefix for the given host system
2762 dnl $1 = variable to set
2763 AC_DEFUN([CF_LIB_PREFIX],
2765 case $cf_cv_system_name in #(vi
2772 ifelse($1,,,[$1=$LIB_PREFIX])
2773 AC_SUBST(LIB_PREFIX)
2775 dnl ---------------------------------------------------------------------------
2776 dnl CF_LIB_RULES version: 61 updated: 2010/10/23 16:10:30
2778 dnl Append definitions and rules for the given models to the subdirectory
2779 dnl Makefiles, and the recursion rule for the top-level Makefile. If the
2780 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
2781 dnl the corresponding makefile to list the models that we'll generate.
2783 dnl For shared libraries, make a list of symbolic links to construct when
2784 dnl generating each library. The convention used for Linux is the simplest
2787 dnl lib<name>.so.<major> ->
2788 dnl lib<name>.so.<maj>.<minor>
2789 AC_DEFUN([CF_LIB_RULES],
2791 CF_LIB_PREFIX(cf_prefix)
2792 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2794 if test $cf_cv_shlib_version = cygdll ; then
2795 TINFO_NAME=$TINFO_ARG_SUFFIX
2799 if test -n "$TINFO_SUFFIX" ; then
2800 case $TINFO_SUFFIX in
2802 TINFO_NAME="${TINFO_NAME}tw"
2803 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^tw//'`
2806 TINFO_NAME="${TINFO_NAME}t"
2807 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^t//'`
2810 TINFO_NAME="${TINFO_NAME}w"
2811 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^w//'`
2816 for cf_dir in $SRC_SUBDIRS
2818 if test ! -d $srcdir/$cf_dir ; then
2820 elif test -f $srcdir/$cf_dir/modules; then
2824 for cf_item in $cf_LIST_MODELS
2826 CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2827 if test $cf_item = shared ; then
2828 if test "$cf_cv_do_symlinks" = yes ; then
2829 case "$cf_cv_shlib_version" in #(vi
2831 case "$cf_cv_system_name" in #(vi
2833 case .${LIB_SUFFIX} in
2835 cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
2836 cf_suffix=tw'.${REL_VERSION}'"$cf_suffix"
2839 cf_suffix=`echo $cf_suffix | sed 's/^t//'`
2840 cf_suffix=t'.${REL_VERSION}'"$cf_suffix"
2843 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2844 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
2847 cf_suffix='.${REL_VERSION}'"$cf_suffix"
2851 *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
2855 case "$cf_cv_system_name" in #(vi
2857 case .${LIB_SUFFIX} in
2859 cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
2860 cf_suffix=tw'.${ABI_VERSION}'"$cf_suffix"
2863 cf_suffix=`echo $cf_suffix | sed 's/^t//'`
2864 cf_suffix=t'.${ABI_VERSION}'"$cf_suffix"
2867 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2868 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
2871 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
2875 *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
2880 # cygwin needs import library, and has unique naming convention
2881 # use autodetected ${cf_prefix} for import lib and static lib, but
2882 # use 'cyg' prefix for shared lib.
2883 if test $cf_cv_shlib_version = cygdll ; then
2884 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
2885 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}${cf_cygsuf}"
2889 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
2892 if test $cf_dir = ncurses ; then
2893 cf_subsets="$LIB_SUBSETS"
2894 cf_r_parts="$cf_subsets"
2895 cf_liblist="$LIBS_TO_MAKE"
2897 while test -n "$cf_r_parts"
2899 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
2900 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
2901 if test "$cf_l_parts" != "$cf_r_parts" ; then
2903 case $cf_l_parts in #(vi
2905 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
2908 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
2914 if test -n "$cf_item"; then
2915 LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
2922 cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
2925 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
2926 -e "s%@SHARED_LIB@%$SHARED_LIB%" \
2927 $cf_dir/Makefile >$cf_dir/Makefile.out
2928 mv $cf_dir/Makefile.out $cf_dir/Makefile
2930 $AWK -f $srcdir/mk-0th.awk \
2931 libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
2932 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2934 for cf_subset in $cf_subsets
2937 for cf_item in $cf_LIST_MODELS
2939 echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
2940 CF_UPPER(cf_ITEM,$cf_item)
2941 CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2942 CF_OBJ_SUBDIR($cf_item,cf_subdir)
2944 # Test for case where we build libtinfo with a different name.
2946 if test $cf_dir = ncurses ; then
2949 cf_libname=${cf_libname}$LIB_SUFFIX
2952 cf_libname=$TINFO_LIB_SUFFIX
2955 cf_libname=$TICS_LIB_SUFFIX
2959 cf_libname=${cf_libname}$LIB_SUFFIX
2961 if test -n "${DFT_ARG_SUFFIX}" ; then
2962 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2963 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2966 # These dependencies really are for development, not
2967 # builds, but they are useful in porting, too.
2968 cf_depend="../include/ncurses_cfg.h"
2969 if test "$srcdir" = "."; then
2972 cf_reldir="\${srcdir}"
2975 if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
2976 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
2977 elif test -f $srcdir/$cf_dir/curses.priv.h; then
2978 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
2982 old_cf_suffix="$cf_suffix"
2983 if test "$cf_cv_shlib_version_infix" = yes ; then
2984 if test -n "$LIB_SUFFIX" ; then
2987 cf_libname=`echo $cf_libname | sed 's/tw$//'`
2988 cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
2992 cf_libname=`echo $cf_libname | sed 's/t$//'`
2993 cf_suffix=`echo $cf_suffix | sed 's/^t//'`
2997 cf_libname=`echo $cf_libname | sed 's/w$//'`
2998 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
3005 $AWK -f $srcdir/mk-1st.awk \
3006 name=${cf_libname}${cf_dir_suffix} \
3007 traces=$LIB_TRACING \
3014 TermlibRoot=$TINFO_NAME \
3015 TermlibSuffix=$TINFO_SUFFIX \
3016 ShlibVer=$cf_cv_shlib_version \
3017 ShlibVerInfix=$cf_cv_shlib_version_infix \
3018 ReLink=${cf_cv_do_relink:-no} \
3019 DoLinks=$cf_cv_do_symlinks \
3020 rmSoLocs=$cf_cv_rm_so_locs \
3021 ldconfig="$LDCONFIG" \
3022 overwrite=$WITH_OVERWRITE \
3023 depend="$cf_depend" \
3025 libtool_version="$LIBTOOL_VERSION" \
3026 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3028 cf_suffix="$old_cf_suffix"
3030 for cf_subdir2 in $cf_subdirs lib
3032 test $cf_subdir = $cf_subdir2 && break
3034 test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
3035 $AWK -f $srcdir/mk-2nd.awk \
3037 traces=$LIB_TRACING \
3043 crenames=$cf_cv_prog_CC_c_o \
3044 cxxrenames=$cf_cv_prog_CXX_c_o \
3045 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3046 cf_subdirs="$cf_subdirs $cf_subdir"
3051 echo ' cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
3054 for cf_dir in $SRC_SUBDIRS
3056 if test ! -d $srcdir/$cf_dir ; then
3060 if test -f $cf_dir/Makefile ; then
3063 echo 'libs \' >> Makefile
3064 echo 'install.libs \' >> Makefile
3065 echo 'uninstall.libs ::' >> Makefile
3066 echo ' cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
3071 if test -f $srcdir/$cf_dir/modules; then
3073 if test -f $srcdir/$cf_dir/headers; then
3074 cat >> Makefile <<CF_EOF
3076 uninstall.includes \\
3079 if test "$cf_dir" != "c++" ; then
3080 echo 'lint \' >> Makefile
3082 cat >> Makefile <<CF_EOF
3088 uninstall.$cf_dir ::
3089 cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
3091 elif test -f $srcdir/$cf_dir/headers; then
3092 cat >> Makefile <<CF_EOF
3098 uninstall.includes ::
3099 cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
3104 cat >> Makefile <<CF_EOF
3106 install.libs uninstall.libs \\
3107 install.data uninstall.data ::
3108 $MAKE_TERMINFO cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
3111 if test "x$cf_with_manpages" = xyes; then
3112 cat >> Makefile <<CF_EOF
3116 cd man && \${MAKE} \${CF_MFLAGS} \[$]@
3120 cat >> Makefile <<CF_EOF
3123 rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
3124 rm -f headers.sh headers.sed mk_shared_lib.sh
3125 rm -f edit_man.* man_alias.*
3126 rm -rf \${DIRS_TO_MAKE}
3129 # Special case: tack's manpage lives in its own directory.
3130 if test "x$cf_with_manpages" = xyes; then
3131 if test -d tack ; then
3132 if test -f $srcdir/$tack.h; then
3133 cat >> Makefile <<CF_EOF
3137 cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
3143 dnl If we're installing into a subdirectory of /usr/include, etc., we should
3144 dnl prepend the subdirectory's name to the "#include" paths. It won't hurt
3145 dnl anything, and will make it more standardized. It's awkward to decide this
3146 dnl at configuration because of quoting, so we'll simply make all headers
3147 dnl installed via a script that can do the right thing.
3149 rm -f headers.sed headers.sh
3151 dnl ( generating this script makes the makefiles a little tidier :-)
3152 echo creating headers.sh
3153 cat >headers.sh <<CF_EOF
3155 # This shell script is generated by the 'configure' script. It is invoked in a
3156 # subdirectory of the build tree. It generates a sed-script in the parent
3157 # directory that is used to adjust includes for header files that reside in a
3158 # subdirectory of /usr/include, etc.
3160 while test \[$]# != 3
3162 PRG="\$PRG \[$]1"; shift
3167 TMPSRC=\${TMPDIR:-/tmp}/\`basename \$SRC\`\$\$
3168 TMPSED=\${TMPDIR:-/tmp}/headers.sed\$\$
3169 echo installing \$SRC in \$DST
3172 if test $WITH_CURSES_H = yes; then
3173 cat >>headers.sh <<CF_EOF
3176 END=\`basename \$DST\`
3177 for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
3179 NAME=\`basename \$i\`
3180 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
3190 cat >>headers.sh <<CF_EOF
3193 END=\`basename \$DST\`
3194 for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
3196 NAME=\`basename \$i\`
3197 if test "\$NAME" = "curses.h"
3199 echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
3202 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
3206 echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
3211 cat >>headers.sh <<CF_EOF
3213 sed -f \$TMPSED \$SRC > \$TMPSRC
3214 NAME=\`basename \$SRC\`
3216 if test $WITH_CURSES_H != yes; then
3217 cat >>headers.sh <<CF_EOF
3218 test "\$NAME" = "curses.h" && NAME=ncurses.h
3221 cat >>headers.sh <<CF_EOF
3222 # Just in case someone gzip'd manpages, remove the conflicting copy.
3223 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
3225 eval \$PRG \$TMPSRC \$DST/\$NAME
3226 rm -f \$TMPSRC \$TMPSED
3229 chmod 0755 headers.sh
3231 for cf_dir in $SRC_SUBDIRS
3233 if test ! -d $srcdir/$cf_dir ; then
3237 if test -f $srcdir/$cf_dir/headers; then
3238 $AWK -f $srcdir/mk-hdr.awk \
3239 subset="$LIB_SUBSETS" \
3240 compat="$WITH_CURSES_H" \
3241 $srcdir/$cf_dir/headers >>$cf_dir/Makefile
3244 if test -f $srcdir/$cf_dir/modules; then
3245 if test "$cf_dir" != "c++" ; then
3246 cat >>$cf_dir/Makefile <<"CF_EOF"
3247 depend : ${AUTO_SRC}
3248 makedepend -- ${CPPFLAGS} -- ${C_SRC}
3250 # DO NOT DELETE THIS LINE -- make depend depends on it.
3255 AC_SUBST(LIBS_TO_MAKE)
3257 dnl ---------------------------------------------------------------------------
3258 dnl CF_LIB_SONAME version: 5 updated: 2010/08/14 18:25:37
3260 dnl Find the and soname for the given shared library. Set the cache variable
3261 dnl cf_cv_$3_soname to this, unless it is not found. Then set the cache
3262 dnl variable to "unknown".
3266 dnl $3 = library name
3267 AC_DEFUN([CF_LIB_SONAME],
3269 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
3271 cf_cv_$3_soname=unknown
3272 if test "$cross_compiling" != yes ; then
3273 cat >conftest.$ac_ext <<CF_EOF
3278 ${cf_cv_main_return:-return}(0);
3281 cf_save_LIBS="$LIBS"
3283 if AC_TRY_EVAL(ac_compile) ; then
3284 if AC_TRY_EVAL(ac_link) ; then
3285 cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
3286 test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
3290 LIBS="$cf_save_LIBS"
3294 dnl ---------------------------------------------------------------------------
3295 dnl CF_LIB_SUFFIX version: 16 updated: 2008/12/27 12:30:03
3297 dnl Compute the library file-suffix from the given model name
3299 dnl $2 = variable to set (the nominal library suffix)
3300 dnl $3 = dependency variable to set (actual filename)
3301 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
3302 AC_DEFUN([CF_LIB_SUFFIX],
3304 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
3323 case $cf_cv_system_name in
3353 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3354 test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
3356 dnl ---------------------------------------------------------------------------
3357 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
3359 dnl Compute the string to append to -library from the given model name
3361 dnl $2 = variable to set
3362 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
3363 AC_DEFUN([CF_LIB_TYPE],
3372 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3374 dnl ---------------------------------------------------------------------------
3375 dnl CF_LINK_DATAONLY version: 9 updated: 2009/01/01 20:21:38
3376 dnl ----------------
3377 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
3378 dnl only data (i.e., no functions), for example NeXT. On those systems we'll
3379 dnl have to provide wrappers for global tables to ensure they're linked
3381 AC_DEFUN([CF_LINK_DATAONLY],
3383 AC_MSG_CHECKING([if data-only library module links])
3384 AC_CACHE_VAL(cf_cv_link_dataonly,[
3386 cat >conftest.$ac_ext <<EOF
3387 #line __oline__ "configure"
3388 int testdata[[3]] = { 123, 456, 789 };
3390 if AC_TRY_EVAL(ac_compile) ; then
3391 mv conftest.o data.o && \
3392 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
3394 rm -f conftest.$ac_ext data.o
3395 cat >conftest.$ac_ext <<EOF
3396 #line __oline__ "configure"
3400 ${cf_cv_main_return:-return}(1); /* I'm told this linker is broken */
3402 extern int testdata[[3]];
3403 return testdata[[0]] == 123
3404 && testdata[[1]] == 456
3405 && testdata[[2]] == 789;
3409 if AC_TRY_EVAL(ac_compile); then
3410 mv conftest.o func.o && \
3411 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
3413 rm -f conftest.$ac_ext func.o
3414 ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
3416 LIBS="conftest.a $LIBS"
3420 extern int testfunc();
3421 ${cf_cv_main_return:-return} (!testfunc());
3424 [cf_cv_link_dataonly=yes],
3425 [cf_cv_link_dataonly=no],
3426 [cf_cv_link_dataonly=unknown])
3429 AC_MSG_RESULT($cf_cv_link_dataonly)
3431 if test "$cf_cv_link_dataonly" = no ; then
3432 AC_DEFINE(BROKEN_LINKER)
3437 dnl ---------------------------------------------------------------------------
3438 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
3440 dnl Most Unix systems have both link and symlink, a few don't have symlink.
3441 dnl A few non-Unix systems implement symlink, but not link.
3442 dnl A few non-systems implement neither (or have nonfunctional versions).
3443 AC_DEFUN([CF_LINK_FUNCS],
3449 if test "$cross_compiling" = yes ; then
3454 AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
3456 for cf_func in link symlink ; do
3458 #include <sys/types.h>
3459 #include <sys/stat.h>
3460 #ifdef HAVE_UNISTD_H
3466 char *src = "config.log";
3467 char *dst = "conftest.chk";
3472 fail = ($cf_func("config.log", "conftest.chk") < 0)
3473 || (stat(dst, &dst_sb) < 0)
3474 || (dst_sb.st_mtime != src_sb.st_mtime);
3480 ${cf_cv_main_return:-return} (fail);
3483 cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
3484 eval 'ac_cv_func_'$cf_func'=yes'],[
3485 eval 'ac_cv_func_'$cf_func'=no'],[
3486 eval 'ac_cv_func_'$cf_func'=error'])
3488 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
3490 test "$ac_cv_func_link" = yes && AC_DEFINE(HAVE_LINK)
3491 test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
3494 dnl ---------------------------------------------------------------------------
3495 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
3497 dnl Check if a return from main to the shell actually returns the same exit
3498 dnl code. This is true for almost any POSIX environment.
3500 dnl Some very old environments did not flush stdout, etc., on an exit. That
3501 dnl would be a useful case to test for also.
3502 AC_DEFUN([CF_MAIN_RETURN],
3504 cf_cv_main_return=return
3506 dnl ---------------------------------------------------------------------------
3507 dnl CF_MAKEFLAGS version: 14 updated: 2011/03/31 19:29:46
3509 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
3510 dnl options to lower-levels. It's very useful for "make -n" -- if we have it.
3511 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
3512 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
3513 AC_DEFUN([CF_MAKEFLAGS],
3515 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
3517 for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
3519 cat >cf_makeflags.tmp <<CF_EOF
3522 @ echo '.$cf_option'
3524 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | fgrep -v "ing directory" | sed -e 's,[[ ]]*$,,'`
3525 case "$cf_result" in
3527 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
3528 case "$cf_result" in
3529 .*CC=*) cf_cv_makeflags=
3531 *) cf_cv_makeflags=$cf_option
3537 *) echo "given option \"$cf_option\", no match \"$cf_result\""
3541 rm -f cf_makeflags.tmp
3544 AC_SUBST(cf_cv_makeflags)
3546 dnl ---------------------------------------------------------------------------
3547 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
3549 dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have
3550 dnl a monocase filesystem.
3551 AC_DEFUN([CF_MAKE_TAGS],[
3552 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
3554 AC_CHECK_PROGS(CTAGS, exctags ctags)
3555 AC_CHECK_PROGS(ETAGS, exetags etags)
3557 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
3559 if test "$cf_cv_mixedcase" = yes ; then
3560 AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
3565 if test "$MAKE_UPPER_TAGS" = yes ; then
3571 if test "$MAKE_LOWER_TAGS" = yes ; then
3580 AC_SUBST(MAKE_UPPER_TAGS)
3581 AC_SUBST(MAKE_LOWER_TAGS)
3583 dnl ---------------------------------------------------------------------------
3584 dnl CF_MANPAGE_FORMAT version: 9 updated: 2010/10/23 16:10:30
3585 dnl -----------------
3586 dnl Option to allow user to override automatic configuration of manpage format.
3587 dnl There are several special cases:
3589 dnl gzip - man checks for, can display gzip'd files
3590 dnl compress - man checks for, can display compressed files
3591 dnl BSDI - files in the cat-directories are suffixed ".0"
3592 dnl formatted - installer should format (put files in cat-directory)
3593 dnl catonly - installer should only format, e.g., for a turnkey system.
3595 dnl There are other configurations which this macro does not test, e.g., HPUX's
3596 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
3597 dnl convention would not match our use).
3598 AC_DEFUN([CF_MANPAGE_FORMAT],
3600 AC_REQUIRE([CF_PATHSEP])
3601 AC_MSG_CHECKING(format of man-pages)
3603 AC_ARG_WITH(manpage-format,
3604 [ --with-manpage-format specify manpage-format: gzip/compress/BSDI/normal and
3605 optionally formatted/catonly, e.g., gzip,formatted],
3606 [MANPAGE_FORMAT=$withval],
3607 [MANPAGE_FORMAT=unknown])
3609 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
3610 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
3614 case $MANPAGE_FORMAT in
3616 if test -z "$MANPATH" ; then
3617 MANPATH="/usr/man:/usr/share/man"
3620 # look for the 'date' man-page (it's most likely to be installed!)
3626 IFS="${IFS:- }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
3627 for cf_dir in $MANPATH; do
3628 test -z "$cf_dir" && cf_dir=/usr/man
3629 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
3631 cf_test=`echo $cf_name | sed -e 's/*//'`
3632 if test "x$cf_test" = "x$cf_name" ; then
3635 *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
3636 *.Z) MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
3637 *.0) MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
3638 *) MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
3652 # if we found a match in either man* or cat*, stop looking
3653 if test -n "$MANPAGE_FORMAT" ; then
3655 test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
3656 test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
3662 test $cf_found=yes && break
3665 # only check the first directory in $MANPATH where we find manpages
3666 if test -n "$MANPAGE_FORMAT" ; then
3670 # if we did not find the example, just assume it is normal
3671 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
3675 for cf_option in $MANPAGE_FORMAT; do
3676 case $cf_option in #(vi
3677 gzip|compress|BSDI|normal|formatted|catonly)
3680 cf_unknown="$cf_unknown $cf_option"
3687 AC_MSG_RESULT($MANPAGE_FORMAT)
3688 if test -n "$cf_unknown" ; then
3689 AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
3692 dnl ---------------------------------------------------------------------------
3693 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
3694 dnl ------------------
3695 dnl The Debian people have their own naming convention for manpages. This
3696 dnl option lets us override the name of the file containing renaming, or
3697 dnl disable it altogether.
3698 AC_DEFUN([CF_MANPAGE_RENAMES],
3700 AC_MSG_CHECKING(for manpage renaming)
3702 AC_ARG_WITH(manpage-renames,
3703 [ --with-manpage-renames specify manpage-renaming],
3704 [MANPAGE_RENAMES=$withval],
3705 [MANPAGE_RENAMES=yes])
3707 case ".$MANPAGE_RENAMES" in #(vi
3711 # Debian 'man' program?
3712 if test -f /etc/debian_version ; then
3713 MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
3720 if test "$MANPAGE_RENAMES" != no ; then
3721 if test -f $srcdir/man/$MANPAGE_RENAMES ; then
3722 MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
3723 elif test ! -f $MANPAGE_RENAMES ; then
3724 AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
3727 test ! -d man && mkdir man
3729 # Construct a sed-script to perform renaming within man-pages
3730 if test -n "$MANPAGE_RENAMES" ; then
3731 test ! -d man && mkdir man
3732 sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
3736 AC_MSG_RESULT($MANPAGE_RENAMES)
3737 AC_SUBST(MANPAGE_RENAMES)
3739 dnl ---------------------------------------------------------------------------
3740 dnl CF_MANPAGE_SYMLINKS version: 5 updated: 2010/07/24 17:12:40
3741 dnl -------------------
3742 dnl Some people expect each tool to make all aliases for manpages in the
3743 dnl man-directory. This accommodates the older, less-capable implementations
3744 dnl of 'man', and is optional.
3745 AC_DEFUN([CF_MANPAGE_SYMLINKS],
3747 AC_MSG_CHECKING(if manpage aliases will be installed)
3749 AC_ARG_WITH(manpage-aliases,
3750 [ --with-manpage-aliases specify manpage-aliases using .so],
3751 [MANPAGE_ALIASES=$withval],
3752 [MANPAGE_ALIASES=yes])
3754 AC_MSG_RESULT($MANPAGE_ALIASES)
3756 case "x$LN_S" in #(vi
3766 if test "$MANPAGE_ALIASES" = yes ; then
3767 AC_MSG_CHECKING(if manpage symlinks should be used)
3769 AC_ARG_WITH(manpage-symlinks,
3770 [ --with-manpage-symlinks specify manpage-aliases using symlinks],
3771 [MANPAGE_SYMLINKS=$withval],
3772 [MANPAGE_SYMLINKS=$cf_use_symlinks])
3774 if test "$$cf_use_symlinks" = no; then
3775 if test "$MANPAGE_SYMLINKS" = yes ; then
3776 AC_MSG_WARN(cannot make symlinks, will use .so files)
3781 AC_MSG_RESULT($MANPAGE_SYMLINKS)
3785 dnl ---------------------------------------------------------------------------
3786 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
3788 dnl This option causes manpages to be run through tbl(1) to generate tables
3790 AC_DEFUN([CF_MANPAGE_TBL],
3792 AC_MSG_CHECKING(for manpage tbl)
3794 AC_ARG_WITH(manpage-tbl,
3795 [ --with-manpage-tbl specify manpage processing with tbl],
3796 [MANPAGE_TBL=$withval],
3799 AC_MSG_RESULT($MANPAGE_TBL)
3801 dnl ---------------------------------------------------------------------------
3802 dnl CF_MAN_PAGES version: 39 updated: 2010/10/23 15:44:18
3804 dnl Try to determine if the man-pages on the system are compressed, and if
3805 dnl so, what format is used. Use this information to construct a script that
3806 dnl will install man-pages.
3807 AC_DEFUN([CF_MAN_PAGES],
3809 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
3815 if test "$prefix" = "NONE" ; then
3816 cf_prefix="$ac_default_prefix"
3821 case "$MANPAGE_FORMAT" in # (vi
3836 test ! -d man && mkdir man
3840 case "$MANPAGE_FORMAT" in #(vi
3843 cf_compress=compress
3851 cf_edit_man=./edit_man.sh
3852 cf_man_alias=`pwd`/man_alias.sed
3854 cat >$cf_edit_man <<CF_EOF
3856 # this script is generated by the configure-script CF_MAN_PAGES macro.
3861 NCURSES_MAJOR="$NCURSES_MAJOR"
3862 NCURSES_MINOR="$NCURSES_MINOR"
3863 NCURSES_PATCH="$NCURSES_PATCH"
3865 NCURSES_OSPEED="$NCURSES_OSPEED"
3866 TERMINFO="$TERMINFO"
3869 INSTALL_DATA="$INSTALL_DATA"
3871 transform="$program_transform_name"
3873 TMP=\${TMPDIR:=/tmp}/man\$\$
3874 trap "rm -f \$TMP" 0 1 2 5 15
3886 top_srcdir=\[$]srcdir/..
3889 if test "\$form" = normal ; then
3890 if test "$cf_format" = yes ; then
3891 if test "$cf_inboth" = no ; then
3892 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3896 cf_subdir=\$mandir/man
3897 cf_tables=$MANPAGE_TBL
3899 cf_subdir=\$mandir/cat
3903 # process the list of source-files
3906 *.orig|*.rej) ;; #(vi
3908 section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
3909 if test \$verb = installing ; then
3910 if test ! -d \$cf_subdir\${section} ; then
3911 mkdir -p \$cf_subdir\$section
3915 # replace variables in man page
3916 if test ! -f $cf_man_alias ; then
3917 cat >>$cf_man_alias <<-CF_EOF2
3918 s,@DATADIR@,\$datadir,g
3919 s,@TERMINFO@,\$TERMINFO,g
3920 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
3921 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
3922 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
3923 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
3928 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3929 cf_name=`echo $cf_name|sed "$program_transform_name"`
3930 cat >>$cf_edit_man <<-CF_EOF
3931 s,@$cf_NAME@,$cf_name,g
3935 cat >>$cf_edit_man <<CF_EOF
3937 echo "...made $cf_man_alias"
3941 cf_source=\`basename \$i\`
3943 test ! -f \$inalias && inalias="\$srcdir/\$inalias"
3944 if test ! -f \$inalias ; then
3945 echo .. skipped \$cf_source
3950 if test "$MANPAGE_ALIASES" != no ; then
3951 cat >>$cf_edit_man <<CF_EOF
3952 aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
3956 if test "$MANPAGE_RENAMES" = no ; then
3957 cat >>$cf_edit_man <<CF_EOF
3958 # perform program transformations for section 1 man pages
3959 if test \$section = 1 ; then
3960 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
3962 cf_target=\$cf_subdir\${section}/\$cf_source
3966 cat >>$cf_edit_man <<CF_EOF
3967 cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
3968 if test -z "\$cf_target" ; then
3969 echo '? missing rename for '\$cf_source
3970 cf_target="\$cf_source"
3972 cf_target="\$cf_subdir\${section}/\${cf_target}"
3977 cat >>$cf_edit_man <<CF_EOF
3978 sed -f $cf_man_alias \\
3981 if test -f $MANPAGE_RENAMES ; then
3982 cat >>$cf_edit_man <<CF_EOF
3983 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
3986 cat >>$cf_edit_man <<CF_EOF
3991 cat >>$cf_edit_man <<CF_EOF
3992 if test \$cf_tables = yes ; then
3993 tbl \$TMP >\$TMP.out
3998 if test $with_curses_h != yes ; then
3999 cat >>$cf_edit_man <<CF_EOF
4000 sed -e "/\#[ ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
4005 cat >>$cf_edit_man <<CF_EOF
4006 if test \$form = format ; then
4007 nroff -man \$TMP >\$TMP.out
4012 if test -n "$cf_compress" ; then
4013 cat >>$cf_edit_man <<CF_EOF
4014 if test \$verb = installing ; then
4015 if ( $cf_compress -f \$TMP )
4017 mv \$TMP.$cf_so_strip \$TMP
4020 cf_target="\$cf_target.$cf_so_strip"
4024 case "$MANPAGE_FORMAT" in #(vi
4026 cat >>$cf_edit_man <<CF_EOF
4027 if test \$form = format ; then
4028 # BSDI installs only .0 suffixes in the cat directories
4029 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
4035 cat >>$cf_edit_man <<CF_EOF
4036 suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
4037 if test \$verb = installing ; then
4038 echo \$verb \$cf_target
4039 \$INSTALL_DATA \$TMP \$cf_target
4040 test -d \$cf_subdir\${section} &&
4041 test -n "\$aliases" && (
4042 cd \$cf_subdir\${section} && (
4043 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
4044 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
4045 cf_target=\`basename \$cf_target\`
4046 for cf_alias in \$aliases
4048 if test \$section = 1 ; then
4049 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
4052 if test "$MANPAGE_SYMLINKS" = yes ; then
4053 if test -f \$cf_alias\${suffix} ; then
4054 if ( cmp -s \$cf_target \$cf_alias\${suffix} )
4059 echo .. \$verb alias \$cf_alias\${suffix}
4061 case "x$LN_S" in #(vi
4063 cat >>$cf_edit_man <<CF_EOF
4064 $LN_S \$cf_target \$cf_alias\${suffix}
4068 cat >>$cf_edit_man <<CF_EOF
4069 rm -f \$cf_alias\${suffix}
4070 $LN_S \$cf_target \$cf_alias\${suffix}
4074 cat >>$cf_edit_man <<CF_EOF
4075 elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
4076 echo ".so \$cf_source" >\$TMP
4078 if test -n "$cf_compress" ; then
4079 cat >>$cf_edit_man <<CF_EOF
4080 if test -n "$cf_so_strip" ; then
4081 $cf_compress -f \$TMP
4082 mv \$TMP.$cf_so_strip \$TMP
4086 cat >>$cf_edit_man <<CF_EOF
4087 echo .. \$verb alias \$cf_alias\${suffix}
4088 rm -f \$cf_alias\${suffix}
4089 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
4094 elif test \$verb = removing ; then
4095 test -f \$cf_target && (
4096 echo \$verb \$cf_target
4099 test -d \$cf_subdir\${section} &&
4100 test -n "\$aliases" && (
4101 cd \$cf_subdir\${section} && (
4102 for cf_alias in \$aliases
4104 if test \$section = 1 ; then
4105 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
4108 echo .. \$verb alias \$cf_alias\${suffix}
4109 rm -f \$cf_alias\${suffix}
4121 if test $cf_inboth = yes ; then
4122 if test \$form != format ; then
4123 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
4129 chmod 755 $cf_edit_man
4132 dnl ---------------------------------------------------------------------------
4133 dnl CF_MATH_LIB version: 8 updated: 2010/05/29 16:31:02
4135 dnl Checks for libraries. At least one UNIX system, Apple Macintosh
4136 dnl Rhapsody 5.5, does not have -lm. We cannot use the simpler
4137 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
4138 AC_DEFUN([CF_MATH_LIB],
4140 AC_CACHE_CHECK(if -lm needed for math functions,
4146 [double x = rand(); printf("result = %g\n", ]ifelse([$2],,sin(x),$2)[)],
4147 [cf_cv_need_libm=no],
4148 [cf_cv_need_libm=yes])])
4149 if test "$cf_cv_need_libm" = yes
4156 dnl ---------------------------------------------------------------------------
4157 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
4158 dnl ----------------------
4159 dnl Check if the file-system supports mixed-case filenames. If we're able to
4160 dnl create a lowercase name and see it as uppercase, it doesn't support that.
4161 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
4163 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
4164 if test "$cross_compiling" = yes ; then
4165 case $target_alias in #(vi
4166 *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
4174 rm -f conftest CONFTEST
4176 if test -f CONFTEST ; then
4181 rm -f conftest CONFTEST
4184 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
4186 dnl ---------------------------------------------------------------------------
4187 dnl CF_MKSTEMP version: 7 updated: 2010/08/14 18:25:37
4189 dnl Check for a working mkstemp. This creates two files, checks that they are
4190 dnl successfully created and distinct (AmigaOS apparently fails on the last).
4191 AC_DEFUN([CF_MKSTEMP],[
4192 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
4195 #include <sys/types.h>
4199 #include <sys/stat.h>
4202 char *tmpl = "conftestXXXXXX";
4210 for (n = 0; n < 2; ++n) {
4211 strcpy(name[n], tmpl);
4212 if ((fd = mkstemp(name[n])) >= 0) {
4213 if (!strcmp(name[n], tmpl)
4214 || stat(name[n], &sb) != 0
4215 || (sb.st_mode & S_IFMT) != S_IFREG
4216 || (sb.st_mode & 077) != 0) {
4223 && !strcmp(name[0], name[1]))
4225 ${cf_cv_main_return:-return}(result);
4227 ],[cf_cv_func_mkstemp=yes
4228 ],[cf_cv_func_mkstemp=no
4229 ],[AC_CHECK_FUNC(mkstemp)
4232 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
4233 AC_DEFINE(HAVE_MKSTEMP)
4236 dnl ---------------------------------------------------------------------------
4237 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
4239 dnl Write a debug message to config.log, along with the line number in the
4240 dnl configure script.
4241 AC_DEFUN([CF_MSG_LOG],[
4242 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
4244 dnl ---------------------------------------------------------------------------
4245 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
4246 dnl ----------------
4247 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
4248 dnl warn about this.
4249 AC_DEFUN([CF_NCURSES_ABI_6],[
4250 if test "${with_abi_version+set}" != set; then
4251 case $cf_cv_rel_version in
4253 cf_cv_rel_version=6.0
4255 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
4260 dnl ---------------------------------------------------------------------------
4261 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
4262 dnl ------------------
4263 dnl see CF_WITH_NO_LEAKS
4264 AC_DEFUN([CF_NO_LEAKS_OPTION],[
4265 AC_MSG_CHECKING(if you want to use $1 for testing)
4268 [AC_DEFINE($3)ifelse([$4],,[
4271 : ${with_cflags:=-g}
4272 : ${with_no_leaks:=yes}
4275 AC_MSG_RESULT(${with_$1:-no})
4277 case .$with_cflags in #(vi
4279 case .$CFLAGS in #(vi
4289 dnl ---------------------------------------------------------------------------
4290 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
4291 dnl ----------------
4292 dnl Check if the given variable is a number. If not, report an error.
4293 dnl $1 is the variable
4294 dnl $2 is the message
4295 AC_DEFUN([CF_NUMBER_SYNTAX],[
4296 if test -n "$1" ; then
4301 AC_MSG_ERROR($2 is not a number: $1)
4305 AC_MSG_ERROR($2 value is empty)
4308 dnl ---------------------------------------------------------------------------
4309 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
4311 dnl Compute the object-directory name from the given model name
4312 AC_DEFUN([CF_OBJ_SUBDIR],
4315 libtool) $2='obj_lo' ;;
4316 normal) $2='objects' ;;
4317 debug) $2='obj_g' ;;
4318 profile) $2='obj_p' ;;
4320 case $cf_cv_system_name in #(vi
4328 dnl ---------------------------------------------------------------------------
4329 dnl CF_PATHSEP version: 5 updated: 2010/05/26 05:38:42
4331 dnl Provide a value for the $PATH and similar separator
4332 AC_DEFUN([CF_PATHSEP],
4334 case $cf_cv_system_name in
4335 os2*) PATH_SEPARATOR=';' ;;
4336 *) PATH_SEPARATOR=':' ;;
4338 ifelse([$1],,,[$1=$PATH_SEPARATOR])
4339 AC_SUBST(PATH_SEPARATOR)
4341 dnl ---------------------------------------------------------------------------
4342 dnl CF_PATH_SYNTAX version: 13 updated: 2010/05/26 05:38:42
4344 dnl Check the argument to see that it looks like a pathname. Rewrite it if it
4345 dnl begins with one of the prefix/exec_prefix variables, and then again if the
4346 dnl result begins with 'NONE'. This is necessary to work around autoconf's
4347 dnl delayed evaluation of those symbols.
4348 AC_DEFUN([CF_PATH_SYNTAX],[
4349 if test "x$prefix" != xNONE; then
4350 cf_path_syntax="$prefix"
4352 cf_path_syntax="$ac_default_prefix"
4355 case ".[$]$1" in #(vi
4356 .\[$]\(*\)*|.\'*\'*) #(vi
4360 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
4362 .\[$]{*prefix}*) #(vi
4364 case ".[$]$1" in #(vi
4366 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
4371 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
4374 ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
4378 dnl ---------------------------------------------------------------------------
4379 dnl CF_PKG_CONFIG version: 4 updated: 2011/02/18 20:26:24
4381 dnl Check for the package-config program, unless disabled by command-line.
4382 AC_DEFUN([CF_PKG_CONFIG],
4384 AC_MSG_CHECKING(if you want to use pkg-config)
4385 AC_ARG_WITH(pkg-config,
4386 [ --with-pkg-config{=path} enable/disable use of pkg-config],
4387 [cf_pkg_config=$withval],
4388 [cf_pkg_config=yes])
4389 AC_MSG_RESULT($cf_pkg_config)
4391 case $cf_pkg_config in #(vi
4396 AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)
4403 test -z "$PKG_CONFIG" && PKG_CONFIG=none
4404 if test "$PKG_CONFIG" != none ; then
4405 CF_PATH_SYNTAX(PKG_CONFIG)
4408 AC_SUBST(PKG_CONFIG)
4410 dnl ---------------------------------------------------------------------------
4411 dnl CF_POSIX_C_SOURCE version: 8 updated: 2010/05/26 05:38:42
4412 dnl -----------------
4413 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
4415 dnl POSIX.1-1990 _POSIX_SOURCE
4416 dnl POSIX.1-1990 and _POSIX_SOURCE and
4417 dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2
4419 dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L
4420 dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L
4421 dnl X/Open 2000 _POSIX_C_SOURCE=200112L
4424 dnl $1 is the nominal value for _POSIX_C_SOURCE
4425 AC_DEFUN([CF_POSIX_C_SOURCE],
4427 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
4429 cf_save_CFLAGS="$CFLAGS"
4430 cf_save_CPPFLAGS="$CPPFLAGS"
4432 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
4433 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
4435 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
4436 CF_MSG_LOG(if the symbol is already defined go no further)
4437 AC_TRY_COMPILE([#include <sys/types.h>],[
4438 #ifndef _POSIX_C_SOURCE
4441 [cf_cv_posix_c_source=no],
4442 [cf_want_posix_source=no
4443 case .$cf_POSIX_C_SOURCE in #(vi
4445 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
4448 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
4449 cf_want_posix_source=yes
4452 cf_want_posix_source=yes
4455 if test "$cf_want_posix_source" = yes ; then
4456 AC_TRY_COMPILE([#include <sys/types.h>],[
4457 #ifdef _POSIX_SOURCE
4460 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
4462 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
4463 CFLAGS="$cf_trim_CFLAGS"
4464 CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
4465 CF_MSG_LOG(if the second compile does not leave our definition intact error)
4466 AC_TRY_COMPILE([#include <sys/types.h>],[
4467 #ifndef _POSIX_C_SOURCE
4470 [cf_cv_posix_c_source=no])
4471 CFLAGS="$cf_save_CFLAGS"
4472 CPPFLAGS="$cf_save_CPPFLAGS"
4476 if test "$cf_cv_posix_c_source" != no ; then
4477 CFLAGS="$cf_trim_CFLAGS"
4478 CPPFLAGS="$cf_trim_CPPFLAGS"
4479 CF_ADD_CFLAGS($cf_cv_posix_c_source)
4483 dnl ---------------------------------------------------------------------------
4484 dnl CF_PREDEFINE version: 2 updated: 2010/05/26 16:44:57
4486 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
4488 dnl $1 = symbol to test
4489 dnl $2 = value (if any) to use for a predefinition
4490 AC_DEFUN([CF_PREDEFINE],
4492 AC_MSG_CHECKING(if we must define $1)
4493 AC_TRY_COMPILE([#include <sys/types.h>
4497 #endif],[cf_result=no],[cf_result=yes])
4498 AC_MSG_RESULT($cf_result)
4500 if test "$cf_result" = yes ; then
4501 CPPFLAGS="$CPPFLAGS ifelse([$2],,-D$1,[-D$1=$2])"
4502 elif test "x$2" != "x" ; then
4503 AC_MSG_CHECKING(checking for compatible value versus $2)
4504 AC_TRY_COMPILE([#include <sys/types.h>
4508 #endif],[cf_result=yes],[cf_result=no])
4509 AC_MSG_RESULT($cf_result)
4510 if test "$cf_result" = no ; then
4511 # perhaps we can override it - try...
4512 CPPFLAGS="$CPPFLAGS -D$1=$2"
4516 dnl ---------------------------------------------------------------------------
4517 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
4519 dnl Append definitions and rules for the given programs to the subdirectory
4520 dnl Makefiles, and the recursion rule for the top-level Makefile.
4523 dnl $1 = script to run
4524 dnl $2 = list of subdirectories
4528 AC_DEFUN([CF_PRG_RULES],
4532 if test ! -d $srcdir/$cf_dir; then
4534 elif test -f $srcdir/$cf_dir/programs; then
4535 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
4540 dnl ---------------------------------------------------------------------------
4541 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
4543 dnl Check for archiver "ar".
4544 AC_DEFUN([CF_PROG_AR],[
4545 AC_CHECK_TOOL(AR, ar, ar)
4547 dnl ---------------------------------------------------------------------------
4548 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
4550 dnl Check for awk, ensure that the check found something.
4551 AC_DEFUN([CF_PROG_AWK],
4554 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
4556 dnl ---------------------------------------------------------------------------
4557 dnl CF_PROG_CC_C_O version: 3 updated: 2010/08/14 18:25:37
4559 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
4560 dnl the output file can be renamed, and allows for a shell variable that can
4561 dnl be used later. The parameter is either CC or CXX. The result is the
4563 dnl $cf_cv_prog_CC_c_o
4564 dnl $cf_cv_prog_CXX_c_o
4565 AC_DEFUN([CF_PROG_CC_C_O],
4566 [AC_REQUIRE([AC_PROG_CC])dnl
4567 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
4568 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
4570 cat > conftest.$ac_ext <<CF_EOF
4574 ${cf_cv_main_return:-return}(0);
4577 # We do the test twice because some compilers refuse to overwrite an
4578 # existing .o file with -o, though they will create one.
4579 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
4580 if AC_TRY_EVAL(ac_try) &&
4581 test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
4583 eval cf_cv_prog_$1_c_o=yes
4585 eval cf_cv_prog_$1_c_o=no
4589 if test $cf_cv_prog_$1_c_o = yes; then
4590 AC_MSG_RESULT([yes])
4595 dnl ---------------------------------------------------------------------------
4596 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
4598 dnl Check if C (preprocessor) -U and -D options are processed in the order
4599 dnl given rather than by type of option. Some compilers insist on apply all
4600 dnl of the -U options after all of the -D options. Others allow mixing them,
4601 dnl and may predefine symbols that conflict with those we define.
4602 AC_DEFUN([CF_PROG_CC_U_D],
4604 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
4605 cf_save_CPPFLAGS="$CPPFLAGS"
4606 CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
4609 make an undefined-error
4612 make a defined-error
4615 cf_cv_cc_u_d_options=yes],[
4616 cf_cv_cc_u_d_options=no])
4617 CPPFLAGS="$cf_save_CPPFLAGS"
4620 dnl ---------------------------------------------------------------------------
4621 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
4623 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
4624 dnl This macro adds a check to ensure the script found something.
4625 AC_DEFUN([CF_PROG_EGREP],
4626 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
4627 [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4628 then ac_cv_prog_egrep='grep -E'
4629 else ac_cv_prog_egrep='egrep'
4631 EGREP=$ac_cv_prog_egrep
4633 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
4635 dnl ---------------------------------------------------------------------------
4636 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
4638 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
4639 AC_DEFUN([CF_PROG_EXT],
4641 AC_REQUIRE([CF_CHECK_CACHE])
4642 case $cf_cv_system_name in
4644 CFLAGS="$CFLAGS -Zmt"
4645 CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
4646 CXXFLAGS="$CXXFLAGS -Zmt"
4647 # autoconf's macro sets -Zexe and suffix both, which conflict:w
4648 LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
4658 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
4660 dnl ---------------------------------------------------------------------------
4661 dnl CF_PROG_GNAT version: 1 updated: 2010/06/19 15:22:18
4663 dnl Check for gnatmake, ensure that it is complete.
4664 AC_DEFUN([CF_PROG_GNAT],[
4665 cf_ada_make=gnatmake
4666 AC_CHECK_PROG(gnat_exists, $cf_ada_make, yes, no)
4667 if test "$ac_cv_prog_gnat_exists" = no; then
4671 AC_CHECK_PROG(M4_exists, m4, yes, no)
4672 if test "$ac_cv_prog_M4_exists" = no; then
4673 cf_cv_prog_gnat_correct=no
4674 echo Ada95 binding required program m4 not found. Ada95 binding disabled.
4676 if test "$cf_cv_prog_gnat_correct" = yes; then
4677 AC_MSG_CHECKING(if GNAT works)
4678 CF_GNAT_TRY_RUN([procedure conftest;],
4681 procedure conftest is
4683 Text_IO.Put ("Hello World");
4685 GNAT.OS_Lib.OS_Exit (0);
4686 end conftest;],[cf_cv_prog_gnat_correct=yes],[cf_cv_prog_gnat_correct=no])
4687 AC_MSG_RESULT($cf_cv_prog_gnat_correct)
4691 AC_SUBST(cf_ada_make)
4693 dnl ---------------------------------------------------------------------------
4694 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
4696 dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the
4697 dnl misc/tabset install won't work properly. Usually this happens only when
4698 dnl using the fallback mkinstalldirs script
4699 AC_DEFUN([CF_PROG_INSTALL],
4705 CF_DIRNAME(cf_dir,$INSTALL)
4706 test -z "$cf_dir" && cf_dir=.
4707 INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
4711 dnl ---------------------------------------------------------------------------
4712 dnl CF_PROG_LDCONFIG version: 2 updated: 2008/12/13 14:08:40
4713 dnl ----------------
4714 dnl Check for ldconfig, needed to fixup shared libraries that would be built
4715 dnl and then used in the install.
4716 AC_DEFUN([CF_PROG_LDCONFIG],[
4717 if test "$cross_compiling" = yes ; then
4720 case "$cf_cv_system_name" in #(vi
4721 dragonfly*|freebsd*) #(vi
4722 test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
4724 *) LDPATH=$PATH:/sbin:/usr/sbin
4725 AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
4731 dnl ---------------------------------------------------------------------------
4732 dnl CF_PROG_LINT version: 2 updated: 2009/08/12 04:43:14
4734 AC_DEFUN([CF_PROG_LINT],
4736 AC_CHECK_PROGS(LINT, tdlint lint alint splint lclint)
4739 dnl ---------------------------------------------------------------------------
4740 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
4742 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
4743 dnl option if it is supported.
4744 AC_DEFUN([CF_PROG_LN_S],[
4746 AC_MSG_CHECKING(if $LN_S -f options work)
4748 rm -f conf$$.src conf$$dst
4750 echo first >conf$$.src
4751 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
4756 rm -f conf$$.dst conf$$src
4757 AC_MSG_RESULT($cf_prog_ln_sf)
4759 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
4761 dnl ---------------------------------------------------------------------------
4762 dnl CF_REGEX version: 8 updated: 2010/08/07 14:09:44
4764 dnl Attempt to determine if we've got one of the flavors of regular-expression
4765 dnl code that we can support.
4766 AC_DEFUN([CF_REGEX],
4771 cf_regex_libs="regex re"
4772 case $host_os in #(vi
4774 cf_regex_libs="regex.dll $cf_regex_libs"
4778 AC_CHECK_FUNC(regcomp,[cf_regex_func=regcomp],[
4779 for cf_regex_lib in $cf_regex_libs
4781 AC_CHECK_LIB($cf_regex_lib,regcomp,[
4782 CF_ADD_LIB($cf_regex_lib)
4783 cf_regex_func=regcomp
4788 if test "$cf_regex_func" = no ; then
4789 AC_CHECK_FUNC(compile,[cf_regex_func=compile],[
4790 AC_CHECK_LIB(gen,compile,[
4792 cf_regex_func=compile])])
4795 if test "$cf_regex_func" = no ; then
4796 AC_MSG_WARN(cannot find regular expression library)
4799 AC_CACHE_CHECK(for regular-expression headers,cf_cv_regex_hdrs,[
4802 case $cf_regex_func in #(vi
4804 for cf_regex_hdr in regexp.h regexpr.h
4806 AC_TRY_LINK([#include <$cf_regex_hdr>],[
4807 char *p = compile("", "", "", 0);
4808 int x = step("", "");
4810 cf_cv_regex_hdrs=$cf_regex_hdr
4816 for cf_regex_hdr in regex.h
4818 AC_TRY_LINK([#include <sys/types.h>
4819 #include <$cf_regex_hdr>],[
4821 int x = regcomp(p, "", 0);
4822 int y = regexec(p, "", 0, 0, 0);
4825 cf_cv_regex_hdrs=$cf_regex_hdr
4834 case $cf_cv_regex_hdrs in #(vi
4835 no) AC_MSG_WARN(no regular expression header found) ;; #(vi
4836 regex.h) AC_DEFINE(HAVE_REGEX_H_FUNCS) ;; #(vi
4837 regexp.h) AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;; #(vi
4838 regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;;
4841 dnl ---------------------------------------------------------------------------
4842 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
4843 dnl ----------------
4844 dnl Remove all -U and -D options that refer to the given symbol from a list
4845 dnl of C compiler options. This works around the problem that not all
4846 dnl compilers process -U and -D options from left-to-right, so a -U option
4847 dnl cannot be used to cancel the effect of a preceding -D option.
4849 dnl $1 = target (which could be the same as the source variable)
4850 dnl $2 = source (including '$')
4851 dnl $3 = symbol to remove
4852 define([CF_REMOVE_DEFINE],
4855 sed -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[[ ]]/ /g' \
4856 -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[$]//g'`
4858 dnl ---------------------------------------------------------------------------
4859 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
4861 dnl Remove the given library from the symbol
4863 dnl $1 = target (which could be the same as the source variable)
4864 dnl $2 = source (including '$')
4865 dnl $3 = library to remove
4866 define([CF_REMOVE_LIB],
4868 # remove $3 library from $2
4869 $1=`echo "$2" | sed -e 's/-l$3[[ ]]//g' -e 's/-l$3[$]//'`
4871 dnl ---------------------------------------------------------------------------
4872 dnl CF_RPATH_HACK version: 9 updated: 2011/02/13 13:31:33
4874 AC_DEFUN([CF_RPATH_HACK],
4876 AC_REQUIRE([CF_LD_RPATH_OPT])
4877 AC_MSG_CHECKING(for updated LDFLAGS)
4878 if test -n "$LD_RPATH_OPT" ; then
4879 AC_MSG_RESULT(maybe)
4881 AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
4882 cf_rpath_list="/usr/lib /lib"
4883 if test "$cf_ldd_prog" != no
4887 AC_TRY_LINK([#include <stdio.h>],
4889 [cf_rpath_oops=`$cf_ldd_prog conftest$ac_exeext | fgrep ' not found' | sed -e 's% =>.*$%%' |sort -u`
4890 cf_rpath_list=`$cf_ldd_prog conftest$ac_exeext | fgrep / | sed -e 's%^.*[[ ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort -u`])
4892 # If we passed the link-test, but get a "not found" on a given library,
4893 # this could be due to inept reconfiguration of gcc to make it only
4894 # partly honor /usr/local/lib (or whatever). Sometimes this behavior
4895 # is intentional, e.g., installing gcc in /usr/bin and suppressing the
4896 # /usr/local libraries.
4897 if test -n "$cf_rpath_oops"
4899 for cf_rpath_src in $cf_rpath_oops
4901 for cf_rpath_dir in \
4906 if test -f $cf_rpath_dir/lib/$cf_rpath_src
4908 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
4909 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
4917 CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
4919 CF_RPATH_HACK_2(LDFLAGS)
4920 CF_RPATH_HACK_2(LIBS)
4922 CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
4924 AC_SUBST(EXTRA_LDFLAGS)
4926 dnl ---------------------------------------------------------------------------
4927 dnl CF_RPATH_HACK_2 version: 6 updated: 2010/04/17 16:31:24
4929 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
4930 dnl EXTRA_LDFLAGS for each -L option found.
4932 dnl $cf_rpath_list contains a list of directories to ignore.
4934 dnl $1 = variable name to update. The LDFLAGS variable should be the only one,
4935 dnl but LIBS often has misplaced -L options.
4936 AC_DEFUN([CF_RPATH_HACK_2],
4938 CF_VERBOSE(...checking $1 [$]$1)
4941 for cf_rpath_src in [$]$1
4943 case $cf_rpath_src in #(vi
4946 # check if this refers to a directory which we will ignore
4948 if test -n "$cf_rpath_list"
4950 for cf_rpath_item in $cf_rpath_list
4952 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
4960 if test "$cf_rpath_skip" = no
4962 # transform the option
4963 if test "$LD_RPATH_OPT" = "-R " ; then
4964 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
4966 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
4969 # if we have not already added this, add it now
4970 cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
4971 if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
4973 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
4974 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
4979 cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
4983 CF_VERBOSE(...checked $1 [$]$1)
4984 AC_SUBST(EXTRA_LDFLAGS)
4986 dnl ---------------------------------------------------------------------------
4987 dnl CF_SHARED_OPTS version: 64 updated: 2010/06/05 16:51:16
4990 dnl Attempt to determine the appropriate CC/LD options for creating a shared
4993 dnl Note: ${LOCAL_LDFLAGS} is used to link executables that will run within the
4994 dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib
4995 dnl We avoid compiling-in a ../lib path for the shared library since that can
4996 dnl lead to unexpected results at runtime.
4997 dnl ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared libraries
4998 dnl are compiled in ../../lib
5000 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
5001 dnl to install symbolic links to the rel/abi versions of shared libraries.
5003 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
5004 dnl version when making symbolic links.
5006 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
5007 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
5008 dnl (ex: libncurses.so.<ver>).
5010 dnl Some loaders leave 'so_locations' lying around. It's nice to clean up.
5011 AC_DEFUN([CF_SHARED_OPTS],
5013 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
5014 AC_REQUIRE([CF_LD_RPATH_OPT])
5018 INSTALL_LIB="-m 644"
5020 cf_cv_do_symlinks=no
5022 test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
5024 AC_MSG_CHECKING(if release/abi version should be used for shared libs)
5025 AC_ARG_WITH(shlib-version,
5026 [ --with-shlib-version=X Specify rel or abi version for shared libs],
5027 [test -z "$withval" && withval=auto
5028 case $withval in #(vi
5030 cf_cv_shlib_version=auto
5032 rel|abi|auto|no) #(vi
5033 cf_cv_shlib_version=$withval
5036 AC_MSG_ERROR([option value must be one of: rel, abi, auto or no])
5039 ],[cf_cv_shlib_version=auto])
5040 AC_MSG_RESULT($cf_cv_shlib_version)
5044 # Some less-capable ports of gcc support only -fpic
5046 if test "$GCC" = yes
5048 AC_MSG_CHECKING(which $CC option to use)
5049 cf_save_CFLAGS="$CFLAGS"
5050 for CC_SHARED_OPTS in -fPIC -fpic ''
5052 CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
5053 AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
5055 AC_MSG_RESULT($CC_SHARED_OPTS)
5056 CFLAGS="$cf_save_CFLAGS"
5059 cf_cv_shlib_version_infix=no
5061 case $cf_cv_system_name in #(vi
5063 if test "$GCC" = yes; then
5065 MK_SHARED_LIB='$(CC) -shared'
5069 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
5073 MK_SHARED_LIB='sh ../mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
5074 cf_cv_shlib_version=cygdll
5075 cf_cv_shlib_version_infix=cygdll
5076 cat >mk_shared_lib.sh <<-CF_EOF
5079 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
5082 Linking shared library
5083 ** SHARED_LIB \[$]SHARED_LIB
5084 ** IMPORT_LIB \[$]IMPORT_LIB
5086 exec \[$]* -shared -Wl,--out-implib=../lib/\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o ../lib/\[$]{SHARED_LIB}
5088 chmod +x mk_shared_lib.sh
5091 EXTRA_CFLAGS="-no-cpp-precomp"
5092 CC_SHARED_OPTS="-dynamic"
5093 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
5094 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
5095 cf_cv_shlib_version_infix=yes
5096 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
5097 cf_save_LDFLAGS=$LDFLAGS
5098 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
5099 AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
5100 LDFLAGS=$cf_save_LDFLAGS])
5101 if test $cf_cv_ldflags_search_paths_first = yes; then
5102 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
5106 # (tested with gcc 2.7.2 -- I don't have c89)
5107 if test "$GCC" = yes; then
5108 LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
5111 LD_SHARED_OPTS='-Wl,+b,${libdir}'
5113 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
5114 # HP-UX shared libraries must be executable, and should be
5115 # readonly to exploit a quirk in the memory manager.
5116 INSTALL_LIB="-m 555"
5119 if test "$cf_cv_enable_rpath" = yes ; then
5120 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
5122 # tested with IRIX 5.2 and 'cc'.
5123 if test "$GCC" != yes; then
5124 CC_SHARED_OPTS='-KPIC'
5125 MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
5127 MK_SHARED_LIB='${CC} -shared -Wl,-soname,`basename $[@]` -o $[@]'
5129 cf_cv_rm_so_locs=yes
5131 linux*|gnu*|k*bsd*-gnu) #(vi
5132 if test "$DFT_LWR_MODEL" = "shared" ; then
5133 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
5134 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5136 if test "$cf_cv_enable_rpath" = yes ; then
5137 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
5140 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
5142 openbsd[[2-9]].*) #(vi
5143 if test "$DFT_LWR_MODEL" = "shared" ; then
5144 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
5145 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5147 if test "$cf_cv_enable_rpath" = yes ; then
5148 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
5150 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5152 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
5154 nto-qnx*|openbsd*|freebsd[[12]].*) #(vi
5155 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5156 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
5157 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5160 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5161 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
5162 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
5163 LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${libdir} $LOCAL_LDFLAGS"
5164 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
5167 MK_SHARED_LIB='${LD} -shared -Bshareable -soname=`basename $[@]` -o $[@]'
5170 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5171 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
5172 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
5173 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5174 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
5175 if test "$cf_cv_shlib_version" = auto; then
5176 if test -f /usr/libexec/ld.elf_so; then
5177 cf_cv_shlib_version=abi
5179 cf_cv_shlib_version=rel
5183 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
5185 MK_SHARED_LIB='${LD} -shared -Bshareable -o $[@]'
5189 # tested with OSF/1 V3.2 and 'cc'
5190 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
5191 # link with shared libs).
5192 MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
5193 case $host_os in #(vi
5195 MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
5198 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
5199 if test "$DFT_LWR_MODEL" = "shared" ; then
5200 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
5201 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5203 cf_cv_rm_so_locs=yes
5205 sco3.2v5*) # (also uw2* and UW7: hops 13-Apr-98
5206 # tested with osr5.0.5
5207 if test "$GCC" != yes; then
5208 CC_SHARED_OPTS='-belf -KPIC'
5210 MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
5211 if test "$cf_cv_enable_rpath" = yes ; then
5212 # only way is to set LD_RUN_PATH but no switch for it
5215 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5216 LINK_PROGS='LD_RUN_PATH=${libdir}'
5217 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
5220 # tested with SunOS 4.1.1 and gcc 2.7.0
5221 if test "$GCC" != yes; then
5222 CC_SHARED_OPTS='-KPIC'
5224 MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
5225 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5228 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
5229 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
5230 if test "$DFT_LWR_MODEL" = "shared" ; then
5231 LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
5232 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5234 if test "$cf_cv_enable_rpath" = yes ; then
5235 EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
5238 if test "$GCC" != yes; then
5239 cf_save_CFLAGS="$CFLAGS"
5240 for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
5242 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
5243 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\n");],[break])
5245 CFLAGS="$cf_save_CFLAGS"
5246 CC_SHARED_OPTS=$cf_shared_opts
5247 MK_SHARED_LIB='${CC} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
5249 MK_SHARED_LIB='${CC} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
5252 sysv5uw7*|unix_sv*) #(vi
5253 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
5254 if test "$GCC" != yes; then
5255 CC_SHARED_OPTS='-KPIC'
5257 MK_SHARED_LIB='${LD} -d y -G -o [$]@'
5260 CC_SHARED_OPTS='unknown'
5261 MK_SHARED_LIB='echo unknown'
5265 # This works if the last tokens in $MK_SHARED_LIB are the -o target.
5266 case "$cf_cv_shlib_version" in #(vi
5268 case "$MK_SHARED_LIB" in #(vi
5270 test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
5273 AC_MSG_WARN(ignored --with-shlib-version)
5279 if test -n "$cf_ld_rpath_opt" ; then
5280 MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${libdir}"
5283 AC_SUBST(CC_SHARED_OPTS)
5284 AC_SUBST(LD_RPATH_OPT)
5285 AC_SUBST(LD_SHARED_OPTS)
5286 AC_SUBST(MK_SHARED_LIB)
5287 AC_SUBST(LINK_PROGS)
5288 AC_SUBST(LINK_TESTS)
5289 AC_SUBST(EXTRA_LDFLAGS)
5290 AC_SUBST(LOCAL_LDFLAGS)
5291 AC_SUBST(LOCAL_LDFLAGS2)
5292 AC_SUBST(INSTALL_LIB)
5294 dnl ---------------------------------------------------------------------------
5295 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
5296 dnl ----------------
5297 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
5298 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
5301 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
5302 dnl If missing, use "rel".
5303 define([CF_SHARED_SONAME],
5305 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
5306 if test "$cf_cv_shlib_version" = rel; then
5307 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
5309 cf_cv_shared_soname='`basename $[@]`'
5312 dnl ---------------------------------------------------------------------------
5313 dnl CF_SIGWINCH version: 1 updated: 2006/04/02 16:41:09
5315 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
5316 dnl programs need this test).
5318 dnl This is really a MacOS X 10.4.3 workaround. Defining _POSIX_C_SOURCE
5319 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses). Oddly, the struct
5320 dnl winsize declaration is left alone - we may revisit this if Apple choose to
5321 dnl break that part of the interface as well.
5322 AC_DEFUN([CF_SIGWINCH],
5324 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
5326 #include <sys/types.h>
5327 #include <sys/signal.h>
5328 ],[int x = SIGWINCH],
5329 [cf_cv_define_sigwinch=yes],
5331 #undef _XOPEN_SOURCE
5332 #undef _POSIX_SOURCE
5333 #undef _POSIX_C_SOURCE
5334 #include <sys/types.h>
5335 #include <sys/signal.h>
5336 ],[int x = SIGWINCH],
5337 [cf_cv_define_sigwinch=maybe],
5338 [cf_cv_define_sigwinch=no])
5342 if test "$cf_cv_define_sigwinch" = maybe ; then
5343 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
5344 cf_cv_fixup_sigwinch=unknown
5346 while test $cf_sigwinch != 1
5349 #undef _XOPEN_SOURCE
5350 #undef _POSIX_SOURCE
5351 #undef _POSIX_C_SOURCE
5352 #include <sys/types.h>
5353 #include <sys/signal.h>
5355 #if SIGWINCH != $cf_sigwinch
5359 [cf_cv_fixup_sigwinch=$cf_sigwinch
5362 cf_sigwinch=`expr $cf_sigwinch - 1`
5366 if test "$cf_cv_fixup_sigwinch" != unknown ; then
5367 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
5371 dnl ---------------------------------------------------------------------------
5372 dnl CF_SIG_ATOMIC_T version: 2 updated: 2005/09/18 17:27:12
5374 dnl signal handler, but there are some gcc depedencies in that recommendation.
5376 AC_DEFUN([CF_SIG_ATOMIC_T],
5378 AC_MSG_CHECKING(for signal global datatype)
5379 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
5381 "volatile sig_atomic_t" \
5386 #include <sys/types.h>
5392 static void handler(int sig)
5396 [signal(SIGINT, handler);
5398 [cf_cv_sig_atomic_t=$cf_type],
5399 [cf_cv_sig_atomic_t=no])
5400 test "$cf_cv_sig_atomic_t" != no && break
5403 AC_MSG_RESULT($cf_cv_sig_atomic_t)
5404 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t)
5406 dnl ---------------------------------------------------------------------------
5407 dnl CF_SIZECHANGE version: 8 updated: 2000/11/04 12:22:16
5409 dnl Check for definitions & structures needed for window size-changing
5410 dnl FIXME: check that this works with "snake" (HP-UX 10.x)
5411 AC_DEFUN([CF_SIZECHANGE],
5413 AC_REQUIRE([CF_STRUCT_TERMIOS])
5414 AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[
5415 cf_cv_sizechange=unknown
5416 cf_save_CPPFLAGS="$CPPFLAGS"
5418 for cf_opts in "" "NEED_PTEM_H"
5421 CPPFLAGS="$cf_save_CPPFLAGS"
5422 test -n "$cf_opts" && CPPFLAGS="$CPPFLAGS -D$cf_opts"
5423 AC_TRY_COMPILE([#include <sys/types.h>
5424 #ifdef HAVE_TERMIOS_H
5425 #include <termios.h>
5427 #ifdef HAVE_TERMIO_H
5432 /* This is a workaround for SCO: they neglected to define struct winsize in
5433 * termios.h -- it's only in termio.h and ptem.h
5435 #include <sys/stream.h>
5436 #include <sys/ptem.h>
5438 #if !defined(sun) || !defined(HAVE_TERMIOS_H)
5439 #include <sys/ioctl.h>
5443 struct ttysize win; /* FIXME: what system is this? */
5444 int y = win.ts_lines;
5445 int x = win.ts_cols;
5452 no TIOCGSIZE or TIOCGWINSZ
5453 #endif /* TIOCGWINSZ */
5454 #endif /* TIOCGSIZE */
5456 [cf_cv_sizechange=yes],
5457 [cf_cv_sizechange=no])
5459 CPPFLAGS="$cf_save_CPPFLAGS"
5460 if test "$cf_cv_sizechange" = yes ; then
5461 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC
5462 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts"
5467 if test "$cf_cv_sizechange" != no ; then
5468 AC_DEFINE(HAVE_SIZECHANGE)
5469 case $cf_cv_sizechange in #(vi
5471 AC_DEFINE_UNQUOTED($cf_cv_sizechange )
5476 dnl ---------------------------------------------------------------------------
5477 dnl CF_SRC_MODULES version: 21 updated: 2010/09/04 17:37:40
5479 dnl For each parameter, test if the source-directory exists, and if it contains
5480 dnl a 'modules' file. If so, add to the list $cf_cv_src_modules which we'll
5481 dnl use in CF_LIB_RULES.
5483 dnl This uses the configured value to make the lists SRC_SUBDIRS and
5484 dnl SUB_MAKEFILES which are used in the makefile-generation scheme.
5485 AC_DEFUN([CF_SRC_MODULES],
5487 AC_MSG_CHECKING(for src modules)
5489 # dependencies and linker-arguments for test-programs
5490 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS"
5491 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2"
5492 if test "$DFT_LWR_MODEL" = "libtool"; then
5493 TEST_ARGS="${TEST_DEPS}"
5494 TEST_ARG2="${TEST_DEP2}"
5496 TEST_ARGS="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARGS"
5497 TEST_ARG2="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARG2"
5503 if test -f $srcdir/$cf_dir/modules; then
5505 # We may/may not have tack in the distribution, though the
5507 if test $cf_dir = tack ; then
5508 if test ! -f $srcdir/${cf_dir}/${cf_dir}.h; then
5513 if test -z "$cf_cv_src_modules"; then
5514 cf_cv_src_modules=$cf_dir
5516 cf_cv_src_modules="$cf_cv_src_modules $cf_dir"
5519 # Make the ncurses_cfg.h file record the library interface files as
5520 # well. These are header files that are the same name as their
5521 # directory. Ncurses is the only library that does not follow
5523 if test $cf_dir = tack ; then
5525 elif test -f $srcdir/${cf_dir}/${cf_dir}.h; then
5526 CF_UPPER(cf_have_include,$cf_dir)
5527 AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H)
5528 AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include})
5529 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEPS"
5530 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEP2"
5531 if test "$DFT_LWR_MODEL" = "libtool"; then
5532 TEST_ARGS="${TEST_DEPS}"
5533 TEST_ARG2="${TEST_DEP2}"
5535 TEST_ARGS="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARGS"
5536 TEST_ARG2="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARG2"
5541 AC_MSG_RESULT($cf_cv_src_modules)
5543 TEST_ARGS="-L${LIB_DIR} $TEST_ARGS"
5544 TEST_ARG2="-L${LIB_2ND} $TEST_ARG2"
5553 if test "x$cf_with_manpages" != xno ; then
5554 SRC_SUBDIRS="$SRC_SUBDIRS man"
5556 SRC_SUBDIRS="$SRC_SUBDIRS include"
5557 for cf_dir in $cf_cv_src_modules
5559 SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir"
5561 if test "x$cf_with_tests" != "xno" ; then
5562 SRC_SUBDIRS="$SRC_SUBDIRS test"
5564 test -z "$MAKE_TERMINFO" && SRC_SUBDIRS="$SRC_SUBDIRS misc"
5565 test "$cf_with_cxx_binding" != no && SRC_SUBDIRS="$SRC_SUBDIRS c++"
5568 if test "$cf_cv_prog_gnat_correct" = yes && test -f $srcdir/Ada95/Makefile.in; then
5569 SRC_SUBDIRS="$SRC_SUBDIRS Ada95"
5570 ADA_SUBDIRS="gen src"
5571 if test "x$cf_with_tests" != "xno" ; then
5572 ADA_SUBDIRS="$ADA_SUBDIRS samples"
5577 for cf_dir in $SRC_SUBDIRS
5579 SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile"
5582 if test -n "$ADA_SUBDIRS"; then
5583 for cf_dir in $ADA_SUBDIRS
5585 SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile"
5587 AC_SUBST(ADA_SUBDIRS)
5590 dnl ---------------------------------------------------------------------------
5591 dnl CF_STDCPP_LIBRARY version: 7 updated: 2010/05/29 16:31:02
5592 dnl -----------------
5593 dnl Check for -lstdc++, which is GNU's standard C++ library.
5594 AC_DEFUN([CF_STDCPP_LIBRARY],
5596 if test -n "$GXX" ; then
5597 case $cf_cv_system_name in #(vi
5599 cf_stdcpp_libname=stdcpp
5602 cf_stdcpp_libname=stdc++
5605 AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[
5607 CF_ADD_LIB($cf_stdcpp_libname)
5609 #include <strstream.h>],[
5611 strstreambuf foo(buf, sizeof(buf))
5613 [cf_cv_libstdcpp=yes],
5614 [cf_cv_libstdcpp=no])
5617 test "$cf_cv_libstdcpp" = yes && CF_ADD_LIB($cf_stdcpp_libname,CXXLIBS)
5620 dnl ---------------------------------------------------------------------------
5621 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
5623 dnl Remove "-g" option from the compiler options
5624 AC_DEFUN([CF_STRIP_G_OPT],
5625 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
5626 dnl ---------------------------------------------------------------------------
5627 dnl CF_STRUCT_SIGACTION version: 4 updated: 2011/04/16 11:52:53
5628 dnl -------------------
5629 dnl Check if we need _POSIX_SOURCE defined to use struct sigaction. We'll only
5630 dnl do this if we've found the sigaction function.
5631 AC_DEFUN([CF_STRUCT_SIGACTION],[
5632 AC_REQUIRE([CF_XOPEN_SOURCE])
5634 if test "$ac_cv_func_sigaction" = yes; then
5635 AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE)
5637 #include <sys/types.h>
5638 #include <signal.h>],
5639 [struct sigaction act],
5643 #define _POSIX_SOURCE
5644 #include <sys/types.h>
5645 #include <signal.h>],
5646 [struct sigaction act],
5648 AC_DEFINE(_POSIX_SOURCE)],
5649 [sigact_bad=unknown])])
5650 AC_MSG_RESULT($sigact_bad)
5653 dnl ---------------------------------------------------------------------------
5654 dnl CF_STRUCT_TERMIOS version: 6 updated: 2011/04/16 11:52:53
5655 dnl -----------------
5656 dnl Some machines require _POSIX_SOURCE to completely define struct termios.
5657 AC_DEFUN([CF_STRUCT_TERMIOS],[
5658 AC_REQUIRE([CF_XOPEN_SOURCE])
5666 if test "$ISC" = yes ; then
5667 AC_CHECK_HEADERS( sys/termio.h )
5669 if test "$ac_cv_header_termios_h" = yes ; then
5670 case "$CFLAGS $CPPFLAGS" in
5672 termios_bad=dunno ;;
5673 *) termios_bad=maybe ;;
5675 if test "$termios_bad" = maybe ; then
5676 AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE)
5677 AC_TRY_COMPILE([#include <termios.h>],
5678 [struct termios foo; int x = foo.c_iflag],
5681 #define _POSIX_SOURCE
5682 #include <termios.h>],
5683 [struct termios foo; int x = foo.c_iflag],
5684 termios_bad=unknown,
5685 termios_bad=yes AC_DEFINE(_POSIX_SOURCE))
5687 AC_MSG_RESULT($termios_bad)
5691 dnl ---------------------------------------------------------------------------
5692 dnl CF_SUBDIR_PATH version: 6 updated: 2010/04/21 06:20:50
5694 dnl Construct a search-list for a nonstandard header/lib-file
5695 dnl $1 = the variable to return as result
5696 dnl $2 = the package name
5697 dnl $3 = the subdirectory, e.g., bin, include or lib
5698 AC_DEFUN([CF_SUBDIR_PATH],
5702 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr,$prefix)
5703 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
5704 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr/local,$prefix)
5705 CF_ADD_SUBDIR_PATH($1,$2,$3,/opt,$prefix)
5706 CF_ADD_SUBDIR_PATH($1,$2,$3,[$]HOME,$prefix)
5708 dnl ---------------------------------------------------------------------------
5709 dnl CF_SUBST version: 4 updated: 2006/06/17 12:33:03
5711 dnl Shorthand macro for substituting things that the user may override
5712 dnl with an environment variable.
5714 dnl $1 = long/descriptive name
5715 dnl $2 = environment variable
5716 dnl $3 = default value
5717 AC_DEFUN([CF_SUBST],
5718 [AC_CACHE_VAL(cf_cv_subst_$2,[
5719 AC_MSG_CHECKING(for $1 (symbol $2))
5720 CF_SUBST_IF([-z "[$]$2"], [$2], [$3])
5721 cf_cv_subst_$2=[$]$2
5722 AC_MSG_RESULT([$]$2)
5725 dnl ---------------------------------------------------------------------------
5726 dnl CF_SUBST_IF version: 2 updated: 2006/06/17 12:33:03
5728 dnl Shorthand macro for substituting things that the user may override
5729 dnl with an environment variable.
5731 dnl $1 = condition to pass to "test"
5732 dnl $2 = environment variable
5733 dnl $3 = value if the test succeeds
5734 dnl $4 = value if the test fails
5735 AC_DEFUN([CF_SUBST_IF],
5744 dnl ---------------------------------------------------------------------------
5745 dnl CF_SUBST_NCURSES_VERSION version: 8 updated: 2006/09/16 11:40:59
5746 dnl ------------------------
5747 dnl Get the version-number for use in shared-library naming, etc.
5748 AC_DEFUN([CF_SUBST_NCURSES_VERSION],
5750 AC_REQUIRE([CF_PROG_EGREP])
5751 NCURSES_MAJOR="`$ac_cv_prog_egrep '^NCURSES_MAJOR[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
5752 NCURSES_MINOR="`$ac_cv_prog_egrep '^NCURSES_MINOR[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
5753 NCURSES_PATCH="`$ac_cv_prog_egrep '^NCURSES_PATCH[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
5754 cf_cv_abi_version=${NCURSES_MAJOR}
5755 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
5756 dnl Show the computed version, for logging
5757 cf_cv_timestamp=`date`
5758 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
5759 dnl We need these values in the generated headers
5760 AC_SUBST(NCURSES_MAJOR)
5761 AC_SUBST(NCURSES_MINOR)
5762 AC_SUBST(NCURSES_PATCH)
5763 dnl We need these values in the generated makefiles
5764 AC_SUBST(cf_cv_rel_version)
5765 AC_SUBST(cf_cv_abi_version)
5766 AC_SUBST(cf_cv_builtin_bool)
5767 AC_SUBST(cf_cv_header_stdbool_h)
5768 AC_SUBST(cf_cv_type_of_bool)dnl
5770 dnl ---------------------------------------------------------------------------
5771 dnl CF_SYS_TIME_SELECT version: 4 updated: 2000/10/04 09:18:40
5772 dnl ------------------
5773 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
5774 dnl older SCO configurations.
5775 AC_DEFUN([CF_SYS_TIME_SELECT],
5777 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
5778 AC_CACHE_VAL(cf_cv_sys_time_select,[
5780 #include <sys/types.h>
5781 #ifdef HAVE_SYS_TIME_H
5782 #include <sys/time.h>
5784 #ifdef HAVE_SYS_SELECT_H
5785 #include <sys/select.h>
5787 ],[],[cf_cv_sys_time_select=yes],
5788 [cf_cv_sys_time_select=no])
5790 AC_MSG_RESULT($cf_cv_sys_time_select)
5791 test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT)
5793 dnl ---------------------------------------------------------------------------
5794 dnl CF_TOP_BUILDDIR version: 1 updated: 2006/10/15 16:33:23
5796 dnl Define a top_builddir symbol, for applications that need an absolute path.
5797 AC_DEFUN([CF_TOP_BUILDDIR],
5800 AC_SUBST(top_builddir)
5802 dnl ---------------------------------------------------------------------------
5803 dnl CF_TYPEOF_CHTYPE version: 8 updated: 2006/12/16 12:33:30
5804 dnl ----------------
5805 dnl Determine the type we should use for chtype (and attr_t, which is treated
5806 dnl as the same thing). We want around 32 bits, so on most machines want a
5807 dnl long, but on newer 64-bit machines, probably want an int. If we're using
5808 dnl wide characters, we have to have a type compatible with that, as well.
5809 AC_DEFUN([CF_TYPEOF_CHTYPE],
5811 AC_MSG_CHECKING([for type of chtype])
5812 AC_CACHE_VAL(cf_cv_typeof_chtype,[
5814 #define WANT_BITS 31
5818 FILE *fp = fopen("cf_test.out", "w");
5820 char *result = "long";
5821 if (sizeof(unsigned long) > sizeof(unsigned int)) {
5824 for (n = 0; n < WANT_BITS; n++) {
5827 if (y != 1 || x == 0) {
5833 * If x is nonzero, an int is big enough for the bits
5836 result = (x != 0) ? "int" : "long";
5841 ${cf_cv_main_return:-return}(0);
5844 [cf_cv_typeof_chtype=`cat cf_test.out`],
5845 [cf_cv_typeof_chtype=long],
5846 [cf_cv_typeof_chtype=long])
5849 AC_MSG_RESULT($cf_cv_typeof_chtype)
5851 AC_SUBST(cf_cv_typeof_chtype)
5852 AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype)
5854 dnl ---------------------------------------------------------------------------
5855 dnl CF_TYPE_SIGACTION version: 3 updated: 2000/08/12 23:18:52
5856 dnl -----------------
5858 AC_DEFUN([CF_TYPE_SIGACTION],
5860 AC_MSG_CHECKING([for type sigaction_t])
5861 AC_CACHE_VAL(cf_cv_type_sigaction,[
5863 #include <signal.h>],
5865 [cf_cv_type_sigaction=yes],
5866 [cf_cv_type_sigaction=no])])
5867 AC_MSG_RESULT($cf_cv_type_sigaction)
5868 test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION)
5870 dnl ---------------------------------------------------------------------------
5871 dnl CF_UNSIGNED_LITERALS version: 2 updated: 1998/02/07 22:10:16
5872 dnl --------------------
5873 dnl Test if the compiler supports 'U' and 'L' suffixes. Only old compilers
5874 dnl won't, but they're still there.
5875 AC_DEFUN([CF_UNSIGNED_LITERALS],
5877 AC_MSG_CHECKING([if unsigned literals are legal])
5878 AC_CACHE_VAL(cf_cv_unsigned_literals,[
5879 AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1],
5880 [cf_cv_unsigned_literals=yes],
5881 [cf_cv_unsigned_literals=no])
5883 AC_MSG_RESULT($cf_cv_unsigned_literals)
5885 dnl ---------------------------------------------------------------------------
5886 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
5888 dnl Make an uppercase version of a variable
5889 dnl $1=uppercase($2)
5890 AC_DEFUN([CF_UPPER],
5892 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
5894 dnl ---------------------------------------------------------------------------
5895 dnl CF_UTF8_LIB version: 7 updated: 2010/06/20 09:24:28
5897 dnl Check for multibyte support, and if not found, utf8 compatibility library
5898 AC_DEFUN([CF_UTF8_LIB],
5900 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
5901 cf_save_LIBS="$LIBS"
5903 #include <stdlib.h>],[putwc(0,0);],
5904 [cf_cv_utf8_lib=yes],
5906 #include <libutf8.h>],[putwc(0,0);],utf8,
5907 [cf_cv_utf8_lib=add-on],
5908 [cf_cv_utf8_lib=no])
5911 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
5913 if test "$cf_cv_utf8_lib" = "add-on" ; then
5914 AC_DEFINE(HAVE_LIBUTF8_H)
5915 CF_ADD_INCDIR($cf_cv_header_path_utf8)
5916 CF_ADD_LIBDIR($cf_cv_library_path_utf8)
5917 CF_ADD_LIBS($cf_cv_library_file_utf8)
5920 dnl ---------------------------------------------------------------------------
5921 dnl CF_VA_COPY version: 2 updated: 2010/03/04 05:37:29
5923 dnl check for va_copy, part of stdarg.h
5924 dnl Also, workaround for glibc's __va_copy, by checking for both.
5925 AC_DEFUN([CF_VA_COPY],[
5926 AC_CACHE_CHECK(for va_copy, cf_cv_have_va_copy,[
5933 cf_cv_have_va_copy=yes,
5934 cf_cv_have_va_copy=no)])
5936 test "$cf_cv_have_va_copy" = yes && AC_DEFINE(HAVE_VA_COPY)
5938 AC_CACHE_CHECK(for __va_copy, cf_cv_have___va_copy,[
5944 __va_copy(dst, src)],
5945 cf_cv_have___va_copy=yes,
5946 cf_cv_have___va_copy=no)])
5948 test "$cf_cv_have___va_copy" = yes && AC_DEFINE(HAVE___VA_COPY)
5950 dnl ---------------------------------------------------------------------------
5951 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
5953 dnl Use AC_VERBOSE w/o the warnings
5954 AC_DEFUN([CF_VERBOSE],
5955 [test -n "$verbose" && echo " $1" 1>&AC_FD_MSG
5958 dnl ---------------------------------------------------------------------------
5959 dnl CF_WCHAR_TYPE version: 3 updated: 2010/05/26 16:44:57
5961 dnl Check if type wide-character type $1 is declared, and if so, which header
5962 dnl file is needed. The second parameter is used to set a shell variable when
5963 dnl the type is not found. The first parameter sets a shell variable for the
5965 AC_DEFUN([CF_WCHAR_TYPE],
5967 # This is needed on Tru64 5.0 to declare $1
5968 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
5973 #ifdef HAVE_LIBUTF8_H
5974 #include <libutf8.h>
5983 #ifdef HAVE_LIBUTF8_H
5984 #include <libutf8.h>
5988 [cf_cv_$1=unknown])])])
5990 if test "$cf_cv_$1" = yes ; then
5991 AC_DEFINE(NEED_WCHAR_H)
5996 # if we do not find $1 in either place, use substitution to provide a fallback.
5997 if test "$cf_cv_$1" = unknown ; then
6002 # if we find $1 in either place, use substitution to provide a fallback.
6003 if test "$cf_cv_$1" != unknown ; then
6008 dnl ---------------------------------------------------------------------------
6009 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
6011 dnl Check for compiler-support for weak symbols.
6012 dnl This works with "recent" gcc.
6013 AC_DEFUN([CF_WEAK_SYMBOLS],[
6014 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
6017 #include <stdio.h>],
6019 #if defined(__GNUC__)
6020 # if defined __USE_ISOC99
6021 # define _cat_pragma(exp) _Pragma(#exp)
6022 # define _weak_pragma(exp) _cat_pragma(weak name)
6024 # define _weak_pragma(exp)
6026 # define _declare(name) __extension__ extern __typeof__(name) name
6027 # define weak_symbol(name) _weak_pragma(name) _declare(name) __attribute__((weak))
6031 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
6034 dnl ---------------------------------------------------------------------------
6035 dnl CF_WITH_ABI_VERSION version: 1 updated: 2003/09/20 18:12:49
6036 dnl -------------------
6037 dnl Allow library's ABI to be overridden. Generally this happens when a
6038 dnl packager has incremented the ABI past that used in the original package,
6039 dnl and wishes to keep doing this.
6041 dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
6043 AC_DEFUN([CF_WITH_ABI_VERSION],[
6044 test -z "$cf_cv_abi_version" && cf_cv_abi_version=0
6045 AC_ARG_WITH(abi-version,
6046 [ --with-abi-version=XXX override derived ABI version],
6047 [AC_MSG_WARN(overriding ABI version $cf_cv_abi_version to $withval)
6048 cf_cv_abi_version=$withval])
6049 CF_NUMBER_SYNTAX($cf_cv_abi_version,ABI version)
6051 $1_ABI=$cf_cv_abi_version
6054 dnl ---------------------------------------------------------------------------
6055 dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58
6056 dnl --------------------
6057 dnl Command-line option to specify the Ada95 compiler.
6058 AC_DEFUN([CF_WITH_ADA_COMPILER],[
6059 AC_MSG_CHECKING(for ada-compiler)
6060 AC_ARG_WITH(ada-compiler,
6061 [ --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
6062 [cf_ada_compiler=$withval],
6063 [cf_ada_compiler=gnatmake])
6064 AC_SUBST(cf_ada_compiler)
6065 AC_MSG_RESULT($cf_ada_compiler)
6067 dnl ---------------------------------------------------------------------------
6068 dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58
6069 dnl -------------------
6070 dnl Command-line option to specify where Ada includes will install.
6071 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
6072 AC_MSG_CHECKING(for ada-include)
6073 CF_WITH_PATH(ada-include,
6074 [ --with-ada-include=DIR Ada includes are in DIR],
6076 PREFIX/share/ada/adainclude,
6077 [$]prefix/share/ada/adainclude)
6078 AC_SUBST(ADA_INCLUDE)
6079 AC_MSG_RESULT($ADA_INCLUDE)
6081 dnl ---------------------------------------------------------------------------
6082 dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58
6083 dnl -------------------
6084 dnl Command-line option to specify where Ada objects will install.
6085 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
6086 AC_MSG_CHECKING(for ada-objects)
6087 CF_WITH_PATH(ada-objects,
6088 [ --with-ada-objects=DIR Ada objects are in DIR],
6090 PREFIX/lib/ada/adalib,
6091 [$]prefix/lib/ada/adalib)
6092 AC_SUBST(ADA_OBJECTS)
6093 AC_MSG_RESULT($ADA_OBJECTS)
6095 dnl ---------------------------------------------------------------------------
6096 dnl CF_WITH_ADA_SHAREDLIB version: 2 updated: 2010/06/26 17:35:58
6097 dnl ---------------------
6098 dnl Command-line option to specify if an Ada95 shared-library should be built,
6099 dnl and optionally what its soname should be.
6100 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
6101 AC_MSG_CHECKING(if an Ada95 shared-library should be built)
6102 AC_ARG_WITH(ada-sharedlib,
6103 [ --with-ada-sharedlib=XX build Ada95 shared-library],
6104 [with_ada_sharedlib=$withval],
6105 [with_ada_sharedlib=no])
6106 AC_MSG_RESULT($with_ada_sharedlib)
6108 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
6109 MAKE_ADA_SHAREDLIB="#"
6111 if test "x$with_ada_sharedlib" != xno
6114 if test "x$with_ada_sharedlib" != xyes
6116 ADA_SHAREDLIB="$with_ada_sharedlib"
6120 AC_SUBST(ADA_SHAREDLIB)
6121 AC_SUBST(MAKE_ADA_SHAREDLIB)
6123 dnl ---------------------------------------------------------------------------
6124 dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
6125 dnl ----------------
6126 dnl Configure-option for dbmalloc. The optional parameter is used to override
6127 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
6128 AC_DEFUN([CF_WITH_DBMALLOC],[
6129 CF_NO_LEAKS_OPTION(dbmalloc,
6130 [ --with-dbmalloc test: use Conor Cahill's dbmalloc library],
6133 if test "$with_dbmalloc" = yes ; then
6134 AC_CHECK_HEADER(dbmalloc.h,
6135 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
6138 dnl ---------------------------------------------------------------------------
6139 dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
6141 dnl Configure-option for dmalloc. The optional parameter is used to override
6142 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
6143 AC_DEFUN([CF_WITH_DMALLOC],[
6144 CF_NO_LEAKS_OPTION(dmalloc,
6145 [ --with-dmalloc test: use Gray Watson's dmalloc library],
6148 if test "$with_dmalloc" = yes ; then
6149 AC_CHECK_HEADER(dmalloc.h,
6150 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
6153 dnl ---------------------------------------------------------------------------
6154 dnl CF_WITH_GPM version: 7 updated: 2008/03/23 14:48:54
6157 dnl The option parameter (if neither yes/no) is assumed to be the name of
6158 dnl the gpm library, e.g., for dynamic loading.
6159 AC_DEFUN([CF_WITH_GPM],
6161 AC_MSG_CHECKING(if you want to link with the GPM mouse library)
6163 [ --with-gpm use Alessandro Rubini's GPM library],
6164 [with_gpm=$withval],
6166 AC_MSG_RESULT($with_gpm)
6168 if test "$with_gpm" != no ; then
6169 AC_CHECK_HEADER(gpm.h,[
6170 AC_DEFINE(HAVE_GPM_H)
6171 if test "$with_gpm" != yes && test "$with_gpm" != maybe ; then
6172 CF_VERBOSE(assuming we really have GPM library)
6173 AC_DEFINE(HAVE_LIBGPM)
6175 AC_CHECK_LIB(gpm,Gpm_Open,[:],[
6176 AC_MSG_ERROR(Cannot link with GPM library)
6181 test "$with_gpm" != maybe && AC_MSG_WARN(Cannot find GPM header)
6186 dnl ---------------------------------------------------------------------------
6187 dnl CF_WITH_LIBTOOL version: 26 updated: 2010/10/23 15:55:24
6189 dnl Provide a configure option to incorporate libtool. Define several useful
6190 dnl symbols for the makefile rules.
6192 dnl The reference to AC_PROG_LIBTOOL does not normally work, since it uses
6193 dnl macros from libtool.m4 which is in the aclocal directory of automake.
6194 dnl Following is a simple script which turns on the AC_PROG_LIBTOOL macro.
6195 dnl But that still does not work properly since the macro is expanded outside
6196 dnl the CF_WITH_LIBTOOL macro:
6199 dnl ACLOCAL=`aclocal --print-ac-dir`
6200 dnl if test -z "$ACLOCAL" ; then
6201 dnl echo cannot find aclocal directory
6203 dnl elif test ! -f $ACLOCAL/libtool.m4 ; then
6204 dnl echo cannot find libtool.m4 file
6208 dnl LOCAL=aclocal.m4
6209 dnl ORIG=aclocal.m4.orig
6211 dnl trap "mv $ORIG $LOCAL" 0 1 2 5 15
6215 dnl # sed the LIBTOOL= assignment to omit the current directory?
6216 dnl sed -e 's/^LIBTOOL=.*/LIBTOOL=${LIBTOOL:-libtool}/' $ACLOCAL/libtool.m4 >>$LOCAL
6217 dnl cat $ORIG >>$LOCAL
6221 AC_DEFUN([CF_WITH_LIBTOOL],
6223 AC_REQUIRE([CF_DISABLE_LIBTOOL_VERSION])
6224 ifdef([AC_PROG_LIBTOOL],,[
6227 # common library maintenance symbols that are convenient for libtool scripts:
6228 LIB_CREATE='${AR} -cr'
6229 LIB_OBJECT='${OBJECTS}'
6233 # symbols used to prop libtool up to enable it to determine what it should be
6241 AC_MSG_CHECKING(if you want to build libraries with libtool)
6242 AC_ARG_WITH(libtool,
6243 [ --with-libtool generate libraries with libtool],
6244 [with_libtool=$withval],
6246 AC_MSG_RESULT($with_libtool)
6247 if test "$with_libtool" != "no"; then
6248 ifdef([AC_PROG_LIBTOOL],[
6249 # missing_content_AC_PROG_LIBTOOL{{
6251 # missing_content_AC_PROG_LIBTOOL}}
6253 if test "$with_libtool" != "yes" ; then
6254 CF_PATH_SYNTAX(with_libtool)
6255 LIBTOOL=$with_libtool
6257 AC_PATH_PROG(LIBTOOL,libtool)
6259 if test -z "$LIBTOOL" ; then
6260 AC_MSG_ERROR(Cannot find libtool)
6263 LIB_CREATE='${LIBTOOL} --mode=link ${CC} -rpath ${DESTDIR}${libdir} ${LIBTOOL_VERSION} `cut -f1 ${srcdir}/VERSION` ${LIBTOOL_OPTS} ${LT_UNDEF} -o'
6264 LIB_OBJECT='${OBJECTS:.o=.lo}'
6266 LIB_CLEAN='${LIBTOOL} --mode=clean'
6267 LIB_COMPILE='${LIBTOOL} --mode=compile'
6268 LIB_LINK='${LIBTOOL} --mode=link ${CC} ${LIBTOOL_OPTS}'
6269 LIB_INSTALL='${LIBTOOL} --mode=install'
6270 LIB_UNINSTALL='${LIBTOOL} --mode=uninstall'
6273 # Show the version of libtool
6274 AC_MSG_CHECKING(version of libtool)
6276 # Save the version in a cache variable - this is not entirely a good
6277 # thing, but the version string from libtool is very ugly, and for
6278 # bug reports it might be useful to have the original string. "("
6279 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.]].*//'`
6280 AC_MSG_RESULT($cf_cv_libtool_version)
6281 if test -z "$cf_cv_libtool_version" ; then
6282 AC_MSG_ERROR(This is not GNU libtool)
6285 # special hack to add -no-undefined (which libtool should do for itself)
6287 case "$cf_cv_system_name" in #(vi
6288 cygwin*|mingw32*|uwin*|aix[[456]]) #(vi
6289 LT_UNDEF=-no-undefined
6292 AC_SUBST([LT_UNDEF])
6294 # special hack to add --tag option for C++ compiler
6295 case $cf_cv_libtool_version in #(vi
6296 1.[[5-9]]*|[[2-9]].[[0-9.a-z]]*) #(vi
6297 LIBTOOL_CXX="$LIBTOOL --tag=CXX"
6298 LIBTOOL="$LIBTOOL --tag=CC"
6301 LIBTOOL_CXX="$LIBTOOL"
6309 test -z "$LIBTOOL" && ECHO_LT=
6312 AC_SUBST(LIBTOOL_CXX)
6313 AC_SUBST(LIBTOOL_OPTS)
6315 AC_SUBST(LIB_CREATE)
6316 AC_SUBST(LIB_OBJECT)
6317 AC_SUBST(LIB_SUFFIX)
6321 AC_SUBST(LIB_COMPILE)
6323 AC_SUBST(LIB_INSTALL)
6324 AC_SUBST(LIB_UNINSTALL)
6327 dnl ---------------------------------------------------------------------------
6328 dnl CF_WITH_PATH version: 10 updated: 2010/10/23 15:44:18
6330 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
6331 dnl defaulting to yes/no.
6333 dnl $1 = option name
6335 dnl $3 = environment variable to set
6336 dnl $4 = default value, shown in the help-message, must be a constant
6337 dnl $5 = default value, if it's an expression & cannot be in the help-message
6339 AC_DEFUN([CF_WITH_PATH],
6340 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
6341 ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
6342 if ifelse([$5],,true,[test -n "$5"]) ; then
6343 CF_PATH_SYNTAX(withval)
6348 dnl ---------------------------------------------------------------------------
6349 dnl CF_WITH_PATHLIST version: 7 updated: 2010/10/23 16:10:30
6350 dnl ----------------
6351 dnl Process an option specifying a list of colon-separated paths.
6353 dnl $1 = option name
6355 dnl $3 = environment variable to set
6356 dnl $4 = default value, shown in the help-message, must be a constant
6357 dnl $5 = default value, if it's an expression & cannot be in the help-message
6358 dnl $6 = flag to tell if we want to define or substitute
6360 AC_DEFUN([CF_WITH_PATHLIST],[
6361 AC_REQUIRE([CF_PATHSEP])
6362 AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
6363 ifelse($4,,[withval=${$3}],[withval=${$3:-ifelse($5,,$4,$5)}]))dnl
6365 IFS="${IFS:- }"; ac_save_ifs="$IFS"; IFS="${PATH_SEPARATOR}"
6367 for cf_src_path in $withval
6369 CF_PATH_SYNTAX(cf_src_path)
6370 test -n "$cf_dst_path" && cf_dst_path="${cf_dst_path}:"
6371 cf_dst_path="${cf_dst_path}${cf_src_path}"
6376 # Strip single quotes from the value, e.g., when it was supplied as a literal
6378 case $cf_dst_path in #(vi
6380 cf_dst_path=`echo $cf_dst_path |sed -e s/\'// -e s/\'\$//`
6383 cf_dst_path=`echo "$cf_dst_path" | sed -e 's/\\\\/\\\\\\\\/g'`
6386 eval '$3="$cf_dst_path"'
6390 dnl ---------------------------------------------------------------------------
6391 dnl CF_WITH_PTHREAD version: 3 updated: 2010/05/29 16:31:02
6393 dnl Check for POSIX thread library.
6394 AC_DEFUN([CF_WITH_PTHREAD],
6396 AC_MSG_CHECKING(if you want to link with the pthread library)
6397 AC_ARG_WITH(pthread,
6398 [ --with-pthread use POSIX thread library],
6399 [with_pthread=$withval],
6401 AC_MSG_RESULT($with_pthread)
6403 if test "$with_pthread" != no ; then
6404 AC_CHECK_HEADER(pthread.h,[
6405 AC_DEFINE(HAVE_PTHREADS_H)
6407 AC_MSG_CHECKING(if we can link with the pthread library)
6408 cf_save_LIBS="$LIBS"
6411 #include <pthread.h>
6413 int rc = pthread_create(0,0,0,0);
6414 ],[with_pthread=yes],[with_pthread=no])
6415 LIBS="$cf_save_LIBS"
6416 AC_MSG_RESULT($with_pthread)
6418 if test "$with_pthread" = yes ; then
6420 AC_DEFINE(HAVE_LIBPTHREADS)
6422 AC_MSG_ERROR(Cannot link with pthread library)
6427 dnl ---------------------------------------------------------------------------
6428 dnl CF_WITH_REL_VERSION version: 1 updated: 2003/09/20 18:12:49
6429 dnl -------------------
6430 dnl Allow library's release-version to be overridden. Generally this happens when a
6431 dnl packager has incremented the release-version past that used in the original package,
6432 dnl and wishes to keep doing this.
6434 dnl $1 is the package name, if any, to derive corresponding {package}_MAJOR
6435 dnl and {package}_MINOR symbols
6437 AC_DEFUN([CF_WITH_REL_VERSION],[
6438 test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0
6439 AC_ARG_WITH(rel-version,
6440 [ --with-rel-version=XXX override derived release version],
6441 [AC_MSG_WARN(overriding release version $cf_cv_rel_version to $withval)
6442 cf_cv_rel_version=$withval])
6444 CF_NUMBER_SYNTAX($cf_cv_rel_version,Release version)
6446 $1_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'`
6447 $1_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[[^.]]*//' -e 's/^\.//' -e 's/\..*//'`
6448 CF_NUMBER_SYNTAX([$]$1_MAJOR,Release major-version)
6449 CF_NUMBER_SYNTAX([$]$1_MINOR,Release minor-version)
6452 dnl ---------------------------------------------------------------------------
6453 dnl CF_WITH_SYSMOUSE version: 2 updated: 2003/03/22 19:13:43
6454 dnl ----------------
6455 dnl If we can compile with sysmouse, make it available unless it is not wanted.
6456 AC_DEFUN([CF_WITH_SYSMOUSE],[
6457 # not everyone has "test -c"
6458 if test -c /dev/sysmouse 2>/dev/null ; then
6459 AC_MSG_CHECKING(if you want to use sysmouse)
6460 AC_ARG_WITH(sysmouse,
6461 [ --with-sysmouse use sysmouse (FreeBSD console)],
6462 [cf_with_sysmouse=$withval],
6463 [cf_with_sysmouse=maybe])
6464 if test "$cf_with_sysmouse" != no ; then
6466 #include <osreldate.h>
6467 #if (__FreeBSD_version >= 400017)
6468 #include <sys/consio.h>
6469 #include <sys/fbio.h>
6471 #include <machine/console.h>
6474 struct mouse_info the_mouse;
6475 ioctl(0, CONS_MOUSECTL, &the_mouse);
6476 ],[cf_with_sysmouse=yes],[cf_with_sysmouse=no])
6478 AC_MSG_RESULT($cf_with_sysmouse)
6479 test "$cf_with_sysmouse" = yes && AC_DEFINE(USE_SYSMOUSE)
6482 dnl ---------------------------------------------------------------------------
6483 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
6484 dnl ----------------
6485 AC_DEFUN([CF_WITH_VALGRIND],[
6486 CF_NO_LEAKS_OPTION(valgrind,
6487 [ --with-valgrind test: use valgrind],
6490 dnl ---------------------------------------------------------------------------
6491 dnl CF_XOPEN_SOURCE version: 35 updated: 2011/02/20 20:37:37
6493 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
6494 dnl or adapt to the vendor's definitions to get equivalent functionality,
6495 dnl without losing the common non-POSIX features.
6498 dnl $1 is the nominal value for _XOPEN_SOURCE
6499 dnl $2 is the nominal value for _POSIX_C_SOURCE
6500 AC_DEFUN([CF_XOPEN_SOURCE],[
6502 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
6503 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
6506 case $host_os in #(vi
6508 cf_xopen_source="-D_ALL_SOURCE"
6513 darwin[[0-8]].*) #(vi
6514 cf_xopen_source="-D_APPLE_C_SOURCE"
6517 cf_xopen_source="-D_DARWIN_C_SOURCE"
6519 freebsd*|dragonfly*) #(vi
6520 # 5.x headers associate
6521 # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
6522 # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
6523 cf_POSIX_C_SOURCE=200112L
6525 cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
6528 cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
6531 cf_xopen_source="-D_HPUX_SOURCE"
6534 cf_xopen_source="-D_SGI_SOURCE"
6536 linux*|gnu*|mint*|k*bsd*-gnu) #(vi
6540 # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <arpa/inet.h>
6543 # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
6546 # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
6549 cf_xopen_source="-D_OSF_SOURCE"
6552 cf_xopen_source="-D_QNX_SOURCE"
6555 # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
6557 solaris2.1[[0-9]]) #(vi
6558 cf_xopen_source="-D__EXTENSIONS__ -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
6560 solaris2.[[1-9]]) #(vi
6561 cf_xopen_source="-D__EXTENSIONS__"
6564 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
6565 AC_TRY_COMPILE([#include <sys/types.h>],[
6566 #ifndef _XOPEN_SOURCE
6569 [cf_cv_xopen_source=no],
6570 [cf_save="$CPPFLAGS"
6571 CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
6572 AC_TRY_COMPILE([#include <sys/types.h>],[
6573 #ifdef _XOPEN_SOURCE
6576 [cf_cv_xopen_source=no],
6577 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
6581 if test "$cf_cv_xopen_source" != no ; then
6582 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
6583 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
6584 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
6585 CF_ADD_CFLAGS($cf_temp_xopen_source)
6587 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
6591 if test -n "$cf_xopen_source" ; then
6592 CF_ADD_CFLAGS($cf_xopen_source)