| dnl Macros used to build the Wine configure script | |
| dnl | |
| dnl Copyright 2002 Alexandre Julliard | |
| dnl | |
| dnl This library is free software; you can redistribute it and/or | |
| dnl modify it under the terms of the GNU Lesser General Public | |
| dnl License as published by the Free Software Foundation; either | |
| dnl version 2.1 of the License, or (at your option) any later version. | |
| dnl | |
| dnl This library is distributed in the hope that it will be useful, | |
| dnl but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| dnl Lesser General Public License for more details. | |
| dnl | |
| dnl You should have received a copy of the GNU Lesser General Public | |
| dnl License along with this library; if not, write to the Free Software | |
| dnl Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA | |
| dnl | |
| dnl As a special exception to the GNU Lesser General Public License, | |
| dnl if you distribute this file as part of a program that contains a | |
| dnl configuration script generated by Autoconf, you may include it | |
| dnl under the same distribution terms that you use for the rest of | |
| dnl that program. | |
| dnl WINE_CHECK_HOST_TOOL(VARIABLE, PROG-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], [PATH]) | |
| dnl | |
| dnl Like AC_CHECK_TOOL but without the broken fallback to non-prefixed name | |
| dnl | |
| AC_DEFUN([WINE_CHECK_HOST_TOOL], | |
| [AS_VAR_SET_IF([ac_tool_prefix], | |
| [AC_CHECK_PROG([$1],[${ac_tool_prefix}$2],[${ac_tool_prefix}$2],,[$4])]) | |
| AS_VAR_IF([ac_cv_prog_$1],[], | |
| [AS_VAR_IF([cross_compiling],[yes],[], | |
| [AS_UNSET([ac_cv_prog_$1]) | |
| AC_CHECK_PROG([$1],[$2],[$2],[$3],[$4])])], | |
| [AS_VAR_COPY([$1],[ac_cv_prog_$1])])]) | |
| dnl **** Initialize the programs used by other checks **** | |
| dnl | |
| dnl Usage: WINE_PATH_SONAME_TOOLS | |
| dnl Usage: WINE_PATH_PKG_CONFIG | |
| dnl | |
| AC_DEFUN([WINE_PATH_SONAME_TOOLS], | |
| [AC_PATH_PROG(LDD,ldd,true,/sbin:/usr/sbin:$PATH) | |
| AC_CHECK_TOOL(OTOOL,otool,otool) | |
| AC_CHECK_TOOL(READELF,[readelf],true)]) | |
| AC_DEFUN([WINE_PATH_PKG_CONFIG], | |
| [WINE_CHECK_HOST_TOOL(PKG_CONFIG,[pkg-config])]) | |
| AC_DEFUN([WINE_PATH_MINGW_PKG_CONFIG], | |
| [AS_VAR_IF([HOST_ARCH],[i386], | |
| [ac_prefix_list="m4_foreach([ac_wine_cpu],[i686,i586,i486,i386],[ac_wine_cpu-w64-mingw32-pkg-config ])"], | |
| [ac_prefix_list="$host_cpu-w64-mingw32-pkg-config"]) | |
| AC_CHECK_PROGS(MINGW_PKG_CONFIG,[$ac_prefix_list],false)]) | |
| dnl **** Extract the soname of a library **** | |
| dnl | |
| dnl Usage: WINE_CHECK_SONAME(library, function, [action-if-found, [action-if-not-found, [other_libraries, [pattern]]]]) | |
| dnl | |
| AC_DEFUN([WINE_CHECK_SONAME], | |
| [AC_REQUIRE([WINE_PATH_SONAME_TOOLS])dnl | |
| AS_VAR_PUSHDEF([ac_Lib],[ac_cv_lib_soname_$1])dnl | |
| m4_pushdef([ac_lib_pattern],m4_default([$6],[lib$1]))dnl | |
| AC_MSG_CHECKING([for -l$1]) | |
| AC_CACHE_VAL(ac_Lib, | |
| [ac_check_soname_save_LIBS=$LIBS | |
| LIBS="-l$1 $5 $LIBS" | |
| AC_LINK_IFELSE([AC_LANG_CALL([], [$2])], | |
| [case "$LIBEXT" in | |
| dll) AS_VAR_SET(ac_Lib,[`$ac_cv_path_LDD conftest.exe | grep "$1" | sed -e "s/dll.*/dll/"';2,$d'`]) ;; | |
| dylib) AS_VAR_SET(ac_Lib,[`$OTOOL -L conftest$ac_exeext | grep "ac_lib_pattern\\.[[0-9A-Za-z.]]*dylib" | sed -e "s/^.*\/\(ac_lib_pattern\.[[0-9A-Za-z.]]*dylib\).*$/\1/"';2,$d'`]) ;; | |
| *) AS_VAR_SET(ac_Lib,[`$READELF -d conftest$ac_exeext | grep "NEEDED.*ac_lib_pattern\\.$LIBEXT" | sed -e "s/^.*\\m4_dquote(\\(ac_lib_pattern\\.$LIBEXT[[^ ]]*\\)\\).*$/\1/"';2,$d'`]) | |
| AS_VAR_IF([ac_Lib],[], | |
| [AS_VAR_SET(ac_Lib,[`$LDD conftest$ac_exeext | grep "ac_lib_pattern\\.$LIBEXT" | sed -e "s/^.*\(ac_lib_pattern\.$LIBEXT[[^ ]]*\).*$/\1/"';2,$d'`])]) ;; | |
| esac], | |
| [AS_VAR_SET(ac_Lib,[])]) | |
| LIBS=$ac_check_soname_save_LIBS])dnl | |
| AS_VAR_IF([ac_Lib],[], | |
| [AC_MSG_RESULT([not found]) | |
| $4], | |
| [AC_MSG_RESULT(AS_VAR_GET(ac_Lib)) | |
| AC_DEFINE_UNQUOTED(AS_TR_CPP(SONAME_LIB$1),["]AS_VAR_GET(ac_Lib)["], | |
| [Define to the soname of the lib$1 library.]) | |
| $3])dnl | |
| m4_popdef([ac_lib_pattern])dnl | |
| AS_VAR_POPDEF([ac_Lib])]) | |
| dnl **** Get flags from pkg-config or alternate xxx-config program **** | |
| dnl | |
| dnl Usage: WINE_PACKAGE_FLAGS(var,pkg-name,[default-lib,[cflags-alternate,libs-alternate,[checks]]]) | |
| dnl | |
| AC_DEFUN([WINE_PACKAGE_FLAGS], | |
| [AC_REQUIRE([WINE_PATH_PKG_CONFIG])dnl | |
| AS_VAR_PUSHDEF([ac_cflags],[[$1]_CFLAGS])dnl | |
| AS_VAR_PUSHDEF([ac_libs],[[$1]_LIBS])dnl | |
| rm -f conftest.err | |
| AC_ARG_VAR(ac_cflags, [C compiler flags for $2, overriding pkg-config])dnl | |
| AS_VAR_IF([ac_cflags],[], | |
| [AS_VAR_SET_IF([PKG_CONFIG], | |
| [ac_cflags=`$PKG_CONFIG --cflags [$2] 2>conftest.err`])]) | |
| m4_ifval([$4],[test "$cross_compiling" = yes || ac_cflags=[$]{ac_cflags:-[$4]}]) | |
| AC_ARG_VAR(ac_libs, [Linker flags for $2, overriding pkg-config])dnl | |
| AS_VAR_IF([ac_libs],[], | |
| [AS_VAR_SET_IF([PKG_CONFIG], | |
| [ac_libs=`$PKG_CONFIG --libs [$2] 2>/dev/null`])]) | |
| m4_ifval([$5],[test "$cross_compiling" = yes || ac_libs=[$]{ac_libs:-[$5]}]) | |
| m4_ifval([$3],[ac_libs=[$]{ac_libs:-"$3"}]) | |
| AS_ECHO(["$as_me:${as_lineno-$LINENO}: $2 cflags: $ac_cflags"]) >&AS_MESSAGE_LOG_FD | |
| AS_ECHO(["$as_me:${as_lineno-$LINENO}: $2 libs: $ac_libs"]) >&AS_MESSAGE_LOG_FD | |
| if test -s conftest.err; then | |
| AS_ECHO_N(["$as_me:${as_lineno-$LINENO}: $2 errors: "]) >&AS_MESSAGE_LOG_FD | |
| cat conftest.err >&AS_MESSAGE_LOG_FD | |
| fi | |
| rm -f conftest.err | |
| AS_IF([test -n "$ac_cflags$ac_libs"],[ac_save_CPPFLAGS=$CPPFLAGS | |
| CPPFLAGS="$CPPFLAGS $ac_cflags" | |
| $6 | |
| CPPFLAGS=$ac_save_CPPFLAGS]) | |
| AS_VAR_POPDEF([ac_libs])dnl | |
| AS_VAR_POPDEF([ac_cflags])])dnl | |
| dnl **** Get flags from MinGW pkg-config or alternate xxx-config program **** | |
| dnl | |
| dnl Usage: WINE_MINGW_PACKAGE_FLAGS(var,pkg-name,[default-lib,[checks]]) | |
| dnl | |
| AC_DEFUN([WINE_MINGW_PACKAGE_FLAGS], | |
| [AC_REQUIRE([WINE_PATH_MINGW_PKG_CONFIG])dnl | |
| AS_VAR_PUSHDEF([ac_cflags],[[$1]_PE_CFLAGS])dnl | |
| AS_VAR_PUSHDEF([ac_libs],[[$1]_PE_LIBS])dnl | |
| AS_VAR_IF([ac_cflags],[], | |
| [AS_VAR_SET_IF([MINGW_PKG_CONFIG], | |
| [ac_cflags=`$MINGW_PKG_CONFIG --cflags [$2] 2>/dev/null`])]) | |
| AS_VAR_IF([ac_libs],[], | |
| [AS_VAR_SET_IF([MINGW_PKG_CONFIG], | |
| [ac_libs=`$MINGW_PKG_CONFIG --libs [$2] 2>/dev/null`])]) | |
| m4_ifval([$3],[ac_libs=[$]{ac_libs:-"$3"}]) | |
| AS_IF([test -n "$ac_cflags$ac_libs"],[ac_save_CPPFLAGS=$CPPFLAGS | |
| CPPFLAGS="$CPPFLAGS $ac_cflags" | |
| $4 | |
| CPPFLAGS=$ac_save_CPPFLAGS]) | |
| AS_VAR_POPDEF([ac_libs])dnl | |
| AS_VAR_POPDEF([ac_cflags])])dnl | |
| dnl **** Mark a directory as an external lib **** | |
| dnl | |
| dnl Usage: WINE_EXTERNAL(dir) | |
| dnl | |
| AC_DEFUN([WINE_EXTERNAL],[m4_append_uniq([_AC_EXTERNAL_SUBDIRS],[$1],[ ])]) | |
| dnl **** Get flags for an external lib program **** | |
| dnl | |
| dnl Usage: WINE_EXTLIB_FLAGS(var,pkg-name,default-libs,default-cflags) | |
| dnl | |
| AC_DEFUN([WINE_EXTLIB_FLAGS], | |
| [AS_VAR_PUSHDEF([ac_cflags],[[$1]_PE_CFLAGS])dnl | |
| AS_VAR_PUSHDEF([ac_libs],[[$1]_PE_LIBS])dnl | |
| AS_VAR_PUSHDEF([ac_enable],[enable_[$2]])dnl | |
| WINE_EXTERNAL(libs/$2)dnl | |
| AC_ARG_VAR(ac_cflags, [C compiler flags for the PE $2, overriding the bundled version])dnl | |
| AC_ARG_VAR(ac_libs, [Linker flags for the PE $2, overriding the bundled version])dnl | |
| AS_VAR_IF([ac_libs],[], | |
| [ac_libs=$3 | |
| AS_VAR_IF([ac_cflags],[],[ac_cflags=$4],[ac_enable=no])], | |
| [ac_enable=no]) | |
| AS_ECHO(["$as_me:${as_lineno-$LINENO}: $2 cflags: $ac_cflags"]) >&AS_MESSAGE_LOG_FD | |
| AS_ECHO(["$as_me:${as_lineno-$LINENO}: $2 libs: $ac_libs"]) >&AS_MESSAGE_LOG_FD | |
| AS_VAR_POPDEF([ac_enable])dnl | |
| AS_VAR_POPDEF([ac_libs])dnl | |
| AS_VAR_POPDEF([ac_cflags])])dnl | |
| dnl **** Link C code with an assembly file **** | |
| dnl | |
| dnl Usage: WINE_TRY_ASM_LINK(asm-code,includes,function,[action-if-found,[action-if-not-found]]) | |
| dnl | |
| AC_DEFUN([WINE_TRY_ASM_LINK], | |
| [AC_LINK_IFELSE([AC_LANG_PROGRAM([[$2]],[[asm($1); $3]])],[$4],[$5])]) | |
| dnl **** Check if we can link an empty program with special CFLAGS **** | |
| dnl | |
| dnl Usage: WINE_TRY_CFLAGS(flags,[action-if-yes,[action-if-no]]) | |
| dnl | |
| dnl The default action-if-yes is to append the flags to EXTRACFLAGS. | |
| dnl | |
| AC_DEFUN([WINE_TRY_CFLAGS], | |
| [AS_VAR_PUSHDEF([ac_var], ac_cv_cflags_[[$1]])dnl | |
| AC_CACHE_CHECK([whether the compiler supports $1], ac_var, | |
| [ac_wine_try_cflags_saved=$CFLAGS | |
| CFLAGS="$CFLAGS $1" | |
| AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(int argc, char **argv) { return 0; }]])], | |
| [AS_VAR_SET(ac_var,yes)], [AS_VAR_SET(ac_var,no)]) | |
| CFLAGS=$ac_wine_try_cflags_saved]) | |
| AS_VAR_IF([ac_var],[yes],[m4_default([$2], [EXTRACFLAGS="$EXTRACFLAGS $1"])], [$3])dnl | |
| AS_VAR_POPDEF([ac_var])]) | |
| dnl **** Check if we can link an empty program with special CFLAGS **** | |
| dnl | |
| dnl Usage: WINE_TRY_PE_CFLAGS(flags,[action-if-yes,[action-if-no]]) | |
| dnl | |
| dnl The default action-if-yes is to append the flags to the arch-specific EXTRACFLAGS. | |
| dnl | |
| AC_DEFUN([WINE_TRY_PE_CFLAGS], | |
| [{ AS_VAR_PUSHDEF([ac_var], ac_cv_${wine_arch}_cflags_[[$1]])dnl | |
| AC_CACHE_CHECK([whether $CC supports $1], ac_var, | |
| [ac_wine_try_cflags_saved=$CFLAGS | |
| ac_wine_try_cflags_saved_exeext=$ac_exeext | |
| CFLAGS="$CFLAGS -nostdlib -nodefaultlibs $1" | |
| ac_exeext=".exe" | |
| AC_LINK_IFELSE([AC_LANG_SOURCE([[void *__os_arm64x_dispatch_ret = 0; | |
| const unsigned int _load_config_used[0x50] = { sizeof(_load_config_used) }; | |
| #if defined(__clang_major__) && defined(MIN_CLANG_VERSION) && __clang_major__ < MIN_CLANG_VERSION | |
| #error Too old clang version | |
| #endif | |
| int __cdecl mainCRTStartup(void) { return 0; }]])], | |
| [AS_VAR_SET(ac_var,yes)], [AS_VAR_SET(ac_var,no)]) | |
| CFLAGS=$ac_wine_try_cflags_saved | |
| ac_exeext=$ac_wine_try_cflags_saved_exeext]) | |
| AS_VAR_IF([ac_var],[yes],[m4_default([$2], [AS_VAR_APPEND([${wine_arch}_EXTRACFLAGS],[" $1"])])], [$3])dnl | |
| AS_VAR_POPDEF([ac_var]) }]) | |
| dnl **** Check whether the given MinGW header is available **** | |
| dnl | |
| dnl Usage: WINE_CHECK_MINGW_HEADER(header,[action-if-found],[action-if-not-found],[other-includes]) | |
| dnl | |
| AC_DEFUN([WINE_CHECK_MINGW_HEADER], | |
| [AS_VAR_PUSHDEF([ac_var],[ac_cv_mingw_header_$1])dnl | |
| AC_CACHE_CHECK([for MinGW $1], ac_var, | |
| [ac_wine_check_headers_saved_cc=$CC | |
| ac_wine_check_headers_saved_exeext=$ac_exeext | |
| AS_VAR_COPY([CC],[${wine_arch}_CC]) | |
| ac_exeext=".exe" | |
| AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[$4 | |
| #include <$1>]])],[AS_VAR_SET([ac_var],[yes])],[AS_VAR_SET([ac_var],[no])]) | |
| CC=$ac_wine_check_headers_saved_cc | |
| ac_exeext=$ac_wine_check_headers_saved_exeext]) | |
| AS_VAR_IF([ac_var],[yes],[$2],[$3])dnl | |
| AS_VAR_POPDEF([ac_var])]) | |
| dnl **** Check whether the given MinGW library is available **** | |
| dnl | |
| dnl Usage: WINE_CHECK_MINGW_LIB(library,function,[action-if-found],[action-if-not-found],[other-libraries]) | |
| dnl | |
| AC_DEFUN([WINE_CHECK_MINGW_LIB], | |
| [AS_VAR_PUSHDEF([ac_var],[ac_cv_mingw_lib_$1])dnl | |
| AC_CACHE_CHECK([for $2 in MinGW -l$1], ac_var, | |
| [ac_wine_check_headers_saved_cc=$CC | |
| ac_wine_check_headers_saved_exeext=$ac_exeext | |
| ac_wine_check_headers_saved_libs=$LIBS | |
| AS_VAR_COPY([CC],[${wine_arch}_CC]) | |
| ac_exeext=".exe" | |
| LIBS="-l$1 $5 $LIBS" | |
| AC_LINK_IFELSE([AC_LANG_CALL([], [$2])],[AS_VAR_SET([ac_var],[yes])],[AS_VAR_SET([ac_var],[no])]) | |
| CC=$ac_wine_check_headers_saved_cc | |
| ac_exeext=$ac_wine_check_headers_saved_exeext | |
| LIBS=$ac_wine_check_headers_saved_libs]) | |
| AS_VAR_IF([ac_var],[yes],[$3],[$4])dnl | |
| AS_VAR_POPDEF([ac_var])]) | |
| dnl **** Check whether we need to define a symbol on the compiler command line **** | |
| dnl | |
| dnl Usage: WINE_CHECK_DEFINE(name),[action-if-yes,[action-if-no]]) | |
| dnl | |
| AC_DEFUN([WINE_CHECK_DEFINE], | |
| [AS_VAR_PUSHDEF([ac_var],[ac_cv_cpp_def_$1])dnl | |
| AC_CACHE_CHECK([whether we need to define $1],ac_var, | |
| AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#ifdef $1 | |
| #error no | |
| #endif])],[AS_VAR_SET([ac_var],[yes])],[AS_VAR_SET([ac_var],[no])])) | |
| AS_VAR_IF([ac_var],[yes],[EXTRACFLAGS="$EXTRACFLAGS -D$1"])dnl | |
| AS_VAR_POPDEF([ac_var])]) | |
| dnl **** Check for functions with some extra libraries **** | |
| dnl | |
| dnl Usage: WINE_CHECK_LIB_FUNCS(funcs,libs,[action-if-found,[action-if-not-found]]) | |
| dnl | |
| AC_DEFUN([WINE_CHECK_LIB_FUNCS], | |
| [ac_wine_check_funcs_save_LIBS="$LIBS" | |
| LIBS="$LIBS $2" | |
| AC_CHECK_FUNCS([$1],[$3],[$4]) | |
| LIBS="$ac_wine_check_funcs_save_LIBS"]) | |
| dnl **** Define helper functions for creating config.status files **** | |
| dnl | |
| dnl Usage: AC_REQUIRE([WINE_CONFIG_HELPERS]) | |
| dnl | |
| AC_DEFUN([WINE_CONFIG_HELPERS], | |
| [AS_VAR_SET([wine_rules],["all: | |
| @echo 'Wine build complete.'"]) | |
| AC_SUBST(SUBDIRS,"") | |
| AC_SUBST(DISABLED_SUBDIRS,"") | |
| AC_SUBST(CONFIGURE_TARGETS,"") | |
| wine_fn_config_makefile () | |
| { | |
| AS_VAR_APPEND([SUBDIRS],[" \\$as_nl $[1]"]) | |
| AS_VAR_COPY([enable],[$[2]]) | |
| case "$enable" in | |
| no) AS_VAR_APPEND([DISABLED_SUBDIRS],[" $[1]"]) ;; | |
| yes) ;; | |
| *aarch64*|*arm*|*i386*|*x86_64*) | |
| if test -n "$PE_ARCHS" -a "$PE_ARCHS" != none | |
| then | |
| for i in $PE_ARCHS | |
| do | |
| test $(expr ",$enable," : ".*,$i,") -gt 0 || AS_VAR_APPEND([${i}_DISABLED_SUBDIRS],[" $[1]"]) | |
| done | |
| else | |
| test $(expr ",$enable," : ".*,$HOST_ARCH,") -gt 0 || AS_VAR_APPEND([DISABLED_SUBDIRS],[" $[1]"]) | |
| fi ;; | |
| "") | |
| case "$[1], $PE_ARCHS " in | |
| programs/*,*\ arm64ec\ *) AS_VAR_APPEND([arm64ec_DISABLED_SUBDIRS],[" $[1]"]) ;; | |
| esac ;; | |
| esac | |
| }]) | |
| dnl **** Define helper function to append a rule to a makefile command list **** | |
| dnl | |
| dnl Usage: WINE_APPEND_RULE(rule) | |
| dnl | |
| AC_DEFUN([WINE_APPEND_RULE],[AC_REQUIRE([WINE_CONFIG_HELPERS])AS_VAR_APPEND([wine_rules],[" | |
| $1"])]) | |
| dnl **** Create a makefile from config.status **** | |
| dnl | |
| dnl Usage: WINE_CONFIG_MAKEFILE(file) | |
| dnl | |
| AC_DEFUN([WINE_CONFIG_MAKEFILE],[AC_REQUIRE([WINE_CONFIG_HELPERS])dnl | |
| AS_VAR_PUSHDEF([ac_enable],[enable_]m4_bpatsubst(m4_bpatsubst([$1],[.*/\([^/]*\)$],[\1]),[.*\.\(.*16\|vxd\)$],[win16]))dnl | |
| m4_append_uniq([_AC_USER_OPTS],ac_enable,[ | |
| ])dnl | |
| m4_if(m4_bregexp([$1],[^tools]),[-1],[],[test "x$enable_tools" = xno || ])wine_fn_config_makefile [$1] ac_enable[]dnl | |
| AS_VAR_POPDEF([ac_enable])]) | |
| dnl **** Append a file to the .gitignore list **** | |
| dnl | |
| dnl Usage: WINE_IGNORE_FILE(file,enable) | |
| dnl | |
| AC_DEFUN([WINE_IGNORE_FILE],[AC_REQUIRE([WINE_CONFIG_HELPERS])dnl | |
| m4_ifval([$2],[test "x$[$2]" = xno || ])AS_VAR_APPEND([CONFIGURE_TARGETS],[" $1"])]) | |
| dnl **** Add a message to the list displayed at the end **** | |
| dnl | |
| dnl Usage: WINE_NOTICE(notice) | |
| dnl Usage: WINE_WARNING(warning) | |
| dnl Usage: WINE_NOTICE_WITH(with_flag, test, notice, enable) | |
| dnl Usage: WINE_WARNING_WITH(with_flag, test, warning, enable) | |
| dnl Usage: WINE_ERROR_WITH(with_flag, test, error, enable) | |
| dnl Usage: WINE_PRINT_MESSAGES | |
| dnl | |
| AC_DEFUN([WINE_NOTICE],[AS_VAR_APPEND([wine_notices],["|$1"])]) | |
| AC_DEFUN([WINE_WARNING],[AS_VAR_APPEND([wine_warnings],["|$1"])]) | |
| AC_DEFUN([WINE_NOTICE_WITH],[AS_IF([$2],[case "x$with_$1" in | |
| x) WINE_NOTICE([$3]) ;; | |
| xno) ;; | |
| *) AC_MSG_ERROR([$3 | |
| This is an error since --with-$1 was requested.]) ;; | |
| esac | |
| m4_ifval([$4],[$4=${$4:-no}])])]) | |
| AC_DEFUN([WINE_WARNING_WITH],[AS_IF([$2],[case "x$with_$1" in | |
| x) WINE_WARNING([$3]) ;; | |
| xno) ;; | |
| *) AC_MSG_ERROR([$3 | |
| This is an error since --with-$1 was requested.]) ;; | |
| esac | |
| m4_ifval([$4],[$4=${$4:-no}])])]) | |
| AC_DEFUN([WINE_ERROR_WITH],[AS_IF([$2],[case "x$with_$1" in | |
| xno) ;; | |
| *) AC_MSG_ERROR([$3 | |
| Use the --without-$1 option if you really want this.]) ;; | |
| esac | |
| m4_ifval([$4],[$4=${$4:-no}])])]) | |
| AC_DEFUN([WINE_PRINT_MESSAGES],[ac_save_IFS="$IFS" | |
| if test "x$wine_notices" != x; then | |
| echo >&AS_MESSAGE_FD | |
| IFS="|" | |
| for msg in $wine_notices; do | |
| IFS="$ac_save_IFS" | |
| AS_VAR_IF([msg],[],,[AC_MSG_NOTICE([$msg])]) | |
| done | |
| fi | |
| IFS="|" | |
| for msg in $wine_warnings; do | |
| IFS="$ac_save_IFS" | |
| AS_VAR_IF([msg],[],,[echo >&2 | |
| AC_MSG_WARN([$msg])]) | |
| done | |
| IFS="$ac_save_IFS"]) | |
| # C++ version tests copied from https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html | |
| # | |
| # LICENSE | |
| # | |
| # Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com> | |
| # Copyright (c) 2012 Zack Weinberg <zackw@panix.com> | |
| # Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu> | |
| # Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com> | |
| # Copyright (c) 2015 Paul Norman <penorman@mac.com> | |
| # Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu> | |
| # Copyright (c) 2016, 2018 Krzesimir Nowak <qdlacz@gmail.com> | |
| # Copyright (c) 2019 Enji Cooper <yaneurabeya@gmail.com> | |
| # Copyright (c) 2020 Jason Merrill <jason@redhat.com> | |
| # Copyright (c) 2021, 2024 Jörn Heusipp <osmanx@problemloesungsmaschine.de> | |
| # Copyright (c) 2015, 2022, 2023, 2024 Olly Betts | |
| # | |
| # Copying and distribution of this file, with or without modification, are | |
| # permitted in any medium without royalty provided the copyright notice | |
| # and this notice are preserved. This file is offered as-is, without any | |
| # warranty. | |
| dnl Test body for checking C++11 support | |
| m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11], | |
| [_AX_CXX_COMPILE_STDCXX_testbody_new_in_11] | |
| ) | |
| dnl Test body for checking C++14 support | |
| m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14], | |
| [_AX_CXX_COMPILE_STDCXX_testbody_new_in_11 | |
| _AX_CXX_COMPILE_STDCXX_testbody_new_in_14] | |
| ) | |
| dnl Test body for checking C++17 support | |
| m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17], | |
| [_AX_CXX_COMPILE_STDCXX_testbody_new_in_11 | |
| _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 | |
| _AX_CXX_COMPILE_STDCXX_testbody_new_in_17] | |
| ) | |
| dnl Test body for checking C++20 support | |
| m4_define([_AX_CXX_COMPILE_STDCXX_testbody_20], | |
| [_AX_CXX_COMPILE_STDCXX_testbody_new_in_11 | |
| _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 | |
| _AX_CXX_COMPILE_STDCXX_testbody_new_in_17 | |
| _AX_CXX_COMPILE_STDCXX_testbody_new_in_20] | |
| ) | |
| dnl Test body for checking C++23 support | |
| m4_define([_AX_CXX_COMPILE_STDCXX_testbody_23], | |
| [_AX_CXX_COMPILE_STDCXX_testbody_new_in_11 | |
| _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 | |
| _AX_CXX_COMPILE_STDCXX_testbody_new_in_17 | |
| _AX_CXX_COMPILE_STDCXX_testbody_new_in_20 | |
| _AX_CXX_COMPILE_STDCXX_testbody_new_in_23] | |
| ) | |
| dnl Tests for new features in C++11 | |
| m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[ | |
| // If the compiler admits that it is not ready for C++11, why torture it? | |
| // Hopefully, this will speed up the test. | |
| #ifndef __cplusplus | |
| #error "This is not a C++ compiler" | |
| // MSVC always sets __cplusplus to 199711L in older versions; newer versions | |
| // only set it correctly if /Zc:__cplusplus is specified as well as a | |
| // /std:c++NN switch: | |
| // | |
| // https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/ | |
| // | |
| // The value __cplusplus ought to have is available in _MSVC_LANG since | |
| // Visual Studio 2015 Update 3: | |
| // | |
| // https://learn.microsoft.com/en-us/cpp/preprocessor/predefined-macros | |
| // | |
| // This was also the first MSVC version to support C++14 so we can't use the | |
| // value of either __cplusplus or _MSVC_LANG to quickly rule out MSVC having | |
| // C++11 or C++14 support, but we can check _MSVC_LANG for C++17 and later. | |
| #elif __cplusplus < 201103L && !defined _MSC_VER | |
| #error "This is not a C++11 compiler" | |
| #else | |
| namespace cxx11 | |
| { | |
| namespace test_static_assert | |
| { | |
| template <typename T> | |
| struct check | |
| { | |
| static_assert(sizeof(int) <= sizeof(T), "not big enough"); | |
| }; | |
| } | |
| namespace test_final_override | |
| { | |
| struct Base | |
| { | |
| virtual ~Base() {} | |
| virtual void f() {} | |
| }; | |
| struct Derived : public Base | |
| { | |
| virtual ~Derived() override {} | |
| virtual void f() override {} | |
| }; | |
| } | |
| namespace test_double_right_angle_brackets | |
| { | |
| template < typename T > | |
| struct check {}; | |
| typedef check<void> single_type; | |
| typedef check<check<void>> double_type; | |
| typedef check<check<check<void>>> triple_type; | |
| typedef check<check<check<check<void>>>> quadruple_type; | |
| } | |
| namespace test_decltype | |
| { | |
| int | |
| f() | |
| { | |
| int a = 1; | |
| decltype(a) b = 2; | |
| return a + b; | |
| } | |
| } | |
| namespace test_type_deduction | |
| { | |
| template < typename T1, typename T2 > | |
| struct is_same | |
| { | |
| static const bool value = false; | |
| }; | |
| template < typename T > | |
| struct is_same<T, T> | |
| { | |
| static const bool value = true; | |
| }; | |
| template < typename T1, typename T2 > | |
| auto | |
| add(T1 a1, T2 a2) -> decltype(a1 + a2) | |
| { | |
| return a1 + a2; | |
| } | |
| int | |
| test(const int c, volatile int v) | |
| { | |
| static_assert(is_same<int, decltype(0)>::value == true, ""); | |
| static_assert(is_same<int, decltype(c)>::value == false, ""); | |
| static_assert(is_same<int, decltype(v)>::value == false, ""); | |
| auto ac = c; | |
| auto av = v; | |
| auto sumi = ac + av + 'x'; | |
| auto sumf = ac + av + 1.0; | |
| static_assert(is_same<int, decltype(ac)>::value == true, ""); | |
| static_assert(is_same<int, decltype(av)>::value == true, ""); | |
| static_assert(is_same<int, decltype(sumi)>::value == true, ""); | |
| static_assert(is_same<int, decltype(sumf)>::value == false, ""); | |
| static_assert(is_same<int, decltype(add(c, v))>::value == true, ""); | |
| return (sumf > 0.0) ? sumi : add(c, v); | |
| } | |
| } | |
| namespace test_noexcept | |
| { | |
| int f() { return 0; } | |
| int g() noexcept { return 0; } | |
| static_assert(noexcept(f()) == false, ""); | |
| static_assert(noexcept(g()) == true, ""); | |
| } | |
| namespace test_constexpr | |
| { | |
| template < typename CharT > | |
| unsigned long constexpr | |
| strlen_c_r(const CharT *const s, const unsigned long acc) noexcept | |
| { | |
| return *s ? strlen_c_r(s + 1, acc + 1) : acc; | |
| } | |
| template < typename CharT > | |
| unsigned long constexpr | |
| strlen_c(const CharT *const s) noexcept | |
| { | |
| return strlen_c_r(s, 0UL); | |
| } | |
| static_assert(strlen_c("") == 0UL, ""); | |
| static_assert(strlen_c("1") == 1UL, ""); | |
| static_assert(strlen_c("example") == 7UL, ""); | |
| static_assert(strlen_c("another\0example") == 7UL, ""); | |
| } | |
| namespace test_rvalue_references | |
| { | |
| template < int N > | |
| struct answer | |
| { | |
| static constexpr int value = N; | |
| }; | |
| answer<1> f(int&) { return answer<1>(); } | |
| answer<2> f(const int&) { return answer<2>(); } | |
| answer<3> f(int&&) { return answer<3>(); } | |
| void | |
| test() | |
| { | |
| int i = 0; | |
| const int c = 0; | |
| static_assert(decltype(f(i))::value == 1, ""); | |
| static_assert(decltype(f(c))::value == 2, ""); | |
| static_assert(decltype(f(0))::value == 3, ""); | |
| } | |
| } | |
| namespace test_uniform_initialization | |
| { | |
| struct test | |
| { | |
| static const int zero {}; | |
| static const int one {1}; | |
| }; | |
| static_assert(test::zero == 0, ""); | |
| static_assert(test::one == 1, ""); | |
| } | |
| namespace test_lambdas | |
| { | |
| void | |
| test1() | |
| { | |
| auto lambda1 = [](){}; | |
| auto lambda2 = lambda1; | |
| lambda1(); | |
| lambda2(); | |
| } | |
| int | |
| test2() | |
| { | |
| auto a = [](int i, int j){ return i + j; }(1, 2); | |
| auto b = []() -> int { return '0'; }(); | |
| auto c = [=](){ return a + b; }(); | |
| auto d = [&](){ return c; }(); | |
| auto e = [a, &b](int x) mutable { | |
| const auto identity = [](int y){ return y; }; | |
| for (auto i = 0; i < a; ++i) | |
| a += b--; | |
| return x + identity(a + b); | |
| }(0); | |
| return a + b + c + d + e; | |
| } | |
| int | |
| test3() | |
| { | |
| const auto nullary = [](){ return 0; }; | |
| const auto unary = [](int x){ return x; }; | |
| using nullary_t = decltype(nullary); | |
| using unary_t = decltype(unary); | |
| const auto higher1st = [](nullary_t f){ return f(); }; | |
| const auto higher2nd = [unary](nullary_t f1){ | |
| return [unary, f1](unary_t f2){ return f2(unary(f1())); }; | |
| }; | |
| return higher1st(nullary) + higher2nd(nullary)(unary); | |
| } | |
| } | |
| namespace test_variadic_templates | |
| { | |
| template <int...> | |
| struct sum; | |
| template <int N0, int... N1toN> | |
| struct sum<N0, N1toN...> | |
| { | |
| static constexpr auto value = N0 + sum<N1toN...>::value; | |
| }; | |
| template <> | |
| struct sum<> | |
| { | |
| static constexpr auto value = 0; | |
| }; | |
| static_assert(sum<>::value == 0, ""); | |
| static_assert(sum<1>::value == 1, ""); | |
| static_assert(sum<23>::value == 23, ""); | |
| static_assert(sum<1, 2>::value == 3, ""); | |
| static_assert(sum<5, 5, 11>::value == 21, ""); | |
| static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, ""); | |
| } | |
| // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae | |
| // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function | |
| // because of this. | |
| namespace test_template_alias_sfinae | |
| { | |
| struct foo {}; | |
| template<typename T> | |
| using member = typename T::member_type; | |
| template<typename T> | |
| void func(...) {} | |
| template<typename T> | |
| void func(member<T>*) {} | |
| void test(); | |
| void test() { func<foo>(0); } | |
| } | |
| } // namespace cxx11 | |
| #endif // __cplusplus >= 201103L | |
| ]]) | |
| dnl Tests for new features in C++14 | |
| m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[ | |
| // If the compiler admits that it is not ready for C++14, why torture it? | |
| // Hopefully, this will speed up the test. | |
| #ifndef __cplusplus | |
| #error "This is not a C++ compiler" | |
| #elif __cplusplus < 201402L && !defined _MSC_VER | |
| #error "This is not a C++14 compiler" | |
| #else | |
| namespace cxx14 | |
| { | |
| namespace test_polymorphic_lambdas | |
| { | |
| int | |
| test() | |
| { | |
| const auto lambda = [](auto&&... args){ | |
| const auto istiny = [](auto x){ | |
| return (sizeof(x) == 1UL) ? 1 : 0; | |
| }; | |
| const int aretiny[] = { istiny(args)... }; | |
| return aretiny[0]; | |
| }; | |
| return lambda(1, 1L, 1.0f, '1'); | |
| } | |
| } | |
| namespace test_binary_literals | |
| { | |
| constexpr auto ivii = 0b0000000000101010; | |
| static_assert(ivii == 42, "wrong value"); | |
| } | |
| namespace test_generalized_constexpr | |
| { | |
| template < typename CharT > | |
| constexpr unsigned long | |
| strlen_c(const CharT *const s) noexcept | |
| { | |
| auto length = 0UL; | |
| for (auto p = s; *p; ++p) | |
| ++length; | |
| return length; | |
| } | |
| static_assert(strlen_c("") == 0UL, ""); | |
| static_assert(strlen_c("x") == 1UL, ""); | |
| static_assert(strlen_c("test") == 4UL, ""); | |
| static_assert(strlen_c("another\0test") == 7UL, ""); | |
| } | |
| namespace test_lambda_init_capture | |
| { | |
| int | |
| test() | |
| { | |
| auto x = 0; | |
| const auto lambda1 = [a = x](int b){ return a + b; }; | |
| const auto lambda2 = [a = lambda1(x)](){ return a; }; | |
| return lambda2(); | |
| } | |
| } | |
| namespace test_digit_separators | |
| { | |
| constexpr auto ten_million = 100'000'000; | |
| static_assert(ten_million == 100000000, ""); | |
| } | |
| namespace test_return_type_deduction | |
| { | |
| auto f(int& x) { return x; } | |
| decltype(auto) g(int& x) { return x; } | |
| template < typename T1, typename T2 > | |
| struct is_same | |
| { | |
| static constexpr auto value = false; | |
| }; | |
| template < typename T > | |
| struct is_same<T, T> | |
| { | |
| static constexpr auto value = true; | |
| }; | |
| int | |
| test() | |
| { | |
| auto x = 0; | |
| static_assert(is_same<int, decltype(f(x))>::value, ""); | |
| static_assert(is_same<int&, decltype(g(x))>::value, ""); | |
| return x; | |
| } | |
| } | |
| } // namespace cxx14 | |
| #endif // __cplusplus >= 201402L | |
| ]]) | |
| dnl Tests for new features in C++17 | |
| m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[ | |
| // If the compiler admits that it is not ready for C++17, why torture it? | |
| // Hopefully, this will speed up the test. | |
| #ifndef __cplusplus | |
| #error "This is not a C++ compiler" | |
| #elif (defined _MSVC_LANG ? _MSVC_LANG : __cplusplus) < 201703L | |
| #error "This is not a C++17 compiler" | |
| #else | |
| namespace cxx17 | |
| { | |
| namespace test_constexpr_lambdas | |
| { | |
| constexpr int foo = [](){return 42;}(); | |
| } | |
| namespace test::nested_namespace::definitions | |
| { | |
| } | |
| namespace test_fold_expression | |
| { | |
| template<typename... Args> | |
| int multiply(Args... args) | |
| { | |
| return (args * ... * 1); | |
| } | |
| template<typename... Args> | |
| bool all(Args... args) | |
| { | |
| return (args && ...); | |
| } | |
| } | |
| namespace test_extended_static_assert | |
| { | |
| static_assert (true); | |
| } | |
| namespace test_typename_in_template_template_parameter | |
| { | |
| template<template<typename> typename X> struct D; | |
| } | |
| namespace test_fallthrough_nodiscard_maybe_unused_attributes | |
| { | |
| int f1() | |
| { | |
| return 42; | |
| } | |
| [[nodiscard]] int f2() | |
| { | |
| [[maybe_unused]] auto unused = f1(); | |
| switch (f1()) | |
| { | |
| case 17: | |
| f1(); | |
| [[fallthrough]]; | |
| case 42: | |
| f1(); | |
| } | |
| return f1(); | |
| } | |
| } | |
| namespace test_extended_aggregate_initialization | |
| { | |
| struct base1 | |
| { | |
| int b1, b2 = 42; | |
| }; | |
| struct base2 | |
| { | |
| base2() { | |
| b3 = 42; | |
| } | |
| int b3; | |
| }; | |
| struct derived : base1, base2 | |
| { | |
| int d; | |
| }; | |
| derived d1 {{1, 2}, {}, 4}; // full initialization | |
| derived d2 {{}, {}, 4}; // value-initialized bases | |
| } | |
| namespace test_general_range_based_for_loop | |
| { | |
| struct iter | |
| { | |
| int i; | |
| int& operator* () | |
| { | |
| return i; | |
| } | |
| const int& operator* () const | |
| { | |
| return i; | |
| } | |
| iter& operator++() | |
| { | |
| ++i; | |
| return *this; | |
| } | |
| }; | |
| struct sentinel | |
| { | |
| int i; | |
| }; | |
| bool operator== (const iter& i, const sentinel& s) | |
| { | |
| return i.i == s.i; | |
| } | |
| bool operator!= (const iter& i, const sentinel& s) | |
| { | |
| return !(i == s); | |
| } | |
| struct range | |
| { | |
| iter begin() const | |
| { | |
| return {0}; | |
| } | |
| sentinel end() const | |
| { | |
| return {5}; | |
| } | |
| }; | |
| void f() | |
| { | |
| range r {}; | |
| for (auto i : r) | |
| { | |
| [[maybe_unused]] auto v = i; | |
| } | |
| } | |
| } | |
| namespace test_lambda_capture_asterisk_this_by_value | |
| { | |
| struct t | |
| { | |
| int i; | |
| int foo() | |
| { | |
| return [*this]() | |
| { | |
| return i; | |
| }(); | |
| } | |
| }; | |
| } | |
| namespace test_enum_class_construction | |
| { | |
| enum class byte : unsigned char | |
| {}; | |
| byte foo {42}; | |
| } | |
| namespace test_constexpr_if | |
| { | |
| template <bool cond> | |
| int f () | |
| { | |
| if constexpr(cond) | |
| { | |
| return 13; | |
| } | |
| else | |
| { | |
| return 42; | |
| } | |
| } | |
| } | |
| namespace test_selection_statement_with_initializer | |
| { | |
| int f() | |
| { | |
| return 13; | |
| } | |
| int f2() | |
| { | |
| if (auto i = f(); i > 0) | |
| { | |
| return 3; | |
| } | |
| switch (auto i = f(); i + 4) | |
| { | |
| case 17: | |
| return 2; | |
| default: | |
| return 1; | |
| } | |
| } | |
| } | |
| namespace test_template_argument_deduction_for_class_templates | |
| { | |
| template <typename T1, typename T2> | |
| struct pair | |
| { | |
| pair (T1 p1, T2 p2) | |
| : m1 {p1}, | |
| m2 {p2} | |
| {} | |
| T1 m1; | |
| T2 m2; | |
| }; | |
| void f() | |
| { | |
| [[maybe_unused]] auto p = pair{13, 42u}; | |
| } | |
| } | |
| namespace test_non_type_auto_template_parameters | |
| { | |
| template <auto n> | |
| struct B | |
| {}; | |
| B<5> b1; | |
| B<'a'> b2; | |
| } | |
| namespace test_exception_spec_type_system | |
| { | |
| struct Good {}; | |
| struct Bad {}; | |
| void g1() noexcept; | |
| void g2(); | |
| template<typename T> | |
| Bad | |
| f(T*, T*); | |
| template<typename T1, typename T2> | |
| Good | |
| f(T1*, T2*); | |
| } | |
| namespace test_inline_variables | |
| { | |
| template<class T> void f(T) | |
| {} | |
| template<class T> inline T g(T) | |
| { | |
| return T{}; | |
| } | |
| template<> inline void f<>(int) | |
| {} | |
| template<> int g<>(int) | |
| { | |
| return 5; | |
| } | |
| } | |
| } // namespace cxx17 | |
| #endif // (defined _MSVC_LANG ? _MSVC_LANG : __cplusplus) < 201703L | |
| ]]) | |
| dnl Tests for new features in C++20 | |
| m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_20], [[ | |
| #ifndef __cplusplus | |
| #error "This is not a C++ compiler" | |
| #elif (defined _MSVC_LANG ? _MSVC_LANG : __cplusplus) < 202002L | |
| #error "This is not a C++20 compiler" | |
| #else | |
| #include <version> | |
| namespace cxx20 | |
| { | |
| // As C++20 supports feature test macros in the standard, there is no | |
| // immediate need to actually test for feature availability on the | |
| // Autoconf side. | |
| } // namespace cxx20 | |
| #endif // (defined _MSVC_LANG ? _MSVC_LANG : __cplusplus) < 202002L | |
| ]]) | |
| dnl Tests for new features in C++23 | |
| m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_23], [[ | |
| #ifndef __cplusplus | |
| #error "This is not a C++ compiler" | |
| #elif (defined _MSVC_LANG ? _MSVC_LANG : __cplusplus) < 202302L | |
| #error "This is not a C++23 compiler" | |
| #else | |
| #include <version> | |
| namespace cxx23 | |
| { | |
| // As C++23 supports feature test macros in the standard, there is no | |
| // immediate need to actually test for feature availability on the | |
| // Autoconf side. | |
| } // namespace cxx23 | |
| #endif // (defined _MSVC_LANG ? _MSVC_LANG : __cplusplus) < 202302L | |
| ]]) |