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