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.558 2011/06/05 00:13:55 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_ACVERSION_CHECK version: 2 updated: 2011/05/08 11:22:03
66 dnl ------------------
67 dnl Conditionally generate script according to whether we're using a given autoconf.
69 dnl $1 = version to compare against
70 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
71 dnl $3 = code to use if AC_ACVERSION is older than $1.
72 define(CF_ACVERSION_CHECK,
74 ifdef([m4_version_compare],
75 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
76 [CF_ACVERSION_COMPARE(
77 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
78 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
79 dnl ---------------------------------------------------------------------------
80 dnl CF_ACVERSION_COMPARE version: 2 updated: 2011/04/14 20:56:50
81 dnl --------------------
82 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
83 dnl MAJOR2, MINOR2, TERNARY2,
84 dnl PRINTABLE2, not FOUND, FOUND)
85 define(CF_ACVERSION_COMPARE,
86 [ifelse(builtin([eval], [$2 < $5]), 1,
87 [ifelse([$8], , ,[$8])],
88 [ifelse([$9], , ,[$9])])])dnl
89 dnl ---------------------------------------------------------------------------
90 dnl CF_ADA_INCLUDE_DIRS version: 6 updated: 2010/02/26 19:52:07
91 dnl -------------------
92 dnl Construct the list of include-options for the C programs in the Ada95
94 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
96 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
97 if test "$srcdir" != "."; then
98 ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
100 if test "$GCC" != yes; then
101 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
102 elif test "$includedir" != "/usr/include"; then
103 if test "$includedir" = '${prefix}/include' ; then
104 if test $prefix != /usr ; then
105 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
108 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
113 dnl ---------------------------------------------------------------------------
114 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
116 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
117 AC_DEFUN([CF_ADD_ADAFLAGS],[
118 ADAFLAGS="$ADAFLAGS $1"
121 dnl ---------------------------------------------------------------------------
122 dnl CF_ADD_CFLAGS version: 10 updated: 2010/05/26 05:38:42
124 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
125 dnl The second parameter if given makes this macro verbose.
127 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
128 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
129 dnl confused by the quotes (which require backslashes to keep them usable).
130 AC_DEFUN([CF_ADD_CFLAGS],
135 cf_new_extra_cppflags=
137 for cf_add_cflags in $1
139 case $cf_fix_cppflags in
141 case $cf_add_cflags in #(vi
142 -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi
143 case $cf_add_cflags in
145 cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
147 test "${cf_add_cflags}" != "${cf_tst_cflags}" \
148 && test -z "${cf_tst_cflags}" \
149 && cf_fix_cppflags=yes
151 if test $cf_fix_cppflags = yes ; then
152 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
154 elif test "${cf_tst_cflags}" = "\"'" ; then
155 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
161 *$cf_add_cflags) #(vi
164 case $cf_add_cflags in #(vi
166 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
167 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
170 cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
175 cf_new_cflags="$cf_new_cflags $cf_add_cflags"
180 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
182 cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
184 test "${cf_add_cflags}" != "${cf_tst_cflags}" \
185 && test -z "${cf_tst_cflags}" \
186 && cf_fix_cppflags=no
191 if test -n "$cf_new_cflags" ; then
192 ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
193 CFLAGS="$CFLAGS $cf_new_cflags"
196 if test -n "$cf_new_cppflags" ; then
197 ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
198 CPPFLAGS="$CPPFLAGS $cf_new_cppflags"
201 if test -n "$cf_new_extra_cppflags" ; then
202 ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
203 EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
206 AC_SUBST(EXTRA_CPPFLAGS)
209 dnl ---------------------------------------------------------------------------
210 dnl CF_ADD_INCDIR version: 13 updated: 2010/05/26 16:44:57
212 dnl Add an include-directory to $CPPFLAGS. Don't add /usr/include, since it's
213 dnl redundant. We don't normally need to add -I/usr/local/include for gcc,
214 dnl but old versions (and some misinstalled ones) need that. To make things
215 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
216 dnl the include-path).
217 AC_DEFUN([CF_ADD_INCDIR],
219 if test -n "$1" ; then
220 for cf_add_incdir in $1
222 while test $cf_add_incdir != /usr/include
224 if test -d $cf_add_incdir
227 if test -n "$CFLAGS$CPPFLAGS" ; then
228 # a loop is needed to ensure we can add subdirs of existing dirs
229 for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
230 if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
231 cf_have_incdir=yes; break
236 if test "$cf_have_incdir" = no ; then
237 if test "$cf_add_incdir" = /usr/local/include ; then
240 cf_save_CPPFLAGS=$CPPFLAGS
241 CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
242 AC_TRY_COMPILE([#include <stdio.h>],
245 [cf_have_incdir=yes])
246 CPPFLAGS=$cf_save_CPPFLAGS
251 if test "$cf_have_incdir" = no ; then
252 CF_VERBOSE(adding $cf_add_incdir to include-path)
253 ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
255 cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
256 test "$cf_top_incdir" = "$cf_add_incdir" && break
257 cf_add_incdir="$cf_top_incdir"
266 dnl ---------------------------------------------------------------------------
267 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
269 dnl Add a library, used to enforce consistency.
271 dnl $1 = library to add, without the "-l"
272 dnl $2 = variable to update (default $LIBS)
273 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
274 dnl ---------------------------------------------------------------------------
275 dnl CF_ADD_LIBDIR version: 9 updated: 2010/05/26 16:44:57
277 dnl Adds to the library-path
279 dnl Some machines have trouble with multiple -L options.
281 dnl $1 is the (list of) directory(s) to add
282 dnl $2 is the optional name of the variable to update (default LDFLAGS)
284 AC_DEFUN([CF_ADD_LIBDIR],
286 if test -n "$1" ; then
287 for cf_add_libdir in $1
289 if test $cf_add_libdir = /usr/lib ; then
291 elif test -d $cf_add_libdir
294 if test -n "$LDFLAGS$LIBS" ; then
295 # a loop is needed to ensure we can add subdirs of existing dirs
296 for cf_test_libdir in $LDFLAGS $LIBS ; do
297 if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
298 cf_have_libdir=yes; break
302 if test "$cf_have_libdir" = no ; then
303 CF_VERBOSE(adding $cf_add_libdir to library-path)
304 ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
310 dnl ---------------------------------------------------------------------------
311 dnl CF_ADD_LIBS version: 1 updated: 2010/06/02 05:03:05
313 dnl Add one or more libraries, used to enforce consistency.
315 dnl $1 = libraries to add, with the "-l", etc.
316 dnl $2 = variable to update (default $LIBS)
317 AC_DEFUN([CF_ADD_LIBS],[ifelse($2,,LIBS,[$2])="$1 [$]ifelse($2,,LIBS,[$2])"])dnl
318 dnl ---------------------------------------------------------------------------
319 dnl CF_ADD_SUBDIR_PATH version: 3 updated: 2010/07/03 20:58:12
320 dnl ------------------
321 dnl Append to a search-list for a nonstandard header/lib-file
322 dnl $1 = the variable to return as result
323 dnl $2 = the package name
324 dnl $3 = the subdirectory, e.g., bin, include or lib
325 dnl $4 = the directory under which we will test for subdirectories
326 dnl $5 = a directory that we do not want $4 to match
327 AC_DEFUN([CF_ADD_SUBDIR_PATH],
329 test "$4" != "$5" && \
331 ifelse([$5],NONE,,[(test $5 = NONE || test "$4" != "$5") &&]) {
332 test -n "$verbose" && echo " ... testing for $3-directories under $4"
333 test -d $4/$3 && $1="[$]$1 $4/$3"
334 test -d $4/$3/$2 && $1="[$]$1 $4/$3/$2"
335 test -d $4/$3/$2/$3 && $1="[$]$1 $4/$3/$2/$3"
336 test -d $4/$2/$3 && $1="[$]$1 $4/$2/$3"
337 test -d $4/$2/$3/$2 && $1="[$]$1 $4/$2/$3/$2"
340 dnl ---------------------------------------------------------------------------
341 dnl CF_ANSI_CC_CHECK version: 10 updated: 2010/10/23 15:52:32
343 dnl This is adapted from the macros 'fp_PROG_CC_STDC' and 'fp_C_PROTOTYPES'
344 dnl in the sharutils 4.2 distribution.
345 AC_DEFUN([CF_ANSI_CC_CHECK],
347 AC_CACHE_CHECK(for ${CC:-cc} option to accept ANSI C, cf_cv_ansi_cc,[
349 cf_save_CFLAGS="$CFLAGS"
350 cf_save_CPPFLAGS="$CPPFLAGS"
351 # Don't try gcc -ansi; that turns off useful extensions and
352 # breaks some systems' header files.
354 # Ultrix and OSF/1 -std1
355 # HP-UX -Aa -D_HPUX_SOURCE
357 # UnixWare 1.2 (cannot use -Xc, since ANSI/POSIX clashes)
358 for cf_arg in "-DCC_HAS_PROTOS" \
363 "-Aa -D_HPUX_SOURCE" \
366 CF_ADD_CFLAGS($cf_arg)
369 #ifndef CC_HAS_PROTOS
370 #if !defined(__STDC__) || (__STDC__ != 1)
375 int test (int i, double x);
376 struct s1 {int (*f) (int a);};
377 struct s2 {int (*f) (double a);};],
378 [cf_cv_ansi_cc="$cf_arg"; break])
380 CFLAGS="$cf_save_CFLAGS"
381 CPPFLAGS="$cf_save_CPPFLAGS"
384 if test "$cf_cv_ansi_cc" != "no"; then
385 if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then
386 CF_ADD_CFLAGS($cf_cv_ansi_cc)
388 AC_DEFINE(CC_HAS_PROTOS)
392 dnl ---------------------------------------------------------------------------
393 dnl CF_ANSI_CC_REQD version: 4 updated: 2008/03/23 14:48:54
395 dnl For programs that must use an ANSI compiler, obtain compiler options that
396 dnl will make it recognize prototypes. We'll do preprocessor checks in other
397 dnl macros, since tools such as unproto can fake prototypes, but only part of
398 dnl the preprocessor.
399 AC_DEFUN([CF_ANSI_CC_REQD],
400 [AC_REQUIRE([CF_ANSI_CC_CHECK])
401 if test "$cf_cv_ansi_cc" = "no"; then
403 [Your compiler does not appear to recognize prototypes.
404 You have the following choices:
405 a. adjust your compiler options
406 b. get an up-to-date compiler
407 c. use a wrapper such as unproto])
410 dnl ---------------------------------------------------------------------------
411 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
413 dnl Allow user to disable a normally-on option.
414 AC_DEFUN([CF_ARG_DISABLE],
415 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
416 dnl ---------------------------------------------------------------------------
417 dnl CF_ARG_OPTION version: 4 updated: 2010/05/26 05:38:42
419 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
425 dnl $3 = action to perform if option is not default
426 dnl $4 = action if perform if option is default
427 dnl $5 = default option value (either 'yes' or 'no')
428 AC_DEFUN([CF_ARG_OPTION],
429 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
430 if test "$enableval" != "$5" ; then
432 ,[ $3]) ifelse([$4],,,[
435 fi],[enableval=$5 ifelse([$4],,,[
439 dnl ---------------------------------------------------------------------------
440 dnl CF_AR_FLAGS version: 5 updated: 2010/05/20 20:24:29
442 dnl Check for suitable "ar" (archiver) options for updating an archive.
443 AC_DEFUN([CF_AR_FLAGS],[
444 AC_REQUIRE([CF_PROG_AR])
446 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
447 cf_cv_ar_flags=unknown
448 for cf_ar_flags in -curv curv -crv crv -cqv cqv -rv rv
451 # check if $ARFLAGS already contains this choice
452 if test "x$ARFLAGS" != "x" ; then
453 cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
454 if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
460 rm -f conftest.$ac_cv_objext
463 cat >conftest.$ac_ext <<EOF
464 #line __oline__ "configure"
465 int testdata[[3]] = { 123, 456, 789 };
467 if AC_TRY_EVAL(ac_compile) ; then
468 echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
469 $AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null
470 if test -f conftest.a ; then
471 cf_cv_ar_flags=$cf_ar_flags
475 CF_VERBOSE(cannot compile test-program)
479 rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
482 if test -n "$ARFLAGS" ; then
483 if test -n "$cf_cv_ar_flags" ; then
484 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
487 ARFLAGS=$cf_cv_ar_flags
492 dnl ---------------------------------------------------------------------------
493 dnl CF_AWK_BIG_PRINTF version: 3 updated: 2008/12/27 12:30:03
494 dnl -----------------
495 dnl Check if awk can handle big strings using printf. Some older versions of
496 dnl awk choke on large strings passed via "%s".
498 dnl $1 = desired string size
499 dnl $2 = variable to set with result
500 AC_DEFUN([CF_AWK_BIG_PRINTF],
507 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' \
508 | $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
516 dnl ---------------------------------------------------------------------------
517 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
519 dnl Test if 'bool' is a builtin type in the configured C++ compiler. Some
520 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
521 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
523 dnl Treat the configuration-variable specially here, since we're directly
524 dnl substituting its value (i.e., 1/0).
526 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
527 AC_DEFUN([CF_BOOL_DECL],
529 AC_MSG_CHECKING(if we should include stdbool.h)
531 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
532 AC_TRY_COMPILE([],[bool foo = false],
533 [cf_cv_header_stdbool_h=0],
538 ],[bool foo = false],
539 [cf_cv_header_stdbool_h=1],
540 [cf_cv_header_stdbool_h=0])])])
542 if test "$cf_cv_header_stdbool_h" = 1
543 then AC_MSG_RESULT(yes)
544 else AC_MSG_RESULT(no)
547 AC_MSG_CHECKING([for builtin bool type])
549 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
552 #include <sys/types.h>
554 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
555 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
558 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
559 then AC_MSG_RESULT(yes)
560 else AC_MSG_RESULT(no)
563 dnl ---------------------------------------------------------------------------
564 dnl CF_BOOL_SIZE version: 12 updated: 2006/12/16 12:33:30
566 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
567 dnl Don't bother looking for bool.h, since it's been deprecated.
569 dnl If the current compiler is C rather than C++, we get the bool definition
570 dnl from <stdbool.h>.
571 AC_DEFUN([CF_BOOL_SIZE],
573 AC_MSG_CHECKING([for size of bool])
574 AC_CACHE_VAL(cf_cv_type_of_bool,[
580 #if defined(__cplusplus)
582 #ifdef HAVE_GXX_BUILTIN_H
583 #include <g++/builtin.h>
584 #elif HAVE_GPP_BUILTIN_H
585 #include <gpp/builtin.h>
592 #if $cf_cv_header_stdbool_h
600 FILE *fp = fopen("cf_test.out", "w");
604 fputs("unsigned ", fp);
605 if (sizeof(x) == sizeof(int)) fputs("int", fp);
606 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
607 else if (sizeof(x) == sizeof(short))fputs("short",fp);
608 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
611 ${cf_cv_main_return:-return}(0);
614 [cf_cv_type_of_bool=`cat cf_test.out`
615 if test -z "$cf_cv_type_of_bool"; then
616 cf_cv_type_of_bool=unknown
618 [cf_cv_type_of_bool=unknown],
619 [cf_cv_type_of_bool=unknown])
622 AC_MSG_RESULT($cf_cv_type_of_bool)
623 if test "$cf_cv_type_of_bool" = unknown ; then
624 case .$NCURSES_BOOL in #(vi
625 .auto|.) NCURSES_BOOL=unsigned;;
627 AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
628 cf_cv_type_of_bool=$NCURSES_BOOL
631 dnl ---------------------------------------------------------------------------
632 dnl CF_BUILD_CC version: 6 updated: 2006/10/14 15:23:15
634 dnl If we're cross-compiling, allow the user to override the tools and their
635 dnl options. The configure script is oriented toward identifying the host
636 dnl compiler, etc., but we need a build compiler to generate parts of the
639 dnl $1 = default for $CPPFLAGS
640 dnl $2 = default for $LIBS
641 AC_DEFUN([CF_BUILD_CC],[
642 AC_REQUIRE([CF_PROG_EXT])
643 if test "$cross_compiling" = yes ; then
645 # defaults that we might want to override
646 : ${BUILD_CFLAGS:=''}
647 : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
648 : ${BUILD_LDFLAGS:=''}
649 : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
650 : ${BUILD_EXEEXT:='$x'}
651 : ${BUILD_OBJEXT:='o'}
653 AC_ARG_WITH(build-cc,
654 [ --with-build-cc=XXX the build C compiler ($BUILD_CC)],
655 [BUILD_CC="$withval"],
656 [AC_CHECK_PROGS(BUILD_CC, gcc cc cl)])
657 AC_MSG_CHECKING(for native build C compiler)
658 AC_MSG_RESULT($BUILD_CC)
660 AC_MSG_CHECKING(for native build C preprocessor)
661 AC_ARG_WITH(build-cpp,
662 [ --with-build-cpp=XXX the build C preprocessor ($BUILD_CPP)],
663 [BUILD_CPP="$withval"],
664 [BUILD_CPP='${BUILD_CC} -E'])
665 AC_MSG_RESULT($BUILD_CPP)
667 AC_MSG_CHECKING(for native build C flags)
668 AC_ARG_WITH(build-cflags,
669 [ --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
670 [BUILD_CFLAGS="$withval"])
671 AC_MSG_RESULT($BUILD_CFLAGS)
673 AC_MSG_CHECKING(for native build C preprocessor-flags)
674 AC_ARG_WITH(build-cppflags,
675 [ --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
676 [BUILD_CPPFLAGS="$withval"])
677 AC_MSG_RESULT($BUILD_CPPFLAGS)
679 AC_MSG_CHECKING(for native build linker-flags)
680 AC_ARG_WITH(build-ldflags,
681 [ --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
682 [BUILD_LDFLAGS="$withval"])
683 AC_MSG_RESULT($BUILD_LDFLAGS)
685 AC_MSG_CHECKING(for native build linker-libraries)
686 AC_ARG_WITH(build-libs,
687 [ --with-build-libs=XXX the build libraries (${BUILD_LIBS})],
688 [BUILD_LIBS="$withval"])
689 AC_MSG_RESULT($BUILD_LIBS)
691 # this assumes we're on Unix.
695 : ${BUILD_CC:='${CC}'}
697 if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
698 AC_MSG_ERROR([Cross-build requires two compilers.
699 Use --with-build-cc to specify the native compiler.])
703 : ${BUILD_CC:='${CC}'}
704 : ${BUILD_CPP:='${CPP}'}
705 : ${BUILD_CFLAGS:='${CFLAGS}'}
706 : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
707 : ${BUILD_LDFLAGS:='${LDFLAGS}'}
708 : ${BUILD_LIBS:='${LIBS}'}
709 : ${BUILD_EXEEXT:='$x'}
710 : ${BUILD_OBJEXT:='o'}
715 AC_SUBST(BUILD_CFLAGS)
716 AC_SUBST(BUILD_CPPFLAGS)
717 AC_SUBST(BUILD_LDFLAGS)
719 AC_SUBST(BUILD_EXEEXT)
720 AC_SUBST(BUILD_OBJEXT)
722 dnl ---------------------------------------------------------------------------
723 dnl CF_CFG_DEFAULTS version: 8 updated: 2011/06/04 20:09:13
725 dnl Determine the default configuration into which we'll install ncurses. This
726 dnl can be overridden by the user's command-line options. There's two items to
728 dnl 1. the prefix (e.g., /usr)
729 dnl 2. the header files (e.g., /usr/include/ncurses)
730 dnl We'll look for a previous installation of ncurses and use the same defaults.
732 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
733 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
734 dnl programs from a vendor's.
735 AC_DEFUN([CF_CFG_DEFAULTS],
737 AC_MSG_CHECKING(for prefix)
738 if test "x$prefix" = "xNONE" ; then
739 case "$cf_cv_system_name" in
740 # non-vendor systems don't have a conflict
741 openbsd*|freebsd*|mirbsd*|linux*|cygwin*|k*bsd*-gnu)
744 *) prefix=$ac_default_prefix
748 AC_MSG_RESULT($prefix)
750 if test "x$prefix" = "xNONE" ; then
751 AC_MSG_CHECKING(for default include-directory)
752 test -n "$verbose" && echo 1>&AC_FD_MSG
755 $includedir/ncurses \
757 $prefix/include/ncurses \
759 /usr/local/include/ncurses \
763 cf_dir=`eval echo $cf_symbol`
764 if test -f $cf_dir/curses.h ; then
765 if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
766 includedir="$cf_symbol"
767 test -n "$verbose" && echo $ac_n " found " 1>&AC_FD_MSG
771 test -n "$verbose" && echo " tested $cf_dir" 1>&AC_FD_MSG
773 AC_MSG_RESULT($includedir)
776 dnl ---------------------------------------------------------------------------
777 dnl CF_CGETENT version: 3 updated: 2000/08/12 23:18:52
779 dnl Check if the terminal-capability database functions are available. If not,
780 dnl ncurses has a much-reduced version.
781 AC_DEFUN([CF_CGETENT],[
782 AC_MSG_CHECKING(for terminal-capability database functions)
783 AC_CACHE_VAL(cf_cv_cgetent,[
785 #include <stdlib.h>],[
788 char *db_array = temp;
789 cgetent(&buf, /* int *, */ &db_array, "vt100");
790 cgetcap(buf, "tc", '=');
791 cgetmatch(buf, "tc");
796 AC_MSG_RESULT($cf_cv_cgetent)
797 test "$cf_cv_cgetent" = yes && AC_DEFINE(HAVE_BSD_CGETENT)
799 dnl ---------------------------------------------------------------------------
800 dnl CF_CHECK_CACHE version: 11 updated: 2008/03/23 14:45:59
802 dnl Check if we're accidentally using a cache from a different machine.
803 dnl Derive the system name, as a check for reusing the autoconf cache.
805 dnl If we've packaged config.guess and config.sub, run that (since it does a
806 dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
807 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
808 dnl which is useful in cross-compiles.
810 dnl Note: we would use $ac_config_sub, but that is one of the places where
811 dnl autoconf 2.5x broke compatibility with autoconf 2.13
812 AC_DEFUN([CF_CHECK_CACHE],
814 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
815 ifelse([$1],,[AC_CANONICAL_HOST],[$1])
816 system_name="$host_os"
818 system_name="`(uname -s -r) 2>/dev/null`"
819 if test -z "$system_name" ; then
820 system_name="`(hostname) 2>/dev/null`"
823 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name")
824 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
826 test -z "$system_name" && system_name="$cf_cv_system_name"
827 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
829 if test ".$system_name" != ".$cf_cv_system_name" ; then
830 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
831 AC_MSG_ERROR("Please remove config.cache and try again.")
834 dnl ---------------------------------------------------------------------------
835 dnl CF_CHECK_ERRNO version: 11 updated: 2010/05/26 05:38:42
837 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
838 dnl the 'errno' variable. Define a DECL_xxx symbol if we must declare it
841 dnl $1 = the name to check
842 dnl $2 = the assumed type
843 AC_DEFUN([CF_CHECK_ERRNO],
845 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
851 #include <sys/types.h>
852 #include <errno.h> ],
853 ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1,
858 if test "$cf_cv_dcl_$1" = no ; then
859 CF_UPPER(cf_result,decl_$1)
860 AC_DEFINE_UNQUOTED($cf_result)
863 # It's possible (for near-UNIX clones) that the data doesn't exist
864 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
866 dnl ---------------------------------------------------------------------------
867 dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23
868 dnl --------------------
869 dnl Check for existence of external data in the current set of libraries. If
870 dnl we can modify it, it's real enough.
871 dnl $1 = the name to check
873 AC_DEFUN([CF_CHECK_EXTERN_DATA],
875 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
885 if test "$cf_cv_have_$1" = yes ; then
886 CF_UPPER(cf_result,have_$1)
887 AC_DEFINE_UNQUOTED($cf_result)
891 dnl ---------------------------------------------------------------------------
892 dnl CF_CHECK_GPM_WGETCH version: 2 updated: 2010/08/14 18:25:37
893 dnl -------------------
894 dnl Check if GPM is already linked with curses. If so - and if the linkage
895 dnl is not "weak" - warn about this because it can create problems linking
896 dnl applications with ncurses.
897 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
898 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
900 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
901 cf_cv_check_gpm_wgetch=unknown
902 if test "$cross_compiling" != yes ; then
904 cat >conftest.$ac_ext <<CF_EOF
909 ${cf_cv_main_return:-return}(0);
914 # This only works if we can look at the symbol table. If a shared
915 # library is stripped for install, we cannot use that. So we're forced
916 # to rely on the static library, noting that some packagers may not
918 LIBS="-static -lgpm -dynamic $LIBS"
919 if AC_TRY_EVAL(ac_compile) ; then
920 if AC_TRY_EVAL(ac_link) ; then
921 cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
922 test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
923 test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
931 if test "$cf_cv_check_gpm_wgetch" != yes ; then
932 AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
935 dnl ---------------------------------------------------------------------------
936 dnl CF_CPP_PARAM_INIT version: 4 updated: 2001/04/07 22:31:18
937 dnl -----------------
938 dnl Check if the C++ compiler accepts duplicate parameter initialization. This
939 dnl is a late feature for the standard and is not in some recent compilers
941 AC_DEFUN([CF_CPP_PARAM_INIT],
943 if test -n "$CXX"; then
944 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
956 TEST::TEST(int x = 1) // some compilers do not like second initializer
962 [cf_cv_cpp_param_init=yes],
963 [cf_cv_cpp_param_init=no],
964 [cf_cv_cpp_param_init=unknown])
968 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT)
970 dnl ---------------------------------------------------------------------------
971 dnl CF_CPP_STATIC_CAST version: 1 updated: 2005/07/23 16:52:43
972 dnl ------------------
973 dnl Check if the C++ compiler accepts static_cast in generics. This appears to
974 dnl not be supported in g++ before 3.0
975 AC_DEFUN([CF_CPP_STATIC_CAST],
977 if test -n "$CXX"; then
979 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
987 NCursesPanel(int nlines,
997 template<class T> class NCursesUserPanel : public NCursesPanel
1000 NCursesUserPanel (int nlines,
1004 const T* p_UserData = static_cast<T*>(0))
1005 : NCursesPanel (nlines, ncols, begin_y, begin_x)
1008 NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
1012 virtual ~NCursesUserPanel() {};
1015 const char* p_UserData = static_cast<char*>(0)],
1016 [cf_cv_cpp_static_cast=yes],
1017 [cf_cv_cpp_static_cast=no])
1024 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST)
1026 dnl ---------------------------------------------------------------------------
1027 dnl CF_C_INLINE version: 3 updated: 2010/05/01 15:14:41
1029 dnl Check if the C compiler supports "inline".
1030 dnl $1 is the name of a shell variable to set if inline is supported
1031 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
1032 AC_DEFUN([CF_C_INLINE],[
1035 if test "$ac_cv_c_inline" != no ; then
1037 if test "$INTEL_COMPILER" = yes
1040 elif test "$GCC" = yes
1042 AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[
1043 cf_save_CFLAGS=$CFLAGS
1044 CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
1045 AC_TRY_COMPILE([inline int foo(void) { return 1; }],
1046 [${cf_cv_main_return:-return} foo()],
1047 [cf_cv_gcc_inline=yes],
1048 [cf_cv_gcc_inline=no])
1049 CFLAGS=$cf_save_CFLAGS
1051 if test "$cf_cv_gcc_inline" = yes ; then
1052 CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
1058 dnl ---------------------------------------------------------------------------
1059 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
1061 dnl "dirname" is not portable, so we fake it with a shell script.
1062 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
1063 dnl ---------------------------------------------------------------------------
1064 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
1066 AC_DEFUN([CF_DIRS_TO_MAKE],
1069 for cf_item in $cf_list_models
1071 CF_OBJ_SUBDIR($cf_item,cf_subdir)
1072 for cf_item2 in $DIRS_TO_MAKE
1074 test $cf_item2 = $cf_subdir && break
1076 test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
1078 for cf_dir in $DIRS_TO_MAKE
1080 test ! -d $cf_dir && mkdir $cf_dir
1082 AC_SUBST(DIRS_TO_MAKE)
1084 dnl ---------------------------------------------------------------------------
1085 dnl CF_DISABLE_LEAKS version: 6 updated: 2010/07/23 04:14:32
1086 dnl ----------------
1087 dnl Combine no-leak checks with the libraries or tools that are used for the
1089 AC_DEFUN([CF_DISABLE_LEAKS],[
1091 AC_REQUIRE([CF_WITH_DMALLOC])
1092 AC_REQUIRE([CF_WITH_DBMALLOC])
1093 AC_REQUIRE([CF_WITH_VALGRIND])
1095 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1096 AC_ARG_ENABLE(leaks,
1097 [ --disable-leaks test: free permanent memory, analyze leaks],
1098 [if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi],
1099 : ${with_no_leaks:=no})
1100 AC_MSG_RESULT($with_no_leaks)
1102 if test "$with_no_leaks" = yes ; then
1104 AC_DEFINE(YY_NO_LEAKS)
1107 dnl ---------------------------------------------------------------------------
1108 dnl CF_DISABLE_LIBTOOL_VERSION version: 1 updated: 2010/05/15 15:45:59
1109 dnl --------------------------
1110 dnl Check if we should use the libtool 1.5 feature "-version-number" instead of
1111 dnl the older "-version-info" feature. The newer feature allows us to use
1112 dnl version numbering on shared libraries which make them compatible with
1113 dnl various systems.
1114 AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION],
1116 AC_MSG_CHECKING(if libtool -version-number should be used)
1117 CF_ARG_DISABLE(libtool-version,
1118 [ --disable-libtool-version enable to use libtool's incompatible naming scheme],
1119 [cf_libtool_version=no],
1120 [cf_libtool_version=yes])
1121 AC_MSG_RESULT($cf_libtool_version)
1123 if test "$cf_libtool_version" = yes ; then
1124 LIBTOOL_VERSION="-version-number"
1126 LIBTOOL_VERSION="-version-info"
1129 AC_SUBST(LIBTOOL_VERSION)
1131 dnl ---------------------------------------------------------------------------
1132 dnl CF_DISABLE_RPATH_HACK version: 2 updated: 2011/02/13 13:31:33
1133 dnl ---------------------
1134 dnl The rpath-hack makes it simpler to build programs, particularly with the
1135 dnl *BSD ports which may have essential libraries in unusual places. But it
1136 dnl can interfere with building an executable for the base system. Use this
1137 dnl option in that case.
1138 AC_DEFUN([CF_DISABLE_RPATH_HACK],
1140 AC_MSG_CHECKING(if rpath-hack should be disabled)
1141 CF_ARG_DISABLE(rpath-hack,
1142 [ --disable-rpath-hack don't add rpath options for additional libraries],
1143 [cf_disable_rpath_hack=yes],
1144 [cf_disable_rpath_hack=no])
1145 AC_MSG_RESULT($cf_disable_rpath_hack)
1146 if test "$cf_disable_rpath_hack" = no ; then
1150 dnl ---------------------------------------------------------------------------
1151 dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
1153 dnl Check if the rpath option should be used, setting cache variable
1154 dnl cf_cv_enable_rpath if so.
1155 AC_DEFUN([CF_ENABLE_RPATH],
1157 AC_MSG_CHECKING(if rpath option should be used)
1158 AC_ARG_ENABLE(rpath,
1159 [ --enable-rpath use rpath option when generating shared libraries],
1160 [cf_cv_enable_rpath=$enableval],
1161 [cf_cv_enable_rpath=no])
1162 AC_MSG_RESULT($cf_cv_enable_rpath)
1164 dnl ---------------------------------------------------------------------------
1165 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
1167 dnl Check if 'errno' is declared in <errno.h>
1168 AC_DEFUN([CF_ERRNO],
1170 CF_CHECK_ERRNO(errno)
1172 dnl ---------------------------------------------------------------------------
1173 dnl CF_ETIP_DEFINES version: 3 updated: 2003/03/22 19:13:43
1175 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
1176 dnl math.h and builtin.h, only for ncurses
1177 AC_DEFUN([CF_ETIP_DEFINES],
1179 AC_MSG_CHECKING(for special defines needed for etip.h)
1180 cf_save_CXXFLAGS="$CXXFLAGS"
1182 for cf_math in "" MATH_H
1184 for cf_excp in "" MATH_EXCEPTION
1186 CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -I${srcdir}/include"
1187 test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
1188 test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
1190 #include <etip.h.in>
1192 test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
1193 test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
1194 cf_result="$cf_math $cf_excp"
1199 AC_MSG_RESULT($cf_result)
1200 CXXFLAGS="$cf_save_CXXFLAGS"
1202 dnl ---------------------------------------------------------------------------
1203 dnl CF_FIND_LINKAGE version: 19 updated: 2010/05/29 16:31:02
1205 dnl Find a library (specifically the linkage used in the code fragment),
1206 dnl searching for it if it is not already in the library path.
1207 dnl See also CF_ADD_SEARCHPATH.
1209 dnl Parameters (4-on are optional):
1210 dnl $1 = headers for library entrypoint
1211 dnl $2 = code fragment for library entrypoint
1212 dnl $3 = the library name without the "-l" option or ".so" suffix.
1213 dnl $4 = action to perform if successful (default: update CPPFLAGS, etc)
1214 dnl $5 = action to perform if not successful
1215 dnl $6 = module name, if not the same as the library name
1216 dnl $7 = extra libraries
1218 dnl Sets these variables:
1219 dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1220 dnl $cf_cv_header_path_$3 - include-directory if needed
1221 dnl $cf_cv_library_path_$3 - library-directory if needed
1222 dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1223 AC_DEFUN([CF_FIND_LINKAGE],[
1225 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1226 # will be set on completion of the AC_TRY_LINK below.
1227 cf_cv_header_path_$3=
1228 cf_cv_library_path_$3=
1230 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1232 cf_save_LIBS="$LIBS"
1234 AC_TRY_LINK([$1],[$2],[
1235 cf_cv_find_linkage_$3=yes
1236 cf_cv_header_path_$3=/usr/include
1237 cf_cv_library_path_$3=/usr/lib
1240 LIBS="-l$3 $7 $cf_save_LIBS"
1242 AC_TRY_LINK([$1],[$2],[
1243 cf_cv_find_linkage_$3=yes
1244 cf_cv_header_path_$3=/usr/include
1245 cf_cv_library_path_$3=/usr/lib
1246 cf_cv_library_file_$3="-l$3"
1248 cf_cv_find_linkage_$3=no
1249 LIBS="$cf_save_LIBS"
1251 CF_VERBOSE(find linkage for $3 library)
1252 CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1254 cf_save_CPPFLAGS="$CPPFLAGS"
1255 cf_test_CPPFLAGS="$CPPFLAGS"
1257 CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1258 for cf_cv_header_path_$3 in $cf_search
1260 if test -d $cf_cv_header_path_$3 ; then
1261 CF_VERBOSE(... testing $cf_cv_header_path_$3)
1262 CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
1263 AC_TRY_COMPILE([$1],[$2],[
1264 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1265 cf_cv_find_linkage_$3=maybe
1266 cf_test_CPPFLAGS="$CPPFLAGS"
1268 CPPFLAGS="$cf_save_CPPFLAGS"
1273 if test "$cf_cv_find_linkage_$3" = maybe ; then
1275 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1277 cf_save_LIBS="$LIBS"
1278 cf_save_LDFLAGS="$LDFLAGS"
1281 CPPFLAGS="$cf_test_CPPFLAGS"
1282 LIBS="-l$3 $7 $cf_save_LIBS"
1283 AC_TRY_LINK([$1],[$2],[
1284 CF_VERBOSE(... found $3 library in system)
1285 cf_cv_find_linkage_$3=yes])
1286 CPPFLAGS="$cf_save_CPPFLAGS"
1287 LIBS="$cf_save_LIBS"
1290 if test "$cf_cv_find_linkage_$3" != yes ; then
1291 CF_LIBRARY_PATH(cf_search,$3)
1292 for cf_cv_library_path_$3 in $cf_search
1294 if test -d $cf_cv_library_path_$3 ; then
1295 CF_VERBOSE(... testing $cf_cv_library_path_$3)
1296 CPPFLAGS="$cf_test_CPPFLAGS"
1297 LIBS="-l$3 $7 $cf_save_LIBS"
1298 LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1299 AC_TRY_LINK([$1],[$2],[
1300 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1301 cf_cv_find_linkage_$3=yes
1302 cf_cv_library_file_$3="-l$3"
1304 CPPFLAGS="$cf_save_CPPFLAGS"
1305 LIBS="$cf_save_LIBS"
1306 LDFLAGS="$cf_save_LDFLAGS"
1310 CPPFLAGS="$cf_save_CPPFLAGS"
1311 LDFLAGS="$cf_save_LDFLAGS"
1315 cf_cv_find_linkage_$3=no
1320 LIBS="$cf_save_LIBS"
1322 if test "$cf_cv_find_linkage_$3" = yes ; then
1324 CF_ADD_INCDIR($cf_cv_header_path_$3)
1325 CF_ADD_LIBDIR($cf_cv_library_path_$3)
1329 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1332 dnl ---------------------------------------------------------------------------
1333 dnl CF_FUNC_DLSYM version: 2 updated: 2010/05/29 16:31:02
1335 dnl Test for dlsym() and related functions, as well as libdl.
1340 AC_DEFUN([CF_FUNC_DLSYM],[
1342 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
1345 AC_CHECK_LIB(dl,dlsym,[
1347 cf_have_libdl=yes])])
1349 if test "$cf_have_dlsym" = yes ; then
1350 test "$cf_have_libdl" = yes && CF_ADD_LIB(dl)
1352 AC_MSG_CHECKING(whether able to link to dl*() functions)
1353 AC_TRY_LINK([#include <dlfcn.h>],[
1355 if ((obj = dlopen("filename", 0)) != 0) {
1356 if (dlsym(obj, "symbolname") == 0) {
1360 AC_DEFINE(HAVE_LIBDL)],[
1361 AC_MSG_ERROR(Cannot link test program for libdl)])
1364 AC_MSG_ERROR(Cannot find dlsym function)
1367 dnl ---------------------------------------------------------------------------
1368 dnl CF_FUNC_MEMMOVE version: 7 updated: 2006/12/16 12:33:30
1370 dnl Check for memmove, or a bcopy that can handle overlapping copy. If neither
1371 dnl is found, add our own version of memmove to the list of objects.
1372 AC_DEFUN([CF_FUNC_MEMMOVE],
1374 AC_CHECK_FUNC(memmove,,[
1375 AC_CHECK_FUNC(bcopy,[
1376 AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
1379 static char data[] = "abcdefghijklmnopqrstuwwxyz";
1381 bcopy(data, temp, sizeof(data));
1382 bcopy(temp+10, temp, 15);
1383 bcopy(temp+5, temp+15, 10);
1384 ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
1387 [cf_cv_good_bcopy=yes],
1388 [cf_cv_good_bcopy=no],
1389 [cf_cv_good_bcopy=unknown])
1391 ],[cf_cv_good_bcopy=no])
1392 if test "$cf_cv_good_bcopy" = yes ; then
1393 AC_DEFINE(USE_OK_BCOPY)
1395 AC_DEFINE(USE_MY_MEMMOVE)
1398 dnl ---------------------------------------------------------------------------
1399 dnl CF_FUNC_NANOSLEEP version: 3 updated: 2006/12/16 12:33:30
1400 dnl -----------------
1401 dnl Check for existence of workable nanosleep() function. Some systems, e.g.,
1402 dnl AIX 4.x, provide a non-working version.
1403 AC_DEFUN([CF_FUNC_NANOSLEEP],[
1404 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
1410 #ifdef HAVE_SYS_TIME_H
1411 #include <sys/time.h>
1415 struct timespec ts1, ts2;
1418 ts1.tv_nsec = 750000000;
1422 code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
1423 ${cf_cv_main_return:-return}(code != 0);
1426 [cf_cv_func_nanosleep=yes],
1427 [cf_cv_func_nanosleep=no],
1428 [cf_cv_func_nanosleep=unknown])])
1430 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP)
1432 dnl ---------------------------------------------------------------------------
1433 dnl CF_FUNC_OPENPTY version: 3 updated: 2010/05/29 16:31:02
1435 dnl Check for openpty() function, along with <pty.h> header. It may need the
1436 dnl "util" library as well.
1437 AC_DEFUN([CF_FUNC_OPENPTY],
1439 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1440 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1441 cf_save_LIBS="$LIBS"
1442 test $cf_cv_lib_util = yes && CF_ADD_LIB(util)
1443 for cf_header in pty.h libutil.h util.h
1446 #include <$cf_header>
1448 int x = openpty((int *)0, (int *)0, (char *)0,
1449 (struct termios *)0, (struct winsize *)0);
1451 cf_cv_func_openpty=$cf_header
1454 cf_cv_func_openpty=no
1457 LIBS="$cf_save_LIBS"
1460 dnl ---------------------------------------------------------------------------
1461 dnl CF_FUNC_POLL version: 4 updated: 2006/12/16 12:33:30
1463 dnl See if the poll function really works. Some platforms have poll(), but
1464 dnl it does not work for terminals or files.
1465 AC_DEFUN([CF_FUNC_POLL],[
1466 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1472 #include <sys/poll.h>
1475 struct pollfd myfds;
1479 myfds.events = POLLIN;
1481 ret = poll(&myfds, 1, 100);
1482 ${cf_cv_main_return:-return}(ret != 0);
1484 [cf_cv_working_poll=yes],
1485 [cf_cv_working_poll=no],
1486 [cf_cv_working_poll=unknown])])
1487 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
1489 dnl ---------------------------------------------------------------------------
1490 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
1492 dnl Some old/broken variations define tcgetattr() only as a macro in
1494 AC_DEFUN([CF_FUNC_TERMIOS],[
1495 AC_REQUIRE([CF_STRUCT_TERMIOS])
1496 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1498 #include <sys/types.h>
1499 #ifdef HAVE_UNISTD_H
1502 #ifdef HAVE_TERMIOS_H
1503 #include <termios.h>
1504 #define TTY struct termios
1506 #ifdef HAVE_TERMIO_H
1508 #define TTY struct termio
1513 tcgetattr(1, &foo);],
1514 [cf_cv_have_tcgetattr=yes],
1515 [cf_cv_have_tcgetattr=no])])
1516 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
1518 dnl ---------------------------------------------------------------------------
1519 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
1521 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1522 dnl versions of C. It is in the GNU C library, and can often be simulated by
1523 dnl other functions.
1524 AC_DEFUN([CF_FUNC_VSSCANF],
1526 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1529 #include <stdio.h>],[
1531 vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1534 #include <stdio.h>],[
1538 strbuf._flag = _IOREAD;
1539 strbuf._ptr = strbuf._base = (unsigned char *) str;
1540 strbuf._cnt = strlen(str);
1541 strbuf._file = _NFILE;
1542 return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1545 #include <stdio.h>],[
1549 strbuf._flag = _IOREAD;
1550 strbuf._ptr = strbuf._base = (unsigned char *) str;
1551 strbuf._cnt = strlen(str);
1552 strbuf._file = _NFILE;
1553 return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1554 cf_cv_func_vsscanf=no])])])])
1556 case $cf_cv_func_vsscanf in #(vi
1557 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
1558 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
1559 _doscan) AC_DEFINE(HAVE__DOSCAN);;
1563 dnl ---------------------------------------------------------------------------
1564 dnl CF_GCC_ATTRIBUTES version: 14 updated: 2010/10/23 15:52:32
1565 dnl -----------------
1566 dnl Test for availability of useful gcc __attribute__ directives to quiet
1567 dnl compiler warnings. Though useful, not all are supported -- and contrary
1568 dnl to documentation, unrecognized directives cause older compilers to barf.
1569 AC_DEFUN([CF_GCC_ATTRIBUTES],
1571 if test "$GCC" = yes
1573 cat > conftest.i <<EOF
1575 #define GCC_PRINTF 0
1580 #ifndef GCC_NORETURN
1581 #define GCC_NORETURN /* nothing */
1584 #define GCC_UNUSED /* nothing */
1587 if test "$GCC" = yes
1589 AC_CHECKING([for $CC __attribute__ directives])
1590 cat > conftest.$ac_ext <<EOF
1591 #line __oline__ "${as_me:-configure}"
1592 #include "confdefs.h"
1593 #include "conftest.h"
1594 #include "conftest.i"
1596 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1598 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1601 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1603 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
1605 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1606 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1607 extern void foo(void) GCC_NORETURN;
1608 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1610 cf_printf_attribute=no
1611 cf_scanf_attribute=no
1612 for cf_attribute in scanf printf unused noreturn
1614 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1615 cf_directive="__attribute__(($cf_attribute))"
1616 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1618 case $cf_attribute in #(vi
1620 cf_printf_attribute=yes
1621 cat >conftest.h <<EOF
1622 #define GCC_$cf_ATTRIBUTE 1
1626 cf_scanf_attribute=yes
1627 cat >conftest.h <<EOF
1628 #define GCC_$cf_ATTRIBUTE 1
1632 cat >conftest.h <<EOF
1633 #define GCC_$cf_ATTRIBUTE $cf_directive
1638 if AC_TRY_EVAL(ac_compile); then
1639 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1640 cat conftest.h >>confdefs.h
1641 case $cf_attribute in #(vi
1643 if test "$cf_printf_attribute" = no ; then
1644 cat >>confdefs.h <<EOF
1645 #define GCC_PRINTFLIKE(fmt,var) /* nothing */
1648 cat >>confdefs.h <<EOF
1649 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1654 if test "$cf_scanf_attribute" = no ; then
1655 cat >>confdefs.h <<EOF
1656 #define GCC_SCANFLIKE(fmt,var) /* nothing */
1659 cat >>confdefs.h <<EOF
1660 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1668 fgrep define conftest.i >>confdefs.h
1673 dnl ---------------------------------------------------------------------------
1674 dnl CF_GCC_VERSION version: 5 updated: 2010/04/24 11:02:31
1676 dnl Find version of gcc
1677 AC_DEFUN([CF_GCC_VERSION],[
1678 AC_REQUIRE([AC_PROG_CC])
1680 if test "$GCC" = yes ; then
1681 AC_MSG_CHECKING(version of $CC)
1682 GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1683 test -z "$GCC_VERSION" && GCC_VERSION=unknown
1684 AC_MSG_RESULT($GCC_VERSION)
1687 dnl ---------------------------------------------------------------------------
1688 dnl CF_GCC_WARNINGS version: 27 updated: 2010/10/23 15:52:32
1690 dnl Check if the compiler supports useful warning options. There's a few that
1691 dnl we don't use, simply because they're too noisy:
1693 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1694 dnl -Wredundant-decls (system headers make this too noisy)
1695 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
1696 dnl -Wwrite-strings (too noisy, but should review occasionally). This
1697 dnl is enabled for ncurses using "--enable-const".
1701 dnl $1 is an optional list of gcc warning flags that a particular
1702 dnl application might want to use, e.g., "no-unused" for
1705 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1707 AC_DEFUN([CF_GCC_WARNINGS],
1709 AC_REQUIRE([CF_GCC_VERSION])
1710 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1712 cat > conftest.$ac_ext <<EOF
1713 #line __oline__ "${as_me:-configure}"
1714 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1717 if test "$INTEL_COMPILER" = yes
1719 # The "-wdXXX" options suppress warnings:
1720 # remark #1419: external declaration in primary source file
1721 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1722 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1723 # remark #193: zero used for undefined preprocessing identifier
1724 # remark #593: variable "curs_sb_left_arrow" was set but never used
1725 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1726 # remark #869: parameter "tw" was never referenced
1727 # remark #981: operands are evaluated in unspecified order
1728 # warning #279: controlling expression is constant
1730 AC_CHECKING([for $CC warning options])
1731 cf_save_CFLAGS="$CFLAGS"
1732 EXTRA_CFLAGS="-Wall"
1744 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1745 if AC_TRY_EVAL(ac_compile); then
1746 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1747 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1750 CFLAGS="$cf_save_CFLAGS"
1752 elif test "$GCC" = yes
1754 AC_CHECKING([for $CC warning options])
1755 cf_save_CFLAGS="$CFLAGS"
1758 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1759 for cf_opt in W Wall \
1760 Wbad-function-cast \
1764 Wmissing-declarations \
1765 Wmissing-prototypes \
1769 Wstrict-prototypes \
1770 Wundef $cf_warn_CONST $1
1772 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1773 if AC_TRY_EVAL(ac_compile); then
1774 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1775 case $cf_opt in #(vi
1777 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1780 case $GCC_VERSION in
1782 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1787 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1790 CFLAGS="$cf_save_CFLAGS"
1794 AC_SUBST(EXTRA_CFLAGS)
1796 dnl ---------------------------------------------------------------------------
1797 dnl CF_GETOPT_HEADER version: 4 updated: 2009/08/31 20:07:52
1798 dnl ----------------
1799 dnl Check for getopt's variables which are commonly defined in stdlib.h,
1800 dnl unistd.h or (nonstandard) in getopt.h
1801 AC_DEFUN([CF_GETOPT_HEADER],
1803 AC_HAVE_HEADERS(unistd.h getopt.h)
1804 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
1805 cf_cv_getopt_header=none
1806 for cf_header in stdio.h stdlib.h unistd.h getopt.h
1809 #include <$cf_header>],
1810 [int x = optind; char *y = optarg],
1811 [cf_cv_getopt_header=$cf_header
1815 if test $cf_cv_getopt_header != none ; then
1816 AC_DEFINE(HAVE_GETOPT_HEADER)
1819 dnl ---------------------------------------------------------------------------
1820 dnl CF_GNAT_GENERICS version: 2 updated: 2011/03/23 20:24:41
1821 dnl ----------------
1822 AC_DEFUN([CF_GNAT_GENERICS],
1824 AC_REQUIRE([CF_GNAT_VERSION])
1826 AC_MSG_CHECKING(if GNAT supports generics)
1827 case $cf_gnat_version in #(vi
1828 3.[[1-9]]*|[[4-9]].*) #(vi
1829 cf_gnat_generics=yes
1835 AC_MSG_RESULT($cf_gnat_generics)
1837 if test "$cf_gnat_generics" = yes
1839 cf_compile_generics=generics
1840 cf_generic_objects="\${GENOBJS}"
1842 cf_compile_generics=
1846 AC_SUBST(cf_compile_generics)
1847 AC_SUBST(cf_generic_objects)
1849 dnl ---------------------------------------------------------------------------
1850 dnl CF_GNAT_PRAGMA_UNREF version: 1 updated: 2010/06/19 15:22:18
1851 dnl --------------------
1852 dnl Check if the gnat pragma "Unreferenced" works.
1853 AC_DEFUN([CF_GNAT_PRAGMA_UNREF],[
1854 AC_CACHE_CHECK(if GNAT pragma Unreferenced works,cf_cv_pragma_unreferenced,[
1855 CF_GNAT_TRY_LINK([procedure conftest;],
1858 procedure conftest is
1860 pragma Unreferenced (test);
1863 Text_IO.Put ("Hello World");
1865 GNAT.OS_Lib.OS_Exit (0);
1867 [cf_cv_pragma_unreferenced=yes],
1868 [cf_cv_pragma_unreferenced=no])])
1870 # if the pragma is supported, use it (needed in the Trace code).
1871 if test $cf_cv_pragma_unreferenced = yes ; then
1876 AC_SUBST(PRAGMA_UNREF)
1878 dnl ---------------------------------------------------------------------------
1879 dnl CF_GNAT_PROJECTS version: 2 updated: 2011/03/23 20:24:41
1880 dnl ----------------
1881 dnl GNAT projects are configured with ".gpr" project files.
1882 dnl GNAT libraries are a further development, using the project feature.
1883 AC_DEFUN([CF_GNAT_PROJECTS],
1885 AC_REQUIRE([CF_GNAT_VERSION])
1887 cf_gnat_libraries=no
1890 AC_MSG_CHECKING(if GNAT supports project files)
1891 case $cf_gnat_version in #(vi
1895 case $cf_cv_system_name in #(vi
1899 mkdir conftest.src conftest.bin conftest.lib
1901 rm -rf conftest* *~conftest*
1902 cat >>library.gpr <<CF_EOF
1904 Kind := External ("LIB_KIND");
1905 for Library_Name use "ConfTest";
1906 for Object_Dir use ".";
1907 for Library_ALI_Dir use External("LIBRARY_DIR");
1908 for Library_Version use External ("SONAME");
1909 for Library_Kind use Kind;
1910 for Library_Dir use External("BUILD_DIR");
1911 Source_Dir := External ("SOURCE_DIR");
1912 for Source_Dirs use (Source_Dir);
1914 for Default_Switches ("Ada") use
1918 "-gnatVa", -- All validity checks
1919 "-gnatwa"); -- Activate all optional errors
1923 cat >>confpackage.ads <<CF_EOF
1924 package ConfPackage is
1928 cat >>confpackage.adb <<CF_EOF
1930 package body ConfPackage is
1931 procedure conftest is
1933 Text_IO.Put ("Hello World");
1938 if ( $cf_ada_make $ADAFLAGS \
1940 -XBUILD_DIR=`cd ../conftest.bin;pwd` \
1941 -XLIBRARY_DIR=`cd ../conftest.lib;pwd` \
1942 -XSOURCE_DIR=`pwd` \
1943 -XSONAME=libConfTest.so.1 \
1944 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
1945 cf_gnat_projects=yes
1948 if test -f conftest.lib/confpackage.ali
1950 cf_gnat_libraries=yes
1952 rm -rf conftest* *~conftest*
1957 AC_MSG_RESULT($cf_gnat_projects)
1959 if test $cf_gnat_projects = yes
1961 AC_MSG_CHECKING(if GNAT supports libraries)
1962 AC_MSG_RESULT($cf_gnat_libraries)
1965 if test "$cf_gnat_projects" = yes
1967 USE_OLD_MAKERULES="#"
1968 USE_GNAT_PROJECTS=""
1970 USE_OLD_MAKERULES=""
1971 USE_GNAT_PROJECTS="#"
1974 if test "$cf_gnat_libraries" = yes
1976 USE_GNAT_LIBRARIES=""
1978 USE_GNAT_LIBRARIES="#"
1981 AC_SUBST(USE_OLD_MAKERULES)
1982 AC_SUBST(USE_GNAT_PROJECTS)
1983 AC_SUBST(USE_GNAT_LIBRARIES)
1985 dnl ---------------------------------------------------------------------------
1986 dnl CF_GNAT_SIGINT version: 1 updated: 2011/03/27 20:07:59
1988 dnl Check if gnat supports SIGINT, and presumably tasking. For the latter, it
1989 dnl is noted that gnat may compile a tasking unit even for configurations which
1990 dnl fail at runtime.
1991 AC_DEFUN([CF_GNAT_SIGINT],[
1992 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
1993 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
1997 pragma Warnings (Off); -- the next pragma exists since 3.11p
1998 pragma Unreserve_All_Interrupts;
1999 pragma Warnings (On);
2001 protected Process is
2003 function Continue return Boolean;
2004 pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
2006 Done : Boolean := False;
2010 [package body ConfTest is
2011 protected body Process is
2016 function Continue return Boolean is
2022 [cf_cv_gnat_sigint=yes],
2023 [cf_cv_gnat_sigint=no])])
2025 if test $cf_cv_gnat_sigint = yes ; then
2030 AC_SUBST(USE_GNAT_SIGINT)
2032 dnl ---------------------------------------------------------------------------
2033 dnl CF_GNAT_TRY_LINK version: 3 updated: 2011/03/19 14:47:45
2034 dnl ----------------
2035 dnl Verify that a test program compiles/links with GNAT.
2036 dnl $cf_ada_make is set to the program that compiles/links
2037 dnl $ADAFLAGS may be set to the GNAT flags.
2039 dnl $1 is the text of the spec
2040 dnl $2 is the text of the body
2041 dnl $3 is the shell command to execute if successful
2042 dnl $4 is the shell command to execute if not successful
2043 AC_DEFUN([CF_GNAT_TRY_LINK],
2045 rm -rf conftest* *~conftest*
2046 cat >>conftest.ads <<CF_EOF
2049 cat >>conftest.adb <<CF_EOF
2052 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
2053 ifelse($3,, :,[ $3])
2057 rm -rf conftest* *~conftest*
2059 dnl ---------------------------------------------------------------------------
2060 dnl CF_GNAT_TRY_RUN version: 5 updated: 2011/03/19 14:47:45
2062 dnl Verify that a test program compiles and runs with GNAT
2063 dnl $cf_ada_make is set to the program that compiles/links
2064 dnl $ADAFLAGS may be set to the GNAT flags.
2066 dnl $1 is the text of the spec
2067 dnl $2 is the text of the body
2068 dnl $3 is the shell command to execute if successful
2069 dnl $4 is the shell command to execute if not successful
2070 AC_DEFUN([CF_GNAT_TRY_RUN],
2072 rm -rf conftest* *~conftest*
2073 cat >>conftest.ads <<CF_EOF
2076 cat >>conftest.adb <<CF_EOF
2079 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
2080 if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
2081 ifelse($3,, :,[ $3])
2088 rm -rf conftest* *~conftest*
2090 dnl ---------------------------------------------------------------------------
2091 dnl CF_GNAT_VERSION version: 17 updated: 2011/03/23 20:24:41
2093 dnl Verify version of GNAT.
2094 AC_DEFUN([CF_GNAT_VERSION],
2096 AC_MSG_CHECKING(for gnat version)
2097 cf_gnat_version=`${cf_ada_make:-gnatmake} -v 2>&1 | \
2098 grep '[[0-9]].[[0-9]][[0-9]]*' |\
2099 sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
2100 AC_MSG_RESULT($cf_gnat_version)
2102 case $cf_gnat_version in #(vi
2103 3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*) #(vi
2104 cf_cv_prog_gnat_correct=yes
2107 AC_MSG_WARN(Unsupported GNAT version $cf_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
2108 cf_cv_prog_gnat_correct=no
2112 dnl ---------------------------------------------------------------------------
2113 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
2115 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
2116 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
2117 dnl (or misfeature) of glibc2, which breaks portability of many applications,
2118 dnl since it is interwoven with GNU extensions.
2120 dnl Well, yes we could work around it...
2121 AC_DEFUN([CF_GNU_SOURCE],
2123 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
2124 AC_TRY_COMPILE([#include <sys/types.h>],[
2125 #ifndef _XOPEN_SOURCE
2128 [cf_cv_gnu_source=no],
2129 [cf_save="$CPPFLAGS"
2130 CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
2131 AC_TRY_COMPILE([#include <sys/types.h>],[
2132 #ifdef _XOPEN_SOURCE
2135 [cf_cv_gnu_source=no],
2136 [cf_cv_gnu_source=yes])
2140 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
2142 dnl ---------------------------------------------------------------------------
2143 dnl CF_GPP_LIBRARY version: 10 updated: 2010/05/29 16:31:02
2145 dnl If we're trying to use g++, test if libg++ is installed (a rather common
2146 dnl problem :-). If we have the compiler but no library, we'll be able to
2147 dnl configure, but won't be able to build the c++ demo program.
2148 AC_DEFUN([CF_GPP_LIBRARY],
2150 cf_cxx_library=unknown
2151 case $cf_cv_system_name in #(vi
2159 if test "$GXX" = yes; then
2160 AC_MSG_CHECKING([for lib$cf_gpp_libname])
2162 CF_ADD_LIB($cf_gpp_libname)
2164 #include <$cf_gpp_libname/builtin.h>
2166 [two_arg_error_handler_t foo2 = lib_error_handler],
2168 CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
2169 if test "$cf_gpp_libname" = cpp ; then
2170 AC_DEFINE(HAVE_GPP_BUILTIN_H)
2172 AC_DEFINE(HAVE_GXX_BUILTIN_H)
2175 #include <builtin.h>
2177 [two_arg_error_handler_t foo2 = lib_error_handler],
2179 CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
2180 AC_DEFINE(HAVE_BUILTIN_H)],
2181 [cf_cxx_library=no])])
2183 AC_MSG_RESULT($cf_cxx_library)
2186 dnl ---------------------------------------------------------------------------
2187 dnl CF_GXX_VERSION version: 6 updated: 2010/10/23 15:44:18
2189 dnl Check for version of g++
2190 AC_DEFUN([CF_GXX_VERSION],[
2191 AC_REQUIRE([AC_PROG_CPP])
2193 if test "$GXX" = yes; then
2194 AC_MSG_CHECKING(version of g++)
2195 GXX_VERSION="`${CXX:-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
2196 test -z "$GXX_VERSION" && GXX_VERSION=unknown
2197 AC_MSG_RESULT($GXX_VERSION)
2200 dnl ---------------------------------------------------------------------------
2201 dnl CF_GXX_WARNINGS version: 6 updated: 2010/08/14 18:25:37
2203 dnl Check if the compiler supports useful warning options.
2205 dnl Most of gcc's options apply to g++, except:
2206 dnl -Wbad-function-cast
2207 dnl -Wmissing-declarations
2208 dnl -Wnested-externs
2210 dnl Omit a few (for now):
2214 dnl $1 is an optional list of g++ warning flags that a particular
2215 dnl application might want to use, e.g., "no-unused" for
2218 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
2220 AC_DEFUN([CF_GXX_WARNINGS],
2223 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
2225 AC_REQUIRE([CF_GXX_VERSION])
2230 cat > conftest.$ac_ext <<EOF
2231 #line __oline__ "configure"
2232 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2235 if test "$INTEL_CPLUSPLUS" = yes
2237 # The "-wdXXX" options suppress warnings:
2238 # remark #1419: external declaration in primary source file
2239 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2240 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2241 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2242 # remark #193: zero used for undefined preprocessing identifier
2243 # remark #593: variable "curs_sb_left_arrow" was set but never used
2244 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2245 # remark #869: parameter "tw" was never referenced
2246 # remark #981: operands are evaluated in unspecified order
2247 # warning #269: invalid format string conversion
2249 AC_CHECKING([for $CC warning options])
2250 cf_save_CXXFLAGS="$CXXFLAGS"
2251 EXTRA_CXXFLAGS="-Wall"
2264 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
2265 if AC_TRY_EVAL(ac_compile); then
2266 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2267 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2270 CXXFLAGS="$cf_save_CXXFLAGS"
2272 elif test "$GXX" = yes
2274 AC_CHECKING([for $CXX warning options])
2275 cf_save_CXXFLAGS="$CXXFLAGS"
2276 EXTRA_CXXFLAGS="-W -Wall"
2277 cf_gxx_extra_warnings=""
2278 test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
2279 case "$GCC_VERSION" in
2283 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
2289 Woverloaded-virtual \
2295 Wmissing-prototypes \
2298 Wstrict-prototypes \
2299 Wundef $cf_gxx_extra_warnings $1
2301 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
2302 if AC_TRY_EVAL(ac_compile); then
2303 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2304 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2306 test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
2309 CXXFLAGS="$cf_save_CXXFLAGS"
2314 AC_SUBST(EXTRA_CXXFLAGS)
2316 dnl ---------------------------------------------------------------------------
2317 dnl CF_HASHED_DB version: 4 updated: 2010/05/29 16:31:02
2319 dnl Look for an instance of the Berkeley hashed database.
2321 dnl $1 = optional parameter, to specify install-prefix for the database.
2322 AC_DEFUN([CF_HASHED_DB],
2329 if test -d "$1" ; then
2330 CF_ADD_INCDIR($1/include)
2331 CF_ADD_LIBDIR($1/lib)
2335 AC_CHECK_HEADER(db.h,[
2336 CF_HASHED_DB_VERSION
2337 if test "$cf_cv_hashed_db_version" = unknown ; then
2338 AC_MSG_ERROR(Cannot determine version of db)
2341 if test "$cf_cv_hashed_db_libs" = unknown ; then
2342 AC_MSG_ERROR(Cannot determine library for db)
2343 elif test "$cf_cv_hashed_db_libs" != default ; then
2344 CF_ADD_LIB($cf_cv_hashed_db_libs)
2348 AC_MSG_ERROR(Cannot find db.h)
2351 dnl ---------------------------------------------------------------------------
2352 dnl CF_HASHED_DB_LIBS version: 9 updated: 2010/05/29 16:31:02
2353 dnl -----------------
2354 dnl Given that we have the header and version for hashed database, find the
2355 dnl library information.
2356 AC_DEFUN([CF_HASHED_DB_LIBS],
2358 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
2359 cf_cv_hashed_db_libs=unknown
2360 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
2362 cf_save_libs="$LIBS"
2363 if test -n "$cf_db_libs"; then
2364 CF_ADD_LIB($cf_db_libs)
2366 CF_MSG_LOG(checking for library "$cf_db_libs")
2368 $ac_includes_default
2371 char *path = "/tmp/foo";
2372 #ifdef DB_VERSION_MAJOR
2373 #if DB_VERSION_MAJOR >= 4
2375 db_create(&result, NULL, 0);
2376 result->open(result,
2383 #elif DB_VERSION_MAJOR >= 3
2385 db_create(&result, NULL, 0);
2386 result->open(result,
2392 #elif DB_VERSION_MAJOR >= 2
2401 #endif /* DB_VERSION_MAJOR */
2403 DB *result = dbopen(path,
2409 ${cf_cv_main_return:-return}(result != 0)
2411 if test -n "$cf_db_libs" ; then
2412 cf_cv_hashed_db_libs=$cf_db_libs
2414 cf_cv_hashed_db_libs=default
2416 LIBS="$cf_save_libs"
2419 LIBS="$cf_save_libs"
2423 dnl ---------------------------------------------------------------------------
2424 dnl CF_HASHED_DB_VERSION version: 3 updated: 2007/12/01 15:01:37
2425 dnl --------------------
2426 dnl Given that we have the header file for hashed database, find the version
2428 AC_DEFUN([CF_HASHED_DB_VERSION],
2430 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
2431 cf_cv_hashed_db_version=unknown
2433 for cf_db_version in 1 2 3 4 5
2435 CF_MSG_LOG(checking for db version $cf_db_version)
2437 $ac_includes_default
2440 #ifdef DB_VERSION_MAJOR
2441 /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
2442 #if $cf_db_version == DB_VERSION_MAJOR
2448 #if $cf_db_version == 1
2449 /* ok: assuming this is DB 1.8.5 */
2455 cf_cv_hashed_db_version=$cf_db_version
2461 dnl ---------------------------------------------------------------------------
2462 dnl CF_HEADER_PATH version: 12 updated: 2010/05/05 05:22:40
2464 dnl Construct a search-list of directories for a nonstandard header-file
2467 dnl $1 = the variable to return as result
2468 dnl $2 = the package name
2469 AC_DEFUN([CF_HEADER_PATH],
2473 # collect the current set of include-directories from compiler flags
2474 cf_header_path_list=""
2475 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2476 for cf_header_path in $CPPFLAGS $CFLAGS
2478 case $cf_header_path in #(vi
2480 cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2481 CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2482 cf_header_path_list="$cf_header_path_list [$]$1"
2488 # add the variations for the package we are looking for
2489 CF_SUBDIR_PATH($1,$2,include)
2491 test "$includedir" != NONE && \
2492 test "$includedir" != "/usr/include" && \
2493 test -d "$includedir" && {
2494 test -d $includedir && $1="[$]$1 $includedir"
2495 test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
2498 test "$oldincludedir" != NONE && \
2499 test "$oldincludedir" != "/usr/include" && \
2500 test -d "$oldincludedir" && {
2501 test -d $oldincludedir && $1="[$]$1 $oldincludedir"
2502 test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
2505 $1="[$]$1 $cf_header_path_list"
2507 dnl ---------------------------------------------------------------------------
2508 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
2510 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2511 AC_DEFUN([CF_HELP_MESSAGE],
2512 [AC_DIVERT_HELP([$1])dnl
2514 dnl ---------------------------------------------------------------------------
2515 dnl CF_INCLUDE_DIRS version: 6 updated: 2009/01/06 19:37:40
2517 dnl Construct the list of include-options according to whether we're building
2518 dnl in the source directory or using '--srcdir=DIR' option. If we're building
2519 dnl with gcc, don't append the includedir if it happens to be /usr/include,
2520 dnl since that usually breaks gcc's shadow-includes.
2521 AC_DEFUN([CF_INCLUDE_DIRS],
2523 CPPFLAGS="$CPPFLAGS -I. -I../include"
2524 if test "$srcdir" != "."; then
2525 CPPFLAGS="$CPPFLAGS -I\${srcdir}/../include"
2527 if test "$GCC" != yes; then
2528 CPPFLAGS="$CPPFLAGS -I\${includedir}"
2529 elif test "$includedir" != "/usr/include"; then
2530 if test "$includedir" = '${prefix}/include' ; then
2531 if test $prefix != /usr ; then
2532 CPPFLAGS="$CPPFLAGS -I\${includedir}"
2535 CPPFLAGS="$CPPFLAGS -I\${includedir}"
2540 dnl ---------------------------------------------------------------------------
2541 dnl CF_INTEL_COMPILER version: 4 updated: 2010/05/26 05:38:42
2542 dnl -----------------
2543 dnl Check if the given compiler is really the Intel compiler for Linux. It
2544 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2545 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2547 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2548 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
2549 dnl the wrappers for gcc and g++ warnings.
2551 dnl $1 = GCC (default) or GXX
2552 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2553 dnl $3 = CFLAGS (default) or CXXFLAGS
2554 AC_DEFUN([CF_INTEL_COMPILER],[
2555 ifelse([$2],,INTEL_COMPILER,[$2])=no
2557 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2560 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2561 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2562 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2564 #ifdef __INTEL_COMPILER
2568 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2569 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
2571 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2572 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2577 dnl ---------------------------------------------------------------------------
2578 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
2580 dnl Check if we have either a function or macro for 'isascii()'.
2581 AC_DEFUN([CF_ISASCII],
2583 AC_MSG_CHECKING(for isascii)
2584 AC_CACHE_VAL(cf_cv_have_isascii,[
2585 AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
2586 [cf_cv_have_isascii=yes],
2587 [cf_cv_have_isascii=no])
2589 AC_MSG_RESULT($cf_cv_have_isascii)
2590 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
2592 dnl ---------------------------------------------------------------------------
2593 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
2595 dnl Add checks for large file support.
2596 AC_DEFUN([CF_LARGEFILE],[
2597 ifdef([AC_FUNC_FSEEKO],[
2599 if test "$enable_largefile" != no ; then
2602 # Normally we would collect these definitions in the config.h,
2603 # but (like _XOPEN_SOURCE), some environments rely on having these
2604 # defined before any of the system headers are included. Another
2605 # case comes up with C++, e.g., on AIX the compiler compiles the
2606 # header files by themselves before looking at the body files it is
2607 # told to compile. For ncurses, those header files do not include
2609 test "$ac_cv_sys_large_files" != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
2610 test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
2611 test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
2613 AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2615 #include <sys/types.h>
2618 /* if transitional largefile support is setup, this is true */
2619 extern struct dirent64 * readdir(DIR *);
2620 struct dirent64 *x = readdir((DIR *)0);
2621 struct dirent *y = readdir((DIR *)0);
2624 [cf_cv_struct_dirent64=yes],
2625 [cf_cv_struct_dirent64=no])
2627 test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
2631 dnl ---------------------------------------------------------------------------
2632 dnl CF_LDFLAGS_STATIC version: 8 updated: 2010/10/23 14:39:56
2633 dnl -----------------
2634 dnl Check for compiler/linker flags used to temporarily force usage of static
2635 dnl libraries. This depends on the compiler and platform. Use this to help
2636 dnl ensure that the linker picks up a given library based on its position in
2637 dnl the list of linker options and libraries.
2638 AC_DEFUN([CF_LDFLAGS_STATIC],[
2640 if test "$GCC" = yes ; then
2641 case $cf_cv_system_name in #(
2642 OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*) #( vi
2646 *) #( normally, except when broken
2647 LDFLAGS_STATIC=-static
2648 LDFLAGS_SHARED=-dynamic
2652 case $cf_cv_system_name in #(
2653 aix[[456]]*) #( from ld manpage
2654 LDFLAGS_STATIC=-bstatic
2655 LDFLAGS_SHARED=-bdynamic
2657 hpux*) #( from ld manpage for hpux10.20, hpux11.11
2658 # We could also use just "archive" and "shared".
2659 LDFLAGS_STATIC=-Wl,-a,archive_shared
2660 LDFLAGS_SHARED=-Wl,-a,shared_archive
2662 irix*) #( from ld manpage IRIX64
2663 LDFLAGS_STATIC=-Bstatic
2664 LDFLAGS_SHARED=-Bdynamic
2666 osf[[45]]*) #( from ld manpage osf4.0d, osf5.1
2667 # alternative "-oldstyle_liblookup" (not in cc manpage)
2668 LDFLAGS_STATIC=-noso
2669 LDFLAGS_SHARED=-so_archive
2672 LDFLAGS_STATIC=-Bstatic
2673 LDFLAGS_SHARED=-Bdynamic
2678 if test -n "$LDFLAGS_STATIC" && test -n "$LDFLAGS_SHARED"
2680 AC_MSG_CHECKING(if linker supports switching between static/dynamic)
2683 cat >conftest.$ac_ext <<EOF
2684 #line __oline__ "configure"
2686 int cf_ldflags_static(FILE *fp) { return fflush(fp); }
2688 if AC_TRY_EVAL(ac_compile) ; then
2689 ( $AR $ARFLAGS libconftest.a conftest.o ) 2>&AC_FD_CC 1>/dev/null
2690 ( eval $RANLIB libconftest.a ) 2>&AC_FD_CC >/dev/null
2694 cf_save_LIBS="$LIBS"
2696 LIBS="$LDFLAGS_STATIC -L`pwd` -lconftest $LDFLAGS_DYNAMIC $LIBS"
2698 #line __oline__ "configure"
2700 int cf_ldflags_static(FILE *fp);
2702 return cf_ldflags_static(stdin);
2703 ],[cf_ldflags_static=yes],[cf_ldflags_static=no])
2706 LIBS="$cf_save_LIBS"
2708 AC_MSG_RESULT($cf_ldflags_static)
2710 if test $cf_ldflags_static != yes
2720 AC_SUBST(LDFLAGS_STATIC)
2721 AC_SUBST(LDFLAGS_SHARED)
2723 dnl ---------------------------------------------------------------------------
2724 dnl CF_LD_RPATH_OPT version: 4 updated: 2011/06/04 20:09:13
2726 dnl For the given system and compiler, find the compiler flags to pass to the
2727 dnl loader to use the "rpath" feature.
2728 AC_DEFUN([CF_LD_RPATH_OPT],
2730 AC_REQUIRE([CF_CHECK_CACHE])
2733 AC_MSG_CHECKING(for an rpath option)
2734 case $cf_cv_system_name in #(vi
2736 if test "$GCC" = yes; then
2737 LD_RPATH_OPT="-Wl,-rpath,"
2739 LD_RPATH_OPT="-rpath "
2742 linux*|gnu*|k*bsd*-gnu) #(vi
2743 LD_RPATH_OPT="-Wl,-rpath,"
2745 openbsd[[2-9]].*|mirbsd*) #(vi
2746 LD_RPATH_OPT="-Wl,-rpath,"
2749 LD_RPATH_OPT="-rpath "
2752 LD_RPATH_OPT="-Wl,-rpath,"
2755 LD_RPATH_OPT="-rpath "
2763 AC_MSG_RESULT($LD_RPATH_OPT)
2765 case "x$LD_RPATH_OPT" in #(vi
2767 AC_MSG_CHECKING(if we need a space after rpath option)
2768 cf_save_LIBS="$LIBS"
2769 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2770 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2771 LIBS="$cf_save_LIBS"
2772 AC_MSG_RESULT($cf_rpath_space)
2773 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2777 dnl ---------------------------------------------------------------------------
2778 dnl CF_LIBRARY_PATH version: 9 updated: 2010/03/28 12:52:50
2780 dnl Construct a search-list of directories for a nonstandard library-file
2783 dnl $1 = the variable to return as result
2784 dnl $2 = the package name
2785 AC_DEFUN([CF_LIBRARY_PATH],
2788 cf_library_path_list=""
2789 if test -n "${LDFLAGS}${LIBS}" ; then
2790 for cf_library_path in $LDFLAGS $LIBS
2792 case $cf_library_path in #(vi
2794 cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2795 CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2796 cf_library_path_list="$cf_library_path_list [$]$1"
2802 CF_SUBDIR_PATH($1,$2,lib)
2804 $1="$cf_library_path_list [$]$1"
2806 dnl ---------------------------------------------------------------------------
2807 dnl CF_LIB_PREFIX version: 8 updated: 2008/09/13 11:34:16
2809 dnl Compute the library-prefix for the given host system
2810 dnl $1 = variable to set
2811 AC_DEFUN([CF_LIB_PREFIX],
2813 case $cf_cv_system_name in #(vi
2820 ifelse($1,,,[$1=$LIB_PREFIX])
2821 AC_SUBST(LIB_PREFIX)
2823 dnl ---------------------------------------------------------------------------
2824 dnl CF_LIB_RULES version: 61 updated: 2010/10/23 16:10:30
2826 dnl Append definitions and rules for the given models to the subdirectory
2827 dnl Makefiles, and the recursion rule for the top-level Makefile. If the
2828 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
2829 dnl the corresponding makefile to list the models that we'll generate.
2831 dnl For shared libraries, make a list of symbolic links to construct when
2832 dnl generating each library. The convention used for Linux is the simplest
2835 dnl lib<name>.so.<major> ->
2836 dnl lib<name>.so.<maj>.<minor>
2837 AC_DEFUN([CF_LIB_RULES],
2839 CF_LIB_PREFIX(cf_prefix)
2840 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2842 if test $cf_cv_shlib_version = cygdll ; then
2843 TINFO_NAME=$TINFO_ARG_SUFFIX
2847 if test -n "$TINFO_SUFFIX" ; then
2848 case $TINFO_SUFFIX in
2850 TINFO_NAME="${TINFO_NAME}tw"
2851 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^tw//'`
2854 TINFO_NAME="${TINFO_NAME}t"
2855 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^t//'`
2858 TINFO_NAME="${TINFO_NAME}w"
2859 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^w//'`
2864 for cf_dir in $SRC_SUBDIRS
2866 if test ! -d $srcdir/$cf_dir ; then
2868 elif test -f $srcdir/$cf_dir/modules; then
2872 for cf_item in $cf_LIST_MODELS
2874 CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2875 if test $cf_item = shared ; then
2876 if test "$cf_cv_do_symlinks" = yes ; then
2877 case "$cf_cv_shlib_version" in #(vi
2879 case "$cf_cv_system_name" in #(vi
2881 case .${LIB_SUFFIX} in
2883 cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
2884 cf_suffix=tw'.${REL_VERSION}'"$cf_suffix"
2887 cf_suffix=`echo $cf_suffix | sed 's/^t//'`
2888 cf_suffix=t'.${REL_VERSION}'"$cf_suffix"
2891 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2892 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
2895 cf_suffix='.${REL_VERSION}'"$cf_suffix"
2899 *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
2903 case "$cf_cv_system_name" in #(vi
2905 case .${LIB_SUFFIX} in
2907 cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
2908 cf_suffix=tw'.${ABI_VERSION}'"$cf_suffix"
2911 cf_suffix=`echo $cf_suffix | sed 's/^t//'`
2912 cf_suffix=t'.${ABI_VERSION}'"$cf_suffix"
2915 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2916 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
2919 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
2923 *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
2928 # cygwin needs import library, and has unique naming convention
2929 # use autodetected ${cf_prefix} for import lib and static lib, but
2930 # use 'cyg' prefix for shared lib.
2931 if test $cf_cv_shlib_version = cygdll ; then
2932 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
2933 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}${cf_cygsuf}"
2937 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
2940 if test $cf_dir = ncurses ; then
2941 cf_subsets="$LIB_SUBSETS"
2942 cf_r_parts="$cf_subsets"
2943 cf_liblist="$LIBS_TO_MAKE"
2945 while test -n "$cf_r_parts"
2947 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
2948 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
2949 if test "$cf_l_parts" != "$cf_r_parts" ; then
2951 case $cf_l_parts in #(vi
2953 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
2956 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
2962 if test -n "$cf_item"; then
2963 LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
2970 cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
2973 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
2974 -e "s%@SHARED_LIB@%$SHARED_LIB%" \
2975 $cf_dir/Makefile >$cf_dir/Makefile.out
2976 mv $cf_dir/Makefile.out $cf_dir/Makefile
2978 $AWK -f $srcdir/mk-0th.awk \
2979 libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
2980 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2982 for cf_subset in $cf_subsets
2985 for cf_item in $cf_LIST_MODELS
2987 echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
2988 CF_UPPER(cf_ITEM,$cf_item)
2989 CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2990 CF_OBJ_SUBDIR($cf_item,cf_subdir)
2992 # Test for case where we build libtinfo with a different name.
2994 if test $cf_dir = ncurses ; then
2997 cf_libname=${cf_libname}$LIB_SUFFIX
3000 cf_libname=$TINFO_LIB_SUFFIX
3003 cf_libname=$TICS_LIB_SUFFIX
3007 cf_libname=${cf_libname}$LIB_SUFFIX
3009 if test -n "${DFT_ARG_SUFFIX}" ; then
3010 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
3011 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
3014 # These dependencies really are for development, not
3015 # builds, but they are useful in porting, too.
3016 cf_depend="../include/ncurses_cfg.h"
3017 if test "$srcdir" = "."; then
3020 cf_reldir="\${srcdir}"
3023 if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
3024 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
3025 elif test -f $srcdir/$cf_dir/curses.priv.h; then
3026 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
3030 old_cf_suffix="$cf_suffix"
3031 if test "$cf_cv_shlib_version_infix" = yes ; then
3032 if test -n "$LIB_SUFFIX" ; then
3035 cf_libname=`echo $cf_libname | sed 's/tw$//'`
3036 cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
3040 cf_libname=`echo $cf_libname | sed 's/t$//'`
3041 cf_suffix=`echo $cf_suffix | sed 's/^t//'`
3045 cf_libname=`echo $cf_libname | sed 's/w$//'`
3046 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
3053 $AWK -f $srcdir/mk-1st.awk \
3054 name=${cf_libname}${cf_dir_suffix} \
3055 traces=$LIB_TRACING \
3062 TermlibRoot=$TINFO_NAME \
3063 TermlibSuffix=$TINFO_SUFFIX \
3064 ShlibVer=$cf_cv_shlib_version \
3065 ShlibVerInfix=$cf_cv_shlib_version_infix \
3066 ReLink=${cf_cv_do_relink:-no} \
3067 DoLinks=$cf_cv_do_symlinks \
3068 rmSoLocs=$cf_cv_rm_so_locs \
3069 ldconfig="$LDCONFIG" \
3070 overwrite=$WITH_OVERWRITE \
3071 depend="$cf_depend" \
3073 libtool_version="$LIBTOOL_VERSION" \
3074 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3076 cf_suffix="$old_cf_suffix"
3078 for cf_subdir2 in $cf_subdirs lib
3080 test $cf_subdir = $cf_subdir2 && break
3082 test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
3083 $AWK -f $srcdir/mk-2nd.awk \
3085 traces=$LIB_TRACING \
3091 crenames=$cf_cv_prog_CC_c_o \
3092 cxxrenames=$cf_cv_prog_CXX_c_o \
3093 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3094 cf_subdirs="$cf_subdirs $cf_subdir"
3099 echo ' cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
3102 for cf_dir in $SRC_SUBDIRS
3104 if test ! -d $srcdir/$cf_dir ; then
3108 if test -f $cf_dir/Makefile ; then
3111 echo 'libs \' >> Makefile
3112 echo 'install.libs \' >> Makefile
3113 echo 'uninstall.libs ::' >> Makefile
3114 echo ' cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
3119 if test -f $srcdir/$cf_dir/modules; then
3121 if test -f $srcdir/$cf_dir/headers; then
3122 cat >> Makefile <<CF_EOF
3124 uninstall.includes \\
3127 if test "$cf_dir" != "c++" ; then
3128 echo 'lint \' >> Makefile
3130 cat >> Makefile <<CF_EOF
3136 uninstall.$cf_dir ::
3137 cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
3139 elif test -f $srcdir/$cf_dir/headers; then
3140 cat >> Makefile <<CF_EOF
3146 uninstall.includes ::
3147 cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
3152 cat >> Makefile <<CF_EOF
3154 install.libs uninstall.libs \\
3155 install.data uninstall.data ::
3156 $MAKE_TERMINFO cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
3159 if test "x$cf_with_manpages" = xyes; then
3160 cat >> Makefile <<CF_EOF
3164 cd man && \${MAKE} \${CF_MFLAGS} \[$]@
3168 cat >> Makefile <<CF_EOF
3171 rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
3172 rm -f headers.sh headers.sed mk_shared_lib.sh
3173 rm -f edit_man.* man_alias.*
3174 rm -rf \${DIRS_TO_MAKE}
3177 # Special case: tack's manpage lives in its own directory.
3178 if test "x$cf_with_manpages" = xyes; then
3179 if test -d tack ; then
3180 if test -f $srcdir/$tack.h; then
3181 cat >> Makefile <<CF_EOF
3185 cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
3191 dnl If we're installing into a subdirectory of /usr/include, etc., we should
3192 dnl prepend the subdirectory's name to the "#include" paths. It won't hurt
3193 dnl anything, and will make it more standardized. It's awkward to decide this
3194 dnl at configuration because of quoting, so we'll simply make all headers
3195 dnl installed via a script that can do the right thing.
3197 rm -f headers.sed headers.sh
3199 dnl ( generating this script makes the makefiles a little tidier :-)
3200 echo creating headers.sh
3201 cat >headers.sh <<CF_EOF
3203 # This shell script is generated by the 'configure' script. It is invoked in a
3204 # subdirectory of the build tree. It generates a sed-script in the parent
3205 # directory that is used to adjust includes for header files that reside in a
3206 # subdirectory of /usr/include, etc.
3208 while test \[$]# != 3
3210 PRG="\$PRG \[$]1"; shift
3215 TMPSRC=\${TMPDIR:-/tmp}/\`basename \$SRC\`\$\$
3216 TMPSED=\${TMPDIR:-/tmp}/headers.sed\$\$
3217 echo installing \$SRC in \$DST
3220 if test $WITH_CURSES_H = yes; then
3221 cat >>headers.sh <<CF_EOF
3224 END=\`basename \$DST\`
3225 for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
3227 NAME=\`basename \$i\`
3228 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
3238 cat >>headers.sh <<CF_EOF
3241 END=\`basename \$DST\`
3242 for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
3244 NAME=\`basename \$i\`
3245 if test "\$NAME" = "curses.h"
3247 echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
3250 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
3254 echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
3259 cat >>headers.sh <<CF_EOF
3261 sed -f \$TMPSED \$SRC > \$TMPSRC
3262 NAME=\`basename \$SRC\`
3264 if test $WITH_CURSES_H != yes; then
3265 cat >>headers.sh <<CF_EOF
3266 test "\$NAME" = "curses.h" && NAME=ncurses.h
3269 cat >>headers.sh <<CF_EOF
3270 # Just in case someone gzip'd manpages, remove the conflicting copy.
3271 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
3273 eval \$PRG \$TMPSRC \$DST/\$NAME
3274 rm -f \$TMPSRC \$TMPSED
3277 chmod 0755 headers.sh
3279 for cf_dir in $SRC_SUBDIRS
3281 if test ! -d $srcdir/$cf_dir ; then
3285 if test -f $srcdir/$cf_dir/headers; then
3286 $AWK -f $srcdir/mk-hdr.awk \
3287 subset="$LIB_SUBSETS" \
3288 compat="$WITH_CURSES_H" \
3289 $srcdir/$cf_dir/headers >>$cf_dir/Makefile
3292 if test -f $srcdir/$cf_dir/modules; then
3293 if test "$cf_dir" != "c++" ; then
3294 cat >>$cf_dir/Makefile <<"CF_EOF"
3295 depend : ${AUTO_SRC}
3296 makedepend -- ${CPPFLAGS} -- ${C_SRC}
3298 # DO NOT DELETE THIS LINE -- make depend depends on it.
3303 AC_SUBST(LIBS_TO_MAKE)
3305 dnl ---------------------------------------------------------------------------
3306 dnl CF_LIB_SONAME version: 5 updated: 2010/08/14 18:25:37
3308 dnl Find the and soname for the given shared library. Set the cache variable
3309 dnl cf_cv_$3_soname to this, unless it is not found. Then set the cache
3310 dnl variable to "unknown".
3314 dnl $3 = library name
3315 AC_DEFUN([CF_LIB_SONAME],
3317 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
3319 cf_cv_$3_soname=unknown
3320 if test "$cross_compiling" != yes ; then
3321 cat >conftest.$ac_ext <<CF_EOF
3326 ${cf_cv_main_return:-return}(0);
3329 cf_save_LIBS="$LIBS"
3331 if AC_TRY_EVAL(ac_compile) ; then
3332 if AC_TRY_EVAL(ac_link) ; then
3333 cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
3334 test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
3338 LIBS="$cf_save_LIBS"
3342 dnl ---------------------------------------------------------------------------
3343 dnl CF_LIB_SUFFIX version: 16 updated: 2008/12/27 12:30:03
3345 dnl Compute the library file-suffix from the given model name
3347 dnl $2 = variable to set (the nominal library suffix)
3348 dnl $3 = dependency variable to set (actual filename)
3349 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
3350 AC_DEFUN([CF_LIB_SUFFIX],
3352 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
3371 case $cf_cv_system_name in
3401 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3402 test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
3404 dnl ---------------------------------------------------------------------------
3405 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
3407 dnl Compute the string to append to -library from the given model name
3409 dnl $2 = variable to set
3410 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
3411 AC_DEFUN([CF_LIB_TYPE],
3420 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3422 dnl ---------------------------------------------------------------------------
3423 dnl CF_LINK_DATAONLY version: 9 updated: 2009/01/01 20:21:38
3424 dnl ----------------
3425 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
3426 dnl only data (i.e., no functions), for example NeXT. On those systems we'll
3427 dnl have to provide wrappers for global tables to ensure they're linked
3429 AC_DEFUN([CF_LINK_DATAONLY],
3431 AC_MSG_CHECKING([if data-only library module links])
3432 AC_CACHE_VAL(cf_cv_link_dataonly,[
3434 cat >conftest.$ac_ext <<EOF
3435 #line __oline__ "configure"
3436 int testdata[[3]] = { 123, 456, 789 };
3438 if AC_TRY_EVAL(ac_compile) ; then
3439 mv conftest.o data.o && \
3440 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
3442 rm -f conftest.$ac_ext data.o
3443 cat >conftest.$ac_ext <<EOF
3444 #line __oline__ "configure"
3448 ${cf_cv_main_return:-return}(1); /* I'm told this linker is broken */
3450 extern int testdata[[3]];
3451 return testdata[[0]] == 123
3452 && testdata[[1]] == 456
3453 && testdata[[2]] == 789;
3457 if AC_TRY_EVAL(ac_compile); then
3458 mv conftest.o func.o && \
3459 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
3461 rm -f conftest.$ac_ext func.o
3462 ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
3464 LIBS="conftest.a $LIBS"
3468 extern int testfunc();
3469 ${cf_cv_main_return:-return} (!testfunc());
3472 [cf_cv_link_dataonly=yes],
3473 [cf_cv_link_dataonly=no],
3474 [cf_cv_link_dataonly=unknown])
3477 AC_MSG_RESULT($cf_cv_link_dataonly)
3479 if test "$cf_cv_link_dataonly" = no ; then
3480 AC_DEFINE(BROKEN_LINKER)
3485 dnl ---------------------------------------------------------------------------
3486 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
3488 dnl Most Unix systems have both link and symlink, a few don't have symlink.
3489 dnl A few non-Unix systems implement symlink, but not link.
3490 dnl A few non-systems implement neither (or have nonfunctional versions).
3491 AC_DEFUN([CF_LINK_FUNCS],
3497 if test "$cross_compiling" = yes ; then
3502 AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
3504 for cf_func in link symlink ; do
3506 #include <sys/types.h>
3507 #include <sys/stat.h>
3508 #ifdef HAVE_UNISTD_H
3514 char *src = "config.log";
3515 char *dst = "conftest.chk";
3520 fail = ($cf_func("config.log", "conftest.chk") < 0)
3521 || (stat(dst, &dst_sb) < 0)
3522 || (dst_sb.st_mtime != src_sb.st_mtime);
3528 ${cf_cv_main_return:-return} (fail);
3531 cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
3532 eval 'ac_cv_func_'$cf_func'=yes'],[
3533 eval 'ac_cv_func_'$cf_func'=no'],[
3534 eval 'ac_cv_func_'$cf_func'=error'])
3536 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
3538 test "$ac_cv_func_link" = yes && AC_DEFINE(HAVE_LINK)
3539 test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
3542 dnl ---------------------------------------------------------------------------
3543 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
3545 dnl Check if a return from main to the shell actually returns the same exit
3546 dnl code. This is true for almost any POSIX environment.
3548 dnl Some very old environments did not flush stdout, etc., on an exit. That
3549 dnl would be a useful case to test for also.
3550 AC_DEFUN([CF_MAIN_RETURN],
3552 cf_cv_main_return=return
3554 dnl ---------------------------------------------------------------------------
3555 dnl CF_MAKEFLAGS version: 14 updated: 2011/03/31 19:29:46
3557 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
3558 dnl options to lower-levels. It's very useful for "make -n" -- if we have it.
3559 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
3560 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
3561 AC_DEFUN([CF_MAKEFLAGS],
3563 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
3565 for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
3567 cat >cf_makeflags.tmp <<CF_EOF
3570 @ echo '.$cf_option'
3572 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | fgrep -v "ing directory" | sed -e 's,[[ ]]*$,,'`
3573 case "$cf_result" in
3575 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
3576 case "$cf_result" in
3577 .*CC=*) cf_cv_makeflags=
3579 *) cf_cv_makeflags=$cf_option
3585 *) echo "given option \"$cf_option\", no match \"$cf_result\""
3589 rm -f cf_makeflags.tmp
3592 AC_SUBST(cf_cv_makeflags)
3594 dnl ---------------------------------------------------------------------------
3595 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
3597 dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have
3598 dnl a monocase filesystem.
3599 AC_DEFUN([CF_MAKE_TAGS],[
3600 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
3602 AC_CHECK_PROGS(CTAGS, exctags ctags)
3603 AC_CHECK_PROGS(ETAGS, exetags etags)
3605 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
3607 if test "$cf_cv_mixedcase" = yes ; then
3608 AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
3613 if test "$MAKE_UPPER_TAGS" = yes ; then
3619 if test "$MAKE_LOWER_TAGS" = yes ; then
3628 AC_SUBST(MAKE_UPPER_TAGS)
3629 AC_SUBST(MAKE_LOWER_TAGS)
3631 dnl ---------------------------------------------------------------------------
3632 dnl CF_MANPAGE_FORMAT version: 9 updated: 2010/10/23 16:10:30
3633 dnl -----------------
3634 dnl Option to allow user to override automatic configuration of manpage format.
3635 dnl There are several special cases:
3637 dnl gzip - man checks for, can display gzip'd files
3638 dnl compress - man checks for, can display compressed files
3639 dnl BSDI - files in the cat-directories are suffixed ".0"
3640 dnl formatted - installer should format (put files in cat-directory)
3641 dnl catonly - installer should only format, e.g., for a turnkey system.
3643 dnl There are other configurations which this macro does not test, e.g., HPUX's
3644 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
3645 dnl convention would not match our use).
3646 AC_DEFUN([CF_MANPAGE_FORMAT],
3648 AC_REQUIRE([CF_PATHSEP])
3649 AC_MSG_CHECKING(format of man-pages)
3651 AC_ARG_WITH(manpage-format,
3652 [ --with-manpage-format specify manpage-format: gzip/compress/BSDI/normal and
3653 optionally formatted/catonly, e.g., gzip,formatted],
3654 [MANPAGE_FORMAT=$withval],
3655 [MANPAGE_FORMAT=unknown])
3657 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
3658 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
3662 case $MANPAGE_FORMAT in
3664 if test -z "$MANPATH" ; then
3665 MANPATH="/usr/man:/usr/share/man"
3668 # look for the 'date' man-page (it's most likely to be installed!)
3674 IFS="${IFS:- }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
3675 for cf_dir in $MANPATH; do
3676 test -z "$cf_dir" && cf_dir=/usr/man
3677 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
3679 cf_test=`echo $cf_name | sed -e 's/*//'`
3680 if test "x$cf_test" = "x$cf_name" ; then
3683 *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
3684 *.Z) MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
3685 *.0) MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
3686 *) MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
3700 # if we found a match in either man* or cat*, stop looking
3701 if test -n "$MANPAGE_FORMAT" ; then
3703 test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
3704 test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
3710 test $cf_found=yes && break
3713 # only check the first directory in $MANPATH where we find manpages
3714 if test -n "$MANPAGE_FORMAT" ; then
3718 # if we did not find the example, just assume it is normal
3719 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
3723 for cf_option in $MANPAGE_FORMAT; do
3724 case $cf_option in #(vi
3725 gzip|compress|BSDI|normal|formatted|catonly)
3728 cf_unknown="$cf_unknown $cf_option"
3735 AC_MSG_RESULT($MANPAGE_FORMAT)
3736 if test -n "$cf_unknown" ; then
3737 AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
3740 dnl ---------------------------------------------------------------------------
3741 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
3742 dnl ------------------
3743 dnl The Debian people have their own naming convention for manpages. This
3744 dnl option lets us override the name of the file containing renaming, or
3745 dnl disable it altogether.
3746 AC_DEFUN([CF_MANPAGE_RENAMES],
3748 AC_MSG_CHECKING(for manpage renaming)
3750 AC_ARG_WITH(manpage-renames,
3751 [ --with-manpage-renames specify manpage-renaming],
3752 [MANPAGE_RENAMES=$withval],
3753 [MANPAGE_RENAMES=yes])
3755 case ".$MANPAGE_RENAMES" in #(vi
3759 # Debian 'man' program?
3760 if test -f /etc/debian_version ; then
3761 MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
3768 if test "$MANPAGE_RENAMES" != no ; then
3769 if test -f $srcdir/man/$MANPAGE_RENAMES ; then
3770 MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
3771 elif test ! -f $MANPAGE_RENAMES ; then
3772 AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
3775 test ! -d man && mkdir man
3777 # Construct a sed-script to perform renaming within man-pages
3778 if test -n "$MANPAGE_RENAMES" ; then
3779 test ! -d man && mkdir man
3780 sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
3784 AC_MSG_RESULT($MANPAGE_RENAMES)
3785 AC_SUBST(MANPAGE_RENAMES)
3787 dnl ---------------------------------------------------------------------------
3788 dnl CF_MANPAGE_SYMLINKS version: 5 updated: 2010/07/24 17:12:40
3789 dnl -------------------
3790 dnl Some people expect each tool to make all aliases for manpages in the
3791 dnl man-directory. This accommodates the older, less-capable implementations
3792 dnl of 'man', and is optional.
3793 AC_DEFUN([CF_MANPAGE_SYMLINKS],
3795 AC_MSG_CHECKING(if manpage aliases will be installed)
3797 AC_ARG_WITH(manpage-aliases,
3798 [ --with-manpage-aliases specify manpage-aliases using .so],
3799 [MANPAGE_ALIASES=$withval],
3800 [MANPAGE_ALIASES=yes])
3802 AC_MSG_RESULT($MANPAGE_ALIASES)
3804 case "x$LN_S" in #(vi
3814 if test "$MANPAGE_ALIASES" = yes ; then
3815 AC_MSG_CHECKING(if manpage symlinks should be used)
3817 AC_ARG_WITH(manpage-symlinks,
3818 [ --with-manpage-symlinks specify manpage-aliases using symlinks],
3819 [MANPAGE_SYMLINKS=$withval],
3820 [MANPAGE_SYMLINKS=$cf_use_symlinks])
3822 if test "$$cf_use_symlinks" = no; then
3823 if test "$MANPAGE_SYMLINKS" = yes ; then
3824 AC_MSG_WARN(cannot make symlinks, will use .so files)
3829 AC_MSG_RESULT($MANPAGE_SYMLINKS)
3833 dnl ---------------------------------------------------------------------------
3834 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
3836 dnl This option causes manpages to be run through tbl(1) to generate tables
3838 AC_DEFUN([CF_MANPAGE_TBL],
3840 AC_MSG_CHECKING(for manpage tbl)
3842 AC_ARG_WITH(manpage-tbl,
3843 [ --with-manpage-tbl specify manpage processing with tbl],
3844 [MANPAGE_TBL=$withval],
3847 AC_MSG_RESULT($MANPAGE_TBL)
3849 dnl ---------------------------------------------------------------------------
3850 dnl CF_MAN_PAGES version: 39 updated: 2010/10/23 15:44:18
3852 dnl Try to determine if the man-pages on the system are compressed, and if
3853 dnl so, what format is used. Use this information to construct a script that
3854 dnl will install man-pages.
3855 AC_DEFUN([CF_MAN_PAGES],
3857 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
3863 if test "$prefix" = "NONE" ; then
3864 cf_prefix="$ac_default_prefix"
3869 case "$MANPAGE_FORMAT" in # (vi
3884 test ! -d man && mkdir man
3888 case "$MANPAGE_FORMAT" in #(vi
3891 cf_compress=compress
3899 cf_edit_man=./edit_man.sh
3900 cf_man_alias=`pwd`/man_alias.sed
3902 cat >$cf_edit_man <<CF_EOF
3904 # this script is generated by the configure-script CF_MAN_PAGES macro.
3909 NCURSES_MAJOR="$NCURSES_MAJOR"
3910 NCURSES_MINOR="$NCURSES_MINOR"
3911 NCURSES_PATCH="$NCURSES_PATCH"
3913 NCURSES_OSPEED="$NCURSES_OSPEED"
3914 TERMINFO="$TERMINFO"
3917 INSTALL_DATA="$INSTALL_DATA"
3919 transform="$program_transform_name"
3921 TMP=\${TMPDIR:=/tmp}/man\$\$
3922 trap "rm -f \$TMP" 0 1 2 5 15
3934 top_srcdir=\[$]srcdir/..
3937 if test "\$form" = normal ; then
3938 if test "$cf_format" = yes ; then
3939 if test "$cf_inboth" = no ; then
3940 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3944 cf_subdir=\$mandir/man
3945 cf_tables=$MANPAGE_TBL
3947 cf_subdir=\$mandir/cat
3951 # process the list of source-files
3954 *.orig|*.rej) ;; #(vi
3956 section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
3957 if test \$verb = installing ; then
3958 if test ! -d \$cf_subdir\${section} ; then
3959 mkdir -p \$cf_subdir\$section
3963 # replace variables in man page
3964 if test ! -f $cf_man_alias ; then
3965 cat >>$cf_man_alias <<-CF_EOF2
3966 s,@DATADIR@,\$datadir,g
3967 s,@TERMINFO@,\$TERMINFO,g
3968 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
3969 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
3970 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
3971 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
3976 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3977 cf_name=`echo $cf_name|sed "$program_transform_name"`
3978 cat >>$cf_edit_man <<-CF_EOF
3979 s,@$cf_NAME@,$cf_name,g
3983 cat >>$cf_edit_man <<CF_EOF
3985 echo "...made $cf_man_alias"
3989 cf_source=\`basename \$i\`
3991 test ! -f \$inalias && inalias="\$srcdir/\$inalias"
3992 if test ! -f \$inalias ; then
3993 echo .. skipped \$cf_source
3998 if test "$MANPAGE_ALIASES" != no ; then
3999 cat >>$cf_edit_man <<CF_EOF
4000 aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
4004 if test "$MANPAGE_RENAMES" = no ; then
4005 cat >>$cf_edit_man <<CF_EOF
4006 # perform program transformations for section 1 man pages
4007 if test \$section = 1 ; then
4008 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
4010 cf_target=\$cf_subdir\${section}/\$cf_source
4014 cat >>$cf_edit_man <<CF_EOF
4015 cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
4016 if test -z "\$cf_target" ; then
4017 echo '? missing rename for '\$cf_source
4018 cf_target="\$cf_source"
4020 cf_target="\$cf_subdir\${section}/\${cf_target}"
4025 cat >>$cf_edit_man <<CF_EOF
4026 sed -f $cf_man_alias \\
4029 if test -f $MANPAGE_RENAMES ; then
4030 cat >>$cf_edit_man <<CF_EOF
4031 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
4034 cat >>$cf_edit_man <<CF_EOF
4039 cat >>$cf_edit_man <<CF_EOF
4040 if test \$cf_tables = yes ; then
4041 tbl \$TMP >\$TMP.out
4046 if test $with_curses_h != yes ; then
4047 cat >>$cf_edit_man <<CF_EOF
4048 sed -e "/\#[ ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
4053 cat >>$cf_edit_man <<CF_EOF
4054 if test \$form = format ; then
4055 nroff -man \$TMP >\$TMP.out
4060 if test -n "$cf_compress" ; then
4061 cat >>$cf_edit_man <<CF_EOF
4062 if test \$verb = installing ; then
4063 if ( $cf_compress -f \$TMP )
4065 mv \$TMP.$cf_so_strip \$TMP
4068 cf_target="\$cf_target.$cf_so_strip"
4072 case "$MANPAGE_FORMAT" in #(vi
4074 cat >>$cf_edit_man <<CF_EOF
4075 if test \$form = format ; then
4076 # BSDI installs only .0 suffixes in the cat directories
4077 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
4083 cat >>$cf_edit_man <<CF_EOF
4084 suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
4085 if test \$verb = installing ; then
4086 echo \$verb \$cf_target
4087 \$INSTALL_DATA \$TMP \$cf_target
4088 test -d \$cf_subdir\${section} &&
4089 test -n "\$aliases" && (
4090 cd \$cf_subdir\${section} && (
4091 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
4092 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
4093 cf_target=\`basename \$cf_target\`
4094 for cf_alias in \$aliases
4096 if test \$section = 1 ; then
4097 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
4100 if test "$MANPAGE_SYMLINKS" = yes ; then
4101 if test -f \$cf_alias\${suffix} ; then
4102 if ( cmp -s \$cf_target \$cf_alias\${suffix} )
4107 echo .. \$verb alias \$cf_alias\${suffix}
4109 case "x$LN_S" in #(vi
4111 cat >>$cf_edit_man <<CF_EOF
4112 $LN_S \$cf_target \$cf_alias\${suffix}
4116 cat >>$cf_edit_man <<CF_EOF
4117 rm -f \$cf_alias\${suffix}
4118 $LN_S \$cf_target \$cf_alias\${suffix}
4122 cat >>$cf_edit_man <<CF_EOF
4123 elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
4124 echo ".so \$cf_source" >\$TMP
4126 if test -n "$cf_compress" ; then
4127 cat >>$cf_edit_man <<CF_EOF
4128 if test -n "$cf_so_strip" ; then
4129 $cf_compress -f \$TMP
4130 mv \$TMP.$cf_so_strip \$TMP
4134 cat >>$cf_edit_man <<CF_EOF
4135 echo .. \$verb alias \$cf_alias\${suffix}
4136 rm -f \$cf_alias\${suffix}
4137 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
4142 elif test \$verb = removing ; then
4143 test -f \$cf_target && (
4144 echo \$verb \$cf_target
4147 test -d \$cf_subdir\${section} &&
4148 test -n "\$aliases" && (
4149 cd \$cf_subdir\${section} && (
4150 for cf_alias in \$aliases
4152 if test \$section = 1 ; then
4153 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
4156 echo .. \$verb alias \$cf_alias\${suffix}
4157 rm -f \$cf_alias\${suffix}
4169 if test $cf_inboth = yes ; then
4170 if test \$form != format ; then
4171 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
4177 chmod 755 $cf_edit_man
4180 dnl ---------------------------------------------------------------------------
4181 dnl CF_MATH_LIB version: 8 updated: 2010/05/29 16:31:02
4183 dnl Checks for libraries. At least one UNIX system, Apple Macintosh
4184 dnl Rhapsody 5.5, does not have -lm. We cannot use the simpler
4185 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
4186 AC_DEFUN([CF_MATH_LIB],
4188 AC_CACHE_CHECK(if -lm needed for math functions,
4194 [double x = rand(); printf("result = %g\n", ]ifelse([$2],,sin(x),$2)[)],
4195 [cf_cv_need_libm=no],
4196 [cf_cv_need_libm=yes])])
4197 if test "$cf_cv_need_libm" = yes
4204 dnl ---------------------------------------------------------------------------
4205 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
4206 dnl ----------------------
4207 dnl Check if the file-system supports mixed-case filenames. If we're able to
4208 dnl create a lowercase name and see it as uppercase, it doesn't support that.
4209 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
4211 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
4212 if test "$cross_compiling" = yes ; then
4213 case $target_alias in #(vi
4214 *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
4222 rm -f conftest CONFTEST
4224 if test -f CONFTEST ; then
4229 rm -f conftest CONFTEST
4232 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
4234 dnl ---------------------------------------------------------------------------
4235 dnl CF_MKSTEMP version: 7 updated: 2010/08/14 18:25:37
4237 dnl Check for a working mkstemp. This creates two files, checks that they are
4238 dnl successfully created and distinct (AmigaOS apparently fails on the last).
4239 AC_DEFUN([CF_MKSTEMP],[
4240 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
4243 #include <sys/types.h>
4247 #include <sys/stat.h>
4250 char *tmpl = "conftestXXXXXX";
4258 for (n = 0; n < 2; ++n) {
4259 strcpy(name[n], tmpl);
4260 if ((fd = mkstemp(name[n])) >= 0) {
4261 if (!strcmp(name[n], tmpl)
4262 || stat(name[n], &sb) != 0
4263 || (sb.st_mode & S_IFMT) != S_IFREG
4264 || (sb.st_mode & 077) != 0) {
4271 && !strcmp(name[0], name[1]))
4273 ${cf_cv_main_return:-return}(result);
4275 ],[cf_cv_func_mkstemp=yes
4276 ],[cf_cv_func_mkstemp=no
4277 ],[AC_CHECK_FUNC(mkstemp)
4280 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
4281 AC_DEFINE(HAVE_MKSTEMP)
4284 dnl ---------------------------------------------------------------------------
4285 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
4287 dnl Write a debug message to config.log, along with the line number in the
4288 dnl configure script.
4289 AC_DEFUN([CF_MSG_LOG],[
4290 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
4292 dnl ---------------------------------------------------------------------------
4293 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
4294 dnl ----------------
4295 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
4296 dnl warn about this.
4297 AC_DEFUN([CF_NCURSES_ABI_6],[
4298 if test "${with_abi_version+set}" != set; then
4299 case $cf_cv_rel_version in
4301 cf_cv_rel_version=6.0
4303 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
4308 dnl ---------------------------------------------------------------------------
4309 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
4310 dnl ------------------
4311 dnl see CF_WITH_NO_LEAKS
4312 AC_DEFUN([CF_NO_LEAKS_OPTION],[
4313 AC_MSG_CHECKING(if you want to use $1 for testing)
4316 [AC_DEFINE($3)ifelse([$4],,[
4319 : ${with_cflags:=-g}
4320 : ${with_no_leaks:=yes}
4323 AC_MSG_RESULT(${with_$1:-no})
4325 case .$with_cflags in #(vi
4327 case .$CFLAGS in #(vi
4337 dnl ---------------------------------------------------------------------------
4338 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
4339 dnl ----------------
4340 dnl Check if the given variable is a number. If not, report an error.
4341 dnl $1 is the variable
4342 dnl $2 is the message
4343 AC_DEFUN([CF_NUMBER_SYNTAX],[
4344 if test -n "$1" ; then
4349 AC_MSG_ERROR($2 is not a number: $1)
4353 AC_MSG_ERROR($2 value is empty)
4356 dnl ---------------------------------------------------------------------------
4357 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
4359 dnl Compute the object-directory name from the given model name
4360 AC_DEFUN([CF_OBJ_SUBDIR],
4363 libtool) $2='obj_lo' ;;
4364 normal) $2='objects' ;;
4365 debug) $2='obj_g' ;;
4366 profile) $2='obj_p' ;;
4368 case $cf_cv_system_name in #(vi
4376 dnl ---------------------------------------------------------------------------
4377 dnl CF_PATHSEP version: 5 updated: 2010/05/26 05:38:42
4379 dnl Provide a value for the $PATH and similar separator
4380 AC_DEFUN([CF_PATHSEP],
4382 case $cf_cv_system_name in
4383 os2*) PATH_SEPARATOR=';' ;;
4384 *) PATH_SEPARATOR=':' ;;
4386 ifelse([$1],,,[$1=$PATH_SEPARATOR])
4387 AC_SUBST(PATH_SEPARATOR)
4389 dnl ---------------------------------------------------------------------------
4390 dnl CF_PATH_SYNTAX version: 13 updated: 2010/05/26 05:38:42
4392 dnl Check the argument to see that it looks like a pathname. Rewrite it if it
4393 dnl begins with one of the prefix/exec_prefix variables, and then again if the
4394 dnl result begins with 'NONE'. This is necessary to work around autoconf's
4395 dnl delayed evaluation of those symbols.
4396 AC_DEFUN([CF_PATH_SYNTAX],[
4397 if test "x$prefix" != xNONE; then
4398 cf_path_syntax="$prefix"
4400 cf_path_syntax="$ac_default_prefix"
4403 case ".[$]$1" in #(vi
4404 .\[$]\(*\)*|.\'*\'*) #(vi
4408 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
4410 .\[$]{*prefix}*) #(vi
4412 case ".[$]$1" in #(vi
4414 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
4419 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
4422 ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
4426 dnl ---------------------------------------------------------------------------
4427 dnl CF_PKG_CONFIG version: 7 updated: 2011/04/29 04:53:22
4429 dnl Check for the package-config program, unless disabled by command-line.
4430 AC_DEFUN([CF_PKG_CONFIG],
4432 AC_MSG_CHECKING(if you want to use pkg-config)
4433 AC_ARG_WITH(pkg-config,
4434 [ --with-pkg-config{=path} enable/disable use of pkg-config],
4435 [cf_pkg_config=$withval],
4436 [cf_pkg_config=yes])
4437 AC_MSG_RESULT($cf_pkg_config)
4439 case $cf_pkg_config in #(vi
4444 CF_ACVERSION_CHECK(2.52,
4445 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
4446 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
4453 test -z "$PKG_CONFIG" && PKG_CONFIG=none
4454 if test "$PKG_CONFIG" != none ; then
4455 CF_PATH_SYNTAX(PKG_CONFIG)
4458 AC_SUBST(PKG_CONFIG)
4460 dnl ---------------------------------------------------------------------------
4461 dnl CF_POSIX_C_SOURCE version: 8 updated: 2010/05/26 05:38:42
4462 dnl -----------------
4463 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
4465 dnl POSIX.1-1990 _POSIX_SOURCE
4466 dnl POSIX.1-1990 and _POSIX_SOURCE and
4467 dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2
4469 dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L
4470 dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L
4471 dnl X/Open 2000 _POSIX_C_SOURCE=200112L
4474 dnl $1 is the nominal value for _POSIX_C_SOURCE
4475 AC_DEFUN([CF_POSIX_C_SOURCE],
4477 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
4479 cf_save_CFLAGS="$CFLAGS"
4480 cf_save_CPPFLAGS="$CPPFLAGS"
4482 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
4483 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
4485 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
4486 CF_MSG_LOG(if the symbol is already defined go no further)
4487 AC_TRY_COMPILE([#include <sys/types.h>],[
4488 #ifndef _POSIX_C_SOURCE
4491 [cf_cv_posix_c_source=no],
4492 [cf_want_posix_source=no
4493 case .$cf_POSIX_C_SOURCE in #(vi
4495 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
4498 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
4499 cf_want_posix_source=yes
4502 cf_want_posix_source=yes
4505 if test "$cf_want_posix_source" = yes ; then
4506 AC_TRY_COMPILE([#include <sys/types.h>],[
4507 #ifdef _POSIX_SOURCE
4510 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
4512 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
4513 CFLAGS="$cf_trim_CFLAGS"
4514 CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
4515 CF_MSG_LOG(if the second compile does not leave our definition intact error)
4516 AC_TRY_COMPILE([#include <sys/types.h>],[
4517 #ifndef _POSIX_C_SOURCE
4520 [cf_cv_posix_c_source=no])
4521 CFLAGS="$cf_save_CFLAGS"
4522 CPPFLAGS="$cf_save_CPPFLAGS"
4526 if test "$cf_cv_posix_c_source" != no ; then
4527 CFLAGS="$cf_trim_CFLAGS"
4528 CPPFLAGS="$cf_trim_CPPFLAGS"
4529 CF_ADD_CFLAGS($cf_cv_posix_c_source)
4533 dnl ---------------------------------------------------------------------------
4534 dnl CF_PREDEFINE version: 2 updated: 2010/05/26 16:44:57
4536 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
4538 dnl $1 = symbol to test
4539 dnl $2 = value (if any) to use for a predefinition
4540 AC_DEFUN([CF_PREDEFINE],
4542 AC_MSG_CHECKING(if we must define $1)
4543 AC_TRY_COMPILE([#include <sys/types.h>
4547 #endif],[cf_result=no],[cf_result=yes])
4548 AC_MSG_RESULT($cf_result)
4550 if test "$cf_result" = yes ; then
4551 CPPFLAGS="$CPPFLAGS ifelse([$2],,-D$1,[-D$1=$2])"
4552 elif test "x$2" != "x" ; then
4553 AC_MSG_CHECKING(checking for compatible value versus $2)
4554 AC_TRY_COMPILE([#include <sys/types.h>
4558 #endif],[cf_result=yes],[cf_result=no])
4559 AC_MSG_RESULT($cf_result)
4560 if test "$cf_result" = no ; then
4561 # perhaps we can override it - try...
4562 CPPFLAGS="$CPPFLAGS -D$1=$2"
4566 dnl ---------------------------------------------------------------------------
4567 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
4569 dnl Append definitions and rules for the given programs to the subdirectory
4570 dnl Makefiles, and the recursion rule for the top-level Makefile.
4573 dnl $1 = script to run
4574 dnl $2 = list of subdirectories
4578 AC_DEFUN([CF_PRG_RULES],
4582 if test ! -d $srcdir/$cf_dir; then
4584 elif test -f $srcdir/$cf_dir/programs; then
4585 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
4590 dnl ---------------------------------------------------------------------------
4591 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
4593 dnl Check for archiver "ar".
4594 AC_DEFUN([CF_PROG_AR],[
4595 AC_CHECK_TOOL(AR, ar, ar)
4597 dnl ---------------------------------------------------------------------------
4598 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
4600 dnl Check for awk, ensure that the check found something.
4601 AC_DEFUN([CF_PROG_AWK],
4604 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
4606 dnl ---------------------------------------------------------------------------
4607 dnl CF_PROG_CC_C_O version: 3 updated: 2010/08/14 18:25:37
4609 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
4610 dnl the output file can be renamed, and allows for a shell variable that can
4611 dnl be used later. The parameter is either CC or CXX. The result is the
4613 dnl $cf_cv_prog_CC_c_o
4614 dnl $cf_cv_prog_CXX_c_o
4615 AC_DEFUN([CF_PROG_CC_C_O],
4616 [AC_REQUIRE([AC_PROG_CC])dnl
4617 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
4618 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
4620 cat > conftest.$ac_ext <<CF_EOF
4624 ${cf_cv_main_return:-return}(0);
4627 # We do the test twice because some compilers refuse to overwrite an
4628 # existing .o file with -o, though they will create one.
4629 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
4630 if AC_TRY_EVAL(ac_try) &&
4631 test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
4633 eval cf_cv_prog_$1_c_o=yes
4635 eval cf_cv_prog_$1_c_o=no
4639 if test $cf_cv_prog_$1_c_o = yes; then
4640 AC_MSG_RESULT([yes])
4645 dnl ---------------------------------------------------------------------------
4646 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
4648 dnl Check if C (preprocessor) -U and -D options are processed in the order
4649 dnl given rather than by type of option. Some compilers insist on apply all
4650 dnl of the -U options after all of the -D options. Others allow mixing them,
4651 dnl and may predefine symbols that conflict with those we define.
4652 AC_DEFUN([CF_PROG_CC_U_D],
4654 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
4655 cf_save_CPPFLAGS="$CPPFLAGS"
4656 CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
4659 make an undefined-error
4662 make a defined-error
4665 cf_cv_cc_u_d_options=yes],[
4666 cf_cv_cc_u_d_options=no])
4667 CPPFLAGS="$cf_save_CPPFLAGS"
4670 dnl ---------------------------------------------------------------------------
4671 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
4673 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
4674 dnl This macro adds a check to ensure the script found something.
4675 AC_DEFUN([CF_PROG_EGREP],
4676 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
4677 [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4678 then ac_cv_prog_egrep='grep -E'
4679 else ac_cv_prog_egrep='egrep'
4681 EGREP=$ac_cv_prog_egrep
4683 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
4685 dnl ---------------------------------------------------------------------------
4686 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
4688 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
4689 AC_DEFUN([CF_PROG_EXT],
4691 AC_REQUIRE([CF_CHECK_CACHE])
4692 case $cf_cv_system_name in
4694 CFLAGS="$CFLAGS -Zmt"
4695 CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
4696 CXXFLAGS="$CXXFLAGS -Zmt"
4697 # autoconf's macro sets -Zexe and suffix both, which conflict:w
4698 LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
4708 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
4710 dnl ---------------------------------------------------------------------------
4711 dnl CF_PROG_GNAT version: 1 updated: 2010/06/19 15:22:18
4713 dnl Check for gnatmake, ensure that it is complete.
4714 AC_DEFUN([CF_PROG_GNAT],[
4715 cf_ada_make=gnatmake
4716 AC_CHECK_PROG(gnat_exists, $cf_ada_make, yes, no)
4717 if test "$ac_cv_prog_gnat_exists" = no; then
4721 AC_CHECK_PROG(M4_exists, m4, yes, no)
4722 if test "$ac_cv_prog_M4_exists" = no; then
4723 cf_cv_prog_gnat_correct=no
4724 echo Ada95 binding required program m4 not found. Ada95 binding disabled.
4726 if test "$cf_cv_prog_gnat_correct" = yes; then
4727 AC_MSG_CHECKING(if GNAT works)
4728 CF_GNAT_TRY_RUN([procedure conftest;],
4731 procedure conftest is
4733 Text_IO.Put ("Hello World");
4735 GNAT.OS_Lib.OS_Exit (0);
4736 end conftest;],[cf_cv_prog_gnat_correct=yes],[cf_cv_prog_gnat_correct=no])
4737 AC_MSG_RESULT($cf_cv_prog_gnat_correct)
4741 AC_SUBST(cf_ada_make)
4743 dnl ---------------------------------------------------------------------------
4744 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
4746 dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the
4747 dnl misc/tabset install won't work properly. Usually this happens only when
4748 dnl using the fallback mkinstalldirs script
4749 AC_DEFUN([CF_PROG_INSTALL],
4755 CF_DIRNAME(cf_dir,$INSTALL)
4756 test -z "$cf_dir" && cf_dir=.
4757 INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
4761 dnl ---------------------------------------------------------------------------
4762 dnl CF_PROG_LDCONFIG version: 3 updated: 2011/06/04 20:09:13
4763 dnl ----------------
4764 dnl Check for ldconfig, needed to fixup shared libraries that would be built
4765 dnl and then used in the install.
4766 AC_DEFUN([CF_PROG_LDCONFIG],[
4767 if test "$cross_compiling" = yes ; then
4770 case "$cf_cv_system_name" in #(vi
4771 dragonfly*|mirbsd*|freebsd*) #(vi
4772 test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
4774 *) LDPATH=$PATH:/sbin:/usr/sbin
4775 AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
4781 dnl ---------------------------------------------------------------------------
4782 dnl CF_PROG_LINT version: 2 updated: 2009/08/12 04:43:14
4784 AC_DEFUN([CF_PROG_LINT],
4786 AC_CHECK_PROGS(LINT, tdlint lint alint splint lclint)
4789 dnl ---------------------------------------------------------------------------
4790 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
4792 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
4793 dnl option if it is supported.
4794 AC_DEFUN([CF_PROG_LN_S],[
4796 AC_MSG_CHECKING(if $LN_S -f options work)
4798 rm -f conf$$.src conf$$dst
4800 echo first >conf$$.src
4801 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
4806 rm -f conf$$.dst conf$$src
4807 AC_MSG_RESULT($cf_prog_ln_sf)
4809 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
4811 dnl ---------------------------------------------------------------------------
4812 dnl CF_REGEX version: 8 updated: 2010/08/07 14:09:44
4814 dnl Attempt to determine if we've got one of the flavors of regular-expression
4815 dnl code that we can support.
4816 AC_DEFUN([CF_REGEX],
4821 cf_regex_libs="regex re"
4822 case $host_os in #(vi
4824 cf_regex_libs="regex.dll $cf_regex_libs"
4828 AC_CHECK_FUNC(regcomp,[cf_regex_func=regcomp],[
4829 for cf_regex_lib in $cf_regex_libs
4831 AC_CHECK_LIB($cf_regex_lib,regcomp,[
4832 CF_ADD_LIB($cf_regex_lib)
4833 cf_regex_func=regcomp
4838 if test "$cf_regex_func" = no ; then
4839 AC_CHECK_FUNC(compile,[cf_regex_func=compile],[
4840 AC_CHECK_LIB(gen,compile,[
4842 cf_regex_func=compile])])
4845 if test "$cf_regex_func" = no ; then
4846 AC_MSG_WARN(cannot find regular expression library)
4849 AC_CACHE_CHECK(for regular-expression headers,cf_cv_regex_hdrs,[
4852 case $cf_regex_func in #(vi
4854 for cf_regex_hdr in regexp.h regexpr.h
4856 AC_TRY_LINK([#include <$cf_regex_hdr>],[
4857 char *p = compile("", "", "", 0);
4858 int x = step("", "");
4860 cf_cv_regex_hdrs=$cf_regex_hdr
4866 for cf_regex_hdr in regex.h
4868 AC_TRY_LINK([#include <sys/types.h>
4869 #include <$cf_regex_hdr>],[
4871 int x = regcomp(p, "", 0);
4872 int y = regexec(p, "", 0, 0, 0);
4875 cf_cv_regex_hdrs=$cf_regex_hdr
4884 case $cf_cv_regex_hdrs in #(vi
4885 no) AC_MSG_WARN(no regular expression header found) ;; #(vi
4886 regex.h) AC_DEFINE(HAVE_REGEX_H_FUNCS) ;; #(vi
4887 regexp.h) AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;; #(vi
4888 regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;;
4891 dnl ---------------------------------------------------------------------------
4892 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
4893 dnl ----------------
4894 dnl Remove all -U and -D options that refer to the given symbol from a list
4895 dnl of C compiler options. This works around the problem that not all
4896 dnl compilers process -U and -D options from left-to-right, so a -U option
4897 dnl cannot be used to cancel the effect of a preceding -D option.
4899 dnl $1 = target (which could be the same as the source variable)
4900 dnl $2 = source (including '$')
4901 dnl $3 = symbol to remove
4902 define([CF_REMOVE_DEFINE],
4905 sed -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[[ ]]/ /g' \
4906 -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[$]//g'`
4908 dnl ---------------------------------------------------------------------------
4909 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
4911 dnl Remove the given library from the symbol
4913 dnl $1 = target (which could be the same as the source variable)
4914 dnl $2 = source (including '$')
4915 dnl $3 = library to remove
4916 define([CF_REMOVE_LIB],
4918 # remove $3 library from $2
4919 $1=`echo "$2" | sed -e 's/-l$3[[ ]]//g' -e 's/-l$3[$]//'`
4921 dnl ---------------------------------------------------------------------------
4922 dnl CF_RPATH_HACK version: 9 updated: 2011/02/13 13:31:33
4924 AC_DEFUN([CF_RPATH_HACK],
4926 AC_REQUIRE([CF_LD_RPATH_OPT])
4927 AC_MSG_CHECKING(for updated LDFLAGS)
4928 if test -n "$LD_RPATH_OPT" ; then
4929 AC_MSG_RESULT(maybe)
4931 AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
4932 cf_rpath_list="/usr/lib /lib"
4933 if test "$cf_ldd_prog" != no
4937 AC_TRY_LINK([#include <stdio.h>],
4939 [cf_rpath_oops=`$cf_ldd_prog conftest$ac_exeext | fgrep ' not found' | sed -e 's% =>.*$%%' |sort -u`
4940 cf_rpath_list=`$cf_ldd_prog conftest$ac_exeext | fgrep / | sed -e 's%^.*[[ ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort -u`])
4942 # If we passed the link-test, but get a "not found" on a given library,
4943 # this could be due to inept reconfiguration of gcc to make it only
4944 # partly honor /usr/local/lib (or whatever). Sometimes this behavior
4945 # is intentional, e.g., installing gcc in /usr/bin and suppressing the
4946 # /usr/local libraries.
4947 if test -n "$cf_rpath_oops"
4949 for cf_rpath_src in $cf_rpath_oops
4951 for cf_rpath_dir in \
4956 if test -f $cf_rpath_dir/lib/$cf_rpath_src
4958 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
4959 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
4967 CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
4969 CF_RPATH_HACK_2(LDFLAGS)
4970 CF_RPATH_HACK_2(LIBS)
4972 CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
4974 AC_SUBST(EXTRA_LDFLAGS)
4976 dnl ---------------------------------------------------------------------------
4977 dnl CF_RPATH_HACK_2 version: 6 updated: 2010/04/17 16:31:24
4979 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
4980 dnl EXTRA_LDFLAGS for each -L option found.
4982 dnl $cf_rpath_list contains a list of directories to ignore.
4984 dnl $1 = variable name to update. The LDFLAGS variable should be the only one,
4985 dnl but LIBS often has misplaced -L options.
4986 AC_DEFUN([CF_RPATH_HACK_2],
4988 CF_VERBOSE(...checking $1 [$]$1)
4991 for cf_rpath_src in [$]$1
4993 case $cf_rpath_src in #(vi
4996 # check if this refers to a directory which we will ignore
4998 if test -n "$cf_rpath_list"
5000 for cf_rpath_item in $cf_rpath_list
5002 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
5010 if test "$cf_rpath_skip" = no
5012 # transform the option
5013 if test "$LD_RPATH_OPT" = "-R " ; then
5014 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
5016 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
5019 # if we have not already added this, add it now
5020 cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
5021 if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
5023 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
5024 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
5029 cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
5033 CF_VERBOSE(...checked $1 [$]$1)
5034 AC_SUBST(EXTRA_LDFLAGS)
5036 dnl ---------------------------------------------------------------------------
5037 dnl CF_SHARED_OPTS version: 66 updated: 2011/06/04 20:09:13
5040 dnl Attempt to determine the appropriate CC/LD options for creating a shared
5043 dnl Note: ${LOCAL_LDFLAGS} is used to link executables that will run within the
5044 dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib
5045 dnl We avoid compiling-in a ../lib path for the shared library since that can
5046 dnl lead to unexpected results at runtime.
5047 dnl ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared libraries
5048 dnl are compiled in ../../lib
5050 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
5051 dnl to install symbolic links to the rel/abi versions of shared libraries.
5053 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
5054 dnl version when making symbolic links.
5056 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
5057 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
5058 dnl (ex: libncurses.so.<ver>).
5060 dnl Some loaders leave 'so_locations' lying around. It's nice to clean up.
5061 AC_DEFUN([CF_SHARED_OPTS],
5063 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
5064 AC_REQUIRE([CF_LD_RPATH_OPT])
5068 INSTALL_LIB="-m 644"
5070 cf_cv_do_symlinks=no
5072 test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
5074 AC_MSG_CHECKING(if release/abi version should be used for shared libs)
5075 AC_ARG_WITH(shlib-version,
5076 [ --with-shlib-version=X Specify rel or abi version for shared libs],
5077 [test -z "$withval" && withval=auto
5078 case $withval in #(vi
5080 cf_cv_shlib_version=auto
5082 rel|abi|auto|no) #(vi
5083 cf_cv_shlib_version=$withval
5086 AC_MSG_ERROR([option value must be one of: rel, abi, auto or no])
5089 ],[cf_cv_shlib_version=auto])
5090 AC_MSG_RESULT($cf_cv_shlib_version)
5094 # Some less-capable ports of gcc support only -fpic
5096 if test "$GCC" = yes
5098 AC_MSG_CHECKING(which $CC option to use)
5099 cf_save_CFLAGS="$CFLAGS"
5100 for CC_SHARED_OPTS in -fPIC -fpic ''
5102 CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
5103 AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
5105 AC_MSG_RESULT($CC_SHARED_OPTS)
5106 CFLAGS="$cf_save_CFLAGS"
5109 cf_cv_shlib_version_infix=no
5111 case $cf_cv_system_name in #(vi
5113 if test "$GCC" = yes; then
5115 MK_SHARED_LIB='$(CC) -shared'
5119 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
5123 MK_SHARED_LIB='sh ../mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
5124 cf_cv_shlib_version=cygdll
5125 cf_cv_shlib_version_infix=cygdll
5126 cat >mk_shared_lib.sh <<-CF_EOF
5129 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
5132 Linking shared library
5133 ** SHARED_LIB \[$]SHARED_LIB
5134 ** IMPORT_LIB \[$]IMPORT_LIB
5136 exec \[$]* -shared -Wl,--out-implib=../lib/\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o ../lib/\[$]{SHARED_LIB}
5138 chmod +x mk_shared_lib.sh
5141 EXTRA_CFLAGS="-no-cpp-precomp"
5142 CC_SHARED_OPTS="-dynamic"
5143 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
5144 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
5145 cf_cv_shlib_version_infix=yes
5146 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
5147 cf_save_LDFLAGS=$LDFLAGS
5148 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
5149 AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
5150 LDFLAGS=$cf_save_LDFLAGS])
5151 if test $cf_cv_ldflags_search_paths_first = yes; then
5152 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
5156 # (tested with gcc 2.7.2 -- I don't have c89)
5157 if test "$GCC" = yes; then
5158 LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
5161 LD_SHARED_OPTS='-Wl,+b,${libdir}'
5163 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
5164 # HP-UX shared libraries must be executable, and should be
5165 # readonly to exploit a quirk in the memory manager.
5166 INSTALL_LIB="-m 555"
5169 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5170 if test "$cf_cv_shlib_version" = rel; then
5171 cf_shared_soname='`basename $@ .${REL_VERSION}`.${ABI_VERSION}'
5173 cf_shared_soname='`basename $@`'
5176 MK_SHARED_LIB='${CC} -shared -Wl,-rpath,${libdir} -Wl,-h,'$cf_shared_soname' -o $@'
5179 if test "$cf_cv_enable_rpath" = yes ; then
5180 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
5182 # tested with IRIX 5.2 and 'cc'.
5183 if test "$GCC" != yes; then
5184 CC_SHARED_OPTS='-KPIC'
5185 MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
5187 MK_SHARED_LIB='${CC} -shared -Wl,-soname,`basename $[@]` -o $[@]'
5189 cf_cv_rm_so_locs=yes
5191 linux*|gnu*|k*bsd*-gnu) #(vi
5192 if test "$DFT_LWR_MODEL" = "shared" ; then
5193 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
5194 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5196 if test "$cf_cv_enable_rpath" = yes ; then
5197 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
5200 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
5202 openbsd[[2-9]].*|mirbsd*) #(vi
5203 if test "$DFT_LWR_MODEL" = "shared" ; then
5204 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
5205 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5207 if test "$cf_cv_enable_rpath" = yes ; then
5208 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
5210 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5212 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
5214 nto-qnx*|openbsd*|freebsd[[12]].*) #(vi
5215 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5216 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
5217 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5220 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5221 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
5222 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
5223 LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${libdir} $LOCAL_LDFLAGS"
5224 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
5227 MK_SHARED_LIB='${LD} -shared -Bshareable -soname=`basename $[@]` -o $[@]'
5230 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5231 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
5232 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
5233 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5234 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
5235 if test "$cf_cv_shlib_version" = auto; then
5236 if test -f /usr/libexec/ld.elf_so; then
5237 cf_cv_shlib_version=abi
5239 cf_cv_shlib_version=rel
5243 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
5245 MK_SHARED_LIB='${LD} -shared -Bshareable -o $[@]'
5249 # tested with OSF/1 V3.2 and 'cc'
5250 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
5251 # link with shared libs).
5252 MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
5253 case $host_os in #(vi
5255 MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
5258 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
5259 if test "$DFT_LWR_MODEL" = "shared" ; then
5260 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
5261 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5263 cf_cv_rm_so_locs=yes
5265 sco3.2v5*) # (also uw2* and UW7: hops 13-Apr-98
5266 # tested with osr5.0.5
5267 if test "$GCC" != yes; then
5268 CC_SHARED_OPTS='-belf -KPIC'
5270 MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
5271 if test "$cf_cv_enable_rpath" = yes ; then
5272 # only way is to set LD_RUN_PATH but no switch for it
5275 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5276 LINK_PROGS='LD_RUN_PATH=${libdir}'
5277 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
5280 # tested with SunOS 4.1.1 and gcc 2.7.0
5281 if test "$GCC" != yes; then
5282 CC_SHARED_OPTS='-KPIC'
5284 MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
5285 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5288 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
5289 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
5290 if test "$DFT_LWR_MODEL" = "shared" ; then
5291 LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
5292 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5294 if test "$cf_cv_enable_rpath" = yes ; then
5295 EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
5298 if test "$GCC" != yes; then
5299 cf_save_CFLAGS="$CFLAGS"
5300 for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
5302 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
5303 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\n");],[break])
5305 CFLAGS="$cf_save_CFLAGS"
5306 CC_SHARED_OPTS=$cf_shared_opts
5307 MK_SHARED_LIB='${CC} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
5309 MK_SHARED_LIB='${CC} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
5312 sysv5uw7*|unix_sv*) #(vi
5313 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
5314 if test "$GCC" != yes; then
5315 CC_SHARED_OPTS='-KPIC'
5317 MK_SHARED_LIB='${LD} -d y -G -o [$]@'
5320 CC_SHARED_OPTS='unknown'
5321 MK_SHARED_LIB='echo unknown'
5325 # This works if the last tokens in $MK_SHARED_LIB are the -o target.
5326 case "$cf_cv_shlib_version" in #(vi
5328 case "$MK_SHARED_LIB" in #(vi
5330 test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
5333 AC_MSG_WARN(ignored --with-shlib-version)
5339 if test -n "$cf_ld_rpath_opt" ; then
5340 MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${libdir}"
5343 AC_SUBST(CC_SHARED_OPTS)
5344 AC_SUBST(LD_RPATH_OPT)
5345 AC_SUBST(LD_SHARED_OPTS)
5346 AC_SUBST(MK_SHARED_LIB)
5347 AC_SUBST(LINK_PROGS)
5348 AC_SUBST(LINK_TESTS)
5349 AC_SUBST(EXTRA_LDFLAGS)
5350 AC_SUBST(LOCAL_LDFLAGS)
5351 AC_SUBST(LOCAL_LDFLAGS2)
5352 AC_SUBST(INSTALL_LIB)
5354 dnl ---------------------------------------------------------------------------
5355 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
5356 dnl ----------------
5357 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
5358 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
5361 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
5362 dnl If missing, use "rel".
5363 define([CF_SHARED_SONAME],
5365 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
5366 if test "$cf_cv_shlib_version" = rel; then
5367 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
5369 cf_cv_shared_soname='`basename $[@]`'
5372 dnl ---------------------------------------------------------------------------
5373 dnl CF_SIGWINCH version: 1 updated: 2006/04/02 16:41:09
5375 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
5376 dnl programs need this test).
5378 dnl This is really a MacOS X 10.4.3 workaround. Defining _POSIX_C_SOURCE
5379 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses). Oddly, the struct
5380 dnl winsize declaration is left alone - we may revisit this if Apple choose to
5381 dnl break that part of the interface as well.
5382 AC_DEFUN([CF_SIGWINCH],
5384 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
5386 #include <sys/types.h>
5387 #include <sys/signal.h>
5388 ],[int x = SIGWINCH],
5389 [cf_cv_define_sigwinch=yes],
5391 #undef _XOPEN_SOURCE
5392 #undef _POSIX_SOURCE
5393 #undef _POSIX_C_SOURCE
5394 #include <sys/types.h>
5395 #include <sys/signal.h>
5396 ],[int x = SIGWINCH],
5397 [cf_cv_define_sigwinch=maybe],
5398 [cf_cv_define_sigwinch=no])
5402 if test "$cf_cv_define_sigwinch" = maybe ; then
5403 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
5404 cf_cv_fixup_sigwinch=unknown
5406 while test $cf_sigwinch != 1
5409 #undef _XOPEN_SOURCE
5410 #undef _POSIX_SOURCE
5411 #undef _POSIX_C_SOURCE
5412 #include <sys/types.h>
5413 #include <sys/signal.h>
5415 #if SIGWINCH != $cf_sigwinch
5419 [cf_cv_fixup_sigwinch=$cf_sigwinch
5422 cf_sigwinch=`expr $cf_sigwinch - 1`
5426 if test "$cf_cv_fixup_sigwinch" != unknown ; then
5427 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
5431 dnl ---------------------------------------------------------------------------
5432 dnl CF_SIG_ATOMIC_T version: 2 updated: 2005/09/18 17:27:12
5434 dnl signal handler, but there are some gcc depedencies in that recommendation.
5436 AC_DEFUN([CF_SIG_ATOMIC_T],
5438 AC_MSG_CHECKING(for signal global datatype)
5439 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
5441 "volatile sig_atomic_t" \
5446 #include <sys/types.h>
5452 static void handler(int sig)
5456 [signal(SIGINT, handler);
5458 [cf_cv_sig_atomic_t=$cf_type],
5459 [cf_cv_sig_atomic_t=no])
5460 test "$cf_cv_sig_atomic_t" != no && break
5463 AC_MSG_RESULT($cf_cv_sig_atomic_t)
5464 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t)
5466 dnl ---------------------------------------------------------------------------
5467 dnl CF_SIZECHANGE version: 8 updated: 2000/11/04 12:22:16
5469 dnl Check for definitions & structures needed for window size-changing
5470 dnl FIXME: check that this works with "snake" (HP-UX 10.x)
5471 AC_DEFUN([CF_SIZECHANGE],
5473 AC_REQUIRE([CF_STRUCT_TERMIOS])
5474 AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[
5475 cf_cv_sizechange=unknown
5476 cf_save_CPPFLAGS="$CPPFLAGS"
5478 for cf_opts in "" "NEED_PTEM_H"
5481 CPPFLAGS="$cf_save_CPPFLAGS"
5482 test -n "$cf_opts" && CPPFLAGS="$CPPFLAGS -D$cf_opts"
5483 AC_TRY_COMPILE([#include <sys/types.h>
5484 #ifdef HAVE_TERMIOS_H
5485 #include <termios.h>
5487 #ifdef HAVE_TERMIO_H
5492 /* This is a workaround for SCO: they neglected to define struct winsize in
5493 * termios.h -- it's only in termio.h and ptem.h
5495 #include <sys/stream.h>
5496 #include <sys/ptem.h>
5498 #if !defined(sun) || !defined(HAVE_TERMIOS_H)
5499 #include <sys/ioctl.h>
5503 struct ttysize win; /* FIXME: what system is this? */
5504 int y = win.ts_lines;
5505 int x = win.ts_cols;
5512 no TIOCGSIZE or TIOCGWINSZ
5513 #endif /* TIOCGWINSZ */
5514 #endif /* TIOCGSIZE */
5516 [cf_cv_sizechange=yes],
5517 [cf_cv_sizechange=no])
5519 CPPFLAGS="$cf_save_CPPFLAGS"
5520 if test "$cf_cv_sizechange" = yes ; then
5521 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC
5522 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts"
5527 if test "$cf_cv_sizechange" != no ; then
5528 AC_DEFINE(HAVE_SIZECHANGE)
5529 case $cf_cv_sizechange in #(vi
5531 AC_DEFINE_UNQUOTED($cf_cv_sizechange )
5536 dnl ---------------------------------------------------------------------------
5537 dnl CF_SRC_MODULES version: 21 updated: 2010/09/04 17:37:40
5539 dnl For each parameter, test if the source-directory exists, and if it contains
5540 dnl a 'modules' file. If so, add to the list $cf_cv_src_modules which we'll
5541 dnl use in CF_LIB_RULES.
5543 dnl This uses the configured value to make the lists SRC_SUBDIRS and
5544 dnl SUB_MAKEFILES which are used in the makefile-generation scheme.
5545 AC_DEFUN([CF_SRC_MODULES],
5547 AC_MSG_CHECKING(for src modules)
5549 # dependencies and linker-arguments for test-programs
5550 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS"
5551 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2"
5552 if test "$DFT_LWR_MODEL" = "libtool"; then
5553 TEST_ARGS="${TEST_DEPS}"
5554 TEST_ARG2="${TEST_DEP2}"
5556 TEST_ARGS="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARGS"
5557 TEST_ARG2="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARG2"
5563 if test -f $srcdir/$cf_dir/modules; then
5565 # We may/may not have tack in the distribution, though the
5567 if test $cf_dir = tack ; then
5568 if test ! -f $srcdir/${cf_dir}/${cf_dir}.h; then
5573 if test -z "$cf_cv_src_modules"; then
5574 cf_cv_src_modules=$cf_dir
5576 cf_cv_src_modules="$cf_cv_src_modules $cf_dir"
5579 # Make the ncurses_cfg.h file record the library interface files as
5580 # well. These are header files that are the same name as their
5581 # directory. Ncurses is the only library that does not follow
5583 if test $cf_dir = tack ; then
5585 elif test -f $srcdir/${cf_dir}/${cf_dir}.h; then
5586 CF_UPPER(cf_have_include,$cf_dir)
5587 AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H)
5588 AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include})
5589 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEPS"
5590 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEP2"
5591 if test "$DFT_LWR_MODEL" = "libtool"; then
5592 TEST_ARGS="${TEST_DEPS}"
5593 TEST_ARG2="${TEST_DEP2}"
5595 TEST_ARGS="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARGS"
5596 TEST_ARG2="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARG2"
5601 AC_MSG_RESULT($cf_cv_src_modules)
5603 TEST_ARGS="-L${LIB_DIR} $TEST_ARGS"
5604 TEST_ARG2="-L${LIB_2ND} $TEST_ARG2"
5613 if test "x$cf_with_manpages" != xno ; then
5614 SRC_SUBDIRS="$SRC_SUBDIRS man"
5616 SRC_SUBDIRS="$SRC_SUBDIRS include"
5617 for cf_dir in $cf_cv_src_modules
5619 SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir"
5621 if test "x$cf_with_tests" != "xno" ; then
5622 SRC_SUBDIRS="$SRC_SUBDIRS test"
5624 test -z "$MAKE_TERMINFO" && SRC_SUBDIRS="$SRC_SUBDIRS misc"
5625 test "$cf_with_cxx_binding" != no && SRC_SUBDIRS="$SRC_SUBDIRS c++"
5628 if test "$cf_cv_prog_gnat_correct" = yes && test -f $srcdir/Ada95/Makefile.in; then
5629 SRC_SUBDIRS="$SRC_SUBDIRS Ada95"
5630 ADA_SUBDIRS="gen src"
5631 if test "x$cf_with_tests" != "xno" ; then
5632 ADA_SUBDIRS="$ADA_SUBDIRS samples"
5637 for cf_dir in $SRC_SUBDIRS
5639 SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile"
5642 if test -n "$ADA_SUBDIRS"; then
5643 for cf_dir in $ADA_SUBDIRS
5645 SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile"
5647 AC_SUBST(ADA_SUBDIRS)
5650 dnl ---------------------------------------------------------------------------
5651 dnl CF_STDCPP_LIBRARY version: 7 updated: 2010/05/29 16:31:02
5652 dnl -----------------
5653 dnl Check for -lstdc++, which is GNU's standard C++ library.
5654 AC_DEFUN([CF_STDCPP_LIBRARY],
5656 if test -n "$GXX" ; then
5657 case $cf_cv_system_name in #(vi
5659 cf_stdcpp_libname=stdcpp
5662 cf_stdcpp_libname=stdc++
5665 AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[
5667 CF_ADD_LIB($cf_stdcpp_libname)
5669 #include <strstream.h>],[
5671 strstreambuf foo(buf, sizeof(buf))
5673 [cf_cv_libstdcpp=yes],
5674 [cf_cv_libstdcpp=no])
5677 test "$cf_cv_libstdcpp" = yes && CF_ADD_LIB($cf_stdcpp_libname,CXXLIBS)
5680 dnl ---------------------------------------------------------------------------
5681 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
5683 dnl Remove "-g" option from the compiler options
5684 AC_DEFUN([CF_STRIP_G_OPT],
5685 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
5686 dnl ---------------------------------------------------------------------------
5687 dnl CF_STRUCT_SIGACTION version: 4 updated: 2011/04/16 11:52:53
5688 dnl -------------------
5689 dnl Check if we need _POSIX_SOURCE defined to use struct sigaction. We'll only
5690 dnl do this if we've found the sigaction function.
5691 AC_DEFUN([CF_STRUCT_SIGACTION],[
5692 AC_REQUIRE([CF_XOPEN_SOURCE])
5694 if test "$ac_cv_func_sigaction" = yes; then
5695 AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE)
5697 #include <sys/types.h>
5698 #include <signal.h>],
5699 [struct sigaction act],
5703 #define _POSIX_SOURCE
5704 #include <sys/types.h>
5705 #include <signal.h>],
5706 [struct sigaction act],
5708 AC_DEFINE(_POSIX_SOURCE)],
5709 [sigact_bad=unknown])])
5710 AC_MSG_RESULT($sigact_bad)
5713 dnl ---------------------------------------------------------------------------
5714 dnl CF_STRUCT_TERMIOS version: 6 updated: 2011/04/16 11:52:53
5715 dnl -----------------
5716 dnl Some machines require _POSIX_SOURCE to completely define struct termios.
5717 AC_DEFUN([CF_STRUCT_TERMIOS],[
5718 AC_REQUIRE([CF_XOPEN_SOURCE])
5726 if test "$ISC" = yes ; then
5727 AC_CHECK_HEADERS( sys/termio.h )
5729 if test "$ac_cv_header_termios_h" = yes ; then
5730 case "$CFLAGS $CPPFLAGS" in
5732 termios_bad=dunno ;;
5733 *) termios_bad=maybe ;;
5735 if test "$termios_bad" = maybe ; then
5736 AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE)
5737 AC_TRY_COMPILE([#include <termios.h>],
5738 [struct termios foo; int x = foo.c_iflag],
5741 #define _POSIX_SOURCE
5742 #include <termios.h>],
5743 [struct termios foo; int x = foo.c_iflag],
5744 termios_bad=unknown,
5745 termios_bad=yes AC_DEFINE(_POSIX_SOURCE))
5747 AC_MSG_RESULT($termios_bad)
5751 dnl ---------------------------------------------------------------------------
5752 dnl CF_SUBDIR_PATH version: 6 updated: 2010/04/21 06:20:50
5754 dnl Construct a search-list for a nonstandard header/lib-file
5755 dnl $1 = the variable to return as result
5756 dnl $2 = the package name
5757 dnl $3 = the subdirectory, e.g., bin, include or lib
5758 AC_DEFUN([CF_SUBDIR_PATH],
5762 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr,$prefix)
5763 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
5764 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr/local,$prefix)
5765 CF_ADD_SUBDIR_PATH($1,$2,$3,/opt,$prefix)
5766 CF_ADD_SUBDIR_PATH($1,$2,$3,[$]HOME,$prefix)
5768 dnl ---------------------------------------------------------------------------
5769 dnl CF_SUBST version: 4 updated: 2006/06/17 12:33:03
5771 dnl Shorthand macro for substituting things that the user may override
5772 dnl with an environment variable.
5774 dnl $1 = long/descriptive name
5775 dnl $2 = environment variable
5776 dnl $3 = default value
5777 AC_DEFUN([CF_SUBST],
5778 [AC_CACHE_VAL(cf_cv_subst_$2,[
5779 AC_MSG_CHECKING(for $1 (symbol $2))
5780 CF_SUBST_IF([-z "[$]$2"], [$2], [$3])
5781 cf_cv_subst_$2=[$]$2
5782 AC_MSG_RESULT([$]$2)
5785 dnl ---------------------------------------------------------------------------
5786 dnl CF_SUBST_IF version: 2 updated: 2006/06/17 12:33:03
5788 dnl Shorthand macro for substituting things that the user may override
5789 dnl with an environment variable.
5791 dnl $1 = condition to pass to "test"
5792 dnl $2 = environment variable
5793 dnl $3 = value if the test succeeds
5794 dnl $4 = value if the test fails
5795 AC_DEFUN([CF_SUBST_IF],
5804 dnl ---------------------------------------------------------------------------
5805 dnl CF_SUBST_NCURSES_VERSION version: 8 updated: 2006/09/16 11:40:59
5806 dnl ------------------------
5807 dnl Get the version-number for use in shared-library naming, etc.
5808 AC_DEFUN([CF_SUBST_NCURSES_VERSION],
5810 AC_REQUIRE([CF_PROG_EGREP])
5811 NCURSES_MAJOR="`$ac_cv_prog_egrep '^NCURSES_MAJOR[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
5812 NCURSES_MINOR="`$ac_cv_prog_egrep '^NCURSES_MINOR[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
5813 NCURSES_PATCH="`$ac_cv_prog_egrep '^NCURSES_PATCH[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
5814 cf_cv_abi_version=${NCURSES_MAJOR}
5815 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
5816 dnl Show the computed version, for logging
5817 cf_cv_timestamp=`date`
5818 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
5819 dnl We need these values in the generated headers
5820 AC_SUBST(NCURSES_MAJOR)
5821 AC_SUBST(NCURSES_MINOR)
5822 AC_SUBST(NCURSES_PATCH)
5823 dnl We need these values in the generated makefiles
5824 AC_SUBST(cf_cv_rel_version)
5825 AC_SUBST(cf_cv_abi_version)
5826 AC_SUBST(cf_cv_builtin_bool)
5827 AC_SUBST(cf_cv_header_stdbool_h)
5828 AC_SUBST(cf_cv_type_of_bool)dnl
5830 dnl ---------------------------------------------------------------------------
5831 dnl CF_SYS_TIME_SELECT version: 4 updated: 2000/10/04 09:18:40
5832 dnl ------------------
5833 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
5834 dnl older SCO configurations.
5835 AC_DEFUN([CF_SYS_TIME_SELECT],
5837 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
5838 AC_CACHE_VAL(cf_cv_sys_time_select,[
5840 #include <sys/types.h>
5841 #ifdef HAVE_SYS_TIME_H
5842 #include <sys/time.h>
5844 #ifdef HAVE_SYS_SELECT_H
5845 #include <sys/select.h>
5847 ],[],[cf_cv_sys_time_select=yes],
5848 [cf_cv_sys_time_select=no])
5850 AC_MSG_RESULT($cf_cv_sys_time_select)
5851 test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT)
5853 dnl ---------------------------------------------------------------------------
5854 dnl CF_TOP_BUILDDIR version: 1 updated: 2006/10/15 16:33:23
5856 dnl Define a top_builddir symbol, for applications that need an absolute path.
5857 AC_DEFUN([CF_TOP_BUILDDIR],
5860 AC_SUBST(top_builddir)
5862 dnl ---------------------------------------------------------------------------
5863 dnl CF_TYPEOF_CHTYPE version: 8 updated: 2006/12/16 12:33:30
5864 dnl ----------------
5865 dnl Determine the type we should use for chtype (and attr_t, which is treated
5866 dnl as the same thing). We want around 32 bits, so on most machines want a
5867 dnl long, but on newer 64-bit machines, probably want an int. If we're using
5868 dnl wide characters, we have to have a type compatible with that, as well.
5869 AC_DEFUN([CF_TYPEOF_CHTYPE],
5871 AC_MSG_CHECKING([for type of chtype])
5872 AC_CACHE_VAL(cf_cv_typeof_chtype,[
5874 #define WANT_BITS 31
5878 FILE *fp = fopen("cf_test.out", "w");
5880 char *result = "long";
5881 if (sizeof(unsigned long) > sizeof(unsigned int)) {
5884 for (n = 0; n < WANT_BITS; n++) {
5887 if (y != 1 || x == 0) {
5893 * If x is nonzero, an int is big enough for the bits
5896 result = (x != 0) ? "int" : "long";
5901 ${cf_cv_main_return:-return}(0);
5904 [cf_cv_typeof_chtype=`cat cf_test.out`],
5905 [cf_cv_typeof_chtype=long],
5906 [cf_cv_typeof_chtype=long])
5909 AC_MSG_RESULT($cf_cv_typeof_chtype)
5911 AC_SUBST(cf_cv_typeof_chtype)
5912 AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype)
5914 dnl ---------------------------------------------------------------------------
5915 dnl CF_TYPE_SIGACTION version: 3 updated: 2000/08/12 23:18:52
5916 dnl -----------------
5918 AC_DEFUN([CF_TYPE_SIGACTION],
5920 AC_MSG_CHECKING([for type sigaction_t])
5921 AC_CACHE_VAL(cf_cv_type_sigaction,[
5923 #include <signal.h>],
5925 [cf_cv_type_sigaction=yes],
5926 [cf_cv_type_sigaction=no])])
5927 AC_MSG_RESULT($cf_cv_type_sigaction)
5928 test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION)
5930 dnl ---------------------------------------------------------------------------
5931 dnl CF_UNSIGNED_LITERALS version: 2 updated: 1998/02/07 22:10:16
5932 dnl --------------------
5933 dnl Test if the compiler supports 'U' and 'L' suffixes. Only old compilers
5934 dnl won't, but they're still there.
5935 AC_DEFUN([CF_UNSIGNED_LITERALS],
5937 AC_MSG_CHECKING([if unsigned literals are legal])
5938 AC_CACHE_VAL(cf_cv_unsigned_literals,[
5939 AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1],
5940 [cf_cv_unsigned_literals=yes],
5941 [cf_cv_unsigned_literals=no])
5943 AC_MSG_RESULT($cf_cv_unsigned_literals)
5945 dnl ---------------------------------------------------------------------------
5946 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
5948 dnl Make an uppercase version of a variable
5949 dnl $1=uppercase($2)
5950 AC_DEFUN([CF_UPPER],
5952 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
5954 dnl ---------------------------------------------------------------------------
5955 dnl CF_UTF8_LIB version: 7 updated: 2010/06/20 09:24:28
5957 dnl Check for multibyte support, and if not found, utf8 compatibility library
5958 AC_DEFUN([CF_UTF8_LIB],
5960 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
5961 cf_save_LIBS="$LIBS"
5963 #include <stdlib.h>],[putwc(0,0);],
5964 [cf_cv_utf8_lib=yes],
5966 #include <libutf8.h>],[putwc(0,0);],utf8,
5967 [cf_cv_utf8_lib=add-on],
5968 [cf_cv_utf8_lib=no])
5971 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
5973 if test "$cf_cv_utf8_lib" = "add-on" ; then
5974 AC_DEFINE(HAVE_LIBUTF8_H)
5975 CF_ADD_INCDIR($cf_cv_header_path_utf8)
5976 CF_ADD_LIBDIR($cf_cv_library_path_utf8)
5977 CF_ADD_LIBS($cf_cv_library_file_utf8)
5980 dnl ---------------------------------------------------------------------------
5981 dnl CF_VA_COPY version: 2 updated: 2010/03/04 05:37:29
5983 dnl check for va_copy, part of stdarg.h
5984 dnl Also, workaround for glibc's __va_copy, by checking for both.
5985 AC_DEFUN([CF_VA_COPY],[
5986 AC_CACHE_CHECK(for va_copy, cf_cv_have_va_copy,[
5993 cf_cv_have_va_copy=yes,
5994 cf_cv_have_va_copy=no)])
5996 test "$cf_cv_have_va_copy" = yes && AC_DEFINE(HAVE_VA_COPY)
5998 AC_CACHE_CHECK(for __va_copy, cf_cv_have___va_copy,[
6004 __va_copy(dst, src)],
6005 cf_cv_have___va_copy=yes,
6006 cf_cv_have___va_copy=no)])
6008 test "$cf_cv_have___va_copy" = yes && AC_DEFINE(HAVE___VA_COPY)
6010 dnl ---------------------------------------------------------------------------
6011 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
6013 dnl Use AC_VERBOSE w/o the warnings
6014 AC_DEFUN([CF_VERBOSE],
6015 [test -n "$verbose" && echo " $1" 1>&AC_FD_MSG
6018 dnl ---------------------------------------------------------------------------
6019 dnl CF_WCHAR_TYPE version: 3 updated: 2010/05/26 16:44:57
6021 dnl Check if type wide-character type $1 is declared, and if so, which header
6022 dnl file is needed. The second parameter is used to set a shell variable when
6023 dnl the type is not found. The first parameter sets a shell variable for the
6025 AC_DEFUN([CF_WCHAR_TYPE],
6027 # This is needed on Tru64 5.0 to declare $1
6028 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
6033 #ifdef HAVE_LIBUTF8_H
6034 #include <libutf8.h>
6043 #ifdef HAVE_LIBUTF8_H
6044 #include <libutf8.h>
6048 [cf_cv_$1=unknown])])])
6050 if test "$cf_cv_$1" = yes ; then
6051 AC_DEFINE(NEED_WCHAR_H)
6056 # if we do not find $1 in either place, use substitution to provide a fallback.
6057 if test "$cf_cv_$1" = unknown ; then
6062 # if we find $1 in either place, use substitution to provide a fallback.
6063 if test "$cf_cv_$1" != unknown ; then
6068 dnl ---------------------------------------------------------------------------
6069 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
6071 dnl Check for compiler-support for weak symbols.
6072 dnl This works with "recent" gcc.
6073 AC_DEFUN([CF_WEAK_SYMBOLS],[
6074 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
6077 #include <stdio.h>],
6079 #if defined(__GNUC__)
6080 # if defined __USE_ISOC99
6081 # define _cat_pragma(exp) _Pragma(#exp)
6082 # define _weak_pragma(exp) _cat_pragma(weak name)
6084 # define _weak_pragma(exp)
6086 # define _declare(name) __extension__ extern __typeof__(name) name
6087 # define weak_symbol(name) _weak_pragma(name) _declare(name) __attribute__((weak))
6091 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
6094 dnl ---------------------------------------------------------------------------
6095 dnl CF_WITH_ABI_VERSION version: 1 updated: 2003/09/20 18:12:49
6096 dnl -------------------
6097 dnl Allow library's ABI to be overridden. Generally this happens when a
6098 dnl packager has incremented the ABI past that used in the original package,
6099 dnl and wishes to keep doing this.
6101 dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
6103 AC_DEFUN([CF_WITH_ABI_VERSION],[
6104 test -z "$cf_cv_abi_version" && cf_cv_abi_version=0
6105 AC_ARG_WITH(abi-version,
6106 [ --with-abi-version=XXX override derived ABI version],
6107 [AC_MSG_WARN(overriding ABI version $cf_cv_abi_version to $withval)
6108 cf_cv_abi_version=$withval])
6109 CF_NUMBER_SYNTAX($cf_cv_abi_version,ABI version)
6111 $1_ABI=$cf_cv_abi_version
6114 dnl ---------------------------------------------------------------------------
6115 dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58
6116 dnl --------------------
6117 dnl Command-line option to specify the Ada95 compiler.
6118 AC_DEFUN([CF_WITH_ADA_COMPILER],[
6119 AC_MSG_CHECKING(for ada-compiler)
6120 AC_ARG_WITH(ada-compiler,
6121 [ --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
6122 [cf_ada_compiler=$withval],
6123 [cf_ada_compiler=gnatmake])
6124 AC_SUBST(cf_ada_compiler)
6125 AC_MSG_RESULT($cf_ada_compiler)
6127 dnl ---------------------------------------------------------------------------
6128 dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58
6129 dnl -------------------
6130 dnl Command-line option to specify where Ada includes will install.
6131 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
6132 AC_MSG_CHECKING(for ada-include)
6133 CF_WITH_PATH(ada-include,
6134 [ --with-ada-include=DIR Ada includes are in DIR],
6136 PREFIX/share/ada/adainclude,
6137 [$]prefix/share/ada/adainclude)
6138 AC_SUBST(ADA_INCLUDE)
6139 AC_MSG_RESULT($ADA_INCLUDE)
6141 dnl ---------------------------------------------------------------------------
6142 dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58
6143 dnl -------------------
6144 dnl Command-line option to specify where Ada objects will install.
6145 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
6146 AC_MSG_CHECKING(for ada-objects)
6147 CF_WITH_PATH(ada-objects,
6148 [ --with-ada-objects=DIR Ada objects are in DIR],
6150 PREFIX/lib/ada/adalib,
6151 [$]prefix/lib/ada/adalib)
6152 AC_SUBST(ADA_OBJECTS)
6153 AC_MSG_RESULT($ADA_OBJECTS)
6155 dnl ---------------------------------------------------------------------------
6156 dnl CF_WITH_ADA_SHAREDLIB version: 2 updated: 2010/06/26 17:35:58
6157 dnl ---------------------
6158 dnl Command-line option to specify if an Ada95 shared-library should be built,
6159 dnl and optionally what its soname should be.
6160 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
6161 AC_MSG_CHECKING(if an Ada95 shared-library should be built)
6162 AC_ARG_WITH(ada-sharedlib,
6163 [ --with-ada-sharedlib=XX build Ada95 shared-library],
6164 [with_ada_sharedlib=$withval],
6165 [with_ada_sharedlib=no])
6166 AC_MSG_RESULT($with_ada_sharedlib)
6168 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
6169 MAKE_ADA_SHAREDLIB="#"
6171 if test "x$with_ada_sharedlib" != xno
6174 if test "x$with_ada_sharedlib" != xyes
6176 ADA_SHAREDLIB="$with_ada_sharedlib"
6180 AC_SUBST(ADA_SHAREDLIB)
6181 AC_SUBST(MAKE_ADA_SHAREDLIB)
6183 dnl ---------------------------------------------------------------------------
6184 dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
6185 dnl ----------------
6186 dnl Configure-option for dbmalloc. The optional parameter is used to override
6187 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
6188 AC_DEFUN([CF_WITH_DBMALLOC],[
6189 CF_NO_LEAKS_OPTION(dbmalloc,
6190 [ --with-dbmalloc test: use Conor Cahill's dbmalloc library],
6193 if test "$with_dbmalloc" = yes ; then
6194 AC_CHECK_HEADER(dbmalloc.h,
6195 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
6198 dnl ---------------------------------------------------------------------------
6199 dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
6201 dnl Configure-option for dmalloc. The optional parameter is used to override
6202 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
6203 AC_DEFUN([CF_WITH_DMALLOC],[
6204 CF_NO_LEAKS_OPTION(dmalloc,
6205 [ --with-dmalloc test: use Gray Watson's dmalloc library],
6208 if test "$with_dmalloc" = yes ; then
6209 AC_CHECK_HEADER(dmalloc.h,
6210 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
6213 dnl ---------------------------------------------------------------------------
6214 dnl CF_WITH_GPM version: 7 updated: 2008/03/23 14:48:54
6217 dnl The option parameter (if neither yes/no) is assumed to be the name of
6218 dnl the gpm library, e.g., for dynamic loading.
6219 AC_DEFUN([CF_WITH_GPM],
6221 AC_MSG_CHECKING(if you want to link with the GPM mouse library)
6223 [ --with-gpm use Alessandro Rubini's GPM library],
6224 [with_gpm=$withval],
6226 AC_MSG_RESULT($with_gpm)
6228 if test "$with_gpm" != no ; then
6229 AC_CHECK_HEADER(gpm.h,[
6230 AC_DEFINE(HAVE_GPM_H)
6231 if test "$with_gpm" != yes && test "$with_gpm" != maybe ; then
6232 CF_VERBOSE(assuming we really have GPM library)
6233 AC_DEFINE(HAVE_LIBGPM)
6235 AC_CHECK_LIB(gpm,Gpm_Open,[:],[
6236 AC_MSG_ERROR(Cannot link with GPM library)
6241 test "$with_gpm" != maybe && AC_MSG_WARN(Cannot find GPM header)
6246 dnl ---------------------------------------------------------------------------
6247 dnl CF_WITH_LIBTOOL version: 26 updated: 2010/10/23 15:55:24
6249 dnl Provide a configure option to incorporate libtool. Define several useful
6250 dnl symbols for the makefile rules.
6252 dnl The reference to AC_PROG_LIBTOOL does not normally work, since it uses
6253 dnl macros from libtool.m4 which is in the aclocal directory of automake.
6254 dnl Following is a simple script which turns on the AC_PROG_LIBTOOL macro.
6255 dnl But that still does not work properly since the macro is expanded outside
6256 dnl the CF_WITH_LIBTOOL macro:
6259 dnl ACLOCAL=`aclocal --print-ac-dir`
6260 dnl if test -z "$ACLOCAL" ; then
6261 dnl echo cannot find aclocal directory
6263 dnl elif test ! -f $ACLOCAL/libtool.m4 ; then
6264 dnl echo cannot find libtool.m4 file
6268 dnl LOCAL=aclocal.m4
6269 dnl ORIG=aclocal.m4.orig
6271 dnl trap "mv $ORIG $LOCAL" 0 1 2 5 15
6275 dnl # sed the LIBTOOL= assignment to omit the current directory?
6276 dnl sed -e 's/^LIBTOOL=.*/LIBTOOL=${LIBTOOL:-libtool}/' $ACLOCAL/libtool.m4 >>$LOCAL
6277 dnl cat $ORIG >>$LOCAL
6281 AC_DEFUN([CF_WITH_LIBTOOL],
6283 AC_REQUIRE([CF_DISABLE_LIBTOOL_VERSION])
6284 ifdef([AC_PROG_LIBTOOL],,[
6287 # common library maintenance symbols that are convenient for libtool scripts:
6288 LIB_CREATE='${AR} -cr'
6289 LIB_OBJECT='${OBJECTS}'
6293 # symbols used to prop libtool up to enable it to determine what it should be
6301 AC_MSG_CHECKING(if you want to build libraries with libtool)
6302 AC_ARG_WITH(libtool,
6303 [ --with-libtool generate libraries with libtool],
6304 [with_libtool=$withval],
6306 AC_MSG_RESULT($with_libtool)
6307 if test "$with_libtool" != "no"; then
6308 ifdef([AC_PROG_LIBTOOL],[
6309 # missing_content_AC_PROG_LIBTOOL{{
6311 # missing_content_AC_PROG_LIBTOOL}}
6313 if test "$with_libtool" != "yes" ; then
6314 CF_PATH_SYNTAX(with_libtool)
6315 LIBTOOL=$with_libtool
6317 AC_PATH_PROG(LIBTOOL,libtool)
6319 if test -z "$LIBTOOL" ; then
6320 AC_MSG_ERROR(Cannot find libtool)
6323 LIB_CREATE='${LIBTOOL} --mode=link ${CC} -rpath ${DESTDIR}${libdir} ${LIBTOOL_VERSION} `cut -f1 ${srcdir}/VERSION` ${LIBTOOL_OPTS} ${LT_UNDEF} -o'
6324 LIB_OBJECT='${OBJECTS:.o=.lo}'
6326 LIB_CLEAN='${LIBTOOL} --mode=clean'
6327 LIB_COMPILE='${LIBTOOL} --mode=compile'
6328 LIB_LINK='${LIBTOOL} --mode=link ${CC} ${LIBTOOL_OPTS}'
6329 LIB_INSTALL='${LIBTOOL} --mode=install'
6330 LIB_UNINSTALL='${LIBTOOL} --mode=uninstall'
6333 # Show the version of libtool
6334 AC_MSG_CHECKING(version of libtool)
6336 # Save the version in a cache variable - this is not entirely a good
6337 # thing, but the version string from libtool is very ugly, and for
6338 # bug reports it might be useful to have the original string. "("
6339 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.]].*//'`
6340 AC_MSG_RESULT($cf_cv_libtool_version)
6341 if test -z "$cf_cv_libtool_version" ; then
6342 AC_MSG_ERROR(This is not GNU libtool)
6345 # special hack to add -no-undefined (which libtool should do for itself)
6347 case "$cf_cv_system_name" in #(vi
6348 cygwin*|mingw32*|uwin*|aix[[456]]) #(vi
6349 LT_UNDEF=-no-undefined
6352 AC_SUBST([LT_UNDEF])
6354 # special hack to add --tag option for C++ compiler
6355 case $cf_cv_libtool_version in #(vi
6356 1.[[5-9]]*|[[2-9]].[[0-9.a-z]]*) #(vi
6357 LIBTOOL_CXX="$LIBTOOL --tag=CXX"
6358 LIBTOOL="$LIBTOOL --tag=CC"
6361 LIBTOOL_CXX="$LIBTOOL"
6369 test -z "$LIBTOOL" && ECHO_LT=
6372 AC_SUBST(LIBTOOL_CXX)
6373 AC_SUBST(LIBTOOL_OPTS)
6375 AC_SUBST(LIB_CREATE)
6376 AC_SUBST(LIB_OBJECT)
6377 AC_SUBST(LIB_SUFFIX)
6381 AC_SUBST(LIB_COMPILE)
6383 AC_SUBST(LIB_INSTALL)
6384 AC_SUBST(LIB_UNINSTALL)
6387 dnl ---------------------------------------------------------------------------
6388 dnl CF_WITH_PATH version: 10 updated: 2010/10/23 15:44:18
6390 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
6391 dnl defaulting to yes/no.
6393 dnl $1 = option name
6395 dnl $3 = environment variable to set
6396 dnl $4 = default value, shown in the help-message, must be a constant
6397 dnl $5 = default value, if it's an expression & cannot be in the help-message
6399 AC_DEFUN([CF_WITH_PATH],
6400 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
6401 ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
6402 if ifelse([$5],,true,[test -n "$5"]) ; then
6403 CF_PATH_SYNTAX(withval)
6408 dnl ---------------------------------------------------------------------------
6409 dnl CF_WITH_PATHLIST version: 7 updated: 2010/10/23 16:10:30
6410 dnl ----------------
6411 dnl Process an option specifying a list of colon-separated paths.
6413 dnl $1 = option name
6415 dnl $3 = environment variable to set
6416 dnl $4 = default value, shown in the help-message, must be a constant
6417 dnl $5 = default value, if it's an expression & cannot be in the help-message
6418 dnl $6 = flag to tell if we want to define or substitute
6420 AC_DEFUN([CF_WITH_PATHLIST],[
6421 AC_REQUIRE([CF_PATHSEP])
6422 AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
6423 ifelse($4,,[withval=${$3}],[withval=${$3:-ifelse($5,,$4,$5)}]))dnl
6425 IFS="${IFS:- }"; ac_save_ifs="$IFS"; IFS="${PATH_SEPARATOR}"
6427 for cf_src_path in $withval
6429 CF_PATH_SYNTAX(cf_src_path)
6430 test -n "$cf_dst_path" && cf_dst_path="${cf_dst_path}:"
6431 cf_dst_path="${cf_dst_path}${cf_src_path}"
6436 # Strip single quotes from the value, e.g., when it was supplied as a literal
6438 case $cf_dst_path in #(vi
6440 cf_dst_path=`echo $cf_dst_path |sed -e s/\'// -e s/\'\$//`
6443 cf_dst_path=`echo "$cf_dst_path" | sed -e 's/\\\\/\\\\\\\\/g'`
6446 eval '$3="$cf_dst_path"'
6450 dnl ---------------------------------------------------------------------------
6451 dnl CF_WITH_PTHREAD version: 3 updated: 2010/05/29 16:31:02
6453 dnl Check for POSIX thread library.
6454 AC_DEFUN([CF_WITH_PTHREAD],
6456 AC_MSG_CHECKING(if you want to link with the pthread library)
6457 AC_ARG_WITH(pthread,
6458 [ --with-pthread use POSIX thread library],
6459 [with_pthread=$withval],
6461 AC_MSG_RESULT($with_pthread)
6463 if test "$with_pthread" != no ; then
6464 AC_CHECK_HEADER(pthread.h,[
6465 AC_DEFINE(HAVE_PTHREADS_H)
6467 AC_MSG_CHECKING(if we can link with the pthread library)
6468 cf_save_LIBS="$LIBS"
6471 #include <pthread.h>
6473 int rc = pthread_create(0,0,0,0);
6474 ],[with_pthread=yes],[with_pthread=no])
6475 LIBS="$cf_save_LIBS"
6476 AC_MSG_RESULT($with_pthread)
6478 if test "$with_pthread" = yes ; then
6480 AC_DEFINE(HAVE_LIBPTHREADS)
6482 AC_MSG_ERROR(Cannot link with pthread library)
6487 dnl ---------------------------------------------------------------------------
6488 dnl CF_WITH_REL_VERSION version: 1 updated: 2003/09/20 18:12:49
6489 dnl -------------------
6490 dnl Allow library's release-version to be overridden. Generally this happens when a
6491 dnl packager has incremented the release-version past that used in the original package,
6492 dnl and wishes to keep doing this.
6494 dnl $1 is the package name, if any, to derive corresponding {package}_MAJOR
6495 dnl and {package}_MINOR symbols
6497 AC_DEFUN([CF_WITH_REL_VERSION],[
6498 test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0
6499 AC_ARG_WITH(rel-version,
6500 [ --with-rel-version=XXX override derived release version],
6501 [AC_MSG_WARN(overriding release version $cf_cv_rel_version to $withval)
6502 cf_cv_rel_version=$withval])
6504 CF_NUMBER_SYNTAX($cf_cv_rel_version,Release version)
6506 $1_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'`
6507 $1_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[[^.]]*//' -e 's/^\.//' -e 's/\..*//'`
6508 CF_NUMBER_SYNTAX([$]$1_MAJOR,Release major-version)
6509 CF_NUMBER_SYNTAX([$]$1_MINOR,Release minor-version)
6512 dnl ---------------------------------------------------------------------------
6513 dnl CF_WITH_SYSMOUSE version: 2 updated: 2003/03/22 19:13:43
6514 dnl ----------------
6515 dnl If we can compile with sysmouse, make it available unless it is not wanted.
6516 AC_DEFUN([CF_WITH_SYSMOUSE],[
6517 # not everyone has "test -c"
6518 if test -c /dev/sysmouse 2>/dev/null ; then
6519 AC_MSG_CHECKING(if you want to use sysmouse)
6520 AC_ARG_WITH(sysmouse,
6521 [ --with-sysmouse use sysmouse (FreeBSD console)],
6522 [cf_with_sysmouse=$withval],
6523 [cf_with_sysmouse=maybe])
6524 if test "$cf_with_sysmouse" != no ; then
6526 #include <osreldate.h>
6527 #if (__FreeBSD_version >= 400017)
6528 #include <sys/consio.h>
6529 #include <sys/fbio.h>
6531 #include <machine/console.h>
6534 struct mouse_info the_mouse;
6535 ioctl(0, CONS_MOUSECTL, &the_mouse);
6536 ],[cf_with_sysmouse=yes],[cf_with_sysmouse=no])
6538 AC_MSG_RESULT($cf_with_sysmouse)
6539 test "$cf_with_sysmouse" = yes && AC_DEFINE(USE_SYSMOUSE)
6542 dnl ---------------------------------------------------------------------------
6543 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
6544 dnl ----------------
6545 AC_DEFUN([CF_WITH_VALGRIND],[
6546 CF_NO_LEAKS_OPTION(valgrind,
6547 [ --with-valgrind test: use valgrind],
6550 dnl ---------------------------------------------------------------------------
6551 dnl CF_XOPEN_SOURCE version: 35 updated: 2011/02/20 20:37:37
6553 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
6554 dnl or adapt to the vendor's definitions to get equivalent functionality,
6555 dnl without losing the common non-POSIX features.
6558 dnl $1 is the nominal value for _XOPEN_SOURCE
6559 dnl $2 is the nominal value for _POSIX_C_SOURCE
6560 AC_DEFUN([CF_XOPEN_SOURCE],[
6562 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
6563 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
6566 case $host_os in #(vi
6568 cf_xopen_source="-D_ALL_SOURCE"
6573 darwin[[0-8]].*) #(vi
6574 cf_xopen_source="-D_APPLE_C_SOURCE"
6577 cf_xopen_source="-D_DARWIN_C_SOURCE"
6579 freebsd*|dragonfly*) #(vi
6580 # 5.x headers associate
6581 # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
6582 # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
6583 cf_POSIX_C_SOURCE=200112L
6585 cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
6588 cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
6591 cf_xopen_source="-D_HPUX_SOURCE"
6594 cf_xopen_source="-D_SGI_SOURCE"
6596 linux*|gnu*|mint*|k*bsd*-gnu) #(vi
6600 # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <arpa/inet.h>
6603 # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
6606 # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
6609 cf_xopen_source="-D_OSF_SOURCE"
6612 cf_xopen_source="-D_QNX_SOURCE"
6615 # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
6617 solaris2.1[[0-9]]) #(vi
6618 cf_xopen_source="-D__EXTENSIONS__ -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
6620 solaris2.[[1-9]]) #(vi
6621 cf_xopen_source="-D__EXTENSIONS__"
6624 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
6625 AC_TRY_COMPILE([#include <sys/types.h>],[
6626 #ifndef _XOPEN_SOURCE
6629 [cf_cv_xopen_source=no],
6630 [cf_save="$CPPFLAGS"
6631 CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
6632 AC_TRY_COMPILE([#include <sys/types.h>],[
6633 #ifdef _XOPEN_SOURCE
6636 [cf_cv_xopen_source=no],
6637 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
6641 if test "$cf_cv_xopen_source" != no ; then
6642 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
6643 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
6644 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
6645 CF_ADD_CFLAGS($cf_temp_xopen_source)
6647 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
6651 if test -n "$cf_xopen_source" ; then
6652 CF_ADD_CFLAGS($cf_xopen_source)