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