32c88f582d62d8a39d2372605974ff8f6fa241a7
[ncurses.git] / aclocal.m4
1 dnl***************************************************************************
2 dnl Copyright (c) 1998-2006,2007 Free Software Foundation, Inc.              *
3 dnl                                                                          *
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:                 *
11 dnl                                                                          *
12 dnl The above copyright notice and this permission notice shall be included  *
13 dnl in all copies or substantial portions of the Software.                   *
14 dnl                                                                          *
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.                               *
22 dnl                                                                          *
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       *
26 dnl authorization.                                                           *
27 dnl***************************************************************************
28 dnl
29 dnl Author: Thomas E. Dickey 1995-on
30 dnl
31 dnl $Id: aclocal.m4,v 1.440 2007/11/25 00:58:01 tom Exp $
32 dnl Macros used in NCURSES auto-configuration script.
33 dnl
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.
37 dnl
38 dnl See http://invisible-island.net/autoconf/ for additional information.
39 dnl
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
46 dnl codeset.m4
47 dnl ====================
48 dnl serial AM1
49 dnl
50 dnl From Bruno Haible.
51 AC_DEFUN([AM_LANGINFO_CODESET],
52 [
53   AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset,
54     [AC_TRY_LINK([#include <langinfo.h>],
55       [char* cs = nl_langinfo(CODESET);],
56       am_cv_langinfo_codeset=yes,
57       am_cv_langinfo_codeset=no)
58     ])
59   if test $am_cv_langinfo_codeset = yes; then
60     AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
61       [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
62   fi
63 ])dnl
64 dnl ---------------------------------------------------------------------------
65 dnl CF_ADA_INCLUDE_DIRS version: 5 updated: 2006/10/14 15:23:15
66 dnl -------------------
67 dnl Construct the list of include-options for the C programs in the Ada95
68 dnl binding.
69 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
70 [
71 ACPPFLAGS="-I. -I../../include $ACPPFLAGS"
72 if test "$srcdir" != "."; then
73         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
74 fi
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}"
81                 fi
82         else
83                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
84         fi
85 fi
86 AC_SUBST(ACPPFLAGS)
87 ])dnl
88 dnl ---------------------------------------------------------------------------
89 dnl CF_ADD_CFLAGS version: 7 updated: 2004/04/25 17:48:30
90 dnl -------------
91 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
92 dnl The second parameter if given makes this macro verbose.
93 dnl
94 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
95 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
96 dnl confused by the quotes (which require backslashes to keep them usable).
97 AC_DEFUN([CF_ADD_CFLAGS],
98 [
99 cf_fix_cppflags=no
100 cf_new_cflags=
101 cf_new_cppflags=
102 cf_new_extra_cppflags=
103
104 for cf_add_cflags in $1
105 do
106 case $cf_fix_cppflags in
107 no)
108         case $cf_add_cflags in #(vi
109         -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi
110                 case $cf_add_cflags in
111                 -D*)
112                         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
113
114                         test "${cf_add_cflags}" != "${cf_tst_cflags}" \
115                         && test -z "${cf_tst_cflags}" \
116                         && cf_fix_cppflags=yes
117
118                         if test $cf_fix_cppflags = yes ; then
119                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
120                                 continue
121                         elif test "${cf_tst_cflags}" = "\"'" ; then
122                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
123                                 continue
124                         fi
125                         ;;
126                 esac
127                 case "$CPPFLAGS" in
128                 *$cf_add_cflags) #(vi
129                         ;;
130                 *) #(vi
131                         cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
132                         ;;
133                 esac
134                 ;;
135         *)
136                 cf_new_cflags="$cf_new_cflags $cf_add_cflags"
137                 ;;
138         esac
139         ;;
140 yes)
141         cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
142
143         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
144
145         test "${cf_add_cflags}" != "${cf_tst_cflags}" \
146         && test -z "${cf_tst_cflags}" \
147         && cf_fix_cppflags=no
148         ;;
149 esac
150 done
151
152 if test -n "$cf_new_cflags" ; then
153         ifelse($2,,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
154         CFLAGS="$CFLAGS $cf_new_cflags"
155 fi
156
157 if test -n "$cf_new_cppflags" ; then
158         ifelse($2,,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
159         CPPFLAGS="$cf_new_cppflags $CPPFLAGS"
160 fi
161
162 if test -n "$cf_new_extra_cppflags" ; then
163         ifelse($2,,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
164         EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
165 fi
166
167 AC_SUBST(EXTRA_CPPFLAGS)
168
169 ])dnl
170 dnl ---------------------------------------------------------------------------
171 dnl CF_ADD_INCDIR version: 8 updated: 2007/07/30 19:22:58
172 dnl -------------
173 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it's
174 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
175 dnl but old versions (and some misinstalled ones) need that.  To make things
176 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
177 dnl the include-path).
178 AC_DEFUN([CF_ADD_INCDIR],
179 [
180 if test -n "$1" ; then
181   for cf_add_incdir in $1
182   do
183         while test $cf_add_incdir != /usr/include
184         do
185           if test -d $cf_add_incdir
186           then
187                 cf_have_incdir=no
188                 if test -n "$CFLAGS$CPPFLAGS" ; then
189                   # a loop is needed to ensure we can add subdirs of existing dirs
190                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
191                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
192                           cf_have_incdir=yes; break
193                         fi
194                   done
195                 fi
196
197                 if test "$cf_have_incdir" = no ; then
198           if test "$cf_add_incdir" = /usr/local/include ; then
199                         if test "$GCC" = yes
200                         then
201                           cf_save_CPPFLAGS=$CPPFLAGS
202                           CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
203                           AC_TRY_COMPILE([#include <stdio.h>],
204                                   [printf("Hello")],
205                                   [],
206                                   [cf_have_incdir=yes])
207                           CPPFLAGS=$cf_save_CPPFLAGS
208                         fi
209                   fi
210                 fi
211
212                 if test "$cf_have_incdir" = no ; then
213                   AC_VERBOSE(adding $cf_add_incdir to include-path)
214                   ifelse($2,,CPPFLAGS,$2)="-I$cf_add_incdir $ifelse($2,,CPPFLAGS,[$]$2)"
215
216           cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
217           test "$cf_top_incdir" = "$cf_add_incdir" && break
218           cf_add_incdir="$cf_top_incdir"
219                 else
220                   break
221                 fi
222           fi
223         done
224   done
225 fi
226 ])dnl
227 dnl ---------------------------------------------------------------------------
228 dnl CF_ADD_LIBDIR version: 5 updated: 2007/07/30 19:12:03
229 dnl -------------
230 dnl     Adds to the library-path
231 dnl
232 dnl     Some machines have trouble with multiple -L options.
233 dnl
234 dnl $1 is the (list of) directory(s) to add
235 dnl $2 is the optional name of the variable to update (default LDFLAGS)
236 dnl
237 AC_DEFUN([CF_ADD_LIBDIR],
238 [
239 if test -n "$1" ; then
240   for cf_add_libdir in $1
241   do
242     if test $cf_add_libdir = /usr/lib ; then
243       :
244     elif test -d $cf_add_libdir
245     then
246       cf_have_libdir=no
247       if test -n "$LDFLAGS$LIBS" ; then
248         # a loop is needed to ensure we can add subdirs of existing dirs
249         for cf_test_libdir in $LDFLAGS $LIBS ; do
250           if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
251             cf_have_libdir=yes; break
252           fi
253         done
254       fi
255       if test "$cf_have_libdir" = no ; then
256         AC_VERBOSE(adding $cf_add_libdir to library-path)
257         ifelse($2,,LDFLAGS,$2)="-L$cf_add_libdir $ifelse($2,,LDFLAGS,[$]$2)"
258       fi
259     fi
260   done
261 fi
262 ])dnl
263 dnl ---------------------------------------------------------------------------
264 dnl CF_ANSI_CC_CHECK version: 9 updated: 2001/12/30 17:53:34
265 dnl ----------------
266 dnl This is adapted from the macros 'fp_PROG_CC_STDC' and 'fp_C_PROTOTYPES'
267 dnl in the sharutils 4.2 distribution.
268 AC_DEFUN([CF_ANSI_CC_CHECK],
269 [
270 AC_CACHE_CHECK(for ${CC-cc} option to accept ANSI C, cf_cv_ansi_cc,[
271 cf_cv_ansi_cc=no
272 cf_save_CFLAGS="$CFLAGS"
273 cf_save_CPPFLAGS="$CPPFLAGS"
274 # Don't try gcc -ansi; that turns off useful extensions and
275 # breaks some systems' header files.
276 # AIX                   -qlanglvl=ansi
277 # Ultrix and OSF/1      -std1
278 # HP-UX                 -Aa -D_HPUX_SOURCE
279 # SVR4                  -Xc
280 # UnixWare 1.2          (cannot use -Xc, since ANSI/POSIX clashes)
281 for cf_arg in "-DCC_HAS_PROTOS" \
282         "" \
283         -qlanglvl=ansi \
284         -std1 \
285         -Ae \
286         "-Aa -D_HPUX_SOURCE" \
287         -Xc
288 do
289         CF_ADD_CFLAGS($cf_arg)
290         AC_TRY_COMPILE(
291 [
292 #ifndef CC_HAS_PROTOS
293 #if !defined(__STDC__) || (__STDC__ != 1)
294 choke me
295 #endif
296 #endif
297 ],[
298         int test (int i, double x);
299         struct s1 {int (*f) (int a);};
300         struct s2 {int (*f) (double a);};],
301         [cf_cv_ansi_cc="$cf_arg"; break])
302 done
303 CFLAGS="$cf_save_CFLAGS"
304 CPPFLAGS="$cf_save_CPPFLAGS"
305 ])
306
307 if test "$cf_cv_ansi_cc" != "no"; then
308 if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then
309         CF_ADD_CFLAGS($cf_cv_ansi_cc)
310 else
311         AC_DEFINE(CC_HAS_PROTOS)
312 fi
313 fi
314 ])dnl
315 dnl ---------------------------------------------------------------------------
316 dnl CF_ANSI_CC_REQD version: 3 updated: 1997/09/06 13:40:44
317 dnl ---------------
318 dnl For programs that must use an ANSI compiler, obtain compiler options that
319 dnl will make it recognize prototypes.  We'll do preprocessor checks in other
320 dnl macros, since tools such as unproto can fake prototypes, but only part of
321 dnl the preprocessor.
322 AC_DEFUN([CF_ANSI_CC_REQD],
323 [AC_REQUIRE([CF_ANSI_CC_CHECK])
324 if test "$cf_cv_ansi_cc" = "no"; then
325         AC_ERROR(
326 [Your compiler does not appear to recognize prototypes.
327 You have the following choices:
328         a. adjust your compiler options
329         b. get an up-to-date compiler
330         c. use a wrapper such as unproto])
331 fi
332 ])dnl
333 dnl ---------------------------------------------------------------------------
334 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
335 dnl ------------
336 dnl Test if 'bool' is a builtin type in the configured C++ compiler.  Some
337 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
338 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
339 dnl
340 dnl Treat the configuration-variable specially here, since we're directly
341 dnl substituting its value (i.e., 1/0).
342 dnl
343 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
344 AC_DEFUN([CF_BOOL_DECL],
345 [
346 AC_MSG_CHECKING(if we should include stdbool.h)
347
348 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
349         AC_TRY_COMPILE([],[bool foo = false],
350                 [cf_cv_header_stdbool_h=0],
351                 [AC_TRY_COMPILE([
352 #ifndef __BEOS__
353 #include <stdbool.h>
354 #endif
355 ],[bool foo = false],
356                         [cf_cv_header_stdbool_h=1],
357                         [cf_cv_header_stdbool_h=0])])])
358
359 if test "$cf_cv_header_stdbool_h" = 1
360 then    AC_MSG_RESULT(yes)
361 else    AC_MSG_RESULT(no)
362 fi
363
364 AC_MSG_CHECKING([for builtin bool type])
365
366 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
367         AC_TRY_COMPILE([
368 #include <stdio.h>
369 #include <sys/types.h>
370 ],[bool x = false],
371                 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
372                 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
373         ])
374
375 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
376 then    AC_MSG_RESULT(yes)
377 else    AC_MSG_RESULT(no)
378 fi
379 ])dnl
380 dnl ---------------------------------------------------------------------------
381 dnl CF_BOOL_SIZE version: 12 updated: 2006/12/16 12:33:30
382 dnl ------------
383 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
384 dnl Don't bother looking for bool.h, since it's been deprecated.
385 dnl
386 dnl If the current compiler is C rather than C++, we get the bool definition
387 dnl from <stdbool.h>.
388 AC_DEFUN([CF_BOOL_SIZE],
389 [
390 AC_MSG_CHECKING([for size of bool])
391 AC_CACHE_VAL(cf_cv_type_of_bool,[
392         rm -f cf_test.out
393         AC_TRY_RUN([
394 #include <stdlib.h>
395 #include <stdio.h>
396
397 #if defined(__cplusplus)
398
399 #ifdef HAVE_GXX_BUILTIN_H
400 #include <g++/builtin.h>
401 #elif HAVE_GPP_BUILTIN_H
402 #include <gpp/builtin.h>
403 #elif HAVE_BUILTIN_H
404 #include <builtin.h>
405 #endif
406
407 #else
408
409 #if $cf_cv_header_stdbool_h
410 #include <stdbool.h>
411 #endif
412
413 #endif
414
415 main()
416 {
417         FILE *fp = fopen("cf_test.out", "w");
418         if (fp != 0) {
419                 bool x = true;
420                 if ((bool)(-x) >= 0)
421                         fputs("unsigned ", fp);
422                 if (sizeof(x) == sizeof(int))       fputs("int",  fp);
423                 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
424                 else if (sizeof(x) == sizeof(short))fputs("short",fp);
425                 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
426                 fclose(fp);
427         }
428         ${cf_cv_main_return:-return}(0);
429 }
430                 ],
431                 [cf_cv_type_of_bool=`cat cf_test.out`
432                  if test -z "$cf_cv_type_of_bool"; then
433                    cf_cv_type_of_bool=unknown
434                  fi],
435                 [cf_cv_type_of_bool=unknown],
436                 [cf_cv_type_of_bool=unknown])
437         ])
438         rm -f cf_test.out
439 AC_MSG_RESULT($cf_cv_type_of_bool)
440 if test "$cf_cv_type_of_bool" = unknown ; then
441         case .$NCURSES_BOOL in #(vi
442         .auto|.) NCURSES_BOOL=unsigned;;
443         esac
444         AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
445         cf_cv_type_of_bool=$NCURSES_BOOL
446 fi
447 ])dnl
448 dnl ---------------------------------------------------------------------------
449 dnl CF_BUILD_CC version: 6 updated: 2006/10/14 15:23:15
450 dnl -----------
451 dnl If we're cross-compiling, allow the user to override the tools and their
452 dnl options.  The configure script is oriented toward identifying the host
453 dnl compiler, etc., but we need a build compiler to generate parts of the
454 dnl source.
455 dnl
456 dnl $1 = default for $CPPFLAGS
457 dnl $2 = default for $LIBS
458 AC_DEFUN([CF_BUILD_CC],[
459 AC_REQUIRE([CF_PROG_EXT])
460 if test "$cross_compiling" = yes ; then
461
462         # defaults that we might want to override
463         : ${BUILD_CFLAGS:=''}
464         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
465         : ${BUILD_LDFLAGS:=''}
466         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
467         : ${BUILD_EXEEXT:='$x'}
468         : ${BUILD_OBJEXT:='o'}
469
470         AC_ARG_WITH(build-cc,
471                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
472                 [BUILD_CC="$withval"],
473                 [AC_CHECK_PROGS(BUILD_CC, gcc cc cl)])
474         AC_MSG_CHECKING(for native build C compiler)
475         AC_MSG_RESULT($BUILD_CC)
476
477         AC_MSG_CHECKING(for native build C preprocessor)
478         AC_ARG_WITH(build-cpp,
479                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
480                 [BUILD_CPP="$withval"],
481                 [BUILD_CPP='${BUILD_CC} -E'])
482         AC_MSG_RESULT($BUILD_CPP)
483
484         AC_MSG_CHECKING(for native build C flags)
485         AC_ARG_WITH(build-cflags,
486                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
487                 [BUILD_CFLAGS="$withval"])
488         AC_MSG_RESULT($BUILD_CFLAGS)
489
490         AC_MSG_CHECKING(for native build C preprocessor-flags)
491         AC_ARG_WITH(build-cppflags,
492                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
493                 [BUILD_CPPFLAGS="$withval"])
494         AC_MSG_RESULT($BUILD_CPPFLAGS)
495
496         AC_MSG_CHECKING(for native build linker-flags)
497         AC_ARG_WITH(build-ldflags,
498                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
499                 [BUILD_LDFLAGS="$withval"])
500         AC_MSG_RESULT($BUILD_LDFLAGS)
501
502         AC_MSG_CHECKING(for native build linker-libraries)
503         AC_ARG_WITH(build-libs,
504                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
505                 [BUILD_LIBS="$withval"])
506         AC_MSG_RESULT($BUILD_LIBS)
507
508         # this assumes we're on Unix.
509         BUILD_EXEEXT=
510         BUILD_OBJEXT=o
511
512         : ${BUILD_CC:='${CC}'}
513
514         if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
515                 AC_MSG_ERROR([Cross-build requires two compilers.
516 Use --with-build-cc to specify the native compiler.])
517         fi
518
519 else
520         : ${BUILD_CC:='${CC}'}
521         : ${BUILD_CPP:='${CPP}'}
522         : ${BUILD_CFLAGS:='${CFLAGS}'}
523         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
524         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
525         : ${BUILD_LIBS:='${LIBS}'}
526         : ${BUILD_EXEEXT:='$x'}
527         : ${BUILD_OBJEXT:='o'}
528 fi
529
530 AC_SUBST(BUILD_CC)
531 AC_SUBST(BUILD_CPP)
532 AC_SUBST(BUILD_CFLAGS)
533 AC_SUBST(BUILD_CPPFLAGS)
534 AC_SUBST(BUILD_LDFLAGS)
535 AC_SUBST(BUILD_LIBS)
536 AC_SUBST(BUILD_EXEEXT)
537 AC_SUBST(BUILD_OBJEXT)
538 ])dnl
539 dnl ---------------------------------------------------------------------------
540 dnl CF_CFG_DEFAULTS version: 7 updated: 2005/09/24 16:15:00
541 dnl ---------------
542 dnl Determine the default configuration into which we'll install ncurses.  This
543 dnl can be overridden by the user's command-line options.  There's two items to
544 dnl look for:
545 dnl     1. the prefix (e.g., /usr)
546 dnl     2. the header files (e.g., /usr/include/ncurses)
547 dnl We'll look for a previous installation of ncurses and use the same defaults.
548 dnl
549 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
550 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
551 dnl programs from a vendor's.
552 AC_DEFUN([CF_CFG_DEFAULTS],
553 [
554 AC_MSG_CHECKING(for prefix)
555 if test "x$prefix" = "xNONE" ; then
556         case "$cf_cv_system_name" in
557                 # non-vendor systems don't have a conflict
558         openbsd*|freebsd*|linux*|cygwin*|k*bsd*-gnu)
559                 prefix=/usr
560                 ;;
561         *)      prefix=$ac_default_prefix
562                 ;;
563         esac
564 fi
565 AC_MSG_RESULT($prefix)
566
567 if test "x$prefix" = "xNONE" ; then
568 AC_MSG_CHECKING(for default include-directory)
569 test -n "$verbose" && echo 1>&AC_FD_MSG
570 for cf_symbol in \
571         $includedir \
572         $includedir/ncurses \
573         $prefix/include \
574         $prefix/include/ncurses \
575         /usr/local/include \
576         /usr/local/include/ncurses \
577         /usr/include \
578         /usr/include/ncurses
579 do
580         cf_dir=`eval echo $cf_symbol`
581         if test -f $cf_dir/curses.h ; then
582         if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
583                 includedir="$cf_symbol"
584                 test -n "$verbose"  && echo $ac_n "     found " 1>&AC_FD_MSG
585                 break
586         fi
587         fi
588         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
589 done
590 AC_MSG_RESULT($includedir)
591 fi
592 ])dnl
593 dnl ---------------------------------------------------------------------------
594 dnl CF_CGETENT version: 3 updated: 2000/08/12 23:18:52
595 dnl ----------
596 dnl Check if the terminal-capability database functions are available.  If not,
597 dnl ncurses has a much-reduced version.
598 AC_DEFUN([CF_CGETENT],[
599 AC_MSG_CHECKING(for terminal-capability database functions)
600 AC_CACHE_VAL(cf_cv_cgetent,[
601 AC_TRY_LINK([
602 #include <stdlib.h>],[
603         char temp[128];
604         char *buf = temp;
605         char *db_array = temp;
606         cgetent(&buf, /* int *, */ &db_array, "vt100");
607         cgetcap(buf, "tc", '=');
608         cgetmatch(buf, "tc");
609         ],
610         [cf_cv_cgetent=yes],
611         [cf_cv_cgetent=no])
612 ])
613 AC_MSG_RESULT($cf_cv_cgetent)
614 test "$cf_cv_cgetent" = yes && AC_DEFINE(HAVE_BSD_CGETENT)
615 ])dnl
616 dnl ---------------------------------------------------------------------------
617 dnl CF_CHECK_CACHE version: 10 updated: 2004/05/23 13:03:31
618 dnl --------------
619 dnl Check if we're accidentally using a cache from a different machine.
620 dnl Derive the system name, as a check for reusing the autoconf cache.
621 dnl
622 dnl If we've packaged config.guess and config.sub, run that (since it does a
623 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
624 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
625 dnl which is useful in cross-compiles.
626 dnl
627 dnl Note: we would use $ac_config_sub, but that is one of the places where
628 dnl autoconf 2.5x broke compatibility with autoconf 2.13
629 AC_DEFUN([CF_CHECK_CACHE],
630 [
631 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
632         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
633         system_name="$host_os"
634 else
635         system_name="`(uname -s -r) 2>/dev/null`"
636         if test -z "$system_name" ; then
637                 system_name="`(hostname) 2>/dev/null`"
638         fi
639 fi
640 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name")
641 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
642
643 test -z "$system_name" && system_name="$cf_cv_system_name"
644 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
645
646 if test ".$system_name" != ".$cf_cv_system_name" ; then
647         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
648         AC_ERROR("Please remove config.cache and try again.")
649 fi
650 ])dnl
651 dnl ---------------------------------------------------------------------------
652 dnl CF_CHECK_ERRNO version: 9 updated: 2001/12/30 18:03:23
653 dnl --------------
654 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
655 dnl the 'errno' variable.  Define a DECL_xxx symbol if we must declare it
656 dnl ourselves.
657 dnl
658 dnl $1 = the name to check
659 AC_DEFUN([CF_CHECK_ERRNO],
660 [
661 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
662     AC_TRY_COMPILE([
663 #ifdef HAVE_STDLIB_H
664 #include <stdlib.h>
665 #endif
666 #include <stdio.h>
667 #include <sys/types.h>
668 #include <errno.h> ],
669     [long x = (long) $1],
670     [cf_cv_dcl_$1=yes],
671     [cf_cv_dcl_$1=no])
672 ])
673
674 if test "$cf_cv_dcl_$1" = no ; then
675     CF_UPPER(cf_result,decl_$1)
676     AC_DEFINE_UNQUOTED($cf_result)
677 fi
678
679 # It's possible (for near-UNIX clones) that the data doesn't exist
680 CF_CHECK_EXTERN_DATA($1,int)
681 ])dnl
682 dnl ---------------------------------------------------------------------------
683 dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23
684 dnl --------------------
685 dnl Check for existence of external data in the current set of libraries.  If
686 dnl we can modify it, it's real enough.
687 dnl $1 = the name to check
688 dnl $2 = its type
689 AC_DEFUN([CF_CHECK_EXTERN_DATA],
690 [
691 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
692     AC_TRY_LINK([
693 #undef $1
694 extern $2 $1;
695 ],
696     [$1 = 2],
697     [cf_cv_have_$1=yes],
698     [cf_cv_have_$1=no])
699 ])
700
701 if test "$cf_cv_have_$1" = yes ; then
702     CF_UPPER(cf_result,have_$1)
703     AC_DEFINE_UNQUOTED($cf_result)
704 fi
705
706 ])dnl
707 dnl ---------------------------------------------------------------------------
708 dnl CF_CHECK_GPM_WGETCH version: 1 updated: 2007/04/28 14:38:06
709 dnl -------------------
710 dnl Check if GPM is already linked with curses.  If so - and if the linkage
711 dnl is not "weak" - warn about this because it can create problems linking
712 dnl applications with ncurses.
713 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
714 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
715
716 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
717 cf_cv_check_gpm_wgetch=unknown
718 if test "$cross_compiling" != yes ; then
719
720 cat >conftest.$ac_ext <<CF_EOF
721 #include <gpm.h>
722 int main()
723 {
724         Gpm_Wgetch();
725         ${cf_cv_main_return:-return}(0);
726 }
727 CF_EOF
728
729         cf_save_LIBS="$LIBS"
730         # This only works if we can look at the symbol table.  If a shared
731         # library is stripped for install, we cannot use that.  So we're forced
732         # to rely on the static library, noting that some packagers may not
733         # include it.
734         LIBS="-static -lgpm -dynamic $LIBS"
735         if AC_TRY_EVAL(ac_compile) ; then
736                 if AC_TRY_EVAL(ac_link) ; then
737                         cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
738                         test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
739                         test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
740                 fi
741         fi
742         rm -f conftest*
743         LIBS="$cf_save_LIBS"
744 fi
745 ])
746
747 if test "$cf_cv_check_gpm_wgetch" != yes ; then
748         AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
749 fi
750 ])])dnl
751 dnl ---------------------------------------------------------------------------
752 dnl CF_CPP_PARAM_INIT version: 4 updated: 2001/04/07 22:31:18
753 dnl -----------------
754 dnl Check if the C++ compiler accepts duplicate parameter initialization.  This
755 dnl is a late feature for the standard and is not in some recent compilers
756 dnl (1999/9/11).
757 AC_DEFUN([CF_CPP_PARAM_INIT],
758 [
759 if test -n "$CXX"; then
760 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
761         AC_LANG_SAVE
762         AC_LANG_CPLUSPLUS
763         AC_TRY_RUN([
764 class TEST {
765 private:
766         int value;
767 public:
768         TEST(int x = 1);
769         ~TEST();
770 };
771
772 TEST::TEST(int x = 1)   // some compilers do not like second initializer
773 {
774         value = x;
775 }
776 void main() { }
777 ],
778         [cf_cv_cpp_param_init=yes],
779         [cf_cv_cpp_param_init=no],
780         [cf_cv_cpp_param_init=unknown])
781         AC_LANG_RESTORE
782 ])
783 fi
784 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT)
785 ])dnl
786 dnl ---------------------------------------------------------------------------
787 dnl CF_CPP_STATIC_CAST version: 1 updated: 2005/07/23 16:52:43
788 dnl ------------------
789 dnl Check if the C++ compiler accepts static_cast in generics.  This appears to
790 dnl not be supported in g++ before 3.0
791 AC_DEFUN([CF_CPP_STATIC_CAST],
792 [
793 if test -n "$CXX"; then
794
795 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
796         AC_LANG_SAVE
797         AC_LANG_CPLUSPLUS
798
799         AC_TRY_COMPILE([
800 class NCursesPanel
801 {
802 public:
803   NCursesPanel(int nlines,
804                int ncols,
805                int begin_y = 0,
806                int begin_x = 0)
807   {
808   }
809
810   ~NCursesPanel();
811 };
812
813 template<class T> class NCursesUserPanel : public NCursesPanel
814 {
815 public:
816   NCursesUserPanel (int nlines,
817                     int ncols,
818                     int begin_y = 0,
819                     int begin_x = 0,
820                     const T* p_UserData = static_cast<T*>(0))
821     : NCursesPanel (nlines, ncols, begin_y, begin_x)
822   {
823   };
824   NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
825   {
826   };
827
828   virtual ~NCursesUserPanel() {};
829 };
830 ],[
831         const char* p_UserData = static_cast<char*>(0)],
832         [cf_cv_cpp_static_cast=yes],
833         [cf_cv_cpp_static_cast=no])
834
835         AC_LANG_RESTORE
836 ])
837
838 fi
839
840 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST)
841 ])dnl
842 dnl ---------------------------------------------------------------------------
843 dnl CF_C_INLINE version: 2 updated: 2007/08/11 14:09:50
844 dnl -----------
845 dnl Check if the C compiler supports "inline".
846 dnl $1 is the name of a shell variable to set if inline is supported
847 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
848 AC_DEFUN([CF_C_INLINE],[
849 AC_C_INLINE
850 $1=
851 if test "$ac_cv_c_inline" != no ; then
852   $1=inline
853   if test "$INTEL_COMPILER" = yes
854   then
855     :
856   elif test "$GCC" = yes
857   then
858     AC_CACHE_CHECK(if gcc supports options to tune inlining,cf_cv_gcc_inline,[
859       cf_save_CFLAGS=$CFLAGS
860       CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
861       AC_TRY_COMPILE([inline int foo(void) { return 1; }],
862       [${cf_cv_main_return:-return} foo()],
863       [cf_cv_gcc_inline=yes],
864       [cf_cv_gcc_inline=no])
865       CFLAGS=$cf_save_CFLAGS
866     ])
867     if test "$cf_cv_gcc_inline" = yes ; then
868         CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
869     fi
870   fi
871 fi
872 AC_SUBST($1)
873 ])dnl
874 dnl ---------------------------------------------------------------------------
875 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
876 dnl ----------
877 dnl "dirname" is not portable, so we fake it with a shell script.
878 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
879 dnl ---------------------------------------------------------------------------
880 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
881 dnl ---------------
882 AC_DEFUN([CF_DIRS_TO_MAKE],
883 [
884 DIRS_TO_MAKE="lib"
885 for cf_item in $cf_list_models
886 do
887         CF_OBJ_SUBDIR($cf_item,cf_subdir)
888         for cf_item2 in $DIRS_TO_MAKE
889         do
890                 test $cf_item2 = $cf_subdir && break
891         done
892         test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
893 done
894 for cf_dir in $DIRS_TO_MAKE
895 do
896         test ! -d $cf_dir && mkdir $cf_dir
897 done
898 AC_SUBST(DIRS_TO_MAKE)
899 ])dnl
900 dnl ---------------------------------------------------------------------------
901 dnl CF_DISABLE_LEAKS version: 4 updated: 2006/12/16 15:10:42
902 dnl ----------------
903 dnl Combine no-leak checks with the libraries or tools that are used for the
904 dnl checks.
905 AC_DEFUN([CF_DISABLE_LEAKS],[
906
907 AC_REQUIRE([CF_WITH_DMALLOC])
908 AC_REQUIRE([CF_WITH_DBMALLOC])
909 AC_REQUIRE([CF_WITH_VALGRIND])
910
911 AC_MSG_CHECKING(if you want to perform memory-leak testing)
912 AC_ARG_ENABLE(leaks,
913         [  --disable-leaks         test: free permanent memory, analyze leaks],
914         [with_no_leaks=yes],
915         : ${with_no_leaks:=no})
916 AC_MSG_RESULT($with_no_leaks)
917
918 if test "$with_no_leaks" = yes ; then
919         AC_DEFINE(NO_LEAKS)
920 fi
921 ])dnl
922 dnl ---------------------------------------------------------------------------
923 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
924 dnl --------
925 dnl Check if 'errno' is declared in <errno.h>
926 AC_DEFUN([CF_ERRNO],
927 [
928 CF_CHECK_ERRNO(errno)
929 ])dnl
930 dnl ---------------------------------------------------------------------------
931 dnl CF_ETIP_DEFINES version: 3 updated: 2003/03/22 19:13:43
932 dnl ---------------
933 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
934 dnl math.h and builtin.h, only for ncurses
935 AC_DEFUN([CF_ETIP_DEFINES],
936 [
937 AC_MSG_CHECKING(for special defines needed for etip.h)
938 cf_save_CXXFLAGS="$CXXFLAGS"
939 cf_result="none"
940 for cf_math in "" MATH_H
941 do
942 for cf_excp in "" MATH_EXCEPTION
943 do
944         CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -I${srcdir}/include"
945         test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
946         test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
947 AC_TRY_COMPILE([
948 #include <etip.h.in>
949 ],[],[
950         test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
951         test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
952         cf_result="$cf_math $cf_excp"
953         break
954 ],[])
955 done
956 done
957 AC_MSG_RESULT($cf_result)
958 CXXFLAGS="$cf_save_CXXFLAGS"
959 ])
960 dnl ---------------------------------------------------------------------------
961 dnl CF_FUNC_DLSYM version: 1 updated: 2004/06/16 20:52:45
962 dnl -------------
963 dnl Test for dlsym() and related functions, as well as libdl.
964 dnl
965 dnl Sets
966 dnl     $cf_have_dlsym
967 dnl     $cf_have_libdl
968 AC_DEFUN([CF_FUNC_DLSYM],[
969 cf_have_dlsym=no
970 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
971
972 cf_have_libdl=no
973 AC_CHECK_LIB(dl,dlsym,[
974         cf_have_dlsym=yes
975         cf_have_libdl=yes])])
976
977 if test "$cf_have_dlsym" = yes ; then
978         test "$cf_have_libdl" = yes && LIBS="-ldl $LIBS"
979
980         AC_MSG_CHECKING(whether able to link to dl*() functions)
981         AC_TRY_LINK([#include <dlfcn.h>],[
982                 void *obj;
983                 if ((obj = dlopen("filename", 0)) != 0) {
984                         if (dlsym(obj, "symbolname") == 0) {
985                         dlclose(obj);
986                         }
987                 }],[
988                 AC_DEFINE(HAVE_LIBDL)],[
989                 AC_MSG_ERROR(Cannot link test program for libdl)])
990         AC_MSG_RESULT(ok)
991 else
992         AC_MSG_ERROR(Cannot find dlsym function)
993 fi
994 ])
995 dnl ---------------------------------------------------------------------------
996 dnl CF_FUNC_MEMMOVE version: 7 updated: 2006/12/16 12:33:30
997 dnl ---------------
998 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
999 dnl is found, add our own version of memmove to the list of objects.
1000 AC_DEFUN([CF_FUNC_MEMMOVE],
1001 [
1002 AC_CHECK_FUNC(memmove,,[
1003 AC_CHECK_FUNC(bcopy,[
1004         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
1005                 AC_TRY_RUN([
1006 int main() {
1007         static char data[] = "abcdefghijklmnopqrstuwwxyz";
1008         char temp[40];
1009         bcopy(data, temp, sizeof(data));
1010         bcopy(temp+10, temp, 15);
1011         bcopy(temp+5, temp+15, 10);
1012         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
1013 }
1014                 ],
1015                 [cf_cv_good_bcopy=yes],
1016                 [cf_cv_good_bcopy=no],
1017                 [cf_cv_good_bcopy=unknown])
1018                 ])
1019         ],[cf_cv_good_bcopy=no])
1020         if test "$cf_cv_good_bcopy" = yes ; then
1021                 AC_DEFINE(USE_OK_BCOPY)
1022         else
1023                 AC_DEFINE(USE_MY_MEMMOVE)
1024         fi
1025 ])])dnl
1026 dnl ---------------------------------------------------------------------------
1027 dnl CF_FUNC_NANOSLEEP version: 3 updated: 2006/12/16 12:33:30
1028 dnl -----------------
1029 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
1030 dnl AIX 4.x, provide a non-working version.
1031 AC_DEFUN([CF_FUNC_NANOSLEEP],[
1032 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
1033 AC_TRY_RUN([
1034 #include <stdio.h>
1035 #include <errno.h>
1036 #include <time.h>
1037
1038 #ifdef HAVE_SYS_TIME_H
1039 #include <sys/time.h>
1040 #endif
1041
1042 int main() {
1043         struct timespec ts1, ts2;
1044         int code;
1045         ts1.tv_sec  = 0;
1046         ts1.tv_nsec = 750000000;
1047         ts2.tv_sec  = 0;
1048         ts2.tv_nsec = 0;
1049         errno = 0;
1050         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
1051         ${cf_cv_main_return:-return}(code != 0);
1052 }
1053 ],
1054         [cf_cv_func_nanosleep=yes],
1055         [cf_cv_func_nanosleep=no],
1056         [cf_cv_func_nanosleep=unknown])])
1057
1058 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP)
1059 ])
1060 dnl ---------------------------------------------------------------------------
1061 dnl CF_FUNC_POLL version: 4 updated: 2006/12/16 12:33:30
1062 dnl ------------
1063 dnl See if the poll function really works.  Some platforms have poll(), but
1064 dnl it does not work for terminals or files.
1065 AC_DEFUN([CF_FUNC_POLL],[
1066 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1067 AC_TRY_RUN([
1068 #include <stdio.h>
1069 #ifdef HAVE_POLL_H
1070 #include <poll.h>
1071 #else
1072 #include <sys/poll.h>
1073 #endif
1074 int main() {
1075         struct pollfd myfds;
1076         int ret;
1077
1078         myfds.fd = 0;
1079         myfds.events = POLLIN;
1080
1081         ret = poll(&myfds, 1, 100);
1082         ${cf_cv_main_return:-return}(ret != 0);
1083 }],
1084         [cf_cv_working_poll=yes],
1085         [cf_cv_working_poll=no],
1086         [cf_cv_working_poll=unknown])])
1087 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
1088 ])dnl
1089 dnl ---------------------------------------------------------------------------
1090 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
1091 dnl ---------------
1092 dnl Some old/broken variations define tcgetattr() only as a macro in
1093 dnl termio(s).h
1094 AC_DEFUN([CF_FUNC_TERMIOS],[
1095 AC_REQUIRE([CF_STRUCT_TERMIOS])
1096 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1097 AC_TRY_LINK([
1098 #include <sys/types.h>
1099 #ifdef HAVE_UNISTD_H
1100 #include <unistd.h>
1101 #endif
1102 #ifdef HAVE_TERMIOS_H
1103 #include <termios.h>
1104 #define TTY struct termios
1105 #else
1106 #ifdef HAVE_TERMIO_H
1107 #include <termio.h>
1108 #define TTY struct termio
1109 #endif
1110 #endif
1111 ],[
1112 TTY foo;
1113 tcgetattr(1, &foo);],
1114 [cf_cv_have_tcgetattr=yes],
1115 [cf_cv_have_tcgetattr=no])])
1116 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
1117 ])dnl
1118 dnl ---------------------------------------------------------------------------
1119 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
1120 dnl ---------------
1121 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1122 dnl versions of C.  It is in the GNU C library, and can often be simulated by
1123 dnl other functions.
1124 AC_DEFUN([CF_FUNC_VSSCANF],
1125 [
1126 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1127 AC_TRY_LINK([
1128 #include <stdarg.h>
1129 #include <stdio.h>],[
1130         va_list ap;
1131         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1132 AC_TRY_LINK([
1133 #include <stdarg.h>
1134 #include <stdio.h>],[
1135     FILE strbuf;
1136     char *str = "from";
1137
1138     strbuf._flag = _IOREAD;
1139     strbuf._ptr = strbuf._base = (unsigned char *) str;
1140     strbuf._cnt = strlen(str);
1141     strbuf._file = _NFILE;
1142     return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1143 AC_TRY_LINK([
1144 #include <stdarg.h>
1145 #include <stdio.h>],[
1146     FILE strbuf;
1147     char *str = "from";
1148
1149     strbuf._flag = _IOREAD;
1150     strbuf._ptr = strbuf._base = (unsigned char *) str;
1151     strbuf._cnt = strlen(str);
1152     strbuf._file = _NFILE;
1153     return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1154 cf_cv_func_vsscanf=no])])])])
1155
1156 case $cf_cv_func_vsscanf in #(vi
1157 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
1158 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
1159 _doscan) AC_DEFINE(HAVE__DOSCAN);;
1160 esac
1161
1162 ])dnl
1163 dnl ---------------------------------------------------------------------------
1164 dnl CF_GCC_ATTRIBUTES version: 11 updated: 2007/07/29 09:55:12
1165 dnl -----------------
1166 dnl Test for availability of useful gcc __attribute__ directives to quiet
1167 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1168 dnl to documentation, unrecognized directives cause older compilers to barf.
1169 AC_DEFUN([CF_GCC_ATTRIBUTES],
1170 [
1171 if test "$GCC" = yes
1172 then
1173 cat > conftest.i <<EOF
1174 #ifndef GCC_PRINTF
1175 #define GCC_PRINTF 0
1176 #endif
1177 #ifndef GCC_SCANF
1178 #define GCC_SCANF 0
1179 #endif
1180 #ifndef GCC_NORETURN
1181 #define GCC_NORETURN /* nothing */
1182 #endif
1183 #ifndef GCC_UNUSED
1184 #define GCC_UNUSED /* nothing */
1185 #endif
1186 EOF
1187 if test "$GCC" = yes
1188 then
1189         AC_CHECKING([for $CC __attribute__ directives])
1190 cat > conftest.$ac_ext <<EOF
1191 #line __oline__ "${as_me-configure}"
1192 #include "confdefs.h"
1193 #include "conftest.h"
1194 #include "conftest.i"
1195 #if     GCC_PRINTF
1196 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1197 #else
1198 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1199 #endif
1200 #if     GCC_SCANF
1201 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1202 #else
1203 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1204 #endif
1205 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1206 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1207 extern void foo(void) GCC_NORETURN;
1208 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1209 EOF
1210         for cf_attribute in scanf printf unused noreturn
1211         do
1212                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1213                 cf_directive="__attribute__(($cf_attribute))"
1214                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1215                 case $cf_attribute in
1216                 scanf|printf)
1217                 cat >conftest.h <<EOF
1218 #define GCC_$cf_ATTRIBUTE 1
1219 EOF
1220                         ;;
1221                 *)
1222                 cat >conftest.h <<EOF
1223 #define GCC_$cf_ATTRIBUTE $cf_directive
1224 EOF
1225                         ;;
1226                 esac
1227                 if AC_TRY_EVAL(ac_compile); then
1228                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1229                         cat conftest.h >>confdefs.h
1230                 fi
1231         done
1232 else
1233         fgrep define conftest.i >>confdefs.h
1234 fi
1235 rm -rf conftest*
1236 fi
1237 ])dnl
1238 dnl ---------------------------------------------------------------------------
1239 dnl CF_GCC_VERSION version: 4 updated: 2005/08/27 09:53:42
1240 dnl --------------
1241 dnl Find version of gcc
1242 AC_DEFUN([CF_GCC_VERSION],[
1243 AC_REQUIRE([AC_PROG_CC])
1244 GCC_VERSION=none
1245 if test "$GCC" = yes ; then
1246         AC_MSG_CHECKING(version of $CC)
1247         GCC_VERSION="`${CC} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1248         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1249         AC_MSG_RESULT($GCC_VERSION)
1250 fi
1251 ])dnl
1252 dnl ---------------------------------------------------------------------------
1253 dnl CF_GCC_WARNINGS version: 22 updated: 2007/07/29 09:55:12
1254 dnl ---------------
1255 dnl Check if the compiler supports useful warning options.  There's a few that
1256 dnl we don't use, simply because they're too noisy:
1257 dnl
1258 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1259 dnl     -Wredundant-decls (system headers make this too noisy)
1260 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1261 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1262 dnl             is enabled for ncurses using "--enable-const".
1263 dnl     -pedantic
1264 dnl
1265 dnl Parameter:
1266 dnl     $1 is an optional list of gcc warning flags that a particular
1267 dnl             application might want to use, e.g., "no-unused" for
1268 dnl             -Wno-unused
1269 dnl Special:
1270 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1271 dnl
1272 AC_DEFUN([CF_GCC_WARNINGS],
1273 [
1274 AC_REQUIRE([CF_GCC_VERSION])
1275 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1276
1277 cat > conftest.$ac_ext <<EOF
1278 #line __oline__ "${as_me-configure}"
1279 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1280 EOF
1281
1282 if test "$INTEL_COMPILER" = yes
1283 then
1284 # The "-wdXXX" options suppress warnings:
1285 # remark #1419: external declaration in primary source file
1286 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1287 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1288 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1289 # remark #193: zero used for undefined preprocessing identifier
1290 # remark #593: variable "curs_sb_left_arrow" was set but never used
1291 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1292 # remark #869: parameter "tw" was never referenced
1293 # remark #981: operands are evaluated in unspecified order
1294 # warning #269: invalid format string conversion
1295
1296         AC_CHECKING([for $CC warning options])
1297         cf_save_CFLAGS="$CFLAGS"
1298         EXTRA_CFLAGS="-Wall"
1299         for cf_opt in \
1300                 wd1419 \
1301                 wd1682 \
1302                 wd1683 \
1303                 wd1684 \
1304                 wd193 \
1305                 wd279 \
1306                 wd593 \
1307                 wd810 \
1308                 wd869 \
1309                 wd981
1310         do
1311                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1312                 if AC_TRY_EVAL(ac_compile); then
1313                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1314                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1315                 fi
1316         done
1317         CFLAGS="$cf_save_CFLAGS"
1318
1319 elif test "$GCC" = yes
1320 then
1321         AC_CHECKING([for $CC warning options])
1322         cf_save_CFLAGS="$CFLAGS"
1323         EXTRA_CFLAGS="-W -Wall"
1324         cf_warn_CONST=""
1325         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1326         for cf_opt in \
1327                 Wbad-function-cast \
1328                 Wcast-align \
1329                 Wcast-qual \
1330                 Winline \
1331                 Wmissing-declarations \
1332                 Wmissing-prototypes \
1333                 Wnested-externs \
1334                 Wpointer-arith \
1335                 Wshadow \
1336                 Wstrict-prototypes \
1337                 Wundef $cf_warn_CONST $1
1338         do
1339                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1340                 if AC_TRY_EVAL(ac_compile); then
1341                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1342                         case $cf_opt in #(vi
1343                         Wcast-qual) #(vi
1344                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1345                                 ;;
1346                         Winline) #(vi
1347                                 case $GCC_VERSION in
1348                                 3.3*)
1349                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1350                                         continue;;
1351                                 esac
1352                                 ;;
1353                         esac
1354                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1355                 fi
1356         done
1357         CFLAGS="$cf_save_CFLAGS"
1358 fi
1359 rm -f conftest*
1360
1361 AC_SUBST(EXTRA_CFLAGS)
1362 ])dnl
1363 dnl ---------------------------------------------------------------------------
1364 dnl CF_GNAT_TRY_LINK version: 1 updated: 2004/08/21 19:02:08
1365 dnl ----------------
1366 dnl Verify that a test program compiles/links with GNAT.
1367 dnl $cf_ada_make is set to the program that compiles/links
1368 dnl $ADAFLAGS may be set to the GNAT flags.
1369 dnl
1370 dnl $1 is the text of the spec
1371 dnl $2 is the text of the body
1372 dnl $3 is the shell command to execute if successful
1373 dnl $4 is the shell command to execute if not successful
1374 AC_DEFUN([CF_GNAT_TRY_LINK],
1375 [
1376 rm -f conftest*
1377 cat >>conftest.ads <<CF_EOF
1378 $1
1379 CF_EOF
1380 cat >>conftest.adb <<CF_EOF
1381 $2
1382 CF_EOF
1383 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1384 ifelse($3,,      :,[      $3])
1385 ifelse($4,,,[else
1386    $4])
1387 fi
1388 rm -f conftest*
1389 ])dnl
1390 dnl ---------------------------------------------------------------------------
1391 dnl CF_GNAT_TRY_RUN version: 3 updated: 2004/08/21 19:02:08
1392 dnl ---------------
1393 dnl Verify that a test program compiles and runs with GNAT
1394 dnl $cf_ada_make is set to the program that compiles/links
1395 dnl $ADAFLAGS may be set to the GNAT flags.
1396 dnl
1397 dnl $1 is the text of the spec
1398 dnl $2 is the text of the body
1399 dnl $3 is the shell command to execute if successful
1400 dnl $4 is the shell command to execute if not successful
1401 AC_DEFUN([CF_GNAT_TRY_RUN],
1402 [
1403 rm -f conftest*
1404 cat >>conftest.ads <<CF_EOF
1405 $1
1406 CF_EOF
1407 cat >>conftest.adb <<CF_EOF
1408 $2
1409 CF_EOF
1410 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1411    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1412 ifelse($3,,      :,[      $3])
1413 ifelse($4,,,[   else
1414       $4])
1415    fi
1416 ifelse($4,,,[else
1417    $4])
1418 fi
1419 rm -f conftest*
1420 ])dnl
1421 dnl ---------------------------------------------------------------------------
1422 dnl CF_GNAT_VERSION version: 12 updated: 2006/10/14 15:23:15
1423 dnl ---------------
1424 dnl Verify version of GNAT.
1425 AC_DEFUN([CF_GNAT_VERSION],
1426 [
1427 AC_MSG_CHECKING(for gnat version)
1428 cf_gnat_version=`${cf_ada_make-gnatmake} -v 2>&1 | grep '[[0-9]].[[0-9]][[0-9]]*' |\
1429   sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1430 AC_MSG_RESULT($cf_gnat_version)
1431
1432 case $cf_gnat_version in
1433   3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*)
1434     cf_cv_prog_gnat_correct=yes
1435     ;;
1436   *) echo Unsupported GNAT version $cf_gnat_version. Required is 3.11 or better. Disabling Ada95 binding.
1437      cf_cv_prog_gnat_correct=no
1438      ;;
1439 esac
1440 case $cf_gnat_version in
1441   3.[[1-9]]*|[[4-9]].*)
1442       cf_compile_generics=generics
1443       cf_generic_objects="\${GENOBJS}"
1444       ;;
1445   *)  cf_compile_generics=
1446       cf_generic_objects=
1447       ;;
1448 esac
1449 ])
1450 dnl ---------------------------------------------------------------------------
1451 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1452 dnl -------------
1453 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1454 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1455 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1456 dnl since it is interwoven with GNU extensions.
1457 dnl
1458 dnl Well, yes we could work around it...
1459 AC_DEFUN([CF_GNU_SOURCE],
1460 [
1461 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1462 AC_TRY_COMPILE([#include <sys/types.h>],[
1463 #ifndef _XOPEN_SOURCE
1464 make an error
1465 #endif],
1466         [cf_cv_gnu_source=no],
1467         [cf_save="$CPPFLAGS"
1468          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1469          AC_TRY_COMPILE([#include <sys/types.h>],[
1470 #ifdef _XOPEN_SOURCE
1471 make an error
1472 #endif],
1473         [cf_cv_gnu_source=no],
1474         [cf_cv_gnu_source=yes])
1475         CPPFLAGS="$cf_save"
1476         ])
1477 ])
1478 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1479 ])dnl
1480 dnl ---------------------------------------------------------------------------
1481 dnl CF_GPP_LIBRARY version: 8 updated: 2003/02/02 01:41:46
1482 dnl --------------
1483 dnl If we're trying to use g++, test if libg++ is installed (a rather common
1484 dnl problem :-).  If we have the compiler but no library, we'll be able to
1485 dnl configure, but won't be able to build the c++ demo program.
1486 AC_DEFUN([CF_GPP_LIBRARY],
1487 [
1488 cf_cxx_library=unknown
1489 case $cf_cv_system_name in #(vi
1490 os2*) #(vi
1491         cf_gpp_libname=gpp
1492         ;;
1493 *)
1494         cf_gpp_libname=g++
1495         ;;
1496 esac
1497 if test "$GXX" = yes; then
1498         AC_MSG_CHECKING([for lib$cf_gpp_libname])
1499         cf_save="$LIBS"
1500         LIBS="$LIBS -l$cf_gpp_libname"
1501         AC_TRY_LINK([
1502 #include <$cf_gpp_libname/builtin.h>
1503         ],
1504         [two_arg_error_handler_t foo2 = lib_error_handler],
1505         [cf_cxx_library=yes
1506          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1507          if test "$cf_gpp_libname" = cpp ; then
1508             AC_DEFINE(HAVE_GPP_BUILTIN_H)
1509          else
1510             AC_DEFINE(HAVE_GXX_BUILTIN_H)
1511          fi],
1512         [AC_TRY_LINK([
1513 #include <builtin.h>
1514         ],
1515         [two_arg_error_handler_t foo2 = lib_error_handler],
1516         [cf_cxx_library=yes
1517          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1518          AC_DEFINE(HAVE_BUILTIN_H)],
1519         [cf_cxx_library=no])])
1520         LIBS="$cf_save"
1521         AC_MSG_RESULT($cf_cxx_library)
1522 fi
1523 ])dnl
1524 dnl ---------------------------------------------------------------------------
1525 dnl CF_GXX_VERSION version: 5 updated: 2005/08/27 09:53:42
1526 dnl --------------
1527 dnl Check for version of g++
1528 AC_DEFUN([CF_GXX_VERSION],[
1529 AC_REQUIRE([AC_PROG_CPP])
1530 GXX_VERSION=none
1531 if test "$GXX" = yes; then
1532         AC_MSG_CHECKING(version of g++)
1533         GXX_VERSION="`${CXX-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1534         test -z "$GXX_VERSION" && GXX_VERSION=unknown
1535         AC_MSG_RESULT($GXX_VERSION)
1536 fi
1537 ])dnl
1538 dnl ---------------------------------------------------------------------------
1539 dnl CF_GXX_WARNINGS version: 5 updated: 2005/08/13 14:54:38
1540 dnl ---------------
1541 dnl Check if the compiler supports useful warning options.
1542 dnl
1543 dnl Most of gcc's options apply to g++, except:
1544 dnl     -Wbad-function-cast
1545 dnl     -Wmissing-declarations
1546 dnl     -Wnested-externs
1547 dnl
1548 dnl Omit a few (for now):
1549 dnl     -Winline
1550 dnl
1551 dnl Parameter:
1552 dnl     $1 is an optional list of g++ warning flags that a particular
1553 dnl             application might want to use, e.g., "no-unused" for
1554 dnl             -Wno-unused
1555 dnl Special:
1556 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1557 dnl
1558 AC_DEFUN([CF_GXX_WARNINGS],
1559 [
1560
1561 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
1562
1563 AC_REQUIRE([CF_GXX_VERSION])
1564
1565 AC_LANG_SAVE
1566 AC_LANG_CPLUSPLUS
1567
1568 cat > conftest.$ac_ext <<EOF
1569 #line __oline__ "configure"
1570 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1571 EOF
1572
1573 if test "$INTEL_CPLUSPLUS" = yes
1574 then
1575 # The "-wdXXX" options suppress warnings:
1576 # remark #1419: external declaration in primary source file
1577 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1578 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1579 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1580 # remark #193: zero used for undefined preprocessing identifier
1581 # remark #593: variable "curs_sb_left_arrow" was set but never used
1582 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1583 # remark #869: parameter "tw" was never referenced
1584 # remark #981: operands are evaluated in unspecified order
1585 # warning #269: invalid format string conversion
1586
1587         AC_CHECKING([for $CC warning options])
1588         cf_save_CXXFLAGS="$CXXFLAGS"
1589         EXTRA_CXXFLAGS="-Wall"
1590         for cf_opt in \
1591                 wd1419 \
1592                 wd1682 \
1593                 wd1683 \
1594                 wd1684 \
1595                 wd193 \
1596                 wd279 \
1597                 wd593 \
1598                 wd810 \
1599                 wd869 \
1600                 wd981
1601         do
1602                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
1603                 if AC_TRY_EVAL(ac_compile); then
1604                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1605                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1606                 fi
1607         done
1608         CXXFLAGS="$cf_save_CXXFLAGS"
1609
1610 elif test "$GXX" = yes
1611 then
1612         AC_CHECKING([for $CXX warning options])
1613         cf_save_CXXFLAGS="$CXXFLAGS"
1614         EXTRA_CXXFLAGS="-W -Wall"
1615         cf_gxx_extra_warnings=""
1616         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
1617         case "$GCC_VERSION" in
1618         [[1-2]].*)
1619                 ;;
1620         *)
1621                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
1622                 ;;
1623         esac
1624         for cf_opt in \
1625                 Wabi \
1626                 fabi-version=0 \
1627                 Woverloaded-virtual \
1628                 Wsign-promo \
1629                 Wsynth \
1630                 Wold-style-cast \
1631                 Wcast-align \
1632                 Wcast-qual \
1633                 Wmissing-prototypes \
1634                 Wpointer-arith \
1635                 Wshadow \
1636                 Wstrict-prototypes \
1637                 Wundef $cf_gxx_extra_warnings $1
1638         do
1639                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
1640                 if AC_TRY_EVAL(ac_compile); then
1641                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1642                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1643                 else
1644                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
1645                 fi
1646         done
1647         CXXFLAGS="$cf_save_CXXFLAGS"
1648 fi
1649
1650 rm -f conftest*
1651 AC_LANG_RESTORE
1652 AC_SUBST(EXTRA_CXXFLAGS)
1653 ])dnl
1654 dnl ---------------------------------------------------------------------------
1655 dnl CF_HASHED_DB version: 3 updated: 2007/11/24 17:43:37
1656 dnl ------------
1657 dnl Look for an instance of the Berkeley hashed database.
1658 dnl
1659 dnl $1 = optional parameter, to specify install-prefix for the database.
1660 AC_DEFUN([CF_HASHED_DB],
1661 [
1662 ifelse([$1],,,[
1663 case $1 in #(vi
1664 yes|*able*) #(vi
1665     ;;
1666 *)
1667     if test -d "$1" ; then
1668         CF_ADD_INCDIR($1/include)
1669         CF_ADD_LIBDIR($1/lib)
1670     fi
1671 esac
1672 ])
1673 AC_CHECK_HEADER(db.h,[
1674 CF_HASHED_DB_VERSION
1675 if test "$cf_cv_hashed_db_version" = unknown ; then
1676         AC_MSG_ERROR(Cannot determine version of db)
1677 else
1678         CF_HASHED_DB_LIBS
1679         if test "$cf_cv_hashed_db_libs" = unknown ; then
1680                 AC_MSG_ERROR(Cannot determine library for db)
1681         elif test "$cf_cv_hashed_db_libs" != default ; then
1682                 LIBS="-l$cf_cv_hashed_db_libs $LIBS"
1683         fi
1684 fi
1685 ],[
1686         AC_MSG_ERROR(Cannot find db.h)
1687 ])
1688 ])dnl
1689 dnl ---------------------------------------------------------------------------
1690 dnl CF_HASHED_DB_LIBS version: 6 updated: 2006/12/16 12:33:30
1691 dnl -----------------
1692 dnl Given that we have the header and version for hashed database, find the
1693 dnl library information.
1694 AC_DEFUN([CF_HASHED_DB_LIBS],
1695 [
1696 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
1697 cf_cv_hashed_db_libs=unknown
1698 for cf_db_libs in db$cf_cv_hashed_db_version db ''
1699 do
1700         cf_save_libs="$LIBS"
1701         if test -n "$cf_db_libs"; then
1702                 LIBS="-l$cf_db_libs $LIBS"
1703         fi
1704         CF_MSG_LOG(checking for library "$cf_db_libs")
1705         AC_TRY_LINK([
1706 $ac_includes_default
1707 #include <db.h>
1708 ],[
1709         char *path = "/tmp/foo";
1710 #ifdef DB_VERSION_MAJOR
1711 #if DB_VERSION_MAJOR >= 4
1712         DB *result = 0;
1713         db_create(&result, NULL, 0);
1714         result->open(result,
1715                 NULL,
1716                 path,
1717                 path,
1718                 DB_HASH,
1719                 DB_CREATE,
1720                 0644);
1721 #elif DB_VERSION_MAJOR >= 3
1722         DB *result = 0;
1723         db_create(&result, NULL, 0);
1724         result->open(result,
1725                 path,
1726                 path,
1727                 DB_HASH,
1728                 DB_CREATE,
1729                 0644);
1730 #elif DB_VERSION_MAJOR >= 2
1731         DB *result = 0;
1732         db_open(path,
1733                 DB_HASH,
1734                 DB_CREATE,
1735                 0644,
1736                 (DB_ENV *) 0,
1737                 (DB_INFO *) 0,
1738                 &result);
1739 #endif /* DB_VERSION_MAJOR */
1740 #else
1741         DB *result = dbopen(path,
1742                      2,
1743                      0644,
1744                      DB_HASH,
1745                      0);
1746 #endif
1747         ${cf_cv_main_return:-return}(result != 0)
1748 ],[
1749         if test -n "$cf_db_libs" ; then
1750                 cf_cv_hashed_db_libs=$cf_db_libs
1751         else
1752                 cf_cv_hashed_db_libs=default
1753         fi
1754         LIBS="$cf_save_libs"
1755         break
1756 ])
1757         LIBS="$cf_save_libs"
1758 done
1759 ])
1760 ])dnl
1761 dnl ---------------------------------------------------------------------------
1762 dnl CF_HASHED_DB_VERSION version: 2 updated: 2006/08/19 15:12:49
1763 dnl --------------------
1764 dnl Given that we have the header file for hashed database, find the version
1765 dnl information.
1766 AC_DEFUN([CF_HASHED_DB_VERSION],
1767 [
1768 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
1769 cf_cv_hashed_db_version=unknown
1770
1771 for cf_db_version in 1 2 3 4
1772 do
1773         CF_MSG_LOG(checking for db version $cf_db_version)
1774         AC_TRY_COMPILE([
1775 $ac_includes_default
1776 #include <db.h>
1777
1778 #ifdef DB_VERSION_MAJOR
1779         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
1780 #if $cf_db_version == DB_VERSION_MAJOR
1781         /* ok */
1782 #else
1783         make an error
1784 #endif
1785 #else
1786 #if $cf_db_version == 1
1787         /* ok: assuming this is DB 1.8.5 */
1788 #else
1789         make an error
1790 #endif
1791 #endif
1792 ],[DBT *foo = 0],[
1793         cf_cv_hashed_db_version=$cf_db_version
1794         break
1795         ])
1796 done
1797 ])
1798 ])dnl
1799 dnl ---------------------------------------------------------------------------
1800 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
1801 dnl ---------------
1802 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
1803 AC_DEFUN([CF_HELP_MESSAGE],
1804 [AC_DIVERT_HELP([$1])dnl
1805 ])dnl
1806 dnl ---------------------------------------------------------------------------
1807 dnl CF_INCLUDE_DIRS version: 5 updated: 2006/10/14 15:23:15
1808 dnl ---------------
1809 dnl Construct the list of include-options according to whether we're building
1810 dnl in the source directory or using '--srcdir=DIR' option.  If we're building
1811 dnl with gcc, don't append the includedir if it happens to be /usr/include,
1812 dnl since that usually breaks gcc's shadow-includes.
1813 AC_DEFUN([CF_INCLUDE_DIRS],
1814 [
1815 CPPFLAGS="-I. -I../include $CPPFLAGS"
1816 if test "$srcdir" != "."; then
1817         CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
1818 fi
1819 if test "$GCC" != yes; then
1820         CPPFLAGS="$CPPFLAGS -I\${includedir}"
1821 elif test "$includedir" != "/usr/include"; then
1822         if test "$includedir" = '${prefix}/include' ; then
1823                 if test $prefix != /usr ; then
1824                         CPPFLAGS="$CPPFLAGS -I\${includedir}"
1825                 fi
1826         else
1827                 CPPFLAGS="$CPPFLAGS -I\${includedir}"
1828         fi
1829 fi
1830 AC_SUBST(CPPFLAGS)
1831 ])dnl
1832 dnl ---------------------------------------------------------------------------
1833 dnl CF_INTEL_COMPILER version: 3 updated: 2005/08/06 18:37:29
1834 dnl -----------------
1835 dnl Check if the given compiler is really the Intel compiler for Linux.  It
1836 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
1837 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
1838 dnl
1839 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1840 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
1841 dnl the wrappers for gcc and g++ warnings.
1842 dnl
1843 dnl $1 = GCC (default) or GXX
1844 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
1845 dnl $3 = CFLAGS (default) or CXXFLAGS
1846 AC_DEFUN([CF_INTEL_COMPILER],[
1847 ifelse($2,,INTEL_COMPILER,[$2])=no
1848
1849 if test "$ifelse($1,,[$1],GCC)" = yes ; then
1850         case $host_os in
1851         linux*|gnu*)
1852                 AC_MSG_CHECKING(if this is really Intel ifelse($1,GXX,C++,C) compiler)
1853                 cf_save_CFLAGS="$ifelse($3,,CFLAGS,[$3])"
1854                 ifelse($3,,CFLAGS,[$3])="$ifelse($3,,CFLAGS,[$3]) -no-gcc"
1855                 AC_TRY_COMPILE([],[
1856 #ifdef __INTEL_COMPILER
1857 #else
1858 make an error
1859 #endif
1860 ],[ifelse($2,,INTEL_COMPILER,[$2])=yes
1861 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
1862 ],[])
1863                 ifelse($3,,CFLAGS,[$3])="$cf_save_CFLAGS"
1864                 AC_MSG_RESULT($ifelse($2,,INTEL_COMPILER,[$2]))
1865                 ;;
1866         esac
1867 fi
1868 ])dnl
1869 dnl ---------------------------------------------------------------------------
1870 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
1871 dnl ----------
1872 dnl Check if we have either a function or macro for 'isascii()'.
1873 AC_DEFUN([CF_ISASCII],
1874 [
1875 AC_MSG_CHECKING(for isascii)
1876 AC_CACHE_VAL(cf_cv_have_isascii,[
1877         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
1878         [cf_cv_have_isascii=yes],
1879         [cf_cv_have_isascii=no])
1880 ])dnl
1881 AC_MSG_RESULT($cf_cv_have_isascii)
1882 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
1883 ])dnl
1884 dnl ---------------------------------------------------------------------------
1885 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
1886 dnl ------------
1887 dnl Add checks for large file support.
1888 AC_DEFUN([CF_LARGEFILE],[
1889 ifdef([AC_FUNC_FSEEKO],[
1890     AC_SYS_LARGEFILE
1891     if test "$enable_largefile" != no ; then
1892         AC_FUNC_FSEEKO
1893
1894         # Normally we would collect these definitions in the config.h,
1895         # but (like _XOPEN_SOURCE), some environments rely on having these
1896         # defined before any of the system headers are included.  Another
1897         # case comes up with C++, e.g., on AIX the compiler compiles the
1898         # header files by themselves before looking at the body files it is
1899         # told to compile.  For ncurses, those header files do not include
1900         # the config.h
1901         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
1902         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
1903         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
1904
1905         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
1906                 AC_TRY_COMPILE([
1907 #include <sys/types.h>
1908 #include <dirent.h>
1909                 ],[
1910                 /* if transitional largefile support is setup, this is true */
1911                 extern struct dirent64 * readdir(DIR *);
1912                 struct dirent64 *x = readdir((DIR *)0);
1913                 struct dirent *y = readdir((DIR *)0);
1914                 int z = x - y;
1915                 ],
1916                 [cf_cv_struct_dirent64=yes],
1917                 [cf_cv_struct_dirent64=no])
1918         ])
1919         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
1920     fi
1921 ])
1922 ])
1923 dnl ---------------------------------------------------------------------------
1924 dnl CF_LDFLAGS_STATIC version: 2 updated: 2007/04/28 15:25:27
1925 dnl -----------------
1926 dnl Check for compiler/linker flags used to temporarily force usage of static
1927 dnl libraries.  This depends on the compiler and platform.  Use this to help
1928 dnl ensure that the linker picks up a given library based on its position in
1929 dnl the list of linker options and libraries.
1930 AC_DEFUN([CF_LDFLAGS_STATIC],[
1931
1932 if test "$GCC" = yes ; then
1933         LDFLAGS_STATIC=-static
1934         LDFLAGS_SHARED=-dynamic
1935 else
1936         case $cf_cv_system_name in #(
1937         aix[[45]]*)     #( from ld manpage
1938                 LDFLAGS_STATIC=-bstatic
1939                 LDFLAGS_SHARED=-bdynamic
1940                 ;;
1941         hpux*)          #( from ld manpage for hpux10.20, hpux11.11
1942                 # We could also use just "archive" and "shared".
1943                 LDFLAGS_STATIC=-Wl,-a,archive_shared
1944                 LDFLAGS_SHARED=-Wl,-a,shared_archive
1945                 ;;
1946         irix*)          #( from ld manpage IRIX64
1947                 LDFLAGS_STATIC=-Bstatic
1948                 LDFLAGS_SHARED=-Bdynamic
1949                 ;;
1950         osf[[45]]*)     #( from ld manpage osf4.0d, osf5.1
1951                 # alternative "-oldstyle_liblookup" (not in cc manpage)
1952                 LDFLAGS_STATIC=-noso 
1953                 LDFLAGS_SHARED=-so_archive
1954                 ;;
1955         solaris2*)
1956                 LDFLAGS_STATIC=-Bstatic
1957                 LDFLAGS_SHARED=-Bdynamic
1958                 ;;
1959         esac
1960 fi
1961
1962 AC_SUBST(LDFLAGS_STATIC)
1963 AC_SUBST(LDFLAGS_SHARED)
1964 ])
1965 dnl ---------------------------------------------------------------------------
1966 dnl CF_LIBUTF8 version: 2 updated: 2002/01/19 22:51:32
1967 dnl ----------
1968 dnl Check for libutf8
1969 AC_DEFUN([CF_LIBUTF8],
1970 [
1971 AC_CACHE_CHECK(for putwc in libutf8,cf_cv_libutf8,[
1972         cf_save_LIBS="$LIBS"
1973         LIBS="-lutf8 $LIBS"
1974 AC_TRY_LINK([
1975 #include <libutf8.h>],[putwc(0,0);],
1976         [cf_cv_libutf8=yes],
1977         [cf_cv_libutf8=no])
1978         LIBS="$cf_save_LIBS"
1979 ])
1980
1981 if test "$cf_cv_libutf8" = yes ; then
1982         AC_DEFINE(HAVE_LIBUTF8_H)
1983         LIBS="-lutf8 $LIBS"
1984 fi
1985 ])dnl
1986 dnl ---------------------------------------------------------------------------
1987 dnl CF_LIB_PREFIX version: 7 updated: 2001/01/12 01:23:48
1988 dnl -------------
1989 dnl Compute the library-prefix for the given host system
1990 dnl $1 = variable to set
1991 AC_DEFUN([CF_LIB_PREFIX],
1992 [
1993         case $cf_cv_system_name in
1994         OS/2*)  LIB_PREFIX=''     ;;
1995         os2*)   LIB_PREFIX=''     ;;
1996         *)      LIB_PREFIX='lib'  ;;
1997         esac
1998 ifelse($1,,,[$1=$LIB_PREFIX])
1999         AC_SUBST(LIB_PREFIX)
2000 ])dnl
2001 dnl ---------------------------------------------------------------------------
2002 dnl CF_LIB_RULES version: 50 updated: 2007/03/24 18:26:59
2003 dnl ------------
2004 dnl Append definitions and rules for the given models to the subdirectory
2005 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
2006 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
2007 dnl the corresponding makefile to list the models that we'll generate.
2008 dnl
2009 dnl For shared libraries, make a list of symbolic links to construct when
2010 dnl generating each library.  The convention used for Linux is the simplest
2011 dnl one:
2012 dnl     lib<name>.so    ->
2013 dnl     lib<name>.so.<major>    ->
2014 dnl     lib<name>.so.<maj>.<minor>
2015 AC_DEFUN([CF_LIB_RULES],
2016 [
2017 CF_LIB_PREFIX(cf_prefix)
2018 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2019 for cf_dir in $SRC_SUBDIRS
2020 do
2021         if test ! -d $srcdir/$cf_dir ; then
2022                 continue
2023         elif test -f $srcdir/$cf_dir/modules; then
2024
2025                 SHARED_LIB=
2026                 LIBS_TO_MAKE=
2027                 for cf_item in $cf_LIST_MODELS
2028                 do
2029                         CF_LIB_SUFFIX($cf_item,cf_suffix)
2030                         if test $cf_item = shared ; then
2031                         if test "$cf_cv_do_symlinks" = yes ; then
2032                                 case "$cf_cv_shlib_version" in #(vi
2033                                 rel) #(vi
2034                                         case "$cf_cv_system_name" in #(vi
2035                                         darwin*)
2036                                         case .${LIB_SUFFIX} in
2037                                         .w*)
2038                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2039                                                 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
2040                                                 ;;
2041                                         *)
2042                                                 cf_suffix='.${REL_VERSION}'"$cf_suffix"
2043                                                 ;;
2044                                         esac
2045                                         ;; #(vi
2046                                         *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
2047                                         esac
2048                                         ;;
2049                                 abi)
2050                                         case "$cf_cv_system_name" in #(vi
2051                                         darwin*)
2052                                         case .${LIB_SUFFIX} in
2053                                         .w*)
2054                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2055                                                 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
2056                                                 ;;
2057                                         *)
2058                                                 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
2059                                                 ;;
2060                                         esac
2061                                         ;; #(vi
2062                                         *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
2063                                         esac
2064                                         ;;
2065                                 esac
2066                         fi
2067                         # cygwin needs import library, and has unique naming convention
2068                         # use autodetected ${cf_prefix} for import lib and static lib, but
2069                         # use 'cyg' prefix for shared lib.
2070                         if test $cf_cv_shlib_version = cygdll ; then
2071                                 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}\${ABI_VERSION}.dll"
2072                                 continue
2073                         fi
2074                         fi
2075                         LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
2076                 done
2077
2078                 if test $cf_dir = ncurses ; then
2079                         cf_subsets="$LIB_SUBSETS"
2080                         cf_r_parts="$cf_subsets"
2081
2082                         while test -n "$cf_r_parts"
2083                         do
2084                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
2085                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
2086                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
2087                                         case $cf_l_parts in #(vi
2088                                         *termlib*) #(vi
2089                                                 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
2090                                                 ;;
2091                                         *ticlib*)
2092                                                 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
2093                                                 ;;
2094                                         *)
2095                                                 break
2096                                                 ;;
2097                                         esac
2098                                         LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
2099                                 else
2100                                         break
2101                                 fi
2102                         done
2103                 else
2104                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
2105                 fi
2106
2107                 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
2108                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
2109                         $cf_dir/Makefile >$cf_dir/Makefile.out
2110                 mv $cf_dir/Makefile.out $cf_dir/Makefile
2111
2112                 $AWK -f $srcdir/mk-0th.awk \
2113                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
2114                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2115
2116                 for cf_subset in $cf_subsets
2117                 do
2118                         cf_subdirs=
2119                         for cf_item in $cf_LIST_MODELS
2120                         do
2121                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
2122                         CF_UPPER(cf_ITEM,$cf_item)
2123                         CF_LIB_SUFFIX($cf_item,cf_suffix)
2124                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
2125
2126                         # Test for case where we build libtinfo with a different name.
2127                         cf_libname=$cf_dir
2128                         if test $cf_dir = ncurses ; then
2129                                 case $cf_subset in
2130                                 *base*)
2131                                         ;;
2132                                 *termlib*)
2133                                         cf_libname=$TINFO_LIB_SUFFIX
2134                                         if test -n "${DFT_ARG_SUFFIX}" ; then
2135                                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2136                                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2137                                         fi
2138                                         ;;
2139                                 ticlib*)
2140                                         cf_libname=$TICS_LIB_SUFFIX
2141                                         if test -n "${DFT_ARG_SUFFIX}" ; then
2142                                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2143                                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2144                                         fi
2145                                         ;;
2146                                 esac
2147                         fi
2148
2149                         # These dependencies really are for development, not
2150                         # builds, but they are useful in porting, too.
2151                         cf_depend="../include/ncurses_cfg.h"
2152                         if test "$srcdir" = "."; then
2153                                 cf_reldir="."
2154                         else
2155                                 cf_reldir="\${srcdir}"
2156                         fi
2157
2158                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
2159                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
2160                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
2161                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
2162                         fi
2163
2164                         cf_dir_suffix=
2165                         old_cf_suffix="$cf_suffix"
2166                         if test "$cf_cv_shlib_version_infix" = yes ; then
2167                         if test -n "$LIB_SUFFIX" ; then
2168                                 case $LIB_SUFFIX in
2169                                 w*)
2170                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
2171                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2172                                         cf_dir_suffix=w
2173                                         ;;
2174                                 esac
2175                         fi
2176                         fi
2177
2178                         $AWK -f $srcdir/mk-1st.awk \
2179                                 name=${cf_libname}${cf_dir_suffix} \
2180                                 traces=$LIB_TRACING \
2181                                 MODEL=$cf_ITEM \
2182                                 model=$cf_subdir \
2183                                 prefix=$cf_prefix \
2184                                 suffix=$cf_suffix \
2185                                 subset=$cf_subset \
2186                                 TermlibRoot=$TINFO_NAME \
2187                                 TermlibSuffix=$TINFO_SUFFIX \
2188                                 ShlibVer=$cf_cv_shlib_version \
2189                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
2190                                 ReLink=${cf_cv_do_relink-no} \
2191                                 DoLinks=$cf_cv_do_symlinks \
2192                                 rmSoLocs=$cf_cv_rm_so_locs \
2193                                 ldconfig="$LDCONFIG" \
2194                                 overwrite=$WITH_OVERWRITE \
2195                                 depend="$cf_depend" \
2196                                 host="$host" \
2197                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2198
2199                         cf_suffix="$old_cf_suffix"
2200
2201                         for cf_subdir2 in $cf_subdirs lib
2202                         do
2203                                 test $cf_subdir = $cf_subdir2 && break
2204                         done
2205                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
2206                         $AWK -f $srcdir/mk-2nd.awk \
2207                                 name=$cf_dir \
2208                                 traces=$LIB_TRACING \
2209                                 MODEL=$cf_ITEM \
2210                                 model=$cf_subdir \
2211                                 subset=$cf_subset \
2212                                 srcdir=$srcdir \
2213                                 echo=$WITH_ECHO \
2214                                 crenames=$cf_cv_prog_CC_c_o \
2215                                 cxxrenames=$cf_cv_prog_CXX_c_o \
2216                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2217                         cf_subdirs="$cf_subdirs $cf_subdir"
2218                         done
2219                 done
2220         fi
2221
2222         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
2223 done
2224
2225 for cf_dir in $SRC_SUBDIRS
2226 do
2227         if test ! -d $srcdir/$cf_dir ; then
2228                 continue
2229         fi
2230
2231         if test -f $cf_dir/Makefile ; then
2232                 case "$cf_dir" in
2233                 Ada95) #(vi
2234                         echo 'libs \' >> Makefile
2235                         echo 'install.libs \' >> Makefile
2236                         echo 'uninstall.libs ::' >> Makefile
2237                         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
2238                         ;;
2239                 esac
2240         fi
2241
2242         if test -f $srcdir/$cf_dir/modules; then
2243                 echo >> Makefile
2244                 if test -f $srcdir/$cf_dir/headers; then
2245 cat >> Makefile <<CF_EOF
2246 install.includes \\
2247 uninstall.includes \\
2248 CF_EOF
2249                 fi
2250 if test "$cf_dir" != "c++" ; then
2251 echo 'lint \' >> Makefile
2252 fi
2253 cat >> Makefile <<CF_EOF
2254 libs \\
2255 lintlib \\
2256 install.libs \\
2257 uninstall.libs \\
2258 install.$cf_dir \\
2259 uninstall.$cf_dir ::
2260         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2261 CF_EOF
2262         elif test -f $srcdir/$cf_dir/headers; then
2263 cat >> Makefile <<CF_EOF
2264
2265 libs \\
2266 install.libs \\
2267 uninstall.libs \\
2268 install.includes \\
2269 uninstall.includes ::
2270         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2271 CF_EOF
2272 fi
2273 done
2274
2275 cat >> Makefile <<CF_EOF
2276
2277 install.libs uninstall.libs \\
2278 install.data uninstall.data ::
2279 $MAKE_TERMINFO  cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
2280
2281 install.man \\
2282 uninstall.man ::
2283         cd man && \${MAKE} \${CF_MFLAGS} \[$]@
2284
2285 distclean ::
2286         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
2287         rm -f headers.sh headers.sed mk_shared_lib.sh
2288         rm -rf \${DIRS_TO_MAKE}
2289 CF_EOF
2290
2291 # Special case: tack's manpage lives in its own directory.
2292 if test -d tack ; then
2293 if test -f $srcdir/$tack.h; then
2294 cat >> Makefile <<CF_EOF
2295
2296 install.man \\
2297 uninstall.man ::
2298         cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
2299 CF_EOF
2300 fi
2301 fi
2302
2303 dnl If we're installing into a subdirectory of /usr/include, etc., we should
2304 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
2305 dnl anything, and will make it more standardized.  It's awkward to decide this
2306 dnl at configuration because of quoting, so we'll simply make all headers
2307 dnl installed via a script that can do the right thing.
2308
2309 rm -f headers.sed headers.sh
2310
2311 dnl ( generating this script makes the makefiles a little tidier :-)
2312 echo creating headers.sh
2313 cat >headers.sh <<CF_EOF
2314 #! /bin/sh
2315 # This shell script is generated by the 'configure' script.  It is invoked in a
2316 # subdirectory of the build tree.  It generates a sed-script in the parent
2317 # directory that is used to adjust includes for header files that reside in a
2318 # subdirectory of /usr/include, etc.
2319 PRG=""
2320 while test \[$]# != 3
2321 do
2322 PRG="\$PRG \[$]1"; shift
2323 done
2324 DST=\[$]1
2325 REF=\[$]2
2326 SRC=\[$]3
2327 TMPSRC=\${TMPDIR-/tmp}/\`basename \$SRC\`\$\$
2328 TMPSED=\${TMPDIR-/tmp}/headers.sed\$\$
2329 echo installing \$SRC in \$DST
2330 CF_EOF
2331
2332 if test $WITH_CURSES_H = yes; then
2333         cat >>headers.sh <<CF_EOF
2334 case \$DST in
2335 /*/include/*)
2336         END=\`basename \$DST\`
2337         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2338         do
2339                 NAME=\`basename \$i\`
2340                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2341         done
2342         ;;
2343 *)
2344         echo "" >> \$TMPSED
2345         ;;
2346 esac
2347 CF_EOF
2348
2349 else
2350         cat >>headers.sh <<CF_EOF
2351 case \$DST in
2352 /*/include/*)
2353         END=\`basename \$DST\`
2354         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2355         do
2356                 NAME=\`basename \$i\`
2357                 if test "\$NAME" = "curses.h"
2358                 then
2359                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2360                         NAME=ncurses.h
2361                 fi
2362                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2363         done
2364         ;;
2365 *)
2366         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2367         ;;
2368 esac
2369 CF_EOF
2370 fi
2371 cat >>headers.sh <<CF_EOF
2372 rm -f \$TMPSRC
2373 sed -f \$TMPSED \$SRC > \$TMPSRC
2374 NAME=\`basename \$SRC\`
2375 CF_EOF
2376 if test $WITH_CURSES_H != yes; then
2377         cat >>headers.sh <<CF_EOF
2378 test "\$NAME" = "curses.h" && NAME=ncurses.h
2379 CF_EOF
2380 fi
2381 cat >>headers.sh <<CF_EOF
2382 # Just in case someone gzip'd manpages, remove the conflicting copy.
2383 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
2384
2385 eval \$PRG \$TMPSRC \$DST/\$NAME
2386 rm -f \$TMPSRC \$TMPSED
2387 CF_EOF
2388
2389 chmod 0755 headers.sh
2390
2391 for cf_dir in $SRC_SUBDIRS
2392 do
2393         if test ! -d $srcdir/$cf_dir ; then
2394                 continue
2395         fi
2396
2397         if test -f $srcdir/$cf_dir/headers; then
2398                 $AWK -f $srcdir/mk-hdr.awk \
2399                         subset="$LIB_SUBSETS" \
2400                         compat="$WITH_CURSES_H" \
2401                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
2402         fi
2403
2404         if test -f $srcdir/$cf_dir/modules; then
2405                 if test "$cf_dir" != "c++" ; then
2406                         cat >>$cf_dir/Makefile <<"CF_EOF"
2407 depend : ${AUTO_SRC}
2408         makedepend -- ${CPPFLAGS} -- ${C_SRC}
2409
2410 # DO NOT DELETE THIS LINE -- make depend depends on it.
2411 CF_EOF
2412                 fi
2413         fi
2414 done
2415
2416 ])dnl
2417 dnl ---------------------------------------------------------------------------
2418 dnl CF_LIB_SONAME version: 3 updated: 2006/12/16 15:55:46
2419 dnl -------------
2420 dnl Find the and soname for the given shared library.  Set the cache variable
2421 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
2422 dnl variable to "unknown".
2423 dnl
2424 dnl $1 = headers
2425 dnl $2 = code
2426 dnl $3 = library name
2427 AC_DEFUN([CF_LIB_SONAME],
2428 [
2429 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
2430
2431 cf_cv_$3_soname=unknown
2432 if test "$cross_compiling" != yes ; then
2433 cat >conftest.$ac_ext <<CF_EOF
2434 $1
2435 int main()
2436 {
2437 $2
2438         ${cf_cv_main_return:-return}(0);
2439 }
2440 CF_EOF
2441 cf_save_LIBS="$LIBS"
2442         LIBS="-l$3 $LIBS"
2443         if AC_TRY_EVAL(ac_compile) ; then
2444                 if AC_TRY_EVAL(ac_link) ; then
2445                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
2446                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
2447                 fi
2448         fi
2449 rm -f conftest*
2450 LIBS="$cf_save_LIBS"
2451 fi
2452 ])
2453 ])
2454 dnl ---------------------------------------------------------------------------
2455 dnl CF_LIB_SUFFIX version: 13 updated: 2003/11/01 16:09:07
2456 dnl -------------
2457 dnl Compute the library file-suffix from the given model name
2458 dnl $1 = model name
2459 dnl $2 = variable to set
2460 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2461 AC_DEFUN([CF_LIB_SUFFIX],
2462 [
2463         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2464         case $1 in
2465         libtool) $2='.la'  ;;
2466         normal)  $2='.a'   ;;
2467         debug)   $2='_g.a' ;;
2468         profile) $2='_p.a' ;;
2469         shared)
2470                 case $cf_cv_system_name in
2471                 cygwin*) $2='.dll' ;;
2472                 darwin*) $2='.dylib' ;;
2473                 hpux*)
2474                         case $target in
2475                         ia64*)  $2='.so' ;;
2476                         *)      $2='.sl' ;;
2477                         esac
2478                         ;;
2479                 *)      $2='.so'  ;;
2480                 esac
2481         esac
2482         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2483 ])dnl
2484 dnl ---------------------------------------------------------------------------
2485 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
2486 dnl -----------
2487 dnl Compute the string to append to -library from the given model name
2488 dnl $1 = model name
2489 dnl $2 = variable to set
2490 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2491 AC_DEFUN([CF_LIB_TYPE],
2492 [
2493         case $1 in
2494         libtool) $2=''   ;;
2495         normal)  $2=''   ;;
2496         debug)   $2='_g' ;;
2497         profile) $2='_p' ;;
2498         shared)  $2=''   ;;
2499         esac
2500         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2501 ])dnl
2502 dnl ---------------------------------------------------------------------------
2503 dnl CF_LINK_DATAONLY version: 8 updated: 2006/12/16 12:33:30
2504 dnl ----------------
2505 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2506 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
2507 dnl have to provide wrappers for global tables to ensure they're linked
2508 dnl properly.
2509 AC_DEFUN([CF_LINK_DATAONLY],
2510 [
2511 AC_MSG_CHECKING([if data-only library module links])
2512 AC_CACHE_VAL(cf_cv_link_dataonly,[
2513         rm -f conftest.a
2514         cat >conftest.$ac_ext <<EOF
2515 #line __oline__ "configure"
2516 int     testdata[[3]] = { 123, 456, 789 };
2517 EOF
2518         if AC_TRY_EVAL(ac_compile) ; then
2519                 mv conftest.o data.o && \
2520                 ( $AR $AR_OPTS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2521         fi
2522         rm -f conftest.$ac_ext data.o
2523         cat >conftest.$ac_ext <<EOF
2524 #line __oline__ "configure"
2525 int     testfunc()
2526 {
2527 #if defined(NeXT)
2528         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
2529 #else
2530         extern int testdata[[3]];
2531         return testdata[[0]] == 123
2532            &&  testdata[[1]] == 456
2533            &&  testdata[[2]] == 789;
2534 #endif
2535 }
2536 EOF
2537         if AC_TRY_EVAL(ac_compile); then
2538                 mv conftest.o func.o && \
2539                 ( $AR $AR_OPTS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2540         fi
2541         rm -f conftest.$ac_ext func.o
2542         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2543         cf_saveLIBS="$LIBS"
2544         LIBS="conftest.a $LIBS"
2545         AC_TRY_RUN([
2546         int main()
2547         {
2548                 extern int testfunc();
2549                 ${cf_cv_main_return:-return} (!testfunc());
2550         }
2551         ],
2552         [cf_cv_link_dataonly=yes],
2553         [cf_cv_link_dataonly=no],
2554         [cf_cv_link_dataonly=unknown])
2555         LIBS="$cf_saveLIBS"
2556         ])
2557 AC_MSG_RESULT($cf_cv_link_dataonly)
2558
2559 if test "$cf_cv_link_dataonly" = no ; then
2560         AC_DEFINE(BROKEN_LINKER)
2561         BROKEN_LINKER=1
2562 fi
2563
2564 ])dnl
2565 dnl ---------------------------------------------------------------------------
2566 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
2567 dnl -------------
2568 dnl Most Unix systems have both link and symlink, a few don't have symlink.
2569 dnl A few non-Unix systems implement symlink, but not link.
2570 dnl A few non-systems implement neither (or have nonfunctional versions).
2571 AC_DEFUN([CF_LINK_FUNCS],
2572 [
2573 AC_CHECK_FUNCS( \
2574         remove \
2575         unlink )
2576
2577 if test "$cross_compiling" = yes ; then
2578         AC_CHECK_FUNCS( \
2579                 link \
2580                 symlink )
2581 else
2582         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
2583                 cf_cv_link_funcs=
2584                 for cf_func in link symlink ; do
2585                         AC_TRY_RUN([
2586 #include <sys/types.h>
2587 #include <sys/stat.h>
2588 #ifdef HAVE_UNISTD_H
2589 #include <unistd.h>
2590 #endif
2591 int main()
2592 {
2593         int fail = 0;
2594         char *src = "config.log";
2595         char *dst = "conftest.chk";
2596         struct stat src_sb;
2597         struct stat dst_sb;
2598
2599         stat(src, &src_sb);
2600         fail = ($cf_func("config.log", "conftest.chk") < 0)
2601             || (stat(dst, &dst_sb) < 0)
2602             || (dst_sb.st_mtime != src_sb.st_mtime);
2603 #ifdef HAVE_UNLINK
2604         unlink(dst);
2605 #else
2606         remove(dst);
2607 #endif
2608         ${cf_cv_main_return:-return} (fail);
2609 }
2610                         ],[
2611                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
2612                         eval 'ac_cv_func_'$cf_func'=yes'],[
2613                         eval 'ac_cv_func_'$cf_func'=no'],[
2614                         eval 'ac_cv_func_'$cf_func'=error'])
2615                 done
2616                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
2617         ])
2618         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
2619         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
2620 fi
2621 ])dnl
2622 dnl ---------------------------------------------------------------------------
2623 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
2624 dnl --------------
2625 dnl Check if a return from main to the shell actually returns the same exit
2626 dnl code.  This is true for almost any POSIX environment.
2627 dnl
2628 dnl Some very old environments did not flush stdout, etc., on an exit.  That
2629 dnl would be a useful case to test for also.
2630 AC_DEFUN([CF_MAIN_RETURN],
2631 [
2632 cf_cv_main_return=return
2633 ])dnl
2634 dnl ---------------------------------------------------------------------------
2635 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
2636 dnl ------------
2637 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2638 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
2639 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2640 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2641 AC_DEFUN([CF_MAKEFLAGS],
2642 [
2643 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2644         cf_cv_makeflags=''
2645         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2646         do
2647                 cat >cf_makeflags.tmp <<CF_EOF
2648 SHELL = /bin/sh
2649 all :
2650         @ echo '.$cf_option'
2651 CF_EOF
2652                 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[       ]]*$,,'`
2653                 case "$cf_result" in
2654                 .*k)
2655                         cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
2656                         case "$cf_result" in
2657                         .*CC=*) cf_cv_makeflags=
2658                                 ;;
2659                         *)      cf_cv_makeflags=$cf_option
2660                                 ;;
2661                         esac
2662                         break
2663                         ;;
2664                 .-)     ;;
2665                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
2666                         ;;
2667                 esac
2668         done
2669         rm -f cf_makeflags.tmp
2670 ])
2671
2672 AC_SUBST(cf_cv_makeflags)
2673 ])dnl
2674 dnl ---------------------------------------------------------------------------
2675 dnl CF_MAKE_TAGS version: 2 updated: 2000/10/04 09:18:40
2676 dnl ------------
2677 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
2678 dnl a monocase filesystem.
2679 AC_DEFUN([CF_MAKE_TAGS],[
2680 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2681 AC_CHECK_PROG(MAKE_LOWER_TAGS, ctags, yes, no)
2682
2683 if test "$cf_cv_mixedcase" = yes ; then
2684         AC_CHECK_PROG(MAKE_UPPER_TAGS, etags, yes, no)
2685 else
2686         MAKE_UPPER_TAGS=no
2687 fi
2688
2689 if test "$MAKE_UPPER_TAGS" = yes ; then
2690         MAKE_UPPER_TAGS=
2691 else
2692         MAKE_UPPER_TAGS="#"
2693 fi
2694 AC_SUBST(MAKE_UPPER_TAGS)
2695
2696 if test "$MAKE_LOWER_TAGS" = yes ; then
2697         MAKE_LOWER_TAGS=
2698 else
2699         MAKE_LOWER_TAGS="#"
2700 fi
2701 AC_SUBST(MAKE_LOWER_TAGS)
2702 ])dnl
2703 dnl ---------------------------------------------------------------------------
2704 dnl CF_MANPAGE_FORMAT version: 7 updated: 2003/12/20 19:30:34
2705 dnl -----------------
2706 dnl Option to allow user to override automatic configuration of manpage format.
2707 dnl There are several special cases:
2708 dnl
2709 dnl     gzip - man checks for, can display gzip'd files
2710 dnl     compress - man checks for, can display compressed files
2711 dnl     BSDI - files in the cat-directories are suffixed ".0"
2712 dnl     formatted - installer should format (put files in cat-directory)
2713 dnl     catonly - installer should only format, e.g., for a turnkey system.
2714 dnl
2715 dnl There are other configurations which this macro does not test, e.g., HPUX's
2716 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
2717 dnl convention would not match our use).
2718 AC_DEFUN([CF_MANPAGE_FORMAT],
2719 [
2720 AC_REQUIRE([CF_PATHSEP])
2721 AC_MSG_CHECKING(format of man-pages)
2722
2723 AC_ARG_WITH(manpage-format,
2724         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
2725                           optionally formatted/catonly, e.g., gzip,formatted],
2726         [MANPAGE_FORMAT=$withval],
2727         [MANPAGE_FORMAT=unknown])
2728
2729 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
2730 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
2731
2732 cf_unknown=
2733
2734 case $MANPAGE_FORMAT in
2735 unknown)
2736   if test -z "$MANPATH" ; then
2737     MANPATH="/usr/man:/usr/share/man"
2738   fi
2739
2740   # look for the 'date' man-page (it's most likely to be installed!)
2741   MANPAGE_FORMAT=
2742   cf_preform=no
2743   cf_catonly=yes
2744   cf_example=date
2745
2746   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATHSEP}"
2747   for cf_dir in $MANPATH; do
2748     test -z "$cf_dir" && cf_dir=/usr/man
2749     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
2750     do
2751       cf_test=`echo $cf_name | sed -e 's/*//'`
2752       if test "x$cf_test" = "x$cf_name" ; then
2753
2754         case "$cf_name" in
2755         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
2756         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
2757         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
2758         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
2759         esac
2760
2761         case "$cf_name" in
2762         $cf_dir/man*)
2763           cf_catonly=no
2764           ;;
2765         $cf_dir/cat*)
2766           cf_preform=yes
2767           ;;
2768         esac
2769         break
2770       fi
2771
2772       # if we found a match in either man* or cat*, stop looking
2773       if test -n "$MANPAGE_FORMAT" ; then
2774         cf_found=no
2775         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
2776         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
2777         case "$cf_name" in
2778         $cf_dir/cat*)
2779           cf_found=yes
2780           ;;
2781         esac
2782         test $cf_found=yes && break
2783       fi
2784     done
2785     # only check the first directory in $MANPATH where we find manpages
2786     if test -n "$MANPAGE_FORMAT" ; then
2787        break
2788     fi
2789   done
2790   # if we did not find the example, just assume it is normal
2791   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
2792   IFS="$ac_save_ifs"
2793   ;;
2794 *)
2795   for cf_option in $MANPAGE_FORMAT; do
2796      case $cf_option in #(vi
2797      gzip|compress|BSDI|normal|formatted|catonly)
2798        ;;
2799      *)
2800        cf_unknown="$cf_unknown $cf_option"
2801        ;;
2802      esac
2803   done
2804   ;;
2805 esac
2806
2807 AC_MSG_RESULT($MANPAGE_FORMAT)
2808 if test -n "$cf_unknown" ; then
2809   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
2810 fi
2811 ])dnl
2812 dnl ---------------------------------------------------------------------------
2813 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
2814 dnl ------------------
2815 dnl The Debian people have their own naming convention for manpages.  This
2816 dnl option lets us override the name of the file containing renaming, or
2817 dnl disable it altogether.
2818 AC_DEFUN([CF_MANPAGE_RENAMES],
2819 [
2820 AC_MSG_CHECKING(for manpage renaming)
2821
2822 AC_ARG_WITH(manpage-renames,
2823         [  --with-manpage-renames  specify manpage-renaming],
2824         [MANPAGE_RENAMES=$withval],
2825         [MANPAGE_RENAMES=yes])
2826
2827 case ".$MANPAGE_RENAMES" in #(vi
2828 .no) #(vi
2829   ;;
2830 .|.yes)
2831   # Debian 'man' program?
2832   if test -f /etc/debian_version ; then
2833     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
2834   else
2835     MANPAGE_RENAMES=no
2836   fi
2837   ;;
2838 esac
2839
2840 if test "$MANPAGE_RENAMES" != no ; then
2841   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
2842     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
2843   elif test ! -f $MANPAGE_RENAMES ; then
2844     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
2845   fi
2846
2847   test ! -d man && mkdir man
2848
2849   # Construct a sed-script to perform renaming within man-pages
2850   if test -n "$MANPAGE_RENAMES" ; then
2851     test ! -d man && mkdir man
2852     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
2853   fi
2854 fi
2855
2856 AC_MSG_RESULT($MANPAGE_RENAMES)
2857 AC_SUBST(MANPAGE_RENAMES)
2858 ])dnl
2859 dnl ---------------------------------------------------------------------------
2860 dnl CF_MANPAGE_SYMLINKS version: 4 updated: 2003/12/13 18:01:58
2861 dnl -------------------
2862 dnl Some people expect each tool to make all aliases for manpages in the
2863 dnl man-directory.  This accommodates the older, less-capable implementations
2864 dnl of 'man', and is optional.
2865 AC_DEFUN([CF_MANPAGE_SYMLINKS],
2866 [
2867 AC_MSG_CHECKING(if manpage aliases will be installed)
2868
2869 AC_ARG_WITH(manpage-aliases,
2870         [  --with-manpage-aliases  specify manpage-aliases using .so],
2871         [MANPAGE_ALIASES=$withval],
2872         [MANPAGE_ALIASES=yes])
2873
2874 AC_MSG_RESULT($MANPAGE_ALIASES)
2875
2876 if test "$LN_S" = "ln -s"; then
2877         cf_use_symlinks=yes
2878 else
2879         cf_use_symlinks=no
2880 fi
2881
2882 MANPAGE_SYMLINKS=no
2883 if test "$MANPAGE_ALIASES" = yes ; then
2884 AC_MSG_CHECKING(if manpage symlinks should be used)
2885
2886 AC_ARG_WITH(manpage-symlinks,
2887         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
2888         [MANPAGE_SYMLINKS=$withval],
2889         [MANPAGE_SYMLINKS=$cf_use_symlinks])
2890
2891 if test "$$cf_use_symlinks" = no; then
2892 if test "$MANPAGE_SYMLINKS" = yes ; then
2893         AC_MSG_WARN(cannot make symlinks, will use .so files)
2894         MANPAGE_SYMLINKS=no
2895 fi
2896 fi
2897
2898 AC_MSG_RESULT($MANPAGE_SYMLINKS)
2899 fi
2900
2901 ])dnl
2902 dnl ---------------------------------------------------------------------------
2903 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
2904 dnl --------------
2905 dnl This option causes manpages to be run through tbl(1) to generate tables
2906 dnl correctly.
2907 AC_DEFUN([CF_MANPAGE_TBL],
2908 [
2909 AC_MSG_CHECKING(for manpage tbl)
2910
2911 AC_ARG_WITH(manpage-tbl,
2912         [  --with-manpage-tbl      specify manpage processing with tbl],
2913         [MANPAGE_TBL=$withval],
2914         [MANPAGE_TBL=no])
2915
2916 AC_MSG_RESULT($MANPAGE_TBL)
2917 ])dnl
2918 dnl ---------------------------------------------------------------------------
2919 dnl CF_MAN_PAGES version: 35 updated: 2007/03/31 11:47:29
2920 dnl ------------
2921 dnl Try to determine if the man-pages on the system are compressed, and if
2922 dnl so, what format is used.  Use this information to construct a script that
2923 dnl will install man-pages.
2924 AC_DEFUN([CF_MAN_PAGES],
2925 [
2926 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
2927 CF_MANPAGE_FORMAT
2928 CF_MANPAGE_RENAMES
2929 CF_MANPAGE_SYMLINKS
2930 CF_MANPAGE_TBL
2931
2932   if test "$prefix" = "NONE" ; then
2933      cf_prefix="$ac_default_prefix"
2934   else
2935      cf_prefix="$prefix"
2936   fi
2937
2938   case "$MANPAGE_FORMAT" in # (vi
2939   *catonly*) # (vi
2940     cf_format=yes
2941     cf_inboth=no
2942     ;;
2943   *formatted*) # (vi
2944     cf_format=yes
2945     cf_inboth=yes
2946     ;;
2947   *)
2948     cf_format=no
2949     cf_inboth=no
2950     ;;
2951   esac
2952
2953 test ! -d man && mkdir man
2954
2955 cf_so_strip=
2956 cf_compress=
2957 case "$MANPAGE_FORMAT" in #(vi
2958 *compress*) #(vi
2959         cf_so_strip="Z"
2960         cf_compress=compress
2961   ;;
2962 *gzip*) #(vi
2963         cf_so_strip="gz"
2964         cf_compress=gzip
2965   ;;
2966 esac
2967
2968 cf_edit_man=./edit_man.sh
2969 cf_man_alias=`pwd`/man_alias.sed
2970
2971 cat >$cf_edit_man <<CF_EOF
2972 #! /bin/sh
2973 # this script is generated by the configure-script CF_MAN_PAGES macro.
2974
2975 prefix="$cf_prefix"
2976 datadir="$datadir"
2977
2978 NCURSES_MAJOR="$NCURSES_MAJOR"
2979 NCURSES_MINOR="$NCURSES_MINOR"
2980 NCURSES_PATCH="$NCURSES_PATCH"
2981
2982 NCURSES_OSPEED="$NCURSES_OSPEED"
2983 TERMINFO="$TERMINFO"
2984
2985 MKDIRS="sh `cd $srcdir && pwd`/mkdirs.sh"
2986
2987 INSTALL="$INSTALL"
2988 INSTALL_DATA="$INSTALL_DATA"
2989
2990 transform="$program_transform_name"
2991
2992 TMP=\${TMPDIR-/tmp}/man\$\$
2993 trap "rm -f \$TMP" 0 1 2 5 15
2994
2995 form=\[$]1
2996 shift || exit 1
2997
2998 verb=\[$]1
2999 shift || exit 1
3000
3001 mandir=\[$]1
3002 shift || exit 1
3003
3004 srcdir=\[$]1
3005 top_srcdir=\[$]srcdir/..
3006 shift || exit 1
3007
3008 if test "\$form" = normal ; then
3009         if test "$cf_format" = yes ; then
3010         if test "$cf_inboth" = no ; then
3011                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3012                 exit $?
3013         fi
3014         fi
3015         cf_subdir=\$mandir/man
3016         cf_tables=$MANPAGE_TBL
3017 else
3018         cf_subdir=\$mandir/cat
3019         cf_tables=yes
3020 fi
3021
3022 # process the list of source-files
3023 for i in \[$]* ; do
3024 case \$i in #(vi
3025 *.orig|*.rej) ;; #(vi
3026 *.[[0-9]]*)
3027         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
3028         if test \$verb = installing ; then
3029         if test ! -d \$cf_subdir\${section} ; then
3030                 \$MKDIRS \$cf_subdir\$section
3031         fi
3032         fi
3033
3034         # replace variables in man page
3035         if test ! -f $cf_man_alias ; then
3036 cat >>$cf_man_alias <<-CF_EOF2
3037                 s,@DATADIR@,\$datadir,g
3038                 s,@TERMINFO@,\$TERMINFO,g
3039                 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
3040                 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
3041                 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
3042                 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
3043 CF_EOF
3044         ifelse($1,,,[
3045         for cf_name in $1
3046         do
3047                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3048                 cf_name=`echo $cf_name|sed "$program_transform_name"`
3049 cat >>$cf_edit_man <<-CF_EOF
3050                 s,@$cf_NAME@,$cf_name,
3051 CF_EOF
3052         done
3053         ])
3054 cat >>$cf_edit_man <<CF_EOF
3055 CF_EOF2
3056                 echo "...made $cf_man_alias"
3057         fi
3058
3059         aliases=
3060         cf_source=\`basename \$i\`
3061         inalias=\$cf_source
3062         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
3063         if test ! -f \$inalias ; then
3064                 echo .. skipped \$cf_source
3065                 continue
3066         fi
3067 CF_EOF
3068
3069 if test "$MANPAGE_ALIASES" != no ; then
3070 cat >>$cf_edit_man <<CF_EOF
3071         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
3072 CF_EOF
3073 fi
3074
3075 if test "$MANPAGE_RENAMES" = no ; then
3076 cat >>$cf_edit_man <<CF_EOF
3077         # perform program transformations for section 1 man pages
3078         if test \$section = 1 ; then
3079                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
3080         else
3081                 cf_target=\$cf_subdir\${section}/\$cf_source
3082         fi
3083 CF_EOF
3084 else
3085 cat >>$cf_edit_man <<CF_EOF
3086         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
3087         if test -z "\$cf_target" ; then
3088                 echo '? missing rename for '\$cf_source
3089                 cf_target="\$cf_source"
3090         fi
3091         cf_target="\$cf_subdir\${section}/\${cf_target}"
3092
3093 CF_EOF
3094 fi
3095
3096 cat >>$cf_edit_man <<CF_EOF
3097         sed     -f $cf_man_alias \\
3098 CF_EOF
3099
3100 if test -f $MANPAGE_RENAMES ; then
3101 cat >>$cf_edit_man <<CF_EOF
3102                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
3103 CF_EOF
3104 else
3105 cat >>$cf_edit_man <<CF_EOF
3106                 < \$i >\$TMP
3107 CF_EOF
3108 fi
3109
3110 cat >>$cf_edit_man <<CF_EOF
3111 if test \$cf_tables = yes ; then
3112         tbl \$TMP >\$TMP.out
3113         mv \$TMP.out \$TMP
3114 fi
3115 CF_EOF
3116
3117 if test $with_curses_h != yes ; then
3118 cat >>$cf_edit_man <<CF_EOF
3119         sed -e "/\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
3120         mv \$TMP.out \$TMP
3121 CF_EOF
3122 fi
3123
3124 cat >>$cf_edit_man <<CF_EOF
3125         if test \$form = format ; then
3126                 nroff -man \$TMP >\$TMP.out
3127                 mv \$TMP.out \$TMP
3128         fi
3129 CF_EOF
3130
3131 if test -n "$cf_compress" ; then
3132 cat >>$cf_edit_man <<CF_EOF
3133         if test \$verb = installing ; then
3134         if ( $cf_compress -f \$TMP )
3135         then
3136                 mv \$TMP.$cf_so_strip \$TMP
3137         fi
3138         fi
3139         cf_target="\$cf_target.$cf_so_strip"
3140 CF_EOF
3141 fi
3142
3143 case "$MANPAGE_FORMAT" in #(vi
3144 *BSDI*)
3145 cat >>$cf_edit_man <<CF_EOF
3146         if test \$form = format ; then
3147                 # BSDI installs only .0 suffixes in the cat directories
3148                 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
3149         fi
3150 CF_EOF
3151   ;;
3152 esac
3153
3154 cat >>$cf_edit_man <<CF_EOF
3155         suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
3156         if test \$verb = installing ; then
3157                 echo \$verb \$cf_target
3158                 \$INSTALL_DATA \$TMP \$cf_target
3159                 test -d \$cf_subdir\${section} &&
3160                 test -n "\$aliases" && (
3161                         cd \$cf_subdir\${section} && (
3162                                 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
3163                                 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
3164                                 cf_target=\`basename \$cf_target\`
3165                                 for cf_alias in \$aliases
3166                                 do
3167                                         if test \$section = 1 ; then
3168                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3169                                         fi
3170
3171                                         if test "$MANPAGE_SYMLINKS" = yes ; then
3172                                                 if test -f \$cf_alias\${suffix} ; then
3173                                                         if ( cmp -s \$cf_target \$cf_alias\${suffix} )
3174                                                         then
3175                                                                 continue
3176                                                         fi
3177                                                 fi
3178                                                 echo .. \$verb alias \$cf_alias\${suffix}
3179                                                 rm -f \$cf_alias\${suffix}
3180                                                 $LN_S \$cf_target \$cf_alias\${suffix}
3181                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
3182                                                 echo ".so \$cf_source" >\$TMP
3183 CF_EOF
3184 if test -n "$cf_compress" ; then
3185 cat >>$cf_edit_man <<CF_EOF
3186                                                 if test -n "$cf_so_strip" ; then
3187                                                         $cf_compress -f \$TMP
3188                                                         mv \$TMP.$cf_so_strip \$TMP
3189                                                 fi
3190 CF_EOF
3191 fi
3192 cat >>$cf_edit_man <<CF_EOF
3193                                                 echo .. \$verb alias \$cf_alias\${suffix}
3194                                                 rm -f \$cf_alias\${suffix}
3195                                                 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
3196                                         fi
3197                                 done
3198                         )
3199                 )
3200         elif test \$verb = removing ; then
3201                 test -f \$cf_target && (
3202                         echo \$verb \$cf_target
3203                         rm -f \$cf_target
3204                 )
3205                 test -d \$cf_subdir\${section} &&
3206                 test -n "\$aliases" && (
3207                         cd \$cf_subdir\${section} && (
3208                                 for cf_alias in \$aliases
3209                                 do
3210                                         if test \$section = 1 ; then
3211                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3212                                         fi
3213
3214                                         echo .. \$verb alias \$cf_alias\${suffix}
3215                                         rm -f \$cf_alias\${suffix}
3216                                 done
3217                         )
3218                 )
3219         else
3220 #               echo ".hy 0"
3221                 cat \$TMP
3222         fi
3223         ;;
3224 esac
3225 done
3226
3227 if test $cf_inboth = yes ; then
3228 if test \$form != format ; then
3229         sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3230 fi
3231 fi
3232
3233 exit 0
3234 CF_EOF
3235 chmod 755 $cf_edit_man
3236
3237 ])dnl
3238 dnl ---------------------------------------------------------------------------
3239 dnl CF_MATH_LIB version: 5 updated: 2000/05/28 01:39:10
3240 dnl -----------
3241 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
3242 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
3243 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
3244 AC_DEFUN([CF_MATH_LIB],
3245 [
3246 AC_CACHE_CHECK(if -lm needed for math functions,
3247         cf_cv_need_libm,[
3248         AC_TRY_LINK([
3249         #include <stdio.h>
3250         #include <math.h>
3251         ],
3252         [double x = rand(); printf("result = %g\n", ]ifelse($2,,sin(x),$2)[)],
3253         [cf_cv_need_libm=no],
3254         [cf_cv_need_libm=yes])])
3255 if test "$cf_cv_need_libm" = yes
3256 then
3257 ifelse($1,,[
3258         LIBS="$LIBS -lm"
3259 ],[$1=-lm])
3260 fi
3261 ])
3262 dnl ---------------------------------------------------------------------------
3263 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
3264 dnl ----------------------
3265 dnl Check if the file-system supports mixed-case filenames.  If we're able to
3266 dnl create a lowercase name and see it as uppercase, it doesn't support that.
3267 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
3268 [
3269 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
3270 if test "$cross_compiling" = yes ; then
3271         case $target_alias in #(vi
3272         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
3273                 cf_cv_mixedcase=no
3274                 ;;
3275         *)
3276                 cf_cv_mixedcase=yes
3277                 ;;
3278         esac
3279 else
3280         rm -f conftest CONFTEST
3281         echo test >conftest
3282         if test -f CONFTEST ; then
3283                 cf_cv_mixedcase=no
3284         else
3285                 cf_cv_mixedcase=yes
3286         fi
3287         rm -f conftest CONFTEST
3288 fi
3289 ])
3290 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
3291 ])dnl
3292 dnl ---------------------------------------------------------------------------
3293 dnl CF_MKSTEMP version: 5 updated: 2006/12/16 12:33:30
3294 dnl ----------
3295 dnl Check for a working mkstemp.  This creates two files, checks that they are
3296 dnl successfully created and distinct (AmigaOS apparently fails on the last).
3297 AC_DEFUN([CF_MKSTEMP],[
3298 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
3299 rm -f conftest*
3300 AC_TRY_RUN([
3301 #include <sys/types.h>
3302 #include <stdlib.h>
3303 #include <stdio.h>
3304 #include <string.h>
3305 #include <sys/stat.h>
3306 int main()
3307 {
3308         char *tmpl = "conftestXXXXXX";
3309         char name[2][80];
3310         int n;
3311         int result = 0;
3312         int fd;
3313         struct stat sb;
3314
3315         umask(077);
3316         for (n = 0; n < 2; ++n) {
3317                 strcpy(name[n], tmpl);
3318                 if ((fd = mkstemp(name[n])) >= 0) {
3319                         if (!strcmp(name[n], tmpl)
3320                          || stat(name[n], &sb) != 0
3321                          || (sb.st_mode & S_IFMT) != S_IFREG
3322                          || (sb.st_mode & 077) != 0) {
3323                                 result = 1;
3324                         }
3325                         close(fd);
3326                 }
3327         }
3328         if (result == 0
3329          && !strcmp(name[0], name[1]))
3330                 result = 1;
3331         ${cf_cv_main_return:-return}(result);
3332 }
3333 ],[cf_cv_func_mkstemp=yes
3334 ],[cf_cv_func_mkstemp=no
3335 ],[AC_CHECK_FUNC(mkstemp)
3336 ])
3337 ])
3338 if test "$cf_cv_func_mkstemp" = yes ; then
3339         AC_DEFINE(HAVE_MKSTEMP)
3340 fi
3341 ])dnl
3342 dnl ---------------------------------------------------------------------------
3343 dnl CF_MSG_LOG version: 4 updated: 2007/07/29 09:55:12
3344 dnl ----------
3345 dnl Write a debug message to config.log, along with the line number in the
3346 dnl configure script.
3347 AC_DEFUN([CF_MSG_LOG],[
3348 echo "${as_me-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
3349 ])dnl
3350 dnl ---------------------------------------------------------------------------
3351 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
3352 dnl ----------------
3353 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
3354 dnl warn about this.
3355 AC_DEFUN([CF_NCURSES_ABI_6],[
3356 if test "${with_abi_version+set}" != set; then
3357         case $cf_cv_rel_version in
3358         5.*)
3359                 cf_cv_rel_version=6.0
3360                 cf_cv_abi_version=6
3361                 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
3362                 ;;
3363         esac
3364 fi
3365 ])dnl
3366 dnl ---------------------------------------------------------------------------
3367 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
3368 dnl ------------------
3369 dnl see CF_WITH_NO_LEAKS
3370 AC_DEFUN([CF_NO_LEAKS_OPTION],[
3371 AC_MSG_CHECKING(if you want to use $1 for testing)
3372 AC_ARG_WITH($1,
3373         [$2],
3374         [AC_DEFINE($3)ifelse([$4],,[
3375          $4
3376 ])
3377         : ${with_cflags:=-g}
3378         : ${with_no_leaks:=yes}
3379          with_$1=yes],
3380         [with_$1=])
3381 AC_MSG_RESULT(${with_$1:-no})
3382
3383 case .$with_cflags in #(vi
3384 .*-g*)
3385         case .$CFLAGS in #(vi
3386         .*-g*) #(vi
3387                 ;;
3388         *)
3389                 CF_ADD_CFLAGS([-g])
3390                 ;;
3391         esac
3392         ;;
3393 esac
3394 ])dnl
3395 dnl ---------------------------------------------------------------------------
3396 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
3397 dnl ----------------
3398 dnl Check if the given variable is a number.  If not, report an error.
3399 dnl $1 is the variable
3400 dnl $2 is the message
3401 AC_DEFUN([CF_NUMBER_SYNTAX],[
3402 if test -n "$1" ; then
3403   case $1 in #(vi
3404   [[0-9]]*) #(vi
3405         ;;
3406   *)
3407         AC_MSG_ERROR($2 is not a number: $1)
3408         ;;
3409   esac
3410 else
3411   AC_MSG_ERROR($2 value is empty)
3412 fi
3413 ])dnl
3414 dnl ---------------------------------------------------------------------------
3415 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
3416 dnl -------------
3417 dnl Compute the object-directory name from the given model name
3418 AC_DEFUN([CF_OBJ_SUBDIR],
3419 [
3420         case $1 in
3421         libtool) $2='obj_lo'  ;;
3422         normal)  $2='objects' ;;
3423         debug)   $2='obj_g' ;;
3424         profile) $2='obj_p' ;;
3425         shared)
3426                 case $cf_cv_system_name in #(vi
3427                 cygwin) #(vi
3428                         $2='objects' ;;
3429                 *)
3430                         $2='obj_s' ;;
3431                 esac
3432         esac
3433 ])dnl
3434 dnl ---------------------------------------------------------------------------
3435 dnl CF_PATHSEP version: 3 updated: 2001/01/12 01:23:53
3436 dnl ----------
3437 dnl Provide a value for the $PATH and similar separator
3438 AC_DEFUN([CF_PATHSEP],
3439 [
3440         case $cf_cv_system_name in
3441         os2*)   PATHSEP=';'  ;;
3442         *)      PATHSEP=':'  ;;
3443         esac
3444 ifelse($1,,,[$1=$PATHSEP])
3445         AC_SUBST(PATHSEP)
3446 ])dnl
3447 dnl ---------------------------------------------------------------------------
3448 dnl CF_PATH_SYNTAX version: 11 updated: 2006/09/02 08:55:46
3449 dnl --------------
3450 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
3451 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3452 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
3453 dnl delayed evaluation of those symbols.
3454 AC_DEFUN([CF_PATH_SYNTAX],[
3455 if test "x$prefix" != xNONE; then
3456   cf_path_syntax="$prefix"
3457 else
3458   cf_path_syntax="$ac_default_prefix"
3459 fi
3460
3461 case ".[$]$1" in #(vi
3462 .\[$]\(*\)*|.\'*\'*) #(vi
3463   ;;
3464 ..|./*|.\\*) #(vi
3465   ;;
3466 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
3467   ;;
3468 .\[$]{*prefix}*) #(vi
3469   eval $1="[$]$1"
3470   case ".[$]$1" in #(vi
3471   .NONE/*)
3472     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3473     ;;
3474   esac
3475   ;; #(vi
3476 .no|.NONE/*)
3477   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3478   ;;
3479 *)
3480   ifelse($2,,[AC_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3481   ;;
3482 esac
3483 ])dnl
3484 dnl ---------------------------------------------------------------------------
3485 dnl CF_POSIX_C_SOURCE version: 6 updated: 2005/07/14 20:25:10
3486 dnl -----------------
3487 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3488 dnl
3489 dnl     POSIX.1-1990                            _POSIX_SOURCE
3490 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
3491 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
3492 dnl             Bindings Option
3493 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
3494 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
3495 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
3496 dnl
3497 dnl Parameters:
3498 dnl     $1 is the nominal value for _POSIX_C_SOURCE
3499 AC_DEFUN([CF_POSIX_C_SOURCE],
3500 [
3501 cf_POSIX_C_SOURCE=ifelse($1,,199506L,$1)
3502
3503 cf_save_CFLAGS="$CFLAGS"
3504 cf_save_CPPFLAGS="$CPPFLAGS"
3505
3506 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3507 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3508
3509 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3510         CF_MSG_LOG(if the symbol is already defined go no further)
3511         AC_TRY_COMPILE([#include <sys/types.h>],[
3512 #ifndef _POSIX_C_SOURCE
3513 make an error
3514 #endif],
3515         [cf_cv_posix_c_source=no],
3516         [cf_want_posix_source=no
3517          case .$cf_POSIX_C_SOURCE in #(vi
3518          .[[12]]??*) #(vi
3519                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3520                 ;;
3521          .2) #(vi
3522                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3523                 cf_want_posix_source=yes
3524                 ;;
3525          .*)
3526                 cf_want_posix_source=yes
3527                 ;;
3528          esac
3529          if test "$cf_want_posix_source" = yes ; then
3530                 AC_TRY_COMPILE([#include <sys/types.h>],[
3531 #ifdef _POSIX_SOURCE
3532 make an error
3533 #endif],[],
3534                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3535          fi
3536          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3537          CFLAGS="$cf_trim_CFLAGS"
3538          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
3539          CF_MSG_LOG(if the second compile does not leave our definition intact error)
3540          AC_TRY_COMPILE([#include <sys/types.h>],[
3541 #ifndef _POSIX_C_SOURCE
3542 make an error
3543 #endif],,
3544          [cf_cv_posix_c_source=no])
3545          CFLAGS="$cf_save_CFLAGS"
3546          CPPFLAGS="$cf_save_CPPFLAGS"
3547         ])
3548 ])
3549
3550 if test "$cf_cv_posix_c_source" != no ; then
3551         CFLAGS="$cf_trim_CFLAGS"
3552         CPPFLAGS="$cf_trim_CPPFLAGS"
3553         if test "$cf_cv_cc_u_d_options" = yes ; then
3554                 cf_temp_posix_c_source=`echo "$cf_cv_posix_c_source" | \
3555                                 sed -e 's/-D/-U/g' -e 's/=[[^   ]]*//g'`
3556                 CPPFLAGS="$CPPFLAGS $cf_temp_posix_c_source"
3557         fi
3558         CPPFLAGS="$CPPFLAGS $cf_cv_posix_c_source"
3559 fi
3560
3561 ])dnl
3562 dnl ---------------------------------------------------------------------------
3563 dnl CF_PREDEFINE version: 1 updated: 2003/07/26 17:53:56
3564 dnl ------------
3565 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
3566 dnl
3567 dnl $1 = symbol to test
3568 dnl $2 = value (if any) to use for a predefinition
3569 AC_DEFUN([CF_PREDEFINE],
3570 [
3571 AC_MSG_CHECKING(if we must define $1)
3572 AC_TRY_COMPILE([#include <sys/types.h>
3573 ],[
3574 #ifndef $1
3575 make an error
3576 #endif],[cf_result=no],[cf_result=yes])
3577 AC_MSG_RESULT($cf_result)
3578
3579 if test "$cf_result" = yes ; then
3580         CPPFLAGS="$CPPFLAGS ifelse($2,,-D$1,[-D$1=$2])"
3581 elif test "x$2" != "x" ; then
3582         AC_MSG_CHECKING(checking for compatible value versus $2)
3583         AC_TRY_COMPILE([#include <sys/types.h>
3584 ],[
3585 #if $1-$2 < 0
3586 make an error
3587 #endif],[cf_result=yes],[cf_result=no])
3588         AC_MSG_RESULT($cf_result)
3589         if test "$cf_result" = no ; then
3590                 # perhaps we can override it - try...
3591                 CPPFLAGS="$CPPFLAGS -D$1=$2"
3592         fi
3593 fi
3594 ])dnl
3595 dnl ---------------------------------------------------------------------------
3596 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
3597 dnl ------------
3598 dnl Append definitions and rules for the given programs to the subdirectory
3599 dnl Makefiles, and the recursion rule for the top-level Makefile.
3600 dnl
3601 dnl parameters
3602 dnl     $1 = script to run
3603 dnl     $2 = list of subdirectories
3604 dnl
3605 dnl variables
3606 dnl     $AWK
3607 AC_DEFUN([CF_PRG_RULES],
3608 [
3609 for cf_dir in $2
3610 do
3611         if test ! -d $srcdir/$cf_dir; then
3612                 continue
3613         elif test -f $srcdir/$cf_dir/programs; then
3614                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
3615         fi
3616 done
3617
3618 ])dnl
3619 dnl ---------------------------------------------------------------------------
3620 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3621 dnl -----------
3622 dnl Check for awk, ensure that the check found something.
3623 AC_DEFUN([CF_PROG_AWK],
3624 [
3625 AC_PROG_AWK
3626 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3627 ])dnl
3628 dnl ---------------------------------------------------------------------------
3629 dnl CF_PROG_CC_C_O version: 2 updated: 2006/12/16 15:55:46
3630 dnl --------------
3631 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3632 dnl the output file can be renamed, and allows for a shell variable that can
3633 dnl be used later.  The parameter is either CC or CXX.  The result is the
3634 dnl cache variable:
3635 dnl     $cf_cv_prog_CC_c_o
3636 dnl     $cf_cv_prog_CXX_c_o
3637 AC_DEFUN([CF_PROG_CC_C_O],
3638 [AC_REQUIRE([AC_PROG_CC])dnl
3639 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3640 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3641 [
3642 cat > conftest.$ac_ext <<CF_EOF
3643 #include <stdio.h>
3644 int main()
3645 {
3646         ${cf_cv_main_return:-return}(0);
3647 }
3648 CF_EOF
3649 # We do the test twice because some compilers refuse to overwrite an
3650 # existing .o file with -o, though they will create one.
3651 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3652 if AC_TRY_EVAL(ac_try) &&
3653   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3654 then
3655   eval cf_cv_prog_$1_c_o=yes
3656 else
3657   eval cf_cv_prog_$1_c_o=no
3658 fi
3659 rm -f conftest*
3660 ])dnl
3661 if test $cf_cv_prog_$1_c_o = yes; then
3662   AC_MSG_RESULT([yes])
3663 else
3664   AC_MSG_RESULT([no])
3665 fi
3666 ])dnl
3667 dnl ---------------------------------------------------------------------------
3668 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
3669 dnl --------------
3670 dnl Check if C (preprocessor) -U and -D options are processed in the order
3671 dnl given rather than by type of option.  Some compilers insist on apply all
3672 dnl of the -U options after all of the -D options.  Others allow mixing them,
3673 dnl and may predefine symbols that conflict with those we define.
3674 AC_DEFUN([CF_PROG_CC_U_D],
3675 [
3676 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
3677         cf_save_CPPFLAGS="$CPPFLAGS"
3678         CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
3679         AC_TRY_COMPILE([],[
3680 #ifndef U_D_OPTIONS
3681 make an undefined-error
3682 #endif
3683 #ifdef  D_U_OPTIONS
3684 make a defined-error
3685 #endif
3686         ],[
3687         cf_cv_cc_u_d_options=yes],[
3688         cf_cv_cc_u_d_options=no])
3689         CPPFLAGS="$cf_save_CPPFLAGS"
3690 ])
3691 ])dnl
3692 dnl ---------------------------------------------------------------------------
3693 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
3694 dnl -------------
3695 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3696 dnl This macro adds a check to ensure the script found something.
3697 AC_DEFUN([CF_PROG_EGREP],
3698 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3699    [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3700     then ac_cv_prog_egrep='grep -E'
3701     else ac_cv_prog_egrep='egrep'
3702     fi])
3703  EGREP=$ac_cv_prog_egrep
3704  AC_SUBST([EGREP])
3705 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3706 ])dnl
3707 dnl ---------------------------------------------------------------------------
3708 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
3709 dnl -----------
3710 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3711 AC_DEFUN([CF_PROG_EXT],
3712 [
3713 AC_REQUIRE([CF_CHECK_CACHE])
3714 case $cf_cv_system_name in
3715 os2*)
3716     CFLAGS="$CFLAGS -Zmt"
3717     CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
3718     CXXFLAGS="$CXXFLAGS -Zmt"
3719     # autoconf's macro sets -Zexe and suffix both, which conflict:w
3720     LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
3721     ac_cv_exeext=.exe
3722     ;;
3723 esac
3724
3725 AC_EXEEXT
3726 AC_OBJEXT
3727
3728 PROG_EXT="$EXEEXT"
3729 AC_SUBST(PROG_EXT)
3730 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
3731 ])dnl
3732 dnl ---------------------------------------------------------------------------
3733 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
3734 dnl ---------------
3735 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
3736 dnl misc/tabset install won't work properly.  Usually this happens only when
3737 dnl using the fallback mkinstalldirs script
3738 AC_DEFUN([CF_PROG_INSTALL],
3739 [AC_PROG_INSTALL
3740 case $INSTALL in
3741 /*)
3742   ;;
3743 *)
3744   CF_DIRNAME(cf_dir,$INSTALL)
3745   test -z "$cf_dir" && cf_dir=.
3746   INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
3747   ;;
3748 esac
3749 ])dnl
3750 dnl ---------------------------------------------------------------------------
3751 dnl CF_PROG_LDCONFIG version: 1 updated: 2003/09/20 17:07:55
3752 dnl ----------------
3753 dnl Check for ldconfig, needed to fixup shared libraries that would be built
3754 dnl and then used in the install.
3755 AC_DEFUN([CF_PROG_LDCONFIG],[
3756 if test "$cross_compiling" = yes ; then
3757   LDCONFIG=:
3758 else
3759 case "$cf_cv_system_name" in #(vi
3760 freebsd*) #(vi
3761   test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
3762   ;;
3763 *) LDPATH=$PATH:/sbin:/usr/sbin
3764   AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
3765   ;;
3766 esac
3767 fi
3768 AC_SUBST(LDCONFIG)
3769 ])dnl
3770 dnl ---------------------------------------------------------------------------
3771 dnl CF_PROG_LINT version: 1 updated: 2006/09/16 11:40:59
3772 dnl ------------
3773 AC_DEFUN([CF_PROG_LINT],
3774 [
3775 AC_CHECK_PROGS(LINT, tdlint lint alint)
3776 AC_SUBST(LINT_OPTS)
3777 ])dnl
3778 dnl ---------------------------------------------------------------------------
3779 dnl CF_REGEX version: 3 updated: 1997/11/01 14:26:01
3780 dnl --------
3781 dnl Attempt to determine if we've got one of the flavors of regular-expression
3782 dnl code that we can support.
3783 AC_DEFUN([CF_REGEX],
3784 [
3785 AC_MSG_CHECKING([for regular-expression headers])
3786 AC_CACHE_VAL(cf_cv_regex,[
3787 AC_TRY_LINK([#include <sys/types.h>
3788 #include <regex.h>],[
3789         regex_t *p;
3790         int x = regcomp(p, "", 0);
3791         int y = regexec(p, "", 0, 0, 0);
3792         regfree(p);
3793         ],[cf_cv_regex="regex.h"],[
3794         AC_TRY_LINK([#include <regexp.h>],[
3795                 char *p = compile("", "", "", 0);
3796                 int x = step("", "");
3797         ],[cf_cv_regex="regexp.h"],[
3798                 cf_save_LIBS="$LIBS"
3799                 LIBS="-lgen $LIBS"
3800                 AC_TRY_LINK([#include <regexpr.h>],[
3801                         char *p = compile("", "", "");
3802                         int x = step("", "");
3803                 ],[cf_cv_regex="regexpr.h"],[LIBS="$cf_save_LIBS"])])])
3804 ])
3805 AC_MSG_RESULT($cf_cv_regex)
3806 case $cf_cv_regex&nb