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