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