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