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