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