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