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