[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 /usr/include;
  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 /usr/lib;
  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],
[
  dnl never add -I/usr/include to the CPPFLAGS
  if test "x$1" = "x/usr/include"; then
    ac_path_to_include=""
  else
    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
  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 WX_CPP_EXPLICIT checks whether the C++ compiler support the explicit
dnl keyword and defines HAVE_EXPLICIT if this is the case
dnl ---------------------------------------------------------------------------

AC_DEFUN([WX_CPP_EXPLICIT],
[
  AC_CACHE_CHECK([if C++ compiler supports the explicit keyword],
                 wx_cv_explicit,
  [
    AC_LANG_SAVE
    AC_LANG_CPLUSPLUS

    dnl do the test in 2 steps: first check that the compiler knows about the
    dnl explicit keyword at all and then verify that it really honours it
    AC_TRY_COMPILE(
      [
        class Foo { public: explicit Foo(int) {} };
      ],
      [
        return 0;
      ],
      [
        AC_TRY_COMPILE(
            [
                class Foo { public: explicit Foo(int) {} };
                static void TakeFoo(const Foo& foo) { }
            ],
            [
                TakeFoo(17);
                return 0;
            ],
            wx_cv_explicit=no,
            wx_cv_explicit=yes
        )
      ],
      wx_cv_explicit=no
    )

    AC_LANG_RESTORE
  ])

  if test "$wx_cv_explicit" = "yes"; then
    AC_DEFINE(HAVE_EXPLICIT)
  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, enablestring)
dnl
dnl enablestring is a hack and allows to show "checking for --disable-foo"
dnl message when running configure instead of the default "checking for
dnl --enable-foo" one whih is useful for the options enabled by default
AC_DEFUN([WX_ARG_ENABLE],
        [
	  enablestring=$4
          AC_MSG_CHECKING([for --${enablestring:-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 Linker features test
dnl ===========================================================================

dnl ---------------------------------------------------------------------------
dnl WX_VERSIONED_SYMBOLS checks whether the linker can create versioned
dnl symbols. If it can, sets LDFLAGS_VERSIONING to $CXX flags needed to use
dnl version script file named versionfile
dnl
dnl call WX_VERSIONED_SYMBOLS(versionfile)
dnl ---------------------------------------------------------------------------
AC_DEFUN([WX_VERSIONED_SYMBOLS],
[
  found_versioning=no

  dnl Check for known non-gcc cases:
  case "${host}" in
    *-*-solaris2* )
      if test "x$GCC" != "xyes" ; then
          LDFLAGS_VERSIONING="-M $1"
          found_versioning=yes
      fi
    ;;
  esac
  
  dnl Generic check for GCC or GCC-like behaviour (Intel C++, GCC):
  if test $found_versioning = no ; then
      AC_CACHE_CHECK([if the linker accepts --version-script], wx_cv_version_script,
      [
        echo "VER_1 { *; };" >conftest.sym
        echo "int main() { return 0; }" >conftest.cpp
  
        if AC_TRY_COMMAND([
                $CXX -o conftest.output $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.cpp
                -Wl,--version-script,conftest.sym >/dev/null 2>conftest.stderr]) ; then
          if test -s conftest.stderr ; then
              wx_cv_version_script=no
          else
              wx_cv_version_script=yes
          fi
        else
          wx_cv_version_script=no
        fi
        rm -f conftest.output conftest.stderr conftest.sym conftest.cpp
      ])
      if test $wx_cv_version_script = yes ; then
        LDFLAGS_VERSIONING="-Wl,--version-script,$1"
      fi
  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=
2b5f62a0	22	for ac_dir in $1 /usr/include;
b040e242 VS	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=
2b5f62a0	38	for ac_dir in $1 /usr/lib;
b040e242 VS	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	[
2b5f62a0 VZ	54	dnl never add -I/usr/include to the CPPFLAGS
2b5f62a0 VZ	55	if test "x$1" = "x/usr/include"; then
b040e242 VS	56	ac_path_to_include=""
b040e242 VS	57	else
2b5f62a0 VZ	58	echo "$2" \| grep "\-I$1" > /dev/null
	59	result=$?
	60	if test $result = 0; then
	61	ac_path_to_include=""
	62	else
	63	ac_path_to_include=" -I$1"
	64	fi
b040e242 VS	65	fi
	66	])
	67
	68	dnl ---------------------------------------------------------------------------
	69	dnl Path to link, already defined
	70	dnl ---------------------------------------------------------------------------
	71	AC_DEFUN([WX_LINK_PATH_EXIST],
	72	[
	73	echo "$2" \| grep "\-L$1" > /dev/null
	74	result=$?
	75	if test $result = 0; then
	76	ac_path_to_link=""
	77	else
	78	ac_path_to_link=" -L$1"
	79	fi
	80	])
	81
	82	dnl ===========================================================================
	83	dnl C++ features test
	84	dnl ===========================================================================
	85
	86	dnl ---------------------------------------------------------------------------
	87	dnl WX_CPP_NEW_HEADERS checks whether the compiler has "new" <iostream> header
	88	dnl or only the old <iostream.h> one - it may be generally assumed that if
	89	dnl <iostream> exists, the other "new" headers (without .h) exist too.
	90	dnl
	91	dnl call WX_CPP_NEW_HEADERS(actiof-if-true, action-if-false-or-cross-compiling)
	92	dnl ---------------------------------------------------------------------------
	93
	94	AC_DEFUN([WX_CPP_NEW_HEADERS],
	95	[
	96	if test "$cross_compiling" = "yes"; then
	97	ifelse([$2], , :, [$2])
	98	else
	99	AC_LANG_SAVE
	100	AC_LANG_CPLUSPLUS
	101
	102	AC_CHECK_HEADERS(iostream)
	103
	104	if test "$ac_cv_header_iostream" = "yes" ; then
	105	ifelse([$1], , :, [$1])
	106	else
	107	ifelse([$2], , :, [$2])
	108	fi
	109
	110	AC_LANG_RESTORE
	111	fi
	112	])
	113
	114	dnl ---------------------------------------------------------------------------
	115	dnl WX_CPP_BOOL checks whether the C++ compiler has a built in bool type
	116	dnl
	117	dnl call WX_CPP_BOOL - will define HAVE_BOOL if the compiler supports bool
	118	dnl ---------------------------------------------------------------------------
	119
	120	AC_DEFUN([WX_CPP_BOOL],
	121	[
	122	AC_CACHE_CHECK([if C++ compiler supports bool], wx_cv_cpp_bool,
	123	[
	124	AC_LANG_SAVE
	125	AC_LANG_CPLUSPLUS
	126
	127	AC_TRY_COMPILE(
	128	[
129	],
130	[
131	bool b = true;
132
133	return 0;
134	],
135	[
136	wx_cv_cpp_bool=yes
137	],
138	[
139	wx_cv_cpp_bool=no
140	]
141	)
142
143	AC_LANG_RESTORE
144	])
145
146	if test "$wx_cv_cpp_bool" = "yes"; then
147	AC_DEFINE(HAVE_BOOL)
148	fi
149	])
150
986ecc86 VZ	151	dnl ---------------------------------------------------------------------------
	152	dnl WX_CPP_EXPLICIT checks whether the C++ compiler support the explicit
	153	dnl keyword and defines HAVE_EXPLICIT if this is the case
	154	dnl ---------------------------------------------------------------------------
	155
	156	AC_DEFUN([WX_CPP_EXPLICIT],
	157	[
	158	AC_CACHE_CHECK([if C++ compiler supports the explicit keyword],
	159	wx_cv_explicit,
	160	[
	161	AC_LANG_SAVE
	162	AC_LANG_CPLUSPLUS
	163
	164	dnl do the test in 2 steps: first check that the compiler knows about the
	165	dnl explicit keyword at all and then verify that it really honours it
	166	AC_TRY_COMPILE(
	167	[
	168	class Foo { public: explicit Foo(int) {} };
	169	],
	170	[
	171	return 0;
	172	],
	173	[
	174	AC_TRY_COMPILE(
	175	[
	176	class Foo { public: explicit Foo(int) {} };
	177	static void TakeFoo(const Foo& foo) { }
	178	],
	179	[
	180	TakeFoo(17);
	181	return 0;
	182	],
	183	wx_cv_explicit=no,
	184	wx_cv_explicit=yes
	185	)
	186	],
	187	wx_cv_explicit=no
	188	)
	189
	190	AC_LANG_RESTORE
	191	])
	192
	193	if test "$wx_cv_explicit" = "yes"; then
	194	AC_DEFINE(HAVE_EXPLICIT)
	195	fi
	196	])
	197
b040e242 VS	198	dnl ---------------------------------------------------------------------------
	199	dnl a slightly better AC_C_BIGENDIAN macro which allows cross-compiling
	200	dnl ---------------------------------------------------------------------------
	201
	202	AC_DEFUN([WX_C_BIGENDIAN],
	203	[AC_CACHE_CHECK([whether byte ordering is bigendian], ac_cv_c_bigendian,
	204	[ac_cv_c_bigendian=unknown
	205	# See if sys/param.h defines the BYTE_ORDER macro.
	206	AC_TRY_COMPILE([#include <sys/types.h>
	207	#include <sys/param.h>], [
	208	#if !BYTE_ORDER \|\| !BIG_ENDIAN \|\| !LITTLE_ENDIAN
	209	bogus endian macros
	210	#endif], [# It does; now see whether it defined to BIG_ENDIAN or not.
	211	AC_TRY_COMPILE([#include <sys/types.h>
	212	#include <sys/param.h>], [
	213	#if BYTE_ORDER != BIG_ENDIAN
	214	not big endian
	215	#endif], ac_cv_c_bigendian=yes, ac_cv_c_bigendian=no)])
	216	if test $ac_cv_c_bigendian = unknown; then
	217	AC_TRY_RUN([main () {
	218	/* Are we little or big endian? From Harbison&Steele. */
	219	union
	220	{
	221	long l;
	222	char c[sizeof (long)];
	223	} u;
	224	u.l = 1;
	225	exit (u.c[sizeof (long) - 1] == 1);
	226	}], [ac_cv_c_bigendian=no], [ac_cv_c_bigendian=yes], [ac_cv_c_bigendian=unknown])
	227	fi])
	228	if test $ac_cv_c_bigendian = unknown; then
	229	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])
	230	fi
	231	if test $ac_cv_c_bigendian = yes; then
	232	AC_DEFINE(WORDS_BIGENDIAN)
	233	fi
	234	])
	235
	236	dnl ---------------------------------------------------------------------------
	237	dnl override AC_ARG_ENABLE/WITH to cache the results in .cache file
	238	dnl ---------------------------------------------------------------------------
	239
	240	AC_DEFUN([WX_ARG_CACHE_INIT],
	241	[
	242	wx_arg_cache_file="configarg.cache"
	243	echo "loading argument cache $wx_arg_cache_file"
	244	rm -f ${wx_arg_cache_file}.tmp
	245	touch ${wx_arg_cache_file}.tmp
	246	touch ${wx_arg_cache_file}
	247	])
	248
	249	AC_DEFUN([WX_ARG_CACHE_FLUSH],
	250	[
	251	echo "saving argument cache $wx_arg_cache_file"
	252	mv ${wx_arg_cache_file}.tmp ${wx_arg_cache_file}
	253	])
	254
	255	dnl this macro checks for a three-valued command line --with argument:
	256	dnl possible arguments are 'yes', 'no', 'sys', or 'builtin'
	257	dnl usage: WX_ARG_SYS_WITH(option, helpmessage, variable-name)
	258	AC_DEFUN([WX_ARG_SYS_WITH],
	259	[
	260	AC_MSG_CHECKING([for --with-$1])
	261	no_cache=0
262	AC_ARG_WITH($1, [$2],
263	[
264	if test "$withval" = yes; then
265	ac_cv_use_$1='$3=yes'
266	elif test "$withval" = no; then
267	ac_cv_use_$1='$3=no'
268	elif test "$withval" = sys; then
269	ac_cv_use_$1='$3=sys'
270	elif test "$withval" = builtin; then
271	ac_cv_use_$1='$3=builtin'
272	else
273	AC_MSG_ERROR([Invalid value for --with-$1: should be yes, no, sys, or builtin])
274	fi
275	],
276	[
277	LINE=`grep "$3" ${wx_arg_cache_file}`
278	if test "x$LINE" != x ; then
279	eval "DEFAULT_$LINE"
280	else
281	no_cache=1
282	fi
283
284	ac_cv_use_$1='$3='$DEFAULT_$3
285	])
286
287	eval "$ac_cv_use_$1"
288	if test "$no_cache" != 1; then
289	echo $ac_cv_use_$1 >> ${wx_arg_cache_file}.tmp
290	fi
291
292	if test "$$3" = yes; then
293	AC_MSG_RESULT(yes)
294	elif test "$$3" = no; then
295	AC_MSG_RESULT(no)
296	elif test "$$3" = sys; then
297	AC_MSG_RESULT([system version])
298	elif test "$$3" = builtin; then
299	AC_MSG_RESULT([builtin version])
300	else
301	AC_MSG_ERROR([Invalid value for --with-$1: should be yes, no, sys, or builtin])
302	fi
303	])
304
305	dnl this macro checks for a command line argument and caches the result
306	dnl usage: WX_ARG_WITH(option, helpmessage, variable-name)
307	AC_DEFUN([WX_ARG_WITH],
308	[
309	AC_MSG_CHECKING([for --with-$1])
310	no_cache=0
311	AC_ARG_WITH($1, [$2],
312	[
313	if test "$withval" = yes; then
314	ac_cv_use_$1='$3=yes'
315	else
316	ac_cv_use_$1='$3=no'
317	fi
318	],
319	[
320	LINE=`grep "$3" ${wx_arg_cache_file}`
321	if test "x$LINE" != x ; then
322	eval "DEFAULT_$LINE"
323	else
324	no_cache=1
325	fi
326
327	ac_cv_use_$1='$3='$DEFAULT_$3
328	])
329
330	eval "$ac_cv_use_$1"
331	if test "$no_cache" != 1; then
332	echo $ac_cv_use_$1 >> ${wx_arg_cache_file}.tmp
333	fi
334
335	if test "$$3" = yes; then
336	AC_MSG_RESULT(yes)
337	else
338	AC_MSG_RESULT(no)
339	fi
340	])
341
342	dnl like WX_ARG_WITH but uses AC_ARG_ENABLE instead of AC_ARG_WITH
5005acfe VZ	343	dnl usage: WX_ARG_ENABLE(option, helpmessage, variable-name, enablestring)
	344	dnl
	345	dnl enablestring is a hack and allows to show "checking for --disable-foo"
	346	dnl message when running configure instead of the default "checking for
	347	dnl --enable-foo" one whih is useful for the options enabled by default
b040e242 VS	348	AC_DEFUN([WX_ARG_ENABLE],
b040e242 VS	349	[
5005acfe VZ	350	enablestring=$4
5005acfe VZ	351	AC_MSG_CHECKING([for --${enablestring:-enable}-$1])
b040e242 VS	352	no_cache=0
	353	AC_ARG_ENABLE($1, [$2],
	354	[
	355	if test "$enableval" = yes; then
	356	ac_cv_use_$1='$3=yes'
	357	else
	358	ac_cv_use_$1='$3=no'
	359	fi
	360	],
	361	[
	362	LINE=`grep "$3" ${wx_arg_cache_file}`
	363	if test "x$LINE" != x ; then
	364	eval "DEFAULT_$LINE"
	365	else
	366	no_cache=1
	367	fi
	368
	369	ac_cv_use_$1='$3='$DEFAULT_$3
	370	])
	371
	372	eval "$ac_cv_use_$1"
	373	if test "$no_cache" != 1; then
	374	echo $ac_cv_use_$1 >> ${wx_arg_cache_file}.tmp
	375	fi
	376
	377	if test "$$3" = yes; then
	378	AC_MSG_RESULT(yes)
	379	else
	380	AC_MSG_RESULT(no)
	381	fi
	382	])
	383
	384
2b5f62a0 VZ	385	dnl ===========================================================================
	386	dnl Linker features test
	387	dnl ===========================================================================
	388
	389	dnl ---------------------------------------------------------------------------
	390	dnl WX_VERSIONED_SYMBOLS checks whether the linker can create versioned
	391	dnl symbols. If it can, sets LDFLAGS_VERSIONING to $CXX flags needed to use
	392	dnl version script file named versionfile
	393	dnl
	394	dnl call WX_VERSIONED_SYMBOLS(versionfile)
	395	dnl ---------------------------------------------------------------------------
	396	AC_DEFUN([WX_VERSIONED_SYMBOLS],
	397	[
	398	found_versioning=no
	399
	400	dnl Check for known non-gcc cases:
	401	case "${host}" in
	402	--solaris2* )
	403	if test "x$GCC" != "xyes" ; then
	404	LDFLAGS_VERSIONING="-M $1"
	405	found_versioning=yes
	406	fi
	407	;;
	408	esac
	409
	410	dnl Generic check for GCC or GCC-like behaviour (Intel C++, GCC):
	411	if test $found_versioning = no ; then
	412	AC_CACHE_CHECK([if the linker accepts --version-script], wx_cv_version_script,
	413	[
	414	echo "VER_1 { *; };" >conftest.sym
	415	echo "int main() { return 0; }" >conftest.cpp
	416
	417	if AC_TRY_COMMAND([
	418	$CXX -o conftest.output $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.cpp
	419	-Wl,--version-script,conftest.sym >/dev/null 2>conftest.stderr]) ; then
	420	if test -s conftest.stderr ; then
	421	wx_cv_version_script=no
	422	else
	423	wx_cv_version_script=yes
	424	fi
	425	else
	426	wx_cv_version_script=no
	427	fi
	428	rm -f conftest.output conftest.stderr conftest.sym conftest.cpp
	429	])
	430	if test $wx_cv_version_script = yes ; then
	431	LDFLAGS_VERSIONING="-Wl,--version-script,$1"
	432	fi
	433	fi
	434	])
	435
b040e242 VS	436
	437	dnl ===========================================================================
	438	dnl "3rd party" macros included here because they are not widely available
	439	dnl ===========================================================================
	440
b040e242 VS	441	dnl ---------------------------------------------------------------------------
	442	dnl test for availability of iconv()
	443	dnl ---------------------------------------------------------------------------
	444
b040e242 VS	445	dnl From Bruno Haible.
	446
	447	AC_DEFUN([AM_ICONV],
	448	[
	449	dnl Some systems have iconv in libc, some have it in libiconv (OSF/1 and
	450	dnl those with the standalone portable GNU libiconv installed).
	451
	452	AC_ARG_WITH([libiconv-prefix],
	453	[ --with-libiconv-prefix=DIR search for libiconv in DIR/include and DIR/lib], [
	454	for dir in `echo "$withval" \| tr : ' '`; do
	455	if test -d $dir/include; then CPPFLAGS="$CPPFLAGS -I$dir/include"; fi
	456	if test -d $dir/lib; then LDFLAGS="$LDFLAGS -L$dir/lib"; fi
	457	done
	458	])
	459
	460	AC_CACHE_CHECK(for iconv, am_cv_func_iconv, [
	461	am_cv_func_iconv="no, consider installing GNU libiconv"
	462	am_cv_lib_iconv=no
	463	AC_TRY_LINK([#include <stdlib.h>
	464	#include <iconv.h>],
	465	[iconv_t cd = iconv_open("","");
	466	iconv(cd,NULL,NULL,NULL,NULL);
	467	iconv_close(cd);],
	468	am_cv_func_iconv=yes)
	469	if test "$am_cv_func_iconv" != yes; then
	470	am_save_LIBS="$LIBS"
	471	LIBS="$LIBS -liconv"
	472	AC_TRY_LINK([#include <stdlib.h>
	473	#include <iconv.h>],
	474	[iconv_t cd = iconv_open("","");
	475	iconv(cd,NULL,NULL,NULL,NULL);
	476	iconv_close(cd);],
	477	am_cv_lib_iconv=yes
	478	am_cv_func_iconv=yes)
	479	LIBS="$am_save_LIBS"
	480	fi
	481	])
	482	if test "$am_cv_func_iconv" = yes; then
	483	AC_DEFINE(HAVE_ICONV, 1, [Define if you have the iconv() function.])
b7043674	484	AC_CACHE_CHECK([if iconv needs const], wx_cv_func_iconv_const,
b040e242 VS	485	AC_TRY_COMPILE([
	486	#include <stdlib.h>
	487	#include <iconv.h>
	488	extern
	489	#ifdef __cplusplus
	490	"C"
	491	#endif
	492	#if defined(__STDC__) \|\| defined(__cplusplus)
	493	size_t iconv (iconv_t cd, char * inbuf, size_t inbytesleft, char * outbuf, size_t outbytesleft);
	494	#else
	495	size_t iconv();
	496	#endif
b7043674 VZ	497	],
	498	[],
	499	wx_cv_func_iconv_const="no",
	500	wx_cv_func_iconv_const="yes"
	501	)
	502	)
	503
	504	iconv_const=
1c405bb5	505	if test "x$wx_cv_func_iconv_const" = "xyes"; then
b7043674 VZ	506	iconv_const="const"
	507	fi
	508
	509	AC_DEFINE_UNQUOTED(ICONV_CONST, $iconv_const,
b040e242 VS	510	[Define as const if the declaration of iconv() needs const.])
	511	fi
	512	LIBICONV=
	513	if test "$am_cv_lib_iconv" = yes; then
	514	LIBICONV="-liconv"
	515	fi
	516	AC_SUBST(LIBICONV)
	517	])
	518
90dd450c VZ	519	dnl ---------------------------------------------------------------------------
	520	dnl AC_SYS_LARGEFILE (partly based on the code from autoconf 2.5x)
	521	dnl ---------------------------------------------------------------------------
	522
	523	dnl WX_SYS_LARGEFILE_TEST
	524	dnl
	525	dnl NB: original autoconf test was checking if compiler supported 6 bit off_t
	526	dnl arithmetic properly but this failed miserably with gcc under Linux
	527	dnl whereas the system still supports 64 bit files, so now simply check
	528	dnl that off_t is big enough
	529	define(WX_SYS_LARGEFILE_TEST,
	530	[typedef struct {
	531	unsigned int field: sizeof(off_t) == 8;
	532	} wxlf;
	533	])
	534
	535
	536	dnl WX_SYS_LARGEFILE_MACRO_VALUE(C-MACRO, VALUE, CACHE-VAR)
	537	define(WX_SYS_LARGEFILE_MACRO_VALUE,
	538	[
	539	AC_CACHE_CHECK([for $1 value needed for large files], [$3],
	540	[
	541	AC_TRY_COMPILE([#define $1 $2
	542	#include <sys/types.h>],
	543	WX_SYS_LARGEFILE_TEST,
	544	[$3=$2],
	545	[$3=no])
	546	]
	547	)
	548
	549	if test "$$3" != no; then
5a5d3c08	550	wx_largefile=yes
90dd450c VZ	551	AC_DEFINE_UNQUOTED([$1], [$$3])
	552	fi
	553	])
	554
	555
	556	dnl AC_SYS_LARGEFILE
	557	dnl ----------------
	558	dnl By default, many hosts won't let programs access large files;
	559	dnl one must use special compiler options to get large-file access to work.
	560	dnl For more details about this brain damage please see:
	561	dnl http://www.sas.com/standards/large.file/x_open.20Mar96.html
	562	AC_DEFUN([AC_SYS_LARGEFILE],
	563	[AC_ARG_ENABLE(largefile,
	564	[ --disable-largefile omit support for large files])
	565	if test "$enable_largefile" != no; then
	566	dnl _FILE_OFFSET_BITS==64 is needed for Linux, Solaris, ...
	567	dnl _LARGE_FILES -- for AIX
5a5d3c08	568	wx_largefile=no
90dd450c VZ	569	WX_SYS_LARGEFILE_MACRO_VALUE(_FILE_OFFSET_BITS, 64, ac_cv_sys_file_offset_bits)
	570	if test "x$wx_largefile" != "xyes"; then
	571	WX_SYS_LARGEFILE_MACRO_VALUE(_LARGE_FILES, 1, ac_cv_sys_large_files)
	572	fi
	573
5a5d3c08	574	AC_MSG_CHECKING(if large file support is available)
90dd450c VZ	575	if test "x$wx_largefile" = "xyes"; then
	576	AC_DEFINE(HAVE_LARGEFILE_SUPPORT)
	577	fi
5a5d3c08	578	AC_MSG_RESULT($wx_largefile)
90dd450c VZ	579	fi
90dd450c VZ	580	])