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