From b6e5b752fe22725adda416e551665e45fda1a5e1 Mon Sep 17 00:00:00 2001 From: Yang Tse Date: Mon, 15 Sep 2008 00:31:42 +0000 Subject: [PATCH] improve detection of: strcasecmp() strcmpi() stricmp() strncasecmp() strncmpi() strnicmp() --- configure.ac | 8 + m4/cares-functions.m4 | 516 +++++++++++++++++++++++++++++++++++++++++- 2 files changed, 522 insertions(+), 2 deletions(-) diff --git a/configure.ac b/configure.ac index 80b5be6f..6468dbe6 100644 --- a/configure.ac +++ b/configure.ac @@ -449,6 +449,7 @@ if test "$ac_cv_lib_resolve_strcasecmp" = "$ac_cv_func_strcasecmp"; then , -lnsl) fi +ac_cv_func_strcasecmp="no" dnl socket lib? AC_CHECK_FUNC(connect, , [ AC_CHECK_LIB(socket, connect) ]) @@ -643,7 +644,14 @@ CURL_CHECK_FUNC_RECVFROM CURL_CHECK_FUNC_SEND CURL_CHECK_MSG_NOSIGNAL +CARES_CHECK_FUNC_STRCASECMP +CARES_CHECK_FUNC_STRCMPI CARES_CHECK_FUNC_STRDUP +CARES_CHECK_FUNC_STRICMP +CARES_CHECK_FUNC_STRNCASECMP +CARES_CHECK_FUNC_STRNCMPI +CARES_CHECK_FUNC_STRNICMP + dnl check for AF_INET6 CARES_CHECK_CONSTANT( diff --git a/m4/cares-functions.m4 b/m4/cares-functions.m4 index 3d263caf..70864ab7 100644 --- a/m4/cares-functions.m4 +++ b/m4/cares-functions.m4 @@ -22,7 +22,7 @@ dnl CARES_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([CARES_INCLUDES_STRING], [ cares_includes_string="\ @@ -33,13 +33,186 @@ cares_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, [], [], [$cares_includes_string]) ]) +dnl CARES_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 cares_disallow_strcasecmp, then +dnl HAVE_STRCASECMP will be defined. + +AC_DEFUN([CARES_CHECK_FUNC_STRCASECMP], [ + AC_REQUIRE([CARES_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],[ + $cares_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([[ + $cares_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$cares_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 CARES_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 cares_disallow_strcmpi, then +dnl HAVE_STRCMPI will be defined. + +AC_DEFUN([CARES_CHECK_FUNC_STRCMPI], [ + AC_REQUIRE([CARES_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],[ + $cares_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([[ + $cares_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$cares_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 CARES_CHECK_FUNC_STRDUP dnl ------------------------------------------------- dnl Verify if strdup is available, prototyped, and @@ -124,3 +297,342 @@ AC_DEFUN([CARES_CHECK_FUNC_STRDUP], [ fi ]) + +dnl CARES_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 cares_disallow_stricmp, then +dnl HAVE_STRICMP will be defined. + +AC_DEFUN([CARES_CHECK_FUNC_STRICMP], [ + AC_REQUIRE([CARES_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],[ + $cares_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([[ + $cares_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$cares_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 CARES_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 cares_disallow_strncasecmp, then +dnl HAVE_STRNCASECMP will be defined. + +AC_DEFUN([CARES_CHECK_FUNC_STRNCASECMP], [ + AC_REQUIRE([CARES_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],[ + $cares_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([[ + $cares_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$cares_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 CARES_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 cares_disallow_strncmpi, then +dnl HAVE_STRNCMPI will be defined. + +AC_DEFUN([CARES_CHECK_FUNC_STRNCMPI], [ + AC_REQUIRE([CARES_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],[ + $cares_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([[ + $cares_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$cares_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 CARES_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 cares_disallow_strnicmp, then +dnl HAVE_STRNICMP will be defined. + +AC_DEFUN([CARES_CHECK_FUNC_STRNICMP], [ + AC_REQUIRE([CARES_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],[ + $cares_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([[ + $cares_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$cares_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 +])