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