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