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