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