[wxWidgets.git] / acinclude.m4

dnl ---------------------------------------------------------------------------
dnl
dnl Macros for configure.in for wxWindows by Robert Roebling, Phil Blecker,
dnl Vadim Zeitlin and Ron Lee
dnl
dnl This script is under the wxWindows licence.
dnl
dnl Version: $Id$
dnl ---------------------------------------------------------------------------

dnl ===========================================================================
dnl macros to find the a file in the list of include/lib paths
dnl ===========================================================================

dnl ---------------------------------------------------------------------------
dnl call WX_PATH_FIND_INCLUDES(search path, header name), sets ac_find_includes
dnl to the full name of the file that was found or leaves it empty if not found
dnl ---------------------------------------------------------------------------
AC_DEFUN([WX_PATH_FIND_INCLUDES],
[
ac_find_includes=
for ac_dir in $1;
  do
    if test -f "$ac_dir/$2"; then
      ac_find_includes=$ac_dir
      break
    fi
  done
])

dnl ---------------------------------------------------------------------------
dnl call WX_PATH_FIND_LIBRARIES(search path, header name), sets ac_find_libraries
dnl to the full name of the file that was found or leaves it empty if not found
dnl ---------------------------------------------------------------------------
AC_DEFUN([WX_PATH_FIND_LIBRARIES],
[
ac_find_libraries=
for ac_dir in $1;
  do
    for ac_extension in a so sl dylib; do
      if test -f "$ac_dir/lib$2.$ac_extension"; then
        ac_find_libraries=$ac_dir
        break 2
      fi
    done
  done
])

dnl ---------------------------------------------------------------------------
dnl Path to include, already defined
dnl ---------------------------------------------------------------------------
AC_DEFUN([WX_INCLUDE_PATH_EXIST],
[
  ac_path_to_include=$1
  echo "$2" | grep "\-I$1" > /dev/null
  result=$?
  if test $result = 0; then
    ac_path_to_include=""
  else
    ac_path_to_include=" -I$1"
  fi
])

dnl ---------------------------------------------------------------------------
dnl Path to link, already defined
dnl ---------------------------------------------------------------------------
AC_DEFUN([WX_LINK_PATH_EXIST],
[
  echo "$2" | grep "\-L$1" > /dev/null
  result=$?
  if test $result = 0; then
    ac_path_to_link=""
  else
    ac_path_to_link=" -L$1"
  fi
])

dnl ===========================================================================
dnl C++ features test
dnl ===========================================================================

dnl ---------------------------------------------------------------------------
dnl WX_CPP_NEW_HEADERS checks whether the compiler has "new" <iostream> header
dnl or only the old <iostream.h> one - it may be generally assumed that if
dnl <iostream> exists, the other "new" headers (without .h) exist too.
dnl
dnl call WX_CPP_NEW_HEADERS(actiof-if-true, action-if-false-or-cross-compiling)
dnl ---------------------------------------------------------------------------

AC_DEFUN([WX_CPP_NEW_HEADERS],
[
  if test "$cross_compiling" = "yes"; then
    ifelse([$2], , :, [$2])
  else
    AC_LANG_SAVE
    AC_LANG_CPLUSPLUS

    AC_CHECK_HEADERS(iostream)

    if test "$ac_cv_header_iostream" = "yes" ; then
      ifelse([$1], , :, [$1])
    else
      ifelse([$2], , :, [$2])
    fi

    AC_LANG_RESTORE
  fi
])

dnl ---------------------------------------------------------------------------
dnl WX_CPP_BOOL checks whether the C++ compiler has a built in bool type
dnl
dnl call WX_CPP_BOOL - will define HAVE_BOOL if the compiler supports bool
dnl ---------------------------------------------------------------------------

AC_DEFUN([WX_CPP_BOOL],
[
  AC_CACHE_CHECK([if C++ compiler supports bool], wx_cv_cpp_bool,
  [
    AC_LANG_SAVE
    AC_LANG_CPLUSPLUS

    AC_TRY_COMPILE(
      [
      ],
      [
        bool b = true;

        return 0;
      ],
      [
        wx_cv_cpp_bool=yes
      ],
      [
        wx_cv_cpp_bool=no
      ]
    )

    AC_LANG_RESTORE
  ])

  if test "$wx_cv_cpp_bool" = "yes"; then
    AC_DEFINE(HAVE_BOOL)
  fi
])

dnl ---------------------------------------------------------------------------
dnl a slightly better AC_C_BIGENDIAN macro which allows cross-compiling
dnl ---------------------------------------------------------------------------

AC_DEFUN([WX_C_BIGENDIAN],
[AC_CACHE_CHECK([whether byte ordering is bigendian], ac_cv_c_bigendian,
[ac_cv_c_bigendian=unknown
# See if sys/param.h defines the BYTE_ORDER macro.
AC_TRY_COMPILE([#include <sys/types.h>
#include <sys/param.h>], [
#if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN
 bogus endian macros
#endif], [# It does; now see whether it defined to BIG_ENDIAN or not.
AC_TRY_COMPILE([#include <sys/types.h>
#include <sys/param.h>], [
#if BYTE_ORDER != BIG_ENDIAN
 not big endian
#endif], ac_cv_c_bigendian=yes, ac_cv_c_bigendian=no)])
if test $ac_cv_c_bigendian = unknown; then
AC_TRY_RUN([main () {
  /* Are we little or big endian?  From Harbison&Steele.  */
  union
  {
    long l;
    char c[sizeof (long)];
  } u;
  u.l = 1;
  exit (u.c[sizeof (long) - 1] == 1);
}], [ac_cv_c_bigendian=no], [ac_cv_c_bigendian=yes], [ac_cv_c_bigendian=unknown])
fi])
if test $ac_cv_c_bigendian = unknown; then
  AC_MSG_WARN([Assuming little-endian target machine - this may be overriden by adding the line "ac_cv_c_bigendian=${ac_cv_c_bigendian='yes'}" to config.cache file])
fi
if test $ac_cv_c_bigendian = yes; then
  AC_DEFINE(WORDS_BIGENDIAN)
fi
])

dnl ---------------------------------------------------------------------------
dnl override AC_ARG_ENABLE/WITH to cache the results in .cache file
dnl ---------------------------------------------------------------------------

AC_DEFUN([WX_ARG_CACHE_INIT],
        [
          wx_arg_cache_file="configarg.cache"
          echo "loading argument cache $wx_arg_cache_file"
          rm -f ${wx_arg_cache_file}.tmp
          touch ${wx_arg_cache_file}.tmp
          touch ${wx_arg_cache_file}
        ])

AC_DEFUN([WX_ARG_CACHE_FLUSH],
        [
          echo "saving argument cache $wx_arg_cache_file"
          mv ${wx_arg_cache_file}.tmp ${wx_arg_cache_file}
        ])

dnl this macro checks for a three-valued command line --with argument:
dnl   possible arguments are 'yes', 'no', 'sys', or 'builtin'
dnl usage: WX_ARG_SYS_WITH(option, helpmessage, variable-name)
AC_DEFUN([WX_ARG_SYS_WITH],
        [
          AC_MSG_CHECKING([for --with-$1])
          no_cache=0
          AC_ARG_WITH($1, [$2],
                      [
                        if test "$withval" = yes; then
                          ac_cv_use_$1='$3=yes'
                        elif test "$withval" = no; then
                          ac_cv_use_$1='$3=no'
                        elif test "$withval" = sys; then
                          ac_cv_use_$1='$3=sys'
                        elif test "$withval" = builtin; then
                          ac_cv_use_$1='$3=builtin'
                        else
                          AC_MSG_ERROR([Invalid value for --with-$1: should be yes, no, sys, or builtin])
                        fi
                      ],
                      [
                        LINE=`grep "$3" ${wx_arg_cache_file}`
                        if test "x$LINE" != x ; then
                          eval "DEFAULT_$LINE"
                        else
                          no_cache=1
                        fi

                        ac_cv_use_$1='$3='$DEFAULT_$3
                      ])

          eval "$ac_cv_use_$1"
          if test "$no_cache" != 1; then
            echo $ac_cv_use_$1 >> ${wx_arg_cache_file}.tmp
          fi

          if test "$$3" = yes; then
            AC_MSG_RESULT(yes)
          elif test "$$3" = no; then
            AC_MSG_RESULT(no)
          elif test "$$3" = sys; then
            AC_MSG_RESULT([system version])
          elif test "$$3" = builtin; then
            AC_MSG_RESULT([builtin version])
          else
            AC_MSG_ERROR([Invalid value for --with-$1: should be yes, no, sys, or builtin])
          fi
        ])

dnl this macro checks for a command line argument and caches the result
dnl usage: WX_ARG_WITH(option, helpmessage, variable-name)
AC_DEFUN([WX_ARG_WITH],
        [
          AC_MSG_CHECKING([for --with-$1])
          no_cache=0
          AC_ARG_WITH($1, [$2],
                      [
                        if test "$withval" = yes; then
                          ac_cv_use_$1='$3=yes'
                        else
                          ac_cv_use_$1='$3=no'
                        fi
                      ],
                      [
                        LINE=`grep "$3" ${wx_arg_cache_file}`
                        if test "x$LINE" != x ; then
                          eval "DEFAULT_$LINE"
                        else
                          no_cache=1
                        fi

                        ac_cv_use_$1='$3='$DEFAULT_$3
                      ])

          eval "$ac_cv_use_$1"
          if test "$no_cache" != 1; then
            echo $ac_cv_use_$1 >> ${wx_arg_cache_file}.tmp
          fi

          if test "$$3" = yes; then
            AC_MSG_RESULT(yes)
          else
            AC_MSG_RESULT(no)
          fi
        ])

dnl like WX_ARG_WITH but uses AC_ARG_ENABLE instead of AC_ARG_WITH
dnl usage: WX_ARG_ENABLE(option, helpmessage, variable-name)
AC_DEFUN([WX_ARG_ENABLE],
        [
          AC_MSG_CHECKING([for --enable-$1])
          no_cache=0
          AC_ARG_ENABLE($1, [$2],
                        [
                          if test "$enableval" = yes; then
                            ac_cv_use_$1='$3=yes'
                          else
                            ac_cv_use_$1='$3=no'
                          fi
                        ],
                        [
                          LINE=`grep "$3" ${wx_arg_cache_file}`
                          if test "x$LINE" != x ; then
                            eval "DEFAULT_$LINE"
                          else
                            no_cache=1
                          fi

                          ac_cv_use_$1='$3='$DEFAULT_$3
                        ])

          eval "$ac_cv_use_$1"
          if test "$no_cache" != 1; then
            echo $ac_cv_use_$1 >> ${wx_arg_cache_file}.tmp
          fi

          if test "$$3" = yes; then
            AC_MSG_RESULT(yes)
          else
            AC_MSG_RESULT(no)
          fi
        ])


dnl ===========================================================================
dnl "3rd party" macros included here because they are not widely available
dnl ===========================================================================

dnl ---------------------------------------------------------------------------
dnl test for availability of iconv()
dnl ---------------------------------------------------------------------------

dnl From Bruno Haible.

AC_DEFUN([AM_ICONV],
[
  dnl Some systems have iconv in libc, some have it in libiconv (OSF/1 and
  dnl those with the standalone portable GNU libiconv installed).

  AC_ARG_WITH([libiconv-prefix],
[  --with-libiconv-prefix=DIR  search for libiconv in DIR/include and DIR/lib], [
    for dir in `echo "$withval" | tr : ' '`; do
      if test -d $dir/include; then CPPFLAGS="$CPPFLAGS -I$dir/include"; fi
      if test -d $dir/lib; then LDFLAGS="$LDFLAGS -L$dir/lib"; fi
    done
   ])

  AC_CACHE_CHECK(for iconv, am_cv_func_iconv, [
    am_cv_func_iconv="no, consider installing GNU libiconv"
    am_cv_lib_iconv=no
    AC_TRY_LINK([#include <stdlib.h>
#include <iconv.h>],
      [iconv_t cd = iconv_open("","");
       iconv(cd,NULL,NULL,NULL,NULL);
       iconv_close(cd);],
      am_cv_func_iconv=yes)
    if test "$am_cv_func_iconv" != yes; then
      am_save_LIBS="$LIBS"
      LIBS="$LIBS -liconv"
      AC_TRY_LINK([#include <stdlib.h>
#include <iconv.h>],
        [iconv_t cd = iconv_open("","");
         iconv(cd,NULL,NULL,NULL,NULL);
         iconv_close(cd);],
        am_cv_lib_iconv=yes
        am_cv_func_iconv=yes)
      LIBS="$am_save_LIBS"
    fi
  ])
  if test "$am_cv_func_iconv" = yes; then
    AC_DEFINE(HAVE_ICONV, 1, [Define if you have the iconv() function.])
    AC_CACHE_CHECK([if iconv needs const], wx_cv_func_iconv_const,
      AC_TRY_COMPILE([
#include <stdlib.h>
#include <iconv.h>
extern
#ifdef __cplusplus
"C"
#endif
#if defined(__STDC__) || defined(__cplusplus)
size_t iconv (iconv_t cd, char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);
#else
size_t iconv();
#endif
        ],
        [],
        wx_cv_func_iconv_const="no",
        wx_cv_func_iconv_const="yes"
      )
    )

    iconv_const=
    if test "x$wx_cv_func_iconv_const" = "xyes"; then
        iconv_const="const"
    fi

    AC_DEFINE_UNQUOTED(ICONV_CONST, $iconv_const,
      [Define as const if the declaration of iconv() needs const.])
  fi
  LIBICONV=
  if test "$am_cv_lib_iconv" = yes; then
    LIBICONV="-liconv"
  fi
  AC_SUBST(LIBICONV)
])

dnl ---------------------------------------------------------------------------
dnl AC_SYS_LARGEFILE (partly based on the code from autoconf 2.5x)
dnl ---------------------------------------------------------------------------

dnl WX_SYS_LARGEFILE_TEST
dnl
dnl NB: original autoconf test was checking if compiler supported 6 bit off_t
dnl     arithmetic properly but this failed miserably with gcc under Linux
dnl     whereas the system still supports 64 bit files, so now simply check
dnl     that off_t is big enough
define(WX_SYS_LARGEFILE_TEST,
[typedef struct {
    unsigned int field: sizeof(off_t) == 8;
} wxlf;
])


dnl WX_SYS_LARGEFILE_MACRO_VALUE(C-MACRO, VALUE, CACHE-VAR)
define(WX_SYS_LARGEFILE_MACRO_VALUE,
[
    AC_CACHE_CHECK([for $1 value needed for large files], [$3],
        [
          AC_TRY_COMPILE([#define $1 $2
                          #include <sys/types.h>],
                         WX_SYS_LARGEFILE_TEST,
                         [$3=$2],
                         [$3=no])
        ]
    )

    if test "$$3" != no; then
        wx_largefile=yes
        AC_DEFINE_UNQUOTED([$1], [$$3])
    fi
])


dnl AC_SYS_LARGEFILE
dnl ----------------
dnl By default, many hosts won't let programs access large files;
dnl one must use special compiler options to get large-file access to work.
dnl For more details about this brain damage please see:
dnl http://www.sas.com/standards/large.file/x_open.20Mar96.html
AC_DEFUN([AC_SYS_LARGEFILE],
[AC_ARG_ENABLE(largefile,
               [  --disable-largefile     omit support for large files])
if test "$enable_largefile" != no; then
    dnl _FILE_OFFSET_BITS==64 is needed for Linux, Solaris, ...
    dnl _LARGE_FILES -- for AIX
    wx_largefile=no
    WX_SYS_LARGEFILE_MACRO_VALUE(_FILE_OFFSET_BITS, 64, ac_cv_sys_file_offset_bits)
    if test "x$wx_largefile" != "xyes"; then
        WX_SYS_LARGEFILE_MACRO_VALUE(_LARGE_FILES, 1, ac_cv_sys_large_files)
    fi

    AC_MSG_CHECKING(if large file support is available)
    if test "x$wx_largefile" = "xyes"; then
        AC_DEFINE(HAVE_LARGEFILE_SUPPORT)
    fi
    AC_MSG_RESULT($wx_largefile)
fi
])
Commit	Line	Data
b040e242 VS	1	dnl ---------------------------------------------------------------------------
	2	dnl
	3	dnl Macros for configure.in for wxWindows by Robert Roebling, Phil Blecker,
	4	dnl Vadim Zeitlin and Ron Lee
	5	dnl
	6	dnl This script is under the wxWindows licence.
	7	dnl
	8	dnl Version: $Id$
	9	dnl ---------------------------------------------------------------------------
	10
	11	dnl ===========================================================================
	12	dnl macros to find the a file in the list of include/lib paths
	13	dnl ===========================================================================
	14
	15	dnl ---------------------------------------------------------------------------
	16	dnl call WX_PATH_FIND_INCLUDES(search path, header name), sets ac_find_includes
	17	dnl to the full name of the file that was found or leaves it empty if not found
	18	dnl ---------------------------------------------------------------------------
	19	AC_DEFUN([WX_PATH_FIND_INCLUDES],
	20	[
	21	ac_find_includes=
	22	for ac_dir in $1;
	23	do
	24	if test -f "$ac_dir/$2"; then
	25	ac_find_includes=$ac_dir
	26	break
	27	fi
	28	done
	29	])
	30
	31	dnl ---------------------------------------------------------------------------
	32	dnl call WX_PATH_FIND_LIBRARIES(search path, header name), sets ac_find_libraries
	33	dnl to the full name of the file that was found or leaves it empty if not found
	34	dnl ---------------------------------------------------------------------------
	35	AC_DEFUN([WX_PATH_FIND_LIBRARIES],
	36	[
	37	ac_find_libraries=
	38	for ac_dir in $1;
	39	do
	40	for ac_extension in a so sl dylib; do
	41	if test -f "$ac_dir/lib$2.$ac_extension"; then
	42	ac_find_libraries=$ac_dir
	43	break 2
	44	fi
	45	done
	46	done
	47	])
	48
	49	dnl ---------------------------------------------------------------------------
	50	dnl Path to include, already defined
	51	dnl ---------------------------------------------------------------------------
	52	AC_DEFUN([WX_INCLUDE_PATH_EXIST],
	53	[
	54	ac_path_to_include=$1
	55	echo "$2" \| grep "\-I$1" > /dev/null
	56	result=$?
	57	if test $result = 0; then
	58	ac_path_to_include=""
	59	else
	60	ac_path_to_include=" -I$1"
	61	fi
	62	])
	63
	64	dnl ---------------------------------------------------------------------------
65	dnl Path to link, already defined
66	dnl ---------------------------------------------------------------------------
67	AC_DEFUN([WX_LINK_PATH_EXIST],
68	[
69	echo "$2" \| grep "\-L$1" > /dev/null
70	result=$?
71	if test $result = 0; then
72	ac_path_to_link=""
73	else
74	ac_path_to_link=" -L$1"
75	fi
76	])
77
78	dnl ===========================================================================
79	dnl C++ features test
80	dnl ===========================================================================
81
82	dnl ---------------------------------------------------------------------------
83	dnl WX_CPP_NEW_HEADERS checks whether the compiler has "new" <iostream> header
84	dnl or only the old <iostream.h> one - it may be generally assumed that if
85	dnl <iostream> exists, the other "new" headers (without .h) exist too.
86	dnl
87	dnl call WX_CPP_NEW_HEADERS(actiof-if-true, action-if-false-or-cross-compiling)
88	dnl ---------------------------------------------------------------------------
89
90	AC_DEFUN([WX_CPP_NEW_HEADERS],
91	[
92	if test "$cross_compiling" = "yes"; then
93	ifelse([$2], , :, [$2])
94	else
95	AC_LANG_SAVE
96	AC_LANG_CPLUSPLUS
97
98	AC_CHECK_HEADERS(iostream)
99
100	if test "$ac_cv_header_iostream" = "yes" ; then
101	ifelse([$1], , :, [$1])
102	else
103	ifelse([$2], , :, [$2])
104	fi
105
106	AC_LANG_RESTORE
107	fi
108	])
109
110	dnl ---------------------------------------------------------------------------
111	dnl WX_CPP_BOOL checks whether the C++ compiler has a built in bool type
112	dnl
113	dnl call WX_CPP_BOOL - will define HAVE_BOOL if the compiler supports bool
114	dnl ---------------------------------------------------------------------------
115
116	AC_DEFUN([WX_CPP_BOOL],
117	[
118	AC_CACHE_CHECK([if C++ compiler supports bool], wx_cv_cpp_bool,
119	[
120	AC_LANG_SAVE
121	AC_LANG_CPLUSPLUS
122
123	AC_TRY_COMPILE(
124	[
125	],
126	[
127	bool b = true;
128
129	return 0;
130	],
131	[
132	wx_cv_cpp_bool=yes
133	],
134	[
135	wx_cv_cpp_bool=no
136	]
137	)
138
139	AC_LANG_RESTORE
140	])
141
142	if test "$wx_cv_cpp_bool" = "yes"; then
143	AC_DEFINE(HAVE_BOOL)
144	fi
145	])
146
147	dnl ---------------------------------------------------------------------------
148	dnl a slightly better AC_C_BIGENDIAN macro which allows cross-compiling
149	dnl ---------------------------------------------------------------------------
150
151	AC_DEFUN([WX_C_BIGENDIAN],
152	[AC_CACHE_CHECK([whether byte ordering is bigendian], ac_cv_c_bigendian,
153	[ac_cv_c_bigendian=unknown
154	# See if sys/param.h defines the BYTE_ORDER macro.
155	AC_TRY_COMPILE([#include <sys/types.h>
156	#include <sys/param.h>], [
157	#if !BYTE_ORDER \|\| !BIG_ENDIAN \|\| !LITTLE_ENDIAN
158	bogus endian macros
159	#endif], [# It does; now see whether it defined to BIG_ENDIAN or not.
160	AC_TRY_COMPILE([#include <sys/types.h>
161	#include <sys/param.h>], [
162	#if BYTE_ORDER != BIG_ENDIAN
163	not big endian
164	#endif], ac_cv_c_bigendian=yes, ac_cv_c_bigendian=no)])
165	if test $ac_cv_c_bigendian = unknown; then
166	AC_TRY_RUN([main () {
167	/* Are we little or big endian? From Harbison&Steele. */
168	union
169	{
170	long l;
171	char c[sizeof (long)];
172	} u;
173	u.l = 1;
174	exit (u.c[sizeof (long) - 1] == 1);
175	}], [ac_cv_c_bigendian=no], [ac_cv_c_bigendian=yes], [ac_cv_c_bigendian=unknown])
176	fi])
177	if test $ac_cv_c_bigendian = unknown; then
178	AC_MSG_WARN([Assuming little-endian target machine - this may be overriden by adding the line "ac_cv_c_bigendian=${ac_cv_c_bigendian='yes'}" to config.cache file])
179	fi
180	if test $ac_cv_c_bigendian = yes; then
181	AC_DEFINE(WORDS_BIGENDIAN)
182	fi
183	])
184
185	dnl ---------------------------------------------------------------------------
186	dnl override AC_ARG_ENABLE/WITH to cache the results in .cache file
187	dnl ---------------------------------------------------------------------------
188
189	AC_DEFUN([WX_ARG_CACHE_INIT],
190	[
191	wx_arg_cache_file="configarg.cache"
192	echo "loading argument cache $wx_arg_cache_file"
193	rm -f ${wx_arg_cache_file}.tmp
194	touch ${wx_arg_cache_file}.tmp
195	touch ${wx_arg_cache_file}
196	])
197
198	AC_DEFUN([WX_ARG_CACHE_FLUSH],
199	[
200	echo "saving argument cache $wx_arg_cache_file"
201	mv ${wx_arg_cache_file}.tmp ${wx_arg_cache_file}
202	])
203
204	dnl this macro checks for a three-valued command line --with argument:
205	dnl possible arguments are 'yes', 'no', 'sys', or 'builtin'
206	dnl usage: WX_ARG_SYS_WITH(option, helpmessage, variable-name)
207	AC_DEFUN([WX_ARG_SYS_WITH],
208	[
209	AC_MSG_CHECKING([for --with-$1])
210	no_cache=0
211	AC_ARG_WITH($1, [$2],
212	[
213	if test "$withval" = yes; then
214	ac_cv_use_$1='$3=yes'
215	elif test "$withval" = no; then
216	ac_cv_use_$1='$3=no'
217	elif test "$withval" = sys; then
218	ac_cv_use_$1='$3=sys'
219	elif test "$withval" = builtin; then
220	ac_cv_use_$1='$3=builtin'
221	else
222	AC_MSG_ERROR([Invalid value for --with-$1: should be yes, no, sys, or builtin])
223	fi
224	],
225	[
226	LINE=`grep "$3" ${wx_arg_cache_file}`
227	if test "x$LINE" != x ; then
228	eval "DEFAULT_$LINE"
229	else
230	no_cache=1
231	fi
232
233	ac_cv_use_$1='$3='$DEFAULT_$3
234	])
235
236	eval "$ac_cv_use_$1"
237	if test "$no_cache" != 1; then
238	echo $ac_cv_use_$1 >> ${wx_arg_cache_file}.tmp
239	fi
240
241	if test "$$3" = yes; then
242	AC_MSG_RESULT(yes)
243	elif test "$$3" = no; then
244	AC_MSG_RESULT(no)
245	elif test "$$3" = sys; then
246	AC_MSG_RESULT([system version])
247	elif test "$$3" = builtin; then
248	AC_MSG_RESULT([builtin version])
249	else
250	AC_MSG_ERROR([Invalid value for --with-$1: should be yes, no, sys, or builtin])
251	fi
252	])
253
254	dnl this macro checks for a command line argument and caches the result
255	dnl usage: WX_ARG_WITH(option, helpmessage, variable-name)
256	AC_DEFUN([WX_ARG_WITH],
257	[
258	AC_MSG_CHECKING([for --with-$1])
259	no_cache=0
260	AC_ARG_WITH($1, [$2],
261	[
262	if test "$withval" = yes; then
263	ac_cv_use_$1='$3=yes'
264	else
265	ac_cv_use_$1='$3=no'
266	fi
267	],
268	[
269	LINE=`grep "$3" ${wx_arg_cache_file}`
270	if test "x$LINE" != x ; then
271	eval "DEFAULT_$LINE"
272	else
273	no_cache=1
274	fi
275
276	ac_cv_use_$1='$3='$DEFAULT_$3
277	])
278
279	eval "$ac_cv_use_$1"
280	if test "$no_cache" != 1; then
281	echo $ac_cv_use_$1 >> ${wx_arg_cache_file}.tmp
282	fi
283
284	if test "$$3" = yes; then
285	AC_MSG_RESULT(yes)
286	else
287	AC_MSG_RESULT(no)
288	fi
289	])
290
291	dnl like WX_ARG_WITH but uses AC_ARG_ENABLE instead of AC_ARG_WITH
292	dnl usage: WX_ARG_ENABLE(option, helpmessage, variable-name)
293	AC_DEFUN([WX_ARG_ENABLE],
294	[
295	AC_MSG_CHECKING([for --enable-$1])
296	no_cache=0
297	AC_ARG_ENABLE($1, [$2],
298	[
299	if test "$enableval" = yes; then
300	ac_cv_use_$1='$3=yes'
301	else
302	ac_cv_use_$1='$3=no'
303	fi
304	],
305	[
306	LINE=`grep "$3" ${wx_arg_cache_file}`
307	if test "x$LINE" != x ; then
308	eval "DEFAULT_$LINE"
309	else
310	no_cache=1
311	fi
312
313	ac_cv_use_$1='$3='$DEFAULT_$3
314	])
315
316	eval "$ac_cv_use_$1"
317	if test "$no_cache" != 1; then
318	echo $ac_cv_use_$1 >> ${wx_arg_cache_file}.tmp
319	fi
320
321	if test "$$3" = yes; then
322	AC_MSG_RESULT(yes)
323	else
324	AC_MSG_RESULT(no)
325	fi
326	])
327
328
329
330	dnl ===========================================================================
331	dnl "3rd party" macros included here because they are not widely available
332	dnl ===========================================================================
333
b040e242 VS	334	dnl ---------------------------------------------------------------------------
	335	dnl test for availability of iconv()
	336	dnl ---------------------------------------------------------------------------
	337
b040e242 VS	338	dnl From Bruno Haible.
	339
	340	AC_DEFUN([AM_ICONV],
	341	[
	342	dnl Some systems have iconv in libc, some have it in libiconv (OSF/1 and
	343	dnl those with the standalone portable GNU libiconv installed).
	344
	345	AC_ARG_WITH([libiconv-prefix],
	346	[ --with-libiconv-prefix=DIR search for libiconv in DIR/include and DIR/lib], [
	347	for dir in `echo "$withval" \| tr : ' '`; do
	348	if test -d $dir/include; then CPPFLAGS="$CPPFLAGS -I$dir/include"; fi
	349	if test -d $dir/lib; then LDFLAGS="$LDFLAGS -L$dir/lib"; fi
	350	done
	351	])
	352
	353	AC_CACHE_CHECK(for iconv, am_cv_func_iconv, [
	354	am_cv_func_iconv="no, consider installing GNU libiconv"
	355	am_cv_lib_iconv=no
	356	AC_TRY_LINK([#include <stdlib.h>
	357	#include <iconv.h>],
	358	[iconv_t cd = iconv_open("","");
	359	iconv(cd,NULL,NULL,NULL,NULL);
	360	iconv_close(cd);],
	361	am_cv_func_iconv=yes)
	362	if test "$am_cv_func_iconv" != yes; then
	363	am_save_LIBS="$LIBS"
	364	LIBS="$LIBS -liconv"
	365	AC_TRY_LINK([#include <stdlib.h>
	366	#include <iconv.h>],
	367	[iconv_t cd = iconv_open("","");
	368	iconv(cd,NULL,NULL,NULL,NULL);
	369	iconv_close(cd);],
	370	am_cv_lib_iconv=yes
	371	am_cv_func_iconv=yes)
	372	LIBS="$am_save_LIBS"
	373	fi
	374	])
	375	if test "$am_cv_func_iconv" = yes; then
	376	AC_DEFINE(HAVE_ICONV, 1, [Define if you have the iconv() function.])
b7043674	377	AC_CACHE_CHECK([if iconv needs const], wx_cv_func_iconv_const,
b040e242 VS	378	AC_TRY_COMPILE([
	379	#include <stdlib.h>
	380	#include <iconv.h>
	381	extern
	382	#ifdef __cplusplus
	383	"C"
	384	#endif
	385	#if defined(__STDC__) \|\| defined(__cplusplus)
	386	size_t iconv (iconv_t cd, char * inbuf, size_t inbytesleft, char * outbuf, size_t outbytesleft);
	387	#else
	388	size_t iconv();
	389	#endif
b7043674 VZ	390	],
	391	[],
	392	wx_cv_func_iconv_const="no",
	393	wx_cv_func_iconv_const="yes"
	394	)
	395	)
	396
	397	iconv_const=
1c405bb5	398	if test "x$wx_cv_func_iconv_const" = "xyes"; then
b7043674 VZ	399	iconv_const="const"
	400	fi
	401
	402	AC_DEFINE_UNQUOTED(ICONV_CONST, $iconv_const,
b040e242 VS	403	[Define as const if the declaration of iconv() needs const.])
	404	fi
	405	LIBICONV=
	406	if test "$am_cv_lib_iconv" = yes; then
	407	LIBICONV="-liconv"
	408	fi
	409	AC_SUBST(LIBICONV)
	410	])
	411
90dd450c VZ	412	dnl ---------------------------------------------------------------------------
	413	dnl AC_SYS_LARGEFILE (partly based on the code from autoconf 2.5x)
	414	dnl ---------------------------------------------------------------------------
	415
	416	dnl WX_SYS_LARGEFILE_TEST
	417	dnl
	418	dnl NB: original autoconf test was checking if compiler supported 6 bit off_t
	419	dnl arithmetic properly but this failed miserably with gcc under Linux
	420	dnl whereas the system still supports 64 bit files, so now simply check
	421	dnl that off_t is big enough
	422	define(WX_SYS_LARGEFILE_TEST,
	423	[typedef struct {
	424	unsigned int field: sizeof(off_t) == 8;
	425	} wxlf;
	426	])
	427
	428
	429	dnl WX_SYS_LARGEFILE_MACRO_VALUE(C-MACRO, VALUE, CACHE-VAR)
	430	define(WX_SYS_LARGEFILE_MACRO_VALUE,
	431	[
	432	AC_CACHE_CHECK([for $1 value needed for large files], [$3],
	433	[
	434	AC_TRY_COMPILE([#define $1 $2
	435	#include <sys/types.h>],
	436	WX_SYS_LARGEFILE_TEST,
	437	[$3=$2],
	438	[$3=no])
	439	]
	440	)
	441
	442	if test "$$3" != no; then
5a5d3c08	443	wx_largefile=yes
90dd450c VZ	444	AC_DEFINE_UNQUOTED([$1], [$$3])
	445	fi
	446	])
	447
	448
	449	dnl AC_SYS_LARGEFILE
	450	dnl ----------------
	451	dnl By default, many hosts won't let programs access large files;
	452	dnl one must use special compiler options to get large-file access to work.
	453	dnl For more details about this brain damage please see:
	454	dnl http://www.sas.com/standards/large.file/x_open.20Mar96.html
	455	AC_DEFUN([AC_SYS_LARGEFILE],
	456	[AC_ARG_ENABLE(largefile,
	457	[ --disable-largefile omit support for large files])
	458	if test "$enable_largefile" != no; then
	459	dnl _FILE_OFFSET_BITS==64 is needed for Linux, Solaris, ...
	460	dnl _LARGE_FILES -- for AIX
5a5d3c08	461	wx_largefile=no
90dd450c VZ	462	WX_SYS_LARGEFILE_MACRO_VALUE(_FILE_OFFSET_BITS, 64, ac_cv_sys_file_offset_bits)
	463	if test "x$wx_largefile" != "xyes"; then
	464	WX_SYS_LARGEFILE_MACRO_VALUE(_LARGE_FILES, 1, ac_cv_sys_large_files)
	465	fi
	466
5a5d3c08	467	AC_MSG_CHECKING(if large file support is available)
90dd450c VZ	468	if test "x$wx_largefile" = "xyes"; then
	469	AC_DEFINE(HAVE_LARGEFILE_SUPPORT)
	470	fi
5a5d3c08	471	AC_MSG_RESULT($wx_largefile)
90dd450c VZ	472	fi
90dd450c VZ	473	])