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