faba48922c24ca08b3320579fcab6854f4f349df
[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.447 2008/04/12 23:49:55 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: 22 updated: 2007/07/29 09:55:12
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                                 3.3*)
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: 7 updated: 2007/12/01 15:01:37
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: 2 updated: 2007/04/28 15:25:27
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         LDFLAGS_STATIC=-static
1962         LDFLAGS_SHARED=-dynamic
1963 else
1964         case $cf_cv_system_name in #(
1965         aix[[45]]*)     #( from ld manpage
1966                 LDFLAGS_STATIC=-bstatic
1967                 LDFLAGS_SHARED=-bdynamic
1968                 ;;
1969         hpux*)          #( from ld manpage for hpux10.20, hpux11.11
1970                 # We could also use just "archive" and "shared".
1971                 LDFLAGS_STATIC=-Wl,-a,archive_shared
1972                 LDFLAGS_SHARED=-Wl,-a,shared_archive
1973                 ;;
1974         irix*)          #( from ld manpage IRIX64
1975                 LDFLAGS_STATIC=-Bstatic
1976                 LDFLAGS_SHARED=-Bdynamic
1977                 ;;
1978         osf[[45]]*)     #( from ld manpage osf4.0d, osf5.1
1979                 # alternative "-oldstyle_liblookup" (not in cc manpage)
1980                 LDFLAGS_STATIC=-noso 
1981                 LDFLAGS_SHARED=-so_archive
1982                 ;;
1983         solaris2*)
1984                 LDFLAGS_STATIC=-Bstatic
1985                 LDFLAGS_SHARED=-Bdynamic
1986                 ;;
1987         esac
1988 fi
1989
1990 AC_SUBST(LDFLAGS_STATIC)
1991 AC_SUBST(LDFLAGS_SHARED)
1992 ])
1993 dnl ---------------------------------------------------------------------------
1994 dnl CF_LIBUTF8 version: 2 updated: 2002/01/19 22:51:32
1995 dnl ----------
1996 dnl Check for libutf8
1997 AC_DEFUN([CF_LIBUTF8],
1998 [
1999 AC_CACHE_CHECK(for putwc in libutf8,cf_cv_libutf8,[
2000         cf_save_LIBS="$LIBS"
2001         LIBS="-lutf8 $LIBS"
2002 AC_TRY_LINK([
2003 #include <libutf8.h>],[putwc(0,0);],
2004         [cf_cv_libutf8=yes],
2005         [cf_cv_libutf8=no])
2006         LIBS="$cf_save_LIBS"
2007 ])
2008
2009 if test "$cf_cv_libutf8" = yes ; then
2010         AC_DEFINE(HAVE_LIBUTF8_H)
2011         LIBS="-lutf8 $LIBS"
2012 fi
2013 ])dnl
2014 dnl ---------------------------------------------------------------------------
2015 dnl CF_LIB_PREFIX version: 7 updated: 2001/01/12 01:23:48
2016 dnl -------------
2017 dnl Compute the library-prefix for the given host system
2018 dnl $1 = variable to set
2019 AC_DEFUN([CF_LIB_PREFIX],
2020 [
2021         case $cf_cv_system_name in
2022         OS/2*)  LIB_PREFIX=''     ;;
2023         os2*)   LIB_PREFIX=''     ;;
2024         *)      LIB_PREFIX='lib'  ;;
2025         esac
2026 ifelse($1,,,[$1=$LIB_PREFIX])
2027         AC_SUBST(LIB_PREFIX)
2028 ])dnl
2029 dnl ---------------------------------------------------------------------------
2030 dnl CF_LIB_RULES version: 50 updated: 2007/03/24 18:26:59
2031 dnl ------------
2032 dnl Append definitions and rules for the given models to the subdirectory
2033 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
2034 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
2035 dnl the corresponding makefile to list the models that we'll generate.
2036 dnl
2037 dnl For shared libraries, make a list of symbolic links to construct when
2038 dnl generating each library.  The convention used for Linux is the simplest
2039 dnl one:
2040 dnl     lib<name>.so    ->
2041 dnl     lib<name>.so.<major>    ->
2042 dnl     lib<name>.so.<maj>.<minor>
2043 AC_DEFUN([CF_LIB_RULES],
2044 [
2045 CF_LIB_PREFIX(cf_prefix)
2046 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2047 for cf_dir in $SRC_SUBDIRS
2048 do
2049         if test ! -d $srcdir/$cf_dir ; then
2050                 continue
2051         elif test -f $srcdir/$cf_dir/modules; then
2052
2053                 SHARED_LIB=
2054                 LIBS_TO_MAKE=
2055                 for cf_item in $cf_LIST_MODELS
2056                 do
2057                         CF_LIB_SUFFIX($cf_item,cf_suffix)
2058                         if test $cf_item = shared ; then
2059                         if test "$cf_cv_do_symlinks" = yes ; then
2060                                 case "$cf_cv_shlib_version" in #(vi
2061                                 rel) #(vi
2062                                         case "$cf_cv_system_name" in #(vi
2063                                         darwin*)
2064                                         case .${LIB_SUFFIX} in
2065                                         .w*)
2066                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2067                                                 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
2068                                                 ;;
2069                                         *)
2070                                                 cf_suffix='.${REL_VERSION}'"$cf_suffix"
2071                                                 ;;
2072                                         esac
2073                                         ;; #(vi
2074                                         *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
2075                                         esac
2076                                         ;;
2077                                 abi)
2078                                         case "$cf_cv_system_name" in #(vi
2079                                         darwin*)
2080                                         case .${LIB_SUFFIX} in
2081                                         .w*)
2082                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2083                                                 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
2084                                                 ;;
2085                                         *)
2086                                                 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
2087                                                 ;;
2088                                         esac
2089                                         ;; #(vi
2090                                         *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
2091                                         esac
2092                                         ;;
2093                                 esac
2094                         fi
2095                         # cygwin needs import library, and has unique naming convention
2096                         # use autodetected ${cf_prefix} for import lib and static lib, but
2097                         # use 'cyg' prefix for shared lib.
2098                         if test $cf_cv_shlib_version = cygdll ; then
2099                                 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}\${ABI_VERSION}.dll"
2100                                 continue
2101                         fi
2102                         fi
2103                         LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
2104                 done
2105
2106                 if test $cf_dir = ncurses ; then
2107                         cf_subsets="$LIB_SUBSETS"
2108                         cf_r_parts="$cf_subsets"
2109
2110                         while test -n "$cf_r_parts"
2111                         do
2112                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
2113                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
2114                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
2115                                         case $cf_l_parts in #(vi
2116                                         *termlib*) #(vi
2117                                                 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
2118                                                 ;;
2119                                         *ticlib*)
2120                                                 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
2121                                                 ;;
2122                                         *)
2123                                                 break
2124                                                 ;;
2125                                         esac
2126                                         LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
2127                                 else
2128                                         break
2129                                 fi
2130                         done
2131                 else
2132                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
2133                 fi
2134
2135                 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
2136                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
2137                         $cf_dir/Makefile >$cf_dir/Makefile.out
2138                 mv $cf_dir/Makefile.out $cf_dir/Makefile
2139
2140                 $AWK -f $srcdir/mk-0th.awk \
2141                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
2142                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2143
2144                 for cf_subset in $cf_subsets
2145                 do
2146                         cf_subdirs=
2147                         for cf_item in $cf_LIST_MODELS
2148                         do
2149                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
2150                         CF_UPPER(cf_ITEM,$cf_item)
2151                         CF_LIB_SUFFIX($cf_item,cf_suffix)
2152                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
2153
2154                         # Test for case where we build libtinfo with a different name.
2155                         cf_libname=$cf_dir
2156                         if test $cf_dir = ncurses ; then
2157                                 case $cf_subset in
2158                                 *base*)
2159                                         ;;
2160                                 *termlib*)
2161                                         cf_libname=$TINFO_LIB_SUFFIX
2162                                         if test -n "${DFT_ARG_SUFFIX}" ; then
2163                                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2164                                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2165                                         fi
2166                                         ;;
2167                                 ticlib*)
2168                                         cf_libname=$TICS_LIB_SUFFIX
2169                                         if test -n "${DFT_ARG_SUFFIX}" ; then
2170                                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2171                                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2172                                         fi
2173                                         ;;
2174                                 esac
2175                         fi
2176
2177                         # These dependencies really are for development, not
2178                         # builds, but they are useful in porting, too.
2179                         cf_depend="../include/ncurses_cfg.h"
2180                         if test "$srcdir" = "."; then
2181                                 cf_reldir="."
2182                         else
2183                                 cf_reldir="\${srcdir}"
2184                         fi
2185
2186                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
2187                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
2188                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
2189                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
2190                         fi
2191
2192                         cf_dir_suffix=
2193                         old_cf_suffix="$cf_suffix"
2194                         if test "$cf_cv_shlib_version_infix" = yes ; then
2195                         if test -n "$LIB_SUFFIX" ; then
2196                                 case $LIB_SUFFIX in
2197                                 w*)
2198                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
2199                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2200                                         cf_dir_suffix=w
2201                                         ;;
2202                                 esac
2203                         fi
2204                         fi
2205
2206                         $AWK -f $srcdir/mk-1st.awk \
2207                                 name=${cf_libname}${cf_dir_suffix} \
2208                                 traces=$LIB_TRACING \
2209                                 MODEL=$cf_ITEM \
2210                                 model=$cf_subdir \
2211                                 prefix=$cf_prefix \
2212                                 suffix=$cf_suffix \
2213                                 subset=$cf_subset \
2214                                 TermlibRoot=$TINFO_NAME \
2215                                 TermlibSuffix=$TINFO_SUFFIX \
2216                                 ShlibVer=$cf_cv_shlib_version \
2217                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
2218                                 ReLink=${cf_cv_do_relink-no} \
2219                                 DoLinks=$cf_cv_do_symlinks \
2220                                 rmSoLocs=$cf_cv_rm_so_locs \
2221                                 ldconfig="$LDCONFIG" \
2222                                 overwrite=$WITH_OVERWRITE \
2223                                 depend="$cf_depend" \
2224                                 host="$host" \
2225                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2226
2227                         cf_suffix="$old_cf_suffix"
2228
2229                         for cf_subdir2 in $cf_subdirs lib
2230                         do
2231                                 test $cf_subdir = $cf_subdir2 && break
2232                         done
2233                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
2234                         $AWK -f $srcdir/mk-2nd.awk \
2235                                 name=$cf_dir \
2236                                 traces=$LIB_TRACING \
2237                                 MODEL=$cf_ITEM \
2238                                 model=$cf_subdir \
2239                                 subset=$cf_subset \
2240                                 srcdir=$srcdir \
2241                                 echo=$WITH_ECHO \
2242                                 crenames=$cf_cv_prog_CC_c_o \
2243                                 cxxrenames=$cf_cv_prog_CXX_c_o \
2244                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2245                         cf_subdirs="$cf_subdirs $cf_subdir"
2246                         done
2247                 done
2248         fi
2249
2250         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
2251 done
2252
2253 for cf_dir in $SRC_SUBDIRS
2254 do
2255         if test ! -d $srcdir/$cf_dir ; then
2256                 continue
2257         fi
2258
2259         if test -f $cf_dir/Makefile ; then
2260                 case "$cf_dir" in
2261                 Ada95) #(vi
2262                         echo 'libs \' >> Makefile
2263                         echo 'install.libs \' >> Makefile
2264                         echo 'uninstall.libs ::' >> Makefile
2265                         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
2266                         ;;
2267                 esac
2268         fi
2269
2270         if test -f $srcdir/$cf_dir/modules; then
2271                 echo >> Makefile
2272                 if test -f $srcdir/$cf_dir/headers; then
2273 cat >> Makefile <<CF_EOF
2274 install.includes \\
2275 uninstall.includes \\
2276 CF_EOF
2277                 fi
2278 if test "$cf_dir" != "c++" ; then
2279 echo 'lint \' >> Makefile
2280 fi
2281 cat >> Makefile <<CF_EOF
2282 libs \\
2283 lintlib \\
2284 install.libs \\
2285 uninstall.libs \\
2286 install.$cf_dir \\
2287 uninstall.$cf_dir ::
2288         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2289 CF_EOF
2290         elif test -f $srcdir/$cf_dir/headers; then
2291 cat >> Makefile <<CF_EOF
2292
2293 libs \\
2294 install.libs \\
2295 uninstall.libs \\
2296 install.includes \\
2297 uninstall.includes ::
2298         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2299 CF_EOF
2300 fi
2301 done
2302
2303 cat >> Makefile <<CF_EOF
2304
2305 install.libs uninstall.libs \\
2306 install.data uninstall.data ::
2307 $MAKE_TERMINFO  cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
2308
2309 install.man \\
2310 uninstall.man ::
2311         cd man && \${MAKE} \${CF_MFLAGS} \[$]@
2312
2313 distclean ::
2314         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
2315         rm -f headers.sh headers.sed mk_shared_lib.sh
2316         rm -rf \${DIRS_TO_MAKE}
2317 CF_EOF
2318
2319 # Special case: tack's manpage lives in its own directory.
2320 if test -d tack ; then
2321 if test -f $srcdir/$tack.h; then
2322 cat >> Makefile <<CF_EOF
2323
2324 install.man \\
2325 uninstall.man ::
2326         cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
2327 CF_EOF
2328 fi
2329 fi
2330
2331 dnl If we're installing into a subdirectory of /usr/include, etc., we should
2332 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
2333 dnl anything, and will make it more standardized.  It's awkward to decide this
2334 dnl at configuration because of quoting, so we'll simply make all headers
2335 dnl installed via a script that can do the right thing.
2336
2337 rm -f headers.sed headers.sh
2338
2339 dnl ( generating this script makes the makefiles a little tidier :-)
2340 echo creating headers.sh
2341 cat >headers.sh <<CF_EOF
2342 #! /bin/sh
2343 # This shell script is generated by the 'configure' script.  It is invoked in a
2344 # subdirectory of the build tree.  It generates a sed-script in the parent
2345 # directory that is used to adjust includes for header files that reside in a
2346 # subdirectory of /usr/include, etc.
2347 PRG=""
2348 while test \[$]# != 3
2349 do
2350 PRG="\$PRG \[$]1"; shift
2351 done
2352 DST=\[$]1
2353 REF=\[$]2
2354 SRC=\[$]3
2355 TMPSRC=\${TMPDIR-/tmp}/\`basename \$SRC\`\$\$
2356 TMPSED=\${TMPDIR-/tmp}/headers.sed\$\$
2357 echo installing \$SRC in \$DST
2358 CF_EOF
2359
2360 if test $WITH_CURSES_H = yes; then
2361         cat >>headers.sh <<CF_EOF
2362 case \$DST in
2363 /*/include/*)
2364         END=\`basename \$DST\`
2365         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2366         do
2367                 NAME=\`basename \$i\`
2368                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2369         done
2370         ;;
2371 *)
2372         echo "" >> \$TMPSED
2373         ;;
2374 esac
2375 CF_EOF
2376
2377 else
2378         cat >>headers.sh <<CF_EOF
2379 case \$DST in
2380 /*/include/*)
2381         END=\`basename \$DST\`
2382         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2383         do
2384                 NAME=\`basename \$i\`
2385                 if test "\$NAME" = "curses.h"
2386                 then
2387                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2388                         NAME=ncurses.h
2389                 fi
2390                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2391         done
2392         ;;
2393 *)
2394         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2395         ;;
2396 esac
2397 CF_EOF
2398 fi
2399 cat >>headers.sh <<CF_EOF
2400 rm -f \$TMPSRC
2401 sed -f \$TMPSED \$SRC > \$TMPSRC
2402 NAME=\`basename \$SRC\`
2403 CF_EOF
2404 if test $WITH_CURSES_H != yes; then
2405         cat >>headers.sh <<CF_EOF
2406 test "\$NAME" = "curses.h" && NAME=ncurses.h
2407 CF_EOF
2408 fi
2409 cat >>headers.sh <<CF_EOF
2410 # Just in case someone gzip'd manpages, remove the conflicting copy.
2411 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
2412
2413 eval \$PRG \$TMPSRC \$DST/\$NAME
2414 rm -f \$TMPSRC \$TMPSED
2415 CF_EOF
2416
2417 chmod 0755 headers.sh
2418
2419 for cf_dir in $SRC_SUBDIRS
2420 do
2421         if test ! -d $srcdir/$cf_dir ; then
2422                 continue
2423         fi
2424
2425         if test -f $srcdir/$cf_dir/headers; then
2426                 $AWK -f $srcdir/mk-hdr.awk \
2427                         subset="$LIB_SUBSETS" \
2428                         compat="$WITH_CURSES_H" \
2429                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
2430         fi
2431
2432         if test -f $srcdir/$cf_dir/modules; then
2433                 if test "$cf_dir" != "c++" ; then
2434                         cat >>$cf_dir/Makefile <<"CF_EOF"
2435 depend : ${AUTO_SRC}
2436         makedepend -- ${CPPFLAGS} -- ${C_SRC}
2437
2438 # DO NOT DELETE THIS LINE -- make depend depends on it.
2439 CF_EOF
2440                 fi
2441         fi
2442 done
2443
2444 ])dnl
2445 dnl ---------------------------------------------------------------------------
2446 dnl CF_LIB_SONAME version: 3 updated: 2006/12/16 15:55:46
2447 dnl -------------
2448 dnl Find the and soname for the given shared library.  Set the cache variable
2449 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
2450 dnl variable to "unknown".
2451 dnl
2452 dnl $1 = headers
2453 dnl $2 = code
2454 dnl $3 = library name
2455 AC_DEFUN([CF_LIB_SONAME],
2456 [
2457 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
2458
2459 cf_cv_$3_soname=unknown
2460 if test "$cross_compiling" != yes ; then
2461 cat >conftest.$ac_ext <<CF_EOF
2462 $1
2463 int main()
2464 {
2465 $2
2466         ${cf_cv_main_return:-return}(0);
2467 }
2468 CF_EOF
2469 cf_save_LIBS="$LIBS"
2470         LIBS="-l$3 $LIBS"
2471         if AC_TRY_EVAL(ac_compile) ; then
2472                 if AC_TRY_EVAL(ac_link) ; then
2473                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
2474                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
2475                 fi
2476         fi
2477 rm -f conftest*
2478 LIBS="$cf_save_LIBS"
2479 fi
2480 ])
2481 ])
2482 dnl ---------------------------------------------------------------------------
2483 dnl CF_LIB_SUFFIX version: 13 updated: 2003/11/01 16:09:07
2484 dnl -------------
2485 dnl Compute the library file-suffix from the given model name
2486 dnl $1 = model name
2487 dnl $2 = variable to set
2488 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2489 AC_DEFUN([CF_LIB_SUFFIX],
2490 [
2491         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2492         case $1 in
2493         libtool) $2='.la'  ;;
2494         normal)  $2='.a'   ;;
2495         debug)   $2='_g.a' ;;
2496         profile) $2='_p.a' ;;
2497         shared)
2498                 case $cf_cv_system_name in
2499                 cygwin*) $2='.dll' ;;
2500                 darwin*) $2='.dylib' ;;
2501                 hpux*)
2502                         case $target in
2503                         ia64*)  $2='.so' ;;
2504                         *)      $2='.sl' ;;
2505                         esac
2506                         ;;
2507                 *)      $2='.so'  ;;
2508                 esac
2509         esac
2510         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2511 ])dnl
2512 dnl ---------------------------------------------------------------------------
2513 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
2514 dnl -----------
2515 dnl Compute the string to append to -library from the given model name
2516 dnl $1 = model name
2517 dnl $2 = variable to set
2518 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2519 AC_DEFUN([CF_LIB_TYPE],
2520 [
2521         case $1 in
2522         libtool) $2=''   ;;
2523         normal)  $2=''   ;;
2524         debug)   $2='_g' ;;
2525         profile) $2='_p' ;;
2526         shared)  $2=''   ;;
2527         esac
2528         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2529 ])dnl
2530 dnl ---------------------------------------------------------------------------
2531 dnl CF_LINK_DATAONLY version: 8 updated: 2006/12/16 12:33:30
2532 dnl ----------------
2533 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2534 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
2535 dnl have to provide wrappers for global tables to ensure they're linked
2536 dnl properly.
2537 AC_DEFUN([CF_LINK_DATAONLY],
2538 [
2539 AC_MSG_CHECKING([if data-only library module links])
2540 AC_CACHE_VAL(cf_cv_link_dataonly,[
2541         rm -f conftest.a
2542         cat >conftest.$ac_ext <<EOF
2543 #line __oline__ "configure"
2544 int     testdata[[3]] = { 123, 456, 789 };
2545 EOF
2546         if AC_TRY_EVAL(ac_compile) ; then
2547                 mv conftest.o data.o && \
2548                 ( $AR $AR_OPTS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2549         fi
2550         rm -f conftest.$ac_ext data.o
2551         cat >conftest.$ac_ext <<EOF
2552 #line __oline__ "configure"
2553 int     testfunc()
2554 {
2555 #if defined(NeXT)
2556         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
2557 #else
2558         extern int testdata[[3]];
2559         return testdata[[0]] == 123
2560            &&  testdata[[1]] == 456
2561            &&  testdata[[2]] == 789;
2562 #endif
2563 }
2564 EOF
2565         if AC_TRY_EVAL(ac_compile); then
2566                 mv conftest.o func.o && \
2567                 ( $AR $AR_OPTS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2568         fi
2569         rm -f conftest.$ac_ext func.o
2570         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2571         cf_saveLIBS="$LIBS"
2572         LIBS="conftest.a $LIBS"
2573         AC_TRY_RUN([
2574         int main()
2575         {
2576                 extern int testfunc();
2577                 ${cf_cv_main_return:-return} (!testfunc());
2578         }
2579         ],
2580         [cf_cv_link_dataonly=yes],
2581         [cf_cv_link_dataonly=no],
2582         [cf_cv_link_dataonly=unknown])
2583         LIBS="$cf_saveLIBS"
2584         ])
2585 AC_MSG_RESULT($cf_cv_link_dataonly)
2586
2587 if test "$cf_cv_link_dataonly" = no ; then
2588         AC_DEFINE(BROKEN_LINKER)
2589         BROKEN_LINKER=1
2590 fi
2591
2592 ])dnl
2593 dnl ---------------------------------------------------------------------------
2594 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
2595 dnl -------------
2596 dnl Most Unix systems have both link and symlink, a few don't have symlink.
2597 dnl A few non-Unix systems implement symlink, but not link.
2598 dnl A few non-systems implement neither (or have nonfunctional versions).
2599 AC_DEFUN([CF_LINK_FUNCS],
2600 [
2601 AC_CHECK_FUNCS( \
2602         remove \
2603         unlink )
2604
2605 if test "$cross_compiling" = yes ; then
2606         AC_CHECK_FUNCS( \
2607                 link \
2608                 symlink )
2609 else
2610         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
2611                 cf_cv_link_funcs=
2612                 for cf_func in link symlink ; do
2613                         AC_TRY_RUN([
2614 #include <sys/types.h>
2615 #include <sys/stat.h>
2616 #ifdef HAVE_UNISTD_H
2617 #include <unistd.h>
2618 #endif
2619 int main()
2620 {
2621         int fail = 0;
2622         char *src = "config.log";
2623         char *dst = "conftest.chk";
2624         struct stat src_sb;
2625         struct stat dst_sb;
2626
2627         stat(src, &src_sb);
2628         fail = ($cf_func("config.log", "conftest.chk") < 0)
2629             || (stat(dst, &dst_sb) < 0)
2630             || (dst_sb.st_mtime != src_sb.st_mtime);
2631 #ifdef HAVE_UNLINK
2632         unlink(dst);
2633 #else
2634         remove(dst);
2635 #endif
2636         ${cf_cv_main_return:-return} (fail);
2637 }
2638                         ],[
2639                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
2640                         eval 'ac_cv_func_'$cf_func'=yes'],[
2641                         eval 'ac_cv_func_'$cf_func'=no'],[
2642                         eval 'ac_cv_func_'$cf_func'=error'])
2643                 done
2644                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
2645         ])
2646         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
2647         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
2648 fi
2649 ])dnl
2650 dnl ---------------------------------------------------------------------------
2651 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
2652 dnl --------------
2653 dnl Check if a return from main to the shell actually returns the same exit
2654 dnl code.  This is true for almost any POSIX environment.
2655 dnl
2656 dnl Some very old environments did not flush stdout, etc., on an exit.  That
2657 dnl would be a useful case to test for also.
2658 AC_DEFUN([CF_MAIN_RETURN],
2659 [
2660 cf_cv_main_return=return
2661 ])dnl
2662 dnl ---------------------------------------------------------------------------
2663 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
2664 dnl ------------
2665 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2666 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
2667 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2668 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2669 AC_DEFUN([CF_MAKEFLAGS],
2670 [
2671 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2672         cf_cv_makeflags=''
2673         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2674         do
2675                 cat >cf_makeflags.tmp <<CF_EOF
2676 SHELL = /bin/sh
2677 all :
2678         @ echo '.$cf_option'
2679 CF_EOF
2680                 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[       ]]*$,,'`
2681                 case "$cf_result" in
2682                 .*k)
2683                         cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
2684                         case "$cf_result" in
2685                         .*CC=*) cf_cv_makeflags=
2686                                 ;;
2687                         *)      cf_cv_makeflags=$cf_option
2688                                 ;;
2689                         esac
2690                         break
2691                         ;;
2692                 .-)     ;;
2693                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
2694                         ;;
2695                 esac
2696         done
2697         rm -f cf_makeflags.tmp
2698 ])
2699
2700 AC_SUBST(cf_cv_makeflags)
2701 ])dnl
2702 dnl ---------------------------------------------------------------------------
2703 dnl CF_MAKE_TAGS version: 2 updated: 2000/10/04 09:18:40
2704 dnl ------------
2705 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
2706 dnl a monocase filesystem.
2707 AC_DEFUN([CF_MAKE_TAGS],[
2708 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2709 AC_CHECK_PROG(MAKE_LOWER_TAGS, ctags, yes, no)
2710
2711 if test "$cf_cv_mixedcase" = yes ; then
2712         AC_CHECK_PROG(MAKE_UPPER_TAGS, etags, yes, no)
2713 else
2714         MAKE_UPPER_TAGS=no
2715 fi
2716
2717 if test "$MAKE_UPPER_TAGS" = yes ; then
2718         MAKE_UPPER_TAGS=
2719 else
2720         MAKE_UPPER_TAGS="#"
2721 fi
2722 AC_SUBST(MAKE_UPPER_TAGS)
2723
2724 if test "$MAKE_LOWER_TAGS" = yes ; then
2725         MAKE_LOWER_TAGS=
2726 else
2727         MAKE_LOWER_TAGS="#"
2728 fi
2729 AC_SUBST(MAKE_LOWER_TAGS)
2730 ])dnl
2731 dnl ---------------------------------------------------------------------------
2732 dnl CF_MANPAGE_FORMAT version: 7 updated: 2003/12/20 19:30:34
2733 dnl -----------------
2734 dnl Option to allow user to override automatic configuration of manpage format.
2735 dnl There are several special cases:
2736 dnl
2737 dnl     gzip - man checks for, can display gzip'd files
2738 dnl     compress - man checks for, can display compressed files
2739 dnl     BSDI - files in the cat-directories are suffixed ".0"
2740 dnl     formatted - installer should format (put files in cat-directory)
2741 dnl     catonly - installer should only format, e.g., for a turnkey system.
2742 dnl
2743 dnl There are other configurations which this macro does not test, e.g., HPUX's
2744 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
2745 dnl convention would not match our use).
2746 AC_DEFUN([CF_MANPAGE_FORMAT],
2747 [
2748 AC_REQUIRE([CF_PATHSEP])
2749 AC_MSG_CHECKING(format of man-pages)
2750
2751 AC_ARG_WITH(manpage-format,
2752         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
2753                           optionally formatted/catonly, e.g., gzip,formatted],
2754         [MANPAGE_FORMAT=$withval],
2755         [MANPAGE_FORMAT=unknown])
2756
2757 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
2758 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
2759
2760 cf_unknown=
2761
2762 case $MANPAGE_FORMAT in
2763 unknown)
2764   if test -z "$MANPATH" ; then
2765     MANPATH="/usr/man:/usr/share/man"
2766   fi
2767
2768   # look for the 'date' man-page (it's most likely to be installed!)
2769   MANPAGE_FORMAT=
2770   cf_preform=no
2771   cf_catonly=yes
2772   cf_example=date
2773
2774   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATHSEP}"
2775   for cf_dir in $MANPATH; do
2776     test -z "$cf_dir" && cf_dir=/usr/man
2777     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
2778     do
2779       cf_test=`echo $cf_name | sed -e 's/*//'`
2780       if test "x$cf_test" = "x$cf_name" ; then
2781
2782         case "$cf_name" in
2783         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
2784         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
2785         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
2786         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
2787         esac
2788
2789         case "$cf_name" in
2790         $cf_dir/man*)
2791           cf_catonly=no
2792           ;;
2793         $cf_dir/cat*)
2794           cf_preform=yes
2795           ;;
2796         esac
2797         break
2798       fi
2799
2800       # if we found a match in either man* or cat*, stop looking
2801       if test -n "$MANPAGE_FORMAT" ; then
2802         cf_found=no
2803         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
2804         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
2805         case "$cf_name" in
2806         $cf_dir/cat*)
2807           cf_found=yes
2808           ;;
2809         esac
2810         test $cf_found=yes && break
2811       fi
2812     done
2813     # only check the first directory in $MANPATH where we find manpages
2814     if test -n "$MANPAGE_FORMAT" ; then
2815        break
2816     fi
2817   done
2818   # if we did not find the example, just assume it is normal
2819   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
2820   IFS="$ac_save_ifs"
2821   ;;
2822 *)
2823   for cf_option in $MANPAGE_FORMAT; do
2824      case $cf_option in #(vi
2825      gzip|compress|BSDI|normal|formatted|catonly)
2826        ;;
2827      *)
2828        cf_unknown="$cf_unknown $cf_option"
2829        ;;
2830      esac
2831   done
2832   ;;
2833 esac
2834
2835 AC_MSG_RESULT($MANPAGE_FORMAT)
2836 if test -n "$cf_unknown" ; then
2837   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
2838 fi
2839 ])dnl
2840 dnl ---------------------------------------------------------------------------
2841 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
2842 dnl ------------------
2843 dnl The Debian people have their own naming convention for manpages.  This
2844 dnl option lets us override the name of the file containing renaming, or
2845 dnl disable it altogether.
2846 AC_DEFUN([CF_MANPAGE_RENAMES],
2847 [
2848 AC_MSG_CHECKING(for manpage renaming)
2849
2850 AC_ARG_WITH(manpage-renames,
2851         [  --with-manpage-renames  specify manpage-renaming],
2852         [MANPAGE_RENAMES=$withval],
2853         [MANPAGE_RENAMES=yes])
2854
2855 case ".$MANPAGE_RENAMES" in #(vi
2856 .no) #(vi
2857   ;;
2858 .|.yes)
2859   # Debian 'man' program?
2860   if test -f /etc/debian_version ; then
2861     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
2862   else
2863     MANPAGE_RENAMES=no
2864   fi
2865   ;;
2866 esac
2867
2868 if test "$MANPAGE_RENAMES" != no ; then
2869   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
2870     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
2871   elif test ! -f $MANPAGE_RENAMES ; then
2872     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
2873   fi
2874
2875   test ! -d man && mkdir man
2876
2877   # Construct a sed-script to perform renaming within man-pages
2878   if test -n "$MANPAGE_RENAMES" ; then
2879     test ! -d man && mkdir man
2880     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
2881   fi
2882 fi
2883
2884 AC_MSG_RESULT($MANPAGE_RENAMES)
2885 AC_SUBST(MANPAGE_RENAMES)
2886 ])dnl
2887 dnl ---------------------------------------------------------------------------
2888 dnl CF_MANPAGE_SYMLINKS version: 4 updated: 2003/12/13 18:01:58
2889 dnl -------------------
2890 dnl Some people expect each tool to make all aliases for manpages in the
2891 dnl man-directory.  This accommodates the older, less-capable implementations
2892 dnl of 'man', and is optional.
2893 AC_DEFUN([CF_MANPAGE_SYMLINKS],
2894 [
2895 AC_MSG_CHECKING(if manpage aliases will be installed)
2896
2897 AC_ARG_WITH(manpage-aliases,
2898         [  --with-manpage-aliases  specify manpage-aliases using .so],
2899         [MANPAGE_ALIASES=$withval],
2900         [MANPAGE_ALIASES=yes])
2901
2902 AC_MSG_RESULT($MANPAGE_ALIASES)
2903
2904 if test "$LN_S" = "ln -s"; then
2905         cf_use_symlinks=yes
2906 else
2907         cf_use_symlinks=no
2908 fi
2909
2910 MANPAGE_SYMLINKS=no
2911 if test "$MANPAGE_ALIASES" = yes ; then
2912 AC_MSG_CHECKING(if manpage symlinks should be used)
2913
2914 AC_ARG_WITH(manpage-symlinks,
2915         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
2916         [MANPAGE_SYMLINKS=$withval],
2917         [MANPAGE_SYMLINKS=$cf_use_symlinks])
2918
2919 if test "$$cf_use_symlinks" = no; then
2920 if test "$MANPAGE_SYMLINKS" = yes ; then
2921         AC_MSG_WARN(cannot make symlinks, will use .so files)
2922         MANPAGE_SYMLINKS=no
2923 fi
2924 fi
2925
2926 AC_MSG_RESULT($MANPAGE_SYMLINKS)
2927 fi
2928
2929 ])dnl
2930 dnl ---------------------------------------------------------------------------
2931 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
2932 dnl --------------
2933 dnl This option causes manpages to be run through tbl(1) to generate tables
2934 dnl correctly.
2935 AC_DEFUN([CF_MANPAGE_TBL],
2936 [
2937 AC_MSG_CHECKING(for manpage tbl)
2938
2939 AC_ARG_WITH(manpage-tbl,
2940         [  --with-manpage-tbl      specify manpage processing with tbl],
2941         [MANPAGE_TBL=$withval],
2942         [MANPAGE_TBL=no])
2943
2944 AC_MSG_RESULT($MANPAGE_TBL)
2945 ])dnl
2946 dnl ---------------------------------------------------------------------------
2947 dnl CF_MAN_PAGES version: 35 updated: 2007/03/31 11:47:29
2948 dnl ------------
2949 dnl Try to determine if the man-pages on the system are compressed, and if
2950 dnl so, what format is used.  Use this information to construct a script that
2951 dnl will install man-pages.
2952 AC_DEFUN([CF_MAN_PAGES],
2953 [
2954 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
2955 CF_MANPAGE_FORMAT
2956 CF_MANPAGE_RENAMES
2957 CF_MANPAGE_SYMLINKS
2958 CF_MANPAGE_TBL
2959
2960   if test "$prefix" = "NONE" ; then
2961      cf_prefix="$ac_default_prefix"
2962   else
2963      cf_prefix="$prefix"
2964   fi
2965
2966   case "$MANPAGE_FORMAT" in # (vi
2967   *catonly*) # (vi
2968     cf_format=yes
2969     cf_inboth=no
2970     ;;
2971   *formatted*) # (vi
2972     cf_format=yes
2973     cf_inboth=yes
2974     ;;
2975   *)
2976     cf_format=no
2977     cf_inboth=no
2978     ;;
2979   esac
2980
2981 test ! -d man && mkdir man
2982
2983 cf_so_strip=
2984 cf_compress=
2985 case "$MANPAGE_FORMAT" in #(vi
2986 *compress*) #(vi
2987         cf_so_strip="Z"
2988         cf_compress=compress
2989   ;;
2990 *gzip*) #(vi
2991         cf_so_strip="gz"
2992         cf_compress=gzip
2993   ;;
2994 esac
2995
2996 cf_edit_man=./edit_man.sh
2997 cf_man_alias=`pwd`/man_alias.sed
2998
2999 cat >$cf_edit_man <<CF_EOF
3000 #! /bin/sh
3001 # this script is generated by the configure-script CF_MAN_PAGES macro.
3002
3003 prefix="$cf_prefix"
3004 datadir="$datadir"
3005
3006 NCURSES_MAJOR="$NCURSES_MAJOR"
3007 NCURSES_MINOR="$NCURSES_MINOR"
3008 NCURSES_PATCH="$NCURSES_PATCH"
3009
3010 NCURSES_OSPEED="$NCURSES_OSPEED"
3011 TERMINFO="$TERMINFO"
3012
3013 MKDIRS="sh `cd $srcdir && pwd`/mkdirs.sh"
3014
3015 INSTALL="$INSTALL"
3016 INSTALL_DATA="$INSTALL_DATA"
3017
3018 transform="$program_transform_name"
3019
3020 TMP=\${TMPDIR-/tmp}/man\$\$
3021 trap "rm -f \$TMP" 0 1 2 5 15
3022
3023 form=\[$]1
3024 shift || exit 1
3025
3026 verb=\[$]1
3027 shift || exit 1
3028
3029 mandir=\[$]1
3030 shift || exit 1
3031
3032 srcdir=\[$]1
3033 top_srcdir=\[$]srcdir/..
3034 shift || exit 1
3035
3036 if test "\$form" = normal ; then
3037         if test "$cf_format" = yes ; then
3038         if test "$cf_inboth" = no ; then
3039                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3040                 exit $?
3041         fi
3042         fi
3043         cf_subdir=\$mandir/man
3044         cf_tables=$MANPAGE_TBL
3045 else
3046         cf_subdir=\$mandir/cat
3047         cf_tables=yes
3048 fi
3049
3050 # process the list of source-files
3051 for i in \[$]* ; do
3052 case \$i in #(vi
3053 *.orig|*.rej) ;; #(vi
3054 *.[[0-9]]*)
3055         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
3056         if test \$verb = installing ; then
3057         if test ! -d \$cf_subdir\${section} ; then
3058                 \$MKDIRS \$cf_subdir\$section
3059         fi
3060         fi
3061
3062         # replace variables in man page
3063         if test ! -f $cf_man_alias ; then
3064 cat >>$cf_man_alias <<-CF_EOF2
3065                 s,@DATADIR@,\$datadir,g
3066                 s,@TERMINFO@,\$TERMINFO,g
3067                 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
3068                 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
3069                 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
3070                 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
3071 CF_EOF
3072         ifelse($1,,,[
3073         for cf_name in $1
3074         do
3075                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3076                 cf_name=`echo $cf_name|sed "$program_transform_name"`
3077 cat >>$cf_edit_man <<-CF_EOF
3078                 s,@$cf_NAME@,$cf_name,
3079 CF_EOF
3080         done
3081         ])
3082 cat >>$cf_edit_man <<CF_EOF
3083 CF_EOF2
3084                 echo "...made $cf_man_alias"
3085         fi
3086
3087         aliases=
3088         cf_source=\`basename \$i\`
3089         inalias=\$cf_source
3090         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
3091         if test ! -f \$inalias ; then
3092                 echo .. skipped \$cf_source
3093                 continue
3094         fi
3095 CF_EOF
3096
3097 if test "$MANPAGE_ALIASES" != no ; then
3098 cat >>$cf_edit_man <<CF_EOF
3099         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
3100 CF_EOF
3101 fi
3102
3103 if test "$MANPAGE_RENAMES" = no ; then
3104 cat >>$cf_edit_man <<CF_EOF
3105         # perform program transformations for section 1 man pages
3106         if test \$section = 1 ; then
3107                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
3108         else
3109                 cf_target=\$cf_subdir\${section}/\$cf_source
3110         fi
3111 CF_EOF
3112 else
3113 cat >>$cf_edit_man <<CF_EOF
3114         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
3115         if test -z "\$cf_target" ; then
3116                 echo '? missing rename for '\$cf_source
3117                 cf_target="\$cf_source"
3118         fi
3119         cf_target="\$cf_subdir\${section}/\${cf_target}"
3120
3121 CF_EOF
3122 fi
3123
3124 cat >>$cf_edit_man <<CF_EOF
3125         sed     -f $cf_man_alias \\
3126 CF_EOF
3127
3128 if test -f $MANPAGE_RENAMES ; then
3129 cat >>$cf_edit_man <<CF_EOF
3130                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
3131 CF_EOF
3132 else
3133 cat >>$cf_edit_man <<CF_EOF
3134                 < \$i >\$TMP
3135 CF_EOF
3136 fi
3137
3138 cat >>$cf_edit_man <<CF_EOF
3139 if test \$cf_tables = yes ; then
3140         tbl \$TMP >\$TMP.out
3141         mv \$TMP.out \$TMP
3142 fi
3143 CF_EOF
3144
3145 if test $with_curses_h != yes ; then
3146 cat >>$cf_edit_man <<CF_EOF
3147         sed -e "/\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
3148         mv \$TMP.out \$TMP
3149 CF_EOF
3150 fi
3151
3152 cat >>$cf_edit_man <<CF_EOF
3153         if test \$form = format ; then
3154                 nroff -man \$TMP >\$TMP.out
3155                 mv \$TMP.out \$TMP
3156         fi
3157 CF_EOF
3158
3159 if test -n "$cf_compress" ; then
3160 cat >>$cf_edit_man <<CF_EOF
3161         if test \$verb = installing ; then
3162         if ( $cf_compress -f \$TMP )
3163         then
3164                 mv \$TMP.$cf_so_strip \$TMP
3165         fi
3166         fi
3167         cf_target="\$cf_target.$cf_so_strip"
3168 CF_EOF
3169 fi
3170
3171 case "$MANPAGE_FORMAT" in #(vi
3172 *BSDI*)
3173 cat >>$cf_edit_man <<CF_EOF
3174         if test \$form = format ; then
3175                 # BSDI installs only .0 suffixes in the cat directories
3176                 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
3177         fi
3178 CF_EOF
3179   ;;
3180 esac
3181
3182 cat >>$cf_edit_man <<CF_EOF
3183         suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
3184         if test \$verb = installing ; then
3185                 echo \$verb \$cf_target
3186                 \$INSTALL_DATA \$TMP \$cf_target
3187                 test -d \$cf_subdir\${section} &&
3188                 test -n "\$aliases" && (
3189                         cd \$cf_subdir\${section} && (
3190                                 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
3191                                 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
3192                                 cf_target=\`basename \$cf_target\`
3193                                 for cf_alias in \$aliases
3194                                 do
3195                                         if test \$section = 1 ; then
3196                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3197                                         fi
3198
3199                                         if test "$MANPAGE_SYMLINKS" = yes ; then
3200                                                 if test -f \$cf_alias\${suffix} ; then
3201                                                         if ( cmp -s \$cf_target \$cf_alias\${suffix} )
3202                                                         then
3203                                                                 continue
3204                                                         fi
3205                                                 fi
3206                                                 echo .. \$verb alias \$cf_alias\${suffix}
3207                                                 rm -f \$cf_alias\${suffix}
3208                                                 $LN_S \$cf_target \$cf_alias\${suffix}
3209                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
3210                                                 echo ".so \$cf_source" >\$TMP
3211 CF_EOF
3212 if test -n "$cf_compress" ; then
3213 cat >>$cf_edit_man <<CF_EOF
3214                                                 if test -n "$cf_so_strip" ; then
3215                                                         $cf_compress -f \$TMP
3216                                                         mv \$TMP.$cf_so_strip \$TMP
3217                                                 fi
3218 CF_EOF
3219 fi
3220 cat >>$cf_edit_man <<CF_EOF
3221                                                 echo .. \$verb alias \$cf_alias\${suffix}
3222                                                 rm -f \$cf_alias\${suffix}
3223                                                 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
3224                                         fi
3225                                 done
3226                         )
3227                 )
3228         elif test \$verb = removing ; then
3229                 test -f \$cf_target && (
3230                         echo \$verb \$cf_target
3231                         rm -f \$cf_target
3232                 )
3233                 test -d \$cf_subdir\${section} &&
3234                 test -n "\$aliases" && (
3235                         cd \$cf_subdir\${section} && (
3236                                 for cf_alias in \$aliases
3237                                 do
3238                                         if test \$section = 1 ; then
3239                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3240                                         fi
3241
3242                                         echo .. \$verb alias \$cf_alias\${suffix}
3243                                         rm -f \$cf_alias\${suffix}
3244                                 done
3245                         )
3246                 )
3247         else
3248 #               echo ".hy 0"
3249                 cat \$TMP
3250         fi
3251         ;;
3252 esac
3253 done
3254
3255 if test $cf_inboth = yes ; then
3256 if test \$form != format ; then
3257         sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3258 fi
3259 fi
3260
3261 exit 0
3262 CF_EOF
3263 chmod 755 $cf_edit_man
3264
3265 ])dnl
3266 dnl ---------------------------------------------------------------------------
3267 dnl CF_MATH_LIB version: 5 updated: 2000/05/28 01:39:10
3268 dnl -----------
3269 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
3270 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
3271 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
3272 AC_DEFUN([CF_MATH_LIB],
3273 [
3274 AC_CACHE_CHECK(if -lm needed for math functions,
3275         cf_cv_need_libm,[
3276         AC_TRY_LINK([
3277         #include <stdio.h>
3278         #include <math.h>
3279         ],
3280         [double x = rand(); printf("result = %g\n", ]ifelse($2,,sin(x),$2)[)],
3281         [cf_cv_need_libm=no],
3282         [cf_cv_need_libm=yes])])
3283 if test "$cf_cv_need_libm" = yes
3284 then
3285 ifelse($1,,[
3286         LIBS="$LIBS -lm"
3287 ],[$1=-lm])
3288 fi
3289 ])
3290 dnl ---------------------------------------------------------------------------
3291 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
3292 dnl ----------------------
3293 dnl Check if the file-system supports mixed-case filenames.  If we're able to
3294 dnl create a lowercase name and see it as uppercase, it doesn't support that.
3295 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
3296 [
3297 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
3298 if test "$cross_compiling" = yes ; then
3299         case $target_alias in #(vi
3300         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
3301                 cf_cv_mixedcase=no
3302                 ;;
3303         *)
3304                 cf_cv_mixedcase=yes
3305                 ;;
3306         esac
3307 else
3308         rm -f conftest CONFTEST
3309         echo test >conftest
3310         if test -f CONFTEST ; then
3311                 cf_cv_mixedcase=no
3312         else
3313                 cf_cv_mixedcase=yes
3314         fi
3315         rm -f conftest CONFTEST
3316 fi
3317 ])
3318 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
3319 ])dnl
3320 dnl ---------------------------------------------------------------------------
3321 dnl CF_MKSTEMP version: 5 updated: 2006/12/16 12:33:30
3322 dnl ----------
3323 dnl Check for a working mkstemp.  This creates two files, checks that they are
3324 dnl successfully created and distinct (AmigaOS apparently fails on the last).
3325 AC_DEFUN([CF_MKSTEMP],[
3326 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
3327 rm -f conftest*
3328 AC_TRY_RUN([
3329 #include <sys/types.h>
3330 #include <stdlib.h>
3331 #include <stdio.h>
3332 #include <string.h>
3333 #include <sys/stat.h>
3334 int main()
3335 {
3336         char *tmpl = "conftestXXXXXX";
3337         char name[2][80];
3338         int n;
3339         int result = 0;
3340         int fd;
3341         struct stat sb;
3342
3343         umask(077);
3344         for (n = 0; n < 2; ++n) {
3345                 strcpy(name[n], tmpl);
3346                 if ((fd = mkstemp(name[n])) >= 0) {
3347                         if (!strcmp(name[n], tmpl)
3348                          || stat(name[n], &sb) != 0
3349                          || (sb.st_mode & S_IFMT) != S_IFREG
3350                          || (sb.st_mode & 077) != 0) {
3351                                 result = 1;
3352                         }
3353                         close(fd);
3354                 }
3355         }
3356         if (result == 0
3357          && !strcmp(name[0], name[1]))
3358                 result = 1;
3359         ${cf_cv_main_return:-return}(result);
3360 }
3361 ],[cf_cv_func_mkstemp=yes
3362 ],[cf_cv_func_mkstemp=no
3363 ],[AC_CHECK_FUNC(mkstemp)
3364 ])
3365 ])
3366 if test "$cf_cv_func_mkstemp" = yes ; then
3367         AC_DEFINE(HAVE_MKSTEMP)
3368 fi
3369 ])dnl
3370 dnl ---------------------------------------------------------------------------
3371 dnl CF_MSG_LOG version: 4 updated: 2007/07/29 09:55:12
3372 dnl ----------
3373 dnl Write a debug message to config.log, along with the line number in the
3374 dnl configure script.
3375 AC_DEFUN([CF_MSG_LOG],[
3376 echo "${as_me-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
3377 ])dnl
3378 dnl ---------------------------------------------------------------------------
3379 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
3380 dnl ----------------
3381 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
3382 dnl warn about this.
3383 AC_DEFUN([CF_NCURSES_ABI_6],[
3384 if test "${with_abi_version+set}" != set; then
3385         case $cf_cv_rel_version in
3386         5.*)
3387                 cf_cv_rel_version=6.0
3388                 cf_cv_abi_version=6
3389                 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
3390                 ;;
3391         esac
3392 fi
3393 ])dnl
3394 dnl ---------------------------------------------------------------------------
3395 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
3396 dnl ------------------
3397 dnl see CF_WITH_NO_LEAKS
3398 AC_DEFUN([CF_NO_LEAKS_OPTION],[
3399 AC_MSG_CHECKING(if you want to use $1 for testing)
3400 AC_ARG_WITH($1,
3401         [$2],
3402         [AC_DEFINE($3)ifelse([$4],,[
3403          $4
3404 ])
3405         : ${with_cflags:=-g}
3406         : ${with_no_leaks:=yes}
3407          with_$1=yes],
3408         [with_$1=])
3409 AC_MSG_RESULT(${with_$1:-no})
3410
3411 case .$with_cflags in #(vi
3412 .*-g*)
3413         case .$CFLAGS in #(vi
3414         .*-g*) #(vi
3415                 ;;
3416         *)
3417                 CF_ADD_CFLAGS([-g])
3418                 ;;
3419         esac
3420         ;;
3421 esac
3422 ])dnl
3423 dnl ---------------------------------------------------------------------------
3424 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
3425 dnl ----------------
3426 dnl Check if the given variable is a number.  If not, report an error.
3427 dnl $1 is the variable
3428 dnl $2 is the message
3429 AC_DEFUN([CF_NUMBER_SYNTAX],[
3430 if test -n "$1" ; then
3431   case $1 in #(vi
3432   [[0-9]]*) #(vi
3433         ;;
3434   *)
3435         AC_MSG_ERROR($2 is not a number: $1)
3436         ;;
3437   esac
3438 else
3439   AC_MSG_ERROR($2 value is empty)
3440 fi
3441 ])dnl
3442 dnl ---------------------------------------------------------------------------
3443 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
3444 dnl -------------
3445 dnl Compute the object-directory name from the given model name
3446 AC_DEFUN([CF_OBJ_SUBDIR],
3447 [
3448         case $1 in
3449         libtool) $2='obj_lo'  ;;
3450         normal)  $2='objects' ;;
3451         debug)   $2='obj_g' ;;
3452         profile) $2='obj_p' ;;
3453         shared)
3454                 case $cf_cv_system_name in #(vi
3455                 cygwin) #(vi
3456                         $2='objects' ;;
3457                 *)
3458                         $2='obj_s' ;;
3459                 esac
3460         esac
3461 ])dnl
3462 dnl ---------------------------------------------------------------------------
3463 dnl CF_PATHSEP version: 3 updated: 2001/01/12 01:23:53
3464 dnl ----------
3465 dnl Provide a value for the $PATH and similar separator
3466 AC_DEFUN([CF_PATHSEP],
3467 [
3468         case $cf_cv_system_name in
3469         os2*)   PATHSEP=';'  ;;
3470         *)      PATHSEP=':'  ;;
3471         esac
3472 ifelse($1,,,[$1=$PATHSEP])
3473         AC_SUBST(PATHSEP)
3474 ])dnl
3475 dnl ---------------------------------------------------------------------------
3476 dnl CF_PATH_SYNTAX version: 12 updated: 2008/03/23 14:45:59
3477 dnl --------------
3478 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
3479 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3480 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
3481 dnl delayed evaluation of those symbols.
3482 AC_DEFUN([CF_PATH_SYNTAX],[
3483 if test "x$prefix" != xNONE; then
3484   cf_path_syntax="$prefix"
3485 else
3486   cf_path_syntax="$ac_default_prefix"
3487 fi
3488
3489 case ".[$]$1" in #(vi
3490 .\[$]\(*\)*|.\'*\'*) #(vi
3491   ;;
3492 ..|./*|.\\*) #(vi
3493   ;;
3494 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
3495   ;;
3496 .\[$]{*prefix}*) #(vi
3497   eval $1="[$]$1"
3498   case ".[$]$1" in #(vi
3499   .NONE/*)
3500     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3501     ;;
3502   esac
3503   ;; #(vi
3504 .no|.NONE/*)
3505   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3506   ;;
3507 *)
3508   ifelse($2,,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3509   ;;
3510 esac
3511 ])dnl
3512 dnl ---------------------------------------------------------------------------
3513 dnl CF_POSIX_C_SOURCE version: 6 updated: 2005/07/14 20:25:10
3514 dnl -----------------
3515 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3516 dnl
3517 dnl     POSIX.1-1990                            _POSIX_SOURCE
3518 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
3519 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
3520 dnl             Bindings Option
3521 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
3522 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
3523 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
3524 dnl
3525 dnl Parameters:
3526 dnl     $1 is the nominal value for _POSIX_C_SOURCE
3527 AC_DEFUN([CF_POSIX_C_SOURCE],
3528 [
3529 cf_POSIX_C_SOURCE=ifelse($1,,199506L,$1)
3530
3531 cf_save_CFLAGS="$CFLAGS"
3532 cf_save_CPPFLAGS="$CPPFLAGS"
3533
3534 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3535 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3536
3537 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3538         CF_MSG_LOG(if the symbol is already defined go no further)
3539         AC_TRY_COMPILE([#include <sys/types.h>],[
3540 #ifndef _POSIX_C_SOURCE
3541 make an error
3542 #endif],
3543         [cf_cv_posix_c_source=no],
3544         [cf_want_posix_source=no
3545          case .$cf_POSIX_C_SOURCE in #(vi
3546          .[[12]]??*) #(vi
3547                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3548                 ;;
3549          .2) #(vi
3550                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3551                 cf_want_posix_source=yes
3552                 ;;
3553          .*)
3554                 cf_want_posix_source=yes
3555                 ;;
3556          esac
3557          if test "$cf_want_posix_source" = yes ; then
3558                 AC_TRY_COMPILE([#include <sys/types.h>],[
3559 #ifdef _POSIX_SOURCE
3560 make an error
3561 #endif],[],
3562                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3563          fi
3564          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3565          CFLAGS="$cf_trim_CFLAGS"
3566          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
3567          CF_MSG_LOG(if the second compile does not leave our definition intact error)
3568          AC_TRY_COMPILE([#include <sys/types.h>],[
3569 #ifndef _POSIX_C_SOURCE
3570 make an error
3571 #endif],,
3572          [cf_cv_posix_c_source=no])
3573          CFLAGS="$cf_save_CFLAGS"
3574          CPPFLAGS="$cf_save_CPPFLAGS"
3575         ])
3576 ])
3577
3578 if test "$cf_cv_posix_c_source" != no ; then
3579         CFLAGS="$cf_trim_CFLAGS"
3580         CPPFLAGS="$cf_trim_CPPFLAGS"
3581         if test "$cf_cv_cc_u_d_options" = yes ; then
3582                 cf_temp_posix_c_source=`echo "$cf_cv_posix_c_source" | \
3583                                 sed -e 's/-D/-U/g' -e 's/=[[^   ]]*//g'`
3584                 CPPFLAGS="$CPPFLAGS $cf_temp_posix_c_source"
3585         fi
3586         CPPFLAGS="$CPPFLAGS $cf_cv_posix_c_source"
3587 fi
3588
3589 ])dnl
3590 dnl ---------------------------------------------------------------------------
3591 dnl CF_PREDEFINE version: 1 updated: 2003/07/26 17:53:56
3592 dnl ------------
3593 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
3594 dnl
3595 dnl $1 = symbol to test
3596 dnl $2 = value (if any) to use for a predefinition
3597 AC_DEFUN([CF_PREDEFINE],
3598 [
3599 AC_MSG_CHECKING(if we must define $1)
3600 AC_TRY_COMPILE([#include <sys/types.h>
3601 ],[
3602 #ifndef $1
3603 make an error
3604 #endif],[cf_result=no],[cf_result=yes])
3605 AC_MSG_RESULT($cf_result)
3606
3607 if test "$cf_result" = yes ; then
3608         CPPFLAGS="$CPPFLAGS ifelse($2,,-D$1,[-D$1=$2])"
3609 elif test "x$2" != "x" ; then
3610         AC_MSG_CHECKING(checking for compatible value versus $2)
3611         AC_TRY_COMPILE([#include <sys/types.h>
3612 ],[
3613 #if $1-$2 < 0
3614 make an error
3615 #endif],[cf_result=yes],[cf_result=no])
3616         AC_MSG_RESULT($cf_result)
3617         if test "$cf_result" = no ; then
3618                 # perhaps we can override it - try...
3619                 CPPFLAGS="$CPPFLAGS -D$1=$2"
3620         fi
3621 fi
3622 ])dnl
3623 dnl ---------------------------------------------------------------------------
3624 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
3625 dnl ------------
3626 dnl Append definitions and rules for the given programs to the subdirectory
3627 dnl Makefiles, and the recursion rule for the top-level Makefile.
3628 dnl
3629 dnl parameters
3630 dnl     $1 = script to run
3631 dnl     $2 = list of subdirectories
3632 dnl
3633 dnl variables
3634 dnl     $AWK
3635 AC_DEFUN([CF_PRG_RULES],
3636 [
3637 for cf_dir in $2
3638 do
3639         if test ! -d $srcdir/$cf_dir; then
3640                 continue
3641         elif test -f $srcdir/$cf_dir/programs; then
3642                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
3643         fi
3644 done
3645
3646 ])dnl
3647 dnl ---------------------------------------------------------------------------
3648 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3649 dnl -----------
3650 dnl Check for awk, ensure that the check found something.
3651 AC_DEFUN([CF_PROG_AWK],
3652 [
3653 AC_PROG_AWK
3654 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3655 ])dnl
3656 dnl ---------------------------------------------------------------------------
3657 dnl CF_PROG_CC_C_O version: 2 updated: 2006/12/16 15:55:46
3658 dnl --------------
3659 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3660 dnl the output file can be renamed, and allows for a shell variable that can
3661 dnl be used later.  The parameter is either CC or CXX.  The result is the
3662 dnl cache variable:
3663 dnl     $cf_cv_prog_CC_c_o
3664 dnl     $cf_cv_prog_CXX_c_o
3665 AC_DEFUN([CF_PROG_CC_C_O],
3666 [AC_REQUIRE([AC_PROG_CC])dnl
3667 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3668 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3669 [
3670 cat > conftest.$ac_ext <<CF_EOF
3671 #include <stdio.h>
3672 int main()
3673 {
3674         ${cf_cv_main_return:-return}(0);
3675 }
3676 CF_EOF
3677 # We do the test twice because some compilers refuse to overwrite an
3678 # existing .o file with -o, though they will create one.
3679 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3680 if AC_TRY_EVAL(ac_try) &&
3681   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3682 then
3683   eval cf_cv_prog_$1_c_o=yes
3684 else
3685   eval cf_cv_prog_$1_c_o=no
3686 fi
3687 rm -f conftest*
3688 ])dnl
3689 if test $cf_cv_prog_$1_c_o = yes; then
3690   AC_MSG_RESULT([yes])
3691 else
3692   AC_MSG_RESULT([no])
3693 fi
3694 ])dnl
3695 dnl ---------------------------------------------------------------------------
3696 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
3697 dnl --------------
3698 dnl Check if C (preprocessor) -U and -D options are processed in the order
3699 dnl given rather than by type of option.  Some compilers insist on apply all
3700 dnl of the -U options after all of the -D options.  Others allow mixing them,
3701 dnl and may predefine symbols that conflict with those we define.
3702 AC_DEFUN([CF_PROG_CC_U_D],
3703 [
3704 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
3705         cf_save_CPPFLAGS="$CPPFLAGS"
3706         CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
3707         AC_TRY_COMPILE([],[
3708 #ifndef U_D_OPTIONS
3709 make an undefined-error
3710 #endif
3711 #ifdef  D_U_OPTIONS
3712 make a defined-error
3713 #endif
3714         ],[
3715         cf_cv_cc_u_d_options=yes],[
3716         cf_cv_cc_u_d_options=no])
3717         CPPFLAGS="$cf_save_CPPFLAGS"
3718 ])
3719 ])dnl
3720 dnl ---------------------------------------------------------------------------
3721 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
3722 dnl -------------
3723 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3724 dnl This macro adds a check to ensure the script found something.
3725 AC_DEFUN([CF_PROG_EGREP],
3726 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3727    [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3728     then ac_cv_prog_egrep='grep -E'
3729     else ac_cv_prog_egrep='egrep'
3730     fi])
3731  EGREP=$ac_cv_prog_egrep
3732  AC_SUBST([EGREP])
3733 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3734 ])dnl
3735 dnl ---------------------------------------------------------------------------
3736 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
3737 dnl -----------
3738 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3739 AC_DEFUN([CF_PROG_EXT],
3740 [
3741 AC_REQUIRE([CF_CHECK_CACHE])
3742 case $cf_cv_system_name in
3743 os2*)
3744     CFLAGS="$CFLAGS -Zmt"
3745     CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
3746     CXXFLAGS="$CXXFLAGS -Zmt"
3747     # autoconf's macro sets -Zexe and suffix both, which conflict:w
3748     LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
3749     ac_cv_exeext=.exe
3750     ;;
3751 esac
3752
3753 AC_EXEEXT
3754 AC_OBJEXT
3755
3756 PROG_EXT="$EXEEXT"
3757 AC_SUBST(PROG_EXT)
3758 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
3759 ])dnl
3760 dnl ---------------------------------------------------------------------------
3761 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
3762 dnl ---------------
3763 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
3764 dnl misc/tabset install won't work properly.  Usually this happens only when
3765 dnl using the fallback mkinstalldirs script
3766 AC_DEFUN([CF_PROG_INSTALL],
3767 [AC_PROG_INSTALL
3768 case $INSTALL in
3769 /*)
3770   ;;
3771 *)
3772   CF_DIRNAME(cf_dir,$INSTALL)
3773   test -z "$cf_dir" && cf_dir=.
3774   INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
3775   ;;
3776 esac
3777 ])dnl
3778 dnl ---------------------------------------------------------------------------
3779 dnl CF_PROG_LDCONFIG version: 1 updated: 2003/09/20 17:07:55
3780 dnl ----------------
3781 dnl Check for ldconfig, needed to fixup shared libraries that would be built
3782 dnl and then used in the install.
3783 AC_DEFUN([CF_PROG_LDCONFIG],[
3784 if test "$cross_compiling" = yes ; then
3785   LDCONFIG=:
3786 else
3787 case "$cf_cv_system_name" in #(vi
3788 freebsd*) #(vi
3789   test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
3790   ;;
3791 *) LDPATH=$PATH:/sbin:/usr/sbin
3792   AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
3793   ;;
3794 esac
3795 fi
3796 AC_SUBST(LDCONFIG)
3797 ])dnl
3798 dnl ---------------------------------------------------------------------------
3799 dnl CF_PROG_LINT version: 1 updated: 2006/09/16 11:40:59
3800 dnl ------------
3801 AC_DEFUN([CF_PROG_LINT],
3802 [
3803 AC_CHECK_PROGS(LINT, tdlint lint alint)
3804 AC_SUBST(LINT_OPTS)
3805 ])dnl
3806 dnl ---------------------------------------------------------------------------
3807 dnl CF_REGEX version: 3 updated: 1997/11/01 14:26:01
3808 dnl --------
3809 dnl Attempt to determine if we've got one of the flavors of regular-expression