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