ncurses 5.7 - patch 20100501
[ncurses.git] / aclocal.m4
1 dnl***************************************************************************
2 dnl Copyright (c) 1998-2009,2010 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 1995-on
30 dnl
31 dnl $Id: aclocal.m4,v 1.515 2010/05/01 19:16:13 tom Exp $
32 dnl Macros used in NCURSES 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 AM_LANGINFO_CODESET version: 3 updated: 2002/10/27 23:21:42
43 dnl -------------------
44 dnl Inserted as requested by gettext 0.10.40
45 dnl File from /usr/share/aclocal
46 dnl codeset.m4
47 dnl ====================
48 dnl serial AM1
49 dnl
50 dnl From Bruno Haible.
51 AC_DEFUN([AM_LANGINFO_CODESET],
52 [
53   AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset,
54     [AC_TRY_LINK([#include <langinfo.h>],
55       [char* cs = nl_langinfo(CODESET);],
56       am_cv_langinfo_codeset=yes,
57       am_cv_langinfo_codeset=no)
58     ])
59   if test $am_cv_langinfo_codeset = yes; then
60     AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
61       [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
62   fi
63 ])dnl
64 dnl ---------------------------------------------------------------------------
65 dnl CF_ADA_INCLUDE_DIRS version: 6 updated: 2010/02/26 19:52:07
66 dnl -------------------
67 dnl Construct the list of include-options for the C programs in the Ada95
68 dnl binding.
69 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
70 [
71 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
72 if test "$srcdir" != "."; then
73         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
74 fi
75 if test "$GCC" != yes; then
76         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
77 elif test "$includedir" != "/usr/include"; then
78         if test "$includedir" = '${prefix}/include' ; then
79                 if test $prefix != /usr ; then
80                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
81                 fi
82         else
83                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
84         fi
85 fi
86 AC_SUBST(ACPPFLAGS)
87 ])dnl
88 dnl ---------------------------------------------------------------------------
89 dnl CF_ADD_CFLAGS version: 9 updated: 2010/01/09 11:05:50
90 dnl -------------
91 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
92 dnl The second parameter if given makes this macro verbose.
93 dnl
94 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
95 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
96 dnl confused by the quotes (which require backslashes to keep them usable).
97 AC_DEFUN([CF_ADD_CFLAGS],
98 [
99 cf_fix_cppflags=no
100 cf_new_cflags=
101 cf_new_cppflags=
102 cf_new_extra_cppflags=
103
104 for cf_add_cflags in $1
105 do
106 case $cf_fix_cppflags in
107 no)
108         case $cf_add_cflags in #(vi
109         -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi
110                 case $cf_add_cflags in
111                 -D*)
112                         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
113
114                         test "${cf_add_cflags}" != "${cf_tst_cflags}" \
115                                 && test -z "${cf_tst_cflags}" \
116                                 && cf_fix_cppflags=yes
117
118                         if test $cf_fix_cppflags = yes ; then
119                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
120                                 continue
121                         elif test "${cf_tst_cflags}" = "\"'" ; then
122                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
123                                 continue
124                         fi
125                         ;;
126                 esac
127                 case "$CPPFLAGS" in
128                 *$cf_add_cflags) #(vi
129                         ;;
130                 *) #(vi
131                         case $cf_add_cflags in #(vi
132                         -D*)
133                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
134                                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
135                                 ;;
136                         esac
137                         cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
138                         ;;
139                 esac
140                 ;;
141         *)
142                 cf_new_cflags="$cf_new_cflags $cf_add_cflags"
143                 ;;
144         esac
145         ;;
146 yes)
147         cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
148
149         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
150
151         test "${cf_add_cflags}" != "${cf_tst_cflags}" \
152                 && test -z "${cf_tst_cflags}" \
153                 && cf_fix_cppflags=no
154         ;;
155 esac
156 done
157
158 if test -n "$cf_new_cflags" ; then
159         ifelse($2,,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
160         CFLAGS="$CFLAGS $cf_new_cflags"
161 fi
162
163 if test -n "$cf_new_cppflags" ; then
164         ifelse($2,,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
165         CPPFLAGS="$CPPFLAGS $cf_new_cppflags"
166 fi
167
168 if test -n "$cf_new_extra_cppflags" ; then
169         ifelse($2,,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
170         EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
171 fi
172
173 AC_SUBST(EXTRA_CPPFLAGS)
174
175 ])dnl
176 dnl ---------------------------------------------------------------------------
177 dnl CF_ADD_INCDIR version: 12 updated: 2009/01/18 10:00:47
178 dnl -------------
179 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it's
180 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
181 dnl but old versions (and some misinstalled ones) need that.  To make things
182 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
183 dnl the include-path).
184 AC_DEFUN([CF_ADD_INCDIR],
185 [
186 if test -n "$1" ; then
187   for cf_add_incdir in $1
188   do
189         while test $cf_add_incdir != /usr/include
190         do
191           if test -d $cf_add_incdir
192           then
193                 cf_have_incdir=no
194                 if test -n "$CFLAGS$CPPFLAGS" ; then
195                   # a loop is needed to ensure we can add subdirs of existing dirs
196                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
197                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
198                           cf_have_incdir=yes; break
199                         fi
200                   done
201                 fi
202
203                 if test "$cf_have_incdir" = no ; then
204                   if test "$cf_add_incdir" = /usr/local/include ; then
205                         if test "$GCC" = yes
206                         then
207                           cf_save_CPPFLAGS=$CPPFLAGS
208                           CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
209                           AC_TRY_COMPILE([#include <stdio.h>],
210                                   [printf("Hello")],
211                                   [],
212                                   [cf_have_incdir=yes])
213                           CPPFLAGS=$cf_save_CPPFLAGS
214                         fi
215                   fi
216                 fi
217
218                 if test "$cf_have_incdir" = no ; then
219                   CF_VERBOSE(adding $cf_add_incdir to include-path)
220                   ifelse($2,,CPPFLAGS,$2)="$ifelse($2,,CPPFLAGS,$2) -I$cf_add_incdir"
221
222                   cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
223                   test "$cf_top_incdir" = "$cf_add_incdir" && break
224                   cf_add_incdir="$cf_top_incdir"
225                 else
226                   break
227                 fi
228           fi
229         done
230   done
231 fi
232 ])dnl
233 dnl ---------------------------------------------------------------------------
234 dnl CF_ADD_LIBDIR version: 8 updated: 2009/01/18 10:01:08
235 dnl -------------
236 dnl     Adds to the library-path
237 dnl
238 dnl     Some machines have trouble with multiple -L options.
239 dnl
240 dnl $1 is the (list of) directory(s) to add
241 dnl $2 is the optional name of the variable to update (default LDFLAGS)
242 dnl
243 AC_DEFUN([CF_ADD_LIBDIR],
244 [
245 if test -n "$1" ; then
246   for cf_add_libdir in $1
247   do
248     if test $cf_add_libdir = /usr/lib ; then
249       :
250     elif test -d $cf_add_libdir
251     then
252       cf_have_libdir=no
253       if test -n "$LDFLAGS$LIBS" ; then
254         # a loop is needed to ensure we can add subdirs of existing dirs
255         for cf_test_libdir in $LDFLAGS $LIBS ; do
256           if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
257             cf_have_libdir=yes; break
258           fi
259         done
260       fi
261       if test "$cf_have_libdir" = no ; then
262         CF_VERBOSE(adding $cf_add_libdir to library-path)
263         ifelse($2,,LDFLAGS,$2)="-L$cf_add_libdir $ifelse($2,,LDFLAGS,$2)"
264       fi
265     fi
266   done
267 fi
268 ])dnl
269 dnl ---------------------------------------------------------------------------
270 dnl CF_ADD_SUBDIR_PATH version: 2 updated: 2007/07/29 10:12:59
271 dnl ------------------
272 dnl Append to a search-list for a nonstandard header/lib-file
273 dnl     $1 = the variable to return as result
274 dnl     $2 = the package name
275 dnl     $3 = the subdirectory, e.g., bin, include or lib
276 dnl $4 = the directory under which we will test for subdirectories
277 dnl $5 = a directory that we do not want $4 to match
278 AC_DEFUN([CF_ADD_SUBDIR_PATH],
279 [
280 test "$4" != "$5" && \
281 test -d "$4" && \
282 ifelse([$5],NONE,,[(test $5 = NONE || test -d $5) &&]) {
283         test -n "$verbose" && echo "    ... testing for $3-directories under $4"
284         test -d $4/$3 &&          $1="[$]$1 $4/$3"
285         test -d $4/$3/$2 &&       $1="[$]$1 $4/$3/$2"
286         test -d $4/$3/$2/$3 &&    $1="[$]$1 $4/$3/$2/$3"
287         test -d $4/$2/$3 &&       $1="[$]$1 $4/$2/$3"
288         test -d $4/$2/$3/$2 &&    $1="[$]$1 $4/$2/$3/$2"
289 }
290 ])dnl
291 dnl ---------------------------------------------------------------------------
292 dnl CF_ANSI_CC_CHECK version: 9 updated: 2001/12/30 17:53:34
293 dnl ----------------
294 dnl This is adapted from the macros 'fp_PROG_CC_STDC' and 'fp_C_PROTOTYPES'
295 dnl in the sharutils 4.2 distribution.
296 AC_DEFUN([CF_ANSI_CC_CHECK],
297 [
298 AC_CACHE_CHECK(for ${CC-cc} option to accept ANSI C, cf_cv_ansi_cc,[
299 cf_cv_ansi_cc=no
300 cf_save_CFLAGS="$CFLAGS"
301 cf_save_CPPFLAGS="$CPPFLAGS"
302 # Don't try gcc -ansi; that turns off useful extensions and
303 # breaks some systems' header files.
304 # AIX                   -qlanglvl=ansi
305 # Ultrix and OSF/1      -std1
306 # HP-UX                 -Aa -D_HPUX_SOURCE
307 # SVR4                  -Xc
308 # UnixWare 1.2          (cannot use -Xc, since ANSI/POSIX clashes)
309 for cf_arg in "-DCC_HAS_PROTOS" \
310         "" \
311         -qlanglvl=ansi \
312         -std1 \
313         -Ae \
314         "-Aa -D_HPUX_SOURCE" \
315         -Xc
316 do
317         CF_ADD_CFLAGS($cf_arg)
318         AC_TRY_COMPILE(
319 [
320 #ifndef CC_HAS_PROTOS
321 #if !defined(__STDC__) || (__STDC__ != 1)
322 choke me
323 #endif
324 #endif
325 ],[
326         int test (int i, double x);
327         struct s1 {int (*f) (int a);};
328         struct s2 {int (*f) (double a);};],
329         [cf_cv_ansi_cc="$cf_arg"; break])
330 done
331 CFLAGS="$cf_save_CFLAGS"
332 CPPFLAGS="$cf_save_CPPFLAGS"
333 ])
334
335 if test "$cf_cv_ansi_cc" != "no"; then
336 if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then
337         CF_ADD_CFLAGS($cf_cv_ansi_cc)
338 else
339         AC_DEFINE(CC_HAS_PROTOS)
340 fi
341 fi
342 ])dnl
343 dnl ---------------------------------------------------------------------------
344 dnl CF_ANSI_CC_REQD version: 4 updated: 2008/03/23 14:48:54
345 dnl ---------------
346 dnl For programs that must use an ANSI compiler, obtain compiler options that
347 dnl will make it recognize prototypes.  We'll do preprocessor checks in other
348 dnl macros, since tools such as unproto can fake prototypes, but only part of
349 dnl the preprocessor.
350 AC_DEFUN([CF_ANSI_CC_REQD],
351 [AC_REQUIRE([CF_ANSI_CC_CHECK])
352 if test "$cf_cv_ansi_cc" = "no"; then
353         AC_MSG_ERROR(
354 [Your compiler does not appear to recognize prototypes.
355 You have the following choices:
356         a. adjust your compiler options
357         b. get an up-to-date compiler
358         c. use a wrapper such as unproto])
359 fi
360 ])dnl
361 dnl ---------------------------------------------------------------------------
362 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
363 dnl --------------
364 dnl Allow user to disable a normally-on option.
365 AC_DEFUN([CF_ARG_DISABLE],
366 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
367 dnl ---------------------------------------------------------------------------
368 dnl CF_ARG_OPTION version: 3 updated: 1997/10/18 14:42:41
369 dnl -------------
370 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
371 dnl values.
372 dnl
373 dnl Parameters:
374 dnl $1 = option name
375 dnl $2 = help-string
376 dnl $3 = action to perform if option is not default
377 dnl $4 = action if perform if option is default
378 dnl $5 = default option value (either 'yes' or 'no')
379 AC_DEFUN([CF_ARG_OPTION],
380 [AC_ARG_ENABLE($1,[$2],[test "$enableval" != ifelse($5,no,yes,no) && enableval=ifelse($5,no,no,yes)
381   if test "$enableval" != "$5" ; then
382 ifelse($3,,[    :]dnl
383 ,[    $3]) ifelse($4,,,[
384   else
385     $4])
386   fi],[enableval=$5 ifelse($4,,,[
387   $4
388 ])dnl
389   ])])dnl
390 dnl ---------------------------------------------------------------------------
391 dnl CF_AR_FLAGS version: 4 updated: 2009/02/07 13:42:23
392 dnl -----------
393 dnl Check for suitable "ar" (archiver) options for updating an archive.
394 AC_DEFUN([CF_AR_FLAGS],[
395 AC_REQUIRE([CF_PROG_AR])
396
397 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
398         cf_cv_ar_flags=unknown
399         for cf_ar_flags in -curv curv -crv crv -cqv cqv -rv rv
400         do
401                 rm -f conftest.$ac_cv_objext
402                 rm -f conftest.a
403
404                 cat >conftest.$ac_ext <<EOF
405 #line __oline__ "configure"
406 int     testdata[[3]] = { 123, 456, 789 };
407 EOF
408                 if AC_TRY_EVAL(ac_compile) ; then
409                         $AR $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null
410                         if test -f conftest.a ; then
411                                 cf_cv_ar_flags=$cf_ar_flags
412                                 break
413                         fi
414                 else
415                         CF_VERBOSE(cannot compile test-program)
416                         break
417                 fi
418         done
419         rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
420 ])
421 test -z "$ARFLAGS" && ARFLAGS=$cf_cv_ar_flags
422 AC_SUBST(ARFLAGS,$cf_cv_ar_flags)
423 ])
424 dnl ---------------------------------------------------------------------------
425 dnl CF_AWK_BIG_PRINTF version: 3 updated: 2008/12/27 12:30:03
426 dnl -----------------
427 dnl Check if awk can handle big strings using printf.  Some older versions of
428 dnl awk choke on large strings passed via "%s".
429 dnl
430 dnl $1 = desired string size
431 dnl $2 = variable to set with result
432 AC_DEFUN([CF_AWK_BIG_PRINTF],
433 [
434         case x$AWK in #(vi
435         x)
436                 eval $2=no
437                 ;;
438         *) #(vi
439                 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' \
440                         | $AWK '{ printf "%d\n", length([$]0); }' | $AWK 'BEGIN { eqls=0; recs=0; } { recs++; if ([$]0 == 12000) eqls++; } END { if (recs != 1 || eqls != 1) exit 1; }' 2>/dev/null >/dev/null ) ; then
441                         eval $2=yes
442                 else
443                         eval $2=no
444                 fi
445                 ;;
446         esac
447 ])dnl
448 dnl ---------------------------------------------------------------------------
449 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
450 dnl ------------
451 dnl Test if 'bool' is a builtin type in the configured C++ compiler.  Some
452 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
453 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
454 dnl
455 dnl Treat the configuration-variable specially here, since we're directly
456 dnl substituting its value (i.e., 1/0).
457 dnl
458 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
459 AC_DEFUN([CF_BOOL_DECL],
460 [
461 AC_MSG_CHECKING(if we should include stdbool.h)
462
463 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
464         AC_TRY_COMPILE([],[bool foo = false],
465                 [cf_cv_header_stdbool_h=0],
466                 [AC_TRY_COMPILE([
467 #ifndef __BEOS__
468 #include <stdbool.h>
469 #endif
470 ],[bool foo = false],
471                         [cf_cv_header_stdbool_h=1],
472                         [cf_cv_header_stdbool_h=0])])])
473
474 if test "$cf_cv_header_stdbool_h" = 1
475 then    AC_MSG_RESULT(yes)
476 else    AC_MSG_RESULT(no)
477 fi
478
479 AC_MSG_CHECKING([for builtin bool type])
480
481 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
482         AC_TRY_COMPILE([
483 #include <stdio.h>
484 #include <sys/types.h>
485 ],[bool x = false],
486                 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
487                 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
488         ])
489
490 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
491 then    AC_MSG_RESULT(yes)
492 else    AC_MSG_RESULT(no)
493 fi
494 ])dnl
495 dnl ---------------------------------------------------------------------------
496 dnl CF_BOOL_SIZE version: 12 updated: 2006/12/16 12:33:30
497 dnl ------------
498 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
499 dnl Don't bother looking for bool.h, since it's been deprecated.
500 dnl
501 dnl If the current compiler is C rather than C++, we get the bool definition
502 dnl from <stdbool.h>.
503 AC_DEFUN([CF_BOOL_SIZE],
504 [
505 AC_MSG_CHECKING([for size of bool])
506 AC_CACHE_VAL(cf_cv_type_of_bool,[
507         rm -f cf_test.out
508         AC_TRY_RUN([
509 #include <stdlib.h>
510 #include <stdio.h>
511
512 #if defined(__cplusplus)
513
514 #ifdef HAVE_GXX_BUILTIN_H
515 #include <g++/builtin.h>
516 #elif HAVE_GPP_BUILTIN_H
517 #include <gpp/builtin.h>
518 #elif HAVE_BUILTIN_H
519 #include <builtin.h>
520 #endif
521
522 #else
523
524 #if $cf_cv_header_stdbool_h
525 #include <stdbool.h>
526 #endif
527
528 #endif
529
530 main()
531 {
532         FILE *fp = fopen("cf_test.out", "w");
533         if (fp != 0) {
534                 bool x = true;
535                 if ((bool)(-x) >= 0)
536                         fputs("unsigned ", fp);
537                 if (sizeof(x) == sizeof(int))       fputs("int",  fp);
538                 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
539                 else if (sizeof(x) == sizeof(short))fputs("short",fp);
540                 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
541                 fclose(fp);
542         }
543         ${cf_cv_main_return:-return}(0);
544 }
545                 ],
546                 [cf_cv_type_of_bool=`cat cf_test.out`
547                  if test -z "$cf_cv_type_of_bool"; then
548                    cf_cv_type_of_bool=unknown
549                  fi],
550                 [cf_cv_type_of_bool=unknown],
551                 [cf_cv_type_of_bool=unknown])
552         ])
553         rm -f cf_test.out
554 AC_MSG_RESULT($cf_cv_type_of_bool)
555 if test "$cf_cv_type_of_bool" = unknown ; then
556         case .$NCURSES_BOOL in #(vi
557         .auto|.) NCURSES_BOOL=unsigned;;
558         esac
559         AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
560         cf_cv_type_of_bool=$NCURSES_BOOL
561 fi
562 ])dnl
563 dnl ---------------------------------------------------------------------------
564 dnl CF_BUILD_CC version: 6 updated: 2006/10/14 15:23:15
565 dnl -----------
566 dnl If we're cross-compiling, allow the user to override the tools and their
567 dnl options.  The configure script is oriented toward identifying the host
568 dnl compiler, etc., but we need a build compiler to generate parts of the
569 dnl source.
570 dnl
571 dnl $1 = default for $CPPFLAGS
572 dnl $2 = default for $LIBS
573 AC_DEFUN([CF_BUILD_CC],[
574 AC_REQUIRE([CF_PROG_EXT])
575 if test "$cross_compiling" = yes ; then
576
577         # defaults that we might want to override
578         : ${BUILD_CFLAGS:=''}
579         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
580         : ${BUILD_LDFLAGS:=''}
581         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
582         : ${BUILD_EXEEXT:='$x'}
583         : ${BUILD_OBJEXT:='o'}
584
585         AC_ARG_WITH(build-cc,
586                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
587                 [BUILD_CC="$withval"],
588                 [AC_CHECK_PROGS(BUILD_CC, gcc cc cl)])
589         AC_MSG_CHECKING(for native build C compiler)
590         AC_MSG_RESULT($BUILD_CC)
591
592         AC_MSG_CHECKING(for native build C preprocessor)
593         AC_ARG_WITH(build-cpp,
594                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
595                 [BUILD_CPP="$withval"],
596                 [BUILD_CPP='${BUILD_CC} -E'])
597         AC_MSG_RESULT($BUILD_CPP)
598
599         AC_MSG_CHECKING(for native build C flags)
600         AC_ARG_WITH(build-cflags,
601                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
602                 [BUILD_CFLAGS="$withval"])
603         AC_MSG_RESULT($BUILD_CFLAGS)
604
605         AC_MSG_CHECKING(for native build C preprocessor-flags)
606         AC_ARG_WITH(build-cppflags,
607                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
608                 [BUILD_CPPFLAGS="$withval"])
609         AC_MSG_RESULT($BUILD_CPPFLAGS)
610
611         AC_MSG_CHECKING(for native build linker-flags)
612         AC_ARG_WITH(build-ldflags,
613                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
614                 [BUILD_LDFLAGS="$withval"])
615         AC_MSG_RESULT($BUILD_LDFLAGS)
616
617         AC_MSG_CHECKING(for native build linker-libraries)
618         AC_ARG_WITH(build-libs,
619                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
620                 [BUILD_LIBS="$withval"])
621         AC_MSG_RESULT($BUILD_LIBS)
622
623         # this assumes we're on Unix.
624         BUILD_EXEEXT=
625         BUILD_OBJEXT=o
626
627         : ${BUILD_CC:='${CC}'}
628
629         if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
630                 AC_MSG_ERROR([Cross-build requires two compilers.
631 Use --with-build-cc to specify the native compiler.])
632         fi
633
634 else
635         : ${BUILD_CC:='${CC}'}
636         : ${BUILD_CPP:='${CPP}'}
637         : ${BUILD_CFLAGS:='${CFLAGS}'}
638         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
639         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
640         : ${BUILD_LIBS:='${LIBS}'}
641         : ${BUILD_EXEEXT:='$x'}
642         : ${BUILD_OBJEXT:='o'}
643 fi
644
645 AC_SUBST(BUILD_CC)
646 AC_SUBST(BUILD_CPP)
647 AC_SUBST(BUILD_CFLAGS)
648 AC_SUBST(BUILD_CPPFLAGS)
649 AC_SUBST(BUILD_LDFLAGS)
650 AC_SUBST(BUILD_LIBS)
651 AC_SUBST(BUILD_EXEEXT)
652 AC_SUBST(BUILD_OBJEXT)
653 ])dnl
654 dnl ---------------------------------------------------------------------------
655 dnl CF_CFG_DEFAULTS version: 7 updated: 2005/09/24 16:15:00
656 dnl ---------------
657 dnl Determine the default configuration into which we'll install ncurses.  This
658 dnl can be overridden by the user's command-line options.  There's two items to
659 dnl look for:
660 dnl     1. the prefix (e.g., /usr)
661 dnl     2. the header files (e.g., /usr/include/ncurses)
662 dnl We'll look for a previous installation of ncurses and use the same defaults.
663 dnl
664 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
665 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
666 dnl programs from a vendor's.
667 AC_DEFUN([CF_CFG_DEFAULTS],
668 [
669 AC_MSG_CHECKING(for prefix)
670 if test "x$prefix" = "xNONE" ; then
671         case "$cf_cv_system_name" in
672                 # non-vendor systems don't have a conflict
673         openbsd*|freebsd*|linux*|cygwin*|k*bsd*-gnu)
674                 prefix=/usr
675                 ;;
676         *)      prefix=$ac_default_prefix
677                 ;;
678         esac
679 fi
680 AC_MSG_RESULT($prefix)
681
682 if test "x$prefix" = "xNONE" ; then
683 AC_MSG_CHECKING(for default include-directory)
684 test -n "$verbose" && echo 1>&AC_FD_MSG
685 for cf_symbol in \
686         $includedir \
687         $includedir/ncurses \
688         $prefix/include \
689         $prefix/include/ncurses \
690         /usr/local/include \
691         /usr/local/include/ncurses \
692         /usr/include \
693         /usr/include/ncurses
694 do
695         cf_dir=`eval echo $cf_symbol`
696         if test -f $cf_dir/curses.h ; then
697         if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
698                 includedir="$cf_symbol"
699                 test -n "$verbose"  && echo $ac_n "     found " 1>&AC_FD_MSG
700                 break
701         fi
702         fi
703         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
704 done
705 AC_MSG_RESULT($includedir)
706 fi
707 ])dnl
708 dnl ---------------------------------------------------------------------------
709 dnl CF_CGETENT version: 3 updated: 2000/08/12 23:18:52
710 dnl ----------
711 dnl Check if the terminal-capability database functions are available.  If not,
712 dnl ncurses has a much-reduced version.
713 AC_DEFUN([CF_CGETENT],[
714 AC_MSG_CHECKING(for terminal-capability database functions)
715 AC_CACHE_VAL(cf_cv_cgetent,[
716 AC_TRY_LINK([
717 #include <stdlib.h>],[
718         char temp[128];
719         char *buf = temp;
720         char *db_array = temp;
721         cgetent(&buf, /* int *, */ &db_array, "vt100");
722         cgetcap(buf, "tc", '=');
723         cgetmatch(buf, "tc");
724         ],
725         [cf_cv_cgetent=yes],
726         [cf_cv_cgetent=no])
727 ])
728 AC_MSG_RESULT($cf_cv_cgetent)
729 test "$cf_cv_cgetent" = yes && AC_DEFINE(HAVE_BSD_CGETENT)
730 ])dnl
731 dnl ---------------------------------------------------------------------------
732 dnl CF_CHECK_CACHE version: 11 updated: 2008/03/23 14:45:59
733 dnl --------------
734 dnl Check if we're accidentally using a cache from a different machine.
735 dnl Derive the system name, as a check for reusing the autoconf cache.
736 dnl
737 dnl If we've packaged config.guess and config.sub, run that (since it does a
738 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
739 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
740 dnl which is useful in cross-compiles.
741 dnl
742 dnl Note: we would use $ac_config_sub, but that is one of the places where
743 dnl autoconf 2.5x broke compatibility with autoconf 2.13
744 AC_DEFUN([CF_CHECK_CACHE],
745 [
746 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
747         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
748         system_name="$host_os"
749 else
750         system_name="`(uname -s -r) 2>/dev/null`"
751         if test -z "$system_name" ; then
752                 system_name="`(hostname) 2>/dev/null`"
753         fi
754 fi
755 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name")
756 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
757
758 test -z "$system_name" && system_name="$cf_cv_system_name"
759 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
760
761 if test ".$system_name" != ".$cf_cv_system_name" ; then
762         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
763         AC_MSG_ERROR("Please remove config.cache and try again.")
764 fi
765 ])dnl
766 dnl ---------------------------------------------------------------------------
767 dnl CF_CHECK_ERRNO version: 10 updated: 2008/08/22 16:33:22
768 dnl --------------
769 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
770 dnl the 'errno' variable.  Define a DECL_xxx symbol if we must declare it
771 dnl ourselves.
772 dnl
773 dnl $1 = the name to check
774 dnl $2 = the assumed type
775 AC_DEFUN([CF_CHECK_ERRNO],
776 [
777 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
778     AC_TRY_COMPILE([
779 #ifdef HAVE_STDLIB_H
780 #include <stdlib.h>
781 #endif
782 #include <stdio.h>
783 #include <sys/types.h>
784 #include <errno.h> ],
785     ifelse($2,,int,$2) x = (ifelse($2,,int,$2)) $1,
786     [cf_cv_dcl_$1=yes],
787     [cf_cv_dcl_$1=no])
788 ])
789
790 if test "$cf_cv_dcl_$1" = no ; then
791     CF_UPPER(cf_result,decl_$1)
792     AC_DEFINE_UNQUOTED($cf_result)
793 fi
794
795 # It's possible (for near-UNIX clones) that the data doesn't exist
796 CF_CHECK_EXTERN_DATA($1,ifelse($2,,int,$2))
797 ])dnl
798 dnl ---------------------------------------------------------------------------
799 dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23
800 dnl --------------------
801 dnl Check for existence of external data in the current set of libraries.  If
802 dnl we can modify it, it's real enough.
803 dnl $1 = the name to check
804 dnl $2 = its type
805 AC_DEFUN([CF_CHECK_EXTERN_DATA],
806 [
807 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
808     AC_TRY_LINK([
809 #undef $1
810 extern $2 $1;
811 ],
812     [$1 = 2],
813     [cf_cv_have_$1=yes],
814     [cf_cv_have_$1=no])
815 ])
816
817 if test "$cf_cv_have_$1" = yes ; then
818     CF_UPPER(cf_result,have_$1)
819     AC_DEFINE_UNQUOTED($cf_result)
820 fi
821
822 ])dnl
823 dnl ---------------------------------------------------------------------------
824 dnl CF_CHECK_GPM_WGETCH version: 1 updated: 2007/04/28 14:38:06
825 dnl -------------------
826 dnl Check if GPM is already linked with curses.  If so - and if the linkage
827 dnl is not "weak" - warn about this because it can create problems linking
828 dnl applications with ncurses.
829 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
830 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
831
832 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
833 cf_cv_check_gpm_wgetch=unknown
834 if test "$cross_compiling" != yes ; then
835
836 cat >conftest.$ac_ext <<CF_EOF
837 #include <gpm.h>
838 int main()
839 {
840         Gpm_Wgetch();
841         ${cf_cv_main_return:-return}(0);
842 }
843 CF_EOF
844
845         cf_save_LIBS="$LIBS"
846         # This only works if we can look at the symbol table.  If a shared
847         # library is stripped for install, we cannot use that.  So we're forced
848         # to rely on the static library, noting that some packagers may not
849         # include it.
850         LIBS="-static -lgpm -dynamic $LIBS"
851         if AC_TRY_EVAL(ac_compile) ; then
852                 if AC_TRY_EVAL(ac_link) ; then
853                         cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
854                         test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
855                         test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
856                 fi
857         fi
858         rm -f conftest*
859         LIBS="$cf_save_LIBS"
860 fi
861 ])
862
863 if test "$cf_cv_check_gpm_wgetch" != yes ; then
864         AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
865 fi
866 ])])dnl
867 dnl ---------------------------------------------------------------------------
868 dnl CF_CPP_PARAM_INIT version: 4 updated: 2001/04/07 22:31:18
869 dnl -----------------
870 dnl Check if the C++ compiler accepts duplicate parameter initialization.  This
871 dnl is a late feature for the standard and is not in some recent compilers
872 dnl (1999/9/11).
873 AC_DEFUN([CF_CPP_PARAM_INIT],
874 [
875 if test -n "$CXX"; then
876 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
877         AC_LANG_SAVE
878         AC_LANG_CPLUSPLUS
879         AC_TRY_RUN([
880 class TEST {
881 private:
882         int value;
883 public:
884         TEST(int x = 1);
885         ~TEST();
886 };
887
888 TEST::TEST(int x = 1)   // some compilers do not like second initializer
889 {
890         value = x;
891 }
892 void main() { }
893 ],
894         [cf_cv_cpp_param_init=yes],
895         [cf_cv_cpp_param_init=no],
896         [cf_cv_cpp_param_init=unknown])
897         AC_LANG_RESTORE
898 ])
899 fi
900 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT)
901 ])dnl
902 dnl ---------------------------------------------------------------------------
903 dnl CF_CPP_STATIC_CAST version: 1 updated: 2005/07/23 16:52:43
904 dnl ------------------
905 dnl Check if the C++ compiler accepts static_cast in generics.  This appears to
906 dnl not be supported in g++ before 3.0
907 AC_DEFUN([CF_CPP_STATIC_CAST],
908 [
909 if test -n "$CXX"; then
910
911 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
912         AC_LANG_SAVE
913         AC_LANG_CPLUSPLUS
914
915         AC_TRY_COMPILE([
916 class NCursesPanel
917 {
918 public:
919   NCursesPanel(int nlines,
920                int ncols,
921                int begin_y = 0,
922                int begin_x = 0)
923   {
924   }
925
926   ~NCursesPanel();
927 };
928
929 template<class T> class NCursesUserPanel : public NCursesPanel
930 {
931 public:
932   NCursesUserPanel (int nlines,
933                     int ncols,
934                     int begin_y = 0,
935                     int begin_x = 0,
936                     const T* p_UserData = static_cast<T*>(0))
937     : NCursesPanel (nlines, ncols, begin_y, begin_x)
938   {
939   };
940   NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
941   {
942   };
943
944   virtual ~NCursesUserPanel() {};
945 };
946 ],[
947         const char* p_UserData = static_cast<char*>(0)],
948         [cf_cv_cpp_static_cast=yes],
949         [cf_cv_cpp_static_cast=no])
950
951         AC_LANG_RESTORE
952 ])
953
954 fi
955
956 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST)
957 ])dnl
958 dnl ---------------------------------------------------------------------------
959 dnl CF_C_INLINE version: 3 updated: 2010/05/01 15:14:41
960 dnl -----------
961 dnl Check if the C compiler supports "inline".
962 dnl $1 is the name of a shell variable to set if inline is supported
963 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
964 AC_DEFUN([CF_C_INLINE],[
965 AC_C_INLINE
966 $1=
967 if test "$ac_cv_c_inline" != no ; then
968   $1=inline
969   if test "$INTEL_COMPILER" = yes
970   then
971     :
972   elif test "$GCC" = yes
973   then
974     AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[
975       cf_save_CFLAGS=$CFLAGS
976       CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
977       AC_TRY_COMPILE([inline int foo(void) { return 1; }],
978       [${cf_cv_main_return:-return} foo()],
979       [cf_cv_gcc_inline=yes],
980       [cf_cv_gcc_inline=no])
981       CFLAGS=$cf_save_CFLAGS
982     ])
983     if test "$cf_cv_gcc_inline" = yes ; then
984         CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
985     fi
986   fi
987 fi
988 AC_SUBST($1)
989 ])dnl
990 dnl ---------------------------------------------------------------------------
991 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
992 dnl ----------
993 dnl "dirname" is not portable, so we fake it with a shell script.
994 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
995 dnl ---------------------------------------------------------------------------
996 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
997 dnl ---------------
998 AC_DEFUN([CF_DIRS_TO_MAKE],
999 [
1000 DIRS_TO_MAKE="lib"
1001 for cf_item in $cf_list_models
1002 do
1003         CF_OBJ_SUBDIR($cf_item,cf_subdir)
1004         for cf_item2 in $DIRS_TO_MAKE
1005         do
1006                 test $cf_item2 = $cf_subdir && break
1007         done
1008         test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
1009 done
1010 for cf_dir in $DIRS_TO_MAKE
1011 do
1012         test ! -d $cf_dir && mkdir $cf_dir
1013 done
1014 AC_SUBST(DIRS_TO_MAKE)
1015 ])dnl
1016 dnl ---------------------------------------------------------------------------
1017 dnl CF_DISABLE_LEAKS version: 5 updated: 2010/03/13 15:14:55
1018 dnl ----------------
1019 dnl Combine no-leak checks with the libraries or tools that are used for the
1020 dnl checks.
1021 AC_DEFUN([CF_DISABLE_LEAKS],[
1022
1023 AC_REQUIRE([CF_WITH_DMALLOC])
1024 AC_REQUIRE([CF_WITH_DBMALLOC])
1025 AC_REQUIRE([CF_WITH_VALGRIND])
1026
1027 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1028 AC_ARG_ENABLE(leaks,
1029         [  --disable-leaks         test: free permanent memory, analyze leaks],
1030         [if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi],
1031         : ${with_no_leaks:=no})
1032 AC_MSG_RESULT($with_no_leaks)
1033
1034 if test "$with_no_leaks" = yes ; then
1035         AC_DEFINE(NO_LEAKS)
1036 fi
1037 ])dnl
1038 dnl ---------------------------------------------------------------------------
1039 dnl CF_DISABLE_RPATH_HACK version: 1 updated: 2010/04/11 10:54:00
1040 dnl ---------------------
1041 dnl The rpath-hack makes it simpler to build programs, particularly with the
1042 dnl *BSD ports which may have essential libraries in unusual places.  But it
1043 dnl can interfere with building an executable for the base system.  Use this
1044 dnl option in that case.
1045 AC_DEFUN([CF_DISABLE_RPATH_HACK],
1046 [
1047 AC_MSG_CHECKING(if rpath should be not be set)
1048 CF_ARG_DISABLE(rpath-hack,
1049         [  --disable-rpath-hack    don't add rpath options for additional libraries],
1050         [cf_disable_rpath_hack=yes],
1051         [cf_disable_rpath_hack=no])
1052 AC_MSG_RESULT($cf_disable_rpath_hack)
1053 if test "$cf_disable_rpath_hack" = no ; then
1054         CF_RPATH_HACK
1055 fi
1056 ])
1057 dnl ---------------------------------------------------------------------------
1058 dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
1059 dnl ---------------
1060 dnl Check if the rpath option should be used, setting cache variable
1061 dnl cf_cv_enable_rpath if so.
1062 AC_DEFUN([CF_ENABLE_RPATH],
1063 [
1064 AC_MSG_CHECKING(if rpath option should be used)
1065 AC_ARG_ENABLE(rpath,
1066 [  --enable-rpath          use rpath option when generating shared libraries],
1067 [cf_cv_enable_rpath=$enableval],
1068 [cf_cv_enable_rpath=no])
1069 AC_MSG_RESULT($cf_cv_enable_rpath)
1070 ])dnl
1071 dnl ---------------------------------------------------------------------------
1072 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
1073 dnl --------
1074 dnl Check if 'errno' is declared in <errno.h>
1075 AC_DEFUN([CF_ERRNO],
1076 [
1077 CF_CHECK_ERRNO(errno)
1078 ])dnl
1079 dnl ---------------------------------------------------------------------------
1080 dnl CF_ETIP_DEFINES version: 3 updated: 2003/03/22 19:13:43
1081 dnl ---------------
1082 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
1083 dnl math.h and builtin.h, only for ncurses
1084 AC_DEFUN([CF_ETIP_DEFINES],
1085 [
1086 AC_MSG_CHECKING(for special defines needed for etip.h)
1087 cf_save_CXXFLAGS="$CXXFLAGS"
1088 cf_result="none"
1089 for cf_math in "" MATH_H
1090 do
1091 for cf_excp in "" MATH_EXCEPTION
1092 do
1093         CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -I${srcdir}/include"
1094         test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
1095         test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
1096 AC_TRY_COMPILE([
1097 #include <etip.h.in>
1098 ],[],[
1099         test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
1100         test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
1101         cf_result="$cf_math $cf_excp"
1102         break
1103 ],[])
1104 done
1105 done
1106 AC_MSG_RESULT($cf_result)
1107 CXXFLAGS="$cf_save_CXXFLAGS"
1108 ])
1109 dnl ---------------------------------------------------------------------------
1110 dnl CF_FIND_LINKAGE version: 16 updated: 2010/04/21 06:20:50
1111 dnl ---------------
1112 dnl Find a library (specifically the linkage used in the code fragment),
1113 dnl searching for it if it is not already in the library path.
1114 dnl See also CF_ADD_SEARCHPATH.
1115 dnl
1116 dnl Parameters (4-on are optional):
1117 dnl     $1 = headers for library entrypoint
1118 dnl     $2 = code fragment for library entrypoint
1119 dnl     $3 = the library name without the "-l" option or ".so" suffix.
1120 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
1121 dnl     $5 = action to perform if not successful
1122 dnl     $6 = module name, if not the same as the library name
1123 dnl     $7 = extra libraries
1124 dnl
1125 dnl Sets these variables:
1126 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1127 dnl     $cf_cv_header_path_$3 - include-directory if needed
1128 dnl     $cf_cv_library_path_$3 - library-directory if needed
1129 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1130 AC_DEFUN([CF_FIND_LINKAGE],[
1131
1132 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1133 # will be set on completion of the AC_TRY_LINK below.
1134 cf_cv_header_path_$3=
1135 cf_cv_library_path_$3=
1136
1137 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1138
1139 AC_TRY_LINK([$1],[$2],[
1140         cf_cv_find_linkage_$3=yes
1141 ],[
1142
1143 cf_save_LIBS="$LIBS"
1144 LIBS="-l$3 $7 $cf_save_LIBS"
1145
1146 AC_TRY_LINK([$1],[$2],[
1147         cf_cv_find_linkage_$3=yes
1148         cf_cv_library_file_$3="-l$3"
1149 ],[
1150     cf_cv_find_linkage_$3=no
1151         LIBS="$cf_save_LIBS"
1152
1153     CF_VERBOSE(find linkage for $3 library)
1154     CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1155
1156     cf_save_CPPFLAGS="$CPPFLAGS"
1157     cf_test_CPPFLAGS="$CPPFLAGS"
1158
1159     CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1160     for cf_cv_header_path_$3 in $cf_search
1161     do
1162       if test -d $cf_cv_header_path_$3 ; then
1163         CF_VERBOSE(... testing $cf_cv_header_path_$3)
1164         CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
1165         AC_TRY_COMPILE([$1],[$2],[
1166             CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1167             cf_cv_find_linkage_$3=maybe
1168             cf_test_CPPFLAGS="$CPPFLAGS"
1169             break],[
1170             CPPFLAGS="$cf_save_CPPFLAGS"
1171             ])
1172       fi
1173     done
1174
1175     if test "$cf_cv_find_linkage_$3" = maybe ; then
1176
1177       CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1178
1179       cf_save_LIBS="$LIBS"
1180       cf_save_LDFLAGS="$LDFLAGS"
1181
1182       ifelse([$6],,,[
1183         CPPFLAGS="$cf_test_CPPFLAGS"
1184         LIBS="-l$3 $7 $cf_save_LIBS"
1185         AC_TRY_LINK([$1],[$2],[
1186             CF_VERBOSE(... found $3 library in system)
1187             cf_cv_find_linkage_$3=yes])
1188             CPPFLAGS="$cf_save_CPPFLAGS"
1189             LIBS="$cf_save_LIBS"
1190             ])
1191
1192       if test "$cf_cv_find_linkage_$3" != yes ; then
1193         CF_LIBRARY_PATH(cf_search,$3)
1194         for cf_cv_library_path_$3 in $cf_search
1195         do
1196           if test -d $cf_cv_library_path_$3 ; then
1197             CF_VERBOSE(... testing $cf_cv_library_path_$3)
1198             CPPFLAGS="$cf_test_CPPFLAGS"
1199             LIBS="-l$3 $7 $cf_save_LIBS"
1200             LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1201             AC_TRY_LINK([$1],[$2],[
1202                 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1203                 cf_cv_find_linkage_$3=yes
1204                 cf_cv_library_file_$3="-l$3"
1205                 break],[
1206                 CPPFLAGS="$cf_save_CPPFLAGS"
1207                 LIBS="$cf_save_LIBS"
1208                 LDFLAGS="$cf_save_LDFLAGS"
1209                 ])
1210           fi
1211         done
1212         LIBS="$cf_save_LIBS"
1213         CPPFLAGS="$cf_save_CPPFLAGS"
1214         LDFLAGS="$cf_save_LDFLAGS"
1215       fi
1216
1217     else
1218       cf_cv_find_linkage_$3=no
1219     fi
1220     ],$7)
1221 ])
1222
1223 if test "$cf_cv_find_linkage_$3" = yes ; then
1224 ifelse([$4],,[
1225         CF_ADD_INCDIR($cf_cv_header_path_$3)
1226         CF_ADD_LIBDIR($cf_cv_library_path_$3)
1227         LIBS="-l$3 $LIBS"
1228 ],[$4])
1229 else
1230 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1231 fi
1232 ])dnl
1233 dnl ---------------------------------------------------------------------------
1234 dnl CF_FUNC_DLSYM version: 1 updated: 2004/06/16 20:52:45
1235 dnl -------------
1236 dnl Test for dlsym() and related functions, as well as libdl.
1237 dnl
1238 dnl Sets
1239 dnl     $cf_have_dlsym
1240 dnl     $cf_have_libdl
1241 AC_DEFUN([CF_FUNC_DLSYM],[
1242 cf_have_dlsym=no
1243 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
1244
1245 cf_have_libdl=no
1246 AC_CHECK_LIB(dl,dlsym,[
1247         cf_have_dlsym=yes
1248         cf_have_libdl=yes])])
1249
1250 if test "$cf_have_dlsym" = yes ; then
1251         test "$cf_have_libdl" = yes && LIBS="-ldl $LIBS"
1252
1253         AC_MSG_CHECKING(whether able to link to dl*() functions)
1254         AC_TRY_LINK([#include <dlfcn.h>],[
1255                 void *obj;
1256                 if ((obj = dlopen("filename", 0)) != 0) {
1257                         if (dlsym(obj, "symbolname") == 0) {
1258                         dlclose(obj);
1259                         }
1260                 }],[
1261                 AC_DEFINE(HAVE_LIBDL)],[
1262                 AC_MSG_ERROR(Cannot link test program for libdl)])
1263         AC_MSG_RESULT(ok)
1264 else
1265         AC_MSG_ERROR(Cannot find dlsym function)
1266 fi
1267 ])
1268 dnl ---------------------------------------------------------------------------
1269 dnl CF_FUNC_MEMMOVE version: 7 updated: 2006/12/16 12:33:30
1270 dnl ---------------
1271 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
1272 dnl is found, add our own version of memmove to the list of objects.
1273 AC_DEFUN([CF_FUNC_MEMMOVE],
1274 [
1275 AC_CHECK_FUNC(memmove,,[
1276 AC_CHECK_FUNC(bcopy,[
1277         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
1278                 AC_TRY_RUN([
1279 int main() {
1280         static char data[] = "abcdefghijklmnopqrstuwwxyz";
1281         char temp[40];
1282         bcopy(data, temp, sizeof(data));
1283         bcopy(temp+10, temp, 15);
1284         bcopy(temp+5, temp+15, 10);
1285         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
1286 }
1287                 ],
1288                 [cf_cv_good_bcopy=yes],
1289                 [cf_cv_good_bcopy=no],
1290                 [cf_cv_good_bcopy=unknown])
1291                 ])
1292         ],[cf_cv_good_bcopy=no])
1293         if test "$cf_cv_good_bcopy" = yes ; then
1294                 AC_DEFINE(USE_OK_BCOPY)
1295         else
1296                 AC_DEFINE(USE_MY_MEMMOVE)
1297         fi
1298 ])])dnl
1299 dnl ---------------------------------------------------------------------------
1300 dnl CF_FUNC_NANOSLEEP version: 3 updated: 2006/12/16 12:33:30
1301 dnl -----------------
1302 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
1303 dnl AIX 4.x, provide a non-working version.
1304 AC_DEFUN([CF_FUNC_NANOSLEEP],[
1305 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
1306 AC_TRY_RUN([
1307 #include <stdio.h>
1308 #include <errno.h>
1309 #include <time.h>
1310
1311 #ifdef HAVE_SYS_TIME_H
1312 #include <sys/time.h>
1313 #endif
1314
1315 int main() {
1316         struct timespec ts1, ts2;
1317         int code;
1318         ts1.tv_sec  = 0;
1319         ts1.tv_nsec = 750000000;
1320         ts2.tv_sec  = 0;
1321         ts2.tv_nsec = 0;
1322         errno = 0;
1323         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
1324         ${cf_cv_main_return:-return}(code != 0);
1325 }
1326 ],
1327         [cf_cv_func_nanosleep=yes],
1328         [cf_cv_func_nanosleep=no],
1329         [cf_cv_func_nanosleep=unknown])])
1330
1331 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP)
1332 ])
1333 dnl ---------------------------------------------------------------------------
1334 dnl CF_FUNC_OPENPTY version: 2 updated: 2008/04/12 19:49:01
1335 dnl ---------------
1336 dnl Check for openpty() function, along with <pty.h> header.  It may need the
1337 dnl "util" library as well.
1338 AC_DEFUN([CF_FUNC_OPENPTY],
1339 [
1340 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1341 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1342     cf_save_LIBS="$LIBS"
1343     test $cf_cv_lib_util = yes && LIBS="-lutil $LIBS"
1344     for cf_header in pty.h libutil.h util.h
1345     do
1346     AC_TRY_LINK([
1347 #include <$cf_header>
1348 ],[
1349     int x = openpty((int *)0, (int *)0, (char *)0,
1350                    (struct termios *)0, (struct winsize *)0);
1351 ],[
1352         cf_cv_func_openpty=$cf_header
1353         break
1354 ],[
1355         cf_cv_func_openpty=no
1356 ])
1357     done
1358     LIBS="$cf_save_LIBS"
1359 ])
1360 ])dnl
1361 dnl ---------------------------------------------------------------------------
1362 dnl CF_FUNC_POLL version: 4 updated: 2006/12/16 12:33:30
1363 dnl ------------
1364 dnl See if the poll function really works.  Some platforms have poll(), but
1365 dnl it does not work for terminals or files.
1366 AC_DEFUN([CF_FUNC_POLL],[
1367 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1368 AC_TRY_RUN([
1369 #include <stdio.h>
1370 #ifdef HAVE_POLL_H
1371 #include <poll.h>
1372 #else
1373 #include <sys/poll.h>
1374 #endif
1375 int main() {
1376         struct pollfd myfds;
1377         int ret;
1378
1379         myfds.fd = 0;
1380         myfds.events = POLLIN;
1381
1382         ret = poll(&myfds, 1, 100);
1383         ${cf_cv_main_return:-return}(ret != 0);
1384 }],
1385         [cf_cv_working_poll=yes],
1386         [cf_cv_working_poll=no],
1387         [cf_cv_working_poll=unknown])])
1388 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
1389 ])dnl
1390 dnl ---------------------------------------------------------------------------
1391 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
1392 dnl ---------------
1393 dnl Some old/broken variations define tcgetattr() only as a macro in
1394 dnl termio(s).h
1395 AC_DEFUN([CF_FUNC_TERMIOS],[
1396 AC_REQUIRE([CF_STRUCT_TERMIOS])
1397 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1398 AC_TRY_LINK([
1399 #include <sys/types.h>
1400 #ifdef HAVE_UNISTD_H
1401 #include <unistd.h>
1402 #endif
1403 #ifdef HAVE_TERMIOS_H
1404 #include <termios.h>
1405 #define TTY struct termios
1406 #else
1407 #ifdef HAVE_TERMIO_H
1408 #include <termio.h>
1409 #define TTY struct termio
1410 #endif
1411 #endif
1412 ],[
1413 TTY foo;
1414 tcgetattr(1, &foo);],
1415 [cf_cv_have_tcgetattr=yes],
1416 [cf_cv_have_tcgetattr=no])])
1417 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
1418 ])dnl
1419 dnl ---------------------------------------------------------------------------
1420 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
1421 dnl ---------------
1422 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1423 dnl versions of C.  It is in the GNU C library, and can often be simulated by
1424 dnl other functions.
1425 AC_DEFUN([CF_FUNC_VSSCANF],
1426 [
1427 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1428 AC_TRY_LINK([
1429 #include <stdarg.h>
1430 #include <stdio.h>],[
1431         va_list ap;
1432         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1433 AC_TRY_LINK([
1434 #include <stdarg.h>
1435 #include <stdio.h>],[
1436     FILE strbuf;
1437     char *str = "from";
1438
1439     strbuf._flag = _IOREAD;
1440     strbuf._ptr = strbuf._base = (unsigned char *) str;
1441     strbuf._cnt = strlen(str);
1442     strbuf._file = _NFILE;
1443     return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1444 AC_TRY_LINK([
1445 #include <stdarg.h>
1446 #include <stdio.h>],[
1447     FILE strbuf;
1448     char *str = "from";
1449
1450     strbuf._flag = _IOREAD;
1451     strbuf._ptr = strbuf._base = (unsigned char *) str;
1452     strbuf._cnt = strlen(str);
1453     strbuf._file = _NFILE;
1454     return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1455 cf_cv_func_vsscanf=no])])])])
1456
1457 case $cf_cv_func_vsscanf in #(vi
1458 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
1459 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
1460 _doscan) AC_DEFINE(HAVE__DOSCAN);;
1461 esac
1462
1463 ])dnl
1464 dnl ---------------------------------------------------------------------------
1465 dnl CF_GCC_ATTRIBUTES version: 13 updated: 2009/08/11 20:19:56
1466 dnl -----------------
1467 dnl Test for availability of useful gcc __attribute__ directives to quiet
1468 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1469 dnl to documentation, unrecognized directives cause older compilers to barf.
1470 AC_DEFUN([CF_GCC_ATTRIBUTES],
1471 [
1472 if test "$GCC" = yes
1473 then
1474 cat > conftest.i <<EOF
1475 #ifndef GCC_PRINTF
1476 #define GCC_PRINTF 0
1477 #endif
1478 #ifndef GCC_SCANF
1479 #define GCC_SCANF 0
1480 #endif
1481 #ifndef GCC_NORETURN
1482 #define GCC_NORETURN /* nothing */
1483 #endif
1484 #ifndef GCC_UNUSED
1485 #define GCC_UNUSED /* nothing */
1486 #endif
1487 EOF
1488 if test "$GCC" = yes
1489 then
1490         AC_CHECKING([for $CC __attribute__ directives])
1491 cat > conftest.$ac_ext <<EOF
1492 #line __oline__ "${as_me-configure}"
1493 #include "confdefs.h"
1494 #include "conftest.h"
1495 #include "conftest.i"
1496 #if     GCC_PRINTF
1497 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1498 #else
1499 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1500 #endif
1501 #if     GCC_SCANF
1502 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1503 #else
1504 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1505 #endif
1506 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1507 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1508 extern void foo(void) GCC_NORETURN;
1509 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1510 EOF
1511         cf_printf_attribute=no
1512         cf_scanf_attribute=no
1513         for cf_attribute in scanf printf unused noreturn
1514         do
1515                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1516                 cf_directive="__attribute__(($cf_attribute))"
1517                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1518
1519                 case $cf_attribute in #(vi
1520                 printf) #(vi
1521                         cf_printf_attribute=yes
1522                         cat >conftest.h <<EOF
1523 #define GCC_$cf_ATTRIBUTE 1
1524 EOF
1525                         ;;
1526                 scanf) #(vi
1527                         cf_scanf_attribute=yes
1528                         cat >conftest.h <<EOF
1529 #define GCC_$cf_ATTRIBUTE 1
1530 EOF
1531                         ;;
1532                 *) #(vi
1533                         cat >conftest.h <<EOF
1534 #define GCC_$cf_ATTRIBUTE $cf_directive
1535 EOF
1536                         ;;
1537                 esac
1538
1539                 if AC_TRY_EVAL(ac_compile); then
1540                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1541                         cat conftest.h >>confdefs.h
1542                         case $cf_attribute in #(vi
1543                         printf) #(vi
1544                                 if test "$cf_printf_attribute" = no ; then
1545                                         cat >>confdefs.h <<EOF
1546 #define GCC_PRINTFLIKE(fmt,var) /* nothing */
1547 EOF
1548                                 else
1549                                         cat >>confdefs.h <<EOF
1550 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1551 EOF
1552                                 fi
1553                                 ;;
1554                         scanf) #(vi
1555                                 if test "$cf_scanf_attribute" = no ; then
1556                                         cat >>confdefs.h <<EOF
1557 #define GCC_SCANFLIKE(fmt,var) /* nothing */
1558 EOF
1559                                 else
1560                                         cat >>confdefs.h <<EOF
1561 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1562 EOF
1563                                 fi
1564                                 ;;
1565                         esac
1566                 fi
1567         done
1568 else
1569         fgrep define conftest.i >>confdefs.h
1570 fi
1571 rm -rf conftest*
1572 fi
1573 ])dnl
1574 dnl ---------------------------------------------------------------------------
1575 dnl CF_GCC_VERSION version: 5 updated: 2010/04/24 11:02:31
1576 dnl --------------
1577 dnl Find version of gcc
1578 AC_DEFUN([CF_GCC_VERSION],[
1579 AC_REQUIRE([AC_PROG_CC])
1580 GCC_VERSION=none
1581 if test "$GCC" = yes ; then
1582         AC_MSG_CHECKING(version of $CC)
1583         GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1584         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1585         AC_MSG_RESULT($GCC_VERSION)
1586 fi
1587 ])dnl
1588 dnl ---------------------------------------------------------------------------
1589 dnl CF_GCC_WARNINGS version: 25 updated: 2010/04/24 11:03:31
1590 dnl ---------------
1591 dnl Check if the compiler supports useful warning options.  There's a few that
1592 dnl we don't use, simply because they're too noisy:
1593 dnl
1594 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1595 dnl     -Wredundant-decls (system headers make this too noisy)
1596 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1597 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1598 dnl             is enabled for ncurses using "--enable-const".
1599 dnl     -pedantic
1600 dnl
1601 dnl Parameter:
1602 dnl     $1 is an optional list of gcc warning flags that a particular
1603 dnl             application might want to use, e.g., "no-unused" for
1604 dnl             -Wno-unused
1605 dnl Special:
1606 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1607 dnl
1608 AC_DEFUN([CF_GCC_WARNINGS],
1609 [
1610 AC_REQUIRE([CF_GCC_VERSION])
1611 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1612
1613 cat > conftest.$ac_ext <<EOF
1614 #line __oline__ "${as_me-configure}"
1615 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1616 EOF
1617
1618 if test "$INTEL_COMPILER" = yes
1619 then
1620 # The "-wdXXX" options suppress warnings:
1621 # remark #1419: external declaration in primary source file
1622 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1623 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1624 # remark #193: zero used for undefined preprocessing identifier
1625 # remark #593: variable "curs_sb_left_arrow" was set but never used
1626 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1627 # remark #869: parameter "tw" was never referenced
1628 # remark #981: operands are evaluated in unspecified order
1629 # warning #279: controlling expression is constant
1630
1631         AC_CHECKING([for $CC warning options])
1632         cf_save_CFLAGS="$CFLAGS"
1633         EXTRA_CFLAGS="-Wall"
1634         for cf_opt in \
1635                 wd1419 \
1636                 wd1683 \
1637                 wd1684 \
1638                 wd193 \
1639                 wd593 \
1640                 wd279 \
1641                 wd810 \
1642                 wd869 \
1643                 wd981
1644         do
1645                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1646                 if AC_TRY_EVAL(ac_compile); then
1647                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1648                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1649                 fi
1650         done
1651         CFLAGS="$cf_save_CFLAGS"
1652
1653 elif test "$GCC" = yes
1654 then
1655         AC_CHECKING([for $CC warning options])
1656         cf_save_CFLAGS="$CFLAGS"
1657         EXTRA_CFLAGS=
1658         cf_warn_CONST=""
1659         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1660         for cf_opt in W Wall \
1661                 Wbad-function-cast \
1662                 Wcast-align \
1663                 Wcast-qual \
1664                 Winline \
1665                 Wmissing-declarations \
1666                 Wmissing-prototypes \
1667                 Wnested-externs \
1668                 Wpointer-arith \
1669                 Wshadow \
1670                 Wstrict-prototypes \
1671                 Wundef $cf_warn_CONST $1
1672         do
1673                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1674                 if AC_TRY_EVAL(ac_compile); then
1675                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1676                         case $cf_opt in #(vi
1677                         Wcast-qual) #(vi
1678                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1679                                 ;;
1680                         Winline) #(vi
1681                                 case $GCC_VERSION in
1682                                 [[34]].*)
1683                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1684                                         continue;;
1685                                 esac
1686                                 ;;
1687                         esac
1688                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1689                 fi
1690         done
1691         CFLAGS="$cf_save_CFLAGS"
1692 fi
1693 rm -f conftest*
1694
1695 AC_SUBST(EXTRA_CFLAGS)
1696 ])dnl
1697 dnl ---------------------------------------------------------------------------
1698 dnl CF_GNAT_TRY_LINK version: 1 updated: 2004/08/21 19:02:08
1699 dnl ----------------
1700 dnl Verify that a test program compiles/links with GNAT.
1701 dnl $cf_ada_make is set to the program that compiles/links
1702 dnl $ADAFLAGS may be set to the GNAT flags.
1703 dnl
1704 dnl $1 is the text of the spec
1705 dnl $2 is the text of the body
1706 dnl $3 is the shell command to execute if successful
1707 dnl $4 is the shell command to execute if not successful
1708 AC_DEFUN([CF_GNAT_TRY_LINK],
1709 [
1710 rm -f conftest*
1711 cat >>conftest.ads <<CF_EOF
1712 $1
1713 CF_EOF
1714 cat >>conftest.adb <<CF_EOF
1715 $2
1716 CF_EOF
1717 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1718 ifelse($3,,      :,[      $3])
1719 ifelse($4,,,[else
1720    $4])
1721 fi
1722 rm -f conftest*
1723 ])dnl
1724 dnl ---------------------------------------------------------------------------
1725 dnl CF_GNAT_TRY_RUN version: 3 updated: 2004/08/21 19:02:08
1726 dnl ---------------
1727 dnl Verify that a test program compiles and runs with GNAT
1728 dnl $cf_ada_make is set to the program that compiles/links
1729 dnl $ADAFLAGS may be set to the GNAT flags.
1730 dnl
1731 dnl $1 is the text of the spec
1732 dnl $2 is the text of the body
1733 dnl $3 is the shell command to execute if successful
1734 dnl $4 is the shell command to execute if not successful
1735 AC_DEFUN([CF_GNAT_TRY_RUN],
1736 [
1737 rm -f conftest*
1738 cat >>conftest.ads <<CF_EOF
1739 $1
1740 CF_EOF
1741 cat >>conftest.adb <<CF_EOF
1742 $2
1743 CF_EOF
1744 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1745    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1746 ifelse($3,,      :,[      $3])
1747 ifelse($4,,,[   else
1748       $4])
1749    fi
1750 ifelse($4,,,[else
1751    $4])
1752 fi
1753 rm -f conftest*
1754 ])dnl
1755 dnl ---------------------------------------------------------------------------
1756 dnl CF_GNAT_VERSION version: 12 updated: 2006/10/14 15:23:15
1757 dnl ---------------
1758 dnl Verify version of GNAT.
1759 AC_DEFUN([CF_GNAT_VERSION],
1760 [
1761 AC_MSG_CHECKING(for gnat version)
1762 cf_gnat_version=`${cf_ada_make-gnatmake} -v 2>&1 | grep '[[0-9]].[[0-9]][[0-9]]*' |\
1763   sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1764 AC_MSG_RESULT($cf_gnat_version)
1765
1766 case $cf_gnat_version in
1767   3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*)
1768     cf_cv_prog_gnat_correct=yes
1769     ;;
1770   *) echo Unsupported GNAT version $cf_gnat_version. Required is 3.11 or better. Disabling Ada95 binding.
1771      cf_cv_prog_gnat_correct=no
1772      ;;
1773 esac
1774 case $cf_gnat_version in
1775   3.[[1-9]]*|[[4-9]].*)
1776       cf_compile_generics=generics
1777       cf_generic_objects="\${GENOBJS}"
1778       ;;
1779   *)  cf_compile_generics=
1780       cf_generic_objects=
1781       ;;
1782 esac
1783 ])
1784 dnl ---------------------------------------------------------------------------
1785 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1786 dnl -------------
1787 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1788 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1789 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1790 dnl since it is interwoven with GNU extensions.
1791 dnl
1792 dnl Well, yes we could work around it...
1793 AC_DEFUN([CF_GNU_SOURCE],
1794 [
1795 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1796 AC_TRY_COMPILE([#include <sys/types.h>],[
1797 #ifndef _XOPEN_SOURCE
1798 make an error
1799 #endif],
1800         [cf_cv_gnu_source=no],
1801         [cf_save="$CPPFLAGS"
1802          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1803          AC_TRY_COMPILE([#include <sys/types.h>],[
1804 #ifdef _XOPEN_SOURCE
1805 make an error
1806 #endif],
1807         [cf_cv_gnu_source=no],
1808         [cf_cv_gnu_source=yes])
1809         CPPFLAGS="$cf_save"
1810         ])
1811 ])
1812 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1813 ])dnl
1814 dnl ---------------------------------------------------------------------------
1815 dnl CF_GPP_LIBRARY version: 9 updated: 2009/12/19 13:46:49
1816 dnl --------------
1817 dnl If we're trying to use g++, test if libg++ is installed (a rather common
1818 dnl problem :-).  If we have the compiler but no library, we'll be able to
1819 dnl configure, but won't be able to build the c++ demo program.
1820 AC_DEFUN([CF_GPP_LIBRARY],
1821 [
1822 cf_cxx_library=unknown
1823 case $cf_cv_system_name in #(vi
1824 os2*) #(vi
1825         cf_gpp_libname=gpp
1826         ;;
1827 *)
1828         cf_gpp_libname=g++
1829         ;;
1830 esac
1831 if test "$GXX" = yes; then
1832         AC_MSG_CHECKING([for lib$cf_gpp_libname])
1833         cf_save="$LIBS"
1834         LIBS="-l$cf_gpp_libname $LIBS"
1835         AC_TRY_LINK([
1836 #include <$cf_gpp_libname/builtin.h>
1837         ],
1838         [two_arg_error_handler_t foo2 = lib_error_handler],
1839         [cf_cxx_library=yes
1840          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1841          if test "$cf_gpp_libname" = cpp ; then
1842             AC_DEFINE(HAVE_GPP_BUILTIN_H)
1843          else
1844             AC_DEFINE(HAVE_GXX_BUILTIN_H)
1845          fi],
1846         [AC_TRY_LINK([
1847 #include <builtin.h>
1848         ],
1849         [two_arg_error_handler_t foo2 = lib_error_handler],
1850         [cf_cxx_library=yes
1851          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1852          AC_DEFINE(HAVE_BUILTIN_H)],
1853         [cf_cxx_library=no])])
1854         LIBS="$cf_save"
1855         AC_MSG_RESULT($cf_cxx_library)
1856 fi
1857 ])dnl
1858 dnl ---------------------------------------------------------------------------
1859 dnl CF_GXX_VERSION version: 5 updated: 2005/08/27 09:53:42
1860 dnl --------------
1861 dnl Check for version of g++
1862 AC_DEFUN([CF_GXX_VERSION],[
1863 AC_REQUIRE([AC_PROG_CPP])
1864 GXX_VERSION=none
1865 if test "$GXX" = yes; then
1866         AC_MSG_CHECKING(version of g++)
1867         GXX_VERSION="`${CXX-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1868         test -z "$GXX_VERSION" && GXX_VERSION=unknown
1869         AC_MSG_RESULT($GXX_VERSION)
1870 fi
1871 ])dnl
1872 dnl ---------------------------------------------------------------------------
1873 dnl CF_GXX_WARNINGS version: 5 updated: 2005/08/13 14:54:38
1874 dnl ---------------
1875 dnl Check if the compiler supports useful warning options.
1876 dnl
1877 dnl Most of gcc's options apply to g++, except:
1878 dnl     -Wbad-function-cast
1879 dnl     -Wmissing-declarations
1880 dnl     -Wnested-externs
1881 dnl
1882 dnl Omit a few (for now):
1883 dnl     -Winline
1884 dnl
1885 dnl Parameter:
1886 dnl     $1 is an optional list of g++ warning flags that a particular
1887 dnl             application might want to use, e.g., "no-unused" for
1888 dnl             -Wno-unused
1889 dnl Special:
1890 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1891 dnl
1892 AC_DEFUN([CF_GXX_WARNINGS],
1893 [
1894
1895 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
1896
1897 AC_REQUIRE([CF_GXX_VERSION])
1898
1899 AC_LANG_SAVE
1900 AC_LANG_CPLUSPLUS
1901
1902 cat > conftest.$ac_ext <<EOF
1903 #line __oline__ "configure"
1904 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1905 EOF
1906
1907 if test "$INTEL_CPLUSPLUS" = yes
1908 then
1909 # The "-wdXXX" options suppress warnings:
1910 # remark #1419: external declaration in primary source file
1911 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1912 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1913 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1914 # remark #193: zero used for undefined preprocessing identifier
1915 # remark #593: variable "curs_sb_left_arrow" was set but never used
1916 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1917 # remark #869: parameter "tw" was never referenced
1918 # remark #981: operands are evaluated in unspecified order
1919 # warning #269: invalid format string conversion
1920
1921         AC_CHECKING([for $CC warning options])
1922         cf_save_CXXFLAGS="$CXXFLAGS"
1923         EXTRA_CXXFLAGS="-Wall"
1924         for cf_opt in \
1925                 wd1419 \
1926                 wd1682 \
1927                 wd1683 \
1928                 wd1684 \
1929                 wd193 \
1930                 wd279 \
1931                 wd593 \
1932                 wd810 \
1933                 wd869 \
1934                 wd981
1935         do
1936                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
1937                 if AC_TRY_EVAL(ac_compile); then
1938                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1939                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1940                 fi
1941         done
1942         CXXFLAGS="$cf_save_CXXFLAGS"
1943
1944 elif test "$GXX" = yes
1945 then
1946         AC_CHECKING([for $CXX warning options])
1947         cf_save_CXXFLAGS="$CXXFLAGS"
1948         EXTRA_CXXFLAGS="-W -Wall"
1949         cf_gxx_extra_warnings=""
1950         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
1951         case "$GCC_VERSION" in
1952         [[1-2]].*)
1953                 ;;
1954         *)
1955                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
1956                 ;;
1957         esac
1958         for cf_opt in \
1959                 Wabi \
1960                 fabi-version=0 \
1961                 Woverloaded-virtual \
1962                 Wsign-promo \
1963                 Wsynth \
1964                 Wold-style-cast \
1965                 Wcast-align \
1966                 Wcast-qual \
1967                 Wmissing-prototypes \
1968                 Wpointer-arith \
1969                 Wshadow \
1970                 Wstrict-prototypes \
1971                 Wundef $cf_gxx_extra_warnings $1
1972         do
1973                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
1974                 if AC_TRY_EVAL(ac_compile); then
1975                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1976                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1977                 else
1978                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
1979                 fi
1980         done
1981         CXXFLAGS="$cf_save_CXXFLAGS"
1982 fi
1983
1984 rm -f conftest*
1985 AC_LANG_RESTORE
1986 AC_SUBST(EXTRA_CXXFLAGS)
1987 ])dnl
1988 dnl ---------------------------------------------------------------------------
1989 dnl CF_HASHED_DB version: 3 updated: 2007/11/24 17:43:37
1990 dnl ------------
1991 dnl Look for an instance of the Berkeley hashed database.
1992 dnl
1993 dnl $1 = optional parameter, to specify install-prefix for the database.
1994 AC_DEFUN([CF_HASHED_DB],
1995 [
1996 ifelse([$1],,,[
1997 case $1 in #(vi
1998 yes|*able*) #(vi
1999     ;;
2000 *)
2001     if test -d "$1" ; then
2002         CF_ADD_INCDIR($1/include)
2003         CF_ADD_LIBDIR($1/lib)
2004     fi
2005 esac
2006 ])
2007 AC_CHECK_HEADER(db.h,[
2008 CF_HASHED_DB_VERSION
2009 if test "$cf_cv_hashed_db_version" = unknown ; then
2010         AC_MSG_ERROR(Cannot determine version of db)
2011 else
2012         CF_HASHED_DB_LIBS
2013         if test "$cf_cv_hashed_db_libs" = unknown ; then
2014                 AC_MSG_ERROR(Cannot determine library for db)
2015         elif test "$cf_cv_hashed_db_libs" != default ; then
2016                 LIBS="-l$cf_cv_hashed_db_libs $LIBS"
2017         fi
2018 fi
2019 ],[
2020         AC_MSG_ERROR(Cannot find db.h)
2021 ])
2022 ])dnl
2023 dnl ---------------------------------------------------------------------------
2024 dnl CF_HASHED_DB_LIBS version: 8 updated: 2008/08/04 06:18:06
2025 dnl -----------------
2026 dnl Given that we have the header and version for hashed database, find the
2027 dnl library information.
2028 AC_DEFUN([CF_HASHED_DB_LIBS],
2029 [
2030 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
2031 cf_cv_hashed_db_libs=unknown
2032 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
2033 do
2034         cf_save_libs="$LIBS"
2035         if test -n "$cf_db_libs"; then
2036                 LIBS="-l$cf_db_libs $LIBS"
2037         fi
2038         CF_MSG_LOG(checking for library "$cf_db_libs")
2039         AC_TRY_LINK([
2040 $ac_includes_default
2041 #include <db.h>
2042 ],[
2043         char *path = "/tmp/foo";
2044 #ifdef DB_VERSION_MAJOR
2045 #if DB_VERSION_MAJOR >= 4
2046         DB *result = 0;
2047         db_create(&result, NULL, 0);
2048         result->open(result,
2049                 NULL,
2050                 path,
2051                 path,
2052                 DB_HASH,
2053                 DB_CREATE,
2054                 0644);
2055 #elif DB_VERSION_MAJOR >= 3
2056         DB *result = 0;
2057         db_create(&result, NULL, 0);
2058         result->open(result,
2059                 path,
2060                 path,
2061                 DB_HASH,
2062                 DB_CREATE,
2063                 0644);
2064 #elif DB_VERSION_MAJOR >= 2
2065         DB *result = 0;
2066         db_open(path,
2067                 DB_HASH,
2068                 DB_CREATE,
2069                 0644,
2070                 (DB_ENV *) 0,
2071                 (DB_INFO *) 0,
2072                 &result);
2073 #endif /* DB_VERSION_MAJOR */
2074 #else
2075         DB *result = dbopen(path,
2076                      2,
2077                      0644,
2078                      DB_HASH,
2079                      0);
2080 #endif
2081         ${cf_cv_main_return:-return}(result != 0)
2082 ],[
2083         if test -n "$cf_db_libs" ; then
2084                 cf_cv_hashed_db_libs=$cf_db_libs
2085         else
2086                 cf_cv_hashed_db_libs=default
2087         fi
2088         LIBS="$cf_save_libs"
2089         break
2090 ])
2091         LIBS="$cf_save_libs"
2092 done
2093 ])
2094 ])dnl
2095 dnl ---------------------------------------------------------------------------
2096 dnl CF_HASHED_DB_VERSION version: 3 updated: 2007/12/01 15:01:37
2097 dnl --------------------
2098 dnl Given that we have the header file for hashed database, find the version
2099 dnl information.
2100 AC_DEFUN([CF_HASHED_DB_VERSION],
2101 [
2102 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
2103 cf_cv_hashed_db_version=unknown
2104
2105 for cf_db_version in 1 2 3 4 5
2106 do
2107         CF_MSG_LOG(checking for db version $cf_db_version)
2108         AC_TRY_COMPILE([
2109 $ac_includes_default
2110 #include <db.h>
2111
2112 #ifdef DB_VERSION_MAJOR
2113         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
2114 #if $cf_db_version == DB_VERSION_MAJOR
2115         /* ok */
2116 #else
2117         make an error
2118 #endif
2119 #else
2120 #if $cf_db_version == 1
2121         /* ok: assuming this is DB 1.8.5 */
2122 #else
2123         make an error
2124 #endif
2125 #endif
2126 ],[DBT *foo = 0],[
2127         cf_cv_hashed_db_version=$cf_db_version
2128         break
2129         ])
2130 done
2131 ])
2132 ])dnl
2133 dnl ---------------------------------------------------------------------------
2134 dnl CF_HEADER_PATH version: 11 updated: 2010/04/21 06:20:50
2135 dnl --------------
2136 dnl Construct a search-list of directories for a nonstandard header-file
2137 dnl
2138 dnl Parameters
2139 dnl     $1 = the variable to return as result
2140 dnl     $2 = the package name
2141 AC_DEFUN([CF_HEADER_PATH],
2142 [
2143 $1=
2144
2145 # collect the current set of include-directories from compiler flags
2146 cf_header_path_list=""
2147 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2148         for cf_header_path in $CPPFLAGS $CFLAGS
2149         do
2150                 case $cf_header_path in #(vi
2151                 -I*)
2152                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2153                         cf_header_path_list="$cf_header_path_list $cf_header_path"
2154                         ;;
2155                 esac
2156         done
2157 fi
2158
2159 # add the variations for the package we are looking for
2160 CF_SUBDIR_PATH($1,$2,include)
2161
2162 test "$includedir" != NONE && \
2163 test "$includedir" != "/usr/include" && \
2164 test -d "$includedir" && {
2165         test -d $includedir &&    $1="[$]$1 $includedir"
2166         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
2167 }
2168
2169 test "$oldincludedir" != NONE && \
2170 test "$oldincludedir" != "/usr/include" && \
2171 test -d "$oldincludedir" && {
2172         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
2173         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
2174 }
2175
2176 $1="[$]$1 $cf_header_path_list"
2177 ])dnl
2178 dnl ---------------------------------------------------------------------------
2179 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
2180 dnl ---------------
2181 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2182 AC_DEFUN([CF_HELP_MESSAGE],
2183 [AC_DIVERT_HELP([$1])dnl
2184 ])dnl
2185 dnl ---------------------------------------------------------------------------
2186 dnl CF_INCLUDE_DIRS version: 6 updated: 2009/01/06 19:37:40
2187 dnl ---------------
2188 dnl Construct the list of include-options according to whether we're building
2189 dnl in the source directory or using '--srcdir=DIR' option.  If we're building
2190 dnl with gcc, don't append the includedir if it happens to be /usr/include,
2191 dnl since that usually breaks gcc's shadow-includes.
2192 AC_DEFUN([CF_INCLUDE_DIRS],
2193 [
2194 CPPFLAGS="$CPPFLAGS -I. -I../include"
2195 if test "$srcdir" != "."; then
2196         CPPFLAGS="$CPPFLAGS -I\${srcdir}/../include"
2197 fi
2198 if test "$GCC" != yes; then
2199         CPPFLAGS="$CPPFLAGS -I\${includedir}"
2200 elif test "$includedir" != "/usr/include"; then
2201         if test "$includedir" = '${prefix}/include' ; then
2202                 if test $prefix != /usr ; then
2203                         CPPFLAGS="$CPPFLAGS -I\${includedir}"
2204                 fi
2205         else
2206                 CPPFLAGS="$CPPFLAGS -I\${includedir}"
2207         fi
2208 fi
2209 AC_SUBST(CPPFLAGS)
2210 ])dnl
2211 dnl ---------------------------------------------------------------------------
2212 dnl CF_INTEL_COMPILER version: 3 updated: 2005/08/06 18:37:29
2213 dnl -----------------
2214 dnl Check if the given compiler is really the Intel compiler for Linux.  It
2215 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2216 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2217 dnl
2218 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2219 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
2220 dnl the wrappers for gcc and g++ warnings.
2221 dnl
2222 dnl $1 = GCC (default) or GXX
2223 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2224 dnl $3 = CFLAGS (default) or CXXFLAGS
2225 AC_DEFUN([CF_INTEL_COMPILER],[
2226 ifelse($2,,INTEL_COMPILER,[$2])=no
2227
2228 if test "$ifelse($1,,[$1],GCC)" = yes ; then
2229         case $host_os in
2230         linux*|gnu*)
2231                 AC_MSG_CHECKING(if this is really Intel ifelse($1,GXX,C++,C) compiler)
2232                 cf_save_CFLAGS="$ifelse($3,,CFLAGS,[$3])"
2233                 ifelse($3,,CFLAGS,[$3])="$ifelse($3,,CFLAGS,[$3]) -no-gcc"
2234                 AC_TRY_COMPILE([],[
2235 #ifdef __INTEL_COMPILER
2236 #else
2237 make an error
2238 #endif
2239 ],[ifelse($2,,INTEL_COMPILER,[$2])=yes
2240 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
2241 ],[])
2242                 ifelse($3,,CFLAGS,[$3])="$cf_save_CFLAGS"
2243                 AC_MSG_RESULT($ifelse($2,,INTEL_COMPILER,[$2]))
2244                 ;;
2245         esac
2246 fi
2247 ])dnl
2248 dnl ---------------------------------------------------------------------------
2249 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
2250 dnl ----------
2251 dnl Check if we have either a function or macro for 'isascii()'.
2252 AC_DEFUN([CF_ISASCII],
2253 [
2254 AC_MSG_CHECKING(for isascii)
2255 AC_CACHE_VAL(cf_cv_have_isascii,[
2256         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
2257         [cf_cv_have_isascii=yes],
2258         [cf_cv_have_isascii=no])
2259 ])dnl
2260 AC_MSG_RESULT($cf_cv_have_isascii)
2261 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
2262 ])dnl
2263 dnl ---------------------------------------------------------------------------
2264 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
2265 dnl ------------
2266 dnl Add checks for large file support.
2267 AC_DEFUN([CF_LARGEFILE],[
2268 ifdef([AC_FUNC_FSEEKO],[
2269     AC_SYS_LARGEFILE
2270     if test "$enable_largefile" != no ; then
2271         AC_FUNC_FSEEKO
2272
2273         # Normally we would collect these definitions in the config.h,
2274         # but (like _XOPEN_SOURCE), some environments rely on having these
2275         # defined before any of the system headers are included.  Another
2276         # case comes up with C++, e.g., on AIX the compiler compiles the
2277         # header files by themselves before looking at the body files it is
2278         # told to compile.  For ncurses, those header files do not include
2279         # the config.h
2280         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
2281         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
2282         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
2283
2284         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2285                 AC_TRY_COMPILE([
2286 #include <sys/types.h>
2287 #include <dirent.h>
2288                 ],[
2289                 /* if transitional largefile support is setup, this is true */
2290                 extern struct dirent64 * readdir(DIR *);
2291                 struct dirent64 *x = readdir((DIR *)0);
2292                 struct dirent *y = readdir((DIR *)0);
2293                 int z = x - y;
2294                 ],
2295                 [cf_cv_struct_dirent64=yes],
2296                 [cf_cv_struct_dirent64=no])
2297         ])
2298         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
2299     fi
2300 ])
2301 ])
2302 dnl ---------------------------------------------------------------------------
2303 dnl CF_LDFLAGS_STATIC version: 7 updated: 2009/04/04 18:31:04
2304 dnl -----------------
2305 dnl Check for compiler/linker flags used to temporarily force usage of static
2306 dnl libraries.  This depends on the compiler and platform.  Use this to help
2307 dnl ensure that the linker picks up a given library based on its position in
2308 dnl the list of linker options and libraries.
2309 AC_DEFUN([CF_LDFLAGS_STATIC],[
2310
2311 if test "$GCC" = yes ; then
2312         case $cf_cv_system_name in #(
2313         OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*)         #( vi
2314                 LDFLAGS_STATIC=
2315                 LDFLAGS_SHARED=
2316                 ;;
2317     *)  #( normally, except when broken
2318         LDFLAGS_STATIC=-static
2319         LDFLAGS_SHARED=-dynamic
2320         ;;
2321     esac
2322 else
2323         case $cf_cv_system_name in #(
2324         aix[[456]]*)    #( from ld manpage
2325                 LDFLAGS_STATIC=-bstatic
2326                 LDFLAGS_SHARED=-bdynamic
2327                 ;;
2328         hpux*)          #( from ld manpage for hpux10.20, hpux11.11
2329                 # We could also use just "archive" and "shared".
2330                 LDFLAGS_STATIC=-Wl,-a,archive_shared
2331                 LDFLAGS_SHARED=-Wl,-a,shared_archive
2332                 ;;
2333         irix*)          #( from ld manpage IRIX64
2334                 LDFLAGS_STATIC=-Bstatic
2335                 LDFLAGS_SHARED=-Bdynamic
2336                 ;;
2337         osf[[45]]*)     #( from ld manpage osf4.0d, osf5.1
2338                 # alternative "-oldstyle_liblookup" (not in cc manpage)
2339                 LDFLAGS_STATIC=-noso
2340                 LDFLAGS_SHARED=-so_archive
2341                 ;;
2342         solaris2*)
2343                 LDFLAGS_STATIC=-Bstatic
2344                 LDFLAGS_SHARED=-Bdynamic
2345                 ;;
2346         esac
2347 fi
2348
2349 AC_SUBST(LDFLAGS_STATIC)
2350 AC_SUBST(LDFLAGS_SHARED)
2351 ])
2352 dnl ---------------------------------------------------------------------------
2353 dnl CF_LD_RPATH_OPT version: 2 updated: 2010/03/27 19:27:54
2354 dnl ---------------
2355 dnl For the given system and compiler, find the compiler flags to pass to the
2356 dnl loader to use the "rpath" feature.
2357 AC_DEFUN([CF_LD_RPATH_OPT],
2358 [
2359 AC_REQUIRE([CF_CHECK_CACHE])
2360
2361 LD_RPATH_OPT=
2362 AC_MSG_CHECKING(for an rpath option)
2363 case $cf_cv_system_name in #(vi
2364 irix*) #(vi
2365         if test "$GCC" = yes; then
2366                 LD_RPATH_OPT="-Wl,-rpath,"
2367         else
2368                 LD_RPATH_OPT="-rpath "
2369         fi
2370         ;;
2371 linux*|gnu*|k*bsd*-gnu) #(vi
2372         LD_RPATH_OPT="-Wl,-rpath,"
2373         ;;
2374 openbsd[[2-9]].*) #(vi
2375         LD_RPATH_OPT="-Wl,-rpath,"
2376         ;;
2377 freebsd*) #(vi
2378         LD_RPATH_OPT="-rpath "
2379         ;;
2380 netbsd*) #(vi
2381         LD_RPATH_OPT="-Wl,-rpath,"
2382         ;;
2383 osf*|mls+*) #(vi
2384         LD_RPATH_OPT="-rpath "
2385         ;;
2386 solaris2*) #(vi
2387         LD_RPATH_OPT="-R"
2388         ;;
2389 *)
2390         ;;
2391 esac
2392 AC_MSG_RESULT($LD_RPATH_OPT)
2393
2394 case "x$LD_RPATH_OPT" in #(vi
2395 x-R*)
2396         AC_MSG_CHECKING(if we need a space after rpath option)
2397         cf_save_LIBS="$LIBS"
2398         LIBS="${LD_RPATH_OPT}$libdir $LIBS"
2399         AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2400         LIBS="$cf_save_LIBS"
2401         AC_MSG_RESULT($cf_rpath_space)
2402         test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2403         ;;
2404 esac
2405 ])dnl
2406 dnl ---------------------------------------------------------------------------
2407 dnl CF_LIBRARY_PATH version: 9 updated: 2010/03/28 12:52:50
2408 dnl ---------------
2409 dnl Construct a search-list of directories for a nonstandard library-file
2410 dnl
2411 dnl Parameters
2412 dnl     $1 = the variable to return as result
2413 dnl     $2 = the package name
2414 AC_DEFUN([CF_LIBRARY_PATH],
2415 [
2416 $1=
2417 cf_library_path_list=""
2418 if test -n "${LDFLAGS}${LIBS}" ; then
2419         for cf_library_path in $LDFLAGS $LIBS
2420         do
2421                 case $cf_library_path in #(vi
2422                 -L*)
2423                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2424                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2425                         cf_library_path_list="$cf_library_path_list [$]$1"
2426                         ;;
2427                 esac
2428         done
2429 fi
2430
2431 CF_SUBDIR_PATH($1,$2,lib)
2432
2433 $1="$cf_library_path_list [$]$1"
2434 ])dnl
2435 dnl ---------------------------------------------------------------------------
2436 dnl CF_LIB_PREFIX version: 8 updated: 2008/09/13 11:34:16
2437 dnl -------------
2438 dnl Compute the library-prefix for the given host system
2439 dnl $1 = variable to set
2440 AC_DEFUN([CF_LIB_PREFIX],
2441 [
2442         case $cf_cv_system_name in #(vi
2443         OS/2*|os2*) #(vi
2444         LIB_PREFIX=''
2445         ;;
2446         *)      LIB_PREFIX='lib'
2447         ;;
2448         esac
2449 ifelse($1,,,[$1=$LIB_PREFIX])
2450         AC_SUBST(LIB_PREFIX)
2451 ])dnl
2452 dnl ---------------------------------------------------------------------------
2453 dnl CF_LIB_RULES version: 55 updated: 2008/12/13 16:17:38
2454 dnl ------------
2455 dnl Append definitions and rules for the given models to the subdirectory
2456 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
2457 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
2458 dnl the corresponding makefile to list the models that we'll generate.
2459 dnl
2460 dnl For shared libraries, make a list of symbolic links to construct when
2461 dnl generating each library.  The convention used for Linux is the simplest
2462 dnl one:
2463 dnl     lib<name>.so    ->
2464 dnl     lib<name>.so.<major>    ->
2465 dnl     lib<name>.so.<maj>.<minor>
2466 AC_DEFUN([CF_LIB_RULES],
2467 [
2468 CF_LIB_PREFIX(cf_prefix)
2469 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2470
2471 if test $cf_cv_shlib_version = cygdll ; then
2472         TINFO_NAME=$TINFO_ARG_SUFFIX
2473         TINFO_SUFFIX=.dll
2474 fi
2475
2476 for cf_dir in $SRC_SUBDIRS
2477 do
2478         if test ! -d $srcdir/$cf_dir ; then
2479                 continue
2480         elif test -f $srcdir/$cf_dir/modules; then
2481
2482                 SHARED_LIB=
2483                 LIBS_TO_MAKE=
2484                 for cf_item in $cf_LIST_MODELS
2485                 do
2486                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2487                         if test $cf_item = shared ; then
2488                         if test "$cf_cv_do_symlinks" = yes ; then
2489                                 case "$cf_cv_shlib_version" in #(vi
2490                                 rel) #(vi
2491                                         case "$cf_cv_system_name" in #(vi
2492                                         darwin*)
2493                                         case .${LIB_SUFFIX} in
2494                                         .w*)
2495                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2496                                                 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
2497                                                 ;;
2498                                         *)
2499                                                 cf_suffix='.${REL_VERSION}'"$cf_suffix"
2500                                                 ;;
2501                                         esac
2502                                         ;; #(vi
2503                                         *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
2504                                         esac
2505                                         ;;
2506                                 abi)
2507                                         case "$cf_cv_system_name" in #(vi
2508                                         darwin*)
2509                                         case .${LIB_SUFFIX} in
2510                                         .w*)
2511                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2512                                                 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
2513                                                 ;;
2514                                         *)
2515                                                 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
2516                                                 ;;
2517                                         esac
2518                                         ;; #(vi
2519                                         *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
2520                                         esac
2521                                         ;;
2522                                 esac
2523                         fi
2524                         # cygwin needs import library, and has unique naming convention
2525                         # use autodetected ${cf_prefix} for import lib and static lib, but
2526                         # use 'cyg' prefix for shared lib.
2527                         if test $cf_cv_shlib_version = cygdll ; then
2528                                 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
2529                                 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}${cf_cygsuf}"
2530                                 continue
2531                         fi
2532                         fi
2533                         LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
2534                 done
2535
2536                 if test $cf_dir = ncurses ; then
2537                         cf_subsets="$LIB_SUBSETS"
2538                         cf_r_parts="$cf_subsets"
2539                         cf_liblist="$LIBS_TO_MAKE"
2540
2541                         while test -n "$cf_r_parts"
2542                         do
2543                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
2544                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
2545                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
2546                                         cf_item=
2547                                         case $cf_l_parts in #(vi
2548                                         *termlib*) #(vi
2549                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
2550                                                 ;;
2551                                         *ticlib*)
2552                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
2553                                                 ;;
2554                                         *)
2555                                                 break
2556                                                 ;;
2557                                         esac
2558                                         if test -n "$cf_item"; then
2559                                                 LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
2560                                         fi
2561                                 else
2562                                         break
2563                                 fi
2564                         done
2565                 else
2566                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
2567                 fi
2568
2569                 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
2570                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
2571                         $cf_dir/Makefile >$cf_dir/Makefile.out
2572                 mv $cf_dir/Makefile.out $cf_dir/Makefile
2573
2574                 $AWK -f $srcdir/mk-0th.awk \
2575                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
2576                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2577
2578                 for cf_subset in $cf_subsets
2579                 do
2580                         cf_subdirs=
2581                         for cf_item in $cf_LIST_MODELS
2582                         do
2583                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
2584                         CF_UPPER(cf_ITEM,$cf_item)
2585                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2586                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
2587
2588                         # Test for case where we build libtinfo with a different name.
2589                         cf_libname=$cf_dir
2590                         if test $cf_dir = ncurses ; then
2591                                 case $cf_subset in
2592                                 *base*)
2593                                         cf_libname=${cf_libname}$LIB_SUFFIX
2594                                         ;;
2595                                 *termlib*)
2596                                         cf_libname=$TINFO_LIB_SUFFIX
2597                                         ;;
2598                                 ticlib*)
2599                                         cf_libname=$TICS_LIB_SUFFIX
2600                                         ;;
2601                                 esac
2602                         else
2603                                 cf_libname=${cf_libname}$LIB_SUFFIX
2604                         fi
2605                         if test -n "${DFT_ARG_SUFFIX}" ; then
2606                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2607                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2608                         fi
2609
2610                         # These dependencies really are for development, not
2611                         # builds, but they are useful in porting, too.
2612                         cf_depend="../include/ncurses_cfg.h"
2613                         if test "$srcdir" = "."; then
2614                                 cf_reldir="."
2615                         else
2616                                 cf_reldir="\${srcdir}"
2617                         fi
2618
2619                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
2620                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
2621                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
2622                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
2623                         fi
2624
2625                         cf_dir_suffix=
2626                         old_cf_suffix="$cf_suffix"
2627                         if test "$cf_cv_shlib_version_infix" = yes ; then
2628                         if test -n "$LIB_SUFFIX" ; then
2629                                 case $LIB_SUFFIX in
2630                                 w*)
2631                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
2632                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2633                                         cf_dir_suffix=w
2634                                         ;;
2635                                 esac
2636                         fi
2637                         fi
2638
2639                         $AWK -f $srcdir/mk-1st.awk \
2640                                 name=${cf_libname}${cf_dir_suffix} \
2641                                 traces=$LIB_TRACING \
2642                                 MODEL=$cf_ITEM \
2643                                 model=$cf_subdir \
2644                                 prefix=$cf_prefix \
2645                                 suffix=$cf_suffix \
2646                                 subset=$cf_subset \
2647                                 TermlibRoot=$TINFO_NAME \
2648                                 TermlibSuffix=$TINFO_SUFFIX \
2649                                 ShlibVer=$cf_cv_shlib_version \
2650                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
2651                                 ReLink=${cf_cv_do_relink-no} \
2652                                 DoLinks=$cf_cv_do_symlinks \
2653                                 rmSoLocs=$cf_cv_rm_so_locs \
2654                                 ldconfig="$LDCONFIG" \
2655                                 overwrite=$WITH_OVERWRITE \
2656                                 depend="$cf_depend" \
2657                                 host="$host" \
2658                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2659
2660                         cf_suffix="$old_cf_suffix"
2661
2662                         for cf_subdir2 in $cf_subdirs lib
2663                         do
2664                                 test $cf_subdir = $cf_subdir2 && break
2665                         done
2666                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
2667                         $AWK -f $srcdir/mk-2nd.awk \
2668                                 name=$cf_dir \
2669                                 traces=$LIB_TRACING \
2670                                 MODEL=$cf_ITEM \
2671                                 model=$cf_subdir \
2672                                 subset=$cf_subset \
2673                                 srcdir=$srcdir \
2674                                 echo=$WITH_ECHO \
2675                                 crenames=$cf_cv_prog_CC_c_o \
2676                                 cxxrenames=$cf_cv_prog_CXX_c_o \
2677                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2678                         cf_subdirs="$cf_subdirs $cf_subdir"
2679                         done
2680                 done
2681         fi
2682
2683         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
2684 done
2685
2686 for cf_dir in $SRC_SUBDIRS
2687 do
2688         if test ! -d $srcdir/$cf_dir ; then
2689                 continue
2690         fi
2691
2692         if test -f $cf_dir/Makefile ; then
2693                 case "$cf_dir" in
2694                 Ada95) #(vi
2695                         echo 'libs \' >> Makefile
2696                         echo 'install.libs \' >> Makefile
2697                         echo 'uninstall.libs ::' >> Makefile
2698                         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
2699                         ;;
2700                 esac
2701         fi
2702
2703         if test -f $srcdir/$cf_dir/modules; then
2704                 echo >> Makefile
2705                 if test -f $srcdir/$cf_dir/headers; then
2706 cat >> Makefile <<CF_EOF
2707 install.includes \\
2708 uninstall.includes \\
2709 CF_EOF
2710                 fi
2711 if test "$cf_dir" != "c++" ; then
2712 echo 'lint \' >> Makefile
2713 fi
2714 cat >> Makefile <<CF_EOF
2715 libs \\
2716 lintlib \\
2717 install.libs \\
2718 uninstall.libs \\
2719 install.$cf_dir \\
2720 uninstall.$cf_dir ::
2721         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2722 CF_EOF
2723         elif test -f $srcdir/$cf_dir/headers; then
2724 cat >> Makefile <<CF_EOF
2725
2726 libs \\
2727 install.libs \\
2728 uninstall.libs \\
2729 install.includes \\
2730 uninstall.includes ::
2731         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2732 CF_EOF
2733 fi
2734 done
2735
2736 cat >> Makefile <<CF_EOF
2737
2738 install.libs uninstall.libs \\
2739 install.data uninstall.data ::
2740 $MAKE_TERMINFO  cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
2741 CF_EOF
2742
2743 if test "x$cf_with_manpages" = xyes; then
2744 cat >> Makefile <<CF_EOF
2745
2746 install.man \\
2747 uninstall.man ::
2748         cd man && \${MAKE} \${CF_MFLAGS} \[$]@
2749 CF_EOF
2750 fi
2751
2752 cat >> Makefile <<CF_EOF
2753
2754 distclean ::
2755         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
2756         rm -f headers.sh headers.sed mk_shared_lib.sh
2757         rm -f edit_man.* man_alias.*
2758         rm -rf \${DIRS_TO_MAKE}
2759 CF_EOF
2760
2761 # Special case: tack's manpage lives in its own directory.
2762 if test "x$cf_with_manpages" = xyes; then
2763 if test -d tack ; then
2764 if test -f $srcdir/$tack.h; then
2765 cat >> Makefile <<CF_EOF
2766
2767 install.man \\
2768 uninstall.man ::
2769         cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
2770 CF_EOF
2771 fi
2772 fi
2773 fi
2774
2775 dnl If we're installing into a subdirectory of /usr/include, etc., we should
2776 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
2777 dnl anything, and will make it more standardized.  It's awkward to decide this
2778 dnl at configuration because of quoting, so we'll simply make all headers
2779 dnl installed via a script that can do the right thing.
2780
2781 rm -f headers.sed headers.sh
2782
2783 dnl ( generating this script makes the makefiles a little tidier :-)
2784 echo creating headers.sh
2785 cat >headers.sh <<CF_EOF
2786 #! /bin/sh
2787 # This shell script is generated by the 'configure' script.  It is invoked in a
2788 # subdirectory of the build tree.  It generates a sed-script in the parent
2789 # directory that is used to adjust includes for header files that reside in a
2790 # subdirectory of /usr/include, etc.
2791 PRG=""
2792 while test \[$]# != 3
2793 do
2794 PRG="\$PRG \[$]1"; shift
2795 done
2796 DST=\[$]1
2797 REF=\[$]2
2798 SRC=\[$]3
2799 TMPSRC=\${TMPDIR-/tmp}/\`basename \$SRC\`\$\$
2800 TMPSED=\${TMPDIR-/tmp}/headers.sed\$\$
2801 echo installing \$SRC in \$DST
2802 CF_EOF
2803
2804 if test $WITH_CURSES_H = yes; then
2805         cat >>headers.sh <<CF_EOF
2806 case \$DST in
2807 /*/include/*)
2808         END=\`basename \$DST\`
2809         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2810         do
2811                 NAME=\`basename \$i\`
2812                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2813         done
2814         ;;
2815 *)
2816         echo "" >> \$TMPSED
2817         ;;
2818 esac
2819 CF_EOF
2820
2821 else
2822         cat >>headers.sh <<CF_EOF
2823 case \$DST in
2824 /*/include/*)
2825         END=\`basename \$DST\`
2826         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2827         do
2828                 NAME=\`basename \$i\`
2829                 if test "\$NAME" = "curses.h"
2830                 then
2831                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2832                         NAME=ncurses.h
2833                 fi
2834                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2835         done
2836         ;;
2837 *)
2838         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2839         ;;
2840 esac
2841 CF_EOF
2842 fi
2843 cat >>headers.sh <<CF_EOF
2844 rm -f \$TMPSRC
2845 sed -f \$TMPSED \$SRC > \$TMPSRC
2846 NAME=\`basename \$SRC\`
2847 CF_EOF
2848 if test $WITH_CURSES_H != yes; then
2849         cat >>headers.sh <<CF_EOF
2850 test "\$NAME" = "curses.h" && NAME=ncurses.h
2851 CF_EOF
2852 fi
2853 cat >>headers.sh <<CF_EOF
2854 # Just in case someone gzip'd manpages, remove the conflicting copy.
2855 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
2856
2857 eval \$PRG \$TMPSRC \$DST/\$NAME
2858 rm -f \$TMPSRC \$TMPSED
2859 CF_EOF
2860
2861 chmod 0755 headers.sh
2862
2863 for cf_dir in $SRC_SUBDIRS
2864 do
2865         if test ! -d $srcdir/$cf_dir ; then
2866                 continue
2867         fi
2868
2869         if test -f $srcdir/$cf_dir/headers; then
2870                 $AWK -f $srcdir/mk-hdr.awk \
2871                         subset="$LIB_SUBSETS" \
2872                         compat="$WITH_CURSES_H" \
2873                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
2874         fi
2875
2876         if test -f $srcdir/$cf_dir/modules; then
2877                 if test "$cf_dir" != "c++" ; then
2878                         cat >>$cf_dir/Makefile <<"CF_EOF"
2879 depend : ${AUTO_SRC}
2880         makedepend -- ${CPPFLAGS} -- ${C_SRC}
2881
2882 # DO NOT DELETE THIS LINE -- make depend depends on it.
2883 CF_EOF
2884                 fi
2885         fi
2886 done
2887
2888 ])dnl
2889 dnl ---------------------------------------------------------------------------
2890 dnl CF_LIB_SONAME version: 3 updated: 2006/12/16 15:55:46
2891 dnl -------------
2892 dnl Find the and soname for the given shared library.  Set the cache variable
2893 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
2894 dnl variable to "unknown".
2895 dnl
2896 dnl $1 = headers
2897 dnl $2 = code
2898 dnl $3 = library name
2899 AC_DEFUN([CF_LIB_SONAME],
2900 [
2901 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
2902
2903 cf_cv_$3_soname=unknown
2904 if test "$cross_compiling" != yes ; then
2905 cat >conftest.$ac_ext <<CF_EOF
2906 $1
2907 int main()
2908 {
2909 $2
2910         ${cf_cv_main_return:-return}(0);
2911 }
2912 CF_EOF
2913 cf_save_LIBS="$LIBS"
2914         LIBS="-l$3 $LIBS"
2915         if AC_TRY_EVAL(ac_compile) ; then
2916                 if AC_TRY_EVAL(ac_link) ; then
2917                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
2918                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
2919                 fi
2920         fi
2921 rm -f conftest*
2922 LIBS="$cf_save_LIBS"
2923 fi
2924 ])
2925 ])
2926 dnl ---------------------------------------------------------------------------
2927 dnl CF_LIB_SUFFIX version: 16 updated: 2008/12/27 12:30:03
2928 dnl -------------
2929 dnl Compute the library file-suffix from the given model name
2930 dnl $1 = model name
2931 dnl $2 = variable to set (the nominal library suffix)
2932 dnl $3 = dependency variable to set (actual filename)
2933 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2934 AC_DEFUN([CF_LIB_SUFFIX],
2935 [
2936         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2937         case $1 in #(vi
2938         libtool) #(vi
2939                 $2='.la'
2940                 $3=[$]$2
2941                 ;;
2942         normal) #(vi
2943                 $2='.a'
2944                 $3=[$]$2
2945                 ;;
2946         debug) #(vi
2947                 $2='_g.a'
2948                 $3=[$]$2
2949                 ;;
2950         profile) #(vi
2951                 $2='_p.a'
2952                 $3=[$]$2
2953                 ;;
2954         shared) #(vi
2955                 case $cf_cv_system_name in
2956                 aix[[56]]*) #(vi
2957                         $2='.a'
2958                         $3=[$]$2
2959                         ;;
2960                 cygwin*) #(vi
2961                         $2='.dll'
2962                         $3='.dll.a'
2963                         ;;
2964                 darwin*) #(vi
2965                         $2='.dylib'
2966                         $3=[$]$2
2967                         ;;
2968                 hpux*) #(vi
2969                         case $target in
2970                         ia64*) #(vi
2971                                 $2='.so'
2972                                 $3=[$]$2
2973                                 ;;
2974                         *) #(vi
2975                                 $2='.sl'
2976                                 $3=[$]$2
2977                                 ;;
2978                         esac
2979                         ;;
2980                 *)      $2='.so'
2981                         $3=[$]$2
2982                         ;;
2983                 esac
2984         esac
2985         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2986         test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
2987 ])dnl
2988 dnl ---------------------------------------------------------------------------
2989 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
2990 dnl -----------
2991 dnl Compute the string to append to -library from the given model name
2992 dnl $1 = model name
2993 dnl $2 = variable to set
2994 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2995 AC_DEFUN([CF_LIB_TYPE],
2996 [
2997         case $1 in
2998         libtool) $2=''   ;;
2999         normal)  $2=''   ;;
3000         debug)   $2='_g' ;;
3001         profile) $2='_p' ;;
3002         shared)  $2=''   ;;
3003         esac
3004         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3005 ])dnl
3006 dnl ---------------------------------------------------------------------------
3007 dnl CF_LINK_DATAONLY version: 9 updated: 2009/01/01 20:21:38
3008 dnl ----------------
3009 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
3010 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
3011 dnl have to provide wrappers for global tables to ensure they're linked
3012 dnl properly.
3013 AC_DEFUN([CF_LINK_DATAONLY],
3014 [
3015 AC_MSG_CHECKING([if data-only library module links])
3016 AC_CACHE_VAL(cf_cv_link_dataonly,[
3017         rm -f conftest.a
3018         cat >conftest.$ac_ext <<EOF
3019 #line __oline__ "configure"
3020 int     testdata[[3]] = { 123, 456, 789 };
3021 EOF
3022         if AC_TRY_EVAL(ac_compile) ; then
3023                 mv conftest.o data.o && \
3024                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
3025         fi
3026         rm -f conftest.$ac_ext data.o
3027         cat >conftest.$ac_ext <<EOF
3028 #line __oline__ "configure"
3029 int     testfunc()
3030 {
3031 #if defined(NeXT)
3032         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
3033 #else
3034         extern int testdata[[3]];
3035         return testdata[[0]] == 123
3036            &&  testdata[[1]] == 456
3037            &&  testdata[[2]] == 789;
3038 #endif
3039 }
3040 EOF
3041         if AC_TRY_EVAL(ac_compile); then
3042                 mv conftest.o func.o && \
3043                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
3044         fi
3045         rm -f conftest.$ac_ext func.o
3046         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
3047         cf_saveLIBS="$LIBS"
3048         LIBS="conftest.a $LIBS"
3049         AC_TRY_RUN([
3050         int main()
3051         {
3052                 extern int testfunc();
3053                 ${cf_cv_main_return:-return} (!testfunc());
3054         }
3055         ],
3056         [cf_cv_link_dataonly=yes],
3057         [cf_cv_link_dataonly=no],
3058         [cf_cv_link_dataonly=unknown])
3059         LIBS="$cf_saveLIBS"
3060         ])
3061 AC_MSG_RESULT($cf_cv_link_dataonly)
3062
3063 if test "$cf_cv_link_dataonly" = no ; then
3064         AC_DEFINE(BROKEN_LINKER)
3065         BROKEN_LINKER=1
3066 fi
3067
3068 ])dnl
3069 dnl ---------------------------------------------------------------------------
3070 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
3071 dnl -------------
3072 dnl Most Unix systems have both link and symlink, a few don't have symlink.
3073 dnl A few non-Unix systems implement symlink, but not link.
3074 dnl A few non-systems implement neither (or have nonfunctional versions).
3075 AC_DEFUN([CF_LINK_FUNCS],
3076 [
3077 AC_CHECK_FUNCS( \
3078         remove \
3079         unlink )
3080
3081 if test "$cross_compiling" = yes ; then
3082         AC_CHECK_FUNCS( \
3083                 link \
3084                 symlink )
3085 else
3086         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
3087                 cf_cv_link_funcs=
3088                 for cf_func in link symlink ; do
3089                         AC_TRY_RUN([
3090 #include <sys/types.h>
3091 #include <sys/stat.h>
3092 #ifdef HAVE_UNISTD_H
3093 #include <unistd.h>
3094 #endif
3095 int main()
3096 {
3097         int fail = 0;
3098         char *src = "config.log";
3099         char *dst = "conftest.chk";
3100         struct stat src_sb;
3101         struct stat dst_sb;
3102
3103         stat(src, &src_sb);
3104         fail = ($cf_func("config.log", "conftest.chk") < 0)
3105             || (stat(dst, &dst_sb) < 0)
3106             || (dst_sb.st_mtime != src_sb.st_mtime);
3107 #ifdef HAVE_UNLINK
3108         unlink(dst);
3109 #else
3110         remove(dst);
3111 #endif
3112         ${cf_cv_main_return:-return} (fail);
3113 }
3114                         ],[
3115                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
3116                         eval 'ac_cv_func_'$cf_func'=yes'],[
3117                         eval 'ac_cv_func_'$cf_func'=no'],[
3118                         eval 'ac_cv_func_'$cf_func'=error'])
3119                 done
3120                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
3121         ])
3122         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
3123         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
3124 fi
3125 ])dnl
3126 dnl ---------------------------------------------------------------------------
3127 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
3128 dnl --------------
3129 dnl Check if a return from main to the shell actually returns the same exit
3130 dnl code.  This is true for almost any POSIX environment.
3131 dnl
3132 dnl Some very old environments did not flush stdout, etc., on an exit.  That
3133 dnl would be a useful case to test for also.
3134 AC_DEFUN([CF_MAIN_RETURN],
3135 [
3136 cf_cv_main_return=return
3137 ])dnl
3138 dnl ---------------------------------------------------------------------------
3139 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
3140 dnl ------------
3141 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
3142 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
3143 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
3144 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
3145 AC_DEFUN([CF_MAKEFLAGS],
3146 [
3147 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
3148         cf_cv_makeflags=''
3149         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
3150         do
3151                 cat >cf_makeflags.tmp <<CF_EOF
3152 SHELL = /bin/sh
3153 all :
3154         @ echo '.$cf_option'
3155 CF_EOF
3156                 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[       ]]*$,,'`
3157                 case "$cf_result" in
3158                 .*k)
3159                         cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
3160                         case "$cf_result" in
3161                         .*CC=*) cf_cv_makeflags=
3162                                 ;;
3163                         *)      cf_cv_makeflags=$cf_option
3164                                 ;;
3165                         esac
3166                         break
3167                         ;;
3168                 .-)     ;;
3169                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
3170                         ;;
3171                 esac
3172         done
3173         rm -f cf_makeflags.tmp
3174 ])
3175
3176 AC_SUBST(cf_cv_makeflags)
3177 ])dnl
3178 dnl ---------------------------------------------------------------------------
3179 dnl CF_MAKE_TAGS version: 5 updated: 2010/04/03 20:07:32
3180 dnl ------------
3181 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
3182 dnl a monocase filesystem.
3183 AC_DEFUN([CF_MAKE_TAGS],[
3184 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
3185
3186 AC_CHECK_PROGS(CTAGS, exctags ctags)
3187 AC_CHECK_PROGS(ETAGS, exetags etags)
3188
3189 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS-ctags}, yes, no)
3190
3191 if test "$cf_cv_mixedcase" = yes ; then
3192         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS-etags}, yes, no)
3193 else
3194         MAKE_UPPER_TAGS=no
3195 fi
3196
3197 if test "$MAKE_UPPER_TAGS" = yes ; then
3198         MAKE_UPPER_TAGS=
3199 else
3200         MAKE_UPPER_TAGS="#"
3201 fi
3202
3203 if test "$MAKE_LOWER_TAGS" = yes ; then
3204         MAKE_LOWER_TAGS=
3205 else
3206         MAKE_LOWER_TAGS="#"
3207 fi
3208
3209 AC_SUBST(CTAGS)
3210 AC_SUBST(ETAGS)
3211
3212 AC_SUBST(MAKE_UPPER_TAGS)
3213 AC_SUBST(MAKE_LOWER_TAGS)
3214 ])dnl
3215 dnl ---------------------------------------------------------------------------
3216 dnl CF_MANPAGE_FORMAT version: 8 updated: 2009/01/11 20:30:50
3217 dnl -----------------
3218 dnl Option to allow user to override automatic configuration of manpage format.
3219 dnl There are several special cases:
3220 dnl
3221 dnl     gzip - man checks for, can display gzip'd files
3222 dnl     compress - man checks for, can display compressed files
3223 dnl     BSDI - files in the cat-directories are suffixed ".0"
3224 dnl     formatted - installer should format (put files in cat-directory)
3225 dnl     catonly - installer should only format, e.g., for a turnkey system.
3226 dnl
3227 dnl There are other configurations which this macro does not test, e.g., HPUX's
3228 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
3229 dnl convention would not match our use).
3230 AC_DEFUN([CF_MANPAGE_FORMAT],
3231 [
3232 AC_REQUIRE([CF_PATHSEP])
3233 AC_MSG_CHECKING(format of man-pages)
3234
3235 AC_ARG_WITH(manpage-format,
3236         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
3237                           optionally formatted/catonly, e.g., gzip,formatted],
3238         [MANPAGE_FORMAT=$withval],
3239         [MANPAGE_FORMAT=unknown])
3240
3241 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
3242 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
3243
3244 cf_unknown=
3245
3246 case $MANPAGE_FORMAT in
3247 unknown)
3248   if test -z "$MANPATH" ; then
3249     MANPATH="/usr/man:/usr/share/man"
3250   fi
3251
3252   # look for the 'date' man-page (it's most likely to be installed!)
3253   MANPAGE_FORMAT=
3254   cf_preform=no
3255   cf_catonly=yes
3256   cf_example=date
3257
3258   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
3259   for cf_dir in $MANPATH; do
3260     test -z "$cf_dir" && cf_dir=/usr/man
3261     for cf_name in $cf_dir/man*/$cf_example.[[01]]* $cf_dir/cat*/$cf_example.[[01]]* $cf_dir/man*/$cf_example $cf_dir/cat*/$cf_example
3262     do
3263       cf_test=`echo $cf_name | sed -e 's/*//'`
3264       if test "x$cf_test" = "x$cf_name" ; then
3265
3266         case "$cf_name" in
3267         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
3268         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
3269         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
3270         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
3271         esac
3272
3273         case "$cf_name" in
3274         $cf_dir/man*)
3275           cf_catonly=no
3276           ;;
3277         $cf_dir/cat*)
3278           cf_preform=yes
3279           ;;
3280         esac
3281         break
3282       fi
3283
3284       # if we found a match in either man* or cat*, stop looking
3285       if test -n "$MANPAGE_FORMAT" ; then
3286         cf_found=no
3287         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
3288         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
3289         case "$cf_name" in
3290         $cf_dir/cat*)
3291           cf_found=yes
3292           ;;
3293         esac
3294         test $cf_found=yes && break
3295       fi
3296     done
3297     # only check the first directory in $MANPATH where we find manpages
3298     if test -n "$MANPAGE_FORMAT" ; then
3299        break
3300     fi
3301   done
3302   # if we did not find the example, just assume it is normal
3303   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
3304   IFS="$ac_save_ifs"
3305   ;;
3306 *)
3307   for cf_option in $MANPAGE_FORMAT; do
3308      case $cf_option in #(vi
3309      gzip|compress|BSDI|normal|formatted|catonly)
3310        ;;
3311      *)
3312        cf_unknown="$cf_unknown $cf_option"
3313        ;;
3314      esac
3315   done
3316   ;;
3317 esac
3318
3319 AC_MSG_RESULT($MANPAGE_FORMAT)
3320 if test -n "$cf_unknown" ; then
3321   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
3322 fi
3323 ])dnl
3324 dnl ---------------------------------------------------------------------------
3325 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
3326 dnl ------------------
3327 dnl The Debian people have their own naming convention for manpages.  This
3328 dnl option lets us override the name of the file containing renaming, or
3329 dnl disable it altogether.
3330 AC_DEFUN([CF_MANPAGE_RENAMES],
3331 [
3332 AC_MSG_CHECKING(for manpage renaming)
3333
3334 AC_ARG_WITH(manpage-renames,
3335         [  --with-manpage-renames  specify manpage-renaming],
3336         [MANPAGE_RENAMES=$withval],
3337         [MANPAGE_RENAMES=yes])
3338
3339 case ".$MANPAGE_RENAMES" in #(vi
3340 .no) #(vi
3341   ;;
3342 .|.yes)
3343   # Debian 'man' program?
3344   if test -f /etc/debian_version ; then
3345     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
3346   else
3347     MANPAGE_RENAMES=no
3348   fi
3349   ;;
3350 esac
3351
3352 if test "$MANPAGE_RENAMES" != no ; then
3353   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
3354     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
3355   elif test ! -f $MANPAGE_RENAMES ; then
3356     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
3357   fi
3358
3359   test ! -d man && mkdir man
3360
3361   # Construct a sed-script to perform renaming within man-pages
3362   if test -n "$MANPAGE_RENAMES" ; then
3363     test ! -d man && mkdir man
3364     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
3365   fi
3366 fi
3367
3368 AC_MSG_RESULT($MANPAGE_RENAMES)
3369 AC_SUBST(MANPAGE_RENAMES)
3370 ])dnl
3371 dnl ---------------------------------------------------------------------------
3372 dnl CF_MANPAGE_SYMLINKS version: 4 updated: 2003/12/13 18:01:58
3373 dnl -------------------
3374 dnl Some people expect each tool to make all aliases for manpages in the
3375 dnl man-directory.  This accommodates the older, less-capable implementations
3376 dnl of 'man', and is optional.
3377 AC_DEFUN([CF_MANPAGE_SYMLINKS],
3378 [
3379 AC_MSG_CHECKING(if manpage aliases will be installed)
3380
3381 AC_ARG_WITH(manpage-aliases,
3382         [  --with-manpage-aliases  specify manpage-aliases using .so],
3383         [MANPAGE_ALIASES=$withval],
3384         [MANPAGE_ALIASES=yes])
3385
3386 AC_MSG_RESULT($MANPAGE_ALIASES)
3387
3388 if test "$LN_S" = "ln -s"; then
3389         cf_use_symlinks=yes
3390 else
3391         cf_use_symlinks=no
3392 fi
3393
3394 MANPAGE_SYMLINKS=no
3395 if test "$MANPAGE_ALIASES" = yes ; then
3396 AC_MSG_CHECKING(if manpage symlinks should be used)
3397
3398 AC_ARG_WITH(manpage-symlinks,
3399         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
3400         [MANPAGE_SYMLINKS=$withval],
3401         [MANPAGE_SYMLINKS=$cf_use_symlinks])
3402
3403 if test "$$cf_use_symlinks" = no; then
3404 if test "$MANPAGE_SYMLINKS" = yes ; then
3405         AC_MSG_WARN(cannot make symlinks, will use .so files)
3406         MANPAGE_SYMLINKS=no
3407 fi
3408 fi
3409
3410 AC_MSG_RESULT($MANPAGE_SYMLINKS)
3411 fi
3412
3413 ])dnl
3414 dnl ---------------------------------------------------------------------------
3415 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
3416 dnl --------------
3417 dnl This option causes manpages to be run through tbl(1) to generate tables
3418 dnl correctly.
3419 AC_DEFUN([CF_MANPAGE_TBL],
3420 [
3421 AC_MSG_CHECKING(for manpage tbl)
3422
3423 AC_ARG_WITH(manpage-tbl,
3424         [  --with-manpage-tbl      specify manpage processing with tbl],
3425         [MANPAGE_TBL=$withval],
3426         [MANPAGE_TBL=no])
3427
3428 AC_MSG_RESULT($MANPAGE_TBL)
3429 ])dnl
3430 dnl ---------------------------------------------------------------------------
3431 dnl CF_MAN_PAGES version: 36 updated: 2010/03/13 13:41:01
3432 dnl ------------
3433 dnl Try to determine if the man-pages on the system are compressed, and if
3434 dnl so, what format is used.  Use this information to construct a script that
3435 dnl will install man-pages.
3436 AC_DEFUN([CF_MAN_PAGES],
3437 [
3438 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
3439 CF_MANPAGE_FORMAT
3440 CF_MANPAGE_RENAMES
3441 CF_MANPAGE_SYMLINKS
3442 CF_MANPAGE_TBL
3443
3444   if test "$prefix" = "NONE" ; then
3445      cf_prefix="$ac_default_prefix"
3446   else
3447      cf_prefix="$prefix"
3448   fi
3449
3450   case "$MANPAGE_FORMAT" in # (vi
3451   *catonly*) # (vi
3452     cf_format=yes
3453     cf_inboth=no
3454     ;;
3455   *formatted*) # (vi
3456     cf_format=yes
3457     cf_inboth=yes
3458     ;;
3459   *)
3460     cf_format=no
3461     cf_inboth=no
3462     ;;
3463   esac
3464
3465 test ! -d man && mkdir man
3466
3467 cf_so_strip=
3468 cf_compress=
3469 case "$MANPAGE_FORMAT" in #(vi
3470 *compress*) #(vi
3471         cf_so_strip="Z"
3472         cf_compress=compress
3473   ;;
3474 *gzip*) #(vi
3475         cf_so_strip="gz"
3476         cf_compress=gzip
3477   ;;
3478 esac
3479
3480 cf_edit_man=./edit_man.sh
3481 cf_man_alias=`pwd`/man_alias.sed
3482
3483 cat >$cf_edit_man <<CF_EOF
3484 #! /bin/sh
3485 # this script is generated by the configure-script CF_MAN_PAGES macro.
3486
3487 prefix="$cf_prefix"
3488 datadir="$datadir"
3489
3490 NCURSES_MAJOR="$NCURSES_MAJOR"
3491 NCURSES_MINOR="$NCURSES_MINOR"
3492 NCURSES_PATCH="$NCURSES_PATCH"
3493
3494 NCURSES_OSPEED="$NCURSES_OSPEED"
3495 TERMINFO="$TERMINFO"
3496
3497 MKDIRS="sh `cd $srcdir && pwd`/mkdirs.sh"
3498
3499 INSTALL="$INSTALL"
3500 INSTALL_DATA="$INSTALL_DATA"
3501
3502 transform="$program_transform_name"
3503
3504 TMP=\${TMPDIR-/tmp}/man\$\$
3505 trap "rm -f \$TMP" 0 1 2 5 15
3506
3507 form=\[$]1
3508 shift || exit 1
3509
3510 verb=\[$]1
3511 shift || exit 1
3512
3513 mandir=\[$]1
3514 shift || exit 1
3515
3516 srcdir=\[$]1
3517 top_srcdir=\[$]srcdir/..
3518 shift || exit 1
3519
3520 if test "\$form" = normal ; then
3521         if test "$cf_format" = yes ; then
3522         if test "$cf_inboth" = no ; then
3523                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3524                 exit $?
3525         fi
3526         fi
3527         cf_subdir=\$mandir/man
3528         cf_tables=$MANPAGE_TBL
3529 else
3530         cf_subdir=\$mandir/cat
3531         cf_tables=yes
3532 fi
3533
3534 # process the list of source-files
3535 for i in \[$]* ; do
3536 case \$i in #(vi
3537 *.orig|*.rej) ;; #(vi
3538 *.[[0-9]]*)
3539         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
3540         if test \$verb = installing ; then
3541         if test ! -d \$cf_subdir\${section} ; then
3542                 \$MKDIRS \$cf_subdir\$section
3543         fi
3544         fi
3545
3546         # replace variables in man page
3547         if test ! -f $cf_man_alias ; then
3548 cat >>$cf_man_alias <<-CF_EOF2
3549                 s,@DATADIR@,\$datadir,g
3550                 s,@TERMINFO@,\$TERMINFO,g
3551                 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
3552                 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
3553                 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
3554                 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
3555 CF_EOF
3556         ifelse($1,,,[
3557         for cf_name in $1
3558         do
3559                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3560                 cf_name=`echo $cf_name|sed "$program_transform_name"`
3561 cat >>$cf_edit_man <<-CF_EOF
3562                 s,@$cf_NAME@,$cf_name,g
3563 CF_EOF
3564         done
3565         ])
3566 cat >>$cf_edit_man <<CF_EOF
3567 CF_EOF2
3568                 echo "...made $cf_man_alias"
3569         fi
3570
3571         aliases=
3572         cf_source=\`basename \$i\`
3573         inalias=\$cf_source
3574         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
3575         if test ! -f \$inalias ; then
3576                 echo .. skipped \$cf_source
3577                 continue
3578         fi
3579 CF_EOF
3580
3581 if test "$MANPAGE_ALIASES" != no ; then
3582 cat >>$cf_edit_man <<CF_EOF
3583         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
3584 CF_EOF
3585 fi
3586
3587 if test "$MANPAGE_RENAMES" = no ; then
3588 cat >>$cf_edit_man <<CF_EOF
3589         # perform program transformations for section 1 man pages
3590         if test \$section = 1 ; then
3591                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
3592         else
3593                 cf_target=\$cf_subdir\${section}/\$cf_source
3594         fi
3595 CF_EOF
3596 else
3597 cat >>$cf_edit_man <<CF_EOF
3598         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
3599         if test -z "\$cf_target" ; then
3600                 echo '? missing rename for '\$cf_source
3601                 cf_target="\$cf_source"
3602         fi
3603         cf_target="\$cf_subdir\${section}/\${cf_target}"
3604
3605 CF_EOF
3606 fi
3607
3608 cat >>$cf_edit_man <<CF_EOF
3609         sed     -f $cf_man_alias \\
3610 CF_EOF
3611
3612 if test -f $MANPAGE_RENAMES ; then
3613 cat >>$cf_edit_man <<CF_EOF
3614                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
3615 CF_EOF
3616 else
3617 cat >>$cf_edit_man <<CF_EOF
3618                 < \$i >\$TMP
3619 CF_EOF
3620 fi
3621
3622 cat >>$cf_edit_man <<CF_EOF
3623 if test \$cf_tables = yes ; then
3624         tbl \$TMP >\$TMP.out
3625         mv \$TMP.out \$TMP
3626 fi
3627 CF_EOF
3628
3629 if test $with_curses_h != yes ; then
3630 cat >>$cf_edit_man <<CF_EOF
3631         sed -e "/\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
3632         mv \$TMP.out \$TMP
3633 CF_EOF
3634 fi
3635
3636 cat >>$cf_edit_man <<CF_EOF
3637         if test \$form = format ; then
3638                 nroff -man \$TMP >\$TMP.out
3639                 mv \$TMP.out \$TMP
3640         fi
3641 CF_EOF
3642
3643 if test -n "$cf_compress" ; then
3644 cat >>$cf_edit_man <<CF_EOF
3645         if test \$verb = installing ; then
3646         if ( $cf_compress -f \$TMP )
3647         then
3648                 mv \$TMP.$cf_so_strip \$TMP
3649         fi
3650         fi
3651         cf_target="\$cf_target.$cf_so_strip"
3652 CF_EOF
3653 fi
3654
3655 case "$MANPAGE_FORMAT" in #(vi
3656 *BSDI*)
3657 cat >>$cf_edit_man <<CF_EOF
3658         if test \$form = format ; then
3659                 # BSDI installs only .0 suffixes in the cat directories
3660                 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
3661         fi
3662 CF_EOF
3663   ;;
3664 esac
3665
3666 cat >>$cf_edit_man <<CF_EOF
3667         suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
3668         if test \$verb = installing ; then
3669                 echo \$verb \$cf_target
3670                 \$INSTALL_DATA \$TMP \$cf_target
3671                 test -d \$cf_subdir\${section} &&
3672                 test -n "\$aliases" && (
3673                         cd \$cf_subdir\${section} && (
3674                                 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
3675                                 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
3676                                 cf_target=\`basename \$cf_target\`
3677                                 for cf_alias in \$aliases
3678                                 do
3679                                         if test \$section = 1 ; then
3680                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3681                                         fi
3682
3683                                         if test "$MANPAGE_SYMLINKS" = yes ; then
3684                                                 if test -f \$cf_alias\${suffix} ; then
3685                                                         if ( cmp -s \$cf_target \$cf_alias\${suffix} )
3686                                                         then
3687                                                                 continue
3688                                                         fi
3689                                                 fi
3690                                                 echo .. \$verb alias \$cf_alias\${suffix}
3691                                                 rm -f \$cf_alias\${suffix}
3692                                                 $LN_S \$cf_target \$cf_alias\${suffix}
3693                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
3694                                                 echo ".so \$cf_source" >\$TMP
3695 CF_EOF
3696 if test -n "$cf_compress" ; then
3697 cat >>$cf_edit_man <<CF_EOF
3698                                                 if test -n "$cf_so_strip" ; then
3699                                                         $cf_compress -f \$TMP
3700                                                         mv \$TMP.$cf_so_strip \$TMP
3701                                                 fi
3702 CF_EOF
3703 fi
3704 cat >>$cf_edit_man <<CF_EOF
3705                                                 echo .. \$verb alias \$cf_alias\${suffix}
3706                                                 rm -f \$cf_alias\${suffix}
3707                                                 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
3708                                         fi
3709                                 done
3710                         )
3711                 )
3712         elif test \$verb = removing ; then
3713                 test -f \$cf_target && (
3714                         echo \$verb \$cf_target
3715                         rm -f \$cf_target
3716                 )
3717                 test -d \$cf_subdir\${section} &&
3718                 test -n "\$aliases" && (
3719                         cd \$cf_subdir\${section} && (
3720                                 for cf_alias in \$aliases
3721                                 do
3722                                         if test \$section = 1 ; then
3723                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3724                                         fi
3725
3726                                         echo .. \$verb alias \$cf_alias\${suffix}
3727                                         rm -f \$cf_alias\${suffix}
3728                                 done
3729                         )
3730                 )
3731         else
3732 #               echo ".hy 0"
3733                 cat \$TMP
3734         fi
3735         ;;
3736 esac
3737 done
3738
3739 if test $cf_inboth = yes ; then
3740 if test \$form != format ; then
3741         sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3742 fi
3743 fi
3744
3745 exit 0
3746 CF_EOF
3747 chmod 755 $cf_edit_man
3748
3749 ])dnl
3750 dnl ---------------------------------------------------------------------------
3751 dnl CF_MATH_LIB version: 6 updated: 2009/12/19 13:46:49
3752 dnl -----------
3753 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
3754 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
3755 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
3756 AC_DEFUN([CF_MATH_LIB],
3757 [
3758 AC_CACHE_CHECK(if -lm needed for math functions,
3759         cf_cv_need_libm,[
3760         AC_TRY_LINK([
3761         #include <stdio.h>
3762         #include <math.h>
3763         ],
3764         [double x = rand(); printf("result = %g\n", ]ifelse($2,,sin(x),$2)[)],
3765         [cf_cv_need_libm=no],
3766         [cf_cv_need_libm=yes])])
3767 if test "$cf_cv_need_libm" = yes
3768 then
3769 ifelse($1,,[
3770         LIBS="-lm $LIBS"
3771 ],[$1=-lm])
3772 fi
3773 ])
3774 dnl ---------------------------------------------------------------------------
3775 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
3776 dnl ----------------------
3777 dnl Check if the file-system supports mixed-case filenames.  If we're able to
3778 dnl create a lowercase name and see it as uppercase, it doesn't support that.
3779 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
3780 [
3781 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
3782 if test "$cross_compiling" = yes ; then
3783         case $target_alias in #(vi
3784         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
3785                 cf_cv_mixedcase=no
3786                 ;;
3787         *)
3788                 cf_cv_mixedcase=yes
3789                 ;;
3790         esac
3791 else
3792         rm -f conftest CONFTEST
3793         echo test >conftest
3794         if test -f CONFTEST ; then
3795                 cf_cv_mixedcase=no
3796         else
3797                 cf_cv_mixedcase=yes
3798         fi
3799         rm -f conftest CONFTEST
3800 fi
3801 ])
3802 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
3803 ])dnl
3804 dnl ---------------------------------------------------------------------------
3805 dnl CF_MKSTEMP version: 5 updated: 2006/12/16 12:33:30
3806 dnl ----------
3807 dnl Check for a working mkstemp.  This creates two files, checks that they are
3808 dnl successfully created and distinct (AmigaOS apparently fails on the last).
3809 AC_DEFUN([CF_MKSTEMP],[
3810 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
3811 rm -f conftest*
3812 AC_TRY_RUN([
3813 #include <sys/types.h>
3814 #include <stdlib.h>
3815 #include <stdio.h>
3816 #include <string.h>
3817 #include <sys/stat.h>
3818 int main()
3819 {
3820         char *tmpl = "conftestXXXXXX";
3821         char name[2][80];
3822         int n;
3823         int result = 0;
3824         int fd;
3825         struct stat sb;
3826
3827         umask(077);
3828         for (n = 0; n < 2; ++n) {
3829                 strcpy(name[n], tmpl);
3830                 if ((fd = mkstemp(name[n])) >= 0) {
3831                         if (!strcmp(name[n], tmpl)
3832                          || stat(name[n], &sb) != 0
3833                          || (sb.st_mode & S_IFMT) != S_IFREG
3834                          || (sb.st_mode & 077) != 0) {
3835                                 result = 1;
3836                         }
3837                         close(fd);
3838                 }
3839         }
3840         if (result == 0
3841          && !strcmp(name[0], name[1]))
3842                 result = 1;
3843         ${cf_cv_main_return:-return}(result);
3844 }
3845 ],[cf_cv_func_mkstemp=yes
3846 ],[cf_cv_func_mkstemp=no
3847 ],[AC_CHECK_FUNC(mkstemp)
3848 ])
3849 ])
3850 if test "$cf_cv_func_mkstemp" = yes ; then
3851         AC_DEFINE(HAVE_MKSTEMP)
3852 fi
3853 ])dnl
3854 dnl ---------------------------------------------------------------------------
3855 dnl CF_MSG_LOG version: 4 updated: 2007/07/29 09:55:12
3856 dnl ----------
3857 dnl Write a debug message to config.log, along with the line number in the
3858 dnl configure script.
3859 AC_DEFUN([CF_MSG_LOG],[
3860 echo "${as_me-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
3861 ])dnl
3862 dnl ---------------------------------------------------------------------------
3863 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
3864 dnl ----------------
3865 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
3866 dnl warn about this.
3867 AC_DEFUN([CF_NCURSES_ABI_6],[
3868 if test "${with_abi_version+set}" != set; then
3869         case $cf_cv_rel_version in
3870         5.*)
3871                 cf_cv_rel_version=6.0
3872                 cf_cv_abi_version=6
3873                 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
3874                 ;;
3875         esac
3876 fi
3877 ])dnl
3878 dnl ---------------------------------------------------------------------------
3879 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
3880 dnl ------------------
3881 dnl see CF_WITH_NO_LEAKS
3882 AC_DEFUN([CF_NO_LEAKS_OPTION],[
3883 AC_MSG_CHECKING(if you want to use $1 for testing)
3884 AC_ARG_WITH($1,
3885         [$2],
3886         [AC_DEFINE($3)ifelse([$4],,[
3887          $4
3888 ])
3889         : ${with_cflags:=-g}
3890         : ${with_no_leaks:=yes}
3891          with_$1=yes],
3892         [with_$1=])
3893 AC_MSG_RESULT(${with_$1:-no})
3894
3895 case .$with_cflags in #(vi
3896 .*-g*)
3897         case .$CFLAGS in #(vi
3898         .*-g*) #(vi
3899                 ;;
3900         *)
3901                 CF_ADD_CFLAGS([-g])
3902                 ;;
3903         esac
3904         ;;
3905 esac
3906 ])dnl
3907 dnl ---------------------------------------------------------------------------
3908 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
3909 dnl ----------------
3910 dnl Check if the given variable is a number.  If not, report an error.
3911 dnl $1 is the variable
3912 dnl $2 is the message
3913 AC_DEFUN([CF_NUMBER_SYNTAX],[
3914 if test -n "$1" ; then
3915   case $1 in #(vi
3916   [[0-9]]*) #(vi
3917         ;;
3918   *)
3919         AC_MSG_ERROR($2 is not a number: $1)
3920         ;;
3921   esac
3922 else
3923   AC_MSG_ERROR($2 value is empty)
3924 fi
3925 ])dnl
3926 dnl ---------------------------------------------------------------------------
3927 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
3928 dnl -------------
3929 dnl Compute the object-directory name from the given model name
3930 AC_DEFUN([CF_OBJ_SUBDIR],
3931 [
3932         case $1 in
3933         libtool) $2='obj_lo'  ;;
3934         normal)  $2='objects' ;;
3935         debug)   $2='obj_g' ;;
3936         profile) $2='obj_p' ;;
3937         shared)
3938                 case $cf_cv_system_name in #(vi
3939                 cygwin) #(vi
3940                         $2='objects' ;;
3941                 *)
3942                         $2='obj_s' ;;
3943                 esac
3944         esac
3945 ])dnl
3946 dnl ---------------------------------------------------------------------------
3947 dnl CF_PATHSEP version: 4 updated: 2009/01/11 20:30:23
3948 dnl ----------
3949 dnl Provide a value for the $PATH and similar separator
3950 AC_DEFUN([CF_PATHSEP],
3951 [
3952         case $cf_cv_system_name in
3953         os2*)   PATH_SEPARATOR=';'  ;;
3954         *)      PATH_SEPARATOR=':'  ;;
3955         esac
3956 ifelse($1,,,[$1=$PATH_SEPARATOR])
3957         AC_SUBST(PATH_SEPARATOR)
3958 ])dnl
3959 dnl ---------------------------------------------------------------------------
3960 dnl CF_PATH_SYNTAX version: 12 updated: 2008/03/23 14:45:59
3961 dnl --------------
3962 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
3963 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3964 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
3965 dnl delayed evaluation of those symbols.
3966 AC_DEFUN([CF_PATH_SYNTAX],[
3967 if test "x$prefix" != xNONE; then
3968   cf_path_syntax="$prefix"
3969 else
3970   cf_path_syntax="$ac_default_prefix"
3971 fi
3972
3973 case ".[$]$1" in #(vi
3974 .\[$]\(*\)*|.\'*\'*) #(vi
3975   ;;
3976 ..|./*|.\\*) #(vi
3977   ;;
3978 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
3979   ;;
3980 .\[$]{*prefix}*) #(vi
3981   eval $1="[$]$1"
3982   case ".[$]$1" in #(vi
3983   .NONE/*)
3984     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3985     ;;
3986   esac
3987   ;; #(vi
3988 .no|.NONE/*)
3989   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3990   ;;
3991 *)
3992   ifelse($2,,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3993   ;;
3994 esac
3995 ])dnl
3996 dnl ---------------------------------------------------------------------------
3997 dnl CF_PKG_CONFIG version: 3 updated: 2009/01/25 10:55:09
3998 dnl -------------
3999 dnl Check for the package-config program, unless disabled by command-line.
4000 AC_DEFUN([CF_PKG_CONFIG],
4001 [
4002 AC_MSG_CHECKING(if you want to use pkg-config)
4003 AC_ARG_WITH(pkg-config,
4004         [  --with-pkg-config{=path} enable/disable use of pkg-config],
4005         [cf_pkg_config=$withval],
4006         [cf_pkg_config=yes])
4007 AC_MSG_RESULT($cf_pkg_config)
4008
4009 case $cf_pkg_config in #(vi
4010 no) #(vi
4011         PKG_CONFIG=none
4012         ;;
4013 yes) #(vi
4014         AC_PATH_PROG(PKG_CONFIG, pkg-config, none)
4015         ;;
4016 *)
4017         PKG_CONFIG=$withval
4018         ;;
4019 esac
4020
4021 test -z "$PKG_CONFIG" && PKG_CONFIG=none
4022 if test "$PKG_CONFIG" != none ; then
4023         CF_PATH_SYNTAX(PKG_CONFIG)
4024 fi
4025
4026 AC_SUBST(PKG_CONFIG)
4027 ])dnl
4028 dnl ---------------------------------------------------------------------------
4029 dnl CF_POSIX_C_SOURCE version: 7 updated: 2010/01/09 11:05:50
4030 dnl -----------------
4031 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
4032 dnl
4033 dnl     POSIX.1-1990                            _POSIX_SOURCE
4034 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
4035 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
4036 dnl             Bindings Option
4037 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
4038 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
4039 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
4040 dnl
4041 dnl Parameters:
4042 dnl     $1 is the nominal value for _POSIX_C_SOURCE
4043 AC_DEFUN([CF_POSIX_C_SOURCE],
4044 [
4045 cf_POSIX_C_SOURCE=ifelse($1,,199506L,$1)
4046
4047 cf_save_CFLAGS="$CFLAGS"
4048 cf_save_CPPFLAGS="$CPPFLAGS"
4049
4050 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
4051 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
4052
4053 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
4054         CF_MSG_LOG(if the symbol is already defined go no further)
4055         AC_TRY_COMPILE([#include <sys/types.h>],[
4056 #ifndef _POSIX_C_SOURCE
4057 make an error
4058 #endif],
4059         [cf_cv_posix_c_source=no],
4060         [cf_want_posix_source=no
4061          case .$cf_POSIX_C_SOURCE in #(vi
4062          .[[12]]??*) #(vi
4063                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
4064                 ;;
4065          .2) #(vi
4066                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
4067                 cf_want_posix_source=yes
4068                 ;;
4069          .*)
4070                 cf_want_posix_source=yes
4071                 ;;
4072          esac
4073          if test "$cf_want_posix_source" = yes ; then
4074                 AC_TRY_COMPILE([#include <sys/types.h>],[
4075 #ifdef _POSIX_SOURCE
4076 make an error
4077 #endif],[],
4078                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
4079          fi
4080          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
4081          CFLAGS="$cf_trim_CFLAGS"
4082          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
4083          CF_MSG_LOG(if the second compile does not leave our definition intact error)
4084          AC_TRY_COMPILE([#include <sys/types.h>],[
4085 #ifndef _POSIX_C_SOURCE
4086 make an error
4087 #endif],,
4088          [cf_cv_posix_c_source=no])
4089          CFLAGS="$cf_save_CFLAGS"
4090          CPPFLAGS="$cf_save_CPPFLAGS"
4091         ])
4092 ])
4093
4094 if test "$cf_cv_posix_c_source" != no ; then
4095         CFLAGS="$cf_trim_CFLAGS"
4096         CPPFLAGS="$cf_trim_CPPFLAGS"
4097         CF_ADD_CFLAGS($cf_cv_posix_c_source)
4098 fi
4099
4100 ])dnl
4101 dnl ---------------------------------------------------------------------------
4102 dnl CF_PREDEFINE version: 1 updated: 2003/07/26 17:53:56
4103 dnl ------------
4104 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
4105 dnl
4106 dnl $1 = symbol to test
4107 dnl $2 = value (if any) to use for a predefinition
4108 AC_DEFUN([CF_PREDEFINE],
4109 [
4110 AC_MSG_CHECKING(if we must define $1)
4111 AC_TRY_COMPILE([#include <sys/types.h>
4112 ],[
4113 #ifndef $1
4114 make an error
4115 #endif],[cf_result=no],[cf_result=yes])
4116 AC_MSG_RESULT($cf_result)
4117
4118 if test "$cf_result" = yes ; then
4119         CPPFLAGS="$CPPFLAGS ifelse($2,,-D$1,[-D$1=$2])"
4120 elif test "x$2" != "x" ; then
4121         AC_MSG_CHECKING(checking for compatible value versus $2)
4122         AC_TRY_COMPILE([#include <sys/types.h>
4123 ],[
4124 #if $1-$2 < 0
4125 make an error
4126 #endif],[cf_result=yes],[cf_result=no])
4127         AC_MSG_RESULT($cf_result)
4128         if test "$cf_result" = no ; then
4129                 # perhaps we can override it - try...
4130                 CPPFLAGS="$CPPFLAGS -D$1=$2"
4131         fi
4132 fi
4133 ])dnl
4134 dnl ---------------------------------------------------------------------------
4135 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
4136 dnl ------------
4137 dnl Append definitions and rules for the given programs to the subdirectory
4138 dnl Makefiles, and the recursion rule for the top-level Makefile.
4139 dnl
4140 dnl parameters
4141 dnl     $1 = script to run
4142 dnl     $2 = list of subdirectories
4143 dnl
4144 dnl variables
4145 dnl     $AWK
4146 AC_DEFUN([CF_PRG_RULES],
4147 [
4148 for cf_dir in $2
4149 do
4150         if test ! -d $srcdir/$cf_dir; then
4151                 continue
4152         elif test -f $srcdir/$cf_dir/programs; then
4153                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
4154         fi
4155 done
4156
4157 ])dnl
4158 dnl ---------------------------------------------------------------------------
4159 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
4160 dnl ----------
4161 dnl Check for archiver "ar".
4162 AC_DEFUN([CF_PROG_AR],[
4163 AC_CHECK_TOOL(AR, ar, ar)
4164 ])
4165 dnl ---------------------------------------------------------------------------
4166 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
4167 dnl -----------
4168 dnl Check for awk, ensure that the check found something.
4169 AC_DEFUN([CF_PROG_AWK],
4170 [
4171 AC_PROG_AWK
4172 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
4173 ])dnl
4174 dnl ---------------------------------------------------------------------------
4175 dnl CF_PROG_CC_C_O version: 2 updated: 2006/12/16 15:55:46
4176 dnl --------------
4177 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
4178 dnl the output file can be renamed, and allows for a shell variable that can
4179 dnl be used later.  The parameter is either CC or CXX.  The result is the
4180 dnl cache variable:
4181 dnl     $cf_cv_prog_CC_c_o
4182 dnl     $cf_cv_prog_CXX_c_o
4183 AC_DEFUN([CF_PROG_CC_C_O],
4184 [AC_REQUIRE([AC_PROG_CC])dnl
4185 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
4186 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
4187 [
4188 cat > conftest.$ac_ext <<CF_EOF
4189 #include <stdio.h>
4190 int main()
4191 {
4192         ${cf_cv_main_return:-return}(0);
4193 }
4194 CF_EOF
4195 # We do the test twice because some compilers refuse to overwrite an
4196 # existing .o file with -o, though they will create one.
4197 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
4198 if AC_TRY_EVAL(ac_try) &&
4199   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
4200 then
4201   eval cf_cv_prog_$1_c_o=yes
4202 else
4203   eval cf_cv_prog_$1_c_o=no
4204 fi
4205 rm -f conftest*
4206 ])dnl
4207 if test $cf_cv_prog_$1_c_o = yes; then
4208   AC_MSG_RESULT([yes])
4209 else
4210   AC_MSG_RESULT([no])
4211 fi
4212 ])dnl
4213 dnl ---------------------------------------------------------------------------
4214 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
4215 dnl --------------
4216 dnl Check if C (preprocessor) -U and -D options are processed in the order
4217 dnl given rather than by type of option.  Some compilers insist on apply all
4218 dnl of the -U options after all of the -D options.  Others allow mixing them,
4219 dnl and may predefine symbols that conflict with those we define.
4220 AC_DEFUN([CF_PROG_CC_U_D],
4221 [
4222 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
4223         cf_save_CPPFLAGS="$CPPFLAGS"
4224         CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
4225         AC_TRY_COMPILE([],[
4226 #ifndef U_D_OPTIONS
4227 make an undefined-error
4228 #endif
4229 #ifdef  D_U_OPTIONS
4230 make a defined-error
4231 #endif
4232         ],[
4233         cf_cv_cc_u_d_options=yes],[
4234         cf_cv_cc_u_d_options=no])
4235         CPPFLAGS="$cf_save_CPPFLAGS"
4236 ])
4237 ])dnl
4238 dnl ---------------------------------------------------------------------------
4239 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
4240 dnl -------------
4241 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
4242 dnl This macro adds a check to ensure the script found something.
4243 AC_DEFUN([CF_PROG_EGREP],
4244 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
4245    [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4246     then ac_cv_prog_egrep='grep -E'
4247     else ac_cv_prog_egrep='egrep'
4248     fi])
4249  EGREP=$ac_cv_prog_egrep
4250  AC_SUBST([EGREP])
4251 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
4252 ])dnl
4253 dnl ---------------------------------------------------------------------------
4254 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
4255 dnl -----------
4256 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
4257 AC_DEFUN([CF_PROG_EXT],
4258 [
4259 AC_REQUIRE([CF_CHECK_CACHE])
4260 case $cf_cv_system_name in
4261 os2*)
4262     CFLAGS="$CFLAGS -Zmt"
4263     CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
4264     CXXFLAGS="$CXXFLAGS -Zmt"
4265     # autoconf's macro sets -Zexe and suffix both, which conflict:w
4266     LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
4267     ac_cv_exeext=.exe
4268     ;;
4269 esac
4270
4271 AC_EXEEXT
4272 AC_OBJEXT
4273
4274 PROG_EXT="$EXEEXT"
4275 AC_SUBST(PROG_EXT)
4276 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
4277 ])dnl
4278 dnl ---------------------------------------------------------------------------
4279 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
4280 dnl ---------------
4281 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
4282 dnl misc/tabset install won't work properly.  Usually this happens only when
4283 dnl using the fallback mkinstalldirs script
4284 AC_DEFUN([CF_PROG_INSTALL],
4285 [AC_PROG_INSTALL
4286 case $INSTALL in
4287 /*)
4288   ;;
4289 *)
4290   CF_DIRNAME(cf_dir,$INSTALL)
4291   test -z "$cf_dir" && cf_dir=.
4292   INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
4293   ;;
4294 esac
4295 ])dnl
4296 dnl ---------------------------------------------------------------------------
4297 dnl CF_PROG_LDCONFIG version: 2 updated: 2008/12/13 14:08:40
4298 dnl ----------------
4299 dnl Check for ldconfig, needed to fixup shared libraries that would be built
4300 dnl and then used in the install.
4301 AC_DEFUN([CF_PROG_LDCONFIG],[
4302 if test "$cross_compiling" = yes ; then
4303   LDCONFIG=:
4304 else
4305 case "$cf_cv_system_name" in #(vi
4306 dragonfly*|freebsd*) #(vi
4307   test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
4308   ;;
4309 *) LDPATH=$PATH:/sbin:/usr/sbin
4310   AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
4311   ;;
4312 esac
4313 fi
4314 AC_SUBST(LDCONFIG)
4315 ])dnl
4316 dnl ---------------------------------------------------------------------------
4317 dnl CF_PROG_LINT version: 2 updated: 2009/08/12 04:43:14
4318 dnl ------------
4319 AC_DEFUN([CF_PROG_LINT],
4320 [
4321 AC_CHECK_PROGS(LINT, tdlint lint alint splint lclint)
4322 AC_SUBST(LINT_OPTS)
4323 ])dnl
4324 dnl ---------------------------------------------------------------------------
4325 dnl CF_REGEX version: 6 updated: 2010/03/27 13:41:56
4326 dnl --------
4327 dnl Attempt to determine if we've got one of the flavors of regular-expression
4328 dnl code that we can support.
4329 AC_DEFUN([CF_REGEX],
4330 [
4331
4332 cf_regex_func=no
4333
4334 AC_CHECK_FUNC(regcomp,[cf_regex_func=regcomp],[
4335         for cf_regex_lib in regex re
4336         do
4337                 AC_CHECK_LIB($cf_regex_lib,regcomp,[
4338                                 LIBS="-l$cf_regex_lib $LIBS"
4339                                 cf_regex_func=regcomp
4340                                 break])
4341         done
4342 ])
4343
4344 if test "$cf_regex_func" = no ; then
4345         AC_CHECK_FUNC(compile,[cf_regex_func=compile],[
4346                 AC_CHECK_LIB(gen,compile,[
4347                                 LIBS="-lgen $LIBS"
4348                                 cf_regex_func=compile])])
4349 fi
4350
4351 if test "$cf_regex_func" = no ; then
4352         AC_MSG_WARN(cannot find regular expression library)
4353 fi
4354
4355 AC_CACHE_CHECK(for regular-expression headers,cf_cv_regex_hdrs,[
4356
4357 cf_cv_regex_hdrs=no
4358 case $cf_regex_func in #(vi
4359 compile) #(vi
4360         for cf_regex_hdr in regexp.h regexpr.h
4361         do
4362                 AC_TRY_LINK([#include <$cf_regex_hdr>],[
4363                         char *p = compile("", "", "", 0);
4364                         int x = step("", "");
4365                 ],[
4366                         cf_cv_regex_hdrs=$cf_regex_hdr
4367                         break
4368                 ])
4369         done
4370         ;;
4371 *)
4372         for cf_regex_hdr in regex.h
4373         do
4374                 AC_TRY_LINK([#include <sys/types.h>
4375 #include <$cf_regex_hdr>],[
4376                         regex_t *p;
4377                         int x = regcomp(p, "", 0);
4378                         int y = regexec(p, "", 0, 0, 0);
4379                         regfree(p);
4380                 ],[
4381                         cf_cv_regex_hdrs=$cf_regex_hdr
4382                         break
4383                 ])
4384         done
4385         ;;
4386 esac
4387
4388 ])
4389
4390 case $cf_cv_regex_hdrs in #(vi
4391     no)        AC_MSG_WARN(no regular expression header found) ;; #(vi
4392     regex.h)   AC_DEFINE(HAVE_REGEX_H_FUNCS) ;; #(vi
4393     regexp.h)  AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;; #(vi
4394     regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;;
4395 esac
4396 ])dnl
4397 dnl ---------------------------------------------------------------------------
4398 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
4399 dnl ----------------
4400 dnl Remove all -U and -D options that refer to the given symbol from a list
4401 dnl of C compiler options.  This works around the problem that not all
4402 dnl compilers process -U and -D options from left-to-right, so a -U option
4403 dnl cannot be used to cancel the effect of a preceding -D option.
4404 dnl
4405 dnl $1 = target (which could be the same as the source variable)
4406 dnl $2 = source (including '$')
4407 dnl $3 = symbol to remove
4408 define([CF_REMOVE_DEFINE],
4409 [
4410 $1=`echo "$2" | \
4411         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
4412                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
4413 ])dnl
4414 dnl ---------------------------------------------------------------------------
4415 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
4416 dnl -------------
4417 dnl Remove the given library from the symbol
4418 dnl
4419 dnl $1 = target (which could be the same as the source variable)
4420 dnl $2 = source (including '$')
4421 dnl $3 = library to remove
4422 define([CF_REMOVE_LIB],
4423 [
4424 # remove $3 library from $2
4425 $1=`echo "$2" | sed -e 's/-l$3[[        ]]//g' -e 's/-l$3[$]//'`
4426 ])dnl
4427 dnl ---------------------------------------------------------------------------
4428 dnl CF_RPATH_HACK version: 8 updated: 2010/04/17 15:38:58
4429 dnl -------------
4430 AC_DEFUN([CF_RPATH_HACK],
4431 [
4432 AC_REQUIRE([CF_LD_RPATH_OPT])
4433 AC_MSG_CHECKING(for updated LDFLAGS)
4434 if test -n "$LD_RPATH_OPT" ; then
4435         AC_MSG_RESULT(maybe)
4436
4437         AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
4438         cf_rpath_list="/usr/lib /lib"
4439         if test "$cf_ldd_prog" != no
4440         then
4441 AC_TRY_LINK([#include <stdio.h>],
4442                 [printf("Hello");],
4443                 [cf_rpath_list=`$cf_ldd_prog conftest$ac_exeext | fgrep / | sed -e 's%^.*[[     ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort -u`])
4444         fi
4445
4446         CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
4447
4448         CF_RPATH_HACK_2(LDFLAGS)
4449         CF_RPATH_HACK_2(LIBS)
4450
4451         CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
4452 fi
4453 AC_SUBST(EXTRA_LDFLAGS)
4454 ])dnl
4455 dnl ---------------------------------------------------------------------------
4456 dnl CF_RPATH_HACK_2 version: 6 updated: 2010/04/17 16:31:24
4457 dnl ---------------
4458 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
4459 dnl EXTRA_LDFLAGS for each -L option found.
4460 dnl
4461 dnl $cf_rpath_list contains a list of directories to ignore.
4462 dnl
4463 dnl $1 = variable name to update.  The LDFLAGS variable should be the only one,
4464 dnl      but LIBS often has misplaced -L options.
4465 AC_DEFUN([CF_RPATH_HACK_2],
4466 [
4467 CF_VERBOSE(...checking $1 [$]$1)
4468
4469 cf_rpath_dst=
4470 for cf_rpath_src in [$]$1
4471 do
4472         case $cf_rpath_src in #(vi
4473         -L*) #(vi
4474
4475                 # check if this refers to a directory which we will ignore
4476                 cf_rpath_skip=no
4477                 if test -n "$cf_rpath_list"
4478                 then
4479                         for cf_rpath_item in $cf_rpath_list
4480                         do
4481                                 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
4482                                 then
4483                                         cf_rpath_skip=yes
4484                                         break
4485                                 fi
4486                         done
4487                 fi
4488
4489                 if test "$cf_rpath_skip" = no
4490                 then
4491                         # transform the option
4492                         if test "$LD_RPATH_OPT" = "-R " ; then
4493                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
4494                         else
4495                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
4496                         fi
4497
4498                         # if we have not already added this, add it now
4499                         cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%&qu