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