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