ncurses 5.7 - patch 20100417
[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.513 2010/04/17 20:33:27 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: 2 updated: 2007/08/11 14:09:50
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 gcc 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: 15 updated: 2010/04/03 18:35:33
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: 4 updated: 2005/08/27 09:53:42
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| 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: 24 updated: 2009/02/01 15:21:00
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="-W -Wall"
1658         cf_warn_CONST=""
1659         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1660         for cf_opt in \
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: 10 updated: 2010/01/17 20:36:17
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 cf_header_path_list=""
2145 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2146         for cf_header_path in $CPPFLAGS $CFLAGS
2147         do
2148                 case $cf_header_path in #(vi
2149                 -I*)
2150                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2151                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2152                         cf_header_path_list="$cf_header_path_list [$]$1"
2153                         ;;
2154                 esac
2155         done
2156 fi
2157
2158 CF_SUBDIR_PATH($1,$2,include)
2159
2160 test "$includedir" != NONE && \
2161 test "$includedir" != "/usr/include" && \
2162 test -d "$includedir" && {
2163         test -d $includedir &&    $1="[$]$1 $includedir"
2164         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
2165 }
2166
2167 test "$oldincludedir" != NONE && \
2168 test "$oldincludedir" != "/usr/include" && \
2169 test -d "$oldincludedir" && {
2170         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
2171         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
2172 }
2173
2174 $1="$cf_header_path_list [$]$1"
2175 ])dnl
2176 dnl ---------------------------------------------------------------------------
2177 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
2178 dnl ---------------
2179 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2180 AC_DEFUN([CF_HELP_MESSAGE],
2181 [AC_DIVERT_HELP([$1])dnl
2182 ])dnl
2183 dnl ---------------------------------------------------------------------------
2184 dnl CF_INCLUDE_DIRS version: 6 updated: 2009/01/06 19:37:40
2185 dnl ---------------
2186 dnl Construct the list of include-options according to whether we're building
2187 dnl in the source directory or using '--srcdir=DIR' option.  If we're building
2188 dnl with gcc, don't append the includedir if it happens to be /usr/include,
2189 dnl since that usually breaks gcc's shadow-includes.
2190 AC_DEFUN([CF_INCLUDE_DIRS],
2191 [
2192 CPPFLAGS="$CPPFLAGS -I. -I../include"
2193 if test "$srcdir" != "."; then
2194         CPPFLAGS="$CPPFLAGS -I\${srcdir}/../include"
2195 fi
2196 if test "$GCC" != yes; then
2197         CPPFLAGS="$CPPFLAGS -I\${includedir}"
2198 elif test "$includedir" != "/usr/include"; then
2199         if test "$includedir" = '${prefix}/include' ; then
2200                 if test $prefix != /usr ; then
2201                         CPPFLAGS="$CPPFLAGS -I\${includedir}"
2202                 fi
2203         else
2204                 CPPFLAGS="$CPPFLAGS -I\${includedir}"
2205         fi
2206 fi
2207 AC_SUBST(CPPFLAGS)
2208 ])dnl
2209 dnl ---------------------------------------------------------------------------
2210 dnl CF_INTEL_COMPILER version: 3 updated: 2005/08/06 18:37:29
2211 dnl -----------------
2212 dnl Check if the given compiler is really the Intel compiler for Linux.  It
2213 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2214 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2215 dnl
2216 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2217 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
2218 dnl the wrappers for gcc and g++ warnings.
2219 dnl
2220 dnl $1 = GCC (default) or GXX
2221 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2222 dnl $3 = CFLAGS (default) or CXXFLAGS
2223 AC_DEFUN([CF_INTEL_COMPILER],[
2224 ifelse($2,,INTEL_COMPILER,[$2])=no
2225
2226 if test "$ifelse($1,,[$1],GCC)" = yes ; then
2227         case $host_os in
2228         linux*|gnu*)
2229                 AC_MSG_CHECKING(if this is really Intel ifelse($1,GXX,C++,C) compiler)
2230                 cf_save_CFLAGS="$ifelse($3,,CFLAGS,[$3])"
2231                 ifelse($3,,CFLAGS,[$3])="$ifelse($3,,CFLAGS,[$3]) -no-gcc"
2232                 AC_TRY_COMPILE([],[
2233 #ifdef __INTEL_COMPILER
2234 #else
2235 make an error
2236 #endif
2237 ],[ifelse($2,,INTEL_COMPILER,[$2])=yes
2238 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
2239 ],[])
2240                 ifelse($3,,CFLAGS,[$3])="$cf_save_CFLAGS"
2241                 AC_MSG_RESULT($ifelse($2,,INTEL_COMPILER,[$2]))
2242                 ;;
2243         esac
2244 fi
2245 ])dnl
2246 dnl ---------------------------------------------------------------------------
2247 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
2248 dnl ----------
2249 dnl Check if we have either a function or macro for 'isascii()'.
2250 AC_DEFUN([CF_ISASCII],
2251 [
2252 AC_MSG_CHECKING(for isascii)
2253 AC_CACHE_VAL(cf_cv_have_isascii,[
2254         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
2255         [cf_cv_have_isascii=yes],
2256         [cf_cv_have_isascii=no])
2257 ])dnl
2258 AC_MSG_RESULT($cf_cv_have_isascii)
2259 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
2260 ])dnl
2261 dnl ---------------------------------------------------------------------------
2262 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
2263 dnl ------------
2264 dnl Add checks for large file support.
2265 AC_DEFUN([CF_LARGEFILE],[
2266 ifdef([AC_FUNC_FSEEKO],[
2267     AC_SYS_LARGEFILE
2268     if test "$enable_largefile" != no ; then
2269         AC_FUNC_FSEEKO
2270
2271         # Normally we would collect these definitions in the config.h,
2272         # but (like _XOPEN_SOURCE), some environments rely on having these
2273         # defined before any of the system headers are included.  Another
2274         # case comes up with C++, e.g., on AIX the compiler compiles the
2275         # header files by themselves before looking at the body files it is
2276         # told to compile.  For ncurses, those header files do not include
2277         # the config.h
2278         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
2279         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
2280         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
2281
2282         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2283                 AC_TRY_COMPILE([
2284 #include <sys/types.h>
2285 #include <dirent.h>
2286                 ],[
2287                 /* if transitional largefile support is setup, this is true */
2288                 extern struct dirent64 * readdir(DIR *);
2289                 struct dirent64 *x = readdir((DIR *)0);
2290                 struct dirent *y = readdir((DIR *)0);
2291                 int z = x - y;
2292                 ],
2293                 [cf_cv_struct_dirent64=yes],
2294                 [cf_cv_struct_dirent64=no])
2295         ])
2296         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
2297     fi
2298 ])
2299 ])
2300 dnl ---------------------------------------------------------------------------
2301 dnl CF_LDFLAGS_STATIC version: 7 updated: 2009/04/04 18:31:04
2302 dnl -----------------
2303 dnl Check for compiler/linker flags used to temporarily force usage of static
2304 dnl libraries.  This depends on the compiler and platform.  Use this to help
2305 dnl ensure that the linker picks up a given library based on its position in
2306 dnl the list of linker options and libraries.
2307 AC_DEFUN([CF_LDFLAGS_STATIC],[
2308
2309 if test "$GCC" = yes ; then
2310         case $cf_cv_system_name in #(
2311         OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*)         #( vi
2312                 LDFLAGS_STATIC=
2313                 LDFLAGS_SHARED=
2314                 ;;
2315     *)  #( normally, except when broken
2316         LDFLAGS_STATIC=-static
2317         LDFLAGS_SHARED=-dynamic
2318         ;;
2319     esac
2320 else
2321         case $cf_cv_system_name in #(
2322         aix[[456]]*)    #( from ld manpage
2323                 LDFLAGS_STATIC=-bstatic
2324                 LDFLAGS_SHARED=-bdynamic
2325                 ;;
2326         hpux*)          #( from ld manpage for hpux10.20, hpux11.11
2327                 # We could also use just "archive" and "shared".
2328                 LDFLAGS_STATIC=-Wl,-a,archive_shared
2329                 LDFLAGS_SHARED=-Wl,-a,shared_archive
2330                 ;;
2331         irix*)          #( from ld manpage IRIX64
2332                 LDFLAGS_STATIC=-Bstatic
2333                 LDFLAGS_SHARED=-Bdynamic
2334                 ;;
2335         osf[[45]]*)     #( from ld manpage osf4.0d, osf5.1
2336                 # alternative "-oldstyle_liblookup" (not in cc manpage)
2337                 LDFLAGS_STATIC=-noso
2338                 LDFLAGS_SHARED=-so_archive
2339                 ;;
2340         solaris2*)
2341                 LDFLAGS_STATIC=-Bstatic
2342                 LDFLAGS_SHARED=-Bdynamic
2343                 ;;
2344         esac
2345 fi
2346
2347 AC_SUBST(LDFLAGS_STATIC)
2348 AC_SUBST(LDFLAGS_SHARED)
2349 ])
2350 dnl ---------------------------------------------------------------------------
2351 dnl CF_LD_RPATH_OPT version: 2 updated: 2010/03/27 19:27:54
2352 dnl ---------------
2353 dnl For the given system and compiler, find the compiler flags to pass to the
2354 dnl loader to use the "rpath" feature.
2355 AC_DEFUN([CF_LD_RPATH_OPT],
2356 [
2357 AC_REQUIRE([CF_CHECK_CACHE])
2358
2359 LD_RPATH_OPT=
2360 AC_MSG_CHECKING(for an rpath option)
2361 case $cf_cv_system_name in #(vi
2362 irix*) #(vi
2363         if test "$GCC" = yes; then
2364                 LD_RPATH_OPT="-Wl,-rpath,"
2365         else
2366                 LD_RPATH_OPT="-rpath "
2367         fi
2368         ;;
2369 linux*|gnu*|k*bsd*-gnu) #(vi
2370         LD_RPATH_OPT="-Wl,-rpath,"
2371         ;;
2372 openbsd[[2-9]].*) #(vi
2373         LD_RPATH_OPT="-Wl,-rpath,"
2374         ;;
2375 freebsd*) #(vi
2376         LD_RPATH_OPT="-rpath "
2377         ;;
2378 netbsd*) #(vi
2379         LD_RPATH_OPT="-Wl,-rpath,"
2380         ;;
2381 osf*|mls+*) #(vi
2382         LD_RPATH_OPT="-rpath "
2383         ;;
2384 solaris2*) #(vi
2385         LD_RPATH_OPT="-R"
2386         ;;
2387 *)
2388         ;;
2389 esac
2390 AC_MSG_RESULT($LD_RPATH_OPT)
2391
2392 case "x$LD_RPATH_OPT" in #(vi
2393 x-R*)
2394         AC_MSG_CHECKING(if we need a space after rpath option)
2395         cf_save_LIBS="$LIBS"
2396         LIBS="${LD_RPATH_OPT}$libdir $LIBS"
2397         AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2398         LIBS="$cf_save_LIBS"
2399         AC_MSG_RESULT($cf_rpath_space)
2400         test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2401         ;;
2402 esac
2403 ])dnl
2404 dnl ---------------------------------------------------------------------------
2405 dnl CF_LIBRARY_PATH version: 9 updated: 2010/03/28 12:52:50
2406 dnl ---------------
2407 dnl Construct a search-list of directories for a nonstandard library-file
2408 dnl
2409 dnl Parameters
2410 dnl     $1 = the variable to return as result
2411 dnl     $2 = the package name
2412 AC_DEFUN([CF_LIBRARY_PATH],
2413 [
2414 $1=
2415 cf_library_path_list=""
2416 if test -n "${LDFLAGS}${LIBS}" ; then
2417         for cf_library_path in $LDFLAGS $LIBS
2418         do
2419                 case $cf_library_path in #(vi
2420                 -L*)
2421                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2422                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2423                         cf_library_path_list="$cf_library_path_list [$]$1"
2424                         ;;
2425                 esac
2426         done
2427 fi
2428
2429 CF_SUBDIR_PATH($1,$2,lib)
2430
2431 $1="$cf_library_path_list [$]$1"
2432 ])dnl
2433 dnl ---------------------------------------------------------------------------
2434 dnl CF_LIB_PREFIX version: 8 updated: 2008/09/13 11:34:16
2435 dnl -------------
2436 dnl Compute the library-prefix for the given host system
2437 dnl $1 = variable to set
2438 AC_DEFUN([CF_LIB_PREFIX],
2439 [
2440         case $cf_cv_system_name in #(vi
2441         OS/2*|os2*) #(vi
2442         LIB_PREFIX=''
2443         ;;
2444         *)      LIB_PREFIX='lib'
2445         ;;
2446         esac
2447 ifelse($1,,,[$1=$LIB_PREFIX])
2448         AC_SUBST(LIB_PREFIX)
2449 ])dnl
2450 dnl ---------------------------------------------------------------------------
2451 dnl CF_LIB_RULES version: 55 updated: 2008/12/13 16:17:38
2452 dnl ------------
2453 dnl Append definitions and rules for the given models to the subdirectory
2454 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
2455 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
2456 dnl the corresponding makefile to list the models that we'll generate.
2457 dnl
2458 dnl For shared libraries, make a list of symbolic links to construct when
2459 dnl generating each library.  The convention used for Linux is the simplest
2460 dnl one:
2461 dnl     lib<name>.so    ->
2462 dnl     lib<name>.so.<major>    ->
2463 dnl     lib<name>.so.<maj>.<minor>
2464 AC_DEFUN([CF_LIB_RULES],
2465 [
2466 CF_LIB_PREFIX(cf_prefix)
2467 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2468
2469 if test $cf_cv_shlib_version = cygdll ; then
2470         TINFO_NAME=$TINFO_ARG_SUFFIX
2471         TINFO_SUFFIX=.dll
2472 fi
2473
2474 for cf_dir in $SRC_SUBDIRS
2475 do
2476         if test ! -d $srcdir/$cf_dir ; then
2477                 continue
2478         elif test -f $srcdir/$cf_dir/modules; then
2479
2480                 SHARED_LIB=
2481                 LIBS_TO_MAKE=
2482                 for cf_item in $cf_LIST_MODELS
2483                 do
2484                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2485                         if test $cf_item = shared ; then
2486                         if test "$cf_cv_do_symlinks" = yes ; then
2487                                 case "$cf_cv_shlib_version" in #(vi
2488                                 rel) #(vi
2489                                         case "$cf_cv_system_name" in #(vi
2490                                         darwin*)
2491                                         case .${LIB_SUFFIX} in
2492                                         .w*)
2493                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2494                                                 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
2495                                                 ;;
2496                                         *)
2497                                                 cf_suffix='.${REL_VERSION}'"$cf_suffix"
2498                                                 ;;
2499                                         esac
2500                                         ;; #(vi
2501                                         *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
2502                                         esac
2503                                         ;;
2504                                 abi)
2505                                         case "$cf_cv_system_name" in #(vi
2506                                         darwin*)
2507                                         case .${LIB_SUFFIX} in
2508                                         .w*)
2509                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2510                                                 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
2511                                                 ;;
2512                                         *)
2513                                                 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
2514                                                 ;;
2515                                         esac
2516                                         ;; #(vi
2517                                         *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
2518                                         esac
2519                                         ;;
2520                                 esac
2521                         fi
2522                         # cygwin needs import library, and has unique naming convention
2523                         # use autodetected ${cf_prefix} for import lib and static lib, but
2524                         # use 'cyg' prefix for shared lib.
2525                         if test $cf_cv_shlib_version = cygdll ; then
2526                                 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
2527                                 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}${cf_cygsuf}"
2528                                 continue
2529                         fi
2530                         fi
2531                         LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
2532                 done
2533
2534                 if test $cf_dir = ncurses ; then
2535                         cf_subsets="$LIB_SUBSETS"
2536                         cf_r_parts="$cf_subsets"
2537                         cf_liblist="$LIBS_TO_MAKE"
2538
2539                         while test -n "$cf_r_parts"
2540                         do
2541                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
2542                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
2543                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
2544                                         cf_item=
2545                                         case $cf_l_parts in #(vi
2546                                         *termlib*) #(vi
2547                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
2548                                                 ;;
2549                                         *ticlib*)
2550                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
2551                                                 ;;
2552                                         *)
2553                                                 break
2554                                                 ;;
2555                                         esac
2556                                         if test -n "$cf_item"; then
2557                                                 LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
2558                                         fi
2559                                 else
2560                                         break
2561                                 fi
2562                         done
2563                 else
2564                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
2565                 fi
2566
2567                 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
2568                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
2569                         $cf_dir/Makefile >$cf_dir/Makefile.out
2570                 mv $cf_dir/Makefile.out $cf_dir/Makefile
2571
2572                 $AWK -f $srcdir/mk-0th.awk \
2573                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
2574                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2575
2576                 for cf_subset in $cf_subsets
2577                 do
2578                         cf_subdirs=
2579                         for cf_item in $cf_LIST_MODELS
2580                         do
2581                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
2582                         CF_UPPER(cf_ITEM,$cf_item)
2583                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2584                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
2585
2586                         # Test for case where we build libtinfo with a different name.
2587                         cf_libname=$cf_dir
2588                         if test $cf_dir = ncurses ; then
2589                                 case $cf_subset in
2590                                 *base*)
2591                                         cf_libname=${cf_libname}$LIB_SUFFIX
2592                                         ;;
2593                                 *termlib*)
2594                                         cf_libname=$TINFO_LIB_SUFFIX
2595                                         ;;
2596                                 ticlib*)
2597                                         cf_libname=$TICS_LIB_SUFFIX
2598                                         ;;
2599                                 esac
2600                         else
2601                                 cf_libname=${cf_libname}$LIB_SUFFIX
2602                         fi
2603                         if test -n "${DFT_ARG_SUFFIX}" ; then
2604                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2605                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2606                         fi
2607
2608                         # These dependencies really are for development, not
2609                         # builds, but they are useful in porting, too.
2610                         cf_depend="../include/ncurses_cfg.h"
2611                         if test "$srcdir" = "."; then
2612                                 cf_reldir="."
2613                         else
2614                                 cf_reldir="\${srcdir}"
2615                         fi
2616
2617                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
2618                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
2619                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
2620                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
2621                         fi
2622
2623                         cf_dir_suffix=
2624                         old_cf_suffix="$cf_suffix"
2625                         if test "$cf_cv_shlib_version_infix" = yes ; then
2626                         if test -n "$LIB_SUFFIX" ; then
2627                                 case $LIB_SUFFIX in
2628                                 w*)
2629                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
2630                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2631                                         cf_dir_suffix=w
2632                                         ;;
2633                                 esac
2634                         fi
2635                         fi
2636
2637                         $AWK -f $srcdir/mk-1st.awk \
2638                                 name=${cf_libname}${cf_dir_suffix} \
2639                                 traces=$LIB_TRACING \
2640                                 MODEL=$cf_ITEM \
2641                                 model=$cf_subdir \
2642                                 prefix=$cf_prefix \
2643                                 suffix=$cf_suffix \
2644                                 subset=$cf_subset \
2645                                 TermlibRoot=$TINFO_NAME \
2646                                 TermlibSuffix=$TINFO_SUFFIX \
2647                                 ShlibVer=$cf_cv_shlib_version \
2648                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
2649                                 ReLink=${cf_cv_do_relink-no} \
2650                                 DoLinks=$cf_cv_do_symlinks \
2651                                 rmSoLocs=$cf_cv_rm_so_locs \
2652                                 ldconfig="$LDCONFIG" \
2653                                 overwrite=$WITH_OVERWRITE \
2654                                 depend="$cf_depend" \
2655                                 host="$host" \
2656                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2657
2658                         cf_suffix="$old_cf_suffix"
2659
2660                         for cf_subdir2 in $cf_subdirs lib
2661                         do
2662                                 test $cf_subdir = $cf_subdir2 && break
2663                         done
2664                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
2665                         $AWK -f $srcdir/mk-2nd.awk \
2666                                 name=$cf_dir \
2667                                 traces=$LIB_TRACING \
2668                                 MODEL=$cf_ITEM \
2669                                 model=$cf_subdir \
2670                                 subset=$cf_subset \
2671                                 srcdir=$srcdir \
2672                                 echo=$WITH_ECHO \
2673                                 crenames=$cf_cv_prog_CC_c_o \
2674                                 cxxrenames=$cf_cv_prog_CXX_c_o \
2675                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2676                         cf_subdirs="$cf_subdirs $cf_subdir"
2677                         done
2678                 done
2679         fi
2680
2681         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
2682 done
2683
2684 for cf_dir in $SRC_SUBDIRS
2685 do
2686         if test ! -d $srcdir/$cf_dir ; then
2687                 continue
2688         fi
2689
2690         if test -f $cf_dir/Makefile ; then
2691                 case "$cf_dir" in
2692                 Ada95) #(vi
2693                         echo 'libs \' >> Makefile
2694                         echo 'install.libs \' >> Makefile
2695                         echo 'uninstall.libs ::' >> Makefile
2696                         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
2697                         ;;
2698                 esac
2699         fi
2700
2701         if test -f $srcdir/$cf_dir/modules; then
2702                 echo >> Makefile
2703                 if test -f $srcdir/$cf_dir/headers; then
2704 cat >> Makefile <<CF_EOF
2705 install.includes \\
2706 uninstall.includes \\
2707 CF_EOF
2708                 fi
2709 if test "$cf_dir" != "c++" ; then
2710 echo 'lint \' >> Makefile
2711 fi
2712 cat >> Makefile <<CF_EOF
2713 libs \\
2714 lintlib \\
2715 install.libs \\
2716 uninstall.libs \\
2717 install.$cf_dir \\
2718 uninstall.$cf_dir ::
2719         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2720 CF_EOF
2721         elif test -f $srcdir/$cf_dir/headers; then
2722 cat >> Makefile <<CF_EOF
2723
2724 libs \\
2725 install.libs \\
2726 uninstall.libs \\
2727 install.includes \\
2728 uninstall.includes ::
2729         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2730 CF_EOF
2731 fi
2732 done
2733
2734 cat >> Makefile <<CF_EOF
2735
2736 install.libs uninstall.libs \\
2737 install.data uninstall.data ::
2738 $MAKE_TERMINFO  cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
2739 CF_EOF
2740
2741 if test "x$cf_with_manpages" = xyes; then
2742 cat >> Makefile <<CF_EOF
2743
2744 install.man \\
2745 uninstall.man ::
2746         cd man && \${MAKE} \${CF_MFLAGS} \[$]@
2747 CF_EOF
2748 fi
2749
2750 cat >> Makefile <<CF_EOF
2751
2752 distclean ::
2753         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
2754         rm -f headers.sh headers.sed mk_shared_lib.sh
2755         rm -f edit_man.* man_alias.*
2756         rm -rf \${DIRS_TO_MAKE}
2757 CF_EOF
2758
2759 # Special case: tack's manpage lives in its own directory.
2760 if test "x$cf_with_manpages" = xyes; then
2761 if test -d tack ; then
2762 if test -f $srcdir/$tack.h; then
2763 cat >> Makefile <<CF_EOF
2764
2765 install.man \\
2766 uninstall.man ::
2767         cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
2768 CF_EOF
2769 fi
2770 fi
2771 fi
2772
2773 dnl If we're installing into a subdirectory of /usr/include, etc., we should
2774 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
2775 dnl anything, and will make it more standardized.  It's awkward to decide this
2776 dnl at configuration because of quoting, so we'll simply make all headers
2777 dnl installed via a script that can do the right thing.
2778
2779 rm -f headers.sed headers.sh
2780
2781 dnl ( generating this script makes the makefiles a little tidier :-)
2782 echo creating headers.sh
2783 cat >headers.sh <<CF_EOF
2784 #! /bin/sh
2785 # This shell script is generated by the 'configure' script.  It is invoked in a
2786 # subdirectory of the build tree.  It generates a sed-script in the parent
2787 # directory that is used to adjust includes for header files that reside in a
2788 # subdirectory of /usr/include, etc.
2789 PRG=""
2790 while test \[$]# != 3
2791 do
2792 PRG="\$PRG \[$]1"; shift
2793 done
2794 DST=\[$]1
2795 REF=\[$]2
2796 SRC=\[$]3
2797 TMPSRC=\${TMPDIR-/tmp}/\`basename \$SRC\`\$\$
2798 TMPSED=\${TMPDIR-/tmp}/headers.sed\$\$
2799 echo installing \$SRC in \$DST
2800 CF_EOF
2801
2802 if test $WITH_CURSES_H = yes; then
2803         cat >>headers.sh <<CF_EOF
2804 case \$DST in
2805 /*/include/*)
2806         END=\`basename \$DST\`
2807         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2808         do
2809                 NAME=\`basename \$i\`
2810                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2811         done
2812         ;;
2813 *)
2814         echo "" >> \$TMPSED
2815         ;;
2816 esac
2817 CF_EOF
2818
2819 else
2820         cat >>headers.sh <<CF_EOF
2821 case \$DST in
2822 /*/include/*)
2823         END=\`basename \$DST\`
2824         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2825         do
2826                 NAME=\`basename \$i\`
2827                 if test "\$NAME" = "curses.h"
2828                 then
2829                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2830                         NAME=ncurses.h
2831                 fi
2832                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2833         done
2834         ;;
2835 *)
2836         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2837         ;;
2838 esac
2839 CF_EOF
2840 fi
2841 cat >>headers.sh <<CF_EOF
2842 rm -f \$TMPSRC
2843 sed -f \$TMPSED \$SRC > \$TMPSRC
2844 NAME=\`basename \$SRC\`
2845 CF_EOF
2846 if test $WITH_CURSES_H != yes; then
2847         cat >>headers.sh <<CF_EOF
2848 test "\$NAME" = "curses.h" && NAME=ncurses.h
2849 CF_EOF
2850 fi
2851 cat >>headers.sh <<CF_EOF
2852 # Just in case someone gzip'd manpages, remove the conflicting copy.
2853 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
2854
2855 eval \$PRG \$TMPSRC \$DST/\$NAME
2856 rm -f \$TMPSRC \$TMPSED
2857 CF_EOF
2858
2859 chmod 0755 headers.sh
2860
2861 for cf_dir in $SRC_SUBDIRS
2862 do
2863         if test ! -d $srcdir/$cf_dir ; then
2864                 continue
2865         fi
2866
2867         if test -f $srcdir/$cf_dir/headers; then
2868                 $AWK -f $srcdir/mk-hdr.awk \
2869                         subset="$LIB_SUBSETS" \
2870                         compat="$WITH_CURSES_H" \
2871                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
2872         fi
2873
2874         if test -f $srcdir/$cf_dir/modules; then
2875                 if test "$cf_dir" != "c++" ; then
2876                         cat >>$cf_dir/Makefile <<"CF_EOF"
2877 depend : ${AUTO_SRC}
2878         makedepend -- ${CPPFLAGS} -- ${C_SRC}
2879
2880 # DO NOT DELETE THIS LINE -- make depend depends on it.
2881 CF_EOF
2882                 fi
2883         fi
2884 done
2885
2886 ])dnl
2887 dnl ---------------------------------------------------------------------------
2888 dnl CF_LIB_SONAME version: 3 updated: 2006/12/16 15:55:46
2889 dnl -------------
2890 dnl Find the and soname for the given shared library.  Set the cache variable
2891 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
2892 dnl variable to "unknown".
2893 dnl
2894 dnl $1 = headers
2895 dnl $2 = code
2896 dnl $3 = library name
2897 AC_DEFUN([CF_LIB_SONAME],
2898 [
2899 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
2900
2901 cf_cv_$3_soname=unknown
2902 if test "$cross_compiling" != yes ; then
2903 cat >conftest.$ac_ext <<CF_EOF
2904 $1
2905 int main()
2906 {
2907 $2
2908         ${cf_cv_main_return:-return}(0);
2909 }
2910 CF_EOF
2911 cf_save_LIBS="$LIBS"
2912         LIBS="-l$3 $LIBS"
2913         if AC_TRY_EVAL(ac_compile) ; then
2914                 if AC_TRY_EVAL(ac_link) ; then
2915                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
2916                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
2917                 fi
2918         fi
2919 rm -f conftest*
2920 LIBS="$cf_save_LIBS"
2921 fi
2922 ])
2923 ])
2924 dnl ---------------------------------------------------------------------------
2925 dnl CF_LIB_SUFFIX version: 16 updated: 2008/12/27 12:30:03
2926 dnl -------------
2927 dnl Compute the library file-suffix from the given model name
2928 dnl $1 = model name
2929 dnl $2 = variable to set (the nominal library suffix)
2930 dnl $3 = dependency variable to set (actual filename)
2931 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2932 AC_DEFUN([CF_LIB_SUFFIX],
2933 [
2934         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2935         case $1 in #(vi
2936         libtool) #(vi
2937                 $2='.la'
2938                 $3=[$]$2
2939                 ;;
2940         normal) #(vi
2941                 $2='.a'
2942                 $3=[$]$2
2943                 ;;
2944         debug) #(vi
2945                 $2='_g.a'
2946                 $3=[$]$2
2947                 ;;
2948         profile) #(vi
2949                 $2='_p.a'
2950                 $3=[$]$2
2951                 ;;
2952         shared) #(vi
2953                 case $cf_cv_system_name in
2954                 aix[[56]]*) #(vi
2955                         $2='.a'
2956                         $3=[$]$2
2957                         ;;
2958                 cygwin*) #(vi
2959                         $2='.dll'
2960                         $3='.dll.a'
2961                         ;;
2962                 darwin*) #(vi
2963                         $2='.dylib'
2964                         $3=[$]$2
2965                         ;;
2966                 hpux*) #(vi
2967                         case $target in
2968                         ia64*) #(vi
2969                                 $2='.so'
2970                                 $3=[$]$2
2971                                 ;;
2972                         *) #(vi
2973                                 $2='.sl'
2974                                 $3=[$]$2
2975                                 ;;
2976                         esac
2977                         ;;
2978                 *)      $2='.so'
2979                         $3=[$]$2
2980                         ;;
2981                 esac
2982         esac
2983         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2984         test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
2985 ])dnl
2986 dnl ---------------------------------------------------------------------------
2987 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
2988 dnl -----------
2989 dnl Compute the string to append to -library from the given model name
2990 dnl $1 = model name
2991 dnl $2 = variable to set
2992 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2993 AC_DEFUN([CF_LIB_TYPE],
2994 [
2995         case $1 in
2996         libtool) $2=''   ;;
2997         normal)  $2=''   ;;
2998         debug)   $2='_g' ;;
2999         profile) $2='_p' ;;
3000         shared)  $2=''   ;;
3001         esac
3002         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3003 ])dnl
3004 dnl ---------------------------------------------------------------------------
3005 dnl CF_LINK_DATAONLY version: 9 updated: 2009/01/01 20:21:38
3006 dnl ----------------
3007 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
3008 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
3009 dnl have to provide wrappers for global tables to ensure they're linked
3010 dnl properly.
3011 AC_DEFUN([CF_LINK_DATAONLY],
3012 [
3013 AC_MSG_CHECKING([if data-only library module links])
3014 AC_CACHE_VAL(cf_cv_link_dataonly,[
3015         rm -f conftest.a
3016         cat >conftest.$ac_ext <<EOF
3017 #line __oline__ "configure"
3018 int     testdata[[3]] = { 123, 456, 789 };
3019 EOF
3020         if AC_TRY_EVAL(ac_compile) ; then
3021                 mv conftest.o data.o && \
3022                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
3023         fi
3024         rm -f conftest.$ac_ext data.o
3025         cat >conftest.$ac_ext <<EOF
3026 #line __oline__ "configure"
3027 int     testfunc()
3028 {
3029 #if defined(NeXT)
3030         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
3031 #else
3032         extern int testdata[[3]];
3033         return testdata[[0]] == 123
3034            &&  testdata[[1]] == 456
3035            &&  testdata[[2]] == 789;
3036 #endif
3037 }
3038 EOF
3039         if AC_TRY_EVAL(ac_compile); then
3040                 mv conftest.o func.o && \
3041                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
3042         fi
3043         rm -f conftest.$ac_ext func.o
3044         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
3045         cf_saveLIBS="$LIBS"
3046         LIBS="conftest.a $LIBS"
3047         AC_TRY_RUN([
3048         int main()
3049         {
3050                 extern int testfunc();
3051                 ${cf_cv_main_return:-return} (!testfunc());
3052         }
3053         ],
3054         [cf_cv_link_dataonly=yes],
3055         [cf_cv_link_dataonly=no],
3056         [cf_cv_link_dataonly=unknown])
3057         LIBS="$cf_saveLIBS"
3058         ])
3059 AC_MSG_RESULT($cf_cv_link_dataonly)
3060
3061 if test "$cf_cv_link_dataonly" = no ; then
3062         AC_DEFINE(BROKEN_LINKER)
3063         BROKEN_LINKER=1
3064 fi
3065
3066 ])dnl
3067 dnl ---------------------------------------------------------------------------
3068 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
3069 dnl -------------
3070 dnl Most Unix systems have both link and symlink, a few don't have symlink.
3071 dnl A few non-Unix systems implement symlink, but not link.
3072 dnl A few non-systems implement neither (or have nonfunctional versions).
3073 AC_DEFUN([CF_LINK_FUNCS],
3074 [
3075 AC_CHECK_FUNCS( \
3076         remove \
3077         unlink )
3078
3079 if test "$cross_compiling" = yes ; then
3080         AC_CHECK_FUNCS( \
3081                 link \
3082                 symlink )
3083 else
3084         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
3085                 cf_cv_link_funcs=
3086                 for cf_func in link symlink ; do
3087                         AC_TRY_RUN([
3088 #include <sys/types.h>
3089 #include <sys/stat.h>
3090 #ifdef HAVE_UNISTD_H
3091 #include <unistd.h>
3092 #endif
3093 int main()
3094 {
3095         int fail = 0;
3096         char *src = "config.log";
3097         char *dst = "conftest.chk";
3098         struct stat src_sb;
3099         struct stat dst_sb;
3100
3101         stat(src, &src_sb);
3102         fail = ($cf_func("config.log", "conftest.chk") < 0)
3103             || (stat(dst, &dst_sb) < 0)
3104             || (dst_sb.st_mtime != src_sb.st_mtime);
3105 #ifdef HAVE_UNLINK
3106         unlink(dst);
3107 #else
3108         remove(dst);
3109 #endif
3110         ${cf_cv_main_return:-return} (fail);
3111 }
3112                         ],[
3113                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
3114                         eval 'ac_cv_func_'$cf_func'=yes'],[
3115                         eval 'ac_cv_func_'$cf_func'=no'],[
3116                         eval 'ac_cv_func_'$cf_func'=error'])
3117                 done
3118                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
3119         ])
3120         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
3121         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
3122 fi
3123 ])dnl
3124 dnl ---------------------------------------------------------------------------
3125 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
3126 dnl --------------
3127 dnl Check if a return from main to the shell actually returns the same exit
3128 dnl code.  This is true for almost any POSIX environment.
3129 dnl
3130 dnl Some very old environments did not flush stdout, etc., on an exit.  That
3131 dnl would be a useful case to test for also.
3132 AC_DEFUN([CF_MAIN_RETURN],
3133 [
3134 cf_cv_main_return=return
3135 ])dnl
3136 dnl ---------------------------------------------------------------------------
3137 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
3138 dnl ------------
3139 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
3140 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
3141 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
3142 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
3143 AC_DEFUN([CF_MAKEFLAGS],
3144 [
3145 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
3146         cf_cv_makeflags=''
3147         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
3148         do
3149                 cat >cf_makeflags.tmp <<CF_EOF
3150 SHELL = /bin/sh
3151 all :
3152         @ echo '.$cf_option'
3153 CF_EOF
3154                 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[       ]]*$,,'`
3155                 case "$cf_result" in
3156                 .*k)
3157                         cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
3158                         case "$cf_result" in
3159                         .*CC=*) cf_cv_makeflags=
3160                                 ;;
3161                         *)      cf_cv_makeflags=$cf_option
3162                                 ;;
3163                         esac
3164                         break
3165                         ;;
3166                 .-)     ;;
3167                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
3168                         ;;
3169                 esac
3170         done
3171         rm -f cf_makeflags.tmp
3172 ])
3173
3174 AC_SUBST(cf_cv_makeflags)
3175 ])dnl
3176 dnl ---------------------------------------------------------------------------
3177 dnl CF_MAKE_TAGS version: 5 updated: 2010/04/03 20:07:32
3178 dnl ------------
3179 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
3180 dnl a monocase filesystem.
3181 AC_DEFUN([CF_MAKE_TAGS],[
3182 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
3183
3184 AC_CHECK_PROGS(CTAGS, exctags ctags)
3185 AC_CHECK_PROGS(ETAGS, exetags etags)
3186
3187 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS-ctags}, yes, no)
3188
3189 if test "$cf_cv_mixedcase" = yes ; then
3190         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS-etags}, yes, no)
3191 else
3192         MAKE_UPPER_TAGS=no
3193 fi
3194
3195 if test "$MAKE_UPPER_TAGS" = yes ; then
3196         MAKE_UPPER_TAGS=
3197 else
3198         MAKE_UPPER_TAGS="#"
3199 fi
3200
3201 if test "$MAKE_LOWER_TAGS" = yes ; then
3202         MAKE_LOWER_TAGS=
3203 else
3204         MAKE_LOWER_TAGS="#"
3205 fi
3206
3207 AC_SUBST(CTAGS)
3208 AC_SUBST(ETAGS)
3209
3210 AC_SUBST(MAKE_UPPER_TAGS)
3211 AC_SUBST(MAKE_LOWER_TAGS)
3212 ])dnl
3213 dnl ---------------------------------------------------------------------------
3214 dnl CF_MANPAGE_FORMAT version: 8 updated: 2009/01/11 20:30:50
3215 dnl -----------------
3216 dnl Option to allow user to override automatic configuration of manpage format.
3217 dnl There are several special cases:
3218 dnl
3219 dnl     gzip - man checks for, can display gzip'd files
3220 dnl     compress - man checks for, can display compressed files
3221 dnl     BSDI - files in the cat-directories are suffixed ".0"
3222 dnl     formatted - installer should format (put files in cat-directory)
3223 dnl     catonly - installer should only format, e.g., for a turnkey system.
3224 dnl
3225 dnl There are other configurations which this macro does not test, e.g., HPUX's
3226 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
3227 dnl convention would not match our use).
3228 AC_DEFUN([CF_MANPAGE_FORMAT],
3229 [
3230 AC_REQUIRE([CF_PATHSEP])
3231 AC_MSG_CHECKING(format of man-pages)
3232
3233 AC_ARG_WITH(manpage-format,
3234         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
3235                           optionally formatted/catonly, e.g., gzip,formatted],
3236         [MANPAGE_FORMAT=$withval],
3237         [MANPAGE_FORMAT=unknown])
3238
3239 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
3240 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
3241
3242 cf_unknown=
3243
3244 case $MANPAGE_FORMAT in
3245 unknown)
3246   if test -z "$MANPATH" ; then
3247     MANPATH="/usr/man:/usr/share/man"
3248   fi
3249
3250   # look for the 'date' man-page (it's most likely to be installed!)
3251   MANPAGE_FORMAT=
3252   cf_preform=no
3253   cf_catonly=yes
3254   cf_example=date
3255
3256   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
3257   for cf_dir in $MANPATH; do
3258     test -z "$cf_dir" && cf_dir=/usr/man
3259     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
3260     do
3261       cf_test=`echo $cf_name | sed -e 's/*//'`
3262       if test "x$cf_test" = "x$cf_name" ; then
3263
3264         case "$cf_name" in
3265         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
3266         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
3267         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
3268         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
3269         esac
3270
3271         case "$cf_name" in
3272         $cf_dir/man*)
3273           cf_catonly=no
3274           ;;
3275         $cf_dir/cat*)
3276           cf_preform=yes
3277           ;;
3278         esac
3279         break
3280       fi
3281
3282       # if we found a match in either man* or cat*, stop looking
3283       if test -n "$MANPAGE_FORMAT" ; then
3284         cf_found=no
3285         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
3286         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
3287         case "$cf_name" in
3288         $cf_dir/cat*)
3289           cf_found=yes
3290           ;;
3291         esac
3292         test $cf_found=yes && break
3293       fi
3294     done
3295     # only check the first directory in $MANPATH where we find manpages
3296     if test -n "$MANPAGE_FORMAT" ; then
3297        break
3298     fi
3299   done
3300   # if we did not find the example, just assume it is normal
3301   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
3302   IFS="$ac_save_ifs"
3303   ;;
3304 *)
3305   for cf_option in $MANPAGE_FORMAT; do
3306      case $cf_option in #(vi
3307      gzip|compress|BSDI|normal|formatted|catonly)
3308        ;;
3309      *)
3310        cf_unknown="$cf_unknown $cf_option"
3311        ;;
3312      esac
3313   done
3314   ;;
3315 esac
3316
3317 AC_MSG_RESULT($MANPAGE_FORMAT)
3318 if test -n "$cf_unknown" ; then
3319   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
3320 fi
3321 ])dnl
3322 dnl ---------------------------------------------------------------------------
3323 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
3324 dnl ------------------
3325 dnl The Debian people have their own naming convention for manpages.  This
3326 dnl option lets us override the name of the file containing renaming, or
3327 dnl disable it altogether.
3328 AC_DEFUN([CF_MANPAGE_RENAMES],
3329 [
3330 AC_MSG_CHECKING(for manpage renaming)
3331
3332 AC_ARG_WITH(manpage-renames,
3333         [  --with-manpage-renames  specify manpage-renaming],
3334         [MANPAGE_RENAMES=$withval],
3335         [MANPAGE_RENAMES=yes])
3336
3337 case ".$MANPAGE_RENAMES" in #(vi
3338 .no) #(vi
3339   ;;
3340 .|.yes)
3341   # Debian 'man' program?
3342   if test -f /etc/debian_version ; then
3343     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
3344   else
3345     MANPAGE_RENAMES=no
3346   fi
3347   ;;
3348 esac
3349
3350 if test "$MANPAGE_RENAMES" != no ; then
3351   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
3352     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
3353   elif test ! -f $MANPAGE_RENAMES ; then
3354     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
3355   fi
3356
3357   test ! -d man && mkdir man
3358
3359   # Construct a sed-script to perform renaming within man-pages
3360   if test -n "$MANPAGE_RENAMES" ; then
3361     test ! -d man && mkdir man
3362     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
3363   fi
3364 fi
3365
3366 AC_MSG_RESULT($MANPAGE_RENAMES)
3367 AC_SUBST(MANPAGE_RENAMES)
3368 ])dnl
3369 dnl ---------------------------------------------------------------------------
3370 dnl CF_MANPAGE_SYMLINKS version: 4 updated: 2003/12/13 18:01:58
3371 dnl -------------------
3372 dnl Some people expect each tool to make all aliases for manpages in the
3373 dnl man-directory.  This accommodates the older, less-capable implementations
3374 dnl of 'man', and is optional.
3375 AC_DEFUN([CF_MANPAGE_SYMLINKS],
3376 [
3377 AC_MSG_CHECKING(if manpage aliases will be installed)
3378
3379 AC_ARG_WITH(manpage-aliases,
3380         [  --with-manpage-aliases  specify manpage-aliases using .so],
3381         [MANPAGE_ALIASES=$withval],
3382         [MANPAGE_ALIASES=yes])
3383
3384 AC_MSG_RESULT($MANPAGE_ALIASES)
3385
3386 if test "$LN_S" = "ln -s"; then
3387         cf_use_symlinks=yes
3388 else
3389         cf_use_symlinks=no
3390 fi
3391
3392 MANPAGE_SYMLINKS=no
3393 if test "$MANPAGE_ALIASES" = yes ; then
3394 AC_MSG_CHECKING(if manpage symlinks should be used)
3395
3396 AC_ARG_WITH(manpage-symlinks,
3397         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
3398         [MANPAGE_SYMLINKS=$withval],
3399         [MANPAGE_SYMLINKS=$cf_use_symlinks])
3400
3401 if test "$$cf_use_symlinks" = no; then
3402 if test "$MANPAGE_SYMLINKS" = yes ; then
3403         AC_MSG_WARN(cannot make symlinks, will use .so files)
3404         MANPAGE_SYMLINKS=no
3405 fi
3406 fi
3407
3408 AC_MSG_RESULT($MANPAGE_SYMLINKS)
3409 fi
3410
3411 ])dnl
3412 dnl ---------------------------------------------------------------------------
3413 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
3414 dnl --------------
3415 dnl This option causes manpages to be run through tbl(1) to generate tables
3416 dnl correctly.
3417 AC_DEFUN([CF_MANPAGE_TBL],
3418 [
3419 AC_MSG_CHECKING(for manpage tbl)
3420
3421 AC_ARG_WITH(manpage-tbl,
3422         [  --with-manpage-tbl      specify manpage processing with tbl],
3423         [MANPAGE_TBL=$withval],
3424         [MANPAGE_TBL=no])
3425
3426 AC_MSG_RESULT($MANPAGE_TBL)
3427 ])dnl
3428 dnl ---------------------------------------------------------------------------
3429 dnl CF_MAN_PAGES version: 36 updated: 2010/03/13 13:41:01
3430 dnl ------------
3431 dnl Try to determine if the man-pages on the system are compressed, and if
3432 dnl so, what format is used.  Use this information to construct a script that
3433 dnl will install man-pages.
3434 AC_DEFUN([CF_MAN_PAGES],
3435 [
3436 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
3437 CF_MANPAGE_FORMAT
3438 CF_MANPAGE_RENAMES
3439 CF_MANPAGE_SYMLINKS
3440 CF_MANPAGE_TBL
3441
3442   if test "$prefix" = "NONE" ; then
3443      cf_prefix="$ac_default_prefix"
3444   else
3445      cf_prefix="$prefix"
3446   fi
3447
3448   case "$MANPAGE_FORMAT" in # (vi
3449   *catonly*) # (vi
3450     cf_format=yes
3451     cf_inboth=no
3452     ;;
3453   *formatted*) # (vi
3454     cf_format=yes
3455     cf_inboth=yes
3456     ;;
3457   *)
3458     cf_format=no
3459     cf_inboth=no
3460     ;;
3461   esac
3462
3463 test ! -d man && mkdir man
3464
3465 cf_so_strip=
3466 cf_compress=
3467 case "$MANPAGE_FORMAT" in #(vi
3468 *compress*) #(vi
3469         cf_so_strip="Z"
3470         cf_compress=compress
3471   ;;
3472 *gzip*) #(vi
3473         cf_so_strip="gz"
3474         cf_compress=gzip
3475   ;;
3476 esac
3477
3478 cf_edit_man=./edit_man.sh
3479 cf_man_alias=`pwd`/man_alias.sed
3480
3481 cat >$cf_edit_man <<CF_EOF
3482 #! /bin/sh
3483 # this script is generated by the configure-script CF_MAN_PAGES macro.
3484
3485 prefix="$cf_prefix"
3486 datadir="$datadir"
3487
3488 NCURSES_MAJOR="$NCURSES_MAJOR"
3489 NCURSES_MINOR="$NCURSES_MINOR"
3490 NCURSES_PATCH="$NCURSES_PATCH"
3491
3492 NCURSES_OSPEED="$NCURSES_OSPEED"
3493 TERMINFO="$TERMINFO"
3494
3495 MKDIRS="sh `cd $srcdir && pwd`/mkdirs.sh"
3496
3497 INSTALL="$INSTALL"
3498 INSTALL_DATA="$INSTALL_DATA"
3499
3500 transform="$program_transform_name"
3501
3502 TMP=\${TMPDIR-/tmp}/man\$\$
3503 trap "rm -f \$TMP" 0 1 2 5 15
3504
3505 form=\[$]1
3506 shift || exit 1
3507
3508 verb=\[$]1
3509 shift || exit 1
3510
3511 mandir=\[$]1
3512 shift || exit 1
3513
3514 srcdir=\[$]1
3515 top_srcdir=\[$]srcdir/..
3516 shift || exit 1
3517
3518 if test "\$form" = normal ; then
3519         if test "$cf_format" = yes ; then
3520         if test "$cf_inboth" = no ; then
3521                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3522                 exit $?
3523         fi
3524         fi
3525         cf_subdir=\$mandir/man
3526         cf_tables=$MANPAGE_TBL
3527 else
3528         cf_subdir=\$mandir/cat
3529         cf_tables=yes
3530 fi
3531
3532 # process the list of source-files
3533 for i in \[$]* ; do
3534 case \$i in #(vi
3535 *.orig|*.rej) ;; #(vi
3536 *.[[0-9]]*)
3537         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
3538         if test \$verb = installing ; then
3539         if test ! -d \$cf_subdir\${section} ; then
3540                 \$MKDIRS \$cf_subdir\$section
3541         fi
3542         fi
3543
3544         # replace variables in man page
3545         if test ! -f $cf_man_alias ; then
3546 cat >>$cf_man_alias <<-CF_EOF2
3547                 s,@DATADIR@,\$datadir,g
3548                 s,@TERMINFO@,\$TERMINFO,g
3549                 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
3550                 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
3551                 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
3552                 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
3553 CF_EOF
3554         ifelse($1,,,[
3555         for cf_name in $1
3556         do
3557                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3558                 cf_name=`echo $cf_name|sed "$program_transform_name"`
3559 cat >>$cf_edit_man <<-CF_EOF
3560                 s,@$cf_NAME@,$cf_name,g
3561 CF_EOF
3562         done
3563         ])
3564 cat >>$cf_edit_man <<CF_EOF
3565 CF_EOF2
3566                 echo "...made $cf_man_alias"
3567         fi
3568
3569         aliases=
3570         cf_source=\`basename \$i\`
3571         inalias=\$cf_source
3572         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
3573         if test ! -f \$inalias ; then
3574                 echo .. skipped \$cf_source
3575                 continue
3576         fi
3577 CF_EOF
3578
3579 if test "$MANPAGE_ALIASES" != no ; then
3580 cat >>$cf_edit_man <<CF_EOF
3581         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
3582 CF_EOF
3583 fi
3584
3585 if test "$MANPAGE_RENAMES" = no ; then
3586 cat >>$cf_edit_man <<CF_EOF
3587         # perform program transformations for section 1 man pages
3588         if test \$section = 1 ; then
3589                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
3590         else
3591                 cf_target=\$cf_subdir\${section}/\$cf_source
3592         fi
3593 CF_EOF
3594 else
3595 cat >>$cf_edit_man <<CF_EOF
3596         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
3597         if test -z "\$cf_target" ; then
3598                 echo '? missing rename for '\$cf_source
3599                 cf_target="\$cf_source"
3600         fi
3601         cf_target="\$cf_subdir\${section}/\${cf_target}"
3602
3603 CF_EOF
3604 fi
3605
3606 cat >>$cf_edit_man <<CF_EOF
3607         sed     -f $cf_man_alias \\
3608 CF_EOF
3609
3610 if test -f $MANPAGE_RENAMES ; then
3611 cat >>$cf_edit_man <<CF_EOF
3612                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
3613 CF_EOF
3614 else
3615 cat >>$cf_edit_man <<CF_EOF
3616                 < \$i >\$TMP
3617 CF_EOF
3618 fi
3619
3620 cat >>$cf_edit_man <<CF_EOF
3621 if test \$cf_tables = yes ; then
3622         tbl \$TMP >\$TMP.out
3623         mv \$TMP.out \$TMP
3624 fi
3625 CF_EOF
3626
3627 if test $with_curses_h != yes ; then
3628 cat >>$cf_edit_man <<CF_EOF
3629         sed -e "/\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
3630         mv \$TMP.out \$TMP
3631 CF_EOF
3632 fi
3633
3634 cat >>$cf_edit_man <<CF_EOF
3635         if test \$form = format ; then
3636                 nroff -man \$TMP >\$TMP.out
3637                 mv \$TMP.out \$TMP
3638         fi
3639 CF_EOF
3640
3641 if test -n "$cf_compress" ; then
3642 cat >>$cf_edit_man <<CF_EOF
3643         if test \$verb = installing ; then
3644         if ( $cf_compress -f \$TMP )
3645         then
3646                 mv \$TMP.$cf_so_strip \$TMP
3647         fi
3648         fi
3649         cf_target="\$cf_target.$cf_so_strip"
3650 CF_EOF
3651 fi
3652
3653 case "$MANPAGE_FORMAT" in #(vi
3654 *BSDI*)
3655 cat >>$cf_edit_man <<CF_EOF
3656         if test \$form = format ; then
3657                 # BSDI installs only .0 suffixes in the cat directories
3658                 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
3659         fi
3660 CF_EOF
3661   ;;
3662 esac
3663
3664 cat >>$cf_edit_man <<CF_EOF
3665         suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
3666         if test \$verb = installing ; then
3667                 echo \$verb \$cf_target
3668                 \$INSTALL_DATA \$TMP \$cf_target
3669                 test -d \$cf_subdir\${section} &&
3670                 test -n "\$aliases" && (
3671                         cd \$cf_subdir\${section} && (
3672                                 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
3673                                 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
3674                                 cf_target=\`basename \$cf_target\`
3675                                 for cf_alias in \$aliases
3676                                 do
3677                                         if test \$section = 1 ; then
3678                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3679                                         fi
3680
3681                                         if test "$MANPAGE_SYMLINKS" = yes ; then
3682                                                 if test -f \$cf_alias\${suffix} ; then
3683                                                         if ( cmp -s \$cf_target \$cf_alias\${suffix} )
3684                                                         then
3685                                                                 continue
3686                                                         fi
3687                                                 fi
3688                                                 echo .. \$verb alias \$cf_alias\${suffix}
3689                                                 rm -f \$cf_alias\${suffix}
3690                                                 $LN_S \$cf_target \$cf_alias\${suffix}
3691                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
3692                                                 echo ".so \$cf_source" >\$TMP
3693 CF_EOF
3694 if test -n "$cf_compress" ; then
3695 cat >>$cf_edit_man <<CF_EOF
3696                                                 if test -n "$cf_so_strip" ; then
3697                                                         $cf_compress -f \$TMP
3698                                                         mv \$TMP.$cf_so_strip \$TMP
3699                                                 fi
3700 CF_EOF
3701 fi
3702 cat >>$cf_edit_man <<CF_EOF
3703                                                 echo .. \$verb alias \$cf_alias\${suffix}
3704                                                 rm -f \$cf_alias\${suffix}
3705                                                 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
3706                                         fi
3707                                 done
3708                         )
3709                 )
3710         elif test \$verb = removing ; then
3711                 test -f \$cf_target && (
3712                         echo \$verb \$cf_target
3713                         rm -f \$cf_target
3714                 )
3715                 test -d \$cf_subdir\${section} &&
3716                 test -n "\$aliases" && (
3717                         cd \$cf_subdir\${section} && (
3718                                 for cf_alias in \$aliases
3719                                 do
3720                                         if test \$section = 1 ; then
3721                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3722                                         fi
3723
3724                                         echo .. \$verb alias \$cf_alias\${suffix}
3725                                         rm -f \$cf_alias\${suffix}
3726                                 done
3727                         )
3728                 )
3729         else
3730 #               echo ".hy 0"
3731                 cat \$TMP
3732         fi
3733         ;;
3734 esac
3735 done
3736
3737 if test $cf_inboth = yes ; then
3738 if test \$form != format ; then
3739         sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3740 fi
3741 fi
3742
3743 exit 0
3744 CF_EOF
3745 chmod 755 $cf_edit_man
3746
3747 ])dnl
3748 dnl ---------------------------------------------------------------------------
3749 dnl CF_MATH_LIB version: 6 updated: 2009/12/19 13:46:49
3750 dnl -----------
3751 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
3752 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
3753 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
3754 AC_DEFUN([CF_MATH_LIB],
3755 [
3756 AC_CACHE_CHECK(if -lm needed for math functions,
3757         cf_cv_need_libm,[
3758         AC_TRY_LINK([
3759         #include <stdio.h>
3760         #include <math.h>
3761         ],
3762         [double x = rand(); printf("result = %g\n", ]ifelse($2,,sin(x),$2)[)],
3763         [cf_cv_need_libm=no],
3764         [cf_cv_need_libm=yes])])
3765 if test "$cf_cv_need_libm" = yes
3766 then
3767 ifelse($1,,[
3768         LIBS="-lm $LIBS"
3769 ],[$1=-lm])
3770 fi
3771 ])
3772 dnl ---------------------------------------------------------------------------
3773 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
3774 dnl ----------------------
3775 dnl Check if the file-system supports mixed-case filenames.  If we're able to
3776 dnl create a lowercase name and see it as uppercase, it doesn't support that.
3777 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
3778 [
3779 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
3780 if test "$cross_compiling" = yes ; then
3781         case $target_alias in #(vi
3782         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
3783                 cf_cv_mixedcase=no
3784                 ;;
3785         *)
3786                 cf_cv_mixedcase=yes
3787                 ;;
3788         esac
3789 else
3790         rm -f conftest CONFTEST
3791         echo test >conftest
3792         if test -f CONFTEST ; then
3793                 cf_cv_mixedcase=no
3794         else
3795                 cf_cv_mixedcase=yes
3796         fi
3797         rm -f conftest CONFTEST
3798 fi
3799 ])
3800 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
3801 ])dnl
3802 dnl ---------------------------------------------------------------------------
3803 dnl CF_MKSTEMP version: 5 updated: 2006/12/16 12:33:30
3804 dnl ----------
3805 dnl Check for a working mkstemp.  This creates two files, checks that they are
3806 dnl successfully created and distinct (AmigaOS apparently fails on the last).
3807 AC_DEFUN([CF_MKSTEMP],[
3808 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
3809 rm -f conftest*
3810 AC_TRY_RUN([
3811 #include <sys/types.h>
3812 #include <stdlib.h>
3813 #include <stdio.h>
3814 #include <string.h>
3815 #include <sys/stat.h>
3816 int main()
3817 {
3818         char *tmpl = "conftestXXXXXX";
3819         char name[2][80];
3820         int n;
3821         int result = 0;
3822         int fd;
3823         struct stat sb;
3824
3825         umask(077);
3826         for (n = 0; n < 2; ++n) {
3827                 strcpy(name[n], tmpl);
3828                 if ((fd = mkstemp(name[n])) >= 0) {
3829                         if (!strcmp(name[n], tmpl)
3830                          || stat(name[n], &sb) != 0
3831                          || (sb.st_mode & S_IFMT) != S_IFREG
3832                          || (sb.st_mode & 077) != 0) {
3833                                 result = 1;
3834                         }
3835                         close(fd);
3836                 }
3837         }
3838         if (result == 0
3839          && !strcmp(name[0], name[1]))
3840                 result = 1;
3841         ${cf_cv_main_return:-return}(result);
3842 }
3843 ],[cf_cv_func_mkstemp=yes
3844 ],[cf_cv_func_mkstemp=no
3845 ],[AC_CHECK_FUNC(mkstemp)
3846 ])
3847 ])
3848 if test "$cf_cv_func_mkstemp" = yes ; then
3849         AC_DEFINE(HAVE_MKSTEMP)
3850 fi
3851 ])dnl
3852 dnl ---------------------------------------------------------------------------
3853 dnl CF_MSG_LOG version: 4 updated: 2007/07/29 09:55:12
3854 dnl ----------
3855 dnl Write a debug message to config.log, along with the line number in the
3856 dnl configure script.
3857 AC_DEFUN([CF_MSG_LOG],[
3858 echo "${as_me-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
3859 ])dnl
3860 dnl ---------------------------------------------------------------------------
3861 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
3862 dnl ----------------
3863 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
3864 dnl warn about this.
3865 AC_DEFUN([CF_NCURSES_ABI_6],[
3866 if test "${with_abi_version+set}" != set; then
3867         case $cf_cv_rel_version in
3868         5.*)
3869                 cf_cv_rel_version=6.0
3870                 cf_cv_abi_version=6
3871                 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
3872                 ;;
3873         esac
3874 fi
3875 ])dnl
3876 dnl ---------------------------------------------------------------------------
3877 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
3878 dnl ------------------
3879 dnl see CF_WITH_NO_LEAKS
3880 AC_DEFUN([CF_NO_LEAKS_OPTION],[
3881 AC_MSG_CHECKING(if you want to use $1 for testing)
3882 AC_ARG_WITH($1,
3883         [$2],
3884         [AC_DEFINE($3)ifelse([$4],,[
3885          $4
3886 ])
3887         : ${with_cflags:=-g}
3888         : ${with_no_leaks:=yes}
3889          with_$1=yes],
3890         [with_$1=])
3891 AC_MSG_RESULT(${with_$1:-no})
3892
3893 case .$with_cflags in #(vi
3894 .*-g*)
3895         case .$CFLAGS in #(vi
3896         .*-g*) #(vi
3897                 ;;
3898         *)
3899                 CF_ADD_CFLAGS([-g])
3900                 ;;
3901         esac
3902         ;;
3903 esac
3904 ])dnl
3905 dnl ---------------------------------------------------------------------------
3906 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
3907 dnl ----------------
3908 dnl Check if the given variable is a number.  If not, report an error.
3909 dnl $1 is the variable
3910 dnl $2 is the message
3911 AC_DEFUN([CF_NUMBER_SYNTAX],[
3912 if test -n "$1" ; then
3913   case $1 in #(vi
3914   [[0-9]]*) #(vi
3915         ;;
3916   *)
3917         AC_MSG_ERROR($2 is not a number: $1)
3918         ;;
3919   esac
3920 else
3921   AC_MSG_ERROR($2 value is empty)
3922 fi
3923 ])dnl
3924 dnl ---------------------------------------------------------------------------
3925 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
3926 dnl -------------
3927 dnl Compute the object-directory name from the given model name
3928 AC_DEFUN([CF_OBJ_SUBDIR],
3929 [
3930         case $1 in
3931         libtool) $2='obj_lo'  ;;
3932         normal)  $2='objects' ;;
3933         debug)   $2='obj_g' ;;
3934         profile) $2='obj_p' ;;
3935         shared)
3936                 case $cf_cv_system_name in #(vi
3937                 cygwin) #(vi
3938                         $2='objects' ;;
3939                 *)
3940                         $2='obj_s' ;;
3941                 esac
3942         esac
3943 ])dnl
3944 dnl ---------------------------------------------------------------------------
3945 dnl CF_PATHSEP version: 4 updated: 2009/01/11 20:30:23
3946 dnl ----------
3947 dnl Provide a value for the $PATH and similar separator
3948 AC_DEFUN([CF_PATHSEP],
3949 [
3950         case $cf_cv_system_name in
3951         os2*)   PATH_SEPARATOR=';'  ;;
3952         *)      PATH_SEPARATOR=':'  ;;
3953         esac
3954 ifelse($1,,,[$1=$PATH_SEPARATOR])
3955         AC_SUBST(PATH_SEPARATOR)
3956 ])dnl
3957 dnl ---------------------------------------------------------------------------
3958 dnl CF_PATH_SYNTAX version: 12 updated: 2008/03/23 14:45:59
3959 dnl --------------
3960 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
3961 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3962 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
3963 dnl delayed evaluation of those symbols.
3964 AC_DEFUN([CF_PATH_SYNTAX],[
3965 if test "x$prefix" != xNONE; then
3966   cf_path_syntax="$prefix"
3967 else
3968   cf_path_syntax="$ac_default_prefix"
3969 fi
3970
3971 case ".[$]$1" in #(vi
3972 .\[$]\(*\)*|.\'*\'*) #(vi
3973   ;;
3974 ..|./*|.\\*) #(vi
3975   ;;
3976 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
3977   ;;
3978 .\[$]{*prefix}*) #(vi
3979   eval $1="[$]$1"
3980   case ".[$]$1" in #(vi
3981   .NONE/*)
3982     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3983     ;;
3984   esac
3985   ;; #(vi
3986 .no|.NONE/*)
3987   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3988   ;;
3989 *)
3990   ifelse($2,,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3991   ;;
3992 esac
3993 ])dnl
3994 dnl ---------------------------------------------------------------------------
3995 dnl CF_PKG_CONFIG version: 3 updated: 2009/01/25 10:55:09
3996 dnl -------------
3997 dnl Check for the package-config program, unless disabled by command-line.
3998 AC_DEFUN([CF_PKG_CONFIG],
3999 [
4000 AC_MSG_CHECKING(if you want to use pkg-config)
4001 AC_ARG_WITH(pkg-config,
4002         [  --with-pkg-config{=path} enable/disable use of pkg-config],
4003         [cf_pkg_config=$withval],
4004         [cf_pkg_config=yes])
4005 AC_MSG_RESULT($cf_pkg_config)
4006
4007 case $cf_pkg_config in #(vi
4008 no) #(vi
4009         PKG_CONFIG=none
4010         ;;
4011 yes) #(vi
4012         AC_PATH_PROG(PKG_CONFIG, pkg-config, none)
4013         ;;
4014 *)
4015         PKG_CONFIG=$withval
4016         ;;
4017 esac
4018
4019 test -z "$PKG_CONFIG" && PKG_CONFIG=none
4020 if test "$PKG_CONFIG" != none ; then
4021         CF_PATH_SYNTAX(PKG_CONFIG)
4022 fi
4023
4024 AC_SUBST(PKG_CONFIG)
4025 ])dnl
4026 dnl ---------------------------------------------------------------------------
4027 dnl CF_POSIX_C_SOURCE version: 7 updated: 2010/01/09 11:05:50
4028 dnl -----------------
4029 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
4030 dnl
4031 dnl     POSIX.1-1990                            _POSIX_SOURCE
4032 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
4033 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
4034 dnl             Bindings Option
4035 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
4036 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
4037 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
4038 dnl
4039 dnl Parameters:
4040 dnl     $1 is the nominal value for _POSIX_C_SOURCE
4041 AC_DEFUN([CF_POSIX_C_SOURCE],
4042 [
4043 cf_POSIX_C_SOURCE=ifelse($1,,199506L,$1)
4044
4045 cf_save_CFLAGS="$CFLAGS"
4046 cf_save_CPPFLAGS="$CPPFLAGS"
4047
4048 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
4049 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
4050
4051 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
4052         CF_MSG_LOG(if the symbol is already defined go no further)
4053         AC_TRY_COMPILE([#include <sys/types.h>],[
4054 #ifndef _POSIX_C_SOURCE
4055 make an error
4056 #endif],
4057         [cf_cv_posix_c_source=no],
4058         [cf_want_posix_source=no
4059          case .$cf_POSIX_C_SOURCE in #(vi
4060          .[[12]]??*) #(vi
4061                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
4062                 ;;
4063          .2) #(vi
4064                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
4065                 cf_want_posix_source=yes
4066                 ;;
4067          .*)
4068                 cf_want_posix_source=yes
4069                 ;;
4070          esac
4071          if test "$cf_want_posix_source" = yes ; then
4072                 AC_TRY_COMPILE([#include <sys/types.h>],[
4073 #ifdef _POSIX_SOURCE
4074 make an error
4075 #endif],[],
4076                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
4077          fi
4078          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
4079          CFLAGS="$cf_trim_CFLAGS"
4080          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
4081          CF_MSG_LOG(if the second compile does not leave our definition intact error)
4082          AC_TRY_COMPILE([#include <sys/types.h>],[
4083 #ifndef _POSIX_C_SOURCE
4084 make an error
4085 #endif],,
4086          [cf_cv_posix_c_source=no])
4087          CFLAGS="$cf_save_CFLAGS"
4088          CPPFLAGS="$cf_save_CPPFLAGS"
4089         ])
4090 ])
4091
4092 if test "$cf_cv_posix_c_source" != no ; then
4093         CFLAGS="$cf_trim_CFLAGS"
4094         CPPFLAGS="$cf_trim_CPPFLAGS"
4095         CF_ADD_CFLAGS($cf_cv_posix_c_source)
4096 fi
4097
4098 ])dnl
4099 dnl ---------------------------------------------------------------------------
4100 dnl CF_PREDEFINE version: 1 updated: 2003/07/26 17:53:56
4101 dnl ------------
4102 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
4103 dnl
4104 dnl $1 = symbol to test
4105 dnl $2 = value (if any) to use for a predefinition
4106 AC_DEFUN([CF_PREDEFINE],
4107 [
4108 AC_MSG_CHECKING(if we must define $1)
4109 AC_TRY_COMPILE([#include <sys/types.h>
4110 ],[
4111 #ifndef $1
4112 make an error
4113 #endif],[cf_result=no],[cf_result=yes])
4114 AC_MSG_RESULT($cf_result)
4115
4116 if test "$cf_result" = yes ; then
4117         CPPFLAGS="$CPPFLAGS ifelse($2,,-D$1,[-D$1=$2])"
4118 elif test "x$2" != "x" ; then
4119         AC_MSG_CHECKING(checking for compatible value versus $2)
4120         AC_TRY_COMPILE([#include <sys/types.h>
4121 ],[
4122 #if $1-$2 < 0
4123 make an error
4124 #endif],[cf_result=yes],[cf_result=no])
4125         AC_MSG_RESULT($cf_result)
4126         if test "$cf_result" = no ; then
4127                 # perhaps we can override it - try...
4128                 CPPFLAGS="$CPPFLAGS -D$1=$2"
4129         fi
4130 fi
4131 ])dnl
4132 dnl ---------------------------------------------------------------------------
4133 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
4134 dnl ------------
4135 dnl Append definitions and rules for the given programs to the subdirectory
4136 dnl Makefiles, and the recursion rule for the top-level Makefile.
4137 dnl
4138 dnl parameters
4139 dnl     $1 = script to run
4140 dnl     $2 = list of subdirectories
4141 dnl
4142 dnl variables
4143 dnl     $AWK
4144 AC_DEFUN([CF_PRG_RULES],
4145 [
4146 for cf_dir in $2
4147 do
4148         if test ! -d $srcdir/$cf_dir; then
4149                 continue
4150         elif test -f $srcdir/$cf_dir/programs; then
4151                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
4152         fi
4153 done
4154
4155 ])dnl
4156 dnl ---------------------------------------------------------------------------
4157 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
4158 dnl ----------
4159 dnl Check for archiver "ar".
4160 AC_DEFUN([CF_PROG_AR],[
4161 AC_CHECK_TOOL(AR, ar, ar)
4162 ])
4163 dnl ---------------------------------------------------------------------------
4164 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
4165 dnl -----------
4166 dnl Check for awk, ensure that the check found something.
4167 AC_DEFUN([CF_PROG_AWK],
4168 [
4169 AC_PROG_AWK
4170 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
4171 ])dnl
4172 dnl ---------------------------------------------------------------------------
4173 dnl CF_PROG_CC_C_O version: 2 updated: 2006/12/16 15:55:46
4174 dnl --------------
4175 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
4176 dnl the output file can be renamed, and allows for a shell variable that can
4177 dnl be used later.  The parameter is either CC or CXX.  The result is the
4178 dnl cache variable:
4179 dnl     $cf_cv_prog_CC_c_o
4180 dnl     $cf_cv_prog_CXX_c_o
4181 AC_DEFUN([CF_PROG_CC_C_O],
4182 [AC_REQUIRE([AC_PROG_CC])dnl
4183 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
4184 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
4185 [
4186 cat > conftest.$ac_ext <<CF_EOF
4187 #include <stdio.h>
4188 int main()
4189 {
4190         ${cf_cv_main_return:-return}(0);
4191 }
4192 CF_EOF
4193 # We do the test twice because some compilers refuse to overwrite an
4194 # existing .o file with -o, though they will create one.
4195 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
4196 if AC_TRY_EVAL(ac_try) &&
4197   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
4198 then
4199   eval cf_cv_prog_$1_c_o=yes
4200 else
4201   eval cf_cv_prog_$1_c_o=no
4202 fi
4203 rm -f conftest*
4204 ])dnl
4205 if test $cf_cv_prog_$1_c_o = yes; then
4206   AC_MSG_RESULT([yes])
4207 else
4208   AC_MSG_RESULT([no])
4209 fi
4210 ])dnl
4211 dnl ---------------------------------------------------------------------------
4212 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
4213 dnl --------------
4214 dnl Check if C (preprocessor) -U and -D options are processed in the order
4215 dnl given rather than by type of option.  Some compilers insist on apply all
4216 dnl of the -U options after all of the -D options.  Others allow mixing them,
4217 dnl and may predefine symbols that conflict with those we define.
4218 AC_DEFUN([CF_PROG_CC_U_D],
4219 [
4220 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
4221         cf_save_CPPFLAGS="$CPPFLAGS"
4222         CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
4223         AC_TRY_COMPILE([],[
4224 #ifndef U_D_OPTIONS
4225 make an undefined-error
4226 #endif
4227 #ifdef  D_U_OPTIONS
4228 make a defined-error
4229 #endif
4230         ],[
4231         cf_cv_cc_u_d_options=yes],[
4232         cf_cv_cc_u_d_options=no])
4233         CPPFLAGS="$cf_save_CPPFLAGS"
4234 ])
4235 ])dnl
4236 dnl ---------------------------------------------------------------------------
4237 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
4238 dnl -------------
4239 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
4240 dnl This macro adds a check to ensure the script found something.
4241 AC_DEFUN([CF_PROG_EGREP],
4242 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
4243    [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4244     then ac_cv_prog_egrep='grep -E'
4245     else ac_cv_prog_egrep='egrep'
4246     fi])
4247  EGREP=$ac_cv_prog_egrep
4248  AC_SUBST([EGREP])
4249 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
4250 ])dnl
4251 dnl ---------------------------------------------------------------------------
4252 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
4253 dnl -----------
4254 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
4255 AC_DEFUN([CF_PROG_EXT],
4256 [
4257 AC_REQUIRE([CF_CHECK_CACHE])
4258 case $cf_cv_system_name in
4259 os2*)
4260     CFLAGS="$CFLAGS -Zmt"
4261     CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
4262     CXXFLAGS="$CXXFLAGS -Zmt"
4263     # autoconf's macro sets -Zexe and suffix both, which conflict:w
4264     LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
4265     ac_cv_exeext=.exe
4266     ;;
4267 esac
4268
4269 AC_EXEEXT
4270 AC_OBJEXT
4271
4272 PROG_EXT="$EXEEXT"
4273 AC_SUBST(PROG_EXT)
4274 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
4275 ])dnl
4276 dnl ---------------------------------------------------------------------------
4277 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
4278 dnl ---------------
4279 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
4280 dnl misc/tabset install won't work properly.  Usually this happens only when
4281 dnl using the fallback mkinstalldirs script
4282 AC_DEFUN([CF_PROG_INSTALL],
4283 [AC_PROG_INSTALL
4284 case $INSTALL in
4285 /*)
4286   ;;
4287 *)
4288   CF_DIRNAME(cf_dir,$INSTALL)
4289   test -z "$cf_dir" && cf_dir=.
4290   INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
4291   ;;
4292 esac
4293 ])dnl
4294 dnl ---------------------------------------------------------------------------
4295 dnl CF_PROG_LDCONFIG version: 2 updated: 2008/12/13 14:08:40
4296 dnl ----------------
4297 dnl Check for ldconfig, needed to fixup shared libraries that would be built
4298 dnl and then used in the install.
4299 AC_DEFUN([CF_PROG_LDCONFIG],[
4300 if test "$cross_compiling" = yes ; then
4301   LDCONFIG=:
4302 else
4303 case "$cf_cv_system_name" in #(vi
4304 dragonfly*|freebsd*) #(vi
4305   test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
4306   ;;
4307 *) LDPATH=$PATH:/sbin:/usr/sbin
4308   AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
4309   ;;
4310 esac
4311 fi
4312 AC_SUBST(LDCONFIG)
4313 ])dnl
4314 dnl ---------------------------------------------------------------------------
4315 dnl CF_PROG_LINT version: 2 updated: 2009/08/12 04:43:14
4316 dnl ------------
4317 AC_DEFUN([CF_PROG_LINT],
4318 [
4319 AC_CHECK_PROGS(LINT, tdlint lint alint splint lclint)
4320 AC_SUBST(LINT_OPTS)
4321 ])dnl
4322 dnl ---------------------------------------------------------------------------
4323 dnl CF_REGEX version: 6 updated: 2010/03/27 13:41:56
4324 dnl --------
4325 dnl Attempt to determine if we've got one of the flavors of regular-expression
4326 dnl code that we can support.
4327 AC_DEFUN([CF_REGEX],
4328 [
4329
4330 cf_regex_func=no
4331
4332 AC_CHECK_FUNC(regcomp,[cf_regex_func=regcomp],[
4333         for cf_regex_lib in regex re
4334         do
4335                 AC_CHECK_LIB($cf_regex_lib,regcomp,[
4336                                 LIBS="-l$cf_regex_lib $LIBS"
4337                                 cf_regex_func=regcomp
4338                                 break])
4339         done
4340 ])
4341
4342 if test "$cf_regex_func" = no ; then
4343         AC_CHECK_FUNC(compile,[cf_regex_func=compile],[
4344                 AC_CHECK_LIB(gen,compile,[
4345                                 LIBS="-lgen $LIBS"
4346                                 cf_regex_func=compile])])
4347 fi
4348
4349 if test "$cf_regex_func" = no ; then
4350         AC_MSG_WARN(cannot find regular expression library)
4351 fi
4352
4353 AC_CACHE_CHECK(for regular-expression headers,cf_cv_regex_hdrs,[
4354
4355 cf_cv_regex_hdrs=no
4356 case $cf_regex_func in #(vi
4357 compile) #(vi
4358         for cf_regex_hdr in regexp.h regexpr.h
4359         do
4360                 AC_TRY_LINK([#include <$cf_regex_hdr>],[
4361                         char *p = compile("", "", "", 0);
4362                         int x = step("", "");
4363                 ],[
4364                         cf_cv_regex_hdrs=$cf_regex_hdr
4365                         break
4366                 ])
4367         done
4368         ;;
4369 *)
4370         for cf_regex_hdr in regex.h
4371         do
4372                 AC_TRY_LINK([#include <sys/types.h>
4373 #include <$cf_regex_hdr>],[
4374                         regex_t *p;
4375                         int x = regcomp(p, "", 0);
4376                         int y = regexec(p, "", 0, 0, 0);
4377                         regfree(p);
4378                 ],[
4379                         cf_cv_regex_hdrs=$cf_regex_hdr
4380                         break
4381                 ])
4382         done
4383         ;;
4384 esac
4385
4386 ])
4387
4388 case $cf_cv_regex_hdrs in #(vi
4389     no)        AC_MSG_WARN(no regular expression header found) ;; #(vi
4390     regex.h)   AC_DEFINE(HAVE_REGEX_H_FUNCS) ;; #(vi
4391     regexp.h)  AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;; #(vi
4392     regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;;
4393 esac
4394 ])dnl
4395 dnl ---------------------------------------------------------------------------
4396 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
4397 dnl ----------------
4398 dnl Remove all -U and -D options that refer to the given symbol from a list
4399 dnl of C compiler options.  This works around the problem that not all
4400 dnl compilers process -U and -D options from left-to-right, so a -U option
4401 dnl cannot be used to cancel the effect of a preceding -D option.
4402 dnl
4403 dnl $1 = target (which could be the same as the source variable)
4404 dnl $2 = source (including '$')
4405 dnl $3 = symbol to remove
4406 define([CF_REMOVE_DEFINE],
4407 [
4408 $1=`echo "$2" | \
4409         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
4410                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
4411 ])dnl
4412 dnl ---------------------------------------------------------------------------
4413 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
4414 dnl -------------
4415 dnl Remove the given library from the symbol
4416 dnl
4417 dnl $1 = target (which could be the same as the source variable)
4418 dnl $2 = source (including '$')
4419 dnl $3 = library to remove
4420 define([CF_REMOVE_LIB],
4421 [
4422 # remove $3 library from $2
4423 $1=`echo "$2" | sed -e 's/-l$3[[        ]]//g' -e 's/-l$3[$]//'`
4424 ])dnl
4425 dnl ---------------------------------------------------------------------------
4426 dnl CF_RPATH_HACK version: 8 updated: 2010/04/17 15:38:58
4427 dnl -------------
4428 AC_DEFUN([CF_RPATH_HACK],
4429 [
4430 AC_REQUIRE([CF_LD_RPATH_OPT])
4431 AC_MSG_CHECKING(for updated LDFLAGS)
4432 if test -n "$LD_RPATH_OPT" ; then
4433         AC_MSG_RESULT(maybe)
4434
4435         AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
4436         cf_rpath_list="/usr/lib /lib"
4437         if test "$cf_ldd_prog" != no
4438         then
4439 AC_TRY_LINK([#include <stdio.h>],
4440                 [printf("Hello");],
4441                 [cf_rpath_list=`$cf_ldd_prog conftest$ac_exeext | fgrep / | sed -e 's%^.*[[     ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort -u`])
4442         fi
4443
4444         CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
4445
4446         CF_RPATH_HACK_2(LDFLAGS)
4447         CF_RPATH_HACK_2(LIBS)
4448
4449         CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
4450 fi
4451 AC_SUBST(EXTRA_LDFLAGS)
4452 ])dnl
4453 dnl ---------------------------------------------------------------------------
4454 dnl CF_RPATH_HACK_2 version: 6 updated: 2010/04/17 16:31:24
4455 dnl ---------------
4456 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
4457 dnl EXTRA_LDFLAGS for each -L option found.
4458 dnl
4459 dnl $cf_rpath_list contains a list of directories to ignore.
4460 dnl
4461 dnl $1 = variable name to update.  The LDFLAGS variable should be the only one,
4462 dnl      but LIBS often has misplaced -L options.
4463 AC_DEFUN([CF_RPATH_HACK_2],
4464 [
4465 CF_VERBOSE(...checking $1 [$]$1)
4466
4467 cf_rpath_dst=
4468 for cf_rpath_src in [$]$1
4469 do
4470         case $cf_rpath_src in #(vi
4471         -L*) #(vi
4472
4473                 # check if this refers to a directory which we will ignore
4474                 cf_rpath_skip=no
4475                 if test -n "$cf_rpath_list"
4476                 then
4477                         for cf_rpath_item in $cf_rpath_list
4478                         do
4479                                 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
4480                                 then
4481                                         cf_rpath_skip=yes
4482                                         break
4483                                 fi
4484                         done
4485                 fi
4486
4487                 if test "$cf_rpath_skip" = no
4488                 then
4489                         # transform the option
4490                         if test "$LD_RPATH_OPT" = "-R " ; then
4491                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
4492                         else
4493                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
4494                         fi
4495
4496                         # if we have not already added this, add it now
4497                         cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
4498                         if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"