1 dnl***************************************************************************
2 dnl Copyright (c) 1998-2009,2010 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.546 2010/10/23 20:14:30 tom Exp $
32 dnl Macros used in NCURSES auto-configuration script.
34 dnl These macros are maintained separately from NCURSES. The copyright on
35 dnl this file applies to the aggregation of macros and does not affect use of
36 dnl these macros in other applications.
38 dnl See http://invisible-island.net/autoconf/ for additional information.
40 dnl ---------------------------------------------------------------------------
41 dnl ---------------------------------------------------------------------------
42 dnl AM_LANGINFO_CODESET version: 3 updated: 2002/10/27 23:21:42
43 dnl -------------------
44 dnl Inserted as requested by gettext 0.10.40
45 dnl File from /usr/share/aclocal
47 dnl ====================
50 dnl From Bruno Haible.
51 AC_DEFUN([AM_LANGINFO_CODESET],
53 AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset,
54 [AC_TRY_LINK([#include <langinfo.h>],
55 [char* cs = nl_langinfo(CODESET);],
56 am_cv_langinfo_codeset=yes,
57 am_cv_langinfo_codeset=no)
59 if test $am_cv_langinfo_codeset = yes; then
60 AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
61 [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
64 dnl ---------------------------------------------------------------------------
65 dnl CF_ADA_INCLUDE_DIRS version: 6 updated: 2010/02/26 19:52:07
66 dnl -------------------
67 dnl Construct the list of include-options for the C programs in the Ada95
69 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
71 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
72 if test "$srcdir" != "."; then
73 ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
75 if test "$GCC" != yes; then
76 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
77 elif test "$includedir" != "/usr/include"; then
78 if test "$includedir" = '${prefix}/include' ; then
79 if test $prefix != /usr ; then
80 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
83 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
88 dnl ---------------------------------------------------------------------------
89 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
91 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
92 AC_DEFUN([CF_ADD_ADAFLAGS],[
93 ADAFLAGS="$ADAFLAGS $1"
96 dnl ---------------------------------------------------------------------------
97 dnl CF_ADD_CFLAGS version: 10 updated: 2010/05/26 05:38:42
99 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
100 dnl The second parameter if given makes this macro verbose.
102 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
103 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
104 dnl confused by the quotes (which require backslashes to keep them usable).
105 AC_DEFUN([CF_ADD_CFLAGS],
110 cf_new_extra_cppflags=
112 for cf_add_cflags in $1
114 case $cf_fix_cppflags in
116 case $cf_add_cflags in #(vi
117 -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi
118 case $cf_add_cflags in
120 cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
122 test "${cf_add_cflags}" != "${cf_tst_cflags}" \
123 && test -z "${cf_tst_cflags}" \
124 && cf_fix_cppflags=yes
126 if test $cf_fix_cppflags = yes ; then
127 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
129 elif test "${cf_tst_cflags}" = "\"'" ; then
130 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
136 *$cf_add_cflags) #(vi
139 case $cf_add_cflags in #(vi
141 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
142 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
145 cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
150 cf_new_cflags="$cf_new_cflags $cf_add_cflags"
155 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
157 cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
159 test "${cf_add_cflags}" != "${cf_tst_cflags}" \
160 && test -z "${cf_tst_cflags}" \
161 && cf_fix_cppflags=no
166 if test -n "$cf_new_cflags" ; then
167 ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
168 CFLAGS="$CFLAGS $cf_new_cflags"
171 if test -n "$cf_new_cppflags" ; then
172 ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
173 CPPFLAGS="$CPPFLAGS $cf_new_cppflags"
176 if test -n "$cf_new_extra_cppflags" ; then
177 ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
178 EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
181 AC_SUBST(EXTRA_CPPFLAGS)
184 dnl ---------------------------------------------------------------------------
185 dnl CF_ADD_INCDIR version: 13 updated: 2010/05/26 16:44:57
187 dnl Add an include-directory to $CPPFLAGS. Don't add /usr/include, since it's
188 dnl redundant. We don't normally need to add -I/usr/local/include for gcc,
189 dnl but old versions (and some misinstalled ones) need that. To make things
190 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
191 dnl the include-path).
192 AC_DEFUN([CF_ADD_INCDIR],
194 if test -n "$1" ; then
195 for cf_add_incdir in $1
197 while test $cf_add_incdir != /usr/include
199 if test -d $cf_add_incdir
202 if test -n "$CFLAGS$CPPFLAGS" ; then
203 # a loop is needed to ensure we can add subdirs of existing dirs
204 for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
205 if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
206 cf_have_incdir=yes; break
211 if test "$cf_have_incdir" = no ; then
212 if test "$cf_add_incdir" = /usr/local/include ; then
215 cf_save_CPPFLAGS=$CPPFLAGS
216 CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
217 AC_TRY_COMPILE([#include <stdio.h>],
220 [cf_have_incdir=yes])
221 CPPFLAGS=$cf_save_CPPFLAGS
226 if test "$cf_have_incdir" = no ; then
227 CF_VERBOSE(adding $cf_add_incdir to include-path)
228 ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
230 cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
231 test "$cf_top_incdir" = "$cf_add_incdir" && break
232 cf_add_incdir="$cf_top_incdir"
241 dnl ---------------------------------------------------------------------------
242 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
244 dnl Add a library, used to enforce consistency.
246 dnl $1 = library to add, without the "-l"
247 dnl $2 = variable to update (default $LIBS)
248 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
249 dnl ---------------------------------------------------------------------------
250 dnl CF_ADD_LIBDIR version: 9 updated: 2010/05/26 16:44:57
252 dnl Adds to the library-path
254 dnl Some machines have trouble with multiple -L options.
256 dnl $1 is the (list of) directory(s) to add
257 dnl $2 is the optional name of the variable to update (default LDFLAGS)
259 AC_DEFUN([CF_ADD_LIBDIR],
261 if test -n "$1" ; then
262 for cf_add_libdir in $1
264 if test $cf_add_libdir = /usr/lib ; then
266 elif test -d $cf_add_libdir
269 if test -n "$LDFLAGS$LIBS" ; then
270 # a loop is needed to ensure we can add subdirs of existing dirs
271 for cf_test_libdir in $LDFLAGS $LIBS ; do
272 if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
273 cf_have_libdir=yes; break
277 if test "$cf_have_libdir" = no ; then
278 CF_VERBOSE(adding $cf_add_libdir to library-path)
279 ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
285 dnl ---------------------------------------------------------------------------
286 dnl CF_ADD_LIBS version: 1 updated: 2010/06/02 05:03:05
288 dnl Add one or more libraries, used to enforce consistency.
290 dnl $1 = libraries to add, with the "-l", etc.
291 dnl $2 = variable to update (default $LIBS)
292 AC_DEFUN([CF_ADD_LIBS],[ifelse($2,,LIBS,[$2])="$1 [$]ifelse($2,,LIBS,[$2])"])dnl
293 dnl ---------------------------------------------------------------------------
294 dnl CF_ADD_SUBDIR_PATH version: 3 updated: 2010/07/03 20:58:12
295 dnl ------------------
296 dnl Append to a search-list for a nonstandard header/lib-file
297 dnl $1 = the variable to return as result
298 dnl $2 = the package name
299 dnl $3 = the subdirectory, e.g., bin, include or lib
300 dnl $4 = the directory under which we will test for subdirectories
301 dnl $5 = a directory that we do not want $4 to match
302 AC_DEFUN([CF_ADD_SUBDIR_PATH],
304 test "$4" != "$5" && \
306 ifelse([$5],NONE,,[(test $5 = NONE || test "$4" != "$5") &&]) {
307 test -n "$verbose" && echo " ... testing for $3-directories under $4"
308 test -d $4/$3 && $1="[$]$1 $4/$3"
309 test -d $4/$3/$2 && $1="[$]$1 $4/$3/$2"
310 test -d $4/$3/$2/$3 && $1="[$]$1 $4/$3/$2/$3"
311 test -d $4/$2/$3 && $1="[$]$1 $4/$2/$3"
312 test -d $4/$2/$3/$2 && $1="[$]$1 $4/$2/$3/$2"
315 dnl ---------------------------------------------------------------------------
316 dnl CF_ANSI_CC_CHECK version: 10 updated: 2010/10/23 15:52:32
318 dnl This is adapted from the macros 'fp_PROG_CC_STDC' and 'fp_C_PROTOTYPES'
319 dnl in the sharutils 4.2 distribution.
320 AC_DEFUN([CF_ANSI_CC_CHECK],
322 AC_CACHE_CHECK(for ${CC:-cc} option to accept ANSI C, cf_cv_ansi_cc,[
324 cf_save_CFLAGS="$CFLAGS"
325 cf_save_CPPFLAGS="$CPPFLAGS"
326 # Don't try gcc -ansi; that turns off useful extensions and
327 # breaks some systems' header files.
329 # Ultrix and OSF/1 -std1
330 # HP-UX -Aa -D_HPUX_SOURCE
332 # UnixWare 1.2 (cannot use -Xc, since ANSI/POSIX clashes)
333 for cf_arg in "-DCC_HAS_PROTOS" \
338 "-Aa -D_HPUX_SOURCE" \
341 CF_ADD_CFLAGS($cf_arg)
344 #ifndef CC_HAS_PROTOS
345 #if !defined(__STDC__) || (__STDC__ != 1)
350 int test (int i, double x);
351 struct s1 {int (*f) (int a);};
352 struct s2 {int (*f) (double a);};],
353 [cf_cv_ansi_cc="$cf_arg"; break])
355 CFLAGS="$cf_save_CFLAGS"
356 CPPFLAGS="$cf_save_CPPFLAGS"
359 if test "$cf_cv_ansi_cc" != "no"; then
360 if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then
361 CF_ADD_CFLAGS($cf_cv_ansi_cc)
363 AC_DEFINE(CC_HAS_PROTOS)
367 dnl ---------------------------------------------------------------------------
368 dnl CF_ANSI_CC_REQD version: 4 updated: 2008/03/23 14:48:54
370 dnl For programs that must use an ANSI compiler, obtain compiler options that
371 dnl will make it recognize prototypes. We'll do preprocessor checks in other
372 dnl macros, since tools such as unproto can fake prototypes, but only part of
373 dnl the preprocessor.
374 AC_DEFUN([CF_ANSI_CC_REQD],
375 [AC_REQUIRE([CF_ANSI_CC_CHECK])
376 if test "$cf_cv_ansi_cc" = "no"; then
378 [Your compiler does not appear to recognize prototypes.
379 You have the following choices:
380 a. adjust your compiler options
381 b. get an up-to-date compiler
382 c. use a wrapper such as unproto])
385 dnl ---------------------------------------------------------------------------
386 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
388 dnl Allow user to disable a normally-on option.
389 AC_DEFUN([CF_ARG_DISABLE],
390 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
391 dnl ---------------------------------------------------------------------------
392 dnl CF_ARG_OPTION version: 4 updated: 2010/05/26 05:38:42
394 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
400 dnl $3 = action to perform if option is not default
401 dnl $4 = action if perform if option is default
402 dnl $5 = default option value (either 'yes' or 'no')
403 AC_DEFUN([CF_ARG_OPTION],
404 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
405 if test "$enableval" != "$5" ; then
407 ,[ $3]) ifelse([$4],,,[
410 fi],[enableval=$5 ifelse([$4],,,[
414 dnl ---------------------------------------------------------------------------
415 dnl CF_AR_FLAGS version: 5 updated: 2010/05/20 20:24:29
417 dnl Check for suitable "ar" (archiver) options for updating an archive.
418 AC_DEFUN([CF_AR_FLAGS],[
419 AC_REQUIRE([CF_PROG_AR])
421 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
422 cf_cv_ar_flags=unknown
423 for cf_ar_flags in -curv curv -crv crv -cqv cqv -rv rv
426 # check if $ARFLAGS already contains this choice
427 if test "x$ARFLAGS" != "x" ; then
428 cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
429 if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
435 rm -f conftest.$ac_cv_objext
438 cat >conftest.$ac_ext <<EOF
439 #line __oline__ "configure"
440 int testdata[[3]] = { 123, 456, 789 };
442 if AC_TRY_EVAL(ac_compile) ; then
443 echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
444 $AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null
445 if test -f conftest.a ; then
446 cf_cv_ar_flags=$cf_ar_flags
450 CF_VERBOSE(cannot compile test-program)
454 rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
457 if test -n "$ARFLAGS" ; then
458 if test -n "$cf_cv_ar_flags" ; then
459 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
462 ARFLAGS=$cf_cv_ar_flags
467 dnl ---------------------------------------------------------------------------
468 dnl CF_AWK_BIG_PRINTF version: 3 updated: 2008/12/27 12:30:03
469 dnl -----------------
470 dnl Check if awk can handle big strings using printf. Some older versions of
471 dnl awk choke on large strings passed via "%s".
473 dnl $1 = desired string size
474 dnl $2 = variable to set with result
475 AC_DEFUN([CF_AWK_BIG_PRINTF],
482 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' \
483 | $AWK '{ printf "%d\n", length([$]0); }' | $AWK 'BEGIN { eqls=0; recs=0; } { recs++; if ([$]0 == 12000) eqls++; } END { if (recs != 1 || eqls != 1) exit 1; }' 2>/dev/null >/dev/null ) ; then
491 dnl ---------------------------------------------------------------------------
492 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
494 dnl Test if 'bool' is a builtin type in the configured C++ compiler. Some
495 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
496 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
498 dnl Treat the configuration-variable specially here, since we're directly
499 dnl substituting its value (i.e., 1/0).
501 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
502 AC_DEFUN([CF_BOOL_DECL],
504 AC_MSG_CHECKING(if we should include stdbool.h)
506 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
507 AC_TRY_COMPILE([],[bool foo = false],
508 [cf_cv_header_stdbool_h=0],
513 ],[bool foo = false],
514 [cf_cv_header_stdbool_h=1],
515 [cf_cv_header_stdbool_h=0])])])
517 if test "$cf_cv_header_stdbool_h" = 1
518 then AC_MSG_RESULT(yes)
519 else AC_MSG_RESULT(no)
522 AC_MSG_CHECKING([for builtin bool type])
524 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
527 #include <sys/types.h>
529 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
530 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
533 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
534 then AC_MSG_RESULT(yes)
535 else AC_MSG_RESULT(no)
538 dnl ---------------------------------------------------------------------------
539 dnl CF_BOOL_SIZE version: 12 updated: 2006/12/16 12:33:30
541 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
542 dnl Don't bother looking for bool.h, since it's been deprecated.
544 dnl If the current compiler is C rather than C++, we get the bool definition
545 dnl from <stdbool.h>.
546 AC_DEFUN([CF_BOOL_SIZE],
548 AC_MSG_CHECKING([for size of bool])
549 AC_CACHE_VAL(cf_cv_type_of_bool,[
555 #if defined(__cplusplus)
557 #ifdef HAVE_GXX_BUILTIN_H
558 #include <g++/builtin.h>
559 #elif HAVE_GPP_BUILTIN_H
560 #include <gpp/builtin.h>
567 #if $cf_cv_header_stdbool_h
575 FILE *fp = fopen("cf_test.out", "w");
579 fputs("unsigned ", fp);
580 if (sizeof(x) == sizeof(int)) fputs("int", fp);
581 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
582 else if (sizeof(x) == sizeof(short))fputs("short",fp);
583 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
586 ${cf_cv_main_return:-return}(0);
589 [cf_cv_type_of_bool=`cat cf_test.out`
590 if test -z "$cf_cv_type_of_bool"; then
591 cf_cv_type_of_bool=unknown
593 [cf_cv_type_of_bool=unknown],
594 [cf_cv_type_of_bool=unknown])
597 AC_MSG_RESULT($cf_cv_type_of_bool)
598 if test "$cf_cv_type_of_bool" = unknown ; then
599 case .$NCURSES_BOOL in #(vi
600 .auto|.) NCURSES_BOOL=unsigned;;
602 AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
603 cf_cv_type_of_bool=$NCURSES_BOOL
606 dnl ---------------------------------------------------------------------------
607 dnl CF_BUILD_CC version: 6 updated: 2006/10/14 15:23:15
609 dnl If we're cross-compiling, allow the user to override the tools and their
610 dnl options. The configure script is oriented toward identifying the host
611 dnl compiler, etc., but we need a build compiler to generate parts of the
614 dnl $1 = default for $CPPFLAGS
615 dnl $2 = default for $LIBS
616 AC_DEFUN([CF_BUILD_CC],[
617 AC_REQUIRE([CF_PROG_EXT])
618 if test "$cross_compiling" = yes ; then
620 # defaults that we might want to override
621 : ${BUILD_CFLAGS:=''}
622 : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
623 : ${BUILD_LDFLAGS:=''}
624 : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
625 : ${BUILD_EXEEXT:='$x'}
626 : ${BUILD_OBJEXT:='o'}
628 AC_ARG_WITH(build-cc,
629 [ --with-build-cc=XXX the build C compiler ($BUILD_CC)],
630 [BUILD_CC="$withval"],
631 [AC_CHECK_PROGS(BUILD_CC, gcc cc cl)])
632 AC_MSG_CHECKING(for native build C compiler)
633 AC_MSG_RESULT($BUILD_CC)
635 AC_MSG_CHECKING(for native build C preprocessor)
636 AC_ARG_WITH(build-cpp,
637 [ --with-build-cpp=XXX the build C preprocessor ($BUILD_CPP)],
638 [BUILD_CPP="$withval"],
639 [BUILD_CPP='${BUILD_CC} -E'])
640 AC_MSG_RESULT($BUILD_CPP)
642 AC_MSG_CHECKING(for native build C flags)
643 AC_ARG_WITH(build-cflags,
644 [ --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
645 [BUILD_CFLAGS="$withval"])
646 AC_MSG_RESULT($BUILD_CFLAGS)
648 AC_MSG_CHECKING(for native build C preprocessor-flags)
649 AC_ARG_WITH(build-cppflags,
650 [ --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
651 [BUILD_CPPFLAGS="$withval"])
652 AC_MSG_RESULT($BUILD_CPPFLAGS)
654 AC_MSG_CHECKING(for native build linker-flags)
655 AC_ARG_WITH(build-ldflags,
656 [ --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
657 [BUILD_LDFLAGS="$withval"])
658 AC_MSG_RESULT($BUILD_LDFLAGS)
660 AC_MSG_CHECKING(for native build linker-libraries)
661 AC_ARG_WITH(build-libs,
662 [ --with-build-libs=XXX the build libraries (${BUILD_LIBS})],
663 [BUILD_LIBS="$withval"])
664 AC_MSG_RESULT($BUILD_LIBS)
666 # this assumes we're on Unix.
670 : ${BUILD_CC:='${CC}'}
672 if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
673 AC_MSG_ERROR([Cross-build requires two compilers.
674 Use --with-build-cc to specify the native compiler.])
678 : ${BUILD_CC:='${CC}'}
679 : ${BUILD_CPP:='${CPP}'}
680 : ${BUILD_CFLAGS:='${CFLAGS}'}
681 : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
682 : ${BUILD_LDFLAGS:='${LDFLAGS}'}
683 : ${BUILD_LIBS:='${LIBS}'}
684 : ${BUILD_EXEEXT:='$x'}
685 : ${BUILD_OBJEXT:='o'}
690 AC_SUBST(BUILD_CFLAGS)
691 AC_SUBST(BUILD_CPPFLAGS)
692 AC_SUBST(BUILD_LDFLAGS)
694 AC_SUBST(BUILD_EXEEXT)
695 AC_SUBST(BUILD_OBJEXT)
697 dnl ---------------------------------------------------------------------------
698 dnl CF_CFG_DEFAULTS version: 7 updated: 2005/09/24 16:15:00
700 dnl Determine the default configuration into which we'll install ncurses. This
701 dnl can be overridden by the user's command-line options. There's two items to
703 dnl 1. the prefix (e.g., /usr)
704 dnl 2. the header files (e.g., /usr/include/ncurses)
705 dnl We'll look for a previous installation of ncurses and use the same defaults.
707 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
708 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
709 dnl programs from a vendor's.
710 AC_DEFUN([CF_CFG_DEFAULTS],
712 AC_MSG_CHECKING(for prefix)
713 if test "x$prefix" = "xNONE" ; then
714 case "$cf_cv_system_name" in
715 # non-vendor systems don't have a conflict
716 openbsd*|freebsd*|linux*|cygwin*|k*bsd*-gnu)
719 *) prefix=$ac_default_prefix
723 AC_MSG_RESULT($prefix)
725 if test "x$prefix" = "xNONE" ; then
726 AC_MSG_CHECKING(for default include-directory)
727 test -n "$verbose" && echo 1>&AC_FD_MSG
730 $includedir/ncurses \
732 $prefix/include/ncurses \
734 /usr/local/include/ncurses \
738 cf_dir=`eval echo $cf_symbol`
739 if test -f $cf_dir/curses.h ; then
740 if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
741 includedir="$cf_symbol"
742 test -n "$verbose" && echo $ac_n " found " 1>&AC_FD_MSG
746 test -n "$verbose" && echo " tested $cf_dir" 1>&AC_FD_MSG
748 AC_MSG_RESULT($includedir)
751 dnl ---------------------------------------------------------------------------
752 dnl CF_CGETENT version: 3 updated: 2000/08/12 23:18:52
754 dnl Check if the terminal-capability database functions are available. If not,
755 dnl ncurses has a much-reduced version.
756 AC_DEFUN([CF_CGETENT],[
757 AC_MSG_CHECKING(for terminal-capability database functions)
758 AC_CACHE_VAL(cf_cv_cgetent,[
760 #include <stdlib.h>],[
763 char *db_array = temp;
764 cgetent(&buf, /* int *, */ &db_array, "vt100");
765 cgetcap(buf, "tc", '=');
766 cgetmatch(buf, "tc");
771 AC_MSG_RESULT($cf_cv_cgetent)
772 test "$cf_cv_cgetent" = yes && AC_DEFINE(HAVE_BSD_CGETENT)
774 dnl ---------------------------------------------------------------------------
775 dnl CF_CHECK_CACHE version: 11 updated: 2008/03/23 14:45:59
777 dnl Check if we're accidentally using a cache from a different machine.
778 dnl Derive the system name, as a check for reusing the autoconf cache.
780 dnl If we've packaged config.guess and config.sub, run that (since it does a
781 dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
782 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
783 dnl which is useful in cross-compiles.
785 dnl Note: we would use $ac_config_sub, but that is one of the places where
786 dnl autoconf 2.5x broke compatibility with autoconf 2.13
787 AC_DEFUN([CF_CHECK_CACHE],
789 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
790 ifelse([$1],,[AC_CANONICAL_HOST],[$1])
791 system_name="$host_os"
793 system_name="`(uname -s -r) 2>/dev/null`"
794 if test -z "$system_name" ; then
795 system_name="`(hostname) 2>/dev/null`"
798 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name")
799 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
801 test -z "$system_name" && system_name="$cf_cv_system_name"
802 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
804 if test ".$system_name" != ".$cf_cv_system_name" ; then
805 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
806 AC_MSG_ERROR("Please remove config.cache and try again.")
809 dnl ---------------------------------------------------------------------------
810 dnl CF_CHECK_ERRNO version: 11 updated: 2010/05/26 05:38:42
812 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
813 dnl the 'errno' variable. Define a DECL_xxx symbol if we must declare it
816 dnl $1 = the name to check
817 dnl $2 = the assumed type
818 AC_DEFUN([CF_CHECK_ERRNO],
820 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
826 #include <sys/types.h>
827 #include <errno.h> ],
828 ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1,
833 if test "$cf_cv_dcl_$1" = no ; then
834 CF_UPPER(cf_result,decl_$1)
835 AC_DEFINE_UNQUOTED($cf_result)
838 # It's possible (for near-UNIX clones) that the data doesn't exist
839 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
841 dnl ---------------------------------------------------------------------------
842 dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23
843 dnl --------------------
844 dnl Check for existence of external data in the current set of libraries. If
845 dnl we can modify it, it's real enough.
846 dnl $1 = the name to check
848 AC_DEFUN([CF_CHECK_EXTERN_DATA],
850 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
860 if test "$cf_cv_have_$1" = yes ; then
861 CF_UPPER(cf_result,have_$1)
862 AC_DEFINE_UNQUOTED($cf_result)
866 dnl ---------------------------------------------------------------------------
867 dnl CF_CHECK_GPM_WGETCH version: 2 updated: 2010/08/14 18:25:37
868 dnl -------------------
869 dnl Check if GPM is already linked with curses. If so - and if the linkage
870 dnl is not "weak" - warn about this because it can create problems linking
871 dnl applications with ncurses.
872 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
873 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
875 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
876 cf_cv_check_gpm_wgetch=unknown
877 if test "$cross_compiling" != yes ; then
879 cat >conftest.$ac_ext <<CF_EOF
884 ${cf_cv_main_return:-return}(0);
889 # This only works if we can look at the symbol table. If a shared
890 # library is stripped for install, we cannot use that. So we're forced
891 # to rely on the static library, noting that some packagers may not
893 LIBS="-static -lgpm -dynamic $LIBS"
894 if AC_TRY_EVAL(ac_compile) ; then
895 if AC_TRY_EVAL(ac_link) ; then
896 cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
897 test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
898 test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
906 if test "$cf_cv_check_gpm_wgetch" != yes ; then
907 AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
910 dnl ---------------------------------------------------------------------------
911 dnl CF_CPP_PARAM_INIT version: 4 updated: 2001/04/07 22:31:18
912 dnl -----------------
913 dnl Check if the C++ compiler accepts duplicate parameter initialization. This
914 dnl is a late feature for the standard and is not in some recent compilers
916 AC_DEFUN([CF_CPP_PARAM_INIT],
918 if test -n "$CXX"; then
919 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
931 TEST::TEST(int x = 1) // some compilers do not like second initializer
937 [cf_cv_cpp_param_init=yes],
938 [cf_cv_cpp_param_init=no],
939 [cf_cv_cpp_param_init=unknown])
943 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT)
945 dnl ---------------------------------------------------------------------------
946 dnl CF_CPP_STATIC_CAST version: 1 updated: 2005/07/23 16:52:43
947 dnl ------------------
948 dnl Check if the C++ compiler accepts static_cast in generics. This appears to
949 dnl not be supported in g++ before 3.0
950 AC_DEFUN([CF_CPP_STATIC_CAST],
952 if test -n "$CXX"; then
954 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
962 NCursesPanel(int nlines,
972 template<class T> class NCursesUserPanel : public NCursesPanel
975 NCursesUserPanel (int nlines,
979 const T* p_UserData = static_cast<T*>(0))
980 : NCursesPanel (nlines, ncols, begin_y, begin_x)
983 NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
987 virtual ~NCursesUserPanel() {};
990 const char* p_UserData = static_cast<char*>(0)],
991 [cf_cv_cpp_static_cast=yes],
992 [cf_cv_cpp_static_cast=no])
999 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST)
1001 dnl ---------------------------------------------------------------------------
1002 dnl CF_C_INLINE version: 3 updated: 2010/05/01 15:14:41
1004 dnl Check if the C compiler supports "inline".
1005 dnl $1 is the name of a shell variable to set if inline is supported
1006 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
1007 AC_DEFUN([CF_C_INLINE],[
1010 if test "$ac_cv_c_inline" != no ; then
1012 if test "$INTEL_COMPILER" = yes
1015 elif test "$GCC" = yes
1017 AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[
1018 cf_save_CFLAGS=$CFLAGS
1019 CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
1020 AC_TRY_COMPILE([inline int foo(void) { return 1; }],
1021 [${cf_cv_main_return:-return} foo()],
1022 [cf_cv_gcc_inline=yes],
1023 [cf_cv_gcc_inline=no])
1024 CFLAGS=$cf_save_CFLAGS
1026 if test "$cf_cv_gcc_inline" = yes ; then
1027 CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
1033 dnl ---------------------------------------------------------------------------
1034 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
1036 dnl "dirname" is not portable, so we fake it with a shell script.
1037 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
1038 dnl ---------------------------------------------------------------------------
1039 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
1041 AC_DEFUN([CF_DIRS_TO_MAKE],
1044 for cf_item in $cf_list_models
1046 CF_OBJ_SUBDIR($cf_item,cf_subdir)
1047 for cf_item2 in $DIRS_TO_MAKE
1049 test $cf_item2 = $cf_subdir && break
1051 test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
1053 for cf_dir in $DIRS_TO_MAKE
1055 test ! -d $cf_dir && mkdir $cf_dir
1057 AC_SUBST(DIRS_TO_MAKE)
1059 dnl ---------------------------------------------------------------------------
1060 dnl CF_DISABLE_LEAKS version: 6 updated: 2010/07/23 04:14:32
1061 dnl ----------------
1062 dnl Combine no-leak checks with the libraries or tools that are used for the
1064 AC_DEFUN([CF_DISABLE_LEAKS],[
1066 AC_REQUIRE([CF_WITH_DMALLOC])
1067 AC_REQUIRE([CF_WITH_DBMALLOC])
1068 AC_REQUIRE([CF_WITH_VALGRIND])
1070 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1071 AC_ARG_ENABLE(leaks,
1072 [ --disable-leaks test: free permanent memory, analyze leaks],
1073 [if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi],
1074 : ${with_no_leaks:=no})
1075 AC_MSG_RESULT($with_no_leaks)
1077 if test "$with_no_leaks" = yes ; then
1079 AC_DEFINE(YY_NO_LEAKS)
1082 dnl ---------------------------------------------------------------------------
1083 dnl CF_DISABLE_LIBTOOL_VERSION version: 1 updated: 2010/05/15 15:45:59
1084 dnl --------------------------
1085 dnl Check if we should use the libtool 1.5 feature "-version-number" instead of
1086 dnl the older "-version-info" feature. The newer feature allows us to use
1087 dnl version numbering on shared libraries which make them compatible with
1088 dnl various systems.
1089 AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION],
1091 AC_MSG_CHECKING(if libtool -version-number should be used)
1092 CF_ARG_DISABLE(libtool-version,
1093 [ --disable-libtool-version enable to use libtool's incompatible naming scheme],
1094 [cf_libtool_version=no],
1095 [cf_libtool_version=yes])
1096 AC_MSG_RESULT($cf_libtool_version)
1098 if test "$cf_libtool_version" = yes ; then
1099 LIBTOOL_VERSION="-version-number"
1101 LIBTOOL_VERSION="-version-info"
1104 AC_SUBST(LIBTOOL_VERSION)
1106 dnl ---------------------------------------------------------------------------
1107 dnl CF_DISABLE_RPATH_HACK version: 1 updated: 2010/04/11 10:54:00
1108 dnl ---------------------
1109 dnl The rpath-hack makes it simpler to build programs, particularly with the
1110 dnl *BSD ports which may have essential libraries in unusual places. But it
1111 dnl can interfere with building an executable for the base system. Use this
1112 dnl option in that case.
1113 AC_DEFUN([CF_DISABLE_RPATH_HACK],
1115 AC_MSG_CHECKING(if rpath should be not be set)
1116 CF_ARG_DISABLE(rpath-hack,
1117 [ --disable-rpath-hack don't add rpath options for additional libraries],
1118 [cf_disable_rpath_hack=yes],
1119 [cf_disable_rpath_hack=no])
1120 AC_MSG_RESULT($cf_disable_rpath_hack)
1121 if test "$cf_disable_rpath_hack" = no ; then
1125 dnl ---------------------------------------------------------------------------
1126 dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
1128 dnl Check if the rpath option should be used, setting cache variable
1129 dnl cf_cv_enable_rpath if so.
1130 AC_DEFUN([CF_ENABLE_RPATH],
1132 AC_MSG_CHECKING(if rpath option should be used)
1133 AC_ARG_ENABLE(rpath,
1134 [ --enable-rpath use rpath option when generating shared libraries],
1135 [cf_cv_enable_rpath=$enableval],
1136 [cf_cv_enable_rpath=no])
1137 AC_MSG_RESULT($cf_cv_enable_rpath)
1139 dnl ---------------------------------------------------------------------------
1140 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
1142 dnl Check if 'errno' is declared in <errno.h>
1143 AC_DEFUN([CF_ERRNO],
1145 CF_CHECK_ERRNO(errno)
1147 dnl ---------------------------------------------------------------------------
1148 dnl CF_ETIP_DEFINES version: 3 updated: 2003/03/22 19:13:43
1150 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
1151 dnl math.h and builtin.h, only for ncurses
1152 AC_DEFUN([CF_ETIP_DEFINES],
1154 AC_MSG_CHECKING(for special defines needed for etip.h)
1155 cf_save_CXXFLAGS="$CXXFLAGS"
1157 for cf_math in "" MATH_H
1159 for cf_excp in "" MATH_EXCEPTION
1161 CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -I${srcdir}/include"
1162 test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
1163 test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
1165 #include <etip.h.in>
1167 test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
1168 test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
1169 cf_result="$cf_math $cf_excp"
1174 AC_MSG_RESULT($cf_result)
1175 CXXFLAGS="$cf_save_CXXFLAGS"
1177 dnl ---------------------------------------------------------------------------
1178 dnl CF_FIND_LINKAGE version: 19 updated: 2010/05/29 16:31:02
1180 dnl Find a library (specifically the linkage used in the code fragment),
1181 dnl searching for it if it is not already in the library path.
1182 dnl See also CF_ADD_SEARCHPATH.
1184 dnl Parameters (4-on are optional):
1185 dnl $1 = headers for library entrypoint
1186 dnl $2 = code fragment for library entrypoint
1187 dnl $3 = the library name without the "-l" option or ".so" suffix.
1188 dnl $4 = action to perform if successful (default: update CPPFLAGS, etc)
1189 dnl $5 = action to perform if not successful
1190 dnl $6 = module name, if not the same as the library name
1191 dnl $7 = extra libraries
1193 dnl Sets these variables:
1194 dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1195 dnl $cf_cv_header_path_$3 - include-directory if needed
1196 dnl $cf_cv_library_path_$3 - library-directory if needed
1197 dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1198 AC_DEFUN([CF_FIND_LINKAGE],[
1200 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1201 # will be set on completion of the AC_TRY_LINK below.
1202 cf_cv_header_path_$3=
1203 cf_cv_library_path_$3=
1205 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1207 cf_save_LIBS="$LIBS"
1209 AC_TRY_LINK([$1],[$2],[
1210 cf_cv_find_linkage_$3=yes
1211 cf_cv_header_path_$3=/usr/include
1212 cf_cv_library_path_$3=/usr/lib
1215 LIBS="-l$3 $7 $cf_save_LIBS"
1217 AC_TRY_LINK([$1],[$2],[
1218 cf_cv_find_linkage_$3=yes
1219 cf_cv_header_path_$3=/usr/include
1220 cf_cv_library_path_$3=/usr/lib
1221 cf_cv_library_file_$3="-l$3"
1223 cf_cv_find_linkage_$3=no
1224 LIBS="$cf_save_LIBS"
1226 CF_VERBOSE(find linkage for $3 library)
1227 CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1229 cf_save_CPPFLAGS="$CPPFLAGS"
1230 cf_test_CPPFLAGS="$CPPFLAGS"
1232 CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1233 for cf_cv_header_path_$3 in $cf_search
1235 if test -d $cf_cv_header_path_$3 ; then
1236 CF_VERBOSE(... testing $cf_cv_header_path_$3)
1237 CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
1238 AC_TRY_COMPILE([$1],[$2],[
1239 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1240 cf_cv_find_linkage_$3=maybe
1241 cf_test_CPPFLAGS="$CPPFLAGS"
1243 CPPFLAGS="$cf_save_CPPFLAGS"
1248 if test "$cf_cv_find_linkage_$3" = maybe ; then
1250 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1252 cf_save_LIBS="$LIBS"
1253 cf_save_LDFLAGS="$LDFLAGS"
1256 CPPFLAGS="$cf_test_CPPFLAGS"
1257 LIBS="-l$3 $7 $cf_save_LIBS"
1258 AC_TRY_LINK([$1],[$2],[
1259 CF_VERBOSE(... found $3 library in system)
1260 cf_cv_find_linkage_$3=yes])
1261 CPPFLAGS="$cf_save_CPPFLAGS"
1262 LIBS="$cf_save_LIBS"
1265 if test "$cf_cv_find_linkage_$3" != yes ; then
1266 CF_LIBRARY_PATH(cf_search,$3)
1267 for cf_cv_library_path_$3 in $cf_search
1269 if test -d $cf_cv_library_path_$3 ; then
1270 CF_VERBOSE(... testing $cf_cv_library_path_$3)
1271 CPPFLAGS="$cf_test_CPPFLAGS"
1272 LIBS="-l$3 $7 $cf_save_LIBS"
1273 LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1274 AC_TRY_LINK([$1],[$2],[
1275 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1276 cf_cv_find_linkage_$3=yes
1277 cf_cv_library_file_$3="-l$3"
1279 CPPFLAGS="$cf_save_CPPFLAGS"
1280 LIBS="$cf_save_LIBS"
1281 LDFLAGS="$cf_save_LDFLAGS"
1285 CPPFLAGS="$cf_save_CPPFLAGS"
1286 LDFLAGS="$cf_save_LDFLAGS"
1290 cf_cv_find_linkage_$3=no
1295 LIBS="$cf_save_LIBS"
1297 if test "$cf_cv_find_linkage_$3" = yes ; then
1299 CF_ADD_INCDIR($cf_cv_header_path_$3)
1300 CF_ADD_LIBDIR($cf_cv_library_path_$3)
1304 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1307 dnl ---------------------------------------------------------------------------
1308 dnl CF_FUNC_DLSYM version: 2 updated: 2010/05/29 16:31:02
1310 dnl Test for dlsym() and related functions, as well as libdl.
1315 AC_DEFUN([CF_FUNC_DLSYM],[
1317 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
1320 AC_CHECK_LIB(dl,dlsym,[
1322 cf_have_libdl=yes])])
1324 if test "$cf_have_dlsym" = yes ; then
1325 test "$cf_have_libdl" = yes && CF_ADD_LIB(dl)
1327 AC_MSG_CHECKING(whether able to link to dl*() functions)
1328 AC_TRY_LINK([#include <dlfcn.h>],[
1330 if ((obj = dlopen("filename", 0)) != 0) {
1331 if (dlsym(obj, "symbolname") == 0) {
1335 AC_DEFINE(HAVE_LIBDL)],[
1336 AC_MSG_ERROR(Cannot link test program for libdl)])
1339 AC_MSG_ERROR(Cannot find dlsym function)
1342 dnl ---------------------------------------------------------------------------
1343 dnl CF_FUNC_MEMMOVE version: 7 updated: 2006/12/16 12:33:30
1345 dnl Check for memmove, or a bcopy that can handle overlapping copy. If neither
1346 dnl is found, add our own version of memmove to the list of objects.
1347 AC_DEFUN([CF_FUNC_MEMMOVE],
1349 AC_CHECK_FUNC(memmove,,[
1350 AC_CHECK_FUNC(bcopy,[
1351 AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
1354 static char data[] = "abcdefghijklmnopqrstuwwxyz";
1356 bcopy(data, temp, sizeof(data));
1357 bcopy(temp+10, temp, 15);
1358 bcopy(temp+5, temp+15, 10);
1359 ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
1362 [cf_cv_good_bcopy=yes],
1363 [cf_cv_good_bcopy=no],
1364 [cf_cv_good_bcopy=unknown])
1366 ],[cf_cv_good_bcopy=no])
1367 if test "$cf_cv_good_bcopy" = yes ; then
1368 AC_DEFINE(USE_OK_BCOPY)
1370 AC_DEFINE(USE_MY_MEMMOVE)
1373 dnl ---------------------------------------------------------------------------
1374 dnl CF_FUNC_NANOSLEEP version: 3 updated: 2006/12/16 12:33:30
1375 dnl -----------------
1376 dnl Check for existence of workable nanosleep() function. Some systems, e.g.,
1377 dnl AIX 4.x, provide a non-working version.
1378 AC_DEFUN([CF_FUNC_NANOSLEEP],[
1379 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
1385 #ifdef HAVE_SYS_TIME_H
1386 #include <sys/time.h>
1390 struct timespec ts1, ts2;
1393 ts1.tv_nsec = 750000000;
1397 code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
1398 ${cf_cv_main_return:-return}(code != 0);
1401 [cf_cv_func_nanosleep=yes],
1402 [cf_cv_func_nanosleep=no],
1403 [cf_cv_func_nanosleep=unknown])])
1405 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP)
1407 dnl ---------------------------------------------------------------------------
1408 dnl CF_FUNC_OPENPTY version: 3 updated: 2010/05/29 16:31:02
1410 dnl Check for openpty() function, along with <pty.h> header. It may need the
1411 dnl "util" library as well.
1412 AC_DEFUN([CF_FUNC_OPENPTY],
1414 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1415 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1416 cf_save_LIBS="$LIBS"
1417 test $cf_cv_lib_util = yes && CF_ADD_LIB(util)
1418 for cf_header in pty.h libutil.h util.h
1421 #include <$cf_header>
1423 int x = openpty((int *)0, (int *)0, (char *)0,
1424 (struct termios *)0, (struct winsize *)0);
1426 cf_cv_func_openpty=$cf_header
1429 cf_cv_func_openpty=no
1432 LIBS="$cf_save_LIBS"
1435 dnl ---------------------------------------------------------------------------
1436 dnl CF_FUNC_POLL version: 4 updated: 2006/12/16 12:33:30
1438 dnl See if the poll function really works. Some platforms have poll(), but
1439 dnl it does not work for terminals or files.
1440 AC_DEFUN([CF_FUNC_POLL],[
1441 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1447 #include <sys/poll.h>
1450 struct pollfd myfds;
1454 myfds.events = POLLIN;
1456 ret = poll(&myfds, 1, 100);
1457 ${cf_cv_main_return:-return}(ret != 0);
1459 [cf_cv_working_poll=yes],
1460 [cf_cv_working_poll=no],
1461 [cf_cv_working_poll=unknown])])
1462 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
1464 dnl ---------------------------------------------------------------------------
1465 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
1467 dnl Some old/broken variations define tcgetattr() only as a macro in
1469 AC_DEFUN([CF_FUNC_TERMIOS],[
1470 AC_REQUIRE([CF_STRUCT_TERMIOS])
1471 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1473 #include <sys/types.h>
1474 #ifdef HAVE_UNISTD_H
1477 #ifdef HAVE_TERMIOS_H
1478 #include <termios.h>
1479 #define TTY struct termios
1481 #ifdef HAVE_TERMIO_H
1483 #define TTY struct termio
1488 tcgetattr(1, &foo);],
1489 [cf_cv_have_tcgetattr=yes],
1490 [cf_cv_have_tcgetattr=no])])
1491 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
1493 dnl ---------------------------------------------------------------------------
1494 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
1496 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1497 dnl versions of C. It is in the GNU C library, and can often be simulated by
1498 dnl other functions.
1499 AC_DEFUN([CF_FUNC_VSSCANF],
1501 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1504 #include <stdio.h>],[
1506 vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1509 #include <stdio.h>],[
1513 strbuf._flag = _IOREAD;
1514 strbuf._ptr = strbuf._base = (unsigned char *) str;
1515 strbuf._cnt = strlen(str);
1516 strbuf._file = _NFILE;
1517 return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1520 #include <stdio.h>],[
1524 strbuf._flag = _IOREAD;
1525 strbuf._ptr = strbuf._base = (unsigned char *) str;
1526 strbuf._cnt = strlen(str);
1527 strbuf._file = _NFILE;
1528 return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1529 cf_cv_func_vsscanf=no])])])])
1531 case $cf_cv_func_vsscanf in #(vi
1532 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
1533 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
1534 _doscan) AC_DEFINE(HAVE__DOSCAN);;
1538 dnl ---------------------------------------------------------------------------
1539 dnl CF_GCC_ATTRIBUTES version: 14 updated: 2010/10/23 15:52:32
1540 dnl -----------------
1541 dnl Test for availability of useful gcc __attribute__ directives to quiet
1542 dnl compiler warnings. Though useful, not all are supported -- and contrary
1543 dnl to documentation, unrecognized directives cause older compilers to barf.
1544 AC_DEFUN([CF_GCC_ATTRIBUTES],
1546 if test "$GCC" = yes
1548 cat > conftest.i <<EOF
1550 #define GCC_PRINTF 0
1555 #ifndef GCC_NORETURN
1556 #define GCC_NORETURN /* nothing */
1559 #define GCC_UNUSED /* nothing */
1562 if test "$GCC" = yes
1564 AC_CHECKING([for $CC __attribute__ directives])
1565 cat > conftest.$ac_ext <<EOF
1566 #line __oline__ "${as_me:-configure}"
1567 #include "confdefs.h"
1568 #include "conftest.h"
1569 #include "conftest.i"
1571 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1573 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1576 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1578 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
1580 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1581 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1582 extern void foo(void) GCC_NORETURN;
1583 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1585 cf_printf_attribute=no
1586 cf_scanf_attribute=no
1587 for cf_attribute in scanf printf unused noreturn
1589 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1590 cf_directive="__attribute__(($cf_attribute))"
1591 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1593 case $cf_attribute in #(vi
1595 cf_printf_attribute=yes
1596 cat >conftest.h <<EOF
1597 #define GCC_$cf_ATTRIBUTE 1
1601 cf_scanf_attribute=yes
1602 cat >conftest.h <<EOF
1603 #define GCC_$cf_ATTRIBUTE 1
1607 cat >conftest.h <<EOF
1608 #define GCC_$cf_ATTRIBUTE $cf_directive
1613 if AC_TRY_EVAL(ac_compile); then
1614 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1615 cat conftest.h >>confdefs.h
1616 case $cf_attribute in #(vi
1618 if test "$cf_printf_attribute" = no ; then
1619 cat >>confdefs.h <<EOF
1620 #define GCC_PRINTFLIKE(fmt,var) /* nothing */
1623 cat >>confdefs.h <<EOF
1624 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1629 if test "$cf_scanf_attribute" = no ; then
1630 cat >>confdefs.h <<EOF
1631 #define GCC_SCANFLIKE(fmt,var) /* nothing */
1634 cat >>confdefs.h <<EOF
1635 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1643 fgrep define conftest.i >>confdefs.h
1648 dnl ---------------------------------------------------------------------------
1649 dnl CF_GCC_VERSION version: 5 updated: 2010/04/24 11:02:31
1651 dnl Find version of gcc
1652 AC_DEFUN([CF_GCC_VERSION],[
1653 AC_REQUIRE([AC_PROG_CC])
1655 if test "$GCC" = yes ; then
1656 AC_MSG_CHECKING(version of $CC)
1657 GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1658 test -z "$GCC_VERSION" && GCC_VERSION=unknown
1659 AC_MSG_RESULT($GCC_VERSION)
1662 dnl ---------------------------------------------------------------------------
1663 dnl CF_GCC_WARNINGS version: 27 updated: 2010/10/23 15:52:32
1665 dnl Check if the compiler supports useful warning options. There's a few that
1666 dnl we don't use, simply because they're too noisy:
1668 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1669 dnl -Wredundant-decls (system headers make this too noisy)
1670 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
1671 dnl -Wwrite-strings (too noisy, but should review occasionally). This
1672 dnl is enabled for ncurses using "--enable-const".
1676 dnl $1 is an optional list of gcc warning flags that a particular
1677 dnl application might want to use, e.g., "no-unused" for
1680 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1682 AC_DEFUN([CF_GCC_WARNINGS],
1684 AC_REQUIRE([CF_GCC_VERSION])
1685 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1687 cat > conftest.$ac_ext <<EOF
1688 #line __oline__ "${as_me:-configure}"
1689 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1692 if test "$INTEL_COMPILER" = yes
1694 # The "-wdXXX" options suppress warnings:
1695 # remark #1419: external declaration in primary source file
1696 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1697 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1698 # remark #193: zero used for undefined preprocessing identifier
1699 # remark #593: variable "curs_sb_left_arrow" was set but never used
1700 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1701 # remark #869: parameter "tw" was never referenced
1702 # remark #981: operands are evaluated in unspecified order
1703 # warning #279: controlling expression is constant
1705 AC_CHECKING([for $CC warning options])
1706 cf_save_CFLAGS="$CFLAGS"
1707 EXTRA_CFLAGS="-Wall"
1719 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1720 if AC_TRY_EVAL(ac_compile); then
1721 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1722 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1725 CFLAGS="$cf_save_CFLAGS"
1727 elif test "$GCC" = yes
1729 AC_CHECKING([for $CC warning options])
1730 cf_save_CFLAGS="$CFLAGS"
1733 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1734 for cf_opt in W Wall \
1735 Wbad-function-cast \
1739 Wmissing-declarations \
1740 Wmissing-prototypes \
1744 Wstrict-prototypes \
1745 Wundef $cf_warn_CONST $1
1747 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1748 if AC_TRY_EVAL(ac_compile); then
1749 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1750 case $cf_opt in #(vi
1752 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1755 case $GCC_VERSION in
1757 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1762 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1765 CFLAGS="$cf_save_CFLAGS"
1769 AC_SUBST(EXTRA_CFLAGS)
1771 dnl ---------------------------------------------------------------------------
1772 dnl CF_GNAT_PRAGMA_UNREF version: 1 updated: 2010/06/19 15:22:18
1773 dnl --------------------
1774 dnl Check if the gnat pragma "Unreferenced" works.
1775 AC_DEFUN([CF_GNAT_PRAGMA_UNREF],[
1776 AC_CACHE_CHECK(if GNAT pragma Unreferenced works,cf_cv_pragma_unreferenced,[
1777 CF_GNAT_TRY_LINK([procedure conftest;],
1780 procedure conftest is
1782 pragma Unreferenced (test);
1785 Text_IO.Put ("Hello World");
1787 GNAT.OS_Lib.OS_Exit (0);
1789 [cf_cv_pragma_unreferenced=yes],
1790 [cf_cv_pragma_unreferenced=no])])
1792 # if the pragma is supported, use it (needed in the Trace code).
1793 if test $cf_cv_pragma_unreferenced = yes ; then
1798 AC_SUBST(PRAGMA_UNREF)
1800 dnl ---------------------------------------------------------------------------
1801 dnl CF_GNAT_TRY_LINK version: 2 updated: 2010/08/14 18:25:37
1802 dnl ----------------
1803 dnl Verify that a test program compiles/links with GNAT.
1804 dnl $cf_ada_make is set to the program that compiles/links
1805 dnl $ADAFLAGS may be set to the GNAT flags.
1807 dnl $1 is the text of the spec
1808 dnl $2 is the text of the body
1809 dnl $3 is the shell command to execute if successful
1810 dnl $4 is the shell command to execute if not successful
1811 AC_DEFUN([CF_GNAT_TRY_LINK],
1814 cat >>conftest.ads <<CF_EOF
1817 cat >>conftest.adb <<CF_EOF
1820 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1821 ifelse($3,, :,[ $3])
1827 dnl ---------------------------------------------------------------------------
1828 dnl CF_GNAT_TRY_RUN version: 4 updated: 2010/08/14 18:25:37
1830 dnl Verify that a test program compiles and runs with GNAT
1831 dnl $cf_ada_make is set to the program that compiles/links
1832 dnl $ADAFLAGS may be set to the GNAT flags.
1834 dnl $1 is the text of the spec
1835 dnl $2 is the text of the body
1836 dnl $3 is the shell command to execute if successful
1837 dnl $4 is the shell command to execute if not successful
1838 AC_DEFUN([CF_GNAT_TRY_RUN],
1841 cat >>conftest.ads <<CF_EOF
1844 cat >>conftest.adb <<CF_EOF
1847 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1848 if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1849 ifelse($3,, :,[ $3])
1858 dnl ---------------------------------------------------------------------------
1859 dnl CF_GNAT_VERSION version: 15 updated: 2010/10/23 15:52:32
1861 dnl Verify version of GNAT.
1862 AC_DEFUN([CF_GNAT_VERSION],
1864 AC_MSG_CHECKING(for gnat version)
1865 cf_gnat_version=`${cf_ada_make:-gnatmake} -v 2>&1 | grep '[[0-9]].[[0-9]][[0-9]]*' |\
1866 sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1867 AC_MSG_RESULT($cf_gnat_version)
1869 case $cf_gnat_version in
1870 3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*)
1871 cf_cv_prog_gnat_correct=yes
1873 *) echo Unsupported GNAT version $cf_gnat_version. Required is 3.11 or better. Disabling Ada95 binding.
1874 cf_cv_prog_gnat_correct=no
1878 case $cf_gnat_version in
1879 3.[[1-9]]*|[[4-9]].*)
1880 cf_compile_generics=generics
1881 cf_generic_objects="\${GENOBJS}"
1883 *) cf_compile_generics=
1888 case $cf_gnat_version in
1890 USE_OLD_MAKERULES=""
1891 USE_GNAT_PROJECTS="#"
1894 USE_OLD_MAKERULES="#"
1895 USE_GNAT_PROJECTS=""
1899 AC_SUBST(cf_compile_generics)
1900 AC_SUBST(cf_generic_objects)
1902 AC_SUBST(USE_OLD_MAKERULES)
1903 AC_SUBST(USE_GNAT_PROJECTS)
1905 dnl ---------------------------------------------------------------------------
1906 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1908 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1909 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
1910 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1911 dnl since it is interwoven with GNU extensions.
1913 dnl Well, yes we could work around it...
1914 AC_DEFUN([CF_GNU_SOURCE],
1916 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1917 AC_TRY_COMPILE([#include <sys/types.h>],[
1918 #ifndef _XOPEN_SOURCE
1921 [cf_cv_gnu_source=no],
1922 [cf_save="$CPPFLAGS"
1923 CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1924 AC_TRY_COMPILE([#include <sys/types.h>],[
1925 #ifdef _XOPEN_SOURCE
1928 [cf_cv_gnu_source=no],
1929 [cf_cv_gnu_source=yes])
1933 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1935 dnl ---------------------------------------------------------------------------
1936 dnl CF_GPP_LIBRARY version: 10 updated: 2010/05/29 16:31:02
1938 dnl If we're trying to use g++, test if libg++ is installed (a rather common
1939 dnl problem :-). If we have the compiler but no library, we'll be able to
1940 dnl configure, but won't be able to build the c++ demo program.
1941 AC_DEFUN([CF_GPP_LIBRARY],
1943 cf_cxx_library=unknown
1944 case $cf_cv_system_name in #(vi
1952 if test "$GXX" = yes; then
1953 AC_MSG_CHECKING([for lib$cf_gpp_libname])
1955 CF_ADD_LIB($cf_gpp_libname)
1957 #include <$cf_gpp_libname/builtin.h>
1959 [two_arg_error_handler_t foo2 = lib_error_handler],
1961 CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
1962 if test "$cf_gpp_libname" = cpp ; then
1963 AC_DEFINE(HAVE_GPP_BUILTIN_H)
1965 AC_DEFINE(HAVE_GXX_BUILTIN_H)
1968 #include <builtin.h>
1970 [two_arg_error_handler_t foo2 = lib_error_handler],
1972 CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
1973 AC_DEFINE(HAVE_BUILTIN_H)],
1974 [cf_cxx_library=no])])
1976 AC_MSG_RESULT($cf_cxx_library)
1979 dnl ---------------------------------------------------------------------------
1980 dnl CF_GXX_VERSION version: 6 updated: 2010/10/23 15:44:18
1982 dnl Check for version of g++
1983 AC_DEFUN([CF_GXX_VERSION],[
1984 AC_REQUIRE([AC_PROG_CPP])
1986 if test "$GXX" = yes; then
1987 AC_MSG_CHECKING(version of g++)
1988 GXX_VERSION="`${CXX:-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1989 test -z "$GXX_VERSION" && GXX_VERSION=unknown
1990 AC_MSG_RESULT($GXX_VERSION)
1993 dnl ---------------------------------------------------------------------------
1994 dnl CF_GXX_WARNINGS version: 6 updated: 2010/08/14 18:25:37
1996 dnl Check if the compiler supports useful warning options.
1998 dnl Most of gcc's options apply to g++, except:
1999 dnl -Wbad-function-cast
2000 dnl -Wmissing-declarations
2001 dnl -Wnested-externs
2003 dnl Omit a few (for now):
2007 dnl $1 is an optional list of g++ warning flags that a particular
2008 dnl application might want to use, e.g., "no-unused" for
2011 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
2013 AC_DEFUN([CF_GXX_WARNINGS],
2016 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
2018 AC_REQUIRE([CF_GXX_VERSION])
2023 cat > conftest.$ac_ext <<EOF
2024 #line __oline__ "configure"
2025 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2028 if test "$INTEL_CPLUSPLUS" = yes
2030 # The "-wdXXX" options suppress warnings:
2031 # remark #1419: external declaration in primary source file
2032 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2033 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2034 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2035 # remark #193: zero used for undefined preprocessing identifier
2036 # remark #593: variable "curs_sb_left_arrow" was set but never used
2037 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2038 # remark #869: parameter "tw" was never referenced
2039 # remark #981: operands are evaluated in unspecified order
2040 # warning #269: invalid format string conversion
2042 AC_CHECKING([for $CC warning options])
2043 cf_save_CXXFLAGS="$CXXFLAGS"
2044 EXTRA_CXXFLAGS="-Wall"
2057 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
2058 if AC_TRY_EVAL(ac_compile); then
2059 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2060 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2063 CXXFLAGS="$cf_save_CXXFLAGS"
2065 elif test "$GXX" = yes
2067 AC_CHECKING([for $CXX warning options])
2068 cf_save_CXXFLAGS="$CXXFLAGS"
2069 EXTRA_CXXFLAGS="-W -Wall"
2070 cf_gxx_extra_warnings=""
2071 test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
2072 case "$GCC_VERSION" in
2076 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
2082 Woverloaded-virtual \
2088 Wmissing-prototypes \
2091 Wstrict-prototypes \
2092 Wundef $cf_gxx_extra_warnings $1
2094 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
2095 if AC_TRY_EVAL(ac_compile); then
2096 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2097 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2099 test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
2102 CXXFLAGS="$cf_save_CXXFLAGS"
2107 AC_SUBST(EXTRA_CXXFLAGS)
2109 dnl ---------------------------------------------------------------------------
2110 dnl CF_HASHED_DB version: 4 updated: 2010/05/29 16:31:02
2112 dnl Look for an instance of the Berkeley hashed database.
2114 dnl $1 = optional parameter, to specify install-prefix for the database.
2115 AC_DEFUN([CF_HASHED_DB],
2122 if test -d "$1" ; then
2123 CF_ADD_INCDIR($1/include)
2124 CF_ADD_LIBDIR($1/lib)
2128 AC_CHECK_HEADER(db.h,[
2129 CF_HASHED_DB_VERSION
2130 if test "$cf_cv_hashed_db_version" = unknown ; then
2131 AC_MSG_ERROR(Cannot determine version of db)
2134 if test "$cf_cv_hashed_db_libs" = unknown ; then
2135 AC_MSG_ERROR(Cannot determine library for db)
2136 elif test "$cf_cv_hashed_db_libs" != default ; then
2137 CF_ADD_LIB($cf_cv_hashed_db_libs)
2141 AC_MSG_ERROR(Cannot find db.h)
2144 dnl ---------------------------------------------------------------------------
2145 dnl CF_HASHED_DB_LIBS version: 9 updated: 2010/05/29 16:31:02
2146 dnl -----------------
2147 dnl Given that we have the header and version for hashed database, find the
2148 dnl library information.
2149 AC_DEFUN([CF_HASHED_DB_LIBS],
2151 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
2152 cf_cv_hashed_db_libs=unknown
2153 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
2155 cf_save_libs="$LIBS"
2156 if test -n "$cf_db_libs"; then
2157 CF_ADD_LIB($cf_db_libs)
2159 CF_MSG_LOG(checking for library "$cf_db_libs")
2161 $ac_includes_default
2164 char *path = "/tmp/foo";
2165 #ifdef DB_VERSION_MAJOR
2166 #if DB_VERSION_MAJOR >= 4
2168 db_create(&result, NULL, 0);
2169 result->open(result,
2176 #elif DB_VERSION_MAJOR >= 3
2178 db_create(&result, NULL, 0);
2179 result->open(result,
2185 #elif DB_VERSION_MAJOR >= 2
2194 #endif /* DB_VERSION_MAJOR */
2196 DB *result = dbopen(path,
2202 ${cf_cv_main_return:-return}(result != 0)
2204 if test -n "$cf_db_libs" ; then
2205 cf_cv_hashed_db_libs=$cf_db_libs
2207 cf_cv_hashed_db_libs=default
2209 LIBS="$cf_save_libs"
2212 LIBS="$cf_save_libs"
2216 dnl ---------------------------------------------------------------------------
2217 dnl CF_HASHED_DB_VERSION version: 3 updated: 2007/12/01 15:01:37
2218 dnl --------------------
2219 dnl Given that we have the header file for hashed database, find the version
2221 AC_DEFUN([CF_HASHED_DB_VERSION],
2223 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
2224 cf_cv_hashed_db_version=unknown
2226 for cf_db_version in 1 2 3 4 5
2228 CF_MSG_LOG(checking for db version $cf_db_version)
2230 $ac_includes_default
2233 #ifdef DB_VERSION_MAJOR
2234 /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
2235 #if $cf_db_version == DB_VERSION_MAJOR
2241 #if $cf_db_version == 1
2242 /* ok: assuming this is DB 1.8.5 */
2248 cf_cv_hashed_db_version=$cf_db_version
2254 dnl ---------------------------------------------------------------------------
2255 dnl CF_HEADER_PATH version: 12 updated: 2010/05/05 05:22:40
2257 dnl Construct a search-list of directories for a nonstandard header-file
2260 dnl $1 = the variable to return as result
2261 dnl $2 = the package name
2262 AC_DEFUN([CF_HEADER_PATH],
2266 # collect the current set of include-directories from compiler flags
2267 cf_header_path_list=""
2268 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2269 for cf_header_path in $CPPFLAGS $CFLAGS
2271 case $cf_header_path in #(vi
2273 cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2274 CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2275 cf_header_path_list="$cf_header_path_list [$]$1"
2281 # add the variations for the package we are looking for
2282 CF_SUBDIR_PATH($1,$2,include)
2284 test "$includedir" != NONE && \
2285 test "$includedir" != "/usr/include" && \
2286 test -d "$includedir" && {
2287 test -d $includedir && $1="[$]$1 $includedir"
2288 test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
2291 test "$oldincludedir" != NONE && \
2292 test "$oldincludedir" != "/usr/include" && \
2293 test -d "$oldincludedir" && {
2294 test -d $oldincludedir && $1="[$]$1 $oldincludedir"
2295 test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
2298 $1="[$]$1 $cf_header_path_list"
2300 dnl ---------------------------------------------------------------------------
2301 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
2303 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2304 AC_DEFUN([CF_HELP_MESSAGE],
2305 [AC_DIVERT_HELP([$1])dnl
2307 dnl ---------------------------------------------------------------------------
2308 dnl CF_INCLUDE_DIRS version: 6 updated: 2009/01/06 19:37:40
2310 dnl Construct the list of include-options according to whether we're building
2311 dnl in the source directory or using '--srcdir=DIR' option. If we're building
2312 dnl with gcc, don't append the includedir if it happens to be /usr/include,
2313 dnl since that usually breaks gcc's shadow-includes.
2314 AC_DEFUN([CF_INCLUDE_DIRS],
2316 CPPFLAGS="$CPPFLAGS -I. -I../include"
2317 if test "$srcdir" != "."; then
2318 CPPFLAGS="$CPPFLAGS -I\${srcdir}/../include"
2320 if test "$GCC" != yes; then
2321 CPPFLAGS="$CPPFLAGS -I\${includedir}"
2322 elif test "$includedir" != "/usr/include"; then
2323 if test "$includedir" = '${prefix}/include' ; then
2324 if test $prefix != /usr ; then
2325 CPPFLAGS="$CPPFLAGS -I\${includedir}"
2328 CPPFLAGS="$CPPFLAGS -I\${includedir}"
2333 dnl ---------------------------------------------------------------------------
2334 dnl CF_INTEL_COMPILER version: 4 updated: 2010/05/26 05:38:42
2335 dnl -----------------
2336 dnl Check if the given compiler is really the Intel compiler for Linux. It
2337 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2338 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2340 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2341 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
2342 dnl the wrappers for gcc and g++ warnings.
2344 dnl $1 = GCC (default) or GXX
2345 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2346 dnl $3 = CFLAGS (default) or CXXFLAGS
2347 AC_DEFUN([CF_INTEL_COMPILER],[
2348 ifelse([$2],,INTEL_COMPILER,[$2])=no
2350 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2353 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2354 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2355 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2357 #ifdef __INTEL_COMPILER
2361 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2362 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
2364 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2365 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2370 dnl ---------------------------------------------------------------------------
2371 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
2373 dnl Check if we have either a function or macro for 'isascii()'.
2374 AC_DEFUN([CF_ISASCII],
2376 AC_MSG_CHECKING(for isascii)
2377 AC_CACHE_VAL(cf_cv_have_isascii,[
2378 AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
2379 [cf_cv_have_isascii=yes],
2380 [cf_cv_have_isascii=no])
2382 AC_MSG_RESULT($cf_cv_have_isascii)
2383 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
2385 dnl ---------------------------------------------------------------------------
2386 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
2388 dnl Add checks for large file support.
2389 AC_DEFUN([CF_LARGEFILE],[
2390 ifdef([AC_FUNC_FSEEKO],[
2392 if test "$enable_largefile" != no ; then
2395 # Normally we would collect these definitions in the config.h,
2396 # but (like _XOPEN_SOURCE), some environments rely on having these
2397 # defined before any of the system headers are included. Another
2398 # case comes up with C++, e.g., on AIX the compiler compiles the
2399 # header files by themselves before looking at the body files it is
2400 # told to compile. For ncurses, those header files do not include
2402 test "$ac_cv_sys_large_files" != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
2403 test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
2404 test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
2406 AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2408 #include <sys/types.h>
2411 /* if transitional largefile support is setup, this is true */
2412 extern struct dirent64 * readdir(DIR *);
2413 struct dirent64 *x = readdir((DIR *)0);
2414 struct dirent *y = readdir((DIR *)0);
2417 [cf_cv_struct_dirent64=yes],
2418 [cf_cv_struct_dirent64=no])
2420 test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
2424 dnl ---------------------------------------------------------------------------
2425 dnl CF_LDFLAGS_STATIC version: 8 updated: 2010/10/23 14:39:56
2426 dnl -----------------
2427 dnl Check for compiler/linker flags used to temporarily force usage of static
2428 dnl libraries. This depends on the compiler and platform. Use this to help
2429 dnl ensure that the linker picks up a given library based on its position in
2430 dnl the list of linker options and libraries.
2431 AC_DEFUN([CF_LDFLAGS_STATIC],[
2433 if test "$GCC" = yes ; then
2434 case $cf_cv_system_name in #(
2435 OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*) #( vi
2439 *) #( normally, except when broken
2440 LDFLAGS_STATIC=-static
2441 LDFLAGS_SHARED=-dynamic
2445 case $cf_cv_system_name in #(
2446 aix[[456]]*) #( from ld manpage
2447 LDFLAGS_STATIC=-bstatic
2448 LDFLAGS_SHARED=-bdynamic
2450 hpux*) #( from ld manpage for hpux10.20, hpux11.11
2451 # We could also use just "archive" and "shared".
2452 LDFLAGS_STATIC=-Wl,-a,archive_shared
2453 LDFLAGS_SHARED=-Wl,-a,shared_archive
2455 irix*) #( from ld manpage IRIX64
2456 LDFLAGS_STATIC=-Bstatic
2457 LDFLAGS_SHARED=-Bdynamic
2459 osf[[45]]*) #( from ld manpage osf4.0d, osf5.1
2460 # alternative "-oldstyle_liblookup" (not in cc manpage)
2461 LDFLAGS_STATIC=-noso
2462 LDFLAGS_SHARED=-so_archive
2465 LDFLAGS_STATIC=-Bstatic
2466 LDFLAGS_SHARED=-Bdynamic
2471 if test -n "$LDFLAGS_STATIC" && test -n "$LDFLAGS_SHARED"
2473 AC_MSG_CHECKING(if linker supports switching between static/dynamic)
2476 cat >conftest.$ac_ext <<EOF
2477 #line __oline__ "configure"
2479 int cf_ldflags_static(FILE *fp) { return fflush(fp); }
2481 if AC_TRY_EVAL(ac_compile) ; then
2482 ( $AR $ARFLAGS libconftest.a conftest.o ) 2>&AC_FD_CC 1>/dev/null
2483 ( eval $RANLIB libconftest.a ) 2>&AC_FD_CC >/dev/null
2487 cf_save_LIBS="$LIBS"
2489 LIBS="$LDFLAGS_STATIC -L`pwd` -lconftest $LDFLAGS_DYNAMIC $LIBS"
2491 #line __oline__ "configure"
2493 int cf_ldflags_static(FILE *fp);
2495 return cf_ldflags_static(stdin);
2496 ],[cf_ldflags_static=yes],[cf_ldflags_static=no])
2499 LIBS="$cf_save_LIBS"
2501 AC_MSG_RESULT($cf_ldflags_static)
2503 if test $cf_ldflags_static != yes
2513 AC_SUBST(LDFLAGS_STATIC)
2514 AC_SUBST(LDFLAGS_SHARED)
2516 dnl ---------------------------------------------------------------------------
2517 dnl CF_LD_RPATH_OPT version: 3 updated: 2010/06/02 05:03:05
2519 dnl For the given system and compiler, find the compiler flags to pass to the
2520 dnl loader to use the "rpath" feature.
2521 AC_DEFUN([CF_LD_RPATH_OPT],
2523 AC_REQUIRE([CF_CHECK_CACHE])
2526 AC_MSG_CHECKING(for an rpath option)
2527 case $cf_cv_system_name in #(vi
2529 if test "$GCC" = yes; then
2530 LD_RPATH_OPT="-Wl,-rpath,"
2532 LD_RPATH_OPT="-rpath "
2535 linux*|gnu*|k*bsd*-gnu) #(vi
2536 LD_RPATH_OPT="-Wl,-rpath,"
2538 openbsd[[2-9]].*) #(vi
2539 LD_RPATH_OPT="-Wl,-rpath,"
2542 LD_RPATH_OPT="-rpath "
2545 LD_RPATH_OPT="-Wl,-rpath,"
2548 LD_RPATH_OPT="-rpath "
2556 AC_MSG_RESULT($LD_RPATH_OPT)
2558 case "x$LD_RPATH_OPT" in #(vi
2560 AC_MSG_CHECKING(if we need a space after rpath option)
2561 cf_save_LIBS="$LIBS"
2562 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2563 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2564 LIBS="$cf_save_LIBS"
2565 AC_MSG_RESULT($cf_rpath_space)
2566 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2570 dnl ---------------------------------------------------------------------------
2571 dnl CF_LIBRARY_PATH version: 9 updated: 2010/03/28 12:52:50
2573 dnl Construct a search-list of directories for a nonstandard library-file
2576 dnl $1 = the variable to return as result
2577 dnl $2 = the package name
2578 AC_DEFUN([CF_LIBRARY_PATH],
2581 cf_library_path_list=""
2582 if test -n "${LDFLAGS}${LIBS}" ; then
2583 for cf_library_path in $LDFLAGS $LIBS
2585 case $cf_library_path in #(vi
2587 cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2588 CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2589 cf_library_path_list="$cf_library_path_list [$]$1"
2595 CF_SUBDIR_PATH($1,$2,lib)
2597 $1="$cf_library_path_list [$]$1"
2599 dnl ---------------------------------------------------------------------------
2600 dnl CF_LIB_PREFIX version: 8 updated: 2008/09/13 11:34:16
2602 dnl Compute the library-prefix for the given host system
2603 dnl $1 = variable to set
2604 AC_DEFUN([CF_LIB_PREFIX],
2606 case $cf_cv_system_name in #(vi
2613 ifelse($1,,,[$1=$LIB_PREFIX])
2614 AC_SUBST(LIB_PREFIX)
2616 dnl ---------------------------------------------------------------------------
2617 dnl CF_LIB_RULES version: 61 updated: 2010/10/23 16:10:30
2619 dnl Append definitions and rules for the given models to the subdirectory
2620 dnl Makefiles, and the recursion rule for the top-level Makefile. If the
2621 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
2622 dnl the corresponding makefile to list the models that we'll generate.
2624 dnl For shared libraries, make a list of symbolic links to construct when
2625 dnl generating each library. The convention used for Linux is the simplest
2628 dnl lib<name>.so.<major> ->
2629 dnl lib<name>.so.<maj>.<minor>
2630 AC_DEFUN([CF_LIB_RULES],
2632 CF_LIB_PREFIX(cf_prefix)
2633 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2635 if test $cf_cv_shlib_version = cygdll ; then
2636 TINFO_NAME=$TINFO_ARG_SUFFIX
2640 if test -n "$TINFO_SUFFIX" ; then
2641 case $TINFO_SUFFIX in
2643 TINFO_NAME="${TINFO_NAME}tw"
2644 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^tw//'`
2647 TINFO_NAME="${TINFO_NAME}t"
2648 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^t//'`
2651 TINFO_NAME="${TINFO_NAME}w"
2652 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^w//'`
2657 for cf_dir in $SRC_SUBDIRS
2659 if test ! -d $srcdir/$cf_dir ; then
2661 elif test -f $srcdir/$cf_dir/modules; then
2665 for cf_item in $cf_LIST_MODELS
2667 CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2668 if test $cf_item = shared ; then
2669 if test "$cf_cv_do_symlinks" = yes ; then
2670 case "$cf_cv_shlib_version" in #(vi
2672 case "$cf_cv_system_name" in #(vi
2674 case .${LIB_SUFFIX} in
2676 cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
2677 cf_suffix=tw'.${REL_VERSION}'"$cf_suffix"
2680 cf_suffix=`echo $cf_suffix | sed 's/^t//'`
2681 cf_suffix=t'.${REL_VERSION}'"$cf_suffix"
2684 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2685 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
2688 cf_suffix='.${REL_VERSION}'"$cf_suffix"
2692 *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
2696 case "$cf_cv_system_name" in #(vi
2698 case .${LIB_SUFFIX} in
2700 cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
2701 cf_suffix=tw'.${ABI_VERSION}'"$cf_suffix"
2704 cf_suffix=`echo $cf_suffix | sed 's/^t//'`
2705 cf_suffix=t'.${ABI_VERSION}'"$cf_suffix"
2708 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2709 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
2712 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
2716 *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
2721 # cygwin needs import library, and has unique naming convention
2722 # use autodetected ${cf_prefix} for import lib and static lib, but
2723 # use 'cyg' prefix for shared lib.
2724 if test $cf_cv_shlib_version = cygdll ; then
2725 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
2726 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}${cf_cygsuf}"
2730 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
2733 if test $cf_dir = ncurses ; then
2734 cf_subsets="$LIB_SUBSETS"
2735 cf_r_parts="$cf_subsets"
2736 cf_liblist="$LIBS_TO_MAKE"
2738 while test -n "$cf_r_parts"
2740 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
2741 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
2742 if test "$cf_l_parts" != "$cf_r_parts" ; then
2744 case $cf_l_parts in #(vi
2746 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
2749 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
2755 if test -n "$cf_item"; then
2756 LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
2763 cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
2766 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
2767 -e "s%@SHARED_LIB@%$SHARED_LIB%" \
2768 $cf_dir/Makefile >$cf_dir/Makefile.out
2769 mv $cf_dir/Makefile.out $cf_dir/Makefile
2771 $AWK -f $srcdir/mk-0th.awk \
2772 libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
2773 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2775 for cf_subset in $cf_subsets
2778 for cf_item in $cf_LIST_MODELS
2780 echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
2781 CF_UPPER(cf_ITEM,$cf_item)
2782 CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2783 CF_OBJ_SUBDIR($cf_item,cf_subdir)
2785 # Test for case where we build libtinfo with a different name.
2787 if test $cf_dir = ncurses ; then
2790 cf_libname=${cf_libname}$LIB_SUFFIX
2793 cf_libname=$TINFO_LIB_SUFFIX
2796 cf_libname=$TICS_LIB_SUFFIX
2800 cf_libname=${cf_libname}$LIB_SUFFIX
2802 if test -n "${DFT_ARG_SUFFIX}" ; then
2803 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2804 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2807 # These dependencies really are for development, not
2808 # builds, but they are useful in porting, too.
2809 cf_depend="../include/ncurses_cfg.h"
2810 if test "$srcdir" = "."; then
2813 cf_reldir="\${srcdir}"
2816 if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
2817 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
2818 elif test -f $srcdir/$cf_dir/curses.priv.h; then
2819 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
2823 old_cf_suffix="$cf_suffix"
2824 if test "$cf_cv_shlib_version_infix" = yes ; then
2825 if test -n "$LIB_SUFFIX" ; then
2828 cf_libname=`echo $cf_libname | sed 's/tw$//'`
2829 cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
2833 cf_libname=`echo $cf_libname | sed 's/t$//'`
2834 cf_suffix=`echo $cf_suffix | sed 's/^t//'`
2838 cf_libname=`echo $cf_libname | sed 's/w$//'`
2839 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2846 $AWK -f $srcdir/mk-1st.awk \
2847 name=${cf_libname}${cf_dir_suffix} \
2848 traces=$LIB_TRACING \
2855 TermlibRoot=$TINFO_NAME \
2856 TermlibSuffix=$TINFO_SUFFIX \
2857 ShlibVer=$cf_cv_shlib_version \
2858 ShlibVerInfix=$cf_cv_shlib_version_infix \
2859 ReLink=${cf_cv_do_relink:-no} \
2860 DoLinks=$cf_cv_do_symlinks \
2861 rmSoLocs=$cf_cv_rm_so_locs \
2862 ldconfig="$LDCONFIG" \
2863 overwrite=$WITH_OVERWRITE \
2864 depend="$cf_depend" \
2866 libtool_version="$LIBTOOL_VERSION" \
2867 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2869 cf_suffix="$old_cf_suffix"
2871 for cf_subdir2 in $cf_subdirs lib
2873 test $cf_subdir = $cf_subdir2 && break
2875 test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
2876 $AWK -f $srcdir/mk-2nd.awk \
2878 traces=$LIB_TRACING \
2884 crenames=$cf_cv_prog_CC_c_o \
2885 cxxrenames=$cf_cv_prog_CXX_c_o \
2886 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2887 cf_subdirs="$cf_subdirs $cf_subdir"
2892 echo ' cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
2895 for cf_dir in $SRC_SUBDIRS
2897 if test ! -d $srcdir/$cf_dir ; then
2901 if test -f $cf_dir/Makefile ; then
2904 echo 'libs \' >> Makefile
2905 echo 'install.libs \' >> Makefile
2906 echo 'uninstall.libs ::' >> Makefile
2907 echo ' cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
2912 if test -f $srcdir/$cf_dir/modules; then
2914 if test -f $srcdir/$cf_dir/headers; then
2915 cat >> Makefile <<CF_EOF
2917 uninstall.includes \\
2920 if test "$cf_dir" != "c++" ; then
2921 echo 'lint \' >> Makefile
2923 cat >> Makefile <<CF_EOF
2929 uninstall.$cf_dir ::
2930 cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2932 elif test -f $srcdir/$cf_dir/headers; then
2933 cat >> Makefile <<CF_EOF
2939 uninstall.includes ::
2940 cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2945 cat >> Makefile <<CF_EOF
2947 install.libs uninstall.libs \\
2948 install.data uninstall.data ::
2949 $MAKE_TERMINFO cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
2952 if test "x$cf_with_manpages" = xyes; then
2953 cat >> Makefile <<CF_EOF
2957 cd man && \${MAKE} \${CF_MFLAGS} \[$]@
2961 cat >> Makefile <<CF_EOF
2964 rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
2965 rm -f headers.sh headers.sed mk_shared_lib.sh
2966 rm -f edit_man.* man_alias.*
2967 rm -rf \${DIRS_TO_MAKE}
2970 # Special case: tack's manpage lives in its own directory.
2971 if test "x$cf_with_manpages" = xyes; then
2972 if test -d tack ; then
2973 if test -f $srcdir/$tack.h; then
2974 cat >> Makefile <<CF_EOF
2978 cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
2984 dnl If we're installing into a subdirectory of /usr/include, etc., we should
2985 dnl prepend the subdirectory's name to the "#include" paths. It won't hurt
2986 dnl anything, and will make it more standardized. It's awkward to decide this
2987 dnl at configuration because of quoting, so we'll simply make all headers
2988 dnl installed via a script that can do the right thing.
2990 rm -f headers.sed headers.sh
2992 dnl ( generating this script makes the makefiles a little tidier :-)
2993 echo creating headers.sh
2994 cat >headers.sh <<CF_EOF
2996 # This shell script is generated by the 'configure' script. It is invoked in a
2997 # subdirectory of the build tree. It generates a sed-script in the parent
2998 # directory that is used to adjust includes for header files that reside in a
2999 # subdirectory of /usr/include, etc.
3001 while test \[$]# != 3
3003 PRG="\$PRG \[$]1"; shift
3008 TMPSRC=\${TMPDIR:-/tmp}/\`basename \$SRC\`\$\$
3009 TMPSED=\${TMPDIR:-/tmp}/headers.sed\$\$
3010 echo installing \$SRC in \$DST
3013 if test $WITH_CURSES_H = yes; then
3014 cat >>headers.sh <<CF_EOF
3017 END=\`basename \$DST\`
3018 for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
3020 NAME=\`basename \$i\`
3021 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
3031 cat >>headers.sh <<CF_EOF
3034 END=\`basename \$DST\`
3035 for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
3037 NAME=\`basename \$i\`
3038 if test "\$NAME" = "curses.h"
3040 echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
3043 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
3047 echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
3052 cat >>headers.sh <<CF_EOF
3054 sed -f \$TMPSED \$SRC > \$TMPSRC
3055 NAME=\`basename \$SRC\`
3057 if test $WITH_CURSES_H != yes; then
3058 cat >>headers.sh <<CF_EOF
3059 test "\$NAME" = "curses.h" && NAME=ncurses.h
3062 cat >>headers.sh <<CF_EOF
3063 # Just in case someone gzip'd manpages, remove the conflicting copy.
3064 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
3066 eval \$PRG \$TMPSRC \$DST/\$NAME
3067 rm -f \$TMPSRC \$TMPSED
3070 chmod 0755 headers.sh
3072 for cf_dir in $SRC_SUBDIRS
3074 if test ! -d $srcdir/$cf_dir ; then
3078 if test -f $srcdir/$cf_dir/headers; then
3079 $AWK -f $srcdir/mk-hdr.awk \
3080 subset="$LIB_SUBSETS" \
3081 compat="$WITH_CURSES_H" \
3082 $srcdir/$cf_dir/headers >>$cf_dir/Makefile
3085 if test -f $srcdir/$cf_dir/modules; then
3086 if test "$cf_dir" != "c++" ; then
3087 cat >>$cf_dir/Makefile <<"CF_EOF"
3088 depend : ${AUTO_SRC}
3089 makedepend -- ${CPPFLAGS} -- ${C_SRC}
3091 # DO NOT DELETE THIS LINE -- make depend depends on it.
3096 AC_SUBST(LIBS_TO_MAKE)
3098 dnl ---------------------------------------------------------------------------
3099 dnl CF_LIB_SONAME version: 5 updated: 2010/08/14 18:25:37
3101 dnl Find the and soname for the given shared library. Set the cache variable
3102 dnl cf_cv_$3_soname to this, unless it is not found. Then set the cache
3103 dnl variable to "unknown".
3107 dnl $3 = library name
3108 AC_DEFUN([CF_LIB_SONAME],
3110 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
3112 cf_cv_$3_soname=unknown
3113 if test "$cross_compiling" != yes ; then
3114 cat >conftest.$ac_ext <<CF_EOF
3119 ${cf_cv_main_return:-return}(0);
3122 cf_save_LIBS="$LIBS"
3124 if AC_TRY_EVAL(ac_compile) ; then
3125 if AC_TRY_EVAL(ac_link) ; then
3126 cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
3127 test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
3131 LIBS="$cf_save_LIBS"
3135 dnl ---------------------------------------------------------------------------
3136 dnl CF_LIB_SUFFIX version: 16 updated: 2008/12/27 12:30:03
3138 dnl Compute the library file-suffix from the given model name
3140 dnl $2 = variable to set (the nominal library suffix)
3141 dnl $3 = dependency variable to set (actual filename)
3142 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
3143 AC_DEFUN([CF_LIB_SUFFIX],
3145 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
3164 case $cf_cv_system_name in
3194 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3195 test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
3197 dnl ---------------------------------------------------------------------------
3198 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
3200 dnl Compute the string to append to -library from the given model name
3202 dnl $2 = variable to set
3203 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
3204 AC_DEFUN([CF_LIB_TYPE],
3213 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3215 dnl ---------------------------------------------------------------------------
3216 dnl CF_LINK_DATAONLY version: 9 updated: 2009/01/01 20:21:38
3217 dnl ----------------
3218 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
3219 dnl only data (i.e., no functions), for example NeXT. On those systems we'll
3220 dnl have to provide wrappers for global tables to ensure they're linked
3222 AC_DEFUN([CF_LINK_DATAONLY],
3224 AC_MSG_CHECKING([if data-only library module links])
3225 AC_CACHE_VAL(cf_cv_link_dataonly,[
3227 cat >conftest.$ac_ext <<EOF
3228 #line __oline__ "configure"
3229 int testdata[[3]] = { 123, 456, 789 };
3231 if AC_TRY_EVAL(ac_compile) ; then
3232 mv conftest.o data.o && \
3233 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
3235 rm -f conftest.$ac_ext data.o
3236 cat >conftest.$ac_ext <<EOF
3237 #line __oline__ "configure"
3241 ${cf_cv_main_return:-return}(1); /* I'm told this linker is broken */
3243 extern int testdata[[3]];
3244 return testdata[[0]] == 123
3245 && testdata[[1]] == 456
3246 && testdata[[2]] == 789;
3250 if AC_TRY_EVAL(ac_compile); then
3251 mv conftest.o func.o && \
3252 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
3254 rm -f conftest.$ac_ext func.o
3255 ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
3257 LIBS="conftest.a $LIBS"
3261 extern int testfunc();
3262 ${cf_cv_main_return:-return} (!testfunc());
3265 [cf_cv_link_dataonly=yes],
3266 [cf_cv_link_dataonly=no],
3267 [cf_cv_link_dataonly=unknown])
3270 AC_MSG_RESULT($cf_cv_link_dataonly)
3272 if test "$cf_cv_link_dataonly" = no ; then
3273 AC_DEFINE(BROKEN_LINKER)
3278 dnl ---------------------------------------------------------------------------
3279 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
3281 dnl Most Unix systems have both link and symlink, a few don't have symlink.
3282 dnl A few non-Unix systems implement symlink, but not link.
3283 dnl A few non-systems implement neither (or have nonfunctional versions).
3284 AC_DEFUN([CF_LINK_FUNCS],
3290 if test "$cross_compiling" = yes ; then
3295 AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
3297 for cf_func in link symlink ; do
3299 #include <sys/types.h>
3300 #include <sys/stat.h>
3301 #ifdef HAVE_UNISTD_H
3307 char *src = "config.log";
3308 char *dst = "conftest.chk";
3313 fail = ($cf_func("config.log", "conftest.chk") < 0)
3314 || (stat(dst, &dst_sb) < 0)
3315 || (dst_sb.st_mtime != src_sb.st_mtime);
3321 ${cf_cv_main_return:-return} (fail);
3324 cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
3325 eval 'ac_cv_func_'$cf_func'=yes'],[
3326 eval 'ac_cv_func_'$cf_func'=no'],[
3327 eval 'ac_cv_func_'$cf_func'=error'])
3329 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
3331 test "$ac_cv_func_link" = yes && AC_DEFINE(HAVE_LINK)
3332 test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
3335 dnl ---------------------------------------------------------------------------
3336 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
3338 dnl Check if a return from main to the shell actually returns the same exit
3339 dnl code. This is true for almost any POSIX environment.
3341 dnl Some very old environments did not flush stdout, etc., on an exit. That
3342 dnl would be a useful case to test for also.
3343 AC_DEFUN([CF_MAIN_RETURN],
3345 cf_cv_main_return=return
3347 dnl ---------------------------------------------------------------------------
3348 dnl CF_MAKEFLAGS version: 13 updated: 2010/10/23 15:52:32
3350 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
3351 dnl options to lower-levels. It's very useful for "make -n" -- if we have it.
3352 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
3353 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
3354 AC_DEFUN([CF_MAKEFLAGS],
3356 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
3358 for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
3360 cat >cf_makeflags.tmp <<CF_EOF
3363 @ echo '.$cf_option'
3365 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[ ]]*$,,'`
3366 case "$cf_result" in
3368 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
3369 case "$cf_result" in
3370 .*CC=*) cf_cv_makeflags=
3372 *) cf_cv_makeflags=$cf_option
3378 *) echo "given option \"$cf_option\", no match \"$cf_result\""
3382 rm -f cf_makeflags.tmp
3385 AC_SUBST(cf_cv_makeflags)
3387 dnl ---------------------------------------------------------------------------
3388 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
3390 dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have
3391 dnl a monocase filesystem.
3392 AC_DEFUN([CF_MAKE_TAGS],[
3393 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
3395 AC_CHECK_PROGS(CTAGS, exctags ctags)
3396 AC_CHECK_PROGS(ETAGS, exetags etags)
3398 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
3400 if test "$cf_cv_mixedcase" = yes ; then
3401 AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
3406 if test "$MAKE_UPPER_TAGS" = yes ; then
3412 if test "$MAKE_LOWER_TAGS" = yes ; then
3421 AC_SUBST(MAKE_UPPER_TAGS)
3422 AC_SUBST(MAKE_LOWER_TAGS)
3424 dnl ---------------------------------------------------------------------------
3425 dnl CF_MANPAGE_FORMAT version: 9 updated: 2010/10/23 16:10:30
3426 dnl -----------------
3427 dnl Option to allow user to override automatic configuration of manpage format.
3428 dnl There are several special cases:
3430 dnl gzip - man checks for, can display gzip'd files
3431 dnl compress - man checks for, can display compressed files
3432 dnl BSDI - files in the cat-directories are suffixed ".0"
3433 dnl formatted - installer should format (put files in cat-directory)
3434 dnl catonly - installer should only format, e.g., for a turnkey system.
3436 dnl There are other configurations which this macro does not test, e.g., HPUX's
3437 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
3438 dnl convention would not match our use).
3439 AC_DEFUN([CF_MANPAGE_FORMAT],
3441 AC_REQUIRE([CF_PATHSEP])
3442 AC_MSG_CHECKING(format of man-pages)
3444 AC_ARG_WITH(manpage-format,
3445 [ --with-manpage-format specify manpage-format: gzip/compress/BSDI/normal and
3446 optionally formatted/catonly, e.g., gzip,formatted],
3447 [MANPAGE_FORMAT=$withval],
3448 [MANPAGE_FORMAT=unknown])
3450 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
3451 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
3455 case $MANPAGE_FORMAT in
3457 if test -z "$MANPATH" ; then
3458 MANPATH="/usr/man:/usr/share/man"
3461 # look for the 'date' man-page (it's most likely to be installed!)
3467 IFS="${IFS:- }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
3468 for cf_dir in $MANPATH; do
3469 test -z "$cf_dir" && cf_dir=/usr/man
3470 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
3472 cf_test=`echo $cf_name | sed -e 's/*//'`
3473 if test "x$cf_test" = "x$cf_name" ; then
3476 *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
3477 *.Z) MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
3478 *.0) MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
3479 *) MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
3493 # if we found a match in either man* or cat*, stop looking
3494 if test -n "$MANPAGE_FORMAT" ; then
3496 test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
3497 test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
3503 test $cf_found=yes && break
3506 # only check the first directory in $MANPATH where we find manpages
3507 if test -n "$MANPAGE_FORMAT" ; then
3511 # if we did not find the example, just assume it is normal
3512 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
3516 for cf_option in $MANPAGE_FORMAT; do
3517 case $cf_option in #(vi
3518 gzip|compress|BSDI|normal|formatted|catonly)
3521 cf_unknown="$cf_unknown $cf_option"
3528 AC_MSG_RESULT($MANPAGE_FORMAT)
3529 if test -n "$cf_unknown" ; then
3530 AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
3533 dnl ---------------------------------------------------------------------------
3534 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
3535 dnl ------------------
3536 dnl The Debian people have their own naming convention for manpages. This
3537 dnl option lets us override the name of the file containing renaming, or
3538 dnl disable it altogether.
3539 AC_DEFUN([CF_MANPAGE_RENAMES],
3541 AC_MSG_CHECKING(for manpage renaming)
3543 AC_ARG_WITH(manpage-renames,
3544 [ --with-manpage-renames specify manpage-renaming],
3545 [MANPAGE_RENAMES=$withval],
3546 [MANPAGE_RENAMES=yes])
3548 case ".$MANPAGE_RENAMES" in #(vi
3552 # Debian 'man' program?
3553 if test -f /etc/debian_version ; then
3554 MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
3561 if test "$MANPAGE_RENAMES" != no ; then
3562 if test -f $srcdir/man/$MANPAGE_RENAMES ; then
3563 MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
3564 elif test ! -f $MANPAGE_RENAMES ; then
3565 AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
3568 test ! -d man && mkdir man
3570 # Construct a sed-script to perform renaming within man-pages
3571 if test -n "$MANPAGE_RENAMES" ; then
3572 test ! -d man && mkdir man
3573 sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
3577 AC_MSG_RESULT($MANPAGE_RENAMES)
3578 AC_SUBST(MANPAGE_RENAMES)
3580 dnl ---------------------------------------------------------------------------
3581 dnl CF_MANPAGE_SYMLINKS version: 5 updated: 2010/07/24 17:12:40
3582 dnl -------------------
3583 dnl Some people expect each tool to make all aliases for manpages in the
3584 dnl man-directory. This accommodates the older, less-capable implementations
3585 dnl of 'man', and is optional.
3586 AC_DEFUN([CF_MANPAGE_SYMLINKS],
3588 AC_MSG_CHECKING(if manpage aliases will be installed)
3590 AC_ARG_WITH(manpage-aliases,
3591 [ --with-manpage-aliases specify manpage-aliases using .so],
3592 [MANPAGE_ALIASES=$withval],
3593 [MANPAGE_ALIASES=yes])
3595 AC_MSG_RESULT($MANPAGE_ALIASES)
3597 case "x$LN_S" in #(vi
3607 if test "$MANPAGE_ALIASES" = yes ; then
3608 AC_MSG_CHECKING(if manpage symlinks should be used)
3610 AC_ARG_WITH(manpage-symlinks,
3611 [ --with-manpage-symlinks specify manpage-aliases using symlinks],
3612 [MANPAGE_SYMLINKS=$withval],
3613 [MANPAGE_SYMLINKS=$cf_use_symlinks])
3615 if test "$$cf_use_symlinks" = no; then
3616 if test "$MANPAGE_SYMLINKS" = yes ; then
3617 AC_MSG_WARN(cannot make symlinks, will use .so files)
3622 AC_MSG_RESULT($MANPAGE_SYMLINKS)
3626 dnl ---------------------------------------------------------------------------
3627 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
3629 dnl This option causes manpages to be run through tbl(1) to generate tables
3631 AC_DEFUN([CF_MANPAGE_TBL],
3633 AC_MSG_CHECKING(for manpage tbl)
3635 AC_ARG_WITH(manpage-tbl,
3636 [ --with-manpage-tbl specify manpage processing with tbl],
3637 [MANPAGE_TBL=$withval],
3640 AC_MSG_RESULT($MANPAGE_TBL)
3642 dnl ---------------------------------------------------------------------------
3643 dnl CF_MAN_PAGES version: 39 updated: 2010/10/23 15:44:18
3645 dnl Try to determine if the man-pages on the system are compressed, and if
3646 dnl so, what format is used. Use this information to construct a script that
3647 dnl will install man-pages.
3648 AC_DEFUN([CF_MAN_PAGES],
3650 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
3656 if test "$prefix" = "NONE" ; then
3657 cf_prefix="$ac_default_prefix"
3662 case "$MANPAGE_FORMAT" in # (vi
3677 test ! -d man && mkdir man
3681 case "$MANPAGE_FORMAT" in #(vi
3684 cf_compress=compress
3692 cf_edit_man=./edit_man.sh
3693 cf_man_alias=`pwd`/man_alias.sed
3695 cat >$cf_edit_man <<CF_EOF
3697 # this script is generated by the configure-script CF_MAN_PAGES macro.
3702 NCURSES_MAJOR="$NCURSES_MAJOR"
3703 NCURSES_MINOR="$NCURSES_MINOR"
3704 NCURSES_PATCH="$NCURSES_PATCH"
3706 NCURSES_OSPEED="$NCURSES_OSPEED"
3707 TERMINFO="$TERMINFO"
3710 INSTALL_DATA="$INSTALL_DATA"
3712 transform="$program_transform_name"
3714 TMP=\${TMPDIR:=/tmp}/man\$\$
3715 trap "rm -f \$TMP" 0 1 2 5 15
3727 top_srcdir=\[$]srcdir/..
3730 if test "\$form" = normal ; then
3731 if test "$cf_format" = yes ; then
3732 if test "$cf_inboth" = no ; then
3733 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3737 cf_subdir=\$mandir/man
3738 cf_tables=$MANPAGE_TBL
3740 cf_subdir=\$mandir/cat
3744 # process the list of source-files
3747 *.orig|*.rej) ;; #(vi
3749 section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
3750 if test \$verb = installing ; then
3751 if test ! -d \$cf_subdir\${section} ; then
3752 mkdir -p \$cf_subdir\$section
3756 # replace variables in man page
3757 if test ! -f $cf_man_alias ; then
3758 cat >>$cf_man_alias <<-CF_EOF2
3759 s,@DATADIR@,\$datadir,g
3760 s,@TERMINFO@,\$TERMINFO,g
3761 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
3762 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
3763 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
3764 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
3769 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3770 cf_name=`echo $cf_name|sed "$program_transform_name"`
3771 cat >>$cf_edit_man <<-CF_EOF
3772 s,@$cf_NAME@,$cf_name,g
3776 cat >>$cf_edit_man <<CF_EOF
3778 echo "...made $cf_man_alias"
3782 cf_source=\`basename \$i\`
3784 test ! -f \$inalias && inalias="\$srcdir/\$inalias"
3785 if test ! -f \$inalias ; then
3786 echo .. skipped \$cf_source
3791 if test "$MANPAGE_ALIASES" != no ; then
3792 cat >>$cf_edit_man <<CF_EOF
3793 aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
3797 if test "$MANPAGE_RENAMES" = no ; then
3798 cat >>$cf_edit_man <<CF_EOF
3799 # perform program transformations for section 1 man pages
3800 if test \$section = 1 ; then
3801 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
3803 cf_target=\$cf_subdir\${section}/\$cf_source
3807 cat >>$cf_edit_man <<CF_EOF
3808 cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
3809 if test -z "\$cf_target" ; then
3810 echo '? missing rename for '\$cf_source
3811 cf_target="\$cf_source"
3813 cf_target="\$cf_subdir\${section}/\${cf_target}"
3818 cat >>$cf_edit_man <<CF_EOF
3819 sed -f $cf_man_alias \\
3822 if test -f $MANPAGE_RENAMES ; then
3823 cat >>$cf_edit_man <<CF_EOF
3824 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
3827 cat >>$cf_edit_man <<CF_EOF
3832 cat >>$cf_edit_man <<CF_EOF
3833 if test \$cf_tables = yes ; then
3834 tbl \$TMP >\$TMP.out
3839 if test $with_curses_h != yes ; then
3840 cat >>$cf_edit_man <<CF_EOF
3841 sed -e "/\#[ ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
3846 cat >>$cf_edit_man <<CF_EOF
3847 if test \$form = format ; then
3848 nroff -man \$TMP >\$TMP.out
3853 if test -n "$cf_compress" ; then
3854 cat >>$cf_edit_man <<CF_EOF
3855 if test \$verb = installing ; then
3856 if ( $cf_compress -f \$TMP )
3858 mv \$TMP.$cf_so_strip \$TMP
3861 cf_target="\$cf_target.$cf_so_strip"
3865 case "$MANPAGE_FORMAT" in #(vi
3867 cat >>$cf_edit_man <<CF_EOF
3868 if test \$form = format ; then
3869 # BSDI installs only .0 suffixes in the cat directories
3870 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
3876 cat >>$cf_edit_man <<CF_EOF
3877 suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
3878 if test \$verb = installing ; then
3879 echo \$verb \$cf_target
3880 \$INSTALL_DATA \$TMP \$cf_target
3881 test -d \$cf_subdir\${section} &&
3882 test -n "\$aliases" && (
3883 cd \$cf_subdir\${section} && (
3884 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
3885 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
3886 cf_target=\`basename \$cf_target\`
3887 for cf_alias in \$aliases
3889 if test \$section = 1 ; then
3890 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3893 if test "$MANPAGE_SYMLINKS" = yes ; then
3894 if test -f \$cf_alias\${suffix} ; then
3895 if ( cmp -s \$cf_target \$cf_alias\${suffix} )
3900 echo .. \$verb alias \$cf_alias\${suffix}
3902 case "x$LN_S" in #(vi
3904 cat >>$cf_edit_man <<CF_EOF
3905 $LN_S \$cf_target \$cf_alias\${suffix}
3909 cat >>$cf_edit_man <<CF_EOF
3910 rm -f \$cf_alias\${suffix}
3911 $LN_S \$cf_target \$cf_alias\${suffix}
3915 cat >>$cf_edit_man <<CF_EOF
3916 elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
3917 echo ".so \$cf_source" >\$TMP
3919 if test -n "$cf_compress" ; then
3920 cat >>$cf_edit_man <<CF_EOF
3921 if test -n "$cf_so_strip" ; then
3922 $cf_compress -f \$TMP
3923 mv \$TMP.$cf_so_strip \$TMP
3927 cat >>$cf_edit_man <<CF_EOF
3928 echo .. \$verb alias \$cf_alias\${suffix}
3929 rm -f \$cf_alias\${suffix}
3930 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
3935 elif test \$verb = removing ; then
3936 test -f \$cf_target && (
3937 echo \$verb \$cf_target
3940 test -d \$cf_subdir\${section} &&
3941 test -n "\$aliases" && (
3942 cd \$cf_subdir\${section} && (
3943 for cf_alias in \$aliases
3945 if test \$section = 1 ; then
3946 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3949 echo .. \$verb alias \$cf_alias\${suffix}
3950 rm -f \$cf_alias\${suffix}
3962 if test $cf_inboth = yes ; then
3963 if test \$form != format ; then
3964 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3970 chmod 755 $cf_edit_man
3973 dnl ---------------------------------------------------------------------------
3974 dnl CF_MATH_LIB version: 8 updated: 2010/05/29 16:31:02
3976 dnl Checks for libraries. At least one UNIX system, Apple Macintosh
3977 dnl Rhapsody 5.5, does not have -lm. We cannot use the simpler
3978 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
3979 AC_DEFUN([CF_MATH_LIB],
3981 AC_CACHE_CHECK(if -lm needed for math functions,
3987 [double x = rand(); printf("result = %g\n", ]ifelse([$2],,sin(x),$2)[)],
3988 [cf_cv_need_libm=no],
3989 [cf_cv_need_libm=yes])])
3990 if test "$cf_cv_need_libm" = yes
3997 dnl ---------------------------------------------------------------------------
3998 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
3999 dnl ----------------------
4000 dnl Check if the file-system supports mixed-case filenames. If we're able to
4001 dnl create a lowercase name and see it as uppercase, it doesn't support that.
4002 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
4004 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
4005 if test "$cross_compiling" = yes ; then
4006 case $target_alias in #(vi
4007 *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
4015 rm -f conftest CONFTEST
4017 if test -f CONFTEST ; then
4022 rm -f conftest CONFTEST
4025 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
4027 dnl ---------------------------------------------------------------------------
4028 dnl CF_MKSTEMP version: 7 updated: 2010/08/14 18:25:37
4030 dnl Check for a working mkstemp. This creates two files, checks that they are
4031 dnl successfully created and distinct (AmigaOS apparently fails on the last).
4032 AC_DEFUN([CF_MKSTEMP],[
4033 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
4036 #include <sys/types.h>
4040 #include <sys/stat.h>
4043 char *tmpl = "conftestXXXXXX";
4051 for (n = 0; n < 2; ++n) {
4052 strcpy(name[n], tmpl);
4053 if ((fd = mkstemp(name[n])) >= 0) {
4054 if (!strcmp(name[n], tmpl)
4055 || stat(name[n], &sb) != 0
4056 || (sb.st_mode & S_IFMT) != S_IFREG
4057 || (sb.st_mode & 077) != 0) {
4064 && !strcmp(name[0], name[1]))
4066 ${cf_cv_main_return:-return}(result);
4068 ],[cf_cv_func_mkstemp=yes
4069 ],[cf_cv_func_mkstemp=no
4070 ],[AC_CHECK_FUNC(mkstemp)
4073 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
4074 AC_DEFINE(HAVE_MKSTEMP)
4077 dnl ---------------------------------------------------------------------------
4078 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
4080 dnl Write a debug message to config.log, along with the line number in the
4081 dnl configure script.
4082 AC_DEFUN([CF_MSG_LOG],[
4083 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
4085 dnl ---------------------------------------------------------------------------
4086 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
4087 dnl ----------------
4088 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
4089 dnl warn about this.
4090 AC_DEFUN([CF_NCURSES_ABI_6],[
4091 if test "${with_abi_version+set}" != set; then
4092 case $cf_cv_rel_version in
4094 cf_cv_rel_version=6.0
4096 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
4101 dnl ---------------------------------------------------------------------------
4102 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
4103 dnl ------------------
4104 dnl see CF_WITH_NO_LEAKS
4105 AC_DEFUN([CF_NO_LEAKS_OPTION],[
4106 AC_MSG_CHECKING(if you want to use $1 for testing)
4109 [AC_DEFINE($3)ifelse([$4],,[
4112 : ${with_cflags:=-g}
4113 : ${with_no_leaks:=yes}
4116 AC_MSG_RESULT(${with_$1:-no})
4118 case .$with_cflags in #(vi
4120 case .$CFLAGS in #(vi
4130 dnl ---------------------------------------------------------------------------
4131 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
4132 dnl ----------------
4133 dnl Check if the given variable is a number. If not, report an error.
4134 dnl $1 is the variable
4135 dnl $2 is the message
4136 AC_DEFUN([CF_NUMBER_SYNTAX],[
4137 if test -n "$1" ; then
4142 AC_MSG_ERROR($2 is not a number: $1)
4146 AC_MSG_ERROR($2 value is empty)
4149 dnl ---------------------------------------------------------------------------
4150 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
4152 dnl Compute the object-directory name from the given model name
4153 AC_DEFUN([CF_OBJ_SUBDIR],
4156 libtool) $2='obj_lo' ;;
4157 normal) $2='objects' ;;
4158 debug) $2='obj_g' ;;
4159 profile) $2='obj_p' ;;
4161 case $cf_cv_system_name in #(vi
4169 dnl ---------------------------------------------------------------------------
4170 dnl CF_PATHSEP version: 5 updated: 2010/05/26 05:38:42
4172 dnl Provide a value for the $PATH and similar separator
4173 AC_DEFUN([CF_PATHSEP],
4175 case $cf_cv_system_name in
4176 os2*) PATH_SEPARATOR=';' ;;
4177 *) PATH_SEPARATOR=':' ;;
4179 ifelse([$1],,,[$1=$PATH_SEPARATOR])
4180 AC_SUBST(PATH_SEPARATOR)
4182 dnl ---------------------------------------------------------------------------
4183 dnl CF_PATH_SYNTAX version: 13 updated: 2010/05/26 05:38:42
4185 dnl Check the argument to see that it looks like a pathname. Rewrite it if it
4186 dnl begins with one of the prefix/exec_prefix variables, and then again if the
4187 dnl result begins with 'NONE'. This is necessary to work around autoconf's
4188 dnl delayed evaluation of those symbols.
4189 AC_DEFUN([CF_PATH_SYNTAX],[
4190 if test "x$prefix" != xNONE; then
4191 cf_path_syntax="$prefix"
4193 cf_path_syntax="$ac_default_prefix"
4196 case ".[$]$1" in #(vi
4197 .\[$]\(*\)*|.\'*\'*) #(vi
4201 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
4203 .\[$]{*prefix}*) #(vi
4205 case ".[$]$1" in #(vi
4207 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
4212 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
4215 ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
4219 dnl ---------------------------------------------------------------------------
4220 dnl CF_PKG_CONFIG version: 3 updated: 2009/01/25 10:55:09
4222 dnl Check for the package-config program, unless disabled by command-line.
4223 AC_DEFUN([CF_PKG_CONFIG],
4225 AC_MSG_CHECKING(if you want to use pkg-config)
4226 AC_ARG_WITH(pkg-config,
4227 [ --with-pkg-config{=path} enable/disable use of pkg-config],
4228 [cf_pkg_config=$withval],
4229 [cf_pkg_config=yes])
4230 AC_MSG_RESULT($cf_pkg_config)
4232 case $cf_pkg_config in #(vi
4237 AC_PATH_PROG(PKG_CONFIG, pkg-config, none)
4244 test -z "$PKG_CONFIG" && PKG_CONFIG=none
4245 if test "$PKG_CONFIG" != none ; then
4246 CF_PATH_SYNTAX(PKG_CONFIG)
4249 AC_SUBST(PKG_CONFIG)
4251 dnl ---------------------------------------------------------------------------
4252 dnl CF_POSIX_C_SOURCE version: 8 updated: 2010/05/26 05:38:42
4253 dnl -----------------
4254 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
4256 dnl POSIX.1-1990 _POSIX_SOURCE
4257 dnl POSIX.1-1990 and _POSIX_SOURCE and
4258 dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2
4260 dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L
4261 dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L
4262 dnl X/Open 2000 _POSIX_C_SOURCE=200112L
4265 dnl $1 is the nominal value for _POSIX_C_SOURCE
4266 AC_DEFUN([CF_POSIX_C_SOURCE],
4268 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
4270 cf_save_CFLAGS="$CFLAGS"
4271 cf_save_CPPFLAGS="$CPPFLAGS"
4273 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
4274 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
4276 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
4277 CF_MSG_LOG(if the symbol is already defined go no further)
4278 AC_TRY_COMPILE([#include <sys/types.h>],[
4279 #ifndef _POSIX_C_SOURCE
4282 [cf_cv_posix_c_source=no],
4283 [cf_want_posix_source=no
4284 case .$cf_POSIX_C_SOURCE in #(vi
4286 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
4289 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
4290 cf_want_posix_source=yes
4293 cf_want_posix_source=yes
4296 if test "$cf_want_posix_source" = yes ; then
4297 AC_TRY_COMPILE([#include <sys/types.h>],[
4298 #ifdef _POSIX_SOURCE
4301 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
4303 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
4304 CFLAGS="$cf_trim_CFLAGS"
4305 CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
4306 CF_MSG_LOG(if the second compile does not leave our definition intact error)
4307 AC_TRY_COMPILE([#include <sys/types.h>],[
4308 #ifndef _POSIX_C_SOURCE
4311 [cf_cv_posix_c_source=no])
4312 CFLAGS="$cf_save_CFLAGS"
4313 CPPFLAGS="$cf_save_CPPFLAGS"
4317 if test "$cf_cv_posix_c_source" != no ; then
4318 CFLAGS="$cf_trim_CFLAGS"
4319 CPPFLAGS="$cf_trim_CPPFLAGS"
4320 CF_ADD_CFLAGS($cf_cv_posix_c_source)
4324 dnl ---------------------------------------------------------------------------
4325 dnl CF_PREDEFINE version: 2 updated: 2010/05/26 16:44:57
4327 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
4329 dnl $1 = symbol to test
4330 dnl $2 = value (if any) to use for a predefinition
4331 AC_DEFUN([CF_PREDEFINE],
4333 AC_MSG_CHECKING(if we must define $1)
4334 AC_TRY_COMPILE([#include <sys/types.h>
4338 #endif],[cf_result=no],[cf_result=yes])
4339 AC_MSG_RESULT($cf_result)
4341 if test "$cf_result" = yes ; then
4342 CPPFLAGS="$CPPFLAGS ifelse([$2],,-D$1,[-D$1=$2])"
4343 elif test "x$2" != "x" ; then
4344 AC_MSG_CHECKING(checking for compatible value versus $2)
4345 AC_TRY_COMPILE([#include <sys/types.h>
4349 #endif],[cf_result=yes],[cf_result=no])
4350 AC_MSG_RESULT($cf_result)
4351 if test "$cf_result" = no ; then
4352 # perhaps we can override it - try...
4353 CPPFLAGS="$CPPFLAGS -D$1=$2"
4357 dnl ---------------------------------------------------------------------------
4358 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
4360 dnl Append definitions and rules for the given programs to the subdirectory
4361 dnl Makefiles, and the recursion rule for the top-level Makefile.
4364 dnl $1 = script to run
4365 dnl $2 = list of subdirectories
4369 AC_DEFUN([CF_PRG_RULES],
4373 if test ! -d $srcdir/$cf_dir; then
4375 elif test -f $srcdir/$cf_dir/programs; then
4376 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
4381 dnl ---------------------------------------------------------------------------
4382 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
4384 dnl Check for archiver "ar".
4385 AC_DEFUN([CF_PROG_AR],[
4386 AC_CHECK_TOOL(AR, ar, ar)
4388 dnl ---------------------------------------------------------------------------
4389 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
4391 dnl Check for awk, ensure that the check found something.
4392 AC_DEFUN([CF_PROG_AWK],
4395 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
4397 dnl ---------------------------------------------------------------------------
4398 dnl CF_PROG_CC_C_O version: 3 updated: 2010/08/14 18:25:37
4400 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
4401 dnl the output file can be renamed, and allows for a shell variable that can
4402 dnl be used later. The parameter is either CC or CXX. The result is the
4404 dnl $cf_cv_prog_CC_c_o
4405 dnl $cf_cv_prog_CXX_c_o
4406 AC_DEFUN([CF_PROG_CC_C_O],
4407 [AC_REQUIRE([AC_PROG_CC])dnl
4408 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
4409 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
4411 cat > conftest.$ac_ext <<CF_EOF
4415 ${cf_cv_main_return:-return}(0);
4418 # We do the test twice because some compilers refuse to overwrite an
4419 # existing .o file with -o, though they will create one.
4420 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
4421 if AC_TRY_EVAL(ac_try) &&
4422 test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
4424 eval cf_cv_prog_$1_c_o=yes
4426 eval cf_cv_prog_$1_c_o=no
4430 if test $cf_cv_prog_$1_c_o = yes; then
4431 AC_MSG_RESULT([yes])
4436 dnl ---------------------------------------------------------------------------
4437 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
4439 dnl Check if C (preprocessor) -U and -D options are processed in the order
4440 dnl given rather than by type of option. Some compilers insist on apply all
4441 dnl of the -U options after all of the -D options. Others allow mixing them,
4442 dnl and may predefine symbols that conflict with those we define.
4443 AC_DEFUN([CF_PROG_CC_U_D],
4445 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
4446 cf_save_CPPFLAGS="$CPPFLAGS"
4447 CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
4450 make an undefined-error
4453 make a defined-error
4456 cf_cv_cc_u_d_options=yes],[
4457 cf_cv_cc_u_d_options=no])
4458 CPPFLAGS="$cf_save_CPPFLAGS"
4461 dnl ---------------------------------------------------------------------------
4462 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
4464 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
4465 dnl This macro adds a check to ensure the script found something.
4466 AC_DEFUN([CF_PROG_EGREP],
4467 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
4468 [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4469 then ac_cv_prog_egrep='grep -E'
4470 else ac_cv_prog_egrep='egrep'
4472 EGREP=$ac_cv_prog_egrep
4474 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
4476 dnl ---------------------------------------------------------------------------
4477 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
4479 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
4480 AC_DEFUN([CF_PROG_EXT],
4482 AC_REQUIRE([CF_CHECK_CACHE])
4483 case $cf_cv_system_name in
4485 CFLAGS="$CFLAGS -Zmt"
4486 CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
4487 CXXFLAGS="$CXXFLAGS -Zmt"
4488 # autoconf's macro sets -Zexe and suffix both, which conflict:w
4489 LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
4499 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
4501 dnl ---------------------------------------------------------------------------
4502 dnl CF_PROG_GNAT version: 1 updated: 2010/06/19 15:22:18
4504 dnl Check for gnatmake, ensure that it is complete.
4505 AC_DEFUN([CF_PROG_GNAT],[
4506 cf_ada_make=gnatmake
4507 AC_CHECK_PROG(gnat_exists, $cf_ada_make, yes, no)
4508 if test "$ac_cv_prog_gnat_exists" = no; then
4512 AC_CHECK_PROG(M4_exists, m4, yes, no)
4513 if test "$ac_cv_prog_M4_exists" = no; then
4514 cf_cv_prog_gnat_correct=no
4515 echo Ada95 binding required program m4 not found. Ada95 binding disabled.
4517 if test "$cf_cv_prog_gnat_correct" = yes; then
4518 AC_MSG_CHECKING(if GNAT works)
4519 CF_GNAT_TRY_RUN([procedure conftest;],
4522 procedure conftest is
4524 Text_IO.Put ("Hello World");
4526 GNAT.OS_Lib.OS_Exit (0);
4527 end conftest;],[cf_cv_prog_gnat_correct=yes],[cf_cv_prog_gnat_correct=no])
4528 AC_MSG_RESULT($cf_cv_prog_gnat_correct)
4532 AC_SUBST(cf_ada_make)
4534 dnl ---------------------------------------------------------------------------
4535 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
4537 dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the
4538 dnl misc/tabset install won't work properly. Usually this happens only when
4539 dnl using the fallback mkinstalldirs script
4540 AC_DEFUN([CF_PROG_INSTALL],
4546 CF_DIRNAME(cf_dir,$INSTALL)
4547 test -z "$cf_dir" && cf_dir=.
4548 INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
4552 dnl ---------------------------------------------------------------------------
4553 dnl CF_PROG_LDCONFIG version: 2 updated: 2008/12/13 14:08:40
4554 dnl ----------------
4555 dnl Check for ldconfig, needed to fixup shared libraries that would be built
4556 dnl and then used in the install.
4557 AC_DEFUN([CF_PROG_LDCONFIG],[
4558 if test "$cross_compiling" = yes ; then
4561 case "$cf_cv_system_name" in #(vi
4562 dragonfly*|freebsd*) #(vi
4563 test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
4565 *) LDPATH=$PATH:/sbin:/usr/sbin
4566 AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
4572 dnl ---------------------------------------------------------------------------
4573 dnl CF_PROG_LINT version: 2 updated: 2009/08/12 04:43:14
4575 AC_DEFUN([CF_PROG_LINT],
4577 AC_CHECK_PROGS(LINT, tdlint lint alint splint lclint)
4580 dnl ---------------------------------------------------------------------------
4581 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
4583 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
4584 dnl option if it is supported.
4585 AC_DEFUN([CF_PROG_LN_S],[
4587 AC_MSG_CHECKING(if $LN_S -f options work)
4589 rm -f conf$$.src conf$$dst
4591 echo first >conf$$.src
4592 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
4597 rm -f conf$$.dst conf$$src
4598 AC_MSG_RESULT($cf_prog_ln_sf)
4600 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
4602 dnl ---------------------------------------------------------------------------
4603 dnl CF_REGEX version: 8 updated: 2010/08/07 14:09:44
4605 dnl Attempt to determine if we've got one of the flavors of regular-expression
4606 dnl code that we can support.
4607 AC_DEFUN([CF_REGEX],
4612 cf_regex_libs="regex re"
4613 case $host_os in #(vi
4615 cf_regex_libs="regex.dll $cf_regex_libs"
4619 AC_CHECK_FUNC(regcomp,[cf_regex_func=regcomp],[
4620 for cf_regex_lib in $cf_regex_libs
4622 AC_CHECK_LIB($cf_regex_lib,regcomp,[
4623 CF_ADD_LIB($cf_regex_lib)
4624 cf_regex_func=regcomp
4629 if test "$cf_regex_func" = no ; then
4630 AC_CHECK_FUNC(compile,[cf_regex_func=compile],[
4631 AC_CHECK_LIB(gen,compile,[
4633 cf_regex_func=compile])])
4636 if test "$cf_regex_func" = no ; then
4637 AC_MSG_WARN(cannot find regular expression library)
4640 AC_CACHE_CHECK(for regular-expression headers,cf_cv_regex_hdrs,[
4643 case $cf_regex_func in #(vi
4645 for cf_regex_hdr in regexp.h regexpr.h
4647 AC_TRY_LINK([#include <$cf_regex_hdr>],[
4648 char *p = compile("", "", "", 0);
4649 int x = step("", "");
4651 cf_cv_regex_hdrs=$cf_regex_hdr
4657 for cf_regex_hdr in regex.h
4659 AC_TRY_LINK([#include <sys/types.h>
4660 #include <$cf_regex_hdr>],[
4662 int x = regcomp(p, "", 0);
4663 int y = regexec(p, "", 0, 0, 0);
4666 cf_cv_regex_hdrs=$cf_regex_hdr
4675 case $cf_cv_regex_hdrs in #(vi
4676 no) AC_MSG_WARN(no regular expression header found) ;; #(vi
4677 regex.h) AC_DEFINE(HAVE_REGEX_H_FUNCS) ;; #(vi
4678 regexp.h) AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;; #(vi
4679 regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;;
4682 dnl ---------------------------------------------------------------------------
4683 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
4684 dnl ----------------
4685 dnl Remove all -U and -D options that refer to the given symbol from a list
4686 dnl of C compiler options. This works around the problem that not all
4687 dnl compilers process -U and -D options from left-to-right, so a -U option
4688 dnl cannot be used to cancel the effect of a preceding -D option.
4690 dnl $1 = target (which could be the same as the source variable)
4691 dnl $2 = source (including '$')
4692 dnl $3 = symbol to remove
4693 define([CF_REMOVE_DEFINE],
4696 sed -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[[ ]]/ /g' \
4697 -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[$]//g'`
4699 dnl ---------------------------------------------------------------------------
4700 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
4702 dnl Remove the given library from the symbol
4704 dnl $1 = target (which could be the same as the source variable)
4705 dnl $2 = source (including '$')
4706 dnl $3 = library to remove
4707 define([CF_REMOVE_LIB],
4709 # remove $3 library from $2
4710 $1=`echo "$2" | sed -e 's/-l$3[[ ]]//g' -e 's/-l$3[$]//'`
4712 dnl ---------------------------------------------------------------------------
4713 dnl CF_RPATH_HACK version: 8 updated: 2010/04/17 15:38:58
4715 AC_DEFUN([CF_RPATH_HACK],
4717 AC_REQUIRE([CF_LD_RPATH_OPT])
4718 AC_MSG_CHECKING(for updated LDFLAGS)
4719 if test -n "$LD_RPATH_OPT" ; then
4720 AC_MSG_RESULT(maybe)
4722 AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
4723 cf_rpath_list="/usr/lib /lib"
4724 if test "$cf_ldd_prog" != no
4726 AC_TRY_LINK([#include <stdio.h>],
4728 [cf_rpath_list=`$cf_ldd_prog conftest$ac_exeext | fgrep / | sed -e 's%^.*[[ ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort -u`])
4731 CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
4733 CF_RPATH_HACK_2(LDFLAGS)
4734 CF_RPATH_HACK_2(LIBS)
4736 CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
4738 AC_SUBST(EXTRA_LDFLAGS)
4740 dnl ---------------------------------------------------------------------------
4741 dnl CF_RPATH_HACK_2 version: 6 updated: 2010/04/17 16:31:24
4743 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
4744 dnl EXTRA_LDFLAGS for each -L option found.
4746 dnl $cf_rpath_list contains a list of directories to ignore.
4748 dnl $1 = variable name to update. The LDFLAGS variable should be the only one,
4749 dnl but LIBS often has misplaced -L options.
4750 AC_DEFUN([CF_RPATH_HACK_2],
4752 CF_VERBOSE(...checking $1 [$]$1)
4755 for cf_rpath_src in [$]$1
4757 case $cf_rpath_src in #(vi
4760 # check if this refers to a directory which we will ignore
4762 if test -n "$cf_rpath_list"
4764 for cf_rpath_item in $cf_rpath_list
4766 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
4774 if test "$cf_rpath_skip" = no
4776 # transform the option
4777 if test "$LD_RPATH_OPT" = "-R " ; then
4778 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
4780 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
4783 # if we have not already added this, add it now
4784 cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
4785 if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
4787 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
4788 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
4793 cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
4797 CF_VERBOSE(...checked $1 [$]$1)
4798 AC_SUBST(EXTRA_LDFLAGS)
4800 dnl ---------------------------------------------------------------------------
4801 dnl CF_SHARED_OPTS version: 64 updated: 2010/06/05 16:51:16
4804 dnl Attempt to determine the appropriate CC/LD options for creating a shared
4807 dnl Note: ${LOCAL_LDFLAGS} is used to link executables that will run within the
4808 dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib
4809 dnl We avoid compiling-in a ../lib path for the shared library since that can
4810 dnl lead to unexpected results at runtime.
4811 dnl ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared libraries
4812 dnl are compiled in ../../lib
4814 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
4815 dnl to install symbolic links to the rel/abi versions of shared libraries.
4817 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
4818 dnl version when making symbolic links.
4820 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
4821 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
4822 dnl (ex: libncurses.so.<ver>).
4824 dnl Some loaders leave 'so_locations' lying around. It's nice to clean up.
4825 AC_DEFUN([CF_SHARED_OPTS],
4827 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
4828 AC_REQUIRE([CF_LD_RPATH_OPT])
4832 INSTALL_LIB="-m 644"
4834 cf_cv_do_symlinks=no
4836 test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
4838 AC_MSG_CHECKING(if release/abi version should be used for shared libs)
4839 AC_ARG_WITH(shlib-version,
4840 [ --with-shlib-version=X Specify rel or abi version for shared libs],
4841 [test -z "$withval" && withval=auto
4842 case $withval in #(vi
4844 cf_cv_shlib_version=auto
4846 rel|abi|auto|no) #(vi
4847 cf_cv_shlib_version=$withval
4850 AC_MSG_ERROR([option value must be one of: rel, abi, auto or no])
4853 ],[cf_cv_shlib_version=auto])
4854 AC_MSG_RESULT($cf_cv_shlib_version)
4858 # Some less-capable ports of gcc support only -fpic
4860 if test "$GCC" = yes
4862 AC_MSG_CHECKING(which $CC option to use)
4863 cf_save_CFLAGS="$CFLAGS"
4864 for CC_SHARED_OPTS in -fPIC -fpic ''
4866 CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
4867 AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
4869 AC_MSG_RESULT($CC_SHARED_OPTS)
4870 CFLAGS="$cf_save_CFLAGS"
4873 cf_cv_shlib_version_infix=no
4875 case $cf_cv_system_name in #(vi
4877 if test "$GCC" = yes; then
4879 MK_SHARED_LIB='$(CC) -shared'
4883 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
4887 MK_SHARED_LIB='sh ../mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
4888 cf_cv_shlib_version=cygdll
4889 cf_cv_shlib_version_infix=cygdll
4890 cat >mk_shared_lib.sh <<-CF_EOF
4893 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
4896 Linking shared library
4897 ** SHARED_LIB \[$]SHARED_LIB
4898 ** IMPORT_LIB \[$]IMPORT_LIB
4900 exec \[$]* -shared -Wl,--out-implib=../lib/\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o ../lib/\[$]{SHARED_LIB}
4902 chmod +x mk_shared_lib.sh
4905 EXTRA_CFLAGS="-no-cpp-precomp"
4906 CC_SHARED_OPTS="-dynamic"
4907 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
4908 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
4909 cf_cv_shlib_version_infix=yes
4910 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
4911 cf_save_LDFLAGS=$LDFLAGS
4912 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4913 AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
4914 LDFLAGS=$cf_save_LDFLAGS])
4915 if test $cf_cv_ldflags_search_paths_first = yes; then
4916 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4920 # (tested with gcc 2.7.2 -- I don't have c89)
4921 if test "$GCC" = yes; then
4922 LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
4925 LD_SHARED_OPTS='-Wl,+b,${libdir}'
4927 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
4928 # HP-UX shared libraries must be executable, and should be
4929 # readonly to exploit a quirk in the memory manager.
4930 INSTALL_LIB="-m 555"
4933 if test "$cf_cv_enable_rpath" = yes ; then
4934 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
4936 # tested with IRIX 5.2 and 'cc'.
4937 if test "$GCC" != yes; then
4938 CC_SHARED_OPTS='-KPIC'
4939 MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
4941 MK_SHARED_LIB='${CC} -shared -Wl,-soname,`basename $[@]` -o $[@]'
4943 cf_cv_rm_so_locs=yes
4945 linux*|gnu*|k*bsd*-gnu) #(vi
4946 if test "$DFT_LWR_MODEL" = "shared" ; then
4947 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
4948 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4950 if test "$cf_cv_enable_rpath" = yes ; then
4951 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
4954 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4956 openbsd[[2-9]].*) #(vi
4957 if test "$DFT_LWR_MODEL" = "shared" ; then
4958 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
4959 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4961 if test "$cf_cv_enable_rpath" = yes ; then
4962 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
4964 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4966 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4968 nto-qnx*|openbsd*|freebsd[[12]].*) #(vi
4969 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4970 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
4971 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4974 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4975 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
4976 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
4977 LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${libdir} $LOCAL_LDFLAGS"
4978 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
4981 MK_SHARED_LIB='${LD} -shared -Bshareable -soname=`basename $[@]` -o $[@]'
4984 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4985 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
4986 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
4987 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4988 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
4989 if test "$cf_cv_shlib_version" = auto; then
4990 if test -f /usr/libexec/ld.elf_so; then
4991 cf_cv_shlib_version=abi
4993 cf_cv_shlib_version=rel
4997 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
4999 MK_SHARED_LIB='${LD} -shared -Bshareable -o $[@]'
5003 # tested with OSF/1 V3.2 and 'cc'
5004 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
5005 # link with shared libs).
5006 MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
5007 case $host_os in #(vi
5009 MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
5012 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
5013 if test "$DFT_LWR_MODEL" = "shared" ; then
5014 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
5015 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5017 cf_cv_rm_so_locs=yes
5019 sco3.2v5*) # (also uw2* and UW7: hops 13-Apr-98
5020 # tested with osr5.0.5
5021 if test "$GCC" != yes; then
5022 CC_SHARED_OPTS='-belf -KPIC'
5024 MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
5025 if test "$cf_cv_enable_rpath" = yes ; then
5026 # only way is to set LD_RUN_PATH but no switch for it
5029 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5030 LINK_PROGS='LD_RUN_PATH=${libdir}'
5031 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
5034 # tested with SunOS 4.1.1 and gcc 2.7.0
5035 if test "$GCC" != yes; then
5036 CC_SHARED_OPTS='-KPIC'
5038 MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
5039 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5042 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
5043 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
5044 if test "$DFT_LWR_MODEL" = "shared" ; then
5045 LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
5046 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5048 if test "$cf_cv_enable_rpath" = yes ; then
5049 EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
5052 if test "$GCC" != yes; then
5053 cf_save_CFLAGS="$CFLAGS"
5054 for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
5056 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
5057 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\n");],[break])
5059 CFLAGS="$cf_save_CFLAGS"
5060 CC_SHARED_OPTS=$cf_shared_opts
5061 MK_SHARED_LIB='${CC} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
5063 MK_SHARED_LIB='${CC} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
5066 sysv5uw7*|unix_sv*) #(vi
5067 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
5068 if test "$GCC" != yes; then
5069 CC_SHARED_OPTS='-KPIC'
5071 MK_SHARED_LIB='${LD} -d y -G -o [$]@'
5074 CC_SHARED_OPTS='unknown'
5075 MK_SHARED_LIB='echo unknown'
5079 # This works if the last tokens in $MK_SHARED_LIB are the -o target.
5080 case "$cf_cv_shlib_version" in #(vi
5082 case "$MK_SHARED_LIB" in #(vi
5084 test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
5087 AC_MSG_WARN(ignored --with-shlib-version)
5093 if test -n "$cf_ld_rpath_opt" ; then
5094 MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${libdir}"
5097 AC_SUBST(CC_SHARED_OPTS)
5098 AC_SUBST(LD_RPATH_OPT)
5099 AC_SUBST(LD_SHARED_OPTS)
5100 AC_SUBST(MK_SHARED_LIB)
5101 AC_SUBST(LINK_PROGS)
5102 AC_SUBST(LINK_TESTS)
5103 AC_SUBST(EXTRA_LDFLAGS)
5104 AC_SUBST(LOCAL_LDFLAGS)
5105 AC_SUBST(LOCAL_LDFLAGS2)
5106 AC_SUBST(INSTALL_LIB)
5108 dnl ---------------------------------------------------------------------------
5109 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
5110 dnl ----------------
5111 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
5112 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
5115 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
5116 dnl If missing, use "rel".
5117 define([CF_SHARED_SONAME],
5119 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
5120 if test "$cf_cv_shlib_version" = rel; then
5121 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
5123 cf_cv_shared_soname='`basename $[@]`'
5126 dnl ---------------------------------------------------------------------------
5127 dnl CF_SIGWINCH version: 1 updated: 2006/04/02 16:41:09
5129 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
5130 dnl programs need this test).
5132 dnl This is really a MacOS X 10.4.3 workaround. Defining _POSIX_C_SOURCE
5133 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses). Oddly, the struct
5134 dnl winsize declaration is left alone - we may revisit this if Apple choose to
5135 dnl break that part of the interface as well.
5136 AC_DEFUN([CF_SIGWINCH],
5138 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
5140 #include <sys/types.h>
5141 #include <sys/signal.h>
5142 ],[int x = SIGWINCH],
5143 [cf_cv_define_sigwinch=yes],
5145 #undef _XOPEN_SOURCE
5146 #undef _POSIX_SOURCE
5147 #undef _POSIX_C_SOURCE
5148 #include <sys/types.h>
5149 #include <sys/signal.h>
5150 ],[int x = SIGWINCH],
5151 [cf_cv_define_sigwinch=maybe],
5152 [cf_cv_define_sigwinch=no])
5156 if test "$cf_cv_define_sigwinch" = maybe ; then
5157 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
5158 cf_cv_fixup_sigwinch=unknown
5160 while test $cf_sigwinch != 1
5163 #undef _XOPEN_SOURCE
5164 #undef _POSIX_SOURCE
5165 #undef _POSIX_C_SOURCE
5166 #include <sys/types.h>
5167 #include <sys/signal.h>
5169 #if SIGWINCH != $cf_sigwinch
5173 [cf_cv_fixup_sigwinch=$cf_sigwinch
5176 cf_sigwinch=`expr $cf_sigwinch - 1`
5180 if test "$cf_cv_fixup_sigwinch" != unknown ; then
5181 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
5185 dnl ---------------------------------------------------------------------------
5186 dnl CF_SIG_ATOMIC_T version: 2 updated: 2005/09/18 17:27:12
5188 dnl signal handler, but there are some gcc depedencies in that recommendation.
5190 AC_DEFUN([CF_SIG_ATOMIC_T],
5192 AC_MSG_CHECKING(for signal global datatype)
5193 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
5195 "volatile sig_atomic_t" \
5200 #include <sys/types.h>
5206 static void handler(int sig)
5210 [signal(SIGINT, handler);
5212 [cf_cv_sig_atomic_t=$cf_type],
5213 [cf_cv_sig_atomic_t=no])
5214 test "$cf_cv_sig_atomic_t" != no && break
5217 AC_MSG_RESULT($cf_cv_sig_atomic_t)
5218 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t)
5220 dnl ---------------------------------------------------------------------------
5221 dnl CF_SIZECHANGE version: 8 updated: 2000/11/04 12:22:16
5223 dnl Check for definitions & structures needed for window size-changing
5224 dnl FIXME: check that this works with "snake" (HP-UX 10.x)
5225 AC_DEFUN([CF_SIZECHANGE],
5227 AC_REQUIRE([CF_STRUCT_TERMIOS])
5228 AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[
5229 cf_cv_sizechange=unknown
5230 cf_save_CPPFLAGS="$CPPFLAGS"
5232 for cf_opts in "" "NEED_PTEM_H"
5235 CPPFLAGS="$cf_save_CPPFLAGS"
5236 test -n "$cf_opts" && CPPFLAGS="$CPPFLAGS -D$cf_opts"
5237 AC_TRY_COMPILE([#include <sys/types.h>
5238 #ifdef HAVE_TERMIOS_H
5239 #include <termios.h>
5241 #ifdef HAVE_TERMIO_H
5246 /* This is a workaround for SCO: they neglected to define struct winsize in
5247 * termios.h -- it's only in termio.h and ptem.h
5249 #include <sys/stream.h>
5250 #include <sys/ptem.h>
5252 #if !defined(sun) || !defined(HAVE_TERMIOS_H)
5253 #include <sys/ioctl.h>
5257 struct ttysize win; /* FIXME: what system is this? */
5258 int y = win.ts_lines;
5259 int x = win.ts_cols;
5266 no TIOCGSIZE or TIOCGWINSZ
5267 #endif /* TIOCGWINSZ */
5268 #endif /* TIOCGSIZE */
5270 [cf_cv_sizechange=yes],
5271 [cf_cv_sizechange=no])
5273 CPPFLAGS="$cf_save_CPPFLAGS"
5274 if test "$cf_cv_sizechange" = yes ; then
5275 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC
5276 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts"
5281 if test "$cf_cv_sizechange" != no ; then
5282 AC_DEFINE(HAVE_SIZECHANGE)
5283 case $cf_cv_sizechange in #(vi
5285 AC_DEFINE_UNQUOTED($cf_cv_sizechange )
5290 dnl ---------------------------------------------------------------------------
5291 dnl CF_SRC_MODULES version: 21 updated: 2010/09/04 17:37:40
5293 dnl For each parameter, test if the source-directory exists, and if it contains
5294 dnl a 'modules' file. If so, add to the list $cf_cv_src_modules which we'll
5295 dnl use in CF_LIB_RULES.
5297 dnl This uses the configured value to make the lists SRC_SUBDIRS and
5298 dnl SUB_MAKEFILES which are used in the makefile-generation scheme.
5299 AC_DEFUN([CF_SRC_MODULES],
5301 AC_MSG_CHECKING(for src modules)
5303 # dependencies and linker-arguments for test-programs
5304 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS"
5305 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2"
5306 if test "$DFT_LWR_MODEL" = "libtool"; then
5307 TEST_ARGS="${TEST_DEPS}"
5308 TEST_ARG2="${TEST_DEP2}"
5310 TEST_ARGS="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARGS"
5311 TEST_ARG2="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARG2"
5317 if test -f $srcdir/$cf_dir/modules; then
5319 # We may/may not have tack in the distribution, though the
5321 if test $cf_dir = tack ; then
5322 if test ! -f $srcdir/${cf_dir}/${cf_dir}.h; then
5327 if test -z "$cf_cv_src_modules"; then
5328 cf_cv_src_modules=$cf_dir
5330 cf_cv_src_modules="$cf_cv_src_modules $cf_dir"
5333 # Make the ncurses_cfg.h file record the library interface files as
5334 # well. These are header files that are the same name as their
5335 # directory. Ncurses is the only library that does not follow
5337 if test $cf_dir = tack ; then
5339 elif test -f $srcdir/${cf_dir}/${cf_dir}.h; then
5340 CF_UPPER(cf_have_include,$cf_dir)
5341 AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H)
5342 AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include})
5343 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEPS"
5344 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEP2"
5345 if test "$DFT_LWR_MODEL" = "libtool"; then
5346 TEST_ARGS="${TEST_DEPS}"
5347 TEST_ARG2="${TEST_DEP2}"
5349 TEST_ARGS="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARGS"
5350 TEST_ARG2="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARG2"
5355 AC_MSG_RESULT($cf_cv_src_modules)
5357 TEST_ARGS="-L${LIB_DIR} $TEST_ARGS"
5358 TEST_ARG2="-L${LIB_2ND} $TEST_ARG2"
5367 if test "x$cf_with_manpages" != xno ; then
5368 SRC_SUBDIRS="$SRC_SUBDIRS man"
5370 SRC_SUBDIRS="$SRC_SUBDIRS include"
5371 for cf_dir in $cf_cv_src_modules
5373 SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir"
5375 if test "x$cf_with_tests" != "xno" ; then
5376 SRC_SUBDIRS="$SRC_SUBDIRS test"
5378 test -z "$MAKE_TERMINFO" && SRC_SUBDIRS="$SRC_SUBDIRS misc"
5379 test "$cf_with_cxx_binding" != no && SRC_SUBDIRS="$SRC_SUBDIRS c++"
5382 if test "$cf_cv_prog_gnat_correct" = yes && test -f $srcdir/Ada95/Makefile.in; then
5383 SRC_SUBDIRS="$SRC_SUBDIRS Ada95"
5384 ADA_SUBDIRS="gen src"
5385 if test "x$cf_with_tests" != "xno" ; then
5386 ADA_SUBDIRS="$ADA_SUBDIRS samples"
5391 for cf_dir in $SRC_SUBDIRS
5393 SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile"
5396 if test -n "$ADA_SUBDIRS"; then
5397 for cf_dir in $ADA_SUBDIRS
5399 SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile"
5401 AC_SUBST(ADA_SUBDIRS)
5404 dnl ---------------------------------------------------------------------------
5405 dnl CF_STDCPP_LIBRARY version: 7 updated: 2010/05/29 16:31:02
5406 dnl -----------------
5407 dnl Check for -lstdc++, which is GNU's standard C++ library.
5408 AC_DEFUN([CF_STDCPP_LIBRARY],
5410 if test -n "$GXX" ; then
5411 case $cf_cv_system_name in #(vi
5413 cf_stdcpp_libname=stdcpp
5416 cf_stdcpp_libname=stdc++
5419 AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[
5421 CF_ADD_LIB($cf_stdcpp_libname)
5423 #include <strstream.h>],[
5425 strstreambuf foo(buf, sizeof(buf))
5427 [cf_cv_libstdcpp=yes],
5428 [cf_cv_libstdcpp=no])
5431 test "$cf_cv_libstdcpp" = yes && CF_ADD_LIB($cf_stdcpp_libname,CXXLIBS)
5434 dnl ---------------------------------------------------------------------------
5435 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
5437 dnl Remove "-g" option from the compiler options
5438 AC_DEFUN([CF_STRIP_G_OPT],
5439 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
5440 dnl ---------------------------------------------------------------------------
5441 dnl CF_STRUCT_SIGACTION version: 3 updated: 2000/08/12 23:18:52
5442 dnl -------------------
5443 dnl Check if we need _POSIX_SOURCE defined to use struct sigaction. We'll only
5444 dnl do this if we've found the sigaction function.
5446 dnl If needed, define SVR4_ACTION.
5447 AC_DEFUN([CF_STRUCT_SIGACTION],[
5448 if test "$ac_cv_func_sigaction" = yes; then
5449 AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE)
5451 #include <sys/types.h>
5452 #include <signal.h>],
5453 [struct sigaction act],
5457 #define _POSIX_SOURCE
5458 #include <sys/types.h>
5459 #include <signal.h>],
5460 [struct sigaction act],
5462 AC_DEFINE(SVR4_ACTION)],
5463 [sigact_bad=unknown])])
5464 AC_MSG_RESULT($sigact_bad)
5467 dnl ---------------------------------------------------------------------------
5468 dnl CF_STRUCT_TERMIOS version: 5 updated: 2000/11/04 12:22:46
5469 dnl -----------------
5470 dnl Some machines require _POSIX_SOURCE to completely define struct termios.
5471 dnl If so, define SVR4_TERMIO
5472 AC_DEFUN([CF_STRUCT_TERMIOS],[
5478 if test "$ISC" = yes ; then
5479 AC_CHECK_HEADERS( sys/termio.h )
5481 if test "$ac_cv_header_termios_h" = yes ; then
5482 case "$CFLAGS $CPPFLAGS" in
5484 termios_bad=dunno ;;
5485 *) termios_bad=maybe ;;
5487 if test "$termios_bad" = maybe ; then
5488 AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE)
5489 AC_TRY_COMPILE([#include <termios.h>],
5490 [struct termios foo; int x = foo.c_iflag],
5493 #define _POSIX_SOURCE
5494 #include <termios.h>],
5495 [struct termios foo; int x = foo.c_iflag],
5496 termios_bad=unknown,
5497 termios_bad=yes AC_DEFINE(SVR4_TERMIO))
5499 AC_MSG_RESULT($termios_bad)
5503 dnl ---------------------------------------------------------------------------
5504 dnl CF_SUBDIR_PATH version: 6 updated: 2010/04/21 06:20:50
5506 dnl Construct a search-list for a nonstandard header/lib-file
5507 dnl $1 = the variable to return as result
5508 dnl $2 = the package name
5509 dnl $3 = the subdirectory, e.g., bin, include or lib
5510 AC_DEFUN([CF_SUBDIR_PATH],
5514 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr,$prefix)
5515 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
5516 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr/local,$prefix)
5517 CF_ADD_SUBDIR_PATH($1,$2,$3,/opt,$prefix)
5518 CF_ADD_SUBDIR_PATH($1,$2,$3,[$]HOME,$prefix)
5520 dnl ---------------------------------------------------------------------------
5521 dnl CF_SUBST version: 4 updated: 2006/06/17 12:33:03
5523 dnl Shorthand macro for substituting things that the user may override
5524 dnl with an environment variable.
5526 dnl $1 = long/descriptive name
5527 dnl $2 = environment variable
5528 dnl $3 = default value
5529 AC_DEFUN([CF_SUBST],
5530 [AC_CACHE_VAL(cf_cv_subst_$2,[
5531 AC_MSG_CHECKING(for $1 (symbol $2))
5532 CF_SUBST_IF([-z "[$]$2"], [$2], [$3])
5533 cf_cv_subst_$2=[$]$2
5534 AC_MSG_RESULT([$]$2)
5537 dnl ---------------------------------------------------------------------------
5538 dnl CF_SUBST_IF version: 2 updated: 2006/06/17 12:33:03
5540 dnl Shorthand macro for substituting things that the user may override
5541 dnl with an environment variable.
5543 dnl $1 = condition to pass to "test"
5544 dnl $2 = environment variable
5545 dnl $3 = value if the test succeeds
5546 dnl $4 = value if the test fails
5547 AC_DEFUN([CF_SUBST_IF],
5556 dnl ---------------------------------------------------------------------------
5557 dnl CF_SUBST_NCURSES_VERSION version: 8 updated: 2006/09/16 11:40:59
5558 dnl ------------------------
5559 dnl Get the version-number for use in shared-library naming, etc.
5560 AC_DEFUN([CF_SUBST_NCURSES_VERSION],
5562 AC_REQUIRE([CF_PROG_EGREP])
5563 NCURSES_MAJOR="`$ac_cv_prog_egrep '^NCURSES_MAJOR[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
5564 NCURSES_MINOR="`$ac_cv_prog_egrep '^NCURSES_MINOR[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
5565 NCURSES_PATCH="`$ac_cv_prog_egrep '^NCURSES_PATCH[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
5566 cf_cv_abi_version=${NCURSES_MAJOR}
5567 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
5568 dnl Show the computed version, for logging
5569 cf_cv_timestamp=`date`
5570 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
5571 dnl We need these values in the generated headers
5572 AC_SUBST(NCURSES_MAJOR)
5573 AC_SUBST(NCURSES_MINOR)
5574 AC_SUBST(NCURSES_PATCH)
5575 dnl We need these values in the generated makefiles
5576 AC_SUBST(cf_cv_rel_version)
5577 AC_SUBST(cf_cv_abi_version)
5578 AC_SUBST(cf_cv_builtin_bool)
5579 AC_SUBST(cf_cv_header_stdbool_h)
5580 AC_SUBST(cf_cv_type_of_bool)dnl
5582 dnl ---------------------------------------------------------------------------
5583 dnl CF_SYS_TIME_SELECT version: 4 updated: 2000/10/04 09:18:40
5584 dnl ------------------
5585 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
5586 dnl older SCO configurations.
5587 AC_DEFUN([CF_SYS_TIME_SELECT],
5589 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
5590 AC_CACHE_VAL(cf_cv_sys_time_select,[
5592 #include <sys/types.h>
5593 #ifdef HAVE_SYS_TIME_H
5594 #include <sys/time.h>
5596 #ifdef HAVE_SYS_SELECT_H
5597 #include <sys/select.h>
5599 ],[],[cf_cv_sys_time_select=yes],
5600 [cf_cv_sys_time_select=no])
5602 AC_MSG_RESULT($cf_cv_sys_time_select)
5603 test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT)
5605 dnl ---------------------------------------------------------------------------
5606 dnl CF_TOP_BUILDDIR version: 1 updated: 2006/10/15 16:33:23
5608 dnl Define a top_builddir symbol, for applications that need an absolute path.
5609 AC_DEFUN([CF_TOP_BUILDDIR],
5612 AC_SUBST(top_builddir)
5614 dnl ---------------------------------------------------------------------------
5615 dnl CF_TYPEOF_CHTYPE version: 8 updated: 2006/12/16 12:33:30
5616 dnl ----------------
5617 dnl Determine the type we should use for chtype (and attr_t, which is treated
5618 dnl as the same thing). We want around 32 bits, so on most machines want a
5619 dnl long, but on newer 64-bit machines, probably want an int. If we're using
5620 dnl wide characters, we have to have a type compatible with that, as well.
5621 AC_DEFUN([CF_TYPEOF_CHTYPE],
5623 AC_MSG_CHECKING([for type of chtype])
5624 AC_CACHE_VAL(cf_cv_typeof_chtype,[
5626 #define WANT_BITS 31
5630 FILE *fp = fopen("cf_test.out", "w");
5632 char *result = "long";
5633 if (sizeof(unsigned long) > sizeof(unsigned int)) {
5636 for (n = 0; n < WANT_BITS; n++) {
5639 if (y != 1 || x == 0) {
5645 * If x is nonzero, an int is big enough for the bits
5648 result = (x != 0) ? "int" : "long";
5653 ${cf_cv_main_return:-return}(0);
5656 [cf_cv_typeof_chtype=`cat cf_test.out`],
5657 [cf_cv_typeof_chtype=long],
5658 [cf_cv_typeof_chtype=long])
5661 AC_MSG_RESULT($cf_cv_typeof_chtype)
5663 AC_SUBST(cf_cv_typeof_chtype)
5664 AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype)
5666 dnl ---------------------------------------------------------------------------
5667 dnl CF_TYPE_SIGACTION version: 3 updated: 2000/08/12 23:18:52
5668 dnl -----------------
5670 AC_DEFUN([CF_TYPE_SIGACTION],
5672 AC_MSG_CHECKING([for type sigaction_t])
5673 AC_CACHE_VAL(cf_cv_type_sigaction,[
5675 #include <signal.h>],
5677 [cf_cv_type_sigaction=yes],
5678 [cf_cv_type_sigaction=no])])
5679 AC_MSG_RESULT($cf_cv_type_sigaction)
5680 test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION)
5682 dnl ---------------------------------------------------------------------------
5683 dnl CF_UNSIGNED_LITERALS version: 2 updated: 1998/02/07 22:10:16
5684 dnl --------------------
5685 dnl Test if the compiler supports 'U' and 'L' suffixes. Only old compilers
5686 dnl won't, but they're still there.
5687 AC_DEFUN([CF_UNSIGNED_LITERALS],
5689 AC_MSG_CHECKING([if unsigned literals are legal])
5690 AC_CACHE_VAL(cf_cv_unsigned_literals,[
5691 AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1],
5692 [cf_cv_unsigned_literals=yes],
5693 [cf_cv_unsigned_literals=no])
5695 AC_MSG_RESULT($cf_cv_unsigned_literals)
5697 dnl ---------------------------------------------------------------------------
5698 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
5700 dnl Make an uppercase version of a variable
5701 dnl $1=uppercase($2)
5702 AC_DEFUN([CF_UPPER],
5704 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
5706 dnl ---------------------------------------------------------------------------
5707 dnl CF_UTF8_LIB version: 7 updated: 2010/06/20 09:24:28
5709 dnl Check for multibyte support, and if not found, utf8 compatibility library
5710 AC_DEFUN([CF_UTF8_LIB],
5712 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
5713 cf_save_LIBS="$LIBS"
5715 #include <stdlib.h>],[putwc(0,0);],
5716 [cf_cv_utf8_lib=yes],
5718 #include <libutf8.h>],[putwc(0,0);],utf8,
5719 [cf_cv_utf8_lib=add-on],
5720 [cf_cv_utf8_lib=no])
5723 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
5725 if test "$cf_cv_utf8_lib" = "add-on" ; then
5726 AC_DEFINE(HAVE_LIBUTF8_H)
5727 CF_ADD_INCDIR($cf_cv_header_path_utf8)
5728 CF_ADD_LIBDIR($cf_cv_library_path_utf8)
5729 CF_ADD_LIBS($cf_cv_library_file_utf8)
5732 dnl ---------------------------------------------------------------------------
5733 dnl CF_VA_COPY version: 2 updated: 2010/03/04 05:37:29
5735 dnl check for va_copy, part of stdarg.h
5736 dnl Also, workaround for glibc's __va_copy, by checking for both.
5737 AC_DEFUN([CF_VA_COPY],[
5738 AC_CACHE_CHECK(for va_copy, cf_cv_have_va_copy,[
5745 cf_cv_have_va_copy=yes,
5746 cf_cv_have_va_copy=no)])
5748 test "$cf_cv_have_va_copy" = yes && AC_DEFINE(HAVE_VA_COPY)
5750 AC_CACHE_CHECK(for __va_copy, cf_cv_have___va_copy,[
5756 __va_copy(dst, src)],
5757 cf_cv_have___va_copy=yes,
5758 cf_cv_have___va_copy=no)])
5760 test "$cf_cv_have___va_copy" = yes && AC_DEFINE(HAVE___VA_COPY)
5762 dnl ---------------------------------------------------------------------------
5763 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
5765 dnl Use AC_VERBOSE w/o the warnings
5766 AC_DEFUN([CF_VERBOSE],
5767 [test -n "$verbose" && echo " $1" 1>&AC_FD_MSG
5770 dnl ---------------------------------------------------------------------------
5771 dnl CF_WCHAR_TYPE version: 3 updated: 2010/05/26 16:44:57
5773 dnl Check if type wide-character type $1 is declared, and if so, which header
5774 dnl file is needed. The second parameter is used to set a shell variable when
5775 dnl the type is not found. The first parameter sets a shell variable for the
5777 AC_DEFUN([CF_WCHAR_TYPE],
5779 # This is needed on Tru64 5.0 to declare $1
5780 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
5785 #ifdef HAVE_LIBUTF8_H
5786 #include <libutf8.h>
5795 #ifdef HAVE_LIBUTF8_H
5796 #include <libutf8.h>
5800 [cf_cv_$1=unknown])])])
5802 if test "$cf_cv_$1" = yes ; then
5803 AC_DEFINE(NEED_WCHAR_H)
5808 # if we do not find $1 in either place, use substitution to provide a fallback.
5809 if test "$cf_cv_$1" = unknown ; then
5814 # if we find $1 in either place, use substitution to provide a fallback.
5815 if test "$cf_cv_$1" != unknown ; then
5820 dnl ---------------------------------------------------------------------------
5821 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
5823 dnl Check for compiler-support for weak symbols.
5824 dnl This works with "recent" gcc.
5825 AC_DEFUN([CF_WEAK_SYMBOLS],[
5826 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
5829 #include <stdio.h>],
5831 #if defined(__GNUC__)
5832 # if defined __USE_ISOC99
5833 # define _cat_pragma(exp) _Pragma(#exp)
5834 # define _weak_pragma(exp) _cat_pragma(weak name)
5836 # define _weak_pragma(exp)
5838 # define _declare(name) __extension__ extern __typeof__(name) name
5839 # define weak_symbol(name) _weak_pragma(name) _declare(name) __attribute__((weak))
5843 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
5846 dnl ---------------------------------------------------------------------------
5847 dnl CF_WITH_ABI_VERSION version: 1 updated: 2003/09/20 18:12:49
5848 dnl -------------------
5849 dnl Allow library's ABI to be overridden. Generally this happens when a
5850 dnl packager has incremented the ABI past that used in the original package,
5851 dnl and wishes to keep doing this.
5853 dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
5855 AC_DEFUN([CF_WITH_ABI_VERSION],[
5856 test -z "$cf_cv_abi_version" && cf_cv_abi_version=0
5857 AC_ARG_WITH(abi-version,
5858 [ --with-abi-version=XXX override derived ABI version],
5859 [AC_MSG_WARN(overriding ABI version $cf_cv_abi_version to $withval)
5860 cf_cv_abi_version=$withval])
5861 CF_NUMBER_SYNTAX($cf_cv_abi_version,ABI version)
5863 $1_ABI=$cf_cv_abi_version
5866 dnl ---------------------------------------------------------------------------
5867 dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58
5868 dnl --------------------
5869 dnl Command-line option to specify the Ada95 compiler.
5870 AC_DEFUN([CF_WITH_ADA_COMPILER],[
5871 AC_MSG_CHECKING(for ada-compiler)
5872 AC_ARG_WITH(ada-compiler,
5873 [ --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
5874 [cf_ada_compiler=$withval],
5875 [cf_ada_compiler=gnatmake])
5876 AC_SUBST(cf_ada_compiler)
5877 AC_MSG_RESULT($cf_ada_compiler)
5879 dnl ---------------------------------------------------------------------------
5880 dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58
5881 dnl -------------------
5882 dnl Command-line option to specify where Ada includes will install.
5883 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
5884 AC_MSG_CHECKING(for ada-include)
5885 CF_WITH_PATH(ada-include,
5886 [ --with-ada-include=DIR Ada includes are in DIR],
5888 PREFIX/share/ada/adainclude,
5889 [$]prefix/share/ada/adainclude)
5890 AC_SUBST(ADA_INCLUDE)
5891 AC_MSG_RESULT($ADA_INCLUDE)
5893 dnl ---------------------------------------------------------------------------
5894 dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58
5895 dnl -------------------
5896 dnl Command-line option to specify where Ada objects will install.
5897 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
5898 AC_MSG_CHECKING(for ada-objects)
5899 CF_WITH_PATH(ada-objects,
5900 [ --with-ada-objects=DIR Ada objects are in DIR],
5902 PREFIX/lib/ada/adalib,
5903 [$]prefix/lib/ada/adalib)
5904 AC_SUBST(ADA_OBJECTS)
5905 AC_MSG_RESULT($ADA_OBJECTS)
5907 dnl ---------------------------------------------------------------------------
5908 dnl CF_WITH_ADA_SHAREDLIB version: 2 updated: 2010/06/26 17:35:58
5909 dnl ---------------------
5910 dnl Command-line option to specify if an Ada95 shared-library should be built,
5911 dnl and optionally what its soname should be.
5912 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
5913 AC_MSG_CHECKING(if an Ada95 shared-library should be built)
5914 AC_ARG_WITH(ada-sharedlib,
5915 [ --with-ada-sharedlib=XX build Ada95 shared-library],
5916 [with_ada_sharedlib=$withval],
5917 [with_ada_sharedlib=no])
5918 AC_MSG_RESULT($with_ada_sharedlib)
5920 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
5921 MAKE_ADA_SHAREDLIB="#"
5923 if test "x$with_ada_sharedlib" != xno
5926 if test "x$with_ada_sharedlib" != xyes
5928 ADA_SHAREDLIB="$with_ada_sharedlib"
5932 AC_SUBST(ADA_SHAREDLIB)
5933 AC_SUBST(MAKE_ADA_SHAREDLIB)
5935 dnl ---------------------------------------------------------------------------
5936 dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
5937 dnl ----------------
5938 dnl Configure-option for dbmalloc. The optional parameter is used to override
5939 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
5940 AC_DEFUN([CF_WITH_DBMALLOC],[
5941 CF_NO_LEAKS_OPTION(dbmalloc,
5942 [ --with-dbmalloc test: use Conor Cahill's dbmalloc library],
5945 if test "$with_dbmalloc" = yes ; then
5946 AC_CHECK_HEADER(dbmalloc.h,
5947 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
5950 dnl ---------------------------------------------------------------------------
5951 dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
5953 dnl Configure-option for dmalloc. The optional parameter is used to override
5954 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
5955 AC_DEFUN([CF_WITH_DMALLOC],[
5956 CF_NO_LEAKS_OPTION(dmalloc,
5957 [ --with-dmalloc test: use Gray Watson's dmalloc library],
5960 if test "$with_dmalloc" = yes ; then
5961 AC_CHECK_HEADER(dmalloc.h,
5962 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
5965 dnl ---------------------------------------------------------------------------
5966 dnl CF_WITH_GPM version: 7 updated: 2008/03/23 14:48:54
5969 dnl The option parameter (if neither yes/no) is assumed to be the name of
5970 dnl the gpm library, e.g., for dynamic loading.
5971 AC_DEFUN([CF_WITH_GPM],
5973 AC_MSG_CHECKING(if you want to link with the GPM mouse library)
5975 [ --with-gpm use Alessandro Rubini's GPM library],
5976 [with_gpm=$withval],
5978 AC_MSG_RESULT($with_gpm)
5980 if test "$with_gpm" != no ; then
5981 AC_CHECK_HEADER(gpm.h,[
5982 AC_DEFINE(HAVE_GPM_H)
5983 if test "$with_gpm" != yes && test "$with_gpm" != maybe ; then
5984 CF_VERBOSE(assuming we really have GPM library)
5985 AC_DEFINE(HAVE_LIBGPM)
5987 AC_CHECK_LIB(gpm,Gpm_Open,[:],[
5988 AC_MSG_ERROR(Cannot link with GPM library)
5993 test "$with_gpm" != maybe && AC_MSG_WARN(Cannot find GPM header)
5998 dnl ---------------------------------------------------------------------------
5999 dnl CF_WITH_LIBTOOL version: 26 updated: 2010/10/23 15:55:24
6001 dnl Provide a configure option to incorporate libtool. Define several useful
6002 dnl symbols for the makefile rules.
6004 dnl The reference to AC_PROG_LIBTOOL does not normally work, since it uses
6005 dnl macros from libtool.m4 which is in the aclocal directory of automake.
6006 dnl Following is a simple script which turns on the AC_PROG_LIBTOOL macro.
6007 dnl But that still does not work properly since the macro is expanded outside
6008 dnl the CF_WITH_LIBTOOL macro:
6011 dnl ACLOCAL=`aclocal --print-ac-dir`
6012 dnl if test -z "$ACLOCAL" ; then
6013 dnl echo cannot find aclocal directory
6015 dnl elif test ! -f $ACLOCAL/libtool.m4 ; then
6016 dnl echo cannot find libtool.m4 file
6020 dnl LOCAL=aclocal.m4
6021 dnl ORIG=aclocal.m4.orig
6023 dnl trap "mv $ORIG $LOCAL" 0 1 2 5 15
6027 dnl # sed the LIBTOOL= assignment to omit the current directory?
6028 dnl sed -e 's/^LIBTOOL=.*/LIBTOOL=${LIBTOOL:-libtool}/' $ACLOCAL/libtool.m4 >>$LOCAL
6029 dnl cat $ORIG >>$LOCAL
6033 AC_DEFUN([CF_WITH_LIBTOOL],
6035 AC_REQUIRE([CF_DISABLE_LIBTOOL_VERSION])
6036 ifdef([AC_PROG_LIBTOOL],,[
6039 # common library maintenance symbols that are convenient for libtool scripts:
6040 LIB_CREATE='${AR} -cr'
6041 LIB_OBJECT='${OBJECTS}'
6045 # symbols used to prop libtool up to enable it to determine what it should be
6053 AC_MSG_CHECKING(if you want to build libraries with libtool)
6054 AC_ARG_WITH(libtool,
6055 [ --with-libtool generate libraries with libtool],
6056 [with_libtool=$withval],
6058 AC_MSG_RESULT($with_libtool)
6059 if test "$with_libtool" != "no"; then
6060 ifdef([AC_PROG_LIBTOOL],[
6061 # missing_content_AC_PROG_LIBTOOL{{
6063 # missing_content_AC_PROG_LIBTOOL}}
6065 if test "$with_libtool" != "yes" ; then
6066 CF_PATH_SYNTAX(with_libtool)
6067 LIBTOOL=$with_libtool
6069 AC_PATH_PROG(LIBTOOL,libtool)
6071 if test -z "$LIBTOOL" ; then
6072 AC_MSG_ERROR(Cannot find libtool)
6075 LIB_CREATE='${LIBTOOL} --mode=link ${CC} -rpath ${DESTDIR}${libdir} ${LIBTOOL_VERSION} `cut -f1 ${srcdir}/VERSION` ${LIBTOOL_OPTS} ${LT_UNDEF} -o'
6076 LIB_OBJECT='${OBJECTS:.o=.lo}'
6078 LIB_CLEAN='${LIBTOOL} --mode=clean'
6079 LIB_COMPILE='${LIBTOOL} --mode=compile'
6080 LIB_LINK='${LIBTOOL} --mode=link ${CC} ${LIBTOOL_OPTS}'
6081 LIB_INSTALL='${LIBTOOL} --mode=install'
6082 LIB_UNINSTALL='${LIBTOOL} --mode=uninstall'
6085 # Show the version of libtool
6086 AC_MSG_CHECKING(version of libtool)
6088 # Save the version in a cache variable - this is not entirely a good
6089 # thing, but the version string from libtool is very ugly, and for
6090 # bug reports it might be useful to have the original string. "("
6091 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.]].*//'`
6092 AC_MSG_RESULT($cf_cv_libtool_version)
6093 if test -z "$cf_cv_libtool_version" ; then
6094 AC_MSG_ERROR(This is not GNU libtool)
6097 # special hack to add -no-undefined (which libtool should do for itself)
6099 case "$cf_cv_system_name" in #(vi
6100 cygwin*|mingw32*|uwin*|aix[[456]]) #(vi
6101 LT_UNDEF=-no-undefined
6104 AC_SUBST([LT_UNDEF])
6106 # special hack to add --tag option for C++ compiler
6107 case $cf_cv_libtool_version in #(vi
6108 1.[[5-9]]*|[[2-9]].[[0-9.a-z]]*) #(vi
6109 LIBTOOL_CXX="$LIBTOOL --tag=CXX"
6110 LIBTOOL="$LIBTOOL --tag=CC"
6113 LIBTOOL_CXX="$LIBTOOL"
6121 test -z "$LIBTOOL" && ECHO_LT=
6124 AC_SUBST(LIBTOOL_CXX)
6125 AC_SUBST(LIBTOOL_OPTS)
6127 AC_SUBST(LIB_CREATE)
6128 AC_SUBST(LIB_OBJECT)
6129 AC_SUBST(LIB_SUFFIX)
6133 AC_SUBST(LIB_COMPILE)
6135 AC_SUBST(LIB_INSTALL)
6136 AC_SUBST(LIB_UNINSTALL)
6139 dnl ---------------------------------------------------------------------------
6140 dnl CF_WITH_PATH version: 10 updated: 2010/10/23 15:44:18
6142 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
6143 dnl defaulting to yes/no.
6145 dnl $1 = option name
6147 dnl $3 = environment variable to set
6148 dnl $4 = default value, shown in the help-message, must be a constant
6149 dnl $5 = default value, if it's an expression & cannot be in the help-message
6151 AC_DEFUN([CF_WITH_PATH],
6152 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
6153 ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
6154 if ifelse([$5],,true,[test -n "$5"]) ; then
6155 CF_PATH_SYNTAX(withval)
6160 dnl ---------------------------------------------------------------------------
6161 dnl CF_WITH_PATHLIST version: 7 updated: 2010/10/23 16:10:30
6162 dnl ----------------
6163 dnl Process an option specifying a list of colon-separated paths.
6165 dnl $1 = option name
6167 dnl $3 = environment variable to set
6168 dnl $4 = default value, shown in the help-message, must be a constant
6169 dnl $5 = default value, if it's an expression & cannot be in the help-message
6170 dnl $6 = flag to tell if we want to define or substitute
6172 AC_DEFUN([CF_WITH_PATHLIST],[
6173 AC_REQUIRE([CF_PATHSEP])
6174 AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
6175 ifelse($4,,[withval=${$3}],[withval=${$3:-ifelse($5,,$4,$5)}]))dnl
6177 IFS="${IFS:- }"; ac_save_ifs="$IFS"; IFS="${PATH_SEPARATOR}"
6179 for cf_src_path in $withval
6181 CF_PATH_SYNTAX(cf_src_path)
6182 test -n "$cf_dst_path" && cf_dst_path="${cf_dst_path}:"
6183 cf_dst_path="${cf_dst_path}${cf_src_path}"
6188 # Strip single quotes from the value, e.g., when it was supplied as a literal
6190 case $cf_dst_path in #(vi
6192 cf_dst_path=`echo $cf_dst_path |sed -e s/\'// -e s/\'\$//`
6195 cf_dst_path=`echo "$cf_dst_path" | sed -e 's/\\\\/\\\\\\\\/g'`
6198 eval '$3="$cf_dst_path"'
6202 dnl ---------------------------------------------------------------------------
6203 dnl CF_WITH_PTHREAD version: 3 updated: 2010/05/29 16:31:02
6205 dnl Check for POSIX thread library.
6206 AC_DEFUN([CF_WITH_PTHREAD],
6208 AC_MSG_CHECKING(if you want to link with the pthread library)
6209 AC_ARG_WITH(pthread,
6210 [ --with-pthread use POSIX thread library],
6211 [with_pthread=$withval],
6213 AC_MSG_RESULT($with_pthread)
6215 if test "$with_pthread" != no ; then
6216 AC_CHECK_HEADER(pthread.h,[
6217 AC_DEFINE(HAVE_PTHREADS_H)
6219 AC_MSG_CHECKING(if we can link with the pthread library)
6220 cf_save_LIBS="$LIBS"
6223 #include <pthread.h>
6225 int rc = pthread_create(0,0,0,0);
6226 ],[with_pthread=yes],[with_pthread=no])
6227 LIBS="$cf_save_LIBS"
6228 AC_MSG_RESULT($with_pthread)
6230 if test "$with_pthread" = yes ; then
6232 AC_DEFINE(HAVE_LIBPTHREADS)
6234 AC_MSG_ERROR(Cannot link with pthread library)
6239 dnl ---------------------------------------------------------------------------
6240 dnl CF_WITH_REL_VERSION version: 1 updated: 2003/09/20 18:12:49
6241 dnl -------------------
6242 dnl Allow library's release-version to be overridden. Generally this happens when a
6243 dnl packager has incremented the release-version past that used in the original package,
6244 dnl and wishes to keep doing this.
6246 dnl $1 is the package name, if any, to derive corresponding {package}_MAJOR
6247 dnl and {package}_MINOR symbols
6249 AC_DEFUN([CF_WITH_REL_VERSION],[
6250 test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0
6251 AC_ARG_WITH(rel-version,
6252 [ --with-rel-version=XXX override derived release version],
6253 [AC_MSG_WARN(overriding release version $cf_cv_rel_version to $withval)
6254 cf_cv_rel_version=$withval])
6256 CF_NUMBER_SYNTAX($cf_cv_rel_version,Release version)
6258 $1_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'`
6259 $1_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[[^.]]*//' -e 's/^\.//' -e 's/\..*//'`
6260 CF_NUMBER_SYNTAX([$]$1_MAJOR,Release major-version)
6261 CF_NUMBER_SYNTAX([$]$1_MINOR,Release minor-version)
6264 dnl ---------------------------------------------------------------------------
6265 dnl CF_WITH_SYSMOUSE version: 2 updated: 2003/03/22 19:13:43
6266 dnl ----------------
6267 dnl If we can compile with sysmouse, make it available unless it is not wanted.
6268 AC_DEFUN([CF_WITH_SYSMOUSE],[
6269 # not everyone has "test -c"
6270 if test -c /dev/sysmouse 2>/dev/null ; then
6271 AC_MSG_CHECKING(if you want to use sysmouse)
6272 AC_ARG_WITH(sysmouse,
6273 [ --with-sysmouse use sysmouse (FreeBSD console)],
6274 [cf_with_sysmouse=$withval],
6275 [cf_with_sysmouse=maybe])
6276 if test "$cf_with_sysmouse" != no ; then
6278 #include <osreldate.h>
6279 #if (__FreeBSD_version >= 400017)
6280 #include <sys/consio.h>
6281 #include <sys/fbio.h>
6283 #include <machine/console.h>
6286 struct mouse_info the_mouse;
6287 ioctl(0, CONS_MOUSECTL, &the_mouse);
6288 ],[cf_with_sysmouse=yes],[cf_with_sysmouse=no])
6290 AC_MSG_RESULT($cf_with_sysmouse)
6291 test "$cf_with_sysmouse" = yes && AC_DEFINE(USE_SYSMOUSE)
6294 dnl ---------------------------------------------------------------------------
6295 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
6296 dnl ----------------
6297 AC_DEFUN([CF_WITH_VALGRIND],[
6298 CF_NO_LEAKS_OPTION(valgrind,
6299 [ --with-valgrind test: use valgrind],
6302 dnl ---------------------------------------------------------------------------
6303 dnl CF_XOPEN_SOURCE version: 34 updated: 2010/05/26 05:38:42
6305 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
6306 dnl or adapt to the vendor's definitions to get equivalent functionality,
6307 dnl without losing the common non-POSIX features.
6310 dnl $1 is the nominal value for _XOPEN_SOURCE
6311 dnl $2 is the nominal value for _POSIX_C_SOURCE
6312 AC_DEFUN([CF_XOPEN_SOURCE],[
6314 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
6315 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
6318 case $host_os in #(vi
6320 cf_xopen_source="-D_ALL_SOURCE"
6322 darwin[[0-8]].*) #(vi
6323 cf_xopen_source="-D_APPLE_C_SOURCE"
6326 cf_xopen_source="-D_DARWIN_C_SOURCE"
6328 freebsd*|dragonfly*) #(vi
6329 # 5.x headers associate
6330 # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
6331 # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
6332 cf_POSIX_C_SOURCE=200112L
6334 cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
6337 cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
6340 cf_xopen_source="-D_HPUX_SOURCE"
6343 cf_xopen_source="-D_SGI_SOURCE"
6345 linux*|gnu*|mint*|k*bsd*-gnu) #(vi
6349 # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <arpa/inet.h>
6352 # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
6355 # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
6358 cf_xopen_source="-D_OSF_SOURCE"
6361 cf_xopen_source="-D_QNX_SOURCE"
6364 # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
6366 solaris2.1[[0-9]]) #(vi
6367 cf_xopen_source="-D__EXTENSIONS__ -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
6369 solaris2.[[1-9]]) #(vi
6370 cf_xopen_source="-D__EXTENSIONS__"
6373 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
6374 AC_TRY_COMPILE([#include <sys/types.h>],[
6375 #ifndef _XOPEN_SOURCE
6378 [cf_cv_xopen_source=no],
6379 [cf_save="$CPPFLAGS"
6380 CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
6381 AC_TRY_COMPILE([#include <sys/types.h>],[
6382 #ifdef _XOPEN_SOURCE
6385 [cf_cv_xopen_source=no],
6386 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
6390 if test "$cf_cv_xopen_source" != no ; then
6391 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
6392 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
6393 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
6394 CF_ADD_CFLAGS($cf_temp_xopen_source)
6396 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
6400 if test -n "$cf_xopen_source" ; then
6401 CF_ADD_CFLAGS($cf_xopen_source)