ncurses 5.6 - patch 20080804
[ncurses.git] / aclocal.m4
1 dnl***************************************************************************
2 dnl Copyright (c) 1998-2007,2008 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.451 2008/08/04 10:26:11 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: 9 updated: 2008/02/09 13:15:34
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                   CF_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: 6 updated: 2008/02/09 13:15:34
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         CF_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: 4 updated: 2008/03/23 14:48:54
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_MSG_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: 11 updated: 2008/03/23 14:45:59
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_MSG_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_OPENPTY version: 2 updated: 2008/04/12 19:49:01
1062 dnl ---------------
1063 dnl Check for openpty() function, along with <pty.h> header.  It may need the
1064 dnl "util" library as well.
1065 AC_DEFUN([CF_FUNC_OPENPTY],
1066 [
1067 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1068 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1069     cf_save_LIBS="$LIBS"
1070     test $cf_cv_lib_util = yes && LIBS="-lutil $LIBS"
1071     for cf_header in pty.h libutil.h util.h
1072     do
1073     AC_TRY_LINK([
1074 #include <$cf_header>
1075 ],[
1076     int x = openpty((int *)0, (int *)0, (char *)0,
1077                    (struct termios *)0, (struct winsize *)0);
1078 ],[
1079         cf_cv_func_openpty=$cf_header
1080         break
1081 ],[
1082         cf_cv_func_openpty=no
1083 ])
1084     done
1085     LIBS="$cf_save_LIBS"
1086 ])
1087 ])dnl
1088 dnl ---------------------------------------------------------------------------
1089 dnl CF_FUNC_POLL version: 4 updated: 2006/12/16 12:33:30
1090 dnl ------------
1091 dnl See if the poll function really works.  Some platforms have poll(), but
1092 dnl it does not work for terminals or files.
1093 AC_DEFUN([CF_FUNC_POLL],[
1094 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1095 AC_TRY_RUN([
1096 #include <stdio.h>
1097 #ifdef HAVE_POLL_H
1098 #include <poll.h>
1099 #else
1100 #include <sys/poll.h>
1101 #endif
1102 int main() {
1103         struct pollfd myfds;
1104         int ret;
1105
1106         myfds.fd = 0;
1107         myfds.events = POLLIN;
1108
1109         ret = poll(&myfds, 1, 100);
1110         ${cf_cv_main_return:-return}(ret != 0);
1111 }],
1112         [cf_cv_working_poll=yes],
1113         [cf_cv_working_poll=no],
1114         [cf_cv_working_poll=unknown])])
1115 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
1116 ])dnl
1117 dnl ---------------------------------------------------------------------------
1118 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
1119 dnl ---------------
1120 dnl Some old/broken variations define tcgetattr() only as a macro in
1121 dnl termio(s).h
1122 AC_DEFUN([CF_FUNC_TERMIOS],[
1123 AC_REQUIRE([CF_STRUCT_TERMIOS])
1124 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1125 AC_TRY_LINK([
1126 #include <sys/types.h>
1127 #ifdef HAVE_UNISTD_H
1128 #include <unistd.h>
1129 #endif
1130 #ifdef HAVE_TERMIOS_H
1131 #include <termios.h>
1132 #define TTY struct termios
1133 #else
1134 #ifdef HAVE_TERMIO_H
1135 #include <termio.h>
1136 #define TTY struct termio
1137 #endif
1138 #endif
1139 ],[
1140 TTY foo;
1141 tcgetattr(1, &foo);],
1142 [cf_cv_have_tcgetattr=yes],
1143 [cf_cv_have_tcgetattr=no])])
1144 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
1145 ])dnl
1146 dnl ---------------------------------------------------------------------------
1147 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
1148 dnl ---------------
1149 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1150 dnl versions of C.  It is in the GNU C library, and can often be simulated by
1151 dnl other functions.
1152 AC_DEFUN([CF_FUNC_VSSCANF],
1153 [
1154 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1155 AC_TRY_LINK([
1156 #include <stdarg.h>
1157 #include <stdio.h>],[
1158         va_list ap;
1159         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1160 AC_TRY_LINK([
1161 #include <stdarg.h>
1162 #include <stdio.h>],[
1163     FILE strbuf;
1164     char *str = "from";
1165
1166     strbuf._flag = _IOREAD;
1167     strbuf._ptr = strbuf._base = (unsigned char *) str;
1168     strbuf._cnt = strlen(str);
1169     strbuf._file = _NFILE;
1170     return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1171 AC_TRY_LINK([
1172 #include <stdarg.h>
1173 #include <stdio.h>],[
1174     FILE strbuf;
1175     char *str = "from";
1176
1177     strbuf._flag = _IOREAD;
1178     strbuf._ptr = strbuf._base = (unsigned char *) str;
1179     strbuf._cnt = strlen(str);
1180     strbuf._file = _NFILE;
1181     return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1182 cf_cv_func_vsscanf=no])])])])
1183
1184 case $cf_cv_func_vsscanf in #(vi
1185 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
1186 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
1187 _doscan) AC_DEFINE(HAVE__DOSCAN);;
1188 esac
1189
1190 ])dnl
1191 dnl ---------------------------------------------------------------------------
1192 dnl CF_GCC_ATTRIBUTES version: 11 updated: 2007/07/29 09:55:12
1193 dnl -----------------
1194 dnl Test for availability of useful gcc __attribute__ directives to quiet
1195 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1196 dnl to documentation, unrecognized directives cause older compilers to barf.
1197 AC_DEFUN([CF_GCC_ATTRIBUTES],
1198 [
1199 if test "$GCC" = yes
1200 then
1201 cat > conftest.i <<EOF
1202 #ifndef GCC_PRINTF
1203 #define GCC_PRINTF 0
1204 #endif
1205 #ifndef GCC_SCANF
1206 #define GCC_SCANF 0
1207 #endif
1208 #ifndef GCC_NORETURN
1209 #define GCC_NORETURN /* nothing */
1210 #endif
1211 #ifndef GCC_UNUSED
1212 #define GCC_UNUSED /* nothing */
1213 #endif
1214 EOF
1215 if test "$GCC" = yes
1216 then
1217         AC_CHECKING([for $CC __attribute__ directives])
1218 cat > conftest.$ac_ext <<EOF
1219 #line __oline__ "${as_me-configure}"
1220 #include "confdefs.h"
1221 #include "conftest.h"
1222 #include "conftest.i"
1223 #if     GCC_PRINTF
1224 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1225 #else
1226 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1227 #endif
1228 #if     GCC_SCANF
1229 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1230 #else
1231 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1232 #endif
1233 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1234 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1235 extern void foo(void) GCC_NORETURN;
1236 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1237 EOF
1238         for cf_attribute in scanf printf unused noreturn
1239         do
1240                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1241                 cf_directive="__attribute__(($cf_attribute))"
1242                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1243                 case $cf_attribute in
1244                 scanf|printf)
1245                 cat >conftest.h <<EOF
1246 #define GCC_$cf_ATTRIBUTE 1
1247 EOF
1248                         ;;
1249                 *)
1250                 cat >conftest.h <<EOF
1251 #define GCC_$cf_ATTRIBUTE $cf_directive
1252 EOF
1253                         ;;
1254                 esac
1255                 if AC_TRY_EVAL(ac_compile); then
1256                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1257                         cat conftest.h >>confdefs.h
1258                 fi
1259         done
1260 else
1261         fgrep define conftest.i >>confdefs.h
1262 fi
1263 rm -rf conftest*
1264 fi
1265 ])dnl
1266 dnl ---------------------------------------------------------------------------
1267 dnl CF_GCC_VERSION version: 4 updated: 2005/08/27 09:53:42
1268 dnl --------------
1269 dnl Find version of gcc
1270 AC_DEFUN([CF_GCC_VERSION],[
1271 AC_REQUIRE([AC_PROG_CC])
1272 GCC_VERSION=none
1273 if test "$GCC" = yes ; then
1274         AC_MSG_CHECKING(version of $CC)
1275         GCC_VERSION="`${CC} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1276         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1277         AC_MSG_RESULT($GCC_VERSION)
1278 fi
1279 ])dnl
1280 dnl ---------------------------------------------------------------------------
1281 dnl CF_GCC_WARNINGS version: 23 updated: 2008/07/26 17:54:02
1282 dnl ---------------
1283 dnl Check if the compiler supports useful warning options.  There's a few that
1284 dnl we don't use, simply because they're too noisy:
1285 dnl
1286 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1287 dnl     -Wredundant-decls (system headers make this too noisy)
1288 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1289 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1290 dnl             is enabled for ncurses using "--enable-const".
1291 dnl     -pedantic
1292 dnl
1293 dnl Parameter:
1294 dnl     $1 is an optional list of gcc warning flags that a particular
1295 dnl             application might want to use, e.g., "no-unused" for
1296 dnl             -Wno-unused
1297 dnl Special:
1298 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1299 dnl
1300 AC_DEFUN([CF_GCC_WARNINGS],
1301 [
1302 AC_REQUIRE([CF_GCC_VERSION])
1303 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1304
1305 cat > conftest.$ac_ext <<EOF
1306 #line __oline__ "${as_me-configure}"
1307 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1308 EOF
1309
1310 if test "$INTEL_COMPILER" = yes
1311 then
1312 # The "-wdXXX" options suppress warnings:
1313 # remark #1419: external declaration in primary source file
1314 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1315 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1316 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1317 # remark #193: zero used for undefined preprocessing identifier
1318 # remark #593: variable "curs_sb_left_arrow" was set but never used
1319 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1320 # remark #869: parameter "tw" was never referenced
1321 # remark #981: operands are evaluated in unspecified order
1322 # warning #269: invalid format string conversion
1323
1324         AC_CHECKING([for $CC warning options])
1325         cf_save_CFLAGS="$CFLAGS"
1326         EXTRA_CFLAGS="-Wall"
1327         for cf_opt in \
1328                 wd1419 \
1329                 wd1682 \
1330                 wd1683 \
1331                 wd1684 \
1332                 wd193 \
1333                 wd279 \
1334                 wd593 \
1335                 wd810 \
1336                 wd869 \
1337                 wd981
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                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1343                 fi
1344         done
1345         CFLAGS="$cf_save_CFLAGS"
1346
1347 elif test "$GCC" = yes
1348 then
1349         AC_CHECKING([for $CC warning options])
1350         cf_save_CFLAGS="$CFLAGS"
1351         EXTRA_CFLAGS="-W -Wall"
1352         cf_warn_CONST=""
1353         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1354         for cf_opt in \
1355                 Wbad-function-cast \
1356                 Wcast-align \
1357                 Wcast-qual \
1358                 Winline \
1359                 Wmissing-declarations \
1360                 Wmissing-prototypes \
1361                 Wnested-externs \
1362                 Wpointer-arith \
1363                 Wshadow \
1364                 Wstrict-prototypes \
1365                 Wundef $cf_warn_CONST $1
1366         do
1367                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1368                 if AC_TRY_EVAL(ac_compile); then
1369                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1370                         case $cf_opt in #(vi
1371                         Wcast-qual) #(vi
1372                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1373                                 ;;
1374                         Winline) #(vi
1375                                 case $GCC_VERSION in
1376                                 [[34]].*)
1377                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1378                                         continue;;
1379                                 esac
1380                                 ;;
1381                         esac
1382                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1383                 fi
1384         done
1385         CFLAGS="$cf_save_CFLAGS"
1386 fi
1387 rm -f conftest*
1388
1389 AC_SUBST(EXTRA_CFLAGS)
1390 ])dnl
1391 dnl ---------------------------------------------------------------------------
1392 dnl CF_GNAT_TRY_LINK version: 1 updated: 2004/08/21 19:02:08
1393 dnl ----------------
1394 dnl Verify that a test program compiles/links with GNAT.
1395 dnl $cf_ada_make is set to the program that compiles/links
1396 dnl $ADAFLAGS may be set to the GNAT flags.
1397 dnl
1398 dnl $1 is the text of the spec
1399 dnl $2 is the text of the body
1400 dnl $3 is the shell command to execute if successful
1401 dnl $4 is the shell command to execute if not successful
1402 AC_DEFUN([CF_GNAT_TRY_LINK],
1403 [
1404 rm -f conftest*
1405 cat >>conftest.ads <<CF_EOF
1406 $1
1407 CF_EOF
1408 cat >>conftest.adb <<CF_EOF
1409 $2
1410 CF_EOF
1411 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1412 ifelse($3,,      :,[      $3])
1413 ifelse($4,,,[else
1414    $4])
1415 fi
1416 rm -f conftest*
1417 ])dnl
1418 dnl ---------------------------------------------------------------------------
1419 dnl CF_GNAT_TRY_RUN version: 3 updated: 2004/08/21 19:02:08
1420 dnl ---------------
1421 dnl Verify that a test program compiles and runs with GNAT
1422 dnl $cf_ada_make is set to the program that compiles/links
1423 dnl $ADAFLAGS may be set to the GNAT flags.
1424 dnl
1425 dnl $1 is the text of the spec
1426 dnl $2 is the text of the body
1427 dnl $3 is the shell command to execute if successful
1428 dnl $4 is the shell command to execute if not successful
1429 AC_DEFUN([CF_GNAT_TRY_RUN],
1430 [
1431 rm -f conftest*
1432 cat >>conftest.ads <<CF_EOF
1433 $1
1434 CF_EOF
1435 cat >>conftest.adb <<CF_EOF
1436 $2
1437 CF_EOF
1438 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1439    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1440 ifelse($3,,      :,[      $3])
1441 ifelse($4,,,[   else
1442       $4])
1443    fi
1444 ifelse($4,,,[else
1445    $4])
1446 fi
1447 rm -f conftest*
1448 ])dnl
1449 dnl ---------------------------------------------------------------------------
1450 dnl CF_GNAT_VERSION version: 12 updated: 2006/10/14 15:23:15
1451 dnl ---------------
1452 dnl Verify version of GNAT.
1453 AC_DEFUN([CF_GNAT_VERSION],
1454 [
1455 AC_MSG_CHECKING(for gnat version)
1456 cf_gnat_version=`${cf_ada_make-gnatmake} -v 2>&1 | grep '[[0-9]].[[0-9]][[0-9]]*' |\
1457   sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1458 AC_MSG_RESULT($cf_gnat_version)
1459
1460 case $cf_gnat_version in
1461   3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*)
1462     cf_cv_prog_gnat_correct=yes
1463     ;;
1464   *) echo Unsupported GNAT version $cf_gnat_version. Required is 3.11 or better. Disabling Ada95 binding.
1465      cf_cv_prog_gnat_correct=no
1466      ;;
1467 esac
1468 case $cf_gnat_version in
1469   3.[[1-9]]*|[[4-9]].*)
1470       cf_compile_generics=generics
1471       cf_generic_objects="\${GENOBJS}"
1472       ;;
1473   *)  cf_compile_generics=
1474       cf_generic_objects=
1475       ;;
1476 esac
1477 ])
1478 dnl ---------------------------------------------------------------------------
1479 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1480 dnl -------------
1481 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1482 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1483 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1484 dnl since it is interwoven with GNU extensions.
1485 dnl
1486 dnl Well, yes we could work around it...
1487 AC_DEFUN([CF_GNU_SOURCE],
1488 [
1489 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1490 AC_TRY_COMPILE([#include <sys/types.h>],[
1491 #ifndef _XOPEN_SOURCE
1492 make an error
1493 #endif],
1494         [cf_cv_gnu_source=no],
1495         [cf_save="$CPPFLAGS"
1496          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1497          AC_TRY_COMPILE([#include <sys/types.h>],[
1498 #ifdef _XOPEN_SOURCE
1499 make an error
1500 #endif],
1501         [cf_cv_gnu_source=no],
1502         [cf_cv_gnu_source=yes])
1503         CPPFLAGS="$cf_save"
1504         ])
1505 ])
1506 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1507 ])dnl
1508 dnl ---------------------------------------------------------------------------
1509 dnl CF_GPP_LIBRARY version: 8 updated: 2003/02/02 01:41:46
1510 dnl --------------
1511 dnl If we're trying to use g++, test if libg++ is installed (a rather common
1512 dnl problem :-).  If we have the compiler but no library, we'll be able to
1513 dnl configure, but won't be able to build the c++ demo program.
1514 AC_DEFUN([CF_GPP_LIBRARY],
1515 [
1516 cf_cxx_library=unknown
1517 case $cf_cv_system_name in #(vi
1518 os2*) #(vi
1519         cf_gpp_libname=gpp
1520         ;;
1521 *)
1522         cf_gpp_libname=g++
1523         ;;
1524 esac
1525 if test "$GXX" = yes; then
1526         AC_MSG_CHECKING([for lib$cf_gpp_libname])
1527         cf_save="$LIBS"
1528         LIBS="$LIBS -l$cf_gpp_libname"
1529         AC_TRY_LINK([
1530 #include <$cf_gpp_libname/builtin.h>
1531         ],
1532         [two_arg_error_handler_t foo2 = lib_error_handler],
1533         [cf_cxx_library=yes
1534          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1535          if test "$cf_gpp_libname" = cpp ; then
1536             AC_DEFINE(HAVE_GPP_BUILTIN_H)
1537          else
1538             AC_DEFINE(HAVE_GXX_BUILTIN_H)
1539          fi],
1540         [AC_TRY_LINK([
1541 #include <builtin.h>
1542         ],
1543         [two_arg_error_handler_t foo2 = lib_error_handler],
1544         [cf_cxx_library=yes
1545          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1546          AC_DEFINE(HAVE_BUILTIN_H)],
1547         [cf_cxx_library=no])])
1548         LIBS="$cf_save"
1549         AC_MSG_RESULT($cf_cxx_library)
1550 fi
1551 ])dnl
1552 dnl ---------------------------------------------------------------------------
1553 dnl CF_GXX_VERSION version: 5 updated: 2005/08/27 09:53:42
1554 dnl --------------
1555 dnl Check for version of g++
1556 AC_DEFUN([CF_GXX_VERSION],[
1557 AC_REQUIRE([AC_PROG_CPP])
1558 GXX_VERSION=none
1559 if test "$GXX" = yes; then
1560         AC_MSG_CHECKING(version of g++)
1561         GXX_VERSION="`${CXX-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1562         test -z "$GXX_VERSION" && GXX_VERSION=unknown
1563         AC_MSG_RESULT($GXX_VERSION)
1564 fi
1565 ])dnl
1566 dnl ---------------------------------------------------------------------------
1567 dnl CF_GXX_WARNINGS version: 5 updated: 2005/08/13 14:54:38
1568 dnl ---------------
1569 dnl Check if the compiler supports useful warning options.
1570 dnl
1571 dnl Most of gcc's options apply to g++, except:
1572 dnl     -Wbad-function-cast
1573 dnl     -Wmissing-declarations
1574 dnl     -Wnested-externs
1575 dnl
1576 dnl Omit a few (for now):
1577 dnl     -Winline
1578 dnl
1579 dnl Parameter:
1580 dnl     $1 is an optional list of g++ warning flags that a particular
1581 dnl             application might want to use, e.g., "no-unused" for
1582 dnl             -Wno-unused
1583 dnl Special:
1584 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1585 dnl
1586 AC_DEFUN([CF_GXX_WARNINGS],
1587 [
1588
1589 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
1590
1591 AC_REQUIRE([CF_GXX_VERSION])
1592
1593 AC_LANG_SAVE
1594 AC_LANG_CPLUSPLUS
1595
1596 cat > conftest.$ac_ext <<EOF
1597 #line __oline__ "configure"
1598 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1599 EOF
1600
1601 if test "$INTEL_CPLUSPLUS" = yes
1602 then
1603 # The "-wdXXX" options suppress warnings:
1604 # remark #1419: external declaration in primary source file
1605 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1606 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1607 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1608 # remark #193: zero used for undefined preprocessing identifier
1609 # remark #593: variable "curs_sb_left_arrow" was set but never used
1610 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1611 # remark #869: parameter "tw" was never referenced
1612 # remark #981: operands are evaluated in unspecified order
1613 # warning #269: invalid format string conversion
1614
1615         AC_CHECKING([for $CC warning options])
1616         cf_save_CXXFLAGS="$CXXFLAGS"
1617         EXTRA_CXXFLAGS="-Wall"
1618         for cf_opt in \
1619                 wd1419 \
1620                 wd1682 \
1621                 wd1683 \
1622                 wd1684 \
1623                 wd193 \
1624                 wd279 \
1625                 wd593 \
1626                 wd810 \
1627                 wd869 \
1628                 wd981
1629         do
1630                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
1631                 if AC_TRY_EVAL(ac_compile); then
1632                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1633                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1634                 fi
1635         done
1636         CXXFLAGS="$cf_save_CXXFLAGS"
1637
1638 elif test "$GXX" = yes
1639 then
1640         AC_CHECKING([for $CXX warning options])
1641         cf_save_CXXFLAGS="$CXXFLAGS"
1642         EXTRA_CXXFLAGS="-W -Wall"
1643         cf_gxx_extra_warnings=""
1644         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
1645         case "$GCC_VERSION" in
1646         [[1-2]].*)
1647                 ;;
1648         *)
1649                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
1650                 ;;
1651         esac
1652         for cf_opt in \
1653                 Wabi \
1654                 fabi-version=0 \
1655                 Woverloaded-virtual \
1656                 Wsign-promo \
1657                 Wsynth \
1658                 Wold-style-cast \
1659                 Wcast-align \
1660                 Wcast-qual \
1661                 Wmissing-prototypes \
1662                 Wpointer-arith \
1663                 Wshadow \
1664                 Wstrict-prototypes \
1665                 Wundef $cf_gxx_extra_warnings $1
1666         do
1667                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
1668                 if AC_TRY_EVAL(ac_compile); then
1669                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1670                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1671                 else
1672                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
1673                 fi
1674         done
1675         CXXFLAGS="$cf_save_CXXFLAGS"
1676 fi
1677
1678 rm -f conftest*
1679 AC_LANG_RESTORE
1680 AC_SUBST(EXTRA_CXXFLAGS)
1681 ])dnl
1682 dnl ---------------------------------------------------------------------------
1683 dnl CF_HASHED_DB version: 3 updated: 2007/11/24 17:43:37
1684 dnl ------------
1685 dnl Look for an instance of the Berkeley hashed database.
1686 dnl
1687 dnl $1 = optional parameter, to specify install-prefix for the database.
1688 AC_DEFUN([CF_HASHED_DB],
1689 [
1690 ifelse([$1],,,[
1691 case $1 in #(vi
1692 yes|*able*) #(vi
1693     ;;
1694 *)
1695     if test -d "$1" ; then
1696         CF_ADD_INCDIR($1/include)
1697         CF_ADD_LIBDIR($1/lib)
1698     fi
1699 esac
1700 ])
1701 AC_CHECK_HEADER(db.h,[
1702 CF_HASHED_DB_VERSION
1703 if test "$cf_cv_hashed_db_version" = unknown ; then
1704         AC_MSG_ERROR(Cannot determine version of db)
1705 else
1706         CF_HASHED_DB_LIBS
1707         if test "$cf_cv_hashed_db_libs" = unknown ; then
1708                 AC_MSG_ERROR(Cannot determine library for db)
1709         elif test "$cf_cv_hashed_db_libs" != default ; then
1710                 LIBS="-l$cf_cv_hashed_db_libs $LIBS"
1711         fi
1712 fi
1713 ],[
1714         AC_MSG_ERROR(Cannot find db.h)
1715 ])
1716 ])dnl
1717 dnl ---------------------------------------------------------------------------
1718 dnl CF_HASHED_DB_LIBS version: 8 updated: 2008/08/04 06:18:06
1719 dnl -----------------
1720 dnl Given that we have the header and version for hashed database, find the
1721 dnl library information.
1722 AC_DEFUN([CF_HASHED_DB_LIBS],
1723 [
1724 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
1725 cf_cv_hashed_db_libs=unknown
1726 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
1727 do
1728         cf_save_libs="$LIBS"
1729         if test -n "$cf_db_libs"; then
1730                 LIBS="-l$cf_db_libs $LIBS"
1731         fi
1732         CF_MSG_LOG(checking for library "$cf_db_libs")
1733         AC_TRY_LINK([
1734 $ac_includes_default
1735 #include <db.h>
1736 ],[
1737         char *path = "/tmp/foo";
1738 #ifdef DB_VERSION_MAJOR
1739 #if DB_VERSION_MAJOR >= 4
1740         DB *result = 0;
1741         db_create(&result, NULL, 0);
1742         result->open(result,
1743                 NULL,
1744                 path,
1745                 path,
1746                 DB_HASH,
1747                 DB_CREATE,
1748                 0644);
1749 #elif DB_VERSION_MAJOR >= 3
1750         DB *result = 0;
1751         db_create(&result, NULL, 0);
1752         result->open(result,
1753                 path,
1754                 path,
1755                 DB_HASH,
1756                 DB_CREATE,
1757                 0644);
1758 #elif DB_VERSION_MAJOR >= 2
1759         DB *result = 0;
1760         db_open(path,
1761                 DB_HASH,
1762                 DB_CREATE,
1763                 0644,
1764                 (DB_ENV *) 0,
1765                 (DB_INFO *) 0,
1766                 &result);
1767 #endif /* DB_VERSION_MAJOR */
1768 #else
1769         DB *result = dbopen(path,
1770                      2,
1771                      0644,
1772                      DB_HASH,
1773                      0);
1774 #endif
1775         ${cf_cv_main_return:-return}(result != 0)
1776 ],[
1777         if test -n "$cf_db_libs" ; then
1778                 cf_cv_hashed_db_libs=$cf_db_libs
1779         else
1780                 cf_cv_hashed_db_libs=default
1781         fi
1782         LIBS="$cf_save_libs"
1783         break
1784 ])
1785         LIBS="$cf_save_libs"
1786 done
1787 ])
1788 ])dnl
1789 dnl ---------------------------------------------------------------------------
1790 dnl CF_HASHED_DB_VERSION version: 3 updated: 2007/12/01 15:01:37
1791 dnl --------------------
1792 dnl Given that we have the header file for hashed database, find the version
1793 dnl information.
1794 AC_DEFUN([CF_HASHED_DB_VERSION],
1795 [
1796 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
1797 cf_cv_hashed_db_version=unknown
1798
1799 for cf_db_version in 1 2 3 4 5
1800 do
1801         CF_MSG_LOG(checking for db version $cf_db_version)
1802         AC_TRY_COMPILE([
1803 $ac_includes_default
1804 #include <db.h>
1805
1806 #ifdef DB_VERSION_MAJOR
1807         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
1808 #if $cf_db_version == DB_VERSION_MAJOR
1809         /* ok */
1810 #else
1811         make an error
1812 #endif
1813 #else
1814 #if $cf_db_version == 1
1815         /* ok: assuming this is DB 1.8.5 */
1816 #else
1817         make an error
1818 #endif
1819 #endif
1820 ],[DBT *foo = 0],[
1821         cf_cv_hashed_db_version=$cf_db_version
1822         break
1823         ])
1824 done
1825 ])
1826 ])dnl
1827 dnl ---------------------------------------------------------------------------
1828 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
1829 dnl ---------------
1830 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
1831 AC_DEFUN([CF_HELP_MESSAGE],
1832 [AC_DIVERT_HELP([$1])dnl
1833 ])dnl
1834 dnl ---------------------------------------------------------------------------
1835 dnl CF_INCLUDE_DIRS version: 5 updated: 2006/10/14 15:23:15
1836 dnl ---------------
1837 dnl Construct the list of include-options according to whether we're building
1838 dnl in the source directory or using '--srcdir=DIR' option.  If we're building
1839 dnl with gcc, don't append the includedir if it happens to be /usr/include,
1840 dnl since that usually breaks gcc's shadow-includes.
1841 AC_DEFUN([CF_INCLUDE_DIRS],
1842 [
1843 CPPFLAGS="-I. -I../include $CPPFLAGS"
1844 if test "$srcdir" != "."; then
1845         CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
1846 fi
1847 if test "$GCC" != yes; then
1848         CPPFLAGS="$CPPFLAGS -I\${includedir}"
1849 elif test "$includedir" != "/usr/include"; then
1850         if test "$includedir" = '${prefix}/include' ; then
1851                 if test $prefix != /usr ; then
1852                         CPPFLAGS="$CPPFLAGS -I\${includedir}"
1853                 fi
1854         else
1855                 CPPFLAGS="$CPPFLAGS -I\${includedir}"
1856         fi
1857 fi
1858 AC_SUBST(CPPFLAGS)
1859 ])dnl
1860 dnl ---------------------------------------------------------------------------
1861 dnl CF_INTEL_COMPILER version: 3 updated: 2005/08/06 18:37:29
1862 dnl -----------------
1863 dnl Check if the given compiler is really the Intel compiler for Linux.  It
1864 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
1865 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
1866 dnl
1867 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1868 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
1869 dnl the wrappers for gcc and g++ warnings.
1870 dnl
1871 dnl $1 = GCC (default) or GXX
1872 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
1873 dnl $3 = CFLAGS (default) or CXXFLAGS
1874 AC_DEFUN([CF_INTEL_COMPILER],[
1875 ifelse($2,,INTEL_COMPILER,[$2])=no
1876
1877 if test "$ifelse($1,,[$1],GCC)" = yes ; then
1878         case $host_os in
1879         linux*|gnu*)
1880                 AC_MSG_CHECKING(if this is really Intel ifelse($1,GXX,C++,C) compiler)
1881                 cf_save_CFLAGS="$ifelse($3,,CFLAGS,[$3])"
1882                 ifelse($3,,CFLAGS,[$3])="$ifelse($3,,CFLAGS,[$3]) -no-gcc"
1883                 AC_TRY_COMPILE([],[
1884 #ifdef __INTEL_COMPILER
1885 #else
1886 make an error
1887 #endif
1888 ],[ifelse($2,,INTEL_COMPILER,[$2])=yes
1889 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
1890 ],[])
1891                 ifelse($3,,CFLAGS,[$3])="$cf_save_CFLAGS"
1892                 AC_MSG_RESULT($ifelse($2,,INTEL_COMPILER,[$2]))
1893                 ;;
1894         esac
1895 fi
1896 ])dnl
1897 dnl ---------------------------------------------------------------------------
1898 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
1899 dnl ----------
1900 dnl Check if we have either a function or macro for 'isascii()'.
1901 AC_DEFUN([CF_ISASCII],
1902 [
1903 AC_MSG_CHECKING(for isascii)
1904 AC_CACHE_VAL(cf_cv_have_isascii,[
1905         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
1906         [cf_cv_have_isascii=yes],
1907         [cf_cv_have_isascii=no])
1908 ])dnl
1909 AC_MSG_RESULT($cf_cv_have_isascii)
1910 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
1911 ])dnl
1912 dnl ---------------------------------------------------------------------------
1913 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
1914 dnl ------------
1915 dnl Add checks for large file support.
1916 AC_DEFUN([CF_LARGEFILE],[
1917 ifdef([AC_FUNC_FSEEKO],[
1918     AC_SYS_LARGEFILE
1919     if test "$enable_largefile" != no ; then
1920         AC_FUNC_FSEEKO
1921
1922         # Normally we would collect these definitions in the config.h,
1923         # but (like _XOPEN_SOURCE), some environments rely on having these
1924         # defined before any of the system headers are included.  Another
1925         # case comes up with C++, e.g., on AIX the compiler compiles the
1926         # header files by themselves before looking at the body files it is
1927         # told to compile.  For ncurses, those header files do not include
1928         # the config.h
1929         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
1930         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
1931         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
1932
1933         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
1934                 AC_TRY_COMPILE([
1935 #include <sys/types.h>
1936 #include <dirent.h>
1937                 ],[
1938                 /* if transitional largefile support is setup, this is true */
1939                 extern struct dirent64 * readdir(DIR *);
1940                 struct dirent64 *x = readdir((DIR *)0);
1941                 struct dirent *y = readdir((DIR *)0);
1942                 int z = x - y;
1943                 ],
1944                 [cf_cv_struct_dirent64=yes],
1945                 [cf_cv_struct_dirent64=no])
1946         ])
1947         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
1948     fi
1949 ])
1950 ])
1951 dnl ---------------------------------------------------------------------------
1952 dnl CF_LDFLAGS_STATIC version: 3 updated: 2008/07/05 13:56:40
1953 dnl -----------------
1954 dnl Check for compiler/linker flags used to temporarily force usage of static
1955 dnl libraries.  This depends on the compiler and platform.  Use this to help
1956 dnl ensure that the linker picks up a given library based on its position in
1957 dnl the list of linker options and libraries.
1958 AC_DEFUN([CF_LDFLAGS_STATIC],[
1959
1960 if test "$GCC" = yes ; then
1961         case $cf_cv_system_name in #(
1962         aix[[45]]*)     #( gcc 4.2.4 linkage on AIX is broken 
1963                 LDFLAGS_STATIC=
1964                 LDFLAGS_SHARED=
1965                 ;;
1966     *)  #( normally, except when broken
1967         LDFLAGS_STATIC=-static
1968         LDFLAGS_SHARED=-dynamic
1969         ;;
1970     esac
1971 else
1972         case $cf_cv_system_name in #(
1973         aix[[45]]*)     #( from ld manpage
1974                 LDFLAGS_STATIC=-bstatic
1975                 LDFLAGS_SHARED=-bdynamic
1976                 ;;
1977         hpux*)          #( from ld manpage for hpux10.20, hpux11.11
1978                 # We could also use just "archive" and "shared".
1979                 LDFLAGS_STATIC=-Wl,-a,archive_shared
1980                 LDFLAGS_SHARED=-Wl,-a,shared_archive
1981                 ;;
1982         irix*)          #( from ld manpage IRIX64
1983                 LDFLAGS_STATIC=-Bstatic
1984                 LDFLAGS_SHARED=-Bdynamic
1985                 ;;
1986         osf[[45]]*)     #( from ld manpage osf4.0d, osf5.1
1987                 # alternative "-oldstyle_liblookup" (not in cc manpage)
1988                 LDFLAGS_STATIC=-noso 
1989                 LDFLAGS_SHARED=-so_archive
1990                 ;;
1991         solaris2*)
1992                 LDFLAGS_STATIC=-Bstatic
1993                 LDFLAGS_SHARED=-Bdynamic
1994                 ;;
1995         esac
1996 fi
1997
1998 AC_SUBST(LDFLAGS_STATIC)
1999 AC_SUBST(LDFLAGS_SHARED)
2000 ])
2001 dnl ---------------------------------------------------------------------------
2002 dnl CF_LIBUTF8 version: 2 updated: 2002/01/19 22:51:32
2003 dnl ----------
2004 dnl Check for libutf8
2005 AC_DEFUN([CF_LIBUTF8],
2006 [
2007 AC_CACHE_CHECK(for putwc in libutf8,cf_cv_libutf8,[
2008         cf_save_LIBS="$LIBS"
2009         LIBS="-lutf8 $LIBS"
2010 AC_TRY_LINK([
2011 #include <libutf8.h>],[putwc(0,0);],
2012         [cf_cv_libutf8=yes],
2013         [cf_cv_libutf8=no])
2014         LIBS="$cf_save_LIBS"
2015 ])
2016
2017 if test "$cf_cv_libutf8" = yes ; then
2018         AC_DEFINE(HAVE_LIBUTF8_H)
2019         LIBS="-lutf8 $LIBS"
2020 fi
2021 ])dnl
2022 dnl ---------------------------------------------------------------------------
2023 dnl CF_LIB_PREFIX version: 7 updated: 2001/01/12 01:23:48
2024 dnl -------------
2025 dnl Compute the library-prefix for the given host system
2026 dnl $1 = variable to set
2027 AC_DEFUN([CF_LIB_PREFIX],
2028 [
2029         case $cf_cv_system_name in
2030         OS/2*)  LIB_PREFIX=''     ;;
2031         os2*)   LIB_PREFIX=''     ;;
2032         *)      LIB_PREFIX='lib'  ;;
2033         esac
2034 ifelse($1,,,[$1=$LIB_PREFIX])
2035         AC_SUBST(LIB_PREFIX)
2036 ])dnl
2037 dnl ---------------------------------------------------------------------------
2038 dnl CF_LIB_RULES version: 50 updated: 2007/03/24 18:26:59
2039 dnl ------------
2040 dnl Append definitions and rules for the given models to the subdirectory
2041 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
2042 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
2043 dnl the corresponding makefile to list the models that we'll generate.
2044 dnl
2045 dnl For shared libraries, make a list of symbolic links to construct when
2046 dnl generating each library.  The convention used for Linux is the simplest
2047 dnl one:
2048 dnl     lib<name>.so    ->
2049 dnl     lib<name>.so.<major>    ->
2050 dnl     lib<name>.so.<maj>.<minor>
2051 AC_DEFUN([CF_LIB_RULES],
2052 [
2053 CF_LIB_PREFIX(cf_prefix)
2054 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2055 for cf_dir in $SRC_SUBDIRS
2056 do
2057         if test ! -d $srcdir/$cf_dir ; then
2058                 continue
2059         elif test -f $srcdir/$cf_dir/modules; then
2060
2061                 SHARED_LIB=
2062                 LIBS_TO_MAKE=
2063                 for cf_item in $cf_LIST_MODELS
2064                 do
2065                         CF_LIB_SUFFIX($cf_item,cf_suffix)
2066                         if test $cf_item = shared ; then
2067                         if test "$cf_cv_do_symlinks" = yes ; then
2068                                 case "$cf_cv_shlib_version" in #(vi
2069                                 rel) #(vi
2070                                         case "$cf_cv_system_name" in #(vi
2071                                         darwin*)
2072                                         case .${LIB_SUFFIX} in
2073                                         .w*)
2074                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2075                                                 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
2076                                                 ;;
2077                                         *)
2078                                                 cf_suffix='.${REL_VERSION}'"$cf_suffix"
2079                                                 ;;
2080                                         esac
2081                                         ;; #(vi
2082                                         *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
2083                                         esac
2084                                         ;;
2085                                 abi)
2086                                         case "$cf_cv_system_name" in #(vi
2087                                         darwin*)
2088                                         case .${LIB_SUFFIX} in
2089                                         .w*)
2090                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2091                                                 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
2092                                                 ;;
2093                                         *)
2094                                                 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
2095                                                 ;;
2096                                         esac
2097                                         ;; #(vi
2098                                         *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
2099                                         esac
2100                                         ;;
2101                                 esac
2102                         fi
2103                         # cygwin needs import library, and has unique naming convention
2104                         # use autodetected ${cf_prefix} for import lib and static lib, but
2105                         # use 'cyg' prefix for shared lib.
2106                         if test $cf_cv_shlib_version = cygdll ; then
2107                                 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}\${ABI_VERSION}.dll"
2108                                 continue
2109                         fi
2110                         fi
2111                         LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
2112                 done
2113
2114                 if test $cf_dir = ncurses ; then
2115                         cf_subsets="$LIB_SUBSETS"
2116                         cf_r_parts="$cf_subsets"
2117
2118                         while test -n "$cf_r_parts"
2119                         do
2120                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
2121                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
2122                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
2123                                         case $cf_l_parts in #(vi
2124                                         *termlib*) #(vi
2125                                                 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
2126                                                 ;;
2127                                         *ticlib*)
2128                                                 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
2129                                                 ;;
2130                                         *)
2131                                                 break
2132                                                 ;;
2133                                         esac
2134                                         LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
2135                                 else
2136                                         break
2137                                 fi
2138                         done
2139                 else
2140                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
2141                 fi
2142
2143                 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
2144                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
2145                         $cf_dir/Makefile >$cf_dir/Makefile.out
2146                 mv $cf_dir/Makefile.out $cf_dir/Makefile
2147
2148                 $AWK -f $srcdir/mk-0th.awk \
2149                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
2150                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2151
2152                 for cf_subset in $cf_subsets
2153                 do
2154                         cf_subdirs=
2155                         for cf_item in $cf_LIST_MODELS
2156                         do
2157                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
2158                         CF_UPPER(cf_ITEM,$cf_item)
2159                         CF_LIB_SUFFIX($cf_item,cf_suffix)
2160                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
2161
2162                         # Test for case where we build libtinfo with a different name.
2163                         cf_libname=$cf_dir
2164                         if test $cf_dir = ncurses ; then
2165                                 case $cf_subset in
2166                                 *base*)
2167                                         ;;
2168                                 *termlib*)
2169                                         cf_libname=$TINFO_LIB_SUFFIX
2170                                         if test -n "${DFT_ARG_SUFFIX}" ; then
2171                                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2172                                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2173                                         fi
2174                                         ;;
2175                                 ticlib*)
2176                                         cf_libname=$TICS_LIB_SUFFIX
2177                                         if test -n "${DFT_ARG_SUFFIX}" ; then
2178                                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2179                                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2180                                         fi
2181                                         ;;
2182                                 esac
2183                         fi
2184
2185                         # These dependencies really are for development, not
2186                         # builds, but they are useful in porting, too.
2187                         cf_depend="../include/ncurses_cfg.h"
2188                         if test "$srcdir" = "."; then
2189                                 cf_reldir="."
2190                         else
2191                                 cf_reldir="\${srcdir}"
2192                         fi
2193
2194                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
2195                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
2196                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
2197                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
2198                         fi
2199
2200                         cf_dir_suffix=
2201                         old_cf_suffix="$cf_suffix"
2202                         if test "$cf_cv_shlib_version_infix" = yes ; then
2203                         if test -n "$LIB_SUFFIX" ; then
2204                                 case $LIB_SUFFIX in
2205                                 w*)
2206                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
2207                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2208                                         cf_dir_suffix=w
2209                                         ;;
2210                                 esac
2211                         fi
2212                         fi
2213
2214                         $AWK -f $srcdir/mk-1st.awk \
2215                                 name=${cf_libname}${cf_dir_suffix} \
2216                                 traces=$LIB_TRACING \
2217                                 MODEL=$cf_ITEM \
2218                                 model=$cf_subdir \
2219                                 prefix=$cf_prefix \
2220                                 suffix=$cf_suffix \
2221                                 subset=$cf_subset \
2222                                 TermlibRoot=$TINFO_NAME \
2223                                 TermlibSuffix=$TINFO_SUFFIX \
2224                                 ShlibVer=$cf_cv_shlib_version \
2225                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
2226                                 ReLink=${cf_cv_do_relink-no} \
2227                                 DoLinks=$cf_cv_do_symlinks \
2228                                 rmSoLocs=$cf_cv_rm_so_locs \
2229                                 ldconfig="$LDCONFIG" \
2230                                 overwrite=$WITH_OVERWRITE \
2231                                 depend="$cf_depend" \
2232                                 host="$host" \
2233                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2234
2235                         cf_suffix="$old_cf_suffix"
2236
2237                         for cf_subdir2 in $cf_subdirs lib
2238                         do
2239                                 test $cf_subdir = $cf_subdir2 && break
2240                         done
2241                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
2242                         $AWK -f $srcdir/mk-2nd.awk \
2243                                 name=$cf_dir \
2244                                 traces=$LIB_TRACING \
2245                                 MODEL=$cf_ITEM \
2246                                 model=$cf_subdir \
2247                                 subset=$cf_subset \
2248                                 srcdir=$srcdir \
2249                                 echo=$WITH_ECHO \
2250                                 crenames=$cf_cv_prog_CC_c_o \
2251                                 cxxrenames=$cf_cv_prog_CXX_c_o \
2252                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2253                         cf_subdirs="$cf_subdirs $cf_subdir"
2254                         done
2255                 done
2256         fi
2257
2258         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
2259 done
2260
2261 for cf_dir in $SRC_SUBDIRS
2262 do
2263         if test ! -d $srcdir/$cf_dir ; then
2264                 continue
2265         fi
2266
2267         if test -f $cf_dir/Makefile ; then
2268                 case "$cf_dir" in
2269                 Ada95) #(vi
2270                         echo 'libs \' >> Makefile
2271                         echo 'install.libs \' >> Makefile
2272                         echo 'uninstall.libs ::' >> Makefile
2273                         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
2274                         ;;
2275                 esac
2276         fi
2277
2278         if test -f $srcdir/$cf_dir/modules; then
2279                 echo >> Makefile
2280                 if test -f $srcdir/$cf_dir/headers; then
2281 cat >> Makefile <<CF_EOF
2282 install.includes \\
2283 uninstall.includes \\
2284 CF_EOF
2285                 fi
2286 if test "$cf_dir" != "c++" ; then
2287 echo 'lint \' >> Makefile
2288 fi
2289 cat >> Makefile <<CF_EOF
2290 libs \\
2291 lintlib \\
2292 install.libs \\
2293 uninstall.libs \\
2294 install.$cf_dir \\
2295 uninstall.$cf_dir ::
2296         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2297 CF_EOF
2298         elif test -f $srcdir/$cf_dir/headers; then
2299 cat >> Makefile <<CF_EOF
2300
2301 libs \\
2302 install.libs \\
2303 uninstall.libs \\
2304 install.includes \\
2305 uninstall.includes ::
2306         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2307 CF_EOF
2308 fi
2309 done
2310
2311 cat >> Makefile <<CF_EOF
2312
2313 install.libs uninstall.libs \\
2314 install.data uninstall.data ::
2315 $MAKE_TERMINFO  cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
2316
2317 install.man \\
2318 uninstall.man ::
2319         cd man && \${MAKE} \${CF_MFLAGS} \[$]@
2320
2321 distclean ::
2322         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
2323         rm -f headers.sh headers.sed mk_shared_lib.sh
2324         rm -rf \${DIRS_TO_MAKE}
2325 CF_EOF
2326
2327 # Special case: tack's manpage lives in its own directory.
2328 if test -d tack ; then
2329 if test -f $srcdir/$tack.h; then
2330 cat >> Makefile <<CF_EOF
2331
2332 install.man \\
2333 uninstall.man ::
2334         cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
2335 CF_EOF
2336 fi
2337 fi
2338
2339 dnl If we're installing into a subdirectory of /usr/include, etc., we should
2340 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
2341 dnl anything, and will make it more standardized.  It's awkward to decide this
2342 dnl at configuration because of quoting, so we'll simply make all headers
2343 dnl installed via a script that can do the right thing.
2344
2345 rm -f headers.sed headers.sh
2346
2347 dnl ( generating this script makes the makefiles a little tidier :-)
2348 echo creating headers.sh
2349 cat >headers.sh <<CF_EOF
2350 #! /bin/sh
2351 # This shell script is generated by the 'configure' script.  It is invoked in a
2352 # subdirectory of the build tree.  It generates a sed-script in the parent
2353 # directory that is used to adjust includes for header files that reside in a
2354 # subdirectory of /usr/include, etc.
2355 PRG=""
2356 while test \[$]# != 3
2357 do
2358 PRG="\$PRG \[$]1"; shift
2359 done
2360 DST=\[$]1
2361 REF=\[$]2
2362 SRC=\[$]3
2363 TMPSRC=\${TMPDIR-/tmp}/\`basename \$SRC\`\$\$
2364 TMPSED=\${TMPDIR-/tmp}/headers.sed\$\$
2365 echo installing \$SRC in \$DST
2366 CF_EOF
2367
2368 if test $WITH_CURSES_H = yes; then
2369         cat >>headers.sh <<CF_EOF
2370 case \$DST in
2371 /*/include/*)
2372         END=\`basename \$DST\`
2373         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2374         do
2375                 NAME=\`basename \$i\`
2376                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2377         done
2378         ;;
2379 *)
2380         echo "" >> \$TMPSED
2381         ;;
2382 esac
2383 CF_EOF
2384
2385 else
2386         cat >>headers.sh <<CF_EOF
2387 case \$DST in
2388 /*/include/*)
2389         END=\`basename \$DST\`
2390         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2391         do
2392                 NAME=\`basename \$i\`
2393                 if test "\$NAME" = "curses.h"
2394                 then
2395                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2396                         NAME=ncurses.h
2397                 fi
2398                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2399         done
2400         ;;
2401 *)
2402         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2403         ;;
2404 esac
2405 CF_EOF
2406 fi
2407 cat >>headers.sh <<CF_EOF
2408 rm -f \$TMPSRC
2409 sed -f \$TMPSED \$SRC > \$TMPSRC
2410 NAME=\`basename \$SRC\`
2411 CF_EOF
2412 if test $WITH_CURSES_H != yes; then
2413         cat >>headers.sh <<CF_EOF
2414 test "\$NAME" = "curses.h" && NAME=ncurses.h
2415 CF_EOF
2416 fi
2417 cat >>headers.sh <<CF_EOF
2418 # Just in case someone gzip'd manpages, remove the conflicting copy.
2419 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
2420
2421 eval \$PRG \$TMPSRC \$DST/\$NAME
2422 rm -f \$TMPSRC \$TMPSED
2423 CF_EOF
2424
2425 chmod 0755 headers.sh
2426
2427 for cf_dir in $SRC_SUBDIRS
2428 do
2429         if test ! -d $srcdir/$cf_dir ; then
2430                 continue
2431         fi
2432
2433         if test -f $srcdir/$cf_dir/headers; then
2434                 $AWK -f $srcdir/mk-hdr.awk \
2435                         subset="$LIB_SUBSETS" \
2436                         compat="$WITH_CURSES_H" \
2437                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
2438         fi
2439
2440         if test -f $srcdir/$cf_dir/modules; then
2441                 if test "$cf_dir" != "c++" ; then
2442                         cat >>$cf_dir/Makefile <<"CF_EOF"
2443 depend : ${AUTO_SRC}
2444         makedepend -- ${CPPFLAGS} -- ${C_SRC}
2445
2446 # DO NOT DELETE THIS LINE -- make depend depends on it.
2447 CF_EOF
2448                 fi
2449         fi
2450 done
2451
2452 ])dnl
2453 dnl ---------------------------------------------------------------------------
2454 dnl CF_LIB_SONAME version: 3 updated: 2006/12/16 15:55:46
2455 dnl -------------
2456 dnl Find the and soname for the given shared library.  Set the cache variable
2457 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
2458 dnl variable to "unknown".
2459 dnl
2460 dnl $1 = headers
2461 dnl $2 = code
2462 dnl $3 = library name
2463 AC_DEFUN([CF_LIB_SONAME],
2464 [
2465 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
2466
2467 cf_cv_$3_soname=unknown
2468 if test "$cross_compiling" != yes ; then
2469 cat >conftest.$ac_ext <<CF_EOF
2470 $1
2471 int main()
2472 {
2473 $2
2474         ${cf_cv_main_return:-return}(0);
2475 }
2476 CF_EOF
2477 cf_save_LIBS="$LIBS"
2478         LIBS="-l$3 $LIBS"
2479         if AC_TRY_EVAL(ac_compile) ; then
2480                 if AC_TRY_EVAL(ac_link) ; then
2481                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
2482                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
2483                 fi
2484         fi
2485 rm -f conftest*
2486 LIBS="$cf_save_LIBS"
2487 fi
2488 ])
2489 ])
2490 dnl ---------------------------------------------------------------------------
2491 dnl CF_LIB_SUFFIX version: 13 updated: 2003/11/01 16:09:07
2492 dnl -------------
2493 dnl Compute the library file-suffix from the given model name
2494 dnl $1 = model name
2495 dnl $2 = variable to set
2496 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2497 AC_DEFUN([CF_LIB_SUFFIX],
2498 [
2499         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2500         case $1 in
2501         libtool) $2='.la'  ;;
2502         normal)  $2='.a'   ;;
2503         debug)   $2='_g.a' ;;
2504         profile) $2='_p.a' ;;
2505         shared)
2506                 case $cf_cv_system_name in
2507                 cygwin*) $2='.dll' ;;
2508                 darwin*) $2='.dylib' ;;
2509                 hpux*)
2510                         case $target in
2511                         ia64*)  $2='.so' ;;
2512                         *)      $2='.sl' ;;
2513                         esac
2514                         ;;
2515                 *)      $2='.so'  ;;
2516                 esac
2517         esac
2518         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2519 ])dnl
2520 dnl ---------------------------------------------------------------------------
2521 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
2522 dnl -----------
2523 dnl Compute the string to append to -library from the given model name
2524 dnl $1 = model name
2525 dnl $2 = variable to set
2526 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2527 AC_DEFUN([CF_LIB_TYPE],
2528 [
2529         case $1 in
2530         libtool) $2=''   ;;
2531         normal)  $2=''   ;;
2532         debug)   $2='_g' ;;
2533         profile) $2='_p' ;;
2534         shared)  $2=''   ;;
2535         esac
2536         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2537 ])dnl
2538 dnl ---------------------------------------------------------------------------
2539 dnl CF_LINK_DATAONLY version: 8 updated: 2006/12/16 12:33:30
2540 dnl ----------------
2541 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2542 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
2543 dnl have to provide wrappers for global tables to ensure they're linked
2544 dnl properly.
2545 AC_DEFUN([CF_LINK_DATAONLY],
2546 [
2547 AC_MSG_CHECKING([if data-only library module links])
2548 AC_CACHE_VAL(cf_cv_link_dataonly,[
2549         rm -f conftest.a
2550         cat >conftest.$ac_ext <<EOF
2551 #line __oline__ "configure"
2552 int     testdata[[3]] = { 123, 456, 789 };
2553 EOF
2554         if AC_TRY_EVAL(ac_compile) ; then
2555                 mv conftest.o data.o && \
2556                 ( $AR $AR_OPTS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2557         fi
2558         rm -f conftest.$ac_ext data.o
2559         cat >conftest.$ac_ext <<EOF
2560 #line __oline__ "configure"
2561 int     testfunc()
2562 {
2563 #if defined(NeXT)
2564         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
2565 #else
2566         extern int testdata[[3]];
2567         return testdata[[0]] == 123
2568            &&  testdata[[1]] == 456
2569            &&  testdata[[2]] == 789;
2570 #endif
2571 }
2572 EOF
2573         if AC_TRY_EVAL(ac_compile); then
2574                 mv conftest.o func.o && \
2575                 ( $AR $AR_OPTS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2576         fi
2577         rm -f conftest.$ac_ext func.o
2578         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2579         cf_saveLIBS="$LIBS"
2580         LIBS="conftest.a $LIBS"
2581         AC_TRY_RUN([
2582         int main()
2583         {
2584                 extern int testfunc();
2585                 ${cf_cv_main_return:-return} (!testfunc());
2586         }
2587         ],
2588         [cf_cv_link_dataonly=yes],
2589         [cf_cv_link_dataonly=no],
2590         [cf_cv_link_dataonly=unknown])
2591         LIBS="$cf_saveLIBS"
2592         ])
2593 AC_MSG_RESULT($cf_cv_link_dataonly)
2594
2595 if test "$cf_cv_link_dataonly" = no ; then
2596         AC_DEFINE(BROKEN_LINKER)
2597         BROKEN_LINKER=1
2598 fi
2599
2600 ])dnl
2601 dnl ---------------------------------------------------------------------------
2602 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
2603 dnl -------------
2604 dnl Most Unix systems have both link and symlink, a few don't have symlink.
2605 dnl A few non-Unix systems implement symlink, but not link.
2606 dnl A few non-systems implement neither (or have nonfunctional versions).
2607 AC_DEFUN([CF_LINK_FUNCS],
2608 [
2609 AC_CHECK_FUNCS( \
2610         remove \
2611         unlink )
2612
2613 if test "$cross_compiling" = yes ; then
2614         AC_CHECK_FUNCS( \
2615                 link \
2616                 symlink )
2617 else
2618         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
2619                 cf_cv_link_funcs=
2620                 for cf_func in link symlink ; do
2621                         AC_TRY_RUN([
2622 #include <sys/types.h>
2623 #include <sys/stat.h>
2624 #ifdef HAVE_UNISTD_H
2625 #include <unistd.h>
2626 #endif
2627 int main()
2628 {
2629         int fail = 0;
2630         char *src = "config.log";
2631         char *dst = "conftest.chk";
2632         struct stat src_sb;
2633         struct stat dst_sb;
2634
2635         stat(src, &src_sb);
2636         fail = ($cf_func("config.log", "conftest.chk") < 0)
2637             || (stat(dst, &dst_sb) < 0)
2638             || (dst_sb.st_mtime != src_sb.st_mtime);
2639 #ifdef HAVE_UNLINK
2640         unlink(dst);
2641 #else
2642         remove(dst);
2643 #endif
2644         ${cf_cv_main_return:-return} (fail);
2645 }
2646                         ],[
2647                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
2648                         eval 'ac_cv_func_'$cf_func'=yes'],[
2649                         eval 'ac_cv_func_'$cf_func'=no'],[
2650                         eval 'ac_cv_func_'$cf_func'=error'])
2651                 done
2652                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
2653         ])
2654         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
2655         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
2656 fi
2657 ])dnl
2658 dnl ---------------------------------------------------------------------------
2659 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
2660 dnl --------------
2661 dnl Check if a return from main to the shell actually returns the same exit
2662 dnl code.  This is true for almost any POSIX environment.
2663 dnl
2664 dnl Some very old environments did not flush stdout, etc., on an exit.  That
2665 dnl would be a useful case to test for also.
2666 AC_DEFUN([CF_MAIN_RETURN],
2667 [
2668 cf_cv_main_return=return
2669 ])dnl
2670 dnl ---------------------------------------------------------------------------
2671 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
2672 dnl ------------
2673 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2674 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
2675 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2676 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2677 AC_DEFUN([CF_MAKEFLAGS],
2678 [
2679 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2680         cf_cv_makeflags=''
2681         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2682         do
2683                 cat >cf_makeflags.tmp <<CF_EOF
2684 SHELL = /bin/sh
2685 all :
2686         @ echo '.$cf_option'
2687 CF_EOF
2688                 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[       ]]*$,,'`
2689                 case "$cf_result" in
2690                 .*k)
2691                         cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
2692                         case "$cf_result" in
2693                         .*CC=*) cf_cv_makeflags=
2694                                 ;;
2695                         *)      cf_cv_makeflags=$cf_option
2696                                 ;;
2697                         esac
2698                         break
2699                         ;;
2700                 .-)     ;;
2701                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
2702                         ;;
2703                 esac
2704         done
2705         rm -f cf_makeflags.tmp
2706 ])
2707
2708 AC_SUBST(cf_cv_makeflags)
2709 ])dnl
2710 dnl ---------------------------------------------------------------------------
2711 dnl CF_MAKE_TAGS version: 2 updated: 2000/10/04 09:18:40
2712 dnl ------------
2713 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
2714 dnl a monocase filesystem.
2715 AC_DEFUN([CF_MAKE_TAGS],[
2716 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2717 AC_CHECK_PROG(MAKE_LOWER_TAGS, ctags, yes, no)
2718
2719 if test "$cf_cv_mixedcase" = yes ; then
2720         AC_CHECK_PROG(MAKE_UPPER_TAGS, etags, yes, no)
2721 else
2722         MAKE_UPPER_TAGS=no
2723 fi
2724
2725 if test "$MAKE_UPPER_TAGS" = yes ; then
2726         MAKE_UPPER_TAGS=
2727 else
2728         MAKE_UPPER_TAGS="#"
2729 fi
2730 AC_SUBST(MAKE_UPPER_TAGS)
2731
2732 if test "$MAKE_LOWER_TAGS" = yes ; then
2733         MAKE_LOWER_TAGS=
2734 else
2735         MAKE_LOWER_TAGS="#"
2736 fi
2737 AC_SUBST(MAKE_LOWER_TAGS)
2738 ])dnl
2739 dnl ---------------------------------------------------------------------------
2740 dnl CF_MANPAGE_FORMAT version: 7 updated: 2003/12/20 19:30:34
2741 dnl -----------------
2742 dnl Option to allow user to override automatic configuration of manpage format.
2743 dnl There are several special cases:
2744 dnl
2745 dnl     gzip - man checks for, can display gzip'd files
2746 dnl     compress - man checks for, can display compressed files
2747 dnl     BSDI - files in the cat-directories are suffixed ".0"
2748 dnl     formatted - installer should format (put files in cat-directory)
2749 dnl     catonly - installer should only format, e.g., for a turnkey system.
2750 dnl
2751 dnl There are other configurations which this macro does not test, e.g., HPUX's
2752 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
2753 dnl convention would not match our use).
2754 AC_DEFUN([CF_MANPAGE_FORMAT],
2755 [
2756 AC_REQUIRE([CF_PATHSEP])
2757 AC_MSG_CHECKING(format of man-pages)
2758
2759 AC_ARG_WITH(manpage-format,
2760         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
2761                           optionally formatted/catonly, e.g., gzip,formatted],
2762         [MANPAGE_FORMAT=$withval],
2763         [MANPAGE_FORMAT=unknown])
2764
2765 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
2766 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
2767
2768 cf_unknown=
2769
2770 case $MANPAGE_FORMAT in
2771 unknown)
2772   if test -z "$MANPATH" ; then
2773     MANPATH="/usr/man:/usr/share/man"
2774   fi
2775
2776   # look for the 'date' man-page (it's most likely to be installed!)
2777   MANPAGE_FORMAT=
2778   cf_preform=no
2779   cf_catonly=yes
2780   cf_example=date
2781
2782   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATHSEP}"
2783   for cf_dir in $MANPATH; do
2784     test -z "$cf_dir" && cf_dir=/usr/man
2785     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
2786     do
2787       cf_test=`echo $cf_name | sed -e 's/*//'`
2788       if test "x$cf_test" = "x$cf_name" ; then
2789
2790         case "$cf_name" in
2791         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
2792         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
2793         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
2794         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
2795         esac
2796
2797         case "$cf_name" in
2798         $cf_dir/man*)
2799           cf_catonly=no
2800           ;;
2801         $cf_dir/cat*)
2802           cf_preform=yes
2803           ;;
2804         esac
2805         break
2806       fi
2807
2808       # if we found a match in either man* or cat*, stop looking
2809       if test -n "$MANPAGE_FORMAT" ; then
2810         cf_found=no
2811         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
2812         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
2813         case "$cf_name" in
2814         $cf_dir/cat*)
2815           cf_found=yes
2816           ;;
2817         esac
2818         test $cf_found=yes && break
2819       fi
2820     done
2821     # only check the first directory in $MANPATH where we find manpages
2822     if test -n "$MANPAGE_FORMAT" ; then
2823        break
2824     fi
2825   done
2826   # if we did not find the example, just assume it is normal
2827   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
2828   IFS="$ac_save_ifs"
2829   ;;
2830 *)
2831   for cf_option in $MANPAGE_FORMAT; do
2832      case $cf_option in #(vi
2833      gzip|compress|BSDI|normal|formatted|catonly)
2834        ;;
2835      *)
2836        cf_unknown="$cf_unknown $cf_option"
2837        ;;
2838      esac
2839   done
2840   ;;
2841 esac
2842
2843 AC_MSG_RESULT($MANPAGE_FORMAT)
2844 if test -n "$cf_unknown" ; then
2845   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
2846 fi
2847 ])dnl
2848 dnl ---------------------------------------------------------------------------
2849 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
2850 dnl ------------------
2851 dnl The Debian people have their own naming convention for manpages.  This
2852 dnl option lets us override the name of the file containing renaming, or
2853 dnl disable it altogether.
2854 AC_DEFUN([CF_MANPAGE_RENAMES],
2855 [
2856 AC_MSG_CHECKING(for manpage renaming)
2857
2858 AC_ARG_WITH(manpage-renames,
2859         [  --with-manpage-renames  specify manpage-renaming],
2860         [MANPAGE_RENAMES=$withval],
2861         [MANPAGE_RENAMES=yes])
2862
2863 case ".$MANPAGE_RENAMES" in #(vi
2864 .no) #(vi
2865   ;;
2866 .|.yes)
2867   # Debian 'man' program?
2868   if test -f /etc/debian_version ; then
2869     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
2870   else
2871     MANPAGE_RENAMES=no
2872   fi
2873   ;;
2874 esac
2875
2876 if test "$MANPAGE_RENAMES" != no ; then
2877   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
2878     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
2879   elif test ! -f $MANPAGE_RENAMES ; then
2880     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
2881   fi
2882
2883   test ! -d man && mkdir man
2884
2885   # Construct a sed-script to perform renaming within man-pages
2886   if test -n "$MANPAGE_RENAMES" ; then
2887     test ! -d man && mkdir man
2888     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
2889   fi
2890 fi
2891
2892 AC_MSG_RESULT($MANPAGE_RENAMES)
2893 AC_SUBST(MANPAGE_RENAMES)
2894 ])dnl
2895 dnl ---------------------------------------------------------------------------
2896 dnl CF_MANPAGE_SYMLINKS version: 4 updated: 2003/12/13 18:01:58
2897 dnl -------------------
2898 dnl Some people expect each tool to make all aliases for manpages in the
2899 dnl man-directory.  This accommodates the older, less-capable implementations
2900 dnl of 'man', and is optional.
2901 AC_DEFUN([CF_MANPAGE_SYMLINKS],
2902 [
2903 AC_MSG_CHECKING(if manpage aliases will be installed)
2904
2905 AC_ARG_WITH(manpage-aliases,
2906         [  --with-manpage-aliases  specify manpage-aliases using .so],
2907         [MANPAGE_ALIASES=$withval],
2908         [MANPAGE_ALIASES=yes])
2909
2910 AC_MSG_RESULT($MANPAGE_ALIASES)
2911
2912 if test "$LN_S" = "ln -s"; then
2913         cf_use_symlinks=yes
2914 else
2915         cf_use_symlinks=no
2916 fi
2917
2918 MANPAGE_SYMLINKS=no
2919 if test "$MANPAGE_ALIASES" = yes ; then
2920 AC_MSG_CHECKING(if manpage symlinks should be used)
2921
2922 AC_ARG_WITH(manpage-symlinks,
2923         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
2924         [MANPAGE_SYMLINKS=$withval],
2925         [MANPAGE_SYMLINKS=$cf_use_symlinks])
2926
2927 if test "$$cf_use_symlinks" = no; then
2928 if test "$MANPAGE_SYMLINKS" = yes ; then
2929         AC_MSG_WARN(cannot make symlinks, will use .so files)
2930         MANPAGE_SYMLINKS=no
2931 fi
2932 fi
2933
2934 AC_MSG_RESULT($MANPAGE_SYMLINKS)
2935 fi
2936
2937 ])dnl
2938 dnl ---------------------------------------------------------------------------
2939 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
2940 dnl --------------
2941 dnl This option causes manpages to be run through tbl(1) to generate tables
2942 dnl correctly.
2943 AC_DEFUN([CF_MANPAGE_TBL],
2944 [
2945 AC_MSG_CHECKING(for manpage tbl)
2946
2947 AC_ARG_WITH(manpage-tbl,
2948         [  --with-manpage-tbl      specify manpage processing with tbl],
2949         [MANPAGE_TBL=$withval],
2950         [MANPAGE_TBL=no])
2951
2952 AC_MSG_RESULT($MANPAGE_TBL)
2953 ])dnl
2954 dnl ---------------------------------------------------------------------------
2955 dnl CF_MAN_PAGES version: 35 updated: 2007/03/31 11:47:29
2956 dnl ------------
2957 dnl Try to determine if the man-pages on the system are compressed, and if
2958 dnl so, what format is used.  Use this information to construct a script that
2959 dnl will install man-pages.
2960 AC_DEFUN([CF_MAN_PAGES],
2961 [
2962 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
2963 CF_MANPAGE_FORMAT
2964 CF_MANPAGE_RENAMES
2965 CF_MANPAGE_SYMLINKS
2966 CF_MANPAGE_TBL
2967
2968   if test "$prefix" = "NONE" ; then
2969      cf_prefix="$ac_default_prefix"
2970   else
2971      cf_prefix="$prefix"
2972   fi
2973
2974   case "$MANPAGE_FORMAT" in # (vi
2975   *catonly*) # (vi
2976     cf_format=yes
2977     cf_inboth=no
2978     ;;
2979   *formatted*) # (vi
2980     cf_format=yes
2981     cf_inboth=yes
2982     ;;
2983   *)
2984     cf_format=no
2985     cf_inboth=no
2986     ;;
2987   esac
2988
2989 test ! -d man && mkdir man
2990
2991 cf_so_strip=
2992 cf_compress=
2993 case "$MANPAGE_FORMAT" in #(vi
2994 *compress*) #(vi
2995         cf_so_strip="Z"
2996         cf_compress=compress
2997   ;;
2998 *gzip*) #(vi
2999         cf_so_strip="gz"
3000         cf_compress=gzip
3001   ;;
3002 esac
3003
3004 cf_edit_man=./edit_man.sh
3005 cf_man_alias=`pwd`/man_alias.sed
3006
3007 cat >$cf_edit_man <<CF_EOF
3008 #! /bin/sh
3009 # this script is generated by the configure-script CF_MAN_PAGES macro.
3010
3011 prefix="$cf_prefix"
3012 datadir="$datadir"
3013
3014 NCURSES_MAJOR="$NCURSES_MAJOR"
3015 NCURSES_MINOR="$NCURSES_MINOR"
3016 NCURSES_PATCH="$NCURSES_PATCH"
3017
3018 NCURSES_OSPEED="$NCURSES_OSPEED"
3019 TERMINFO="$TERMINFO"
3020
3021 MKDIRS="sh `cd $srcdir && pwd`/mkdirs.sh"
3022
3023 INSTALL="$INSTALL"
3024 INSTALL_DATA="$INSTALL_DATA"
3025
3026 transform="$program_transform_name"
3027
3028 TMP=\${TMPDIR-/tmp}/man\$\$
3029 trap "rm -f \$TMP" 0 1 2 5 15
3030
3031 form=\[$]1
3032 shift || exit 1
3033
3034 verb=\[$]1
3035 shift || exit 1
3036
3037 mandir=\[$]1
3038 shift || exit 1
3039
3040 srcdir=\[$]1
3041 top_srcdir=\[$]srcdir/..
3042 shift || exit 1
3043
3044 if test "\$form" = normal ; then
3045         if test "$cf_format" = yes ; then
3046         if test "$cf_inboth" = no ; then
3047                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3048                 exit $?
3049         fi
3050         fi
3051         cf_subdir=\$mandir/man
3052         cf_tables=$MANPAGE_TBL
3053 else
3054         cf_subdir=\$mandir/cat
3055         cf_tables=yes
3056 fi
3057
3058 # process the list of source-files
3059 for i in \[$]* ; do
3060 case \$i in #(vi
3061 *.orig|*.rej) ;; #(vi
3062 *.[[0-9]]*)
3063         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
3064         if test \$verb = installing ; then
3065         if test ! -d \$cf_subdir\${section} ; then
3066                 \$MKDIRS \$cf_subdir\$section
3067         fi
3068         fi
3069
3070         # replace variables in man page
3071         if test ! -f $cf_man_alias ; then
3072 cat >>$cf_man_alias <<-CF_EOF2
3073                 s,@DATADIR@,\$datadir,g
3074                 s,@TERMINFO@,\$TERMINFO,g
3075                 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
3076                 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
3077                 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
3078                 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
3079 CF_EOF
3080         ifelse($1,,,[
3081         for cf_name in $1
3082         do
3083                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3084                 cf_name=`echo $cf_name|sed "$program_transform_name"`
3085 cat >>$cf_edit_man <<-CF_EOF
3086                 s,@$cf_NAME@,$cf_name,
3087 CF_EOF
3088         done
3089         ])
3090 cat >>$cf_edit_man <<CF_EOF
3091 CF_EOF2
3092                 echo "...made $cf_man_alias"
3093         fi
3094
3095         aliases=
3096         cf_source=\`basename \$i\`
3097         inalias=\$cf_source
3098         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
3099         if test ! -f \$inalias ; then
3100                 echo .. skipped \$cf_source
3101                 continue
3102         fi
3103 CF_EOF
3104
3105 if test "$MANPAGE_ALIASES" != no ; then
3106 cat >>$cf_edit_man <<CF_EOF
3107         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
3108 CF_EOF
3109 fi
3110
3111 if test "$MANPAGE_RENAMES" = no ; then
3112 cat >>$cf_edit_man <<CF_EOF
3113         # perform program transformations for section 1 man pages
3114         if test \$section = 1 ; then
3115                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
3116         else
3117                 cf_target=\$cf_subdir\${section}/\$cf_source
3118         fi
3119 CF_EOF
3120 else
3121 cat >>$cf_edit_man <<CF_EOF
3122         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
3123         if test -z "\$cf_target" ; then
3124                 echo '? missing rename for '\$cf_source
3125                 cf_target="\$cf_source"
3126         fi
3127         cf_target="\$cf_subdir\${section}/\${cf_target}"
3128
3129 CF_EOF
3130 fi
3131
3132 cat >>$cf_edit_man <<CF_EOF
3133         sed     -f $cf_man_alias \\
3134 CF_EOF
3135
3136 if test -f $MANPAGE_RENAMES ; then
3137 cat >>$cf_edit_man <<CF_EOF
3138                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
3139 CF_EOF
3140 else
3141 cat >>$cf_edit_man <<CF_EOF
3142                 < \$i >\$TMP
3143 CF_EOF
3144 fi
3145
3146 cat >>$cf_edit_man <<CF_EOF
3147 if test \$cf_tables = yes ; then
3148         tbl \$TMP >\$TMP.out
3149         mv \$TMP.out \$TMP
3150 fi
3151 CF_EOF
3152
3153 if test $with_curses_h != yes ; then
3154 cat >>$cf_edit_man <<CF_EOF
3155         sed -e "/\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
3156         mv \$TMP.out \$TMP
3157 CF_EOF
3158 fi
3159
3160 cat >>$cf_edit_man <<CF_EOF
3161         if test \$form = format ; then
3162                 nroff -man \$TMP >\$TMP.out
3163                 mv \$TMP.out \$TMP
3164         fi
3165 CF_EOF
3166
3167 if test -n "$cf_compress" ; then
3168 cat >>$cf_edit_man <<CF_EOF
3169         if test \$verb = installing ; then
3170         if ( $cf_compress -f \$TMP )
3171         then
3172                 mv \$TMP.$cf_so_strip \$TMP
3173         fi
3174         fi
3175         cf_target="\$cf_target.$cf_so_strip"
3176 CF_EOF
3177 fi
3178
3179 case "$MANPAGE_FORMAT" in #(vi
3180 *BSDI*)
3181 cat >>$cf_edit_man <<CF_EOF
3182         if test \$form = format ; then
3183                 # BSDI installs only .0 suffixes in the cat directories
3184                 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
3185         fi
3186 CF_EOF
3187   ;;
3188 esac
3189
3190 cat >>$cf_edit_man <<CF_EOF
3191         suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
3192         if test \$verb = installing ; then
3193                 echo \$verb \$cf_target
3194                 \$INSTALL_DATA \$TMP \$cf_target
3195                 test -d \$cf_subdir\${section} &&
3196                 test -n "\$aliases" && (
3197                         cd \$cf_subdir\${section} && (
3198                                 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
3199                                 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
3200                                 cf_target=\`basename \$cf_target\`
3201                                 for cf_alias in \$aliases
3202                                 do
3203                                         if test \$section = 1 ; then
3204                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3205                                         fi
3206
3207                                         if test "$MANPAGE_SYMLINKS" = yes ; then
3208                                                 if test -f \$cf_alias\${suffix} ; then
3209                                                         if ( cmp -s \$cf_target \$cf_alias\${suffix} )
3210                                                         then
3211                                                                 continue
3212                                                         fi
3213                                                 fi
3214                                                 echo .. \$verb alias \$cf_alias\${suffix}
3215                                                 rm -f \$cf_alias\${suffix}
3216                                                 $LN_S \$cf_target \$cf_alias\${suffix}
3217                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
3218                                                 echo ".so \$cf_source" >\$TMP
3219 CF_EOF
3220 if test -n "$cf_compress" ; then
3221 cat >>$cf_edit_man <<CF_EOF
3222                                                 if test -n "$cf_so_strip" ; then
3223                                                         $cf_compress -f \$TMP
3224                                                         mv \$TMP.$cf_so_strip \$TMP
3225                                                 fi
3226 CF_EOF
3227 fi
3228 cat >>$cf_edit_man <<CF_EOF
3229                                                 echo .. \$verb alias \$cf_alias\${suffix}
3230                                                 rm -f \$cf_alias\${suffix}
3231                                                 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
3232                                         fi
3233                                 done
3234                         )
3235                 )
3236         elif test \$verb = removing ; then
3237                 test -f \$cf_target && (
3238                         echo \$verb \$cf_target
3239                         rm -f \$cf_target
3240                 )
3241                 test -d \$cf_subdir\${section} &&
3242                 test -n "\$aliases" && (
3243                         cd \$cf_subdir\${section} && (
3244                                 for cf_alias in \$aliases
3245                                 do
3246                                         if test \$section = 1 ; then
3247                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3248                                         fi
3249
3250                                         echo .. \$verb alias \$cf_alias\${suffix}
3251                                         rm -f \$cf_alias\${suffix}
3252                                 done
3253                         )
3254                 )
3255         else
3256 #               echo ".hy 0"
3257                 cat \$TMP
3258         fi
3259         ;;
3260 esac
3261 done
3262
3263 if test $cf_inboth = yes ; then
3264 if test \$form != format ; then
3265         sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3266 fi
3267 fi
3268
3269 exit 0
3270 CF_EOF
3271 chmod 755 $cf_edit_man
3272
3273 ])dnl
3274 dnl ---------------------------------------------------------------------------
3275 dnl CF_MATH_LIB version: 5 updated: 2000/05/28 01:39:10
3276 dnl -----------
3277 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
3278 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
3279 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
3280 AC_DEFUN([CF_MATH_LIB],
3281 [
3282 AC_CACHE_CHECK(if -lm needed for math functions,
3283         cf_cv_need_libm,[
3284         AC_TRY_LINK([
3285         #include <stdio.h>
3286         #include <math.h>
3287         ],
3288         [double x = rand(); printf("result = %g\n", ]ifelse($2,,sin(x),$2)[)],
3289         [cf_cv_need_libm=no],
3290         [cf_cv_need_libm=yes])])
3291 if test "$cf_cv_need_libm" = yes
3292 then
3293 ifelse($1,,[
3294         LIBS="$LIBS -lm"
3295 ],[$1=-lm])
3296 fi
3297 ])
3298 dnl ---------------------------------------------------------------------------
3299 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
3300 dnl ----------------------
3301 dnl Check if the file-system supports mixed-case filenames.  If we're able to
3302 dnl create a lowercase name and see it as uppercase, it doesn't support that.
3303 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
3304 [
3305 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
3306 if test "$cross_compiling" = yes ; then
3307         case $target_alias in #(vi
3308         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
3309                 cf_cv_mixedcase=no
3310                 ;;
3311         *)
3312                 cf_cv_mixedcase=yes
3313                 ;;
3314         esac
3315 else
3316         rm -f conftest CONFTEST
3317         echo test >conftest
3318         if test -f CONFTEST ; then
3319                 cf_cv_mixedcase=no
3320         else
3321                 cf_cv_mixedcase=yes
3322         fi
3323         rm -f conftest CONFTEST
3324 fi
3325 ])
3326 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
3327 ])dnl
3328 dnl ---------------------------------------------------------------------------
3329 dnl CF_MKSTEMP version: 5 updated: 2006/12/16 12:33:30
3330 dnl ----------
3331 dnl Check for a working mkstemp.  This creates two files, checks that they are
3332 dnl successfully created and distinct (AmigaOS apparently fails on the last).
3333 AC_DEFUN([CF_MKSTEMP],[
3334 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
3335 rm -f conftest*
3336 AC_TRY_RUN([
3337 #include <sys/types.h>
3338 #include <stdlib.h>
3339 #include <stdio.h>
3340 #include <string.h>
3341 #include <sys/stat.h>
3342 int main()
3343 {
3344         char *tmpl = "conftestXXXXXX";
3345         char name[2][80];
3346         int n;
3347         int result = 0;
3348         int fd;
3349         struct stat sb;
3350
3351         umask(077);
3352         for (n = 0; n < 2; ++n) {
3353                 strcpy(name[n], tmpl);
3354                 if ((fd = mkstemp(name[n])) >= 0) {
3355                         if (!strcmp(name[n], tmpl)
3356                          || stat(name[n], &sb) != 0
3357                          || (sb.st_mode & S_IFMT) != S_IFREG
3358                          || (sb.st_mode & 077) != 0) {
3359                                 result = 1;
3360                         }
3361                         close(fd);
3362                 }
3363         }
3364         if (result == 0
3365          && !strcmp(name[0], name[1]))
3366                 result = 1;
3367         ${cf_cv_main_return:-return}(result);
3368 }
3369 ],[cf_cv_func_mkstemp=yes
3370 ],[cf_cv_func_mkstemp=no
3371 ],[AC_CHECK_FUNC(mkstemp)
3372 ])
3373 ])
3374 if test "$cf_cv_func_mkstemp" = yes ; then
3375         AC_DEFINE(HAVE_MKSTEMP)
3376 fi
3377 ])dnl
3378 dnl ---------------------------------------------------------------------------
3379 dnl CF_MSG_LOG version: 4 updated: 2007/07/29 09:55:12
3380 dnl ----------
3381 dnl Write a debug message to config.log, along with the line number in the
3382 dnl configure script.
3383 AC_DEFUN([CF_MSG_LOG],[
3384 echo "${as_me-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
3385 ])dnl
3386 dnl ---------------------------------------------------------------------------
3387 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
3388 dnl ----------------
3389 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
3390 dnl warn about this.
3391 AC_DEFUN([CF_NCURSES_ABI_6],[
3392 if test "${with_abi_version+set}" != set; then
3393         case $cf_cv_rel_version in
3394         5.*)
3395                 cf_cv_rel_version=6.0
3396                 cf_cv_abi_version=6
3397                 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
3398                 ;;
3399         esac
3400 fi
3401 ])dnl
3402 dnl ---------------------------------------------------------------------------
3403 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
3404 dnl ------------------
3405 dnl see CF_WITH_NO_LEAKS
3406 AC_DEFUN([CF_NO_LEAKS_OPTION],[
3407 AC_MSG_CHECKING(if you want to use $1 for testing)
3408 AC_ARG_WITH($1,
3409         [$2],
3410         [AC_DEFINE($3)ifelse([$4],,[
3411          $4
3412 ])
3413         : ${with_cflags:=-g}
3414         : ${with_no_leaks:=yes}
3415          with_$1=yes],
3416         [with_$1=])
3417 AC_MSG_RESULT(${with_$1:-no})
3418
3419 case .$with_cflags in #(vi
3420 .*-g*)
3421         case .$CFLAGS in #(vi
3422         .*-g*) #(vi
3423                 ;;
3424         *)
3425                 CF_ADD_CFLAGS([-g])
3426                 ;;
3427         esac
3428         ;;
3429 esac
3430 ])dnl
3431 dnl ---------------------------------------------------------------------------
3432 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
3433 dnl ----------------
3434 dnl Check if the given variable is a number.  If not, report an error.
3435 dnl $1 is the variable
3436 dnl $2 is the message
3437 AC_DEFUN([CF_NUMBER_SYNTAX],[
3438 if test -n "$1" ; then
3439   case $1 in #(vi
3440   [[0-9]]*) #(vi
3441         ;;
3442   *)
3443         AC_MSG_ERROR($2 is not a number: $1)
3444         ;;
3445   esac
3446 else
3447   AC_MSG_ERROR($2 value is empty)
3448 fi
3449 ])dnl
3450 dnl ---------------------------------------------------------------------------
3451 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
3452 dnl -------------
3453 dnl Compute the object-directory name from the given model name
3454 AC_DEFUN([CF_OBJ_SUBDIR],
3455 [
3456         case $1 in
3457         libtool) $2='obj_lo'  ;;
3458         normal)  $2='objects' ;;
3459         debug)   $2='obj_g' ;;
3460         profile) $2='obj_p' ;;
3461         shared)
3462                 case $cf_cv_system_name in #(vi
3463                 cygwin) #(vi
3464                         $2='objects' ;;
3465                 *)
3466                         $2='obj_s' ;;
3467                 esac
3468         esac
3469 ])dnl
3470 dnl ---------------------------------------------------------------------------
3471 dnl CF_PATHSEP version: 3 updated: 2001/01/12 01:23:53
3472 dnl ----------
3473 dnl Provide a value for the $PATH and similar separator
3474 AC_DEFUN([CF_PATHSEP],
3475 [
3476         case $cf_cv_system_name in
3477         os2*)   PATHSEP=';'  ;;
3478         *)      PATHSEP=':'  ;;
3479         esac
3480 ifelse($1,,,[$1=$PATHSEP])
3481         AC_SUBST(PATHSEP)
3482 ])dnl
3483 dnl ---------------------------------------------------------------------------
3484 dnl CF_PATH_SYNTAX version: 12 updated: 2008/03/23 14:45:59
3485 dnl --------------
3486 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
3487 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3488 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
3489 dnl delayed evaluation of those symbols.
3490 AC_DEFUN([CF_PATH_SYNTAX],[
3491 if test "x$prefix" != xNONE; then
3492   cf_path_syntax="$prefix"
3493 else
3494   cf_path_syntax="$ac_default_prefix"
3495 fi
3496
3497 case ".[$]$1" in #(vi
3498 .\[$]\(*\)*|.\'*\'*) #(vi
3499   ;;
3500 ..|./*|.\\*) #(vi
3501   ;;
3502 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
3503   ;;
3504 .\[$]{*prefix}*) #(vi
3505   eval $1="[$]$1"
3506   case ".[$]$1" in #(vi
3507   .NONE/*)
3508     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3509     ;;
3510   esac
3511   ;; #(vi
3512 .no|.NONE/*)
3513   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3514   ;;
3515 *)
3516   ifelse($2,,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3517   ;;
3518 esac
3519 ])dnl
3520 dnl ---------------------------------------------------------------------------
3521 dnl CF_POSIX_C_SOURCE version: 6 updated: 2005/07/14 20:25:10
3522 dnl -----------------
3523 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3524 dnl
3525 dnl     POSIX.1-1990                            _POSIX_SOURCE
3526 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
3527 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
3528 dnl             Bindings Option
3529 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
3530 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
3531 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
3532 dnl
3533 dnl Parameters:
3534 dnl     $1 is the nominal value for _POSIX_C_SOURCE
3535 AC_DEFUN([CF_POSIX_C_SOURCE],
3536 [
3537 cf_POSIX_C_SOURCE=ifelse($1,,199506L,$1)
3538
3539 cf_save_CFLAGS="$CFLAGS"
3540 cf_save_CPPFLAGS="$CPPFLAGS"
3541
3542 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3543 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3544
3545 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3546         CF_MSG_LOG(if the symbol is already defined go no further)
3547         AC_TRY_COMPILE([#include <sys/types.h>],[
3548 #ifndef _POSIX_C_SOURCE
3549 make an error
3550 #endif],
3551         [cf_cv_posix_c_source=no],
3552         [cf_want_posix_source=no
3553          case .$cf_POSIX_C_SOURCE in #(vi
3554          .[[12]]??*) #(vi
3555                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3556                 ;;
3557          .2) #(vi
3558                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3559                 cf_want_posix_source=yes
3560                 ;;
3561          .*)
3562                 cf_want_posix_source=yes
3563                 ;;
3564          esac
3565          if test "$cf_want_posix_source" = yes ; then
3566                 AC_TRY_COMPILE([#include <sys/types.h>],[
3567 #ifdef _POSIX_SOURCE
3568 make an error
3569 #endif],[],
3570                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3571          fi
3572          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3573          CFLAGS="$cf_trim_CFLAGS"
3574          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
3575          CF_MSG_LOG(if the second compile does not leave our definition intact error)
3576          AC_TRY_COMPILE([#include <sys/types.h>],[
3577 #ifndef _POSIX_C_SOURCE
3578 make an error
3579 #endif],,
3580          [cf_cv_posix_c_source=no])
3581          CFLAGS="$cf_save_CFLAGS"
3582          CPPFLAGS="$cf_save_CPPFLAGS"
3583         ])
3584 ])
3585
3586 if test "$cf_cv_posix_c_source" != no ; then
3587         CFLAGS="$cf_trim_CFLAGS"
3588         CPPFLAGS="$cf_trim_CPPFLAGS"
3589         if test "$cf_cv_cc_u_d_options" = yes ; then
3590                 cf_temp_posix_c_source=`echo "$cf_cv_posix_c_source" | \
3591                                 sed -e 's/-D/-U/g' -e 's/=[[^   ]]*//g'`
3592                 CPPFLAGS="$CPPFLAGS $cf_temp_posix_c_source"
3593         fi
3594         CPPFLAGS="$CPPFLAGS $cf_cv_posix_c_source"
3595 fi
3596
3597 ])dnl
3598 dnl ---------------------------------------------------------------------------
3599 dnl CF_PREDEFINE version: 1 updated: 2003/07/26 17:53:56
3600 dnl ------------
3601 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
3602 dnl
3603 dnl $1 = symbol to test
3604 dnl $2 = value (if any) to use for a predefinition
3605 AC_DEFUN([CF_PREDEFINE],
3606 [
3607 AC_MSG_CHECKING(if we must define $1)
3608 AC_TRY_COMPILE([#include <sys/types.h>
3609 ],[
3610 #ifndef $1
3611 make an error
3612 #endif],[cf_result=no],[cf_result=yes])
3613 AC_MSG_RESULT($cf_result)
3614
3615 if test "$cf_result" = yes ; then
3616         CPPFLAGS="$CPPFLAGS ifelse($2,,-D$1,[-D$1=$2])"
3617 elif test "x$2" != "x" ; then
3618         AC_MSG_CHECKING(checking for compatible value versus $2)
3619         AC_TRY_COMPILE([#include <sys/types.h>
3620 ],[
3621 #if $1-$2 < 0
3622 make an error
3623 #endif],[cf_result=yes],[cf_result=no])
3624         AC_MSG_RESULT($cf_result)
3625         if test "$cf_result" = no ; then
3626                 # perhaps we can override it - try...
3627                 CPPFLAGS="$CPPFLAGS -D$1=$2"
3628         fi
3629 fi
3630 ])dnl
3631 dnl ---------------------------------------------------------------------------
3632 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
3633 dnl ------------
3634 dnl Append definitions and rules for the given programs to the subdirectory
3635 dnl Makefiles, and the recursion rule for the top-level Makefile.
3636 dnl
3637 dnl parameters
3638 dnl     $1 = script to run
3639 dnl     $2 = list of subdirectories
3640 dnl
3641 dnl variables
3642 dnl     $AWK
3643 AC_DEFUN([CF_PRG_RULES],
3644 [
3645 for cf_dir in $2
3646 do
3647         if test ! -d $srcdir/$cf_dir; then
3648                 continue
3649         elif test -f $srcdir/$cf_dir/programs; then
3650                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
3651         fi
3652 done
3653
3654 ])dnl
3655 dnl ---------------------------------------------------------------------------
3656 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3657 dnl -----------
3658 dnl Check for awk, ensure that the check found something.
3659 AC_DEFUN([CF_PROG_AWK],
3660 [
3661 AC_PROG_AWK
3662 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3663 ])dnl
3664 dnl ---------------------------------------------------------------------------
3665 dnl CF_PROG_CC_C_O version: 2 updated: 2006/12/16 15:55:46
3666 dnl --------------
3667 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3668 dnl the output file can be renamed, and allows for a shell variable that can
3669 dnl be used later.  The parameter is either CC or CXX.  The result is the
3670 dnl cache variable:
3671 dnl     $cf_cv_prog_CC_c_o
3672 dnl     $cf_cv_prog_CXX_c_o
3673 AC_DEFUN([CF_PROG_CC_C_O],
3674 [AC_REQUIRE([AC_PROG_CC])dnl
3675 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3676 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3677 [
3678 cat > conftest.$ac_ext <<CF_EOF
3679 #include <stdio.h>
3680 int main()
3681 {
3682         ${cf_cv_main_return:-return}(0);
3683 }
3684 CF_EOF
3685 # We do the test twice because some compilers refuse to overwrite an
3686 # existing .o file with -o, though they will create one.
3687 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3688 if AC_TRY_EVAL(ac_try) &&
3689   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3690 then
3691   eval cf_cv_prog_$1_c_o=yes
3692 else
3693   eval cf_cv_prog_$1_c_o=no
3694 fi
3695 rm -f conftest*
3696 ])dnl
3697 if test $cf_cv_prog_$1_c_o = yes; then
3698   AC_MSG_RESULT([yes])
3699 else
3700   AC_MSG_RESULT([no])
3701 fi
3702 ])dnl
3703 dnl ---------------------------------------------------------------------------
3704 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
3705 dnl --------------
3706 dnl Check if C (preprocessor) -U and -D options are processed in the order
3707 dnl given rather than by type of option.  Some compilers insist on apply all
3708 dnl of the -U options after all of the -D options.  Others allow mixing them,
3709 dnl and may predefine symbols that conflict with those we define.
3710 AC_DEFUN([CF_PROG_CC_U_D],
3711 [
3712 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
3713         cf_save_CPPFLAGS="$CPPFLAGS"
3714         CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
3715         AC_TRY_COMPILE([],[
3716 #ifndef U_D_OPTIONS
3717 make an undefined-error
3718 #endif
3719 #ifdef  D_U_OPTIONS
3720 make a defined-error
3721 #endif
3722         ],[
3723         cf_cv_cc_u_d_options=yes],[
3724         cf_cv_cc_u_d_options=no])
3725         CPPFLAGS="$cf_save_CPPFLAGS"
3726 ])
3727 ])dnl
3728 dnl ---------------------------------------------------------------------------
3729 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
3730 dnl -------------
3731 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3732 dnl This macro adds a check to ensure the script found something.
3733 AC_DEFUN([CF_PROG_EGREP],
3734 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3735    [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3736     then ac_cv_prog_egrep='grep -E'
3737     else ac_cv_prog_egrep='egrep'
3738     fi])
3739  EGREP=$ac_cv_prog_egrep
3740  AC_SUBST([EGREP])
3741 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3742 ])dnl
3743 dnl ---------------------------------------------------------------------------
3744 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
3745 dnl -----------
3746 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3747 AC_DEFUN([CF_PROG_EXT],
3748 [
3749 AC_REQUIRE([CF_CHECK_CACHE])
3750 case $cf_cv_system_name in
3751 os2*)
3752     CFLAGS="$CFLAGS -Zmt"
3753     CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
3754     CXXFLAGS="$CXXFLAGS -Zmt"
3755     # autoconf's macro sets -Zexe and suffix both, which conflict:w
3756     LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
3757     ac_cv_exeext=.exe
3758     ;;
3759 esac
3760
3761 AC_EXEEXT
3762 AC_OBJEXT
3763
3764 PROG_EXT="$EXEEXT"
3765 AC_SUBST(PROG_EXT)
3766 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
3767 ])dnl
3768 dnl ---------------------------------------------------------------------------
3769 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
3770 dnl ---------------
3771 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
3772 dnl misc/tabset install won't work properly.  Usually this happens only when
3773 dnl using the fallback mkinstalldirs script
3774 AC_DEFUN([CF_PROG_INSTALL],
3775 [AC_PROG_INSTALL
3776 case $INSTALL in
3777 /*)
3778   ;;
3779 *)
3780   CF_DIRNAME(cf_dir,$INSTALL)
3781   test -z "$cf_dir" && cf_dir=.
3782   INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
3783   ;;
3784 esac
3785 ])dnl
3786 dnl ---------------------------------------------------------------------------
3787 dnl CF_PROG_LDCONFIG version: 1 updated: 2003/09/20 17:07:55
3788 dnl ----------------
3789 dnl Check for ldconfig, needed to fixup shared libraries that would be built
3790 dnl and then used in the install.
3791 AC_DEFUN([CF_PROG_LDCONFIG],[
3792 if test "$cross_compiling" = yes ; then
3793   LDCONFIG=:
3794 else
3795 case "$cf_cv_system_name" in #(vi
3796 freebsd*) #(vi
3797   test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
3798   ;;
3799 *) LDPATH=$PATH:/sbin:/usr/sbin
3800   AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
3801   ;;
3802 esac
3803 fi
3804 AC_SUBST(LDCONFIG)