From 4c621bc697b13472eeb90202f42b2a183b629e42 Mon Sep 17 00:00:00 2001 From: Yang Tse Date: Mon, 15 Sep 2008 00:32:08 +0000 Subject: improve detection of: strcasecmp() strcasestr() strcmpi() stricmp() strlcat() strncasecmp() strncmpi() strnicmp() --- m4/curl-functions.m4 | 687 ++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 685 insertions(+), 2 deletions(-) (limited to 'm4/curl-functions.m4') diff --git a/m4/curl-functions.m4 b/m4/curl-functions.m4 index 4be2dbaa8..70307c82d 100644 --- a/m4/curl-functions.m4 +++ b/m4/curl-functions.m4 @@ -91,7 +91,7 @@ curl_includes_stdlib="\ dnl CURL_INCLUDES_STRING dnl ------------------------------------------------- dnl Set up variable with list of headers that must be -dnl included when string.h is to be included. +dnl included when string(s).h is to be included. AC_DEFUN([CURL_INCLUDES_STRING], [ curl_includes_string="\ @@ -102,9 +102,12 @@ curl_includes_string="\ #ifdef HAVE_STRING_H # include #endif +#ifdef HAVE_STRINGS_H +# include +#endif /* includes end */" AC_CHECK_HEADERS( - sys/types.h string.h, + sys/types.h string.h strings.h, [], [], [$curl_includes_string]) ]) @@ -532,6 +535,261 @@ AC_DEFUN([CURL_CHECK_FUNC_SIGACTION], [ ]) +dnl CURL_CHECK_FUNC_STRCASECMP +dnl ------------------------------------------------- +dnl Verify if strcasecmp is available, prototyped, and +dnl can be compiled. If all of these are true, and +dnl usage has not been previously disallowed with +dnl shell variable curl_disallow_strcasecmp, then +dnl HAVE_STRCASECMP will be defined. + +AC_DEFUN([CURL_CHECK_FUNC_STRCASECMP], [ + AC_REQUIRE([CURL_INCLUDES_STRING])dnl + # + tst_links_strcasecmp="unknown" + tst_proto_strcasecmp="unknown" + tst_compi_strcasecmp="unknown" + tst_allow_strcasecmp="unknown" + # + AC_MSG_CHECKING([if strcasecmp can be linked]) + AC_LINK_IFELSE([ + AC_LANG_FUNC_LINK_TRY([strcasecmp]) + ],[ + AC_MSG_RESULT([yes]) + tst_links_strcasecmp="yes" + ],[ + AC_MSG_RESULT([no]) + tst_links_strcasecmp="no" + ]) + # + if test "$tst_links_strcasecmp" = "yes"; then + AC_MSG_CHECKING([if strcasecmp is prototyped]) + AC_EGREP_CPP([strcasecmp],[ + $curl_includes_string + ],[ + AC_MSG_RESULT([yes]) + tst_proto_strcasecmp="yes" + ],[ + AC_MSG_RESULT([no]) + tst_proto_strcasecmp="no" + ]) + fi + # + if test "$tst_proto_strcasecmp" = "yes"; then + AC_MSG_CHECKING([if strcasecmp is compilable]) + AC_COMPILE_IFELSE([ + AC_LANG_PROGRAM([[ + $curl_includes_string + ]],[[ + if(0 != strcasecmp(0, 0)) + return 1; + ]]) + ],[ + AC_MSG_RESULT([yes]) + tst_compi_strcasecmp="yes" + ],[ + AC_MSG_RESULT([no]) + tst_compi_strcasecmp="no" + ]) + fi + # + if test "$tst_compi_strcasecmp" = "yes"; then + AC_MSG_CHECKING([if strcasecmp usage allowed]) + if test "x$curl_disallow_strcasecmp" != "xyes"; then + AC_MSG_RESULT([yes]) + tst_allow_strcasecmp="yes" + else + AC_MSG_RESULT([no]) + tst_allow_strcasecmp="no" + fi + fi + # + AC_MSG_CHECKING([if strcasecmp might be used]) + if test "$tst_links_strcasecmp" = "yes" && + test "$tst_proto_strcasecmp" = "yes" && + test "$tst_compi_strcasecmp" = "yes" && + test "$tst_allow_strcasecmp" = "yes"; then + AC_MSG_RESULT([yes]) + AC_DEFINE_UNQUOTED(HAVE_STRCASECMP, 1, + [Define to 1 if you have the strcasecmp function.]) + ac_cv_func_strcasecmp="yes" + else + AC_MSG_RESULT([no]) + ac_cv_func_strcasecmp="no" + fi +]) + + +dnl CURL_CHECK_FUNC_STRCASESTR +dnl ------------------------------------------------- +dnl Verify if strcasestr is available, prototyped, and +dnl can be compiled. If all of these are true, and +dnl usage has not been previously disallowed with +dnl shell variable curl_disallow_strcasestr, then +dnl HAVE_STRCASESTR will be defined. + +AC_DEFUN([CURL_CHECK_FUNC_STRCASESTR], [ + AC_REQUIRE([CURL_INCLUDES_STRING])dnl + # + tst_links_strcasestr="unknown" + tst_proto_strcasestr="unknown" + tst_compi_strcasestr="unknown" + tst_allow_strcasestr="unknown" + # + AC_MSG_CHECKING([if strcasestr can be linked]) + AC_LINK_IFELSE([ + AC_LANG_FUNC_LINK_TRY([strcasestr]) + ],[ + AC_MSG_RESULT([yes]) + tst_links_strcasestr="yes" + ],[ + AC_MSG_RESULT([no]) + tst_links_strcasestr="no" + ]) + # + if test "$tst_links_strcasestr" = "yes"; then + AC_MSG_CHECKING([if strcasestr is prototyped]) + AC_EGREP_CPP([strcasestr],[ + $curl_includes_string + ],[ + AC_MSG_RESULT([yes]) + tst_proto_strcasestr="yes" + ],[ + AC_MSG_RESULT([no]) + tst_proto_strcasestr="no" + ]) + fi + # + if test "$tst_proto_strcasestr" = "yes"; then + AC_MSG_CHECKING([if strcasestr is compilable]) + AC_COMPILE_IFELSE([ + AC_LANG_PROGRAM([[ + $curl_includes_string + ]],[[ + if(0 != strcasestr(0, 0)) + return 1; + ]]) + ],[ + AC_MSG_RESULT([yes]) + tst_compi_strcasestr="yes" + ],[ + AC_MSG_RESULT([no]) + tst_compi_strcasestr="no" + ]) + fi + # + if test "$tst_compi_strcasestr" = "yes"; then + AC_MSG_CHECKING([if strcasestr usage allowed]) + if test "x$curl_disallow_strcasestr" != "xyes"; then + AC_MSG_RESULT([yes]) + tst_allow_strcasestr="yes" + else + AC_MSG_RESULT([no]) + tst_allow_strcasestr="no" + fi + fi + # + AC_MSG_CHECKING([if strcasestr might be used]) + if test "$tst_links_strcasestr" = "yes" && + test "$tst_proto_strcasestr" = "yes" && + test "$tst_compi_strcasestr" = "yes" && + test "$tst_allow_strcasestr" = "yes"; then + AC_MSG_RESULT([yes]) + AC_DEFINE_UNQUOTED(HAVE_STRCASESTR, 1, + [Define to 1 if you have the strcasestr function.]) + ac_cv_func_strcasestr="yes" + else + AC_MSG_RESULT([no]) + ac_cv_func_strcasestr="no" + fi +]) + + +dnl CURL_CHECK_FUNC_STRCMPI +dnl ------------------------------------------------- +dnl Verify if strcmpi is available, prototyped, and +dnl can be compiled. If all of these are true, and +dnl usage has not been previously disallowed with +dnl shell variable curl_disallow_strcmpi, then +dnl HAVE_STRCMPI will be defined. + +AC_DEFUN([CURL_CHECK_FUNC_STRCMPI], [ + AC_REQUIRE([CURL_INCLUDES_STRING])dnl + # + tst_links_strcmpi="unknown" + tst_proto_strcmpi="unknown" + tst_compi_strcmpi="unknown" + tst_allow_strcmpi="unknown" + # + AC_MSG_CHECKING([if strcmpi can be linked]) + AC_LINK_IFELSE([ + AC_LANG_FUNC_LINK_TRY([strcmpi]) + ],[ + AC_MSG_RESULT([yes]) + tst_links_strcmpi="yes" + ],[ + AC_MSG_RESULT([no]) + tst_links_strcmpi="no" + ]) + # + if test "$tst_links_strcmpi" = "yes"; then + AC_MSG_CHECKING([if strcmpi is prototyped]) + AC_EGREP_CPP([strcmpi],[ + $curl_includes_string + ],[ + AC_MSG_RESULT([yes]) + tst_proto_strcmpi="yes" + ],[ + AC_MSG_RESULT([no]) + tst_proto_strcmpi="no" + ]) + fi + # + if test "$tst_proto_strcmpi" = "yes"; then + AC_MSG_CHECKING([if strcmpi is compilable]) + AC_COMPILE_IFELSE([ + AC_LANG_PROGRAM([[ + $curl_includes_string + ]],[[ + if(0 != strcmpi(0, 0)) + return 1; + ]]) + ],[ + AC_MSG_RESULT([yes]) + tst_compi_strcmpi="yes" + ],[ + AC_MSG_RESULT([no]) + tst_compi_strcmpi="no" + ]) + fi + # + if test "$tst_compi_strcmpi" = "yes"; then + AC_MSG_CHECKING([if strcmpi usage allowed]) + if test "x$curl_disallow_strcmpi" != "xyes"; then + AC_MSG_RESULT([yes]) + tst_allow_strcmpi="yes" + else + AC_MSG_RESULT([no]) + tst_allow_strcmpi="no" + fi + fi + # + AC_MSG_CHECKING([if strcmpi might be used]) + if test "$tst_links_strcmpi" = "yes" && + test "$tst_proto_strcmpi" = "yes" && + test "$tst_compi_strcmpi" = "yes" && + test "$tst_allow_strcmpi" = "yes"; then + AC_MSG_RESULT([yes]) + AC_DEFINE_UNQUOTED(HAVE_STRCMPI, 1, + [Define to 1 if you have the strcmpi function.]) + ac_cv_func_strcmpi="yes" + else + AC_MSG_RESULT([no]) + ac_cv_func_strcmpi="no" + fi +]) + + dnl CURL_CHECK_FUNC_STRDUP dnl ------------------------------------------------- dnl Verify if strdup is available, prototyped, and @@ -873,6 +1131,431 @@ AC_DEFUN([CURL_CHECK_FUNC_STRERROR_R], [ ]) +dnl CURL_CHECK_FUNC_STRICMP +dnl ------------------------------------------------- +dnl Verify if stricmp is available, prototyped, and +dnl can be compiled. If all of these are true, and +dnl usage has not been previously disallowed with +dnl shell variable curl_disallow_stricmp, then +dnl HAVE_STRICMP will be defined. + +AC_DEFUN([CURL_CHECK_FUNC_STRICMP], [ + AC_REQUIRE([CURL_INCLUDES_STRING])dnl + # + tst_links_stricmp="unknown" + tst_proto_stricmp="unknown" + tst_compi_stricmp="unknown" + tst_allow_stricmp="unknown" + # + AC_MSG_CHECKING([if stricmp can be linked]) + AC_LINK_IFELSE([ + AC_LANG_FUNC_LINK_TRY([stricmp]) + ],[ + AC_MSG_RESULT([yes]) + tst_links_stricmp="yes" + ],[ + AC_MSG_RESULT([no]) + tst_links_stricmp="no" + ]) + # + if test "$tst_links_stricmp" = "yes"; then + AC_MSG_CHECKING([if stricmp is prototyped]) + AC_EGREP_CPP([stricmp],[ + $curl_includes_string + ],[ + AC_MSG_RESULT([yes]) + tst_proto_stricmp="yes" + ],[ + AC_MSG_RESULT([no]) + tst_proto_stricmp="no" + ]) + fi + # + if test "$tst_proto_stricmp" = "yes"; then + AC_MSG_CHECKING([if stricmp is compilable]) + AC_COMPILE_IFELSE([ + AC_LANG_PROGRAM([[ + $curl_includes_string + ]],[[ + if(0 != stricmp(0, 0)) + return 1; + ]]) + ],[ + AC_MSG_RESULT([yes]) + tst_compi_stricmp="yes" + ],[ + AC_MSG_RESULT([no]) + tst_compi_stricmp="no" + ]) + fi + # + if test "$tst_compi_stricmp" = "yes"; then + AC_MSG_CHECKING([if stricmp usage allowed]) + if test "x$curl_disallow_stricmp" != "xyes"; then + AC_MSG_RESULT([yes]) + tst_allow_stricmp="yes" + else + AC_MSG_RESULT([no]) + tst_allow_stricmp="no" + fi + fi + # + AC_MSG_CHECKING([if stricmp might be used]) + if test "$tst_links_stricmp" = "yes" && + test "$tst_proto_stricmp" = "yes" && + test "$tst_compi_stricmp" = "yes" && + test "$tst_allow_stricmp" = "yes"; then + AC_MSG_RESULT([yes]) + AC_DEFINE_UNQUOTED(HAVE_STRICMP, 1, + [Define to 1 if you have the stricmp function.]) + ac_cv_func_stricmp="yes" + else + AC_MSG_RESULT([no]) + ac_cv_func_stricmp="no" + fi +]) + + +dnl CURL_CHECK_FUNC_STRLCAT +dnl ------------------------------------------------- +dnl Verify if strlcat is available, prototyped, and +dnl can be compiled. If all of these are true, and +dnl usage has not been previously disallowed with +dnl shell variable curl_disallow_strlcat, then +dnl HAVE_STRLCAT will be defined. + +AC_DEFUN([CURL_CHECK_FUNC_STRLCAT], [ + AC_REQUIRE([CURL_INCLUDES_STRING])dnl + # + tst_links_strlcat="unknown" + tst_proto_strlcat="unknown" + tst_compi_strlcat="unknown" + tst_allow_strlcat="unknown" + # + AC_MSG_CHECKING([if strlcat can be linked]) + AC_LINK_IFELSE([ + AC_LANG_FUNC_LINK_TRY([strlcat]) + ],[ + AC_MSG_RESULT([yes]) + tst_links_strlcat="yes" + ],[ + AC_MSG_RESULT([no]) + tst_links_strlcat="no" + ]) + # + if test "$tst_links_strlcat" = "yes"; then + AC_MSG_CHECKING([if strlcat is prototyped]) + AC_EGREP_CPP([strlcat],[ + $curl_includes_string + ],[ + AC_MSG_RESULT([yes]) + tst_proto_strlcat="yes" + ],[ + AC_MSG_RESULT([no]) + tst_proto_strlcat="no" + ]) + fi + # + if test "$tst_proto_strlcat" = "yes"; then + AC_MSG_CHECKING([if strlcat is compilable]) + AC_COMPILE_IFELSE([ + AC_LANG_PROGRAM([[ + $curl_includes_string + ]],[[ + if(0 != strlcat(0, 0, 0)) + return 1; + ]]) + ],[ + AC_MSG_RESULT([yes]) + tst_compi_strlcat="yes" + ],[ + AC_MSG_RESULT([no]) + tst_compi_strlcat="no" + ]) + fi + # + if test "$tst_compi_strlcat" = "yes"; then + AC_MSG_CHECKING([if strlcat usage allowed]) + if test "x$curl_disallow_strlcat" != "xyes"; then + AC_MSG_RESULT([yes]) + tst_allow_strlcat="yes" + else + AC_MSG_RESULT([no]) + tst_allow_strlcat="no" + fi + fi + # + AC_MSG_CHECKING([if strlcat might be used]) + if test "$tst_links_strlcat" = "yes" && + test "$tst_proto_strlcat" = "yes" && + test "$tst_compi_strlcat" = "yes" && + test "$tst_allow_strlcat" = "yes"; then + AC_MSG_RESULT([yes]) + AC_DEFINE_UNQUOTED(HAVE_STRLCAT, 1, + [Define to 1 if you have the strlcat function.]) + ac_cv_func_strlcat="yes" + else + AC_MSG_RESULT([no]) + ac_cv_func_strlcat="no" + fi +]) + + +dnl CURL_CHECK_FUNC_STRNCASECMP +dnl ------------------------------------------------- +dnl Verify if strncasecmp is available, prototyped, and +dnl can be compiled. If all of these are true, and +dnl usage has not been previously disallowed with +dnl shell variable curl_disallow_strncasecmp, then +dnl HAVE_STRNCASECMP will be defined. + +AC_DEFUN([CURL_CHECK_FUNC_STRNCASECMP], [ + AC_REQUIRE([CURL_INCLUDES_STRING])dnl + # + tst_links_strncasecmp="unknown" + tst_proto_strncasecmp="unknown" + tst_compi_strncasecmp="unknown" + tst_allow_strncasecmp="unknown" + # + AC_MSG_CHECKING([if strncasecmp can be linked]) + AC_LINK_IFELSE([ + AC_LANG_FUNC_LINK_TRY([strncasecmp]) + ],[ + AC_MSG_RESULT([yes]) + tst_links_strncasecmp="yes" + ],[ + AC_MSG_RESULT([no]) + tst_links_strncasecmp="no" + ]) + # + if test "$tst_links_strncasecmp" = "yes"; then + AC_MSG_CHECKING([if strncasecmp is prototyped]) + AC_EGREP_CPP([strncasecmp],[ + $curl_includes_string + ],[ + AC_MSG_RESULT([yes]) + tst_proto_strncasecmp="yes" + ],[ + AC_MSG_RESULT([no]) + tst_proto_strncasecmp="no" + ]) + fi + # + if test "$tst_proto_strncasecmp" = "yes"; then + AC_MSG_CHECKING([if strncasecmp is compilable]) + AC_COMPILE_IFELSE([ + AC_LANG_PROGRAM([[ + $curl_includes_string + ]],[[ + if(0 != strncasecmp(0, 0, 0)) + return 1; + ]]) + ],[ + AC_MSG_RESULT([yes]) + tst_compi_strncasecmp="yes" + ],[ + AC_MSG_RESULT([no]) + tst_compi_strncasecmp="no" + ]) + fi + # + if test "$tst_compi_strncasecmp" = "yes"; then + AC_MSG_CHECKING([if strncasecmp usage allowed]) + if test "x$curl_disallow_strncasecmp" != "xyes"; then + AC_MSG_RESULT([yes]) + tst_allow_strncasecmp="yes" + else + AC_MSG_RESULT([no]) + tst_allow_strncasecmp="no" + fi + fi + # + AC_MSG_CHECKING([if strncasecmp might be used]) + if test "$tst_links_strncasecmp" = "yes" && + test "$tst_proto_strncasecmp" = "yes" && + test "$tst_compi_strncasecmp" = "yes" && + test "$tst_allow_strncasecmp" = "yes"; then + AC_MSG_RESULT([yes]) + AC_DEFINE_UNQUOTED(HAVE_STRNCASECMP, 1, + [Define to 1 if you have the strncasecmp function.]) + ac_cv_func_strncasecmp="yes" + else + AC_MSG_RESULT([no]) + ac_cv_func_strncasecmp="no" + fi +]) + + +dnl CURL_CHECK_FUNC_STRNCMPI +dnl ------------------------------------------------- +dnl Verify if strncmpi is available, prototyped, and +dnl can be compiled. If all of these are true, and +dnl usage has not been previously disallowed with +dnl shell variable curl_disallow_strncmpi, then +dnl HAVE_STRNCMPI will be defined. + +AC_DEFUN([CURL_CHECK_FUNC_STRNCMPI], [ + AC_REQUIRE([CURL_INCLUDES_STRING])dnl + # + tst_links_strncmpi="unknown" + tst_proto_strncmpi="unknown" + tst_compi_strncmpi="unknown" + tst_allow_strncmpi="unknown" + # + AC_MSG_CHECKING([if strncmpi can be linked]) + AC_LINK_IFELSE([ + AC_LANG_FUNC_LINK_TRY([strncmpi]) + ],[ + AC_MSG_RESULT([yes]) + tst_links_strncmpi="yes" + ],[ + AC_MSG_RESULT([no]) + tst_links_strncmpi="no" + ]) + # + if test "$tst_links_strncmpi" = "yes"; then + AC_MSG_CHECKING([if strncmpi is prototyped]) + AC_EGREP_CPP([strncmpi],[ + $curl_includes_string + ],[ + AC_MSG_RESULT([yes]) + tst_proto_strncmpi="yes" + ],[ + AC_MSG_RESULT([no]) + tst_proto_strncmpi="no" + ]) + fi + # + if test "$tst_proto_strncmpi" = "yes"; then + AC_MSG_CHECKING([if strncmpi is compilable]) + AC_COMPILE_IFELSE([ + AC_LANG_PROGRAM([[ + $curl_includes_string + ]],[[ + if(0 != strncmpi(0, 0)) + return 1; + ]]) + ],[ + AC_MSG_RESULT([yes]) + tst_compi_strncmpi="yes" + ],[ + AC_MSG_RESULT([no]) + tst_compi_strncmpi="no" + ]) + fi + # + if test "$tst_compi_strncmpi" = "yes"; then + AC_MSG_CHECKING([if strncmpi usage allowed]) + if test "x$curl_disallow_strncmpi" != "xyes"; then + AC_MSG_RESULT([yes]) + tst_allow_strncmpi="yes" + else + AC_MSG_RESULT([no]) + tst_allow_strncmpi="no" + fi + fi + # + AC_MSG_CHECKING([if strncmpi might be used]) + if test "$tst_links_strncmpi" = "yes" && + test "$tst_proto_strncmpi" = "yes" && + test "$tst_compi_strncmpi" = "yes" && + test "$tst_allow_strncmpi" = "yes"; then + AC_MSG_RESULT([yes]) + AC_DEFINE_UNQUOTED(HAVE_STRNCMPI, 1, + [Define to 1 if you have the strncmpi function.]) + ac_cv_func_strncmpi="yes" + else + AC_MSG_RESULT([no]) + ac_cv_func_strncmpi="no" + fi +]) + + +dnl CURL_CHECK_FUNC_STRNICMP +dnl ------------------------------------------------- +dnl Verify if strnicmp is available, prototyped, and +dnl can be compiled. If all of these are true, and +dnl usage has not been previously disallowed with +dnl shell variable curl_disallow_strnicmp, then +dnl HAVE_STRNICMP will be defined. + +AC_DEFUN([CURL_CHECK_FUNC_STRNICMP], [ + AC_REQUIRE([CURL_INCLUDES_STRING])dnl + # + tst_links_strnicmp="unknown" + tst_proto_strnicmp="unknown" + tst_compi_strnicmp="unknown" + tst_allow_strnicmp="unknown" + # + AC_MSG_CHECKING([if strnicmp can be linked]) + AC_LINK_IFELSE([ + AC_LANG_FUNC_LINK_TRY([strnicmp]) + ],[ + AC_MSG_RESULT([yes]) + tst_links_strnicmp="yes" + ],[ + AC_MSG_RESULT([no]) + tst_links_strnicmp="no" + ]) + # + if test "$tst_links_strnicmp" = "yes"; then + AC_MSG_CHECKING([if strnicmp is prototyped]) + AC_EGREP_CPP([strnicmp],[ + $curl_includes_string + ],[ + AC_MSG_RESULT([yes]) + tst_proto_strnicmp="yes" + ],[ + AC_MSG_RESULT([no]) + tst_proto_strnicmp="no" + ]) + fi + # + if test "$tst_proto_strnicmp" = "yes"; then + AC_MSG_CHECKING([if strnicmp is compilable]) + AC_COMPILE_IFELSE([ + AC_LANG_PROGRAM([[ + $curl_includes_string + ]],[[ + if(0 != strnicmp(0, 0)) + return 1; + ]]) + ],[ + AC_MSG_RESULT([yes]) + tst_compi_strnicmp="yes" + ],[ + AC_MSG_RESULT([no]) + tst_compi_strnicmp="no" + ]) + fi + # + if test "$tst_compi_strnicmp" = "yes"; then + AC_MSG_CHECKING([if strnicmp usage allowed]) + if test "x$curl_disallow_strnicmp" != "xyes"; then + AC_MSG_RESULT([yes]) + tst_allow_strnicmp="yes" + else + AC_MSG_RESULT([no]) + tst_allow_strnicmp="no" + fi + fi + # + AC_MSG_CHECKING([if strnicmp might be used]) + if test "$tst_links_strnicmp" = "yes" && + test "$tst_proto_strnicmp" = "yes" && + test "$tst_compi_strnicmp" = "yes" && + test "$tst_allow_strnicmp" = "yes"; then + AC_MSG_RESULT([yes]) + AC_DEFINE_UNQUOTED(HAVE_STRNICMP, 1, + [Define to 1 if you have the strnicmp function.]) + ac_cv_func_strnicmp="yes" + else + AC_MSG_RESULT([no]) + ac_cv_func_strnicmp="no" + fi +]) + + dnl CURL_CHECK_FUNC_STRTOK_R dnl ------------------------------------------------- dnl Verify if strtok_r is available, prototyped, and -- cgit v1.2.3