ncurses 6.3 - patch 20220122
[ncurses.git] / Ada95 / aclocal.m4
1 dnl***************************************************************************
2 dnl Copyright 2018-2021,2022 Thomas E. Dickey                                *
3 dnl Copyright 2010-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
31 dnl
32 dnl $Id: aclocal.m4,v 1.192 2022/01/23 00:21:27 tom Exp $
33 dnl Macros used in NCURSES Ada95 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 CF_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49
46 dnl ------------------
47 dnl Conditionally generate script according to whether we're using a given autoconf.
48 dnl
49 dnl $1 = version to compare against
50 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
51 dnl $3 = code to use if AC_ACVERSION is older than $1.
52 define([CF_ACVERSION_CHECK],
53 [
54 ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
55 ifdef([m4_version_compare],
56 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
57 [CF_ACVERSION_COMPARE(
58 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
59 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
60 dnl ---------------------------------------------------------------------------
61 dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
62 dnl --------------------
63 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
64 dnl                      MAJOR2, MINOR2, TERNARY2,
65 dnl                      PRINTABLE2, not FOUND, FOUND)
66 define([CF_ACVERSION_COMPARE],
67 [ifelse(builtin([eval], [$2 < $5]), 1,
68 [ifelse([$8], , ,[$8])],
69 [ifelse([$9], , ,[$9])])])dnl
70 dnl ---------------------------------------------------------------------------
71 dnl CF_ADA_INCLUDE_DIRS version: 8 updated: 2013/10/14 04:24:07
72 dnl -------------------
73 dnl Construct the list of include-options for the C programs in the Ada95
74 dnl binding.
75 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
76 [
77 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
78 if test "$srcdir" != "."; then
79         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
80 fi
81 if test "$GCC" != yes; then
82         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
83 elif test "$includedir" != "/usr/include"; then
84         if test "$includedir" = '${prefix}/include' ; then
85                 if test x$prefix != x/usr ; then
86                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
87                 fi
88         else
89                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
90         fi
91 fi
92 AC_SUBST(ACPPFLAGS)
93 ])dnl
94 dnl ---------------------------------------------------------------------------
95 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
96 dnl ---------------
97 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
98 AC_DEFUN([CF_ADD_ADAFLAGS],[
99         ADAFLAGS="$ADAFLAGS $1"
100         AC_SUBST(ADAFLAGS)
101 ])dnl
102 dnl ---------------------------------------------------------------------------
103 dnl CF_ADD_CFLAGS version: 15 updated: 2020/12/31 10:54:15
104 dnl -------------
105 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
106 dnl $1 = flags to add
107 dnl $2 = if given makes this macro verbose.
108 dnl
109 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
110 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
111 dnl confused by the quotes (which require backslashes to keep them usable).
112 AC_DEFUN([CF_ADD_CFLAGS],
113 [
114 cf_fix_cppflags=no
115 cf_new_cflags=
116 cf_new_cppflags=
117 cf_new_extra_cppflags=
118
119 for cf_add_cflags in $1
120 do
121 case "$cf_fix_cppflags" in
122 (no)
123         case "$cf_add_cflags" in
124         (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
125                 case "$cf_add_cflags" in
126                 (-D*)
127                         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
128
129                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
130                                 && test -z "${cf_tst_cflags}" \
131                                 && cf_fix_cppflags=yes
132
133                         if test "$cf_fix_cppflags" = yes ; then
134                                 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
135                                 continue
136                         elif test "${cf_tst_cflags}" = "\"'" ; then
137                                 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
138                                 continue
139                         fi
140                         ;;
141                 esac
142                 case "$CPPFLAGS" in
143                 (*$cf_add_cflags)
144                         ;;
145                 (*)
146                         case "$cf_add_cflags" in
147                         (-D*)
148                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
149                                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
150                                 ;;
151                         esac
152                         CF_APPEND_TEXT(cf_new_cppflags,$cf_add_cflags)
153                         ;;
154                 esac
155                 ;;
156         (*)
157                 CF_APPEND_TEXT(cf_new_cflags,$cf_add_cflags)
158                 ;;
159         esac
160         ;;
161 (yes)
162         CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
163
164         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[[^"]]*"'\''//'`
165
166         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
167                 && test -z "${cf_tst_cflags}" \
168                 && cf_fix_cppflags=no
169         ;;
170 esac
171 done
172
173 if test -n "$cf_new_cflags" ; then
174         ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
175         CF_APPEND_TEXT(CFLAGS,$cf_new_cflags)
176 fi
177
178 if test -n "$cf_new_cppflags" ; then
179         ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
180         CF_APPEND_TEXT(CPPFLAGS,$cf_new_cppflags)
181 fi
182
183 if test -n "$cf_new_extra_cppflags" ; then
184         ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
185         CF_APPEND_TEXT(EXTRA_CPPFLAGS,$cf_new_extra_cppflags)
186 fi
187
188 AC_SUBST(EXTRA_CPPFLAGS)
189
190 ])dnl
191 dnl ---------------------------------------------------------------------------
192 dnl CF_ADD_INCDIR version: 17 updated: 2021/09/04 06:35:04
193 dnl -------------
194 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it is
195 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
196 dnl but old versions (and some misinstalled ones) need that.  To make things
197 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
198 dnl the include-path).
199 AC_DEFUN([CF_ADD_INCDIR],
200 [
201 if test -n "$1" ; then
202   for cf_add_incdir in $1
203   do
204         while test "$cf_add_incdir" != /usr/include
205         do
206           if test -d "$cf_add_incdir"
207           then
208                 cf_have_incdir=no
209                 if test -n "$CFLAGS$CPPFLAGS" ; then
210                   # a loop is needed to ensure we can add subdirs of existing dirs
211                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
212                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
213                           cf_have_incdir=yes; break
214                         fi
215                   done
216                 fi
217
218                 if test "$cf_have_incdir" = no ; then
219                   if test "$cf_add_incdir" = /usr/local/include ; then
220                         if test "$GCC" = yes
221                         then
222                           cf_save_CPPFLAGS=$CPPFLAGS
223                           CF_APPEND_TEXT(CPPFLAGS,-I$cf_add_incdir)
224                           AC_TRY_COMPILE([#include <stdio.h>],
225                                   [printf("Hello")],
226                                   [],
227                                   [cf_have_incdir=yes])
228                           CPPFLAGS=$cf_save_CPPFLAGS
229                         fi
230                   fi
231                 fi
232
233                 if test "$cf_have_incdir" = no ; then
234                   CF_VERBOSE(adding $cf_add_incdir to include-path)
235                   ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
236
237                   cf_top_incdir=`echo "$cf_add_incdir" | sed -e 's%/include/.*$%/include%'`
238                   test "$cf_top_incdir" = "$cf_add_incdir" && break
239                   cf_add_incdir="$cf_top_incdir"
240                 else
241                   break
242                 fi
243           else
244                 break
245           fi
246         done
247   done
248 fi
249 ])dnl
250 dnl ---------------------------------------------------------------------------
251 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
252 dnl ----------
253 dnl Add a library, used to enforce consistency.
254 dnl
255 dnl $1 = library to add, without the "-l"
256 dnl $2 = variable to update (default $LIBS)
257 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
258 dnl ---------------------------------------------------------------------------
259 dnl CF_ADD_LIBDIR version: 11 updated: 2020/12/31 20:19:42
260 dnl -------------
261 dnl     Adds to the library-path
262 dnl
263 dnl     Some machines have trouble with multiple -L options.
264 dnl
265 dnl $1 is the (list of) directory(s) to add
266 dnl $2 is the optional name of the variable to update (default LDFLAGS)
267 dnl
268 AC_DEFUN([CF_ADD_LIBDIR],
269 [
270 if test -n "$1" ; then
271         for cf_add_libdir in $1
272         do
273                 if test "$cf_add_libdir" = /usr/lib ; then
274                         :
275                 elif test -d "$cf_add_libdir"
276                 then
277                         cf_have_libdir=no
278                         if test -n "$LDFLAGS$LIBS" ; then
279                                 # a loop is needed to ensure we can add subdirs of existing dirs
280                                 for cf_test_libdir in $LDFLAGS $LIBS ; do
281                                         if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
282                                                 cf_have_libdir=yes; break
283                                         fi
284                                 done
285                         fi
286                         if test "$cf_have_libdir" = no ; then
287                                 CF_VERBOSE(adding $cf_add_libdir to library-path)
288                                 ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
289                         fi
290                 fi
291         done
292 fi
293 ])dnl
294 dnl ---------------------------------------------------------------------------
295 dnl CF_ADD_LIBS version: 3 updated: 2019/11/02 16:47:33
296 dnl -----------
297 dnl Add one or more libraries, used to enforce consistency.  Libraries are
298 dnl prepended to an existing list, since their dependencies are assumed to
299 dnl already exist in the list.
300 dnl
301 dnl $1 = libraries to add, with the "-l", etc.
302 dnl $2 = variable to update (default $LIBS)
303 AC_DEFUN([CF_ADD_LIBS],[
304 cf_add_libs="[$]ifelse($2,,LIBS,[$2])"
305 # reverse order
306 cf_add_0lib=
307 for cf_add_1lib in $1; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done
308 # filter duplicates
309 for cf_add_1lib in $cf_add_0lib; do
310         for cf_add_2lib in $cf_add_libs; do
311                 if test "x$cf_add_1lib" = "x$cf_add_2lib"; then
312                         cf_add_1lib=
313                         break
314                 fi
315         done
316         test -n "$cf_add_1lib" && cf_add_libs="$cf_add_1lib $cf_add_libs"
317 done
318 ifelse($2,,LIBS,[$2])="$cf_add_libs"
319 ])dnl
320 dnl ---------------------------------------------------------------------------
321 dnl CF_ADD_SUBDIR_PATH version: 5 updated: 2020/12/31 20:19:42
322 dnl ------------------
323 dnl Append to a search-list for a nonstandard header/lib-file
324 dnl     $1 = the variable to return as result
325 dnl     $2 = the package name
326 dnl     $3 = the subdirectory, e.g., bin, include or lib
327 dnl $4 = the directory under which we will test for subdirectories
328 dnl $5 = a directory that we do not want $4 to match
329 AC_DEFUN([CF_ADD_SUBDIR_PATH],
330 [
331 test "x$4" != "x$5" && \
332 test -d "$4" && \
333 ifelse([$5],NONE,,[{ test -z "$5" || test "x$5" = xNONE || test "x$4" != "x$5"; } &&]) {
334         test -n "$verbose" && echo "    ... testing for $3-directories under $4"
335         test -d "$4/$3" &&          $1="[$]$1 $4/$3"
336         test -d "$4/$3/$2" &&       $1="[$]$1 $4/$3/$2"
337         test -d "$4/$3/$2/$3" &&    $1="[$]$1 $4/$3/$2/$3"
338         test -d "$4/$2/$3" &&       $1="[$]$1 $4/$2/$3"
339         test -d "$4/$2/$3/$2" &&    $1="[$]$1 $4/$2/$3/$2"
340 }
341 ])dnl
342 dnl ---------------------------------------------------------------------------
343 dnl CF_APPEND_CFLAGS version: 3 updated: 2021/09/05 17:25:40
344 dnl ----------------
345 dnl Use CF_ADD_CFLAGS after first checking for potential redefinitions.
346 dnl $1 = flags to add
347 dnl $2 = if given makes this macro verbose.
348 define([CF_APPEND_CFLAGS],
349 [
350 for cf_add_cflags in $1
351 do
352         case "x$cf_add_cflags" in
353         (x-[[DU]]*)
354                 CF_REMOVE_CFLAGS($cf_add_cflags,CFLAGS,[$2])
355                 CF_REMOVE_CFLAGS($cf_add_cflags,CPPFLAGS,[$2])
356                 ;;
357         esac
358         CF_ADD_CFLAGS([$cf_add_cflags],[$2])
359 done
360 ])dnl
361 dnl ---------------------------------------------------------------------------
362 dnl CF_APPEND_TEXT version: 1 updated: 2017/02/25 18:58:55
363 dnl --------------
364 dnl use this macro for appending text without introducing an extra blank at
365 dnl the beginning
366 define([CF_APPEND_TEXT],
367 [
368         test -n "[$]$1" && $1="[$]$1 "
369         $1="[$]{$1}$2"
370 ])dnl
371 dnl ---------------------------------------------------------------------------
372 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
373 dnl --------------
374 dnl Allow user to disable a normally-on option.
375 AC_DEFUN([CF_ARG_DISABLE],
376 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
377 dnl ---------------------------------------------------------------------------
378 dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31
379 dnl -------------
380 dnl Allow user to enable a normally-off option.
381 AC_DEFUN([CF_ARG_ENABLE],
382 [CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl
383 dnl ---------------------------------------------------------------------------
384 dnl CF_ARG_OPTION version: 5 updated: 2015/05/10 19:52:14
385 dnl -------------
386 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
387 dnl values.
388 dnl
389 dnl Parameters:
390 dnl $1 = option name
391 dnl $2 = help-string
392 dnl $3 = action to perform if option is not default
393 dnl $4 = action if perform if option is default
394 dnl $5 = default option value (either 'yes' or 'no')
395 AC_DEFUN([CF_ARG_OPTION],
396 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
397         if test "$enableval" != "$5" ; then
398 ifelse([$3],,[    :]dnl
399 ,[    $3]) ifelse([$4],,,[
400         else
401                 $4])
402         fi],[enableval=$5 ifelse([$4],,,[
403         $4
404 ])dnl
405 ])])dnl
406 dnl ---------------------------------------------------------------------------
407 dnl CF_AR_FLAGS version: 9 updated: 2021/01/01 13:31:04
408 dnl -----------
409 dnl Check for suitable "ar" (archiver) options for updating an archive.
410 dnl
411 dnl In particular, handle some obsolete cases where the "-" might be omitted,
412 dnl as well as a workaround for breakage of make's archive rules by the GNU
413 dnl binutils "ar" program.
414 AC_DEFUN([CF_AR_FLAGS],[
415 AC_REQUIRE([CF_PROG_AR])
416
417 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
418         case "$cf_cv_system_name" in
419         (*-msvc*)
420                 cf_cv_ar_flags=''
421                 cat >mk_static_lib.sh <<-EOF
422                 #!$SHELL
423                 MSVC_BIN="[$]AR"
424                 out="\[$]1"
425                 shift
426                 exec \[$]MSVC_BIN -out:"\[$]out" \[$]@
427                 EOF
428                 chmod +x mk_static_lib.sh
429                 AR=`pwd`/mk_static_lib.sh
430                 ;;
431         (*)
432                 cf_cv_ar_flags=unknown
433                 for cf_ar_flags in -curvU -curv curv -crv crv -cqv cqv -rv rv
434                 do
435
436                         # check if $ARFLAGS already contains this choice
437                         if test "x$ARFLAGS" != "x" ; then
438                                 cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
439                                 if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
440                                         cf_cv_ar_flags=
441                                         break
442                                 fi
443                         fi
444
445                         rm -f "conftest.$ac_cv_objext"
446                         rm -f conftest.a
447
448                         cat >"conftest.$ac_ext" <<EOF
449 #line __oline__ "configure"
450 int     testdata[[3]] = { 123, 456, 789 };
451 EOF
452                         if AC_TRY_EVAL(ac_compile) ; then
453                                 echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
454                                 $AR $ARFLAGS "$cf_ar_flags" conftest.a "conftest.$ac_cv_objext" 2>&AC_FD_CC 1>/dev/null
455                                 if test -f conftest.a ; then
456                                         cf_cv_ar_flags="$cf_ar_flags"
457                                         break
458                                 fi
459                         else
460                                 CF_VERBOSE(cannot compile test-program)
461                                 break
462                         fi
463                 done
464                 rm -f conftest.a "conftest.$ac_ext" "conftest.$ac_cv_objext"
465                 ;;
466         esac
467 ])
468
469 if test -n "$ARFLAGS" ; then
470         if test -n "$cf_cv_ar_flags" ; then
471                 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
472         fi
473 else
474         ARFLAGS=$cf_cv_ar_flags
475 fi
476
477 AC_SUBST(ARFLAGS)
478 ])
479 dnl ---------------------------------------------------------------------------
480 dnl CF_BUILD_CC version: 9 updated: 2021/01/02 09:31:20
481 dnl -----------
482 dnl If we're cross-compiling, allow the user to override the tools and their
483 dnl options.  The configure script is oriented toward identifying the host
484 dnl compiler, etc., but we need a build compiler to generate parts of the
485 dnl source.
486 dnl
487 dnl $1 = default for $CPPFLAGS
488 dnl $2 = default for $LIBS
489 AC_DEFUN([CF_BUILD_CC],[
490 CF_ACVERSION_CHECK(2.52,,
491         [AC_REQUIRE([CF_PROG_EXT])])
492 if test "$cross_compiling" = yes ; then
493
494         # defaults that we might want to override
495         : ${BUILD_CFLAGS:=''}
496         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
497         : ${BUILD_LDFLAGS:=''}
498         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
499         : ${BUILD_EXEEXT:='$x'}
500         : ${BUILD_OBJEXT:='o'}
501
502         AC_ARG_WITH(build-cc,
503                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
504                 [BUILD_CC="$withval"],
505                 [AC_CHECK_PROGS(BUILD_CC, [gcc clang c99 c89 cc cl],none)])
506         AC_MSG_CHECKING(for native build C compiler)
507         AC_MSG_RESULT($BUILD_CC)
508
509         AC_MSG_CHECKING(for native build C preprocessor)
510         AC_ARG_WITH(build-cpp,
511                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
512                 [BUILD_CPP="$withval"],
513                 [BUILD_CPP='${BUILD_CC} -E'])
514         AC_MSG_RESULT($BUILD_CPP)
515
516         AC_MSG_CHECKING(for native build C flags)
517         AC_ARG_WITH(build-cflags,
518                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
519                 [BUILD_CFLAGS="$withval"])
520         AC_MSG_RESULT($BUILD_CFLAGS)
521
522         AC_MSG_CHECKING(for native build C preprocessor-flags)
523         AC_ARG_WITH(build-cppflags,
524                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
525                 [BUILD_CPPFLAGS="$withval"])
526         AC_MSG_RESULT($BUILD_CPPFLAGS)
527
528         AC_MSG_CHECKING(for native build linker-flags)
529         AC_ARG_WITH(build-ldflags,
530                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
531                 [BUILD_LDFLAGS="$withval"])
532         AC_MSG_RESULT($BUILD_LDFLAGS)
533
534         AC_MSG_CHECKING(for native build linker-libraries)
535         AC_ARG_WITH(build-libs,
536                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
537                 [BUILD_LIBS="$withval"])
538         AC_MSG_RESULT($BUILD_LIBS)
539
540         # this assumes we're on Unix.
541         BUILD_EXEEXT=
542         BUILD_OBJEXT=o
543
544         : ${BUILD_CC:='${CC}'}
545
546         if { test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}'; } ; then
547                 AC_MSG_ERROR([Cross-build requires two compilers.
548 Use --with-build-cc to specify the native compiler.])
549         fi
550
551 else
552         : ${BUILD_CC:='${CC}'}
553         : ${BUILD_CPP:='${CPP}'}
554         : ${BUILD_CFLAGS:='${CFLAGS}'}
555         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
556         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
557         : ${BUILD_LIBS:='${LIBS}'}
558         : ${BUILD_EXEEXT:='$x'}
559         : ${BUILD_OBJEXT:='o'}
560 fi
561
562 AC_SUBST(BUILD_CC)
563 AC_SUBST(BUILD_CPP)
564 AC_SUBST(BUILD_CFLAGS)
565 AC_SUBST(BUILD_CPPFLAGS)
566 AC_SUBST(BUILD_LDFLAGS)
567 AC_SUBST(BUILD_LIBS)
568 AC_SUBST(BUILD_EXEEXT)
569 AC_SUBST(BUILD_OBJEXT)
570 ])dnl
571 dnl ---------------------------------------------------------------------------
572 dnl CF_C11_NORETURN version: 3 updated: 2021/03/28 11:36:23
573 dnl ---------------
574 AC_DEFUN([CF_C11_NORETURN],
575 [
576 AC_MSG_CHECKING(if you want to use C11 _Noreturn feature)
577 CF_ARG_ENABLE(stdnoreturn,
578         [  --enable-stdnoreturn    enable C11 _Noreturn feature for diagnostics],
579         [enable_stdnoreturn=yes],
580         [enable_stdnoreturn=no])
581 AC_MSG_RESULT($enable_stdnoreturn)
582
583 if test $enable_stdnoreturn = yes; then
584 AC_CACHE_CHECK([for C11 _Noreturn feature], cf_cv_c11_noreturn,
585         [AC_TRY_COMPILE([
586 #include <stdio.h>
587 #include <stdlib.h>
588 #include <stdnoreturn.h>
589 static _Noreturn void giveup(void) { exit(0); }
590         ],
591         [if (feof(stdin)) giveup()],
592         cf_cv_c11_noreturn=yes,
593         cf_cv_c11_noreturn=no)
594         ])
595 else
596         cf_cv_c11_noreturn=no,
597 fi
598
599 if test "$cf_cv_c11_noreturn" = yes; then
600         AC_DEFINE(HAVE_STDNORETURN_H, 1,[Define if <stdnoreturn.h> header is available and working])
601         AC_DEFINE_UNQUOTED(STDC_NORETURN,_Noreturn,[Define if C11 _Noreturn keyword is supported])
602         HAVE_STDNORETURN_H=1
603 else
604         HAVE_STDNORETURN_H=0
605 fi
606
607 AC_SUBST(HAVE_STDNORETURN_H)
608 AC_SUBST(STDC_NORETURN)
609 ])dnl
610 dnl ---------------------------------------------------------------------------
611 dnl CF_CC_ENV_FLAGS version: 10 updated: 2020/12/31 18:40:20
612 dnl ---------------
613 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
614 dnl into CC.  This will not help with broken scripts that wrap the compiler
615 dnl with options, but eliminates a more common category of user confusion.
616 dnl
617 dnl In particular, it addresses the problem of being able to run the C
618 dnl preprocessor in a consistent manner.
619 dnl
620 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
621 dnl the nuisance of having inconsistent settings for compiler and preprocessor
622 dnl outweighs that limitation.
623 AC_DEFUN([CF_CC_ENV_FLAGS],
624 [
625 # This should have been defined by AC_PROG_CC
626 : "${CC:=cc}"
627
628 AC_MSG_CHECKING(\$CFLAGS variable)
629 case "x$CFLAGS" in
630 (*-[[IUD]]*)
631         AC_MSG_RESULT(broken)
632         AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
633         cf_flags="$CFLAGS"
634         CFLAGS=
635         for cf_arg in $cf_flags
636         do
637                 CF_ADD_CFLAGS($cf_arg)
638         done
639         ;;
640 (*)
641         AC_MSG_RESULT(ok)
642         ;;
643 esac
644
645 AC_MSG_CHECKING(\$CC variable)
646 case "$CC" in
647 (*[[\ \ ]]-*)
648         AC_MSG_RESULT(broken)
649         AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
650         # humor him...
651         cf_prog=`echo "$CC" | sed -e 's/        / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
652         cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'`
653         CC="$cf_prog"
654         for cf_arg in $cf_flags
655         do
656                 case "x$cf_arg" in
657                 (x-[[IUDfgOW]]*)
658                         CF_ADD_CFLAGS($cf_arg)
659                         ;;
660                 (*)
661                         CC="$CC $cf_arg"
662                         ;;
663                 esac
664         done
665         CF_VERBOSE(resulting CC: '$CC')
666         CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
667         CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
668         ;;
669 (*)
670         AC_MSG_RESULT(ok)
671         ;;
672 esac
673 ])dnl
674 dnl ---------------------------------------------------------------------------
675 dnl CF_CFG_DEFAULTS version: 16 updated: 2021/01/04 19:33:05
676 dnl ---------------
677 dnl Determine the default configuration into which we'll install ncurses.  This
678 dnl can be overridden by the user's command-line options.  There's two items to
679 dnl look for:
680 dnl     1. the prefix (e.g., /usr)
681 dnl     2. the header files (e.g., /usr/include/ncurses)
682 dnl We'll look for a previous installation of ncurses and use the same defaults.
683 dnl
684 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
685 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
686 dnl programs from a vendor's.
687 AC_DEFUN([CF_CFG_DEFAULTS],
688 [AC_REQUIRE([AC_PROG_FGREP])dnl
689
690 AC_MSG_CHECKING(for prefix)
691 if test "x$prefix" = "xNONE" ; then
692         case "$cf_cv_system_name" in
693                 # non-vendor systems don't have a conflict
694         (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
695                 prefix=/usr
696                 ;;
697         (*)     prefix=$ac_default_prefix
698                 ;;
699         esac
700 fi
701 AC_MSG_RESULT($prefix)
702
703 if test "x$prefix" = "xNONE" ; then
704 AC_MSG_CHECKING(for default include-directory)
705 test -n "$verbose" && echo 1>&AC_FD_MSG
706 for cf_symbol in \
707         "$includedir" \
708         "$includedir/ncurses" \
709         "$prefix/include" \
710         "$prefix/include/ncurses" \
711         /usr/local/include \
712         /usr/local/include/ncurses \
713         /usr/include \
714         /usr/include/ncurses
715 do
716         cf_dir=`eval echo "$cf_symbol"`
717         if test -f "$cf_dir/curses.h" ; then
718         if ( ${FGREP-fgrep} NCURSES_VERSION "$cf_dir/curses.h" >/dev/null 2>&1 ) ; then
719                 includedir="$cf_symbol"
720                 test -n "$verbose"  && echo $ECHO_N "   found " 1>&AC_FD_MSG
721                 break
722         fi
723         fi
724         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
725 done
726 AC_MSG_RESULT($includedir)
727 fi
728 ])dnl
729 dnl ---------------------------------------------------------------------------
730 dnl CF_CHECK_CACHE version: 13 updated: 2020/12/31 10:54:15
731 dnl --------------
732 dnl Check if we're accidentally using a cache from a different machine.
733 dnl Derive the system name, as a check for reusing the autoconf cache.
734 dnl
735 dnl If we've packaged config.guess and config.sub, run that (since it does a
736 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
737 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
738 dnl which is useful in cross-compiles.
739 dnl
740 dnl Note: we would use $ac_config_sub, but that is one of the places where
741 dnl autoconf 2.5x broke compatibility with autoconf 2.13
742 AC_DEFUN([CF_CHECK_CACHE],
743 [
744 if test -f "$srcdir/config.guess" || test -f "$ac_aux_dir/config.guess" ; then
745         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
746         system_name="$host_os"
747 else
748         system_name="`(uname -s -r) 2>/dev/null`"
749         if test -z "$system_name" ; then
750                 system_name="`(hostname) 2>/dev/null`"
751         fi
752 fi
753 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
754 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
755
756 test -z "$system_name" && system_name="$cf_cv_system_name"
757 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
758
759 if test ".$system_name" != ".$cf_cv_system_name" ; then
760         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
761         AC_MSG_ERROR("Please remove config.cache and try again.")
762 fi
763 ])dnl
764 dnl ---------------------------------------------------------------------------
765 dnl CF_CHECK_GNAT_VERSION version: 4 updated: 2021/01/01 13:31:04
766 dnl ---------------------
767 AC_DEFUN([CF_CHECK_GNAT_VERSION],
768 [
769 AC_REQUIRE([CF_GNAT_VERSION])
770 case "$cf_cv_gnat_version" in
771 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
772         cf_cv_prog_gnat_correct=yes
773         ;;
774 (*)
775         AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
776         cf_cv_prog_gnat_correct=no
777         ;;
778 esac
779 ])
780 dnl ---------------------------------------------------------------------------
781 dnl CF_CHECK_LIBSSP version: 1 updated: 2021/10/30 10:40:19
782 dnl ---------------
783 dnl Check if libssp is needed, e.g., to work around misconfigured libraries
784 dnl used in cross-compiling to MinGW.
785 AC_DEFUN([CF_CHECK_LIBSSP],[
786 AC_CACHE_CHECK(if ssp library is needed,cf_cv_need_libssp,[
787 AC_TRY_LINK([
788 #include <sys/types.h>
789 #include <dirent.h>
790 ],[
791        DIR *dp = opendir(".");
792 ],cf_cv_need_libssp=no,[
793         cf_save_LIBS="$LIBS"
794         LIBS="$LIBS -lssp"
795         AC_TRY_LINK([
796 #include <sys/types.h>
797 #include <dirent.h>
798         ],[
799                    DIR *dp = opendir(".");
800         ],cf_cv_need_libssp=yes,
801           cf_cv_need_libssp=maybe)
802         LIBS="$cf_save_LIBS"
803 ])dnl
804 ])
805
806 if test "x$cf_cv_need_libssp" = xyes
807 then
808         CF_ADD_LIB(ssp)
809 fi
810 ])dnl
811 dnl ---------------------------------------------------------------------------
812 dnl CF_CLANG_COMPILER version: 8 updated: 2021/01/01 13:31:04
813 dnl -----------------
814 dnl Check if the given compiler is really clang.  clang's C driver defines
815 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
816 dnl not ignore some gcc options.
817 dnl
818 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
819 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
820 dnl the wrappers for gcc and g++ warnings.
821 dnl
822 dnl $1 = GCC (default) or GXX
823 dnl $2 = CLANG_COMPILER (default)
824 dnl $3 = CFLAGS (default) or CXXFLAGS
825 AC_DEFUN([CF_CLANG_COMPILER],[
826 ifelse([$2],,CLANG_COMPILER,[$2])=no
827
828 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
829         AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
830         cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
831         AC_TRY_COMPILE([],[
832 #ifdef __clang__
833 #else
834 make an error
835 #endif
836 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
837 ],[])
838         ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
839         AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
840 fi
841
842 CLANG_VERSION=none
843
844 if test "x$ifelse([$2],,CLANG_COMPILER,[$2])" = "xyes" ; then
845         case "$CC" in
846         (c[[1-9]][[0-9]]|*/c[[1-9]][[0-9]])
847                 AC_MSG_WARN(replacing broken compiler alias $CC)
848                 CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`"
849                 CC=clang
850                 ;;
851         esac
852
853         AC_MSG_CHECKING(version of $CC)
854         CLANG_VERSION="`$CC --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(CLANG[[^)]]*) //' -e 's/^.*(Debian[[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
855         test -z "$CLANG_VERSION" && CLANG_VERSION=unknown
856         AC_MSG_RESULT($CLANG_VERSION)
857
858         for cf_clang_opt in \
859                 -Qunused-arguments \
860                 -Wno-error=implicit-function-declaration
861         do
862                 AC_MSG_CHECKING(if option $cf_clang_opt works)
863                 cf_save_CFLAGS="$CFLAGS"
864                 CFLAGS="$CFLAGS $cf_clang_opt"
865                 AC_TRY_LINK([
866                         #include <stdio.h>],[
867                         printf("hello!\\n");],[
868                         cf_clang_optok=yes],[
869                         cf_clang_optok=no])
870                 AC_MSG_RESULT($cf_clang_optok)
871                 CFLAGS="$cf_save_CFLAGS"
872                 if test "$cf_clang_optok" = yes; then
873                         CF_VERBOSE(adding option $cf_clang_opt)
874                         CF_APPEND_TEXT(CFLAGS,$cf_clang_opt)
875                 fi
876         done
877 fi
878 ])
879 dnl ---------------------------------------------------------------------------
880 dnl CF_CONST_X_STRING version: 7 updated: 2021/06/07 17:39:17
881 dnl -----------------
882 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
883 dnl character-strings.
884 dnl
885 dnl It is ambiguous because the specification accommodated the pre-ANSI
886 dnl compilers bundled by more than one vendor in lieu of providing a standard C
887 dnl compiler other than by costly add-ons.  Because of this, the specification
888 dnl did not take into account the use of const for telling the compiler that
889 dnl string literals would be in readonly memory.
890 dnl
891 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
892 dnl let the compiler decide how to represent Xt's strings which were #define'd.
893 dnl That does not solve the problem of using the block of Xt's strings which
894 dnl are compiled into the library (and is less efficient than one might want).
895 dnl
896 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
897 dnl when compiling the library and compiling using the library, to tell the
898 dnl compiler that String is const.
899 AC_DEFUN([CF_CONST_X_STRING],
900 [
901 AC_REQUIRE([AC_PATH_XTRA])
902
903 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
904
905 AC_TRY_COMPILE(
906 [
907 #include <stdlib.h>
908 #include <X11/Intrinsic.h>
909 ],
910 [String foo = malloc(1); free((void*)foo)],[
911
912 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
913         AC_TRY_COMPILE(
914                 [
915 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
916 #undef  XTSTRINGDEFINES /* X11R5 and later */
917 #include <stdlib.h>
918 #include <X11/Intrinsic.h>
919                 ],[String foo = malloc(1); *foo = 0],[
920                         cf_cv_const_x_string=no
921                 ],[
922                         cf_cv_const_x_string=yes
923                 ])
924 ])
925
926 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
927
928 case "$cf_cv_const_x_string" in
929 (no)
930         CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
931         ;;
932 (*)
933         CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
934         ;;
935 esac
936
937 ])
938 ])dnl
939 dnl ---------------------------------------------------------------------------
940 dnl CF_CONST_X_STRING version: 7 updated: 2021/06/07 17:39:17
941 dnl -----------------
942 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
943 dnl character-strings.
944 dnl
945 dnl It is ambiguous because the specification accommodated the pre-ANSI
946 dnl compilers bundled by more than one vendor in lieu of providing a standard C
947 dnl compiler other than by costly add-ons.  Because of this, the specification
948 dnl did not take into account the use of const for telling the compiler that
949 dnl string literals would be in readonly memory.
950 dnl
951 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
952 dnl let the compiler decide how to represent Xt's strings which were #define'd.
953 dnl That does not solve the problem of using the block of Xt's strings which
954 dnl are compiled into the library (and is less efficient than one might want).
955 dnl
956 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
957 dnl when compiling the library and compiling using the library, to tell the
958 dnl compiler that String is const.
959 AC_DEFUN([CF_CONST_X_STRING],
960 [
961 AC_REQUIRE([AC_PATH_XTRA])
962
963 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
964
965 AC_TRY_COMPILE(
966 [
967 #include <stdlib.h>
968 #include <X11/Intrinsic.h>
969 ],
970 [String foo = malloc(1); free((void*)foo)],[
971
972 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
973         AC_TRY_COMPILE(
974                 [
975 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
976 #undef  XTSTRINGDEFINES /* X11R5 and later */
977 #include <stdlib.h>
978 #include <X11/Intrinsic.h>
979                 ],[String foo = malloc(1); *foo = 0],[
980                         cf_cv_const_x_string=no
981                 ],[
982                         cf_cv_const_x_string=yes
983                 ])
984 ])
985
986 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
987
988 case "$cf_cv_const_x_string" in
989 (no)
990         CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
991         ;;
992 (*)
993         CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
994         ;;
995 esac
996
997 ])
998 ])dnl
999 dnl ---------------------------------------------------------------------------
1000 dnl CF_CURSES_HEADER version: 5 updated: 2015/04/23 20:35:30
1001 dnl ----------------
1002 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
1003 dnl variations of ncurses' installs.
1004 dnl
1005 dnl $1 = ncurses when looking for ncurses, or is empty
1006 AC_DEFUN([CF_CURSES_HEADER],[
1007 AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[
1008 cf_cv_ncurses_header=none
1009 for cf_header in \
1010         ncurses.h ifelse($1,,,[$1/ncurses.h]) \
1011         curses.h ifelse($1,,,[$1/curses.h]) ifelse($1,,[ncurses/ncurses.h ncurses/curses.h])
1012 do
1013 AC_TRY_COMPILE([#include <${cf_header}>],
1014         [initscr(); tgoto("?", 0,0)],
1015         [cf_cv_ncurses_header=$cf_header; break],[])
1016 done
1017 ])
1018
1019 if test "$cf_cv_ncurses_header" = none ; then
1020         AC_MSG_ERROR(No curses header-files found)
1021 fi
1022
1023 # cheat, to get the right #define's for HAVE_NCURSES_H, etc.
1024 AC_CHECK_HEADERS($cf_cv_ncurses_header)
1025 ])dnl
1026 dnl ---------------------------------------------------------------------------
1027 dnl CF_DIRNAME version: 5 updated: 2020/12/31 20:19:42
1028 dnl ----------
1029 dnl "dirname" is not portable, so we fake it with a shell script.
1030 AC_DEFUN([CF_DIRNAME],[$1=`echo "$2" | sed -e 's%/[[^/]]*$%%'`])dnl
1031 dnl ---------------------------------------------------------------------------
1032 dnl CF_DISABLE_ECHO version: 14 updated: 2021/09/04 06:35:04
1033 dnl ---------------
1034 dnl You can always use "make -n" to see the actual options, but it is hard to
1035 dnl pick out/analyze warning messages when the compile-line is long.
1036 dnl
1037 dnl Sets:
1038 dnl     ECHO_LT - symbol to control if libtool is verbose
1039 dnl     ECHO_LD - symbol to prefix "cc -o" lines
1040 dnl     RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1041 dnl     SHOW_CC - symbol to put before explicit "cc -c" lines
1042 dnl     ECHO_CC - symbol to put before any "cc" line
1043 dnl
1044 AC_DEFUN([CF_DISABLE_ECHO],[
1045 AC_MSG_CHECKING(if you want to see long compiling messages)
1046 CF_ARG_DISABLE(echo,
1047         [  --disable-echo          do not display "compiling" commands],
1048         [
1049         ECHO_LT='--silent'
1050         ECHO_LD='@echo linking [$]@;'
1051         RULE_CC='@echo compiling [$]<'
1052         SHOW_CC='@echo compiling [$]@'
1053         ECHO_CC='@'
1054 ],[
1055         ECHO_LT=''
1056         ECHO_LD=''
1057         RULE_CC=''
1058         SHOW_CC=''
1059         ECHO_CC=''
1060 ])
1061 AC_MSG_RESULT($enableval)
1062 AC_SUBST(ECHO_LT)
1063 AC_SUBST(ECHO_LD)
1064 AC_SUBST(RULE_CC)
1065 AC_SUBST(SHOW_CC)
1066 AC_SUBST(ECHO_CC)
1067 ])dnl
1068 dnl ---------------------------------------------------------------------------
1069 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
1070 dnl ------------------------
1071 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
1072 AC_MSG_CHECKING(if we want to use GNAT projects)
1073 CF_ARG_DISABLE(gnat-projects,
1074         [  --disable-gnat-projects test: disable GNAT projects even if usable],
1075         [enable_gnat_projects=no],
1076         [enable_gnat_projects=yes])
1077 AC_MSG_RESULT($enable_gnat_projects)
1078 ])dnl
1079 dnl ---------------------------------------------------------------------------
1080 dnl CF_ENABLE_BROKEN_LINKER version: 2 updated: 2021/01/02 17:09:14
1081 dnl -----------------------
1082 dnl Some linkers cannot reference a data-only object.  Cygwin used to be one.
1083 dnl This usually follows CF_LINK_DATAONLY, but is not required in case we need
1084 dnl an unconditional feature.
1085 AC_DEFUN([CF_ENABLE_BROKEN_LINKER],[
1086
1087 AC_MSG_CHECKING(if you want broken-linker support code)
1088 AC_ARG_ENABLE(broken_linker,
1089         [  --enable-broken_linker  compile with broken-linker support code],
1090         [with_broken_linker=$enableval],
1091         [with_broken_linker=no])
1092 AC_MSG_RESULT($with_broken_linker)
1093
1094 : "${BROKEN_LINKER:=0}"
1095 if test "x$with_broken_linker" = xyes ; then
1096         AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules])
1097         BROKEN_LINKER=1
1098 fi
1099 AC_SUBST(BROKEN_LINKER)
1100 ])dnl
1101 dnl ---------------------------------------------------------------------------
1102 dnl CF_ENABLE_WARNINGS version: 9 updated: 2021/01/05 19:40:50
1103 dnl ------------------
1104 dnl Configure-option to enable gcc warnings
1105 dnl
1106 dnl $1 = extra options to add, if supported
1107 dnl $2 = option for checking attributes.  By default, this is done when
1108 dnl      warnings are enabled.  For other values:
1109 dnl      yes: always do this, e.g., to use in generated library-headers
1110 dnl      no: never do this
1111 AC_DEFUN([CF_ENABLE_WARNINGS],[
1112 if test "$GCC" = yes || test "$GXX" = yes
1113 then
1114 CF_FIX_WARNINGS(CFLAGS)
1115 CF_FIX_WARNINGS(CPPFLAGS)
1116 CF_FIX_WARNINGS(LDFLAGS)
1117 AC_MSG_CHECKING(if you want to turn on gcc warnings)
1118 CF_ARG_ENABLE(warnings,
1119         [  --enable-warnings       test: turn on gcc compiler warnings],
1120         [enable_warnings=yes],
1121         [enable_warnings=no])
1122 AC_MSG_RESULT($enable_warnings)
1123 if test "$enable_warnings" = "yes"
1124 then
1125         ifelse($2,,[CF_GCC_ATTRIBUTES])
1126         CF_GCC_WARNINGS($1)
1127 fi
1128 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
1129 fi
1130 ])dnl
1131 dnl ---------------------------------------------------------------------------
1132 dnl CF_FIND_LIBRARY version: 11 updated: 2021/01/02 09:31:20
1133 dnl ---------------
1134 dnl Look for a non-standard library, given parameters for AC_TRY_LINK.  We
1135 dnl prefer a standard location, and use -L options only if we do not find the
1136 dnl library in the standard library location(s).
1137 dnl     $1 = library name
1138 dnl     $2 = library class, usually the same as library name
1139 dnl     $3 = includes
1140 dnl     $4 = code fragment to compile/link
1141 dnl     $5 = corresponding function-name
1142 dnl     $6 = flag, nonnull if failure should not cause an error-exit
1143 dnl
1144 dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had
1145 dnl to use a -L option.
1146 AC_DEFUN([CF_FIND_LIBRARY],
1147 [
1148         eval 'cf_cv_have_lib_'"$1"'=no'
1149         cf_libdir=""
1150         AC_CHECK_FUNC($5,
1151                 eval 'cf_cv_have_lib_'"$1"'=yes',[
1152                 cf_save_LIBS="$LIBS"
1153                 AC_MSG_CHECKING(for $5 in -l$1)
1154                 LIBS="-l$1 $LIBS"
1155                 AC_TRY_LINK([$3],[$4],
1156                         [AC_MSG_RESULT(yes)
1157                          eval 'cf_cv_have_lib_'"$1"'=yes'
1158                         ],
1159                         [AC_MSG_RESULT(no)
1160                         CF_LIBRARY_PATH(cf_search,$2)
1161                         for cf_libdir in $cf_search
1162                         do
1163                                 AC_MSG_CHECKING(for -l$1 in $cf_libdir)
1164                                 LIBS="-L$cf_libdir -l$1 $cf_save_LIBS"
1165                                 AC_TRY_LINK([$3],[$4],
1166                                         [AC_MSG_RESULT(yes)
1167                                          eval 'cf_cv_have_lib_'"$1"'=yes'
1168                                          break],
1169                                         [AC_MSG_RESULT(no)
1170                                          LIBS="$cf_save_LIBS"])
1171                         done
1172                         ])
1173                 ])
1174 eval 'cf_found_library="[$]cf_cv_have_lib_'"$1"\"
1175 ifelse($6,,[
1176 if test "$cf_found_library" = no ; then
1177         AC_MSG_ERROR(Cannot link $1 library)
1178 fi
1179 ])
1180 ])dnl
1181 dnl ---------------------------------------------------------------------------
1182 dnl CF_FIND_LINKAGE version: 22 updated: 2020/12/31 20:19:42
1183 dnl ---------------
1184 dnl Find a library (specifically the linkage used in the code fragment),
1185 dnl searching for it if it is not already in the library path.
1186 dnl See also CF_ADD_SEARCHPATH.
1187 dnl
1188 dnl Parameters (4-on are optional):
1189 dnl     $1 = headers for library entrypoint
1190 dnl     $2 = code fragment for library entrypoint
1191 dnl     $3 = the library name without the "-l" option or ".so" suffix.
1192 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
1193 dnl     $5 = action to perform if not successful
1194 dnl     $6 = module name, if not the same as the library name
1195 dnl     $7 = extra libraries
1196 dnl
1197 dnl Sets these variables:
1198 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1199 dnl     $cf_cv_header_path_$3 - include-directory if needed
1200 dnl     $cf_cv_library_path_$3 - library-directory if needed
1201 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1202 AC_DEFUN([CF_FIND_LINKAGE],[
1203
1204 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1205 # will be set on completion of the AC_TRY_LINK below.
1206 cf_cv_header_path_$3=
1207 cf_cv_library_path_$3=
1208
1209 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1210
1211 cf_save_LIBS="$LIBS"
1212
1213 AC_TRY_LINK([$1],[$2],[
1214         cf_cv_find_linkage_$3=yes
1215         cf_cv_header_path_$3=/usr/include
1216         cf_cv_library_path_$3=/usr/lib
1217 ],[
1218
1219 LIBS="-l$3 $7 $cf_save_LIBS"
1220
1221 AC_TRY_LINK([$1],[$2],[
1222         cf_cv_find_linkage_$3=yes
1223         cf_cv_header_path_$3=/usr/include
1224         cf_cv_library_path_$3=/usr/lib
1225         cf_cv_library_file_$3="-l$3"
1226 ],[
1227         cf_cv_find_linkage_$3=no
1228         LIBS="$cf_save_LIBS"
1229
1230         CF_VERBOSE(find linkage for $3 library)
1231         CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1232
1233         cf_save_CPPFLAGS="$CPPFLAGS"
1234         cf_test_CPPFLAGS="$CPPFLAGS"
1235
1236         CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1237         for cf_cv_header_path_$3 in $cf_search
1238         do
1239                 if test -d "$cf_cv_header_path_$3" ; then
1240                         CF_VERBOSE(... testing $cf_cv_header_path_$3)
1241                         CPPFLAGS="$cf_save_CPPFLAGS"
1242                         CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
1243                         AC_TRY_COMPILE([$1],[$2],[
1244                                 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1245                                 cf_cv_find_linkage_$3=maybe
1246                                 cf_test_CPPFLAGS="$CPPFLAGS"
1247                                 break],[
1248                                 CPPFLAGS="$cf_save_CPPFLAGS"
1249                                 ])
1250                 fi
1251         done
1252
1253         if test "$cf_cv_find_linkage_$3" = maybe ; then
1254
1255                 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1256
1257                 cf_save_LIBS="$LIBS"
1258                 cf_save_LDFLAGS="$LDFLAGS"
1259
1260                 ifelse([$6],,,[
1261                 CPPFLAGS="$cf_test_CPPFLAGS"
1262                 LIBS="-l$3 $7 $cf_save_LIBS"
1263                 AC_TRY_LINK([$1],[$2],[
1264                         CF_VERBOSE(... found $3 library in system)
1265                         cf_cv_find_linkage_$3=yes])
1266                         CPPFLAGS="$cf_save_CPPFLAGS"
1267                         LIBS="$cf_save_LIBS"
1268                         ])
1269
1270                 if test "$cf_cv_find_linkage_$3" != yes ; then
1271                         CF_LIBRARY_PATH(cf_search,$3)
1272                         for cf_cv_library_path_$3 in $cf_search
1273                         do
1274                                 if test -d "$cf_cv_library_path_$3" ; then
1275                                         CF_VERBOSE(... testing $cf_cv_library_path_$3)
1276                                         CPPFLAGS="$cf_test_CPPFLAGS"
1277                                         LIBS="-l$3 $7 $cf_save_LIBS"
1278                                         LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1279                                         AC_TRY_LINK([$1],[$2],[
1280                                         CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1281                                         cf_cv_find_linkage_$3=yes
1282                                         cf_cv_library_file_$3="-l$3"
1283                                         break],[
1284                                         CPPFLAGS="$cf_save_CPPFLAGS"
1285                                         LIBS="$cf_save_LIBS"
1286                                         LDFLAGS="$cf_save_LDFLAGS"
1287                                         ])
1288                                 fi
1289                         done
1290                         CPPFLAGS="$cf_save_CPPFLAGS"
1291                         LDFLAGS="$cf_save_LDFLAGS"
1292                 fi
1293
1294         else
1295                 cf_cv_find_linkage_$3=no
1296         fi
1297         ],$7)
1298 ])
1299
1300 LIBS="$cf_save_LIBS"
1301
1302 if test "$cf_cv_find_linkage_$3" = yes ; then
1303 ifelse([$4],,[
1304         CF_ADD_INCDIR($cf_cv_header_path_$3)
1305         CF_ADD_LIBDIR($cf_cv_library_path_$3)
1306         CF_ADD_LIB($3)
1307 ],[$4])
1308 else
1309 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1310 fi
1311 ])dnl
1312 dnl ---------------------------------------------------------------------------
1313 dnl CF_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04
1314 dnl -----------------
1315 dnl make ADAFLAGS consistent with CFLAGS
1316 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
1317         AC_MSG_CHECKING(optimization options for ADAFLAGS)
1318         case "$CFLAGS" in
1319         (*-g*)
1320                 CF_ADD_ADAFLAGS(-g)
1321                 ;;
1322         esac
1323         case "$CFLAGS" in
1324         (*-O*)
1325                 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[        ]].*//'`
1326                 CF_ADD_ADAFLAGS($cf_O_flag)
1327                 ;;
1328         esac
1329         AC_MSG_RESULT($ADAFLAGS)
1330 ])dnl
1331 dnl ---------------------------------------------------------------------------
1332 dnl CF_FIX_WARNINGS version: 4 updated: 2021/12/16 18:22:31
1333 dnl ---------------
1334 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc.  Any of gcc's
1335 dnl "-Werror" flags can interfere with configure-checks.  Those go into
1336 dnl EXTRA_CFLAGS.
1337 dnl
1338 dnl $1 = variable name to repair
1339 define([CF_FIX_WARNINGS],[
1340 if test "$GCC" = yes || test "$GXX" = yes
1341 then
1342         case [$]$1 in
1343         (*-Werror=*)
1344                 cf_temp_flags=
1345                 for cf_temp_scan in [$]$1
1346                 do
1347                         case "x$cf_temp_scan" in
1348                         (x-Werror=format*)
1349                                 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
1350                                 ;;
1351                         (x-Werror=*)
1352                                 CF_APPEND_TEXT(EXTRA_CFLAGS,$cf_temp_scan)
1353                                 ;;
1354                         (*)
1355                                 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
1356                                 ;;
1357                         esac
1358                 done
1359                 if test "x[$]$1" != "x$cf_temp_flags"
1360                 then
1361                         CF_VERBOSE(repairing $1: [$]$1)
1362                         $1="$cf_temp_flags"
1363                         CF_VERBOSE(... fixed [$]$1)
1364                         CF_VERBOSE(... extra $EXTRA_CFLAGS)
1365                 fi
1366                 ;;
1367         esac
1368 fi
1369 AC_SUBST(EXTRA_CFLAGS)
1370 ])dnl
1371 dnl ---------------------------------------------------------------------------
1372 dnl CF_GCC_ATTRIBUTES version: 24 updated: 2021/03/20 12:00:25
1373 dnl -----------------
1374 dnl Test for availability of useful gcc __attribute__ directives to quiet
1375 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1376 dnl to documentation, unrecognized directives cause older compilers to barf.
1377 AC_DEFUN([CF_GCC_ATTRIBUTES],
1378 [AC_REQUIRE([AC_PROG_FGREP])dnl
1379 AC_REQUIRE([CF_C11_NORETURN])dnl
1380
1381 if test "$GCC" = yes || test "$GXX" = yes
1382 then
1383 cat > conftest.i <<EOF
1384 #ifndef GCC_PRINTF
1385 #define GCC_PRINTF 0
1386 #endif
1387 #ifndef GCC_SCANF
1388 #define GCC_SCANF 0
1389 #endif
1390 #ifndef GCC_NORETURN
1391 #define GCC_NORETURN /* nothing */
1392 #endif
1393 #ifndef GCC_UNUSED
1394 #define GCC_UNUSED /* nothing */
1395 #endif
1396 EOF
1397 if test "$GCC" = yes
1398 then
1399         AC_CHECKING([for $CC __attribute__ directives])
1400 cat > "conftest.$ac_ext" <<EOF
1401 #line __oline__ "${as_me:-configure}"
1402 #include "confdefs.h"
1403 #include "conftest.h"
1404 #include "conftest.i"
1405 #if     GCC_PRINTF
1406 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1407 #else
1408 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1409 #endif
1410 #if     GCC_SCANF
1411 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1412 #else
1413 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1414 #endif
1415 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1416 extern GCC_NORETURN void oops(char *,...) GCC_PRINTFLIKE(1,2);
1417 extern GCC_NORETURN void foo(void);
1418 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
1419 EOF
1420         cf_printf_attribute=no
1421         cf_scanf_attribute=no
1422         for cf_attribute in scanf printf unused noreturn
1423         do
1424                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1425                 cf_directive="__attribute__(($cf_attribute))"
1426                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1427
1428                 case "$cf_attribute" in
1429                 (printf)
1430                         cf_printf_attribute=yes
1431                         cat >conftest.h <<EOF
1432 #define GCC_$cf_ATTRIBUTE 1
1433 EOF
1434                         ;;
1435                 (scanf)
1436                         cf_scanf_attribute=yes
1437                         cat >conftest.h <<EOF
1438 #define GCC_$cf_ATTRIBUTE 1
1439 EOF
1440                         ;;
1441                 (*)
1442                         cat >conftest.h <<EOF
1443 #define GCC_$cf_ATTRIBUTE $cf_directive
1444 EOF
1445                         ;;
1446                 esac
1447
1448                 if AC_TRY_EVAL(ac_compile); then
1449                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1450                         cat conftest.h >>confdefs.h
1451                         case "$cf_attribute" in
1452                         (noreturn)
1453                                 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1454                                 ;;
1455                         (printf)
1456                                 cf_value='/* nothing */'
1457                                 if test "$cf_printf_attribute" != no ; then
1458                                         cf_value='__attribute__((format(printf,fmt,var)))'
1459                                         AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1460                                 fi
1461                                 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1462                                 ;;
1463                         (scanf)
1464                                 cf_value='/* nothing */'
1465                                 if test "$cf_scanf_attribute" != no ; then
1466                                         cf_value='__attribute__((format(scanf,fmt,var)))'
1467                                         AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1468                                 fi
1469                                 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1470                                 ;;
1471                         (unused)
1472                                 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
1473                                 ;;
1474                         esac
1475                 fi
1476         done
1477 else
1478         ${FGREP-fgrep} define conftest.i >>confdefs.h
1479 fi
1480 rm -rf ./conftest*
1481 fi
1482 ])dnl
1483 dnl ---------------------------------------------------------------------------
1484 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
1485 dnl --------------
1486 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
1487 dnl compatible), attempt to determine if icc/clang is actually used.
1488 AC_DEFUN([CF_GCC_VERSION],[
1489 AC_REQUIRE([AC_PROG_CC])
1490 GCC_VERSION=none
1491 if test "$GCC" = yes ; then
1492         AC_MSG_CHECKING(version of $CC)
1493         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.]].*//'`"
1494         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1495         AC_MSG_RESULT($GCC_VERSION)
1496 fi
1497 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1498 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
1499 ])dnl
1500 dnl ---------------------------------------------------------------------------
1501 dnl CF_GCC_WARNINGS version: 41 updated: 2021/01/01 16:53:59
1502 dnl ---------------
1503 dnl Check if the compiler supports useful warning options.  There's a few that
1504 dnl we don't use, simply because they're too noisy:
1505 dnl
1506 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1507 dnl     -Winline (usually not worthwhile)
1508 dnl     -Wredundant-decls (system headers make this too noisy)
1509 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1510 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1511 dnl             is enabled for ncurses using "--enable-const".
1512 dnl     -pedantic
1513 dnl
1514 dnl Parameter:
1515 dnl     $1 is an optional list of gcc warning flags that a particular
1516 dnl             application might want to use, e.g., "no-unused" for
1517 dnl             -Wno-unused
1518 dnl Special:
1519 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1520 dnl
1521 AC_DEFUN([CF_GCC_WARNINGS],
1522 [
1523 AC_REQUIRE([CF_GCC_VERSION])
1524 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
1525 cat > "conftest.$ac_ext" <<EOF
1526 #line __oline__ "${as_me:-configure}"
1527 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1528 EOF
1529 if test "$INTEL_COMPILER" = yes
1530 then
1531 # The "-wdXXX" options suppress warnings:
1532 # remark #1419: external declaration in primary source file
1533 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1534 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1535 # remark #193: zero used for undefined preprocessing identifier
1536 # remark #593: variable "curs_sb_left_arrow" was set but never used
1537 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1538 # remark #869: parameter "tw" was never referenced
1539 # remark #981: operands are evaluated in unspecified order
1540 # warning #279: controlling expression is constant
1541
1542         AC_CHECKING([for $CC warning options])
1543         cf_save_CFLAGS="$CFLAGS"
1544         EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
1545         for cf_opt in \
1546                 wd1419 \
1547                 wd1683 \
1548                 wd1684 \
1549                 wd193 \
1550                 wd593 \
1551                 wd279 \
1552                 wd810 \
1553                 wd869 \
1554                 wd981
1555         do
1556                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1557                 if AC_TRY_EVAL(ac_compile); then
1558                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1559                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1560                 fi
1561         done
1562         CFLAGS="$cf_save_CFLAGS"
1563 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
1564 then
1565         AC_CHECKING([for $CC warning options])
1566         cf_save_CFLAGS="$CFLAGS"
1567         cf_warn_CONST=""
1568         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1569         cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
1570         test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
1571         for cf_opt in W Wall \
1572                 Wbad-function-cast \
1573                 Wcast-align \
1574                 Wcast-qual \
1575                 Wdeclaration-after-statement \
1576                 Wextra \
1577                 Winline \
1578                 Wmissing-declarations \
1579                 Wmissing-prototypes \
1580                 Wnested-externs \
1581                 Wpointer-arith \
1582                 Wshadow \
1583                 Wstrict-prototypes \
1584                 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
1585         do
1586                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1587                 if AC_TRY_EVAL(ac_compile); then
1588                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1589                         case "$cf_opt" in
1590                         (Winline)
1591                                 case "$GCC_VERSION" in
1592                                 ([[34]].*)
1593                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1594                                         continue;;
1595                                 esac
1596                                 ;;
1597                         (Wpointer-arith)
1598                                 case "$GCC_VERSION" in
1599                                 ([[12]].*)
1600                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1601                                         continue;;
1602                                 esac
1603                                 ;;
1604                         esac
1605                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1606                 fi
1607         done
1608         CFLAGS="$cf_save_CFLAGS"
1609 fi
1610 rm -rf ./conftest*
1611
1612 AC_SUBST(EXTRA_CFLAGS)
1613 ])dnl
1614 dnl ---------------------------------------------------------------------------
1615 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
1616 dnl -----------------
1617 AC_DEFUN([CF_GNATPREP_OPT_T],[
1618 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
1619 cf_cv_gnatprep_opt_t=no
1620 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
1621 ])
1622 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
1623 AC_SUBST(GNATPREP_OPTS)
1624 ])dnl
1625 dnl ---------------------------------------------------------------------------
1626 dnl CF_GNAT_GENERICS version: 7 updated: 2021/01/01 13:31:04
1627 dnl ----------------
1628 AC_DEFUN([CF_GNAT_GENERICS],
1629 [
1630 AC_REQUIRE([CF_GNAT_VERSION])
1631
1632 AC_MSG_CHECKING(if GNAT supports generics)
1633 case "$cf_cv_gnat_version" in
1634 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
1635         cf_gnat_generics=yes
1636         ;;
1637 (*)
1638         cf_gnat_generics=no
1639         ;;
1640 esac
1641 AC_MSG_RESULT($cf_gnat_generics)
1642
1643 if test "$cf_gnat_generics" = yes
1644 then
1645         cf_compile_generics=generics
1646         cf_generic_objects="\${GENOBJS}"
1647 else
1648         cf_compile_generics=
1649         cf_generic_objects=
1650 fi
1651
1652 AC_SUBST(cf_compile_generics)
1653 AC_SUBST(cf_generic_objects)
1654 ])dnl
1655 dnl ---------------------------------------------------------------------------
1656 dnl CF_GNAT_PROJECTS version: 13 updated: 2021/01/02 17:09:14
1657 dnl ----------------
1658 dnl GNAT projects are configured with ".gpr" project files.
1659 dnl GNAT libraries are a further development, using the project feature.
1660 AC_DEFUN([CF_GNAT_PROJECTS],
1661 [
1662 AC_REQUIRE([CF_GNAT_VERSION])
1663 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
1664
1665 cf_gnat_libraries=no
1666 cf_gnat_projects=no
1667
1668 if test "$enable_gnat_projects" != no ; then
1669 AC_MSG_CHECKING(if GNAT supports project files)
1670 case "$cf_cv_gnat_version" in
1671 (3.[[0-9]]*)
1672         ;;
1673 (*)
1674         case "$cf_cv_system_name" in
1675         (cygwin*|msys*)
1676                 ;;
1677         (*)
1678                 rm -rf ./conftest* ./*~conftest*
1679                 if mkdir conftest.src conftest.bin conftest.lib
1680                 then
1681                         cd conftest.src
1682                         rm -rf ./conftest* ./*~conftest*
1683                         cat >>library.gpr <<CF_EOF
1684 project Library is
1685   Kind := External ("LIB_KIND");
1686   for Library_Name use "ConfTest";
1687   for Object_Dir use ".";
1688   for Library_ALI_Dir use External("LIBRARY_DIR");
1689   for Library_Version use External ("SONAME");
1690   for Library_Kind use Kind;
1691   for Library_Dir use External("BUILD_DIR");
1692   Source_Dir := External ("SOURCE_DIR");
1693   for Source_Dirs use (Source_Dir);
1694 end Library;
1695 CF_EOF
1696                         cat >>confpackage.ads <<CF_EOF
1697 package ConfPackage is
1698    procedure conftest;
1699 end ConfPackage;
1700 CF_EOF
1701                         cat >>confpackage.adb <<CF_EOF
1702 with Text_IO;
1703 package body ConfPackage is
1704    procedure conftest is
1705    begin
1706       Text_IO.Put ("Hello World");
1707       Text_IO.New_Line;
1708    end conftest;
1709 end ConfPackage;
1710 CF_EOF
1711                         if ( "$cf_ada_make" $ADAFLAGS \
1712                                         -Plibrary.gpr \
1713                                         -XBUILD_DIR="`cd ../conftest.bin;pwd`" \
1714                                         -XLIBRARY_DIR="`cd ../conftest.lib;pwd`" \
1715                                         -XSOURCE_DIR="`pwd`" \
1716                                         -XSONAME=libConfTest.so.1 \
1717                                         -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
1718                                 cf_gnat_projects=yes
1719                         fi
1720                         cd ..
1721                 fi
1722                 if test -f conftest.lib/confpackage.ali
1723                 then
1724                         cf_gnat_libraries=yes
1725                 fi
1726                 rm -rf ./conftest* ./*~conftest*
1727                 ;;
1728         esac
1729         ;;
1730 esac
1731 AC_MSG_RESULT($cf_gnat_projects)
1732 fi # enable_gnat_projects
1733
1734 if test "$cf_gnat_projects" = yes
1735 then
1736         AC_MSG_CHECKING(if GNAT supports libraries)
1737         AC_MSG_RESULT($cf_gnat_libraries)
1738 fi
1739
1740 USE_OLD_MAKERULES=""
1741 USE_GNAT_PROJECTS="#"
1742 USE_GNAT_MAKE_GPR="#"
1743 USE_GNAT_GPRBUILD="#"
1744
1745 if test "$cf_gnat_projects" = yes
1746 then
1747         USE_OLD_MAKERULES="#"
1748         USE_GNAT_PROJECTS=""
1749         if test "$cf_cv_VERSION_GPRBUILD" != no
1750         then
1751                 USE_GNAT_GPRBUILD=""
1752         elif test "$cf_cv_VERSION_GNATMAKE" != no
1753         then
1754                 USE_GNAT_MAKE_GPR=""
1755         else
1756                 AC_MSG_WARN(use old makefile rules since tools are missing)
1757         fi
1758 fi
1759
1760 if test "$cf_gnat_libraries" = yes
1761 then
1762         USE_GNAT_LIBRARIES=""
1763 else
1764         USE_GNAT_LIBRARIES="#"
1765 fi
1766
1767 AC_SUBST(USE_OLD_MAKERULES)
1768 AC_SUBST(USE_GNAT_PROJECTS)
1769 AC_SUBST(USE_GNAT_LIBRARIES)
1770 AC_SUBST(USE_GNAT_MAKE_GPR)
1771 AC_SUBST(USE_GNAT_GPRBUILD)
1772 ])dnl
1773 dnl ---------------------------------------------------------------------------
1774 dnl CF_GNAT_SIGINT version: 2 updated: 2021/01/01 13:31:04
1775 dnl --------------
1776 dnl Check if gnat supports SIGINT, and presumably tasking.  For the latter, it
1777 dnl is noted that gnat may compile a tasking unit even for configurations which
1778 dnl fail at runtime.
1779 AC_DEFUN([CF_GNAT_SIGINT],[
1780 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
1781 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
1782
1783 package ConfTest is
1784
1785    pragma Warnings (Off);  --  the next pragma exists since 3.11p
1786    pragma Unreserve_All_Interrupts;
1787    pragma Warnings (On);
1788
1789    protected Process is
1790       procedure Stop;
1791       function Continue return Boolean;
1792       pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
1793    private
1794       Done : Boolean := False;
1795    end Process;
1796
1797 end ConfTest;],
1798 [package body ConfTest is
1799    protected body Process is
1800       procedure Stop is
1801       begin
1802          Done := True;
1803       end Stop;
1804       function Continue return Boolean is
1805       begin
1806          return not Done;
1807       end Continue;
1808    end Process;
1809 end ConfTest;],
1810         [cf_cv_gnat_sigint=yes],
1811         [cf_cv_gnat_sigint=no])])
1812
1813 if test "$cf_cv_gnat_sigint" = yes ; then
1814         USE_GNAT_SIGINT=""
1815 else
1816         USE_GNAT_SIGINT="#"
1817 fi
1818 AC_SUBST(USE_GNAT_SIGINT)
1819 ])dnl
1820 dnl ---------------------------------------------------------------------------
1821 dnl CF_GNAT_TRY_LINK version: 4 updated: 2021/01/01 13:31:04
1822 dnl ----------------
1823 dnl Verify that a test program compiles/links with GNAT.
1824 dnl $cf_ada_make is set to the program that compiles/links
1825 dnl $ADAFLAGS may be set to the GNAT flags.
1826 dnl
1827 dnl $1 is the text of the spec
1828 dnl $2 is the text of the body
1829 dnl $3 is the shell command to execute if successful
1830 dnl $4 is the shell command to execute if not successful
1831 AC_DEFUN([CF_GNAT_TRY_LINK],
1832 [
1833 rm -rf ./conftest* ./*~conftest*
1834 cat >>conftest.ads <<CF_EOF
1835 $1
1836 CF_EOF
1837 cat >>conftest.adb <<CF_EOF
1838 $2
1839 CF_EOF
1840 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1841 ifelse($3,,      :,[      $3])
1842 ifelse($4,,,[else
1843    $4])
1844 fi
1845 rm -rf ./conftest* ./*~conftest*
1846 ])dnl
1847 dnl ---------------------------------------------------------------------------
1848 dnl CF_GNAT_TRY_RUN version: 6 updated: 2021/01/01 13:31:04
1849 dnl ---------------
1850 dnl Verify that a test program compiles and runs with GNAT
1851 dnl $cf_ada_make is set to the program that compiles/links
1852 dnl $ADAFLAGS may be set to the GNAT flags.
1853 dnl
1854 dnl $1 is the text of the spec
1855 dnl $2 is the text of the body
1856 dnl $3 is the shell command to execute if successful
1857 dnl $4 is the shell command to execute if not successful
1858 AC_DEFUN([CF_GNAT_TRY_RUN],
1859 [
1860 rm -rf ./conftest* ./*~conftest*
1861 cat >>conftest.ads <<CF_EOF
1862 $1
1863 CF_EOF
1864 cat >>conftest.adb <<CF_EOF
1865 $2
1866 CF_EOF
1867 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1868    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1869 ifelse($3,,      :,[      $3])
1870 ifelse($4,,,[   else
1871       $4])
1872    fi
1873 ifelse($4,,,[else
1874    $4])
1875 fi
1876 rm -rf ./conftest* ./*~conftest*
1877 ])dnl
1878 dnl ---------------------------------------------------------------------------
1879 dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54
1880 dnl ---------------
1881 dnl $1 = cache variable to update
1882 dnl $2 = program name
1883 dnl Verify version of GNAT or related tool
1884 AC_DEFUN([CF_GNAT_VERSION],
1885 [
1886 AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[
1887 cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \
1888         grep '[[0-9]].[[0-9]][[0-9]]*' |\
1889         sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1890 ])
1891 test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no
1892 ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version])
1893 ])dnl
1894 dnl ---------------------------------------------------------------------------
1895 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
1896 dnl -------------
1897 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1898 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1899 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1900 dnl since it is interwoven with GNU extensions.
1901 dnl
1902 dnl Well, yes we could work around it...
1903 dnl
1904 dnl Parameters:
1905 dnl     $1 is the nominal value for _XOPEN_SOURCE
1906 AC_DEFUN([CF_GNU_SOURCE],
1907 [
1908 cf_gnu_xopen_source=ifelse($1,,500,$1)
1909
1910 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
1911 AC_TRY_COMPILE([#include <sys/types.h>],[
1912         #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
1913                 return 0;
1914         #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
1915                 return 0;
1916         #else
1917         #       error not GNU C library
1918         #endif],
1919         [cf_cv_gnu_library=yes],
1920         [cf_cv_gnu_library=no])
1921 ])
1922
1923 if test x$cf_cv_gnu_library = xyes; then
1924
1925         # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
1926         # was changed to help a little.  newlib incorporated the change about 4
1927         # years later.
1928         AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
1929                 cf_save="$CPPFLAGS"
1930                 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1931                 AC_TRY_COMPILE([#include <sys/types.h>],[
1932                         #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
1933                                 return 0;
1934                         #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
1935                                 return 0;
1936                         #else
1937                         #       error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
1938                         #endif],
1939                         [cf_cv_gnu_library_219=yes],
1940                         [cf_cv_gnu_library_219=no])
1941                 CPPFLAGS="$cf_save"
1942         ])
1943
1944         if test "x$cf_cv_gnu_library_219" = xyes; then
1945                 cf_save="$CPPFLAGS"
1946                 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
1947                         CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
1948                         AC_TRY_COMPILE([
1949                                 #include <limits.h>
1950                                 #include <sys/types.h>
1951                                 ],[
1952                                 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
1953                                         return 0;
1954                                 #else
1955                                 #       error GNU C library is too old
1956                                 #endif],
1957                                 [cf_cv_gnu_dftsrc_219=yes],
1958                                 [cf_cv_gnu_dftsrc_219=no])
1959                         ])
1960                 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
1961         else
1962                 cf_cv_gnu_dftsrc_219=maybe
1963         fi
1964
1965         if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
1966
1967                 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1968                 AC_TRY_COMPILE([#include <sys/types.h>],[
1969                         #ifndef _XOPEN_SOURCE
1970                         #error  expected _XOPEN_SOURCE to be defined
1971                         #endif],
1972                         [cf_cv_gnu_source=no],
1973                         [cf_save="$CPPFLAGS"
1974                          CF_ADD_CFLAGS(-D_GNU_SOURCE)
1975                          AC_TRY_COMPILE([#include <sys/types.h>],[
1976                                 #ifdef _XOPEN_SOURCE
1977                                 #error  expected _XOPEN_SOURCE to be undefined
1978                                 #endif],
1979                                 [cf_cv_gnu_source=no],
1980                                 [cf_cv_gnu_source=yes])
1981                         CPPFLAGS="$cf_save"
1982                         ])
1983                 ])
1984
1985                 if test "$cf_cv_gnu_source" = yes
1986                 then
1987                 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
1988                         CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
1989                         AC_TRY_COMPILE([#include <sys/types.h>],[
1990                                 #ifdef _DEFAULT_SOURCE
1991                                 #error  expected _DEFAULT_SOURCE to be undefined
1992                                 #endif],
1993                                 [cf_cv_default_source=no],
1994                                 [cf_cv_default_source=yes])
1995                         ])
1996                         if test "$cf_cv_default_source" = yes
1997                         then
1998                                 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1999                         fi
2000                 fi
2001         fi
2002
2003 fi
2004 ])dnl
2005 dnl ---------------------------------------------------------------------------
2006 dnl CF_HEADER_PATH version: 15 updated: 2021/01/01 13:31:04
2007 dnl --------------
2008 dnl Construct a search-list of directories for a nonstandard header-file
2009 dnl
2010 dnl Parameters
2011 dnl     $1 = the variable to return as result
2012 dnl     $2 = the package name
2013 AC_DEFUN([CF_HEADER_PATH],
2014 [
2015 $1=
2016
2017 # collect the current set of include-directories from compiler flags
2018 cf_header_path_list=""
2019 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2020         for cf_header_path in $CPPFLAGS $CFLAGS
2021         do
2022                 case "$cf_header_path" in
2023                 (-I*)
2024                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2025                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2026                         cf_header_path_list="$cf_header_path_list [$]$1"
2027                         ;;
2028                 esac
2029         done
2030 fi
2031
2032 # add the variations for the package we are looking for
2033 CF_SUBDIR_PATH($1,$2,include)
2034
2035 test "$includedir" != NONE && \
2036 test "$includedir" != "/usr/include" && \
2037 test -d "$includedir" && {
2038         test -d "$includedir" &&    $1="[$]$1 $includedir"
2039         test -d "$includedir/$2" && $1="[$]$1 $includedir/$2"
2040 }
2041
2042 test "$oldincludedir" != NONE && \
2043 test "$oldincludedir" != "/usr/include" && \
2044 test -d "$oldincludedir" && {
2045         test -d "$oldincludedir"    && $1="[$]$1 $oldincludedir"
2046         test -d "$oldincludedir/$2" && $1="[$]$1 $oldincludedir/$2"
2047 }
2048
2049 $1="[$]$1 $cf_header_path_list"
2050 ])dnl
2051 dnl ---------------------------------------------------------------------------
2052 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
2053 dnl ---------------
2054 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2055 AC_DEFUN([CF_HELP_MESSAGE],
2056 [CF_ACVERSION_CHECK(2.53,[],[
2057 AC_DIVERT_HELP($1)])dnl
2058 ])dnl
2059 dnl ---------------------------------------------------------------------------
2060 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
2061 dnl ---------------
2062 dnl Construct the list of include-options according to whether we're building
2063 dnl in the source directory or using '--srcdir=DIR' option.
2064 AC_DEFUN([CF_INCLUDE_DIRS],
2065 [
2066 if test "$srcdir" != "."; then
2067         CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
2068 fi
2069 CPPFLAGS="-I../include $CPPFLAGS"
2070 if test "$srcdir" != "."; then
2071         CPPFLAGS="-I\${srcdir} $CPPFLAGS"
2072 fi
2073 CPPFLAGS="-I. $CPPFLAGS"
2074 AC_SUBST(CPPFLAGS)
2075 ])dnl
2076 dnl ---------------------------------------------------------------------------
2077 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
2078 dnl ---------------
2079 dnl prompt for/fill-in useful install-program options
2080 AC_DEFUN([CF_INSTALL_OPTS],
2081 [
2082 CF_INSTALL_OPT_S
2083 CF_INSTALL_OPT_P
2084 CF_INSTALL_OPT_O
2085 ])dnl
2086 dnl ---------------------------------------------------------------------------
2087 dnl CF_INSTALL_OPT_O version: 3 updated: 2020/12/31 20:19:42
2088 dnl ----------------
2089 dnl Almost all "install" programs default to the current user's ownership.
2090 dnl Almost - MINIX is an exception.
2091 AC_DEFUN([CF_INSTALL_OPT_O],
2092 [
2093 AC_MSG_CHECKING(if install needs to be told about ownership)
2094 case `$ac_config_guess` in
2095 (*minix)
2096         with_install_o=yes
2097         ;;
2098 (*)
2099         with_install_o=no
2100         ;;
2101 esac
2102
2103 AC_MSG_RESULT($with_install_o)
2104 if test "x$with_install_o" = xyes
2105 then
2106         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'`"
2107 else
2108         INSTALL_OPT_O=
2109 fi
2110
2111 AC_SUBST(INSTALL_OPT_O)
2112 ])dnl
2113 dnl ---------------------------------------------------------------------------
2114 dnl CF_INSTALL_OPT_P version: 3 updated: 2021/01/01 13:31:04
2115 dnl ----------------
2116 dnl Some install-programs accept a "-p" option to preserve file modification
2117 dnl timestamps.  That can be useful as an install option, as well as a way to
2118 dnl avoid the need for ranlib after copying a static archive.
2119 AC_DEFUN([CF_INSTALL_OPT_P],
2120 [
2121 : "${INSTALL:=install}"
2122 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
2123         rm -rf ./conftest*
2124         date >conftest.in
2125         mkdir conftest.out
2126         sleep 3
2127         if $INSTALL -p conftest.in conftest.out 2>/dev/null
2128         then
2129                 if test -f conftest.out/conftest.in
2130                 then
2131                         test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
2132                         test conftest.out/conftest.in -nt conftest.in 2>conftest.err
2133                         if test -s conftest.err
2134                         then
2135                                 cf_cv_install_p=no
2136                         else
2137                                 cf_cv_install_p=yes
2138                         fi
2139                 else
2140                         cf_cv_install_p=no
2141                 fi
2142         else
2143                 cf_cv_install_p=no
2144         fi
2145         rm -rf ./conftest*
2146 ])
2147 ])dnl
2148 dnl ---------------------------------------------------------------------------
2149 dnl CF_INSTALL_OPT_S version: 3 updated: 2021/01/05 19:23:48
2150 dnl ----------------
2151 dnl By default, we should strip executables which are installed, but leave the
2152 dnl ability to suppress that for unit-testing.
2153 AC_DEFUN([CF_INSTALL_OPT_S],
2154 [
2155 AC_MSG_CHECKING(if you want to install stripped executables)
2156 CF_ARG_DISABLE(stripping,
2157         [  --disable-stripping     do not strip (debug info) installed executables],
2158         [enable_stripping=no],
2159         [enable_stripping=yes])
2160 AC_MSG_RESULT($enable_stripping)
2161
2162 if test "$enable_stripping" = yes
2163 then
2164         INSTALL_OPT_S="-s"
2165 else
2166         INSTALL_OPT_S=
2167 fi
2168 AC_SUBST(INSTALL_OPT_S)
2169 ])dnl
2170 dnl ---------------------------------------------------------------------------
2171 dnl CF_INTEL_COMPILER version: 8 updated: 2021/01/01 16:53:59
2172 dnl -----------------
2173 dnl Check if the given compiler is really the Intel compiler for Linux.  It
2174 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2175 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2176 dnl
2177 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2178 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
2179 dnl the wrappers for gcc and g++ warnings.
2180 dnl
2181 dnl $1 = GCC (default) or GXX
2182 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2183 dnl $3 = CFLAGS (default) or CXXFLAGS
2184 AC_DEFUN([CF_INTEL_COMPILER],[
2185 AC_REQUIRE([AC_CANONICAL_HOST])
2186 ifelse([$2],,INTEL_COMPILER,[$2])=no
2187
2188 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2189         case "$host_os" in
2190         (linux*|gnu*)
2191                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2192                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2193                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2194                 AC_TRY_COMPILE([],[
2195 #ifdef __INTEL_COMPILER
2196 #else
2197 make an error
2198 #endif
2199 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2200 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2201 ],[])
2202                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2203                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2204                 ;;
2205         esac
2206 fi
2207 ])dnl
2208 dnl ---------------------------------------------------------------------------
2209 dnl CF_LARGEFILE version: 12 updated: 2020/03/19 20:23:48
2210 dnl ------------
2211 dnl Add checks for large file support.
2212 AC_DEFUN([CF_LARGEFILE],[
2213 ifdef([AC_FUNC_FSEEKO],[
2214         AC_SYS_LARGEFILE
2215         if test "$enable_largefile" != no ; then
2216         AC_FUNC_FSEEKO
2217
2218         # Normally we would collect these definitions in the config.h,
2219         # but (like _XOPEN_SOURCE), some environments rely on having these
2220         # defined before any of the system headers are included.  Another
2221         # case comes up with C++, e.g., on AIX the compiler compiles the
2222         # header files by themselves before looking at the body files it is
2223         # told to compile.  For ncurses, those header files do not include
2224         # the config.h
2225         if test "$ac_cv_sys_large_files" != no
2226         then
2227                 CF_APPEND_TEXT(CPPFLAGS,-D_LARGE_FILES)
2228         fi
2229         if test "$ac_cv_sys_largefile_source" != no
2230         then
2231                 CF_APPEND_TEXT(CPPFLAGS,-D_LARGEFILE_SOURCE)
2232         fi
2233         if test "$ac_cv_sys_file_offset_bits" != no
2234         then
2235                 CF_APPEND_TEXT(CPPFLAGS,-D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits)
2236         fi
2237
2238         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2239                 AC_TRY_COMPILE([
2240 #pragma GCC diagnostic error "-Wincompatible-pointer-types"
2241 #include <sys/types.h>
2242 #include <dirent.h>
2243                 ],[
2244                 /* if transitional largefile support is setup, this is true */
2245                 extern struct dirent64 * readdir(DIR *);
2246                 struct dirent64 *x = readdir((DIR *)0);
2247                 struct dirent *y = readdir((DIR *)0);
2248                 int z = x - y;
2249                 (void)z;
2250                 ],
2251                 [cf_cv_struct_dirent64=yes],
2252                 [cf_cv_struct_dirent64=no])
2253         ])
2254         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64])
2255         fi
2256 ])
2257 ])
2258 dnl ---------------------------------------------------------------------------
2259 dnl CF_LD_RPATH_OPT version: 9 updated: 2021/01/01 13:31:04
2260 dnl ---------------
2261 dnl For the given system and compiler, find the compiler flags to pass to the
2262 dnl loader to use the "rpath" feature.
2263 AC_DEFUN([CF_LD_RPATH_OPT],
2264 [
2265 AC_REQUIRE([CF_CHECK_CACHE])
2266
2267 LD_RPATH_OPT=
2268 if test "x$cf_cv_enable_rpath" != xno
2269 then
2270         AC_MSG_CHECKING(for an rpath option)
2271         case "$cf_cv_system_name" in
2272         (irix*)
2273                 if test "$GCC" = yes; then
2274                         LD_RPATH_OPT="-Wl,-rpath,"
2275                 else
2276                         LD_RPATH_OPT="-rpath "
2277                 fi
2278                 ;;
2279         (linux*|gnu*|k*bsd*-gnu|freebsd*)
2280                 LD_RPATH_OPT="-Wl,-rpath,"
2281                 ;;
2282         (openbsd[[2-9]].*|mirbsd*)
2283                 LD_RPATH_OPT="-Wl,-rpath,"
2284                 ;;
2285         (dragonfly*)
2286                 LD_RPATH_OPT="-rpath "
2287                 ;;
2288         (netbsd*)
2289                 LD_RPATH_OPT="-Wl,-rpath,"
2290                 ;;
2291         (osf*|mls+*)
2292                 LD_RPATH_OPT="-rpath "
2293                 ;;
2294         (solaris2*)
2295                 LD_RPATH_OPT="-R"
2296                 ;;
2297         (*)
2298                 ;;
2299         esac
2300         AC_MSG_RESULT($LD_RPATH_OPT)
2301
2302         case "x$LD_RPATH_OPT" in
2303         (x-R*)
2304                 AC_MSG_CHECKING(if we need a space after rpath option)
2305                 cf_save_LIBS="$LIBS"
2306                 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2307                 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2308                 LIBS="$cf_save_LIBS"
2309                 AC_MSG_RESULT($cf_rpath_space)
2310                 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2311                 ;;
2312         esac
2313 fi
2314 ])dnl
2315 dnl ---------------------------------------------------------------------------
2316 dnl CF_LIBRARY_PATH version: 11 updated: 2021/01/01 13:31:04
2317 dnl ---------------
2318 dnl Construct a search-list of directories for a nonstandard library-file
2319 dnl
2320 dnl Parameters
2321 dnl     $1 = the variable to return as result
2322 dnl     $2 = the package name
2323 AC_DEFUN([CF_LIBRARY_PATH],
2324 [
2325 $1=
2326 cf_library_path_list=""
2327 if test -n "${LDFLAGS}${LIBS}" ; then
2328         for cf_library_path in $LDFLAGS $LIBS
2329         do
2330                 case "$cf_library_path" in
2331                 (-L*)
2332                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2333                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2334                         cf_library_path_list="$cf_library_path_list [$]$1"
2335                         ;;
2336                 esac
2337         done
2338 fi
2339
2340 CF_SUBDIR_PATH($1,$2,lib)
2341
2342 $1="$cf_library_path_list [$]$1"
2343 ])dnl
2344 dnl ---------------------------------------------------------------------------
2345 dnl CF_LIB_PREFIX version: 14 updated: 2021/01/01 13:31:04
2346 dnl -------------
2347 dnl Compute the library-prefix for the given host system
2348 dnl $1 = variable to set
2349 define([CF_LIB_PREFIX],
2350 [
2351         case "$cf_cv_system_name" in
2352         (OS/2*|os2*)
2353                 if test "$DFT_LWR_MODEL" = libtool; then
2354                         LIB_PREFIX='lib'
2355                 else
2356                         LIB_PREFIX=''
2357                 fi
2358                 ;;
2359         (*-msvc*)
2360                 LIB_PREFIX=''
2361                 ;;
2362         (*)     LIB_PREFIX='lib'
2363                 ;;
2364         esac
2365 ifelse($1,,,[$1=$LIB_PREFIX])
2366         AC_SUBST(LIB_PREFIX)
2367 ])dnl
2368 dnl ---------------------------------------------------------------------------
2369 dnl CF_LIB_SUFFIX version: 28 updated: 2021/01/01 16:53:59
2370 dnl -------------
2371 dnl Compute the library file-suffix from the given model name
2372 dnl $1 = model name
2373 dnl $2 = variable to set (the nominal library suffix)
2374 dnl $3 = dependency variable to set (actual filename)
2375 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2376 AC_DEFUN([CF_LIB_SUFFIX],
2377 [
2378         case X$1 in
2379         (Xlibtool)
2380                 $2='.la'
2381                 $3=[$]$2
2382                 ;;
2383         (Xdebug)
2384                 case "$cf_cv_system_name" in
2385                 (*-msvc*)
2386                         $2='_g.lib'
2387                         ;;
2388                 (*)
2389                         $2='_g.a'
2390                         ;;
2391                 esac
2392                 $3=[$]$2
2393                 ;;
2394         (Xprofile)
2395                 case "$cf_cv_system_name" in
2396                 (*-msvc*)
2397                         $2='_p.lib'
2398                         ;;
2399                 (*)
2400                         $2='_p.a'
2401                         ;;
2402                 esac
2403                 $3=[$]$2
2404                 ;;
2405         (Xshared)
2406                 case "$cf_cv_system_name" in
2407                 (aix[[5-7]]*)
2408                         $2='.so'
2409                         $3=[$]$2
2410                         ;;
2411                 (*-msvc*)
2412                         $2='.dll'
2413                         $3='.dll.lib'
2414                         ;;
2415                 (cygwin*|msys*|mingw*)
2416                         $2='.dll'
2417                         $3='.dll.a'
2418                         ;;
2419                 (darwin*)
2420                         $2='.dylib'
2421                         $3=[$]$2
2422                         ;;
2423                 (hpux*)
2424                         case "$target" in
2425                         (ia64*)
2426                                 $2='.so'
2427                                 $3=[$]$2
2428                                 ;;
2429                         (*)
2430                                 $2='.sl'
2431                                 $3=[$]$2
2432                                 ;;
2433                         esac
2434                         ;;
2435                 (*)
2436                         $2='.so'
2437                         $3=[$]$2
2438                         ;;
2439                 esac
2440                 ;;
2441         (*)
2442                 case "$target" in
2443                 (*-msvc*)
2444                         $2='.lib'
2445                         ;;
2446                 (*)
2447                         $2='.a'
2448                         ;;
2449                 esac
2450                 $3=[$]$2
2451                 ;;
2452         esac
2453         if test -n "${LIB_SUFFIX}${EXTRA_SUFFIX}"
2454         then
2455                 $2="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$2}"
2456                 $3="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$3}"
2457         fi
2458 ])dnl
2459 dnl ---------------------------------------------------------------------------
2460 dnl CF_LIB_TYPE version: 5 updated: 2015/04/17 21:13:04
2461 dnl -----------
2462 dnl Compute the string to append to -library from the given model name
2463 dnl $1 = model name
2464 dnl $2 = variable to set
2465 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2466 AC_DEFUN([CF_LIB_TYPE],
2467 [
2468         case $1 in
2469         (libtool) $2=''   ;;
2470         (normal)  $2=''   ;;
2471         (debug)   $2='_g' ;;
2472         (profile) $2='_p' ;;
2473         (shared)  $2=''   ;;
2474         esac
2475         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2476 ])dnl
2477 dnl ---------------------------------------------------------------------------
2478 dnl CF_LINK_DATAONLY version: 13 updated: 2020/02/08 15:59:30
2479 dnl ----------------
2480 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2481 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
2482 dnl have to provide wrappers for global tables to ensure they're linked
2483 dnl properly.
2484 AC_DEFUN([CF_LINK_DATAONLY],
2485 [
2486 AC_MSG_CHECKING([if data-only library module links])
2487 AC_CACHE_VAL(cf_cv_link_dataonly,[
2488         rm -f conftest.a
2489         cat >conftest.$ac_ext <<EOF
2490 #line __oline__ "configure"
2491 int     testdata[[3]] = { 123, 456, 789 };
2492 EOF
2493         if AC_TRY_EVAL(ac_compile) ; then
2494                 mv conftest.o data.o && \
2495                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2496         fi
2497         rm -f conftest.$ac_ext data.o
2498         cat >conftest.$ac_ext <<EOF
2499 #line __oline__ "configure"
2500 int     testfunc(void)
2501 {
2502 #if defined(NeXT)
2503         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
2504 #else
2505         extern int testdata[[3]];
2506         return testdata[[0]] == 123
2507            &&  testdata[[1]] == 456
2508            &&  testdata[[2]] == 789;
2509 #endif
2510 }
2511 EOF
2512         if AC_TRY_EVAL(ac_compile); then
2513                 mv conftest.o func.o && \
2514                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2515         fi
2516         rm -f conftest.$ac_ext func.o
2517         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2518         cf_saveLIBS="$LIBS"
2519         LIBS="conftest.a $LIBS"
2520         AC_TRY_RUN([
2521         int main(void)
2522         {
2523                 extern int testfunc();
2524                 ${cf_cv_main_return:-return} (!testfunc());
2525         }
2526         ],
2527         [cf_cv_link_dataonly=yes],
2528         [cf_cv_link_dataonly=no],
2529         [cf_cv_link_dataonly=unknown])
2530         LIBS="$cf_saveLIBS"
2531         ])
2532 AC_MSG_RESULT($cf_cv_link_dataonly)
2533
2534 if test "$cf_cv_link_dataonly" = no ; then
2535         AC_DEFINE(BROKEN_LINKER,1,[if data-only library module does not link])
2536         BROKEN_LINKER=1
2537 fi
2538 AC_SUBST(BROKEN_LINKER)
2539
2540 ])dnl
2541 dnl ---------------------------------------------------------------------------
2542 dnl CF_MAKEFLAGS version: 21 updated: 2021/09/04 06:47:34
2543 dnl ------------
2544 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2545 dnl options to lower-levels.  It is very useful for "make -n" -- if we have it.
2546 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2547 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2548 AC_DEFUN([CF_MAKEFLAGS],
2549 [AC_REQUIRE([AC_PROG_FGREP])dnl
2550
2551 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2552         cf_cv_makeflags=''
2553         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2554         do
2555                 cat >cf_makeflags.tmp <<CF_EOF
2556 SHELL = $SHELL
2557 all :
2558         @ echo '.$cf_option'
2559 CF_EOF
2560                 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | ${FGREP-fgrep} -v "ing directory" | sed -e 's,[[  ]]*$,,'`
2561                 case "$cf_result" in
2562                 (.*k|.*kw)
2563                         cf_result="`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`"
2564                         case "$cf_result" in
2565                         (.*CC=*)        cf_cv_makeflags=
2566                                 ;;
2567                         (*)     cf_cv_makeflags=$cf_option
2568                                 ;;
2569                         esac
2570                         break
2571                         ;;
2572                 (.-)
2573                         ;;
2574                 (*)
2575                         CF_MSG_LOG(given option \"$cf_option\", no match \"$cf_result\")
2576                         ;;
2577                 esac
2578         done
2579         rm -f cf_makeflags.tmp
2580 ])
2581
2582 AC_SUBST(cf_cv_makeflags)
2583 ])dnl
2584 dnl ---------------------------------------------------------------------------
2585 dnl CF_MAKE_PHONY version: 3 updated: 2021/01/08 16:08:21
2586 dnl -------------
2587 dnl Check if the make-program handles a ".PHONY" target, e.g,. a target which
2588 dnl acts as a placeholder.
2589 dnl
2590 dnl The ".PHONY" feature was proposed in 2011 here
2591 dnl     https://www.austingroupbugs.net/view.php?id=523
2592 dnl and is scheduled for release in P1003.1 Issue 8 (late 2022).
2593 dnl
2594 dnl This is not supported by SVr4 make (or SunOS 4, 4.3SD, etc), but works with
2595 dnl a few others (i.e., GNU make and the non-POSIX "BSD" make):
2596 dnl
2597 dnl + This is a GNU make feature (since April 1988, but in turn from binutils,
2598 dnl   date unspecified).
2599 dnl
2600 dnl + It was adopted in NetBSD make in June 1995.
2601 dnl
2602 dnl + The other BSD make programs are derived from the NetBSD make (and for
2603 dnl   that reason are not actually different "implementations").
2604 dnl
2605 dnl + Some features of NetBSD make were actually adapted from pmake, which
2606 dnl   began as a modified GNU make starting in 1993.
2607 dnl
2608 dnl + Version 3.8 of the dmake program in January 1992 also implemented this
2609 dnl   GNU make extension, but is less well known than the BSD make.
2610 AC_DEFUN([CF_MAKE_PHONY],[
2611 AC_CACHE_CHECK(for \".PHONY\" make-support, cf_cv_make_PHONY,[
2612         rm -rf conftest*
2613         (
2614                 mkdir conftest || exit 1
2615                 cd conftest
2616                 cat >makefile <<'CF_EOF'
2617 .PHONY: always
2618 DATA=0
2619 always: always.out
2620         @echo "** making [$]@ [$](DATA)"
2621 once: once.out
2622         @echo "** making [$]@ [$](DATA)"
2623 always.out:
2624         @echo "** making [$]@ [$](DATA)"
2625         echo [$](DATA) > [$]@
2626 once.out:
2627         @echo "** making [$]@ [$](DATA)"
2628         echo [$](DATA) > [$]@
2629 CF_EOF
2630                 for cf_data in 1 2 3
2631                 do
2632                         ${MAKE:-make} always DATA=$cf_data
2633                         ${MAKE:-make} once   DATA=$cf_data
2634                         ${MAKE:-make} -t always once
2635                         if test -f always ; then
2636                                 echo "no (case 1)" > ../conftest.tmp
2637                         elif test ! -f always.out ; then
2638                                 echo "no (case 2)" > ../conftest.tmp
2639                         elif test ! -f once.out ; then
2640                                 echo "no (case 3)" > ../conftest.tmp
2641                         elif ! cmp -s always.out once.out ; then
2642                                 echo "no (case 4)" > ../conftest.tmp
2643                                 diff always.out once.out
2644                         else
2645                                 cf_check="`cat always.out`"
2646                                 if test "x$cf_check" != "x$cf_data" ; then
2647                                         echo "no (case 5)" > ../conftest.tmp
2648                                 else
2649                                         echo yes > ../conftest.tmp
2650                                         rm -f ./*.out
2651                                         continue
2652                                 fi
2653                         fi
2654                         break
2655                 done
2656         ) >&AC_FD_CC 2>&1
2657         cf_cv_make_PHONY="`cat conftest.tmp`"
2658         rm -rf conftest*
2659 ])
2660 MAKE_NO_PHONY="#"
2661 MAKE_PHONY="#"
2662 test "x$cf_cv_make_PHONY" = xyes && MAKE_PHONY=
2663 test "x$cf_cv_make_PHONY" != xyes && MAKE_NO_PHONY=
2664 AC_SUBST(MAKE_NO_PHONY)
2665 AC_SUBST(MAKE_PHONY)
2666 ])dnl
2667 dnl ---------------------------------------------------------------------------
2668 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
2669 dnl ------------
2670 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
2671 dnl a monocase filesystem.
2672 AC_DEFUN([CF_MAKE_TAGS],[
2673 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2674
2675 AC_CHECK_PROGS(CTAGS, exctags ctags)
2676 AC_CHECK_PROGS(ETAGS, exetags etags)
2677
2678 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
2679
2680 if test "$cf_cv_mixedcase" = yes ; then
2681         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
2682 else
2683         MAKE_UPPER_TAGS=no
2684 fi
2685
2686 if test "$MAKE_UPPER_TAGS" = yes ; then
2687         MAKE_UPPER_TAGS=
2688 else
2689         MAKE_UPPER_TAGS="#"
2690 fi
2691
2692 if test "$MAKE_LOWER_TAGS" = yes ; then
2693         MAKE_LOWER_TAGS=
2694 else
2695         MAKE_LOWER_TAGS="#"
2696 fi
2697
2698 AC_SUBST(CTAGS)
2699 AC_SUBST(ETAGS)
2700
2701 AC_SUBST(MAKE_UPPER_TAGS)
2702 AC_SUBST(MAKE_LOWER_TAGS)
2703 ])dnl
2704 dnl ---------------------------------------------------------------------------
2705 dnl CF_MIXEDCASE_FILENAMES version: 9 updated: 2021/01/01 16:53:59
2706 dnl ----------------------
2707 dnl Check if the file-system supports mixed-case filenames.  If we're able to
2708 dnl create a lowercase name and see it as uppercase, it doesn't support that.
2709 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
2710 [
2711 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
2712 if test "$cross_compiling" = yes ; then
2713         case "$target_alias" in
2714         (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*)
2715                 cf_cv_mixedcase=no
2716                 ;;
2717         (*)
2718                 cf_cv_mixedcase=yes
2719                 ;;
2720         esac
2721 else
2722         rm -f conftest CONFTEST
2723         echo test >conftest
2724         if test -f CONFTEST ; then
2725                 cf_cv_mixedcase=no
2726         else
2727                 cf_cv_mixedcase=yes
2728         fi
2729         rm -f conftest CONFTEST
2730 fi
2731 ])
2732 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
2733 ])dnl
2734 dnl ---------------------------------------------------------------------------
2735 dnl CF_MKSTEMP version: 11 updated: 2021/01/01 13:31:04
2736 dnl ----------
2737 dnl Check for a working mkstemp.  This creates two files, checks that they are
2738 dnl successfully created and distinct (AmigaOS apparently fails on the last).
2739 AC_DEFUN([CF_MKSTEMP],[
2740 AC_CHECK_HEADERS( \
2741 unistd.h \
2742 )
2743 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
2744 rm -rf ./conftest*
2745 AC_TRY_RUN([
2746 #include <sys/types.h>
2747 #ifdef HAVE_UNISTD_H
2748 #include <unistd.h>
2749 #endif
2750 #include <stdlib.h>
2751 #include <stdio.h>
2752 #include <string.h>
2753 #include <sys/stat.h>
2754 int main(void)
2755 {
2756         char *tmpl = "conftestXXXXXX";
2757         char name[2][80];
2758         int n;
2759         int result = 0;
2760         int fd;
2761         struct stat sb;
2762
2763         umask(077);
2764         for (n = 0; n < 2; ++n) {
2765                 strcpy(name[n], tmpl);
2766                 if ((fd = mkstemp(name[n])) >= 0) {
2767                         if (!strcmp(name[n], tmpl)
2768                          || stat(name[n], &sb) != 0
2769                          || (sb.st_mode & S_IFMT) != S_IFREG
2770                          || (sb.st_mode & 077) != 0) {
2771                                 result = 1;
2772                         }
2773                         close(fd);
2774                 }
2775         }
2776         if (result == 0
2777          && !strcmp(name[0], name[1]))
2778                 result = 1;
2779         ${cf_cv_main_return:-return}(result);
2780 }
2781 ],[cf_cv_func_mkstemp=yes
2782 ],[cf_cv_func_mkstemp=no
2783 ],[cf_cv_func_mkstemp=maybe])
2784 ])
2785 if test "x$cf_cv_func_mkstemp" = xmaybe ; then
2786         AC_CHECK_FUNC(mkstemp)
2787 fi
2788 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
2789         AC_DEFINE(HAVE_MKSTEMP,1,[Define to 1 if mkstemp() is available and working.])
2790 fi
2791 ])dnl
2792 dnl ---------------------------------------------------------------------------
2793 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
2794 dnl ----------
2795 dnl Write a debug message to config.log, along with the line number in the
2796 dnl configure script.
2797 AC_DEFUN([CF_MSG_LOG],[
2798 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
2799 ])dnl
2800 dnl ---------------------------------------------------------------------------
2801 dnl CF_NCURSES_ADDON version: 6 updated: 2021/01/04 19:33:05
2802 dnl ----------------
2803 dnl Configure an ncurses add-on, built outside the ncurses tree.
2804 AC_DEFUN([CF_NCURSES_ADDON],[
2805 AC_REQUIRE([CF_NCURSES_CONFIG])
2806
2807 AC_PROVIDE([CF_SUBST_NCURSES_VERSION])
2808
2809 AC_MSG_CHECKING(if you want wide-character code)
2810 AC_ARG_ENABLE(widec,
2811         [  --enable-widec          compile with wide-char/UTF-8 code],
2812         [with_widec=$enableval],
2813         [with_widec=no])
2814 AC_MSG_RESULT($with_widec)
2815 if test "$with_widec" = yes ; then
2816         CF_UTF8_LIB
2817         CF_NCURSES_CONFIG(ncursesw)
2818 else
2819         CF_NCURSES_CONFIG(ncurses)
2820 fi
2821
2822 if test "$NCURSES_CONFIG_PKG" != none ; then
2823         cf_version=`$PKG_CONFIG --modversion $NCURSES_CONFIG_PKG 2>/dev/null`
2824
2825         NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2826         NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
2827         NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
2828
2829         cf_cv_abi_version=`$PKG_CONFIG --variable=abi_version $NCURSES_CONFIG_PKG 2>/dev/null`
2830         if test -z "$cf_cv_abi_version"
2831         then
2832                 cf_cv_abi_version=`$PKG_CONFIG --variable=major_version $NCURSES_CONFIG_PKG 2>/dev/null`
2833         fi
2834
2835 elif test "$NCURSES_CONFIG" != none ; then
2836
2837         cf_version=`$NCURSES_CONFIG --version 2>/dev/null`
2838
2839         NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2840         NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
2841         NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
2842
2843         # ABI version is not available from headers
2844         cf_cv_abi_version=`$NCURSES_CONFIG --abi-version 2>/dev/null`
2845
2846 else
2847
2848         for cf_name in MAJOR MINOR PATCH
2849         do
2850         cat >conftest.$ac_ext <<CF_EOF
2851         #include <${cf_cv_ncurses_header:-curses.h}>
2852         AUTOCONF_$cf_name NCURSES_VERSION_$cf_name
2853 CF_EOF
2854                 cf_try="$ac_cpp conftest.$ac_ext 2>&5 | fgrep AUTOCONF_$cf_name >conftest.out"
2855                 AC_TRY_EVAL(cf_try)
2856                 if test -f conftest.out ; then
2857                         cf_result=`sed -e "s/^.*AUTOCONF_${cf_name}[[   ]][[    ]]*//" conftest.out`
2858                         eval NCURSES_$cf_name=\"$cf_result\"
2859                         # cat conftest.$ac_ext
2860                         # cat conftest.out
2861                 fi
2862         done
2863
2864         cf_cv_abi_version=${NCURSES_MAJOR}
2865
2866 fi
2867
2868 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
2869
2870 dnl Show the computed version, for logging
2871 cf_cv_timestamp=`date`
2872
2873 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
2874
2875 dnl We need these values in the generated headers
2876 AC_SUBST(NCURSES_MAJOR)
2877 AC_SUBST(NCURSES_MINOR)
2878 AC_SUBST(NCURSES_PATCH)
2879
2880 dnl We need these values in the generated makefiles
2881 AC_SUBST(cf_cv_rel_version)
2882 AC_SUBST(cf_cv_abi_version)
2883
2884 dnl FIXME - not needed for Ada95
2885 AC_SUBST(cf_cv_builtin_bool)
2886 AC_SUBST(cf_cv_header_stdbool_h)
2887 AC_SUBST(cf_cv_type_of_bool)dnl
2888
2889 ])
2890 dnl ---------------------------------------------------------------------------
2891 dnl CF_NCURSES_CC_CHECK version: 5 updated: 2020/12/31 20:19:42
2892 dnl -------------------
2893 dnl Check if we can compile with ncurses' header file
2894 dnl $1 is the cache variable to set
2895 dnl $2 is the header-file to include
2896 dnl $3 is the root name (ncurses or ncursesw)
2897 AC_DEFUN([CF_NCURSES_CC_CHECK],[
2898         AC_TRY_COMPILE([
2899 ]ifelse($3,ncursesw,[
2900 #define _XOPEN_SOURCE_EXTENDED
2901 #undef  HAVE_LIBUTF8_H  /* in case we used CF_UTF8_LIB */
2902 #define HAVE_LIBUTF8_H  /* to force ncurses' header file to use cchar_t */
2903 ])[
2904 #include <$2>],[
2905 #ifdef NCURSES_VERSION
2906 ]ifelse($3,ncursesw,[
2907 #ifndef WACS_BSSB
2908         make an error
2909 #endif
2910 ])[
2911 printf("%s\\n", NCURSES_VERSION);
2912 #else
2913 #ifdef __NCURSES_H
2914 printf("old\\n");
2915 #else
2916         make an error
2917 #endif
2918 #endif
2919         ]
2920         ,[$1=$2]
2921         ,[$1=no])
2922 ])dnl
2923 dnl ---------------------------------------------------------------------------
2924 dnl CF_NCURSES_CONFIG version: 28 updated: 2021/08/28 15:20:37
2925 dnl -----------------
2926 dnl Tie together the configure-script macros for ncurses, preferring these in
2927 dnl order:
2928 dnl a) ".pc" files for pkg-config, using $NCURSES_CONFIG_PKG
2929 dnl b) the "-config" script from ncurses, using $NCURSES_CONFIG
2930 dnl c) just plain libraries
2931 dnl
2932 dnl $1 is the root library name (default: "ncurses")
2933 AC_DEFUN([CF_NCURSES_CONFIG],[
2934 AC_REQUIRE([CF_PKG_CONFIG])
2935 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
2936 cf_have_ncuconfig=no
2937
2938 if test "x${PKG_CONFIG:=none}" != xnone; then
2939         AC_MSG_CHECKING(pkg-config for $cf_ncuconfig_root)
2940         if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
2941                 AC_MSG_RESULT(yes)
2942
2943                 AC_MSG_CHECKING(if the $cf_ncuconfig_root package files work)
2944                 cf_have_ncuconfig=unknown
2945
2946                 cf_save_CFLAGS="$CFLAGS"
2947                 cf_save_CPPFLAGS="$CPPFLAGS"
2948                 cf_save_LIBS="$LIBS"
2949
2950                 cf_pkg_cflags="`$PKG_CONFIG --cflags $cf_ncuconfig_root`"
2951                 cf_pkg_libs="`$PKG_CONFIG --libs $cf_ncuconfig_root`"
2952
2953                 # while -W for passing linker flags is prevalent, it is not "standard".
2954                 # At least one wrapper for c89/c99 (in Apple's xcode) has its own
2955                 # incompatible _and_ non-standard -W option which gives an error.  Work
2956                 # around that pitfall.
2957                 case "x${CC}@@${cf_pkg_libs}@${cf_pkg_cflags}" in
2958                 (x*c[[89]]9@@*-W*)
2959                         CF_ADD_CFLAGS($cf_pkg_cflags)
2960                         CF_ADD_LIBS($cf_pkg_libs)
2961
2962                         AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2963                                 [initscr(); mousemask(0,0); tigetstr((char *)0);],
2964                                 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2965                                         int main(void)
2966                                         { const char *xx = curses_version(); return (xx == 0); }],
2967                                         [cf_test_ncuconfig=yes],
2968                                         [cf_test_ncuconfig=no],
2969                                         [cf_test_ncuconfig=maybe])],
2970                                 [cf_test_ncuconfig=no])
2971
2972                         CFLAGS="$cf_save_CFLAGS"
2973                         CPPFLAGS="$cf_save_CPPFLAGS"
2974                         LIBS="$cf_save_LIBS"
2975
2976                         if test "x$cf_test_ncuconfig" != xyes; then
2977                                 cf_temp=`echo "x$cf_pkg_cflags" | sed -e s/^x// -e 's/-W[[^     ]]*//g'`
2978                                 cf_pkg_cflags="$cf_temp"
2979                                 cf_temp=`echo "x$cf_pkg_libs" | sed -e s/^x// -e 's/-W[[^       ]]*//g'`
2980                                 cf_pkg_libs="$cf_temp"
2981                         fi
2982                         ;;
2983                 esac
2984
2985                 CF_APPEND_CFLAGS($cf_pkg_cflags)
2986                 CF_ADD_LIBS($cf_pkg_libs)
2987
2988                 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2989                         [initscr(); mousemask(0,0); tigetstr((char *)0);],
2990                         [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2991                                 int main(void)
2992                                 { const char *xx = curses_version(); return (xx == 0); }],
2993                                 [cf_have_ncuconfig=yes],
2994                                 [cf_have_ncuconfig=no],
2995                                 [cf_have_ncuconfig=maybe])],
2996                         [cf_have_ncuconfig=no])
2997                 AC_MSG_RESULT($cf_have_ncuconfig)
2998                 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
2999                 if test "$cf_have_ncuconfig" != "yes"
3000                 then
3001                         CPPFLAGS="$cf_save_CPPFLAGS"
3002                         LIBS="$cf_save_LIBS"
3003                         NCURSES_CONFIG_PKG=none
3004                 else
3005                         AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3006                         NCURSES_CONFIG_PKG=$cf_ncuconfig_root
3007                         CF_TERM_HEADER
3008                 fi
3009
3010         else
3011                 AC_MSG_RESULT(no)
3012                 NCURSES_CONFIG_PKG=none
3013         fi
3014 else
3015         NCURSES_CONFIG_PKG=none
3016 fi
3017
3018 if test "x$cf_have_ncuconfig" = "xno"; then
3019         cf_ncurses_config="${cf_ncuconfig_root}${NCURSES_CONFIG_SUFFIX}-config"; echo "Looking for ${cf_ncurses_config}"
3020
3021         CF_ACVERSION_CHECK(2.52,
3022                 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
3023                 [AC_PATH_PROGS(NCURSES_CONFIG,  ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
3024
3025         if test "$NCURSES_CONFIG" != none ; then
3026
3027                 CF_APPEND_CFLAGS(`$NCURSES_CONFIG --cflags`)
3028                 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
3029
3030                 # even with config script, some packages use no-override for curses.h
3031                 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
3032
3033                 dnl like CF_NCURSES_CPPFLAGS
3034                 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3035
3036                 dnl like CF_NCURSES_LIBS
3037                 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
3038                 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
3039
3040                 dnl like CF_NCURSES_VERSION
3041                 cf_cv_ncurses_version="`$NCURSES_CONFIG --version`"
3042
3043         else
3044
3045                 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
3046                 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
3047
3048         fi
3049 else
3050         NCURSES_CONFIG=none
3051 fi
3052 ])dnl
3053 dnl ---------------------------------------------------------------------------
3054 dnl CF_NCURSES_CPPFLAGS version: 22 updated: 2021/01/02 09:31:20
3055 dnl -------------------
3056 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
3057 dnl the CPPFLAGS variable so we can include its header.
3058 dnl
3059 dnl The header files may be installed as either curses.h, or ncurses.h (would
3060 dnl be obsolete, except that some packagers prefer this name to distinguish it
3061 dnl from a "native" curses implementation).  If not installed for overwrite,
3062 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
3063 dnl /usr/include/ncurses), but someone may have installed overwriting the
3064 dnl vendor's curses.  Only very old versions (pre-1.9.2d, the first autoconf'd
3065 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
3066 dnl the header.
3067 dnl
3068 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
3069 dnl is already in the include-path, don't even bother with this, since we cannot
3070 dnl easily determine which file it is.  In this case, it has to be <curses.h>.
3071 dnl
3072 dnl The optional parameter gives the root name of the library, in case it is
3073 dnl not installed as the default curses library.  That is how the
3074 dnl wide-character version of ncurses is installed.
3075 AC_DEFUN([CF_NCURSES_CPPFLAGS],
3076 [AC_REQUIRE([CF_WITH_CURSES_DIR])
3077
3078 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
3079 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
3080
3081 test -n "$cf_cv_curses_dir" && \
3082 test "$cf_cv_curses_dir" != "no" && { \
3083   CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
3084 }
3085
3086 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
3087         cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
3088         { test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw; } && cf_header_list="$cf_header_list curses.h ncurses.h"
3089         for cf_header in $cf_header_list
3090         do
3091                 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
3092                 test "$cf_cv_ncurses_h" != no && break
3093         done
3094 ])
3095
3096 CF_NCURSES_HEADER
3097 CF_TERM_HEADER
3098
3099 # some applications need this, but should check for NCURSES_VERSION
3100 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3101
3102 CF_NCURSES_VERSION
3103 ])dnl
3104 dnl ---------------------------------------------------------------------------
3105 dnl CF_NCURSES_HEADER version: 7 updated: 2021/01/04 19:33:05
3106 dnl -----------------
3107 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
3108 dnl variations of ncurses' installs.
3109 dnl
3110 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
3111 AC_DEFUN([CF_NCURSES_HEADER],[
3112
3113 if test "$cf_cv_ncurses_h" != no ; then
3114         cf_cv_ncurses_header=$cf_cv_ncurses_h
3115 else
3116
3117 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
3118         test -n "$verbose" && echo
3119         CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
3120         test -n "$verbose" && echo "search path $cf_search"
3121         cf_save2_CPPFLAGS="$CPPFLAGS"
3122         for cf_incdir in $cf_search
3123         do
3124                 CF_ADD_INCDIR($cf_incdir)
3125                 for cf_header in \
3126                         ncurses.h \
3127                         curses.h
3128                 do
3129                         CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
3130                         if test "$cf_cv_ncurses_h2" != no ; then
3131                                 cf_cv_ncurses_h2=$cf_incdir/$cf_header
3132                                 test -n "$verbose" && echo $ECHO_N "    ... found $ECHO_C" 1>&AC_FD_MSG
3133                                 break
3134                         fi
3135                         test -n "$verbose" && echo "    ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
3136                 done
3137                 CPPFLAGS="$cf_save2_CPPFLAGS"
3138                 test "$cf_cv_ncurses_h2" != no && break
3139         done
3140         test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
3141         ])
3142
3143         CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
3144         cf_cv_ncurses_header="`basename "$cf_cv_ncurses_h2"`"
3145         if test "`basename "$cf_1st_incdir"`" = "$cf_ncuhdr_root" ; then
3146                 cf_cv_ncurses_header="$cf_ncuhdr_root/$cf_cv_ncurses_header"
3147         fi
3148         CF_ADD_INCDIR($cf_1st_incdir)
3149
3150 fi
3151
3152 # Set definitions to allow ifdef'ing for ncurses.h
3153
3154 case "$cf_cv_ncurses_header" in
3155 (*ncurses.h)
3156         AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
3157         ;;
3158 esac
3159
3160 case "$cf_cv_ncurses_header" in
3161 (ncurses/curses.h|ncurses/ncurses.h)
3162         AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
3163         ;;
3164 (ncursesw/curses.h|ncursesw/ncurses.h)
3165         AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
3166         ;;
3167 esac
3168
3169 ])dnl
3170 dnl ---------------------------------------------------------------------------
3171 dnl CF_NCURSES_LIBS version: 21 updated: 2021/09/04 06:37:12
3172 dnl ---------------
3173 dnl Look for the ncurses library.  This is a little complicated on Linux,
3174 dnl because it may be linked with the gpm (general purpose mouse) library.
3175 dnl Some distributions have gpm linked with (bsd) curses, which makes it
3176 dnl unusable with ncurses.  However, we don't want to link with gpm unless
3177 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
3178 dnl and the linker will record a dependency.
3179 dnl
3180 dnl The optional parameter gives the root name of the library, in case it is
3181 dnl not installed as the default curses library.  That is how the
3182 dnl wide-character version of ncurses is installed.
3183 AC_DEFUN([CF_NCURSES_LIBS],
3184 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
3185
3186 cf_nculib_root=ifelse($1,,ncurses,$1)
3187         # This works, except for the special case where we find gpm, but
3188         # ncurses is in a nonstandard location via $LIBS, and we really want
3189         # to link gpm.
3190 cf_ncurses_LIBS=""
3191 cf_ncurses_SAVE="$LIBS"
3192 AC_CHECK_LIB(gpm,Gpm_Open,
3193         [AC_CHECK_LIB(gpm,initscr,
3194                 [LIBS="$cf_ncurses_SAVE"],
3195                 [cf_ncurses_LIBS="-lgpm"])])
3196
3197 case "$host_os" in
3198 (freebsd*)
3199         # This is only necessary if you are linking against an obsolete
3200         # version of ncurses (but it should do no harm, since it is static).
3201         if test "$cf_nculib_root" = ncurses ; then
3202                 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
3203         fi
3204         ;;
3205 esac
3206
3207 CF_ADD_LIBS($cf_ncurses_LIBS)
3208
3209 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
3210 then
3211         CF_ADD_LIBS(-l$cf_nculib_root)
3212 else
3213         CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
3214                 [#include <${cf_cv_ncurses_header:-curses.h}>],
3215                 [initscr()],
3216                 initscr)
3217 fi
3218
3219 if test -n "$cf_ncurses_LIBS" ; then
3220         AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
3221         cf_ncurses_SAVE="$LIBS"
3222         for p in $cf_ncurses_LIBS ; do
3223                 q=`echo "$LIBS" | sed -e "s%$p %%" -e "s%$p$%%"`
3224                 if test "$q" != "$LIBS" ; then
3225                         LIBS="$q"
3226                 fi
3227         done
3228         AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
3229                 [initscr(); mousemask(0,0); tigetstr((char *)0);],
3230                 [AC_MSG_RESULT(yes)],
3231                 [AC_MSG_RESULT(no)
3232                  LIBS="$cf_ncurses_SAVE"])
3233 fi
3234
3235 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
3236 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
3237 ])dnl
3238 dnl ---------------------------------------------------------------------------
3239 dnl CF_NCURSES_VERSION version: 16 updated: 2020/12/31 20:19:42
3240 dnl ------------------
3241 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
3242 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS.  We don't use
3243 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
3244 AC_DEFUN([CF_NCURSES_VERSION],
3245 [
3246 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
3247 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
3248         cf_cv_ncurses_version=no
3249         cf_tempfile=out$$
3250         rm -f "$cf_tempfile"
3251         AC_TRY_RUN([
3252 #include <${cf_cv_ncurses_header:-curses.h}>
3253 #include <stdio.h>
3254 int main(void)
3255 {
3256         FILE *fp = fopen("$cf_tempfile", "w");
3257 #ifdef NCURSES_VERSION
3258 # ifdef NCURSES_VERSION_PATCH
3259         fprintf(fp, "%s.%d\\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
3260 # else
3261         fprintf(fp, "%s\\n", NCURSES_VERSION);
3262 # endif
3263 #else
3264 # ifdef __NCURSES_H
3265         fprintf(fp, "old\\n");
3266 # else
3267         make an error
3268 # endif
3269 #endif
3270         ${cf_cv_main_return:-return}(0);
3271 }],[
3272         cf_cv_ncurses_version=`cat $cf_tempfile`],,[
3273
3274         # This will not work if the preprocessor splits the line after the
3275         # Autoconf token.  The 'unproto' program does that.
3276         cat > "conftest.$ac_ext" <<EOF
3277 #include <${cf_cv_ncurses_header:-curses.h}>
3278 #undef Autoconf
3279 #ifdef NCURSES_VERSION
3280 Autoconf NCURSES_VERSION
3281 #else
3282 #ifdef __NCURSES_H
3283 Autoconf "old"
3284 #endif
3285 ;
3286 #endif
3287 EOF
3288         cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
3289         AC_TRY_EVAL(cf_try)
3290         if test -f conftest.out ; then
3291                 cf_out=`sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%' conftest.out`
3292                 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
3293                 rm -f conftest.out
3294         fi
3295 ])
3296         rm -f "$cf_tempfile"
3297 ])
3298 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3299 ])dnl
3300 dnl ---------------------------------------------------------------------------
3301 dnl CF_OBJ_SUBDIR version: 8 updated: 2021/01/01 13:31:04
3302 dnl -------------
3303 dnl Compute the object-directory name from the given model name
3304 AC_DEFUN([CF_OBJ_SUBDIR],
3305 [
3306         case $1 in
3307         (libtool) $2='obj_lo'  ;;
3308         (normal)  $2='objects' ;;
3309         (debug)   $2='obj_g' ;;
3310         (profile) $2='obj_p' ;;
3311         (shared)
3312                 case "$cf_cv_system_name" in
3313                 (cygwin|msys)
3314                         $2='objects' ;;
3315                 (*)
3316                         $2='obj_s' ;;
3317                 esac
3318         esac
3319 ])dnl
3320 dnl ---------------------------------------------------------------------------
3321 dnl CF_PATHSEP version: 8 updated: 2021/01/01 13:31:04
3322 dnl ----------
3323 dnl Provide a value for the $PATH and similar separator (or amend the value
3324 dnl as provided in autoconf 2.5x).
3325 AC_DEFUN([CF_PATHSEP],
3326 [
3327         AC_MSG_CHECKING(for PATH separator)
3328         case "$cf_cv_system_name" in
3329         (os2*)  PATH_SEPARATOR=';'  ;;
3330         (*)     ${PATH_SEPARATOR:=':'}  ;;
3331         esac
3332 ifelse([$1],,,[$1=$PATH_SEPARATOR])
3333         AC_SUBST(PATH_SEPARATOR)
3334         AC_MSG_RESULT($PATH_SEPARATOR)
3335 ])dnl
3336 dnl ---------------------------------------------------------------------------
3337 dnl CF_PATH_SYNTAX version: 18 updated: 2020/12/31 18:40:20
3338 dnl --------------
3339 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
3340 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3341 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
3342 dnl delayed evaluation of those symbols.
3343 AC_DEFUN([CF_PATH_SYNTAX],[
3344 if test "x$prefix" != xNONE; then
3345         cf_path_syntax="$prefix"
3346 else
3347         cf_path_syntax="$ac_default_prefix"
3348 fi
3349
3350 case ".[$]$1" in
3351 (.\[$]\(*\)*|.\'*\'*)
3352         ;;
3353 (..|./*|.\\*)
3354         ;;
3355 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
3356         ;;
3357 (.\[$]\{*prefix\}*|.\[$]\{*dir\}*)
3358         eval $1="[$]$1"
3359         case ".[$]$1" in
3360         (.NONE/*)
3361                 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3362                 ;;
3363         esac
3364         ;;
3365 (.no|.NONE/*)
3366         $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3367         ;;
3368 (*)
3369         ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3370         ;;
3371 esac
3372 ])dnl
3373 dnl ---------------------------------------------------------------------------
3374 dnl CF_PKG_CONFIG version: 12 updated: 2021/10/10 20:18:09
3375 dnl -------------
3376 dnl Check for the package-config program, unless disabled by command-line.
3377 dnl
3378 dnl Sets $PKG_CONFIG to the pathname of the pkg-config program.
3379 AC_DEFUN([CF_PKG_CONFIG],
3380 [
3381 AC_MSG_CHECKING(if you want to use pkg-config)
3382 AC_ARG_WITH(pkg-config,
3383         [  --with-pkg-config{=path} enable/disable use of pkg-config],
3384         [cf_pkg_config=$withval],
3385         [cf_pkg_config=yes])
3386 AC_MSG_RESULT($cf_pkg_config)
3387
3388 case "$cf_pkg_config" in
3389 (no)
3390         PKG_CONFIG=none
3391         ;;
3392 (yes)
3393         CF_ACVERSION_CHECK(2.52,
3394                 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
3395                 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
3396         ;;
3397 (*)
3398         PKG_CONFIG=$withval
3399         ;;
3400 esac
3401
3402 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3403 if test "$PKG_CONFIG" != none ; then
3404         CF_PATH_SYNTAX(PKG_CONFIG)
3405 elif test "x$cf_pkg_config" != xno ; then
3406         AC_MSG_WARN(pkg-config is not installed)
3407 fi
3408
3409 AC_SUBST(PKG_CONFIG)
3410 ])dnl
3411 dnl ---------------------------------------------------------------------------
3412 dnl CF_POSIX_C_SOURCE version: 11 updated: 2018/12/31 20:46:17
3413 dnl -----------------
3414 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3415 dnl
3416 dnl     POSIX.1-1990                            _POSIX_SOURCE
3417 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
3418 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
3419 dnl             Bindings Option
3420 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
3421 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
3422 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
3423 dnl
3424 dnl Parameters:
3425 dnl     $1 is the nominal value for _POSIX_C_SOURCE
3426 AC_DEFUN([CF_POSIX_C_SOURCE],
3427 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
3428
3429 if test "$cf_cv_posix_visible" = no; then
3430
3431 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
3432
3433 cf_save_CFLAGS="$CFLAGS"
3434 cf_save_CPPFLAGS="$CPPFLAGS"
3435
3436 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3437 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3438
3439 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3440         CF_MSG_LOG(if the symbol is already defined go no further)
3441         AC_TRY_COMPILE([#include <sys/types.h>],[
3442 #ifndef _POSIX_C_SOURCE
3443 make an error
3444 #endif],
3445         [cf_cv_posix_c_source=no],
3446         [cf_want_posix_source=no
3447          case .$cf_POSIX_C_SOURCE in
3448          (.[[12]]??*)
3449                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3450                 ;;
3451          (.2)
3452                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3453                 cf_want_posix_source=yes
3454                 ;;
3455          (.*)
3456                 cf_want_posix_source=yes
3457                 ;;
3458          esac
3459          if test "$cf_want_posix_source" = yes ; then
3460                 AC_TRY_COMPILE([#include <sys/types.h>],[
3461 #ifdef _POSIX_SOURCE
3462 make an error
3463 #endif],[],
3464                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3465          fi
3466          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3467          CFLAGS="$cf_trim_CFLAGS"
3468          CPPFLAGS="$cf_trim_CPPFLAGS"
3469          CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
3470          CF_MSG_LOG(if the second compile does not leave our definition intact error)
3471          AC_TRY_COMPILE([#include <sys/types.h>],[
3472 #ifndef _POSIX_C_SOURCE
3473 make an error
3474 #endif],,
3475          [cf_cv_posix_c_source=no])
3476          CFLAGS="$cf_save_CFLAGS"
3477          CPPFLAGS="$cf_save_CPPFLAGS"
3478         ])
3479 ])
3480
3481 if test "$cf_cv_posix_c_source" != no ; then
3482         CFLAGS="$cf_trim_CFLAGS"
3483         CPPFLAGS="$cf_trim_CPPFLAGS"
3484         CF_ADD_CFLAGS($cf_cv_posix_c_source)
3485 fi
3486
3487 fi # cf_cv_posix_visible
3488
3489 ])dnl
3490 dnl ---------------------------------------------------------------------------
3491 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
3492 dnl ----------------
3493 dnl POSIX documents test-macros which an application may set before any system
3494 dnl headers are included to make features available.
3495 dnl
3496 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
3497 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
3498 dnl recent features visible in the system header files unless the application
3499 dnl overrides the corresponding test-macros.  Doing that introduces portability
3500 dnl problems.
3501 dnl
3502 dnl This macro makes a special check for the symbols used for this, to avoid a
3503 dnl conflicting definition.
3504 AC_DEFUN([CF_POSIX_VISIBLE],
3505 [
3506 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
3507 AC_TRY_COMPILE([#include <stdio.h>],[
3508 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
3509         && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
3510         && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
3511         && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
3512 #error conflicting symbols found
3513 #endif
3514 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
3515 ])
3516 ])dnl
3517 dnl ---------------------------------------------------------------------------
3518 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
3519 dnl ----------
3520 dnl Check for archiver "ar".
3521 AC_DEFUN([CF_PROG_AR],[
3522 AC_CHECK_TOOL(AR, ar, ar)
3523 ])
3524 dnl ---------------------------------------------------------------------------
3525 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3526 dnl -----------
3527 dnl Check for awk, ensure that the check found something.
3528 AC_DEFUN([CF_PROG_AWK],
3529 [
3530 AC_PROG_AWK
3531 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3532 ])dnl
3533 dnl ---------------------------------------------------------------------------
3534 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
3535 dnl ----------
3536 dnl standard check for CC, plus followup sanity checks
3537 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
3538 AC_DEFUN([CF_PROG_CC],[
3539 CF_ACVERSION_CHECK(2.53,
3540         [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
3541          AC_REQUIRE([AC_PROG_CC])],
3542         [])
3543 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
3544 CF_GCC_VERSION
3545 CF_ACVERSION_CHECK(2.52,
3546         [AC_PROG_CC_STDC],
3547         [CF_ANSI_CC_REQD])
3548 CF_CC_ENV_FLAGS
3549 ])dnl
3550 dnl ---------------------------------------------------------------------------
3551 dnl CF_PROG_CC_C_O version: 6 updated: 2021/01/01 13:31:04
3552 dnl --------------
3553 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3554 dnl the output file can be renamed, and allows for a shell variable that can
3555 dnl be used later.  The parameter is either CC or CXX.  The result is the
3556 dnl cache variable:
3557 dnl     $cf_cv_prog_CC_c_o
3558 dnl     $cf_cv_prog_CXX_c_o
3559 dnl
3560 dnl $1 = compiler
3561 dnl $2 = compiler options, if any
3562 AC_DEFUN([CF_PROG_CC_C_O],
3563 [AC_REQUIRE([AC_PROG_CC])dnl
3564 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3565 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3566 [
3567 cat > conftest.$ac_ext <<CF_EOF
3568 int main(void)
3569 {
3570         ${cf_cv_main_return:-return}(0);
3571 }
3572 CF_EOF
3573 # We do the test twice because some compilers refuse to overwrite an
3574 # existing .o file with -o, though they will create one.
3575 ac_try='[$]$1 $2 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3576 if AC_TRY_EVAL(ac_try) &&
3577   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3578 then
3579   eval cf_cv_prog_$1_c_o=yes
3580 else
3581   eval cf_cv_prog_$1_c_o=no
3582 fi
3583 rm -rf ./conftest*
3584 ])dnl
3585 if test "$cf_cv_prog_$1_c_o" = yes; then
3586   AC_MSG_RESULT([yes])
3587 else
3588   AC_MSG_RESULT([no])
3589 fi
3590 ])dnl
3591 dnl ---------------------------------------------------------------------------
3592 dnl CF_PROG_EGREP version: 2 updated: 2015/04/18 08:56:57
3593 dnl -------------
3594 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3595 dnl This macro adds a check to ensure the script found something.
3596 AC_DEFUN([CF_PROG_EGREP],
3597 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3598         [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3599                 then ac_cv_prog_egrep='grep -E'
3600                 else ac_cv_prog_egrep='egrep'
3601         fi])
3602         EGREP=$ac_cv_prog_egrep
3603         AC_SUBST([EGREP])
3604         test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3605 ])dnl
3606 dnl ---------------------------------------------------------------------------
3607 dnl CF_PROG_EXT version: 15 updated: 2021/01/02 09:31:20
3608 dnl -----------
3609 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3610 AC_DEFUN([CF_PROG_EXT],
3611 [
3612 AC_REQUIRE([CF_CHECK_CACHE])
3613 case "$cf_cv_system_name" in
3614 (os2*)
3615         CFLAGS="$CFLAGS -Zmt"
3616         CF_APPEND_TEXT(CPPFLAGS,-D__ST_MT_ERRNO__)