AC_DEFUN([AI_CHECK_TAO],
    [
        AC_LANG_PUSH(C++)

        AC_ARG_VAR([IDLCPPFLAGS], [additional -I and -D IDL compiler flags])
        AC_ARG_VAR([ACE_ROOT], [stock-built ACE prefix (ignored if --with-acetao-prefix or --with-ace-root is used)])
        AC_ARG_VAR([TAO_ROOT], [stock-built TAO prefix (ignored if --with-acetao-prefix or --with-tao-root is used)])

        AC_ARG_WITH(
            [acetao-prefix],
            AS_HELP_STRING(--with-acetao-prefix=DIR,search for autotools-installed ACE+TAO in DIR),
            [
                ACETAO_PREFIX="${withval}"
            ],
            [
                ACETAO_PREFIX=""
            ])
        AC_ARG_WITH(
            [ace-root],
            AS_HELP_STRING(--with-ace-root=DIR,search for stock-built ACE in DIR (ignored if --with-acetao-prefix is used) [[[$ACE_ROOT]]]),
            [
                ACE_ROOT="${withval}"
            ])
        AC_ARG_WITH(
            [tao-root],
            AS_HELP_STRING(--with-tao-root=DIR,search for stock-built TAO in DIR (ignored if --with-acetao-prefix is used) [[[$TAO_ROOT,$ACE_ROOT/TAO]]]),
            [
                TAO_ROOT="${withval}"
            ])

        TAO_DEFINES=""
        TAO_USES_THREADS="yes"
        AC_ARG_ENABLE(
            [tao-exceptions],
            AS_HELP_STRING(--enable-tao-exceptions,TAO has been built with C++ exception handling enabled (ignored if --with-ace-root or $ACE_ROOT is not used) [[[yes]]]),
            [
                if test "x${ACETAO_PREFIX}" = "x" && test "x${ACE_ROOT}" != "x"  && test "x${enableval}" = "xno"
                then
                    TAO_USES_THREADS="no"
                fi
                if test "x${enableval}" != "xno"
                then
                    TAO_DEFINES="-DACE_HAS_EXCEPTIONS ${TAO_DEFINES}"
                fi
            ],
            [
                TAO_DEFINES="-DACE_HAS_EXCEPTIONS ${TAO_DEFINES}"
            ])
        AC_ARG_ENABLE(
            [tao-inline],
            AS_HELP_STRING(--enable-tao-inline,TAO has been built with code inlining enabled (ignored if --with-ace-root or $ACE_ROOT is not used) [[[yes]]]),
            [
                if test "x${enableval}" != "xno"
                then
                    TAO_DEFINES="-D__ACE_INLINE__ ${TAO_DEFINES}"
                else
                    TAO_DEFINES="-DACE_NO_INLINE ${TAO_DEFINES}"
                fi
            ],
            [
                TAO_DEFINES="-D__ACE_INLINE__ ${TAO_DEFINES}"
            ])
        

        checkAceTaoPrefix()
        {
            ACETAO_PREFIX="${1}"
            ACETAO_PREFIX=`echo ${ACETAO_PREFIX} | sed 's|[[\\/]]$||'`
            if test ! -f "${ACETAO_PREFIX}/include/tao/ORB.h"
            then
                ACETAO_PREFIX=""
            fi
        }

        findTao()
        {
            TAO="no"
            ORB_DEFINES=""

            if test "x${AI_DLOPEN}" = "x"
            then
                AI_CHECK_DLOPEN
            fi
            if test "x${acx_pthread_ok}" = "x" && test "x${TAO_USES_THREADS}" != "xno"
            then
                ACX_PTHREAD
            fi
            if test "x${AI_SOCKET}" = "x"
            then
                AI_CHECK_SOCKET
            fi
            if test "x${AI_POSIX_SHM}" = "x"
            then
                AI_CHECK_POSIX_SHM
            fi

            AC_MSG_NOTICE([checking for TAO...])

            if test "x${TAO_USES_THREADS}" != "xno" && test "x${acx_pthread_ok}" != "xyes"
            then
                return
            fi
            if test "x${AI_SOCKET}" != "xyes"
            then
                return
            fi


            # Try the stock build directory structure first, then the autotooled one.
            if test "x${ACETAO_PREFIX}" = "x" && test "x${ACE_ROOT}" != "x" 
            then
                ACE_ROOT=`echo ${ACE_ROOT} | sed 's|[[\\/]]$||'`
                if test "x${TAO_ROOT}" = "x"
                then
                    TAO_ROOT="${ACE_ROOT}/TAO"
                else
                    TAO_ROOT=`echo ${TAO_ROOT} | sed 's|[[\\/]]$||'`
                fi

                if test ! -f "${ACE_ROOT}/bin/tao_idl"
                then
                    return
                fi

                ORB_BIN_DIRS="${ACE_ROOT}/bin"
                ORB_LIB_DIRS="${ACE_ROOT}/lib"
                ORB_INC_DIRS="${ACE_ROOT} ${TAO_ROOT} ${TAO_ROOT}/orbsvcs"
                ORB_COSS_IDL_DIRS="${TAO_ROOT}/orbsvcs ${TAO_ROOT}/orbsvcs/orbsvcs ${TAO_ROOT}/tao"

                if test -f "${TAO_ROOT}/tao/AnyTypeCode/Any.h"
                then
                    TAO_ANY_H_INCLUDE="#include <tao/AnyTypeCode/Any.h>"
                elif test -f "${TAO_ROOT}/tao/Any.h"
                then
                    TAO_ANY_H_INCLUDE="#include <tao/Any.h>"
                else
                    TAO_ANY_H_INCLUDE=""
                fi

            else
                if test "x${ACETAO_PREFIX}" = "x"
                then
                    for ACETAO_PREFIX in "/usr/local" "/usr" "/usr/pkg" "/opt/sfw" "/usr/sfw" "/opt/local"
                    do
                        checkAceTaoPrefix "${ACETAO_PREFIX}"
                        if test "x${ACETAO_PREFIX}" != "x"
                        then
                            break
                        fi
                    done
                else
                    checkAceTaoPrefix "${ACETAO_PREFIX}"
                fi

                if test "x${ACETAO_PREFIX}" = "x"
                then
                    return
                fi
                if test ! -f "${ACETAO_PREFIX}/bin/tao_idl"
                then
                    return
                fi

                ORB_BIN_DIRS="${ACETAO_PREFIX}/bin"
                ORB_LIB_DIRS="${ACETAO_PREFIX}/lib"

                if test ! -d "${ACETAO_PREFIX}/include/orbsvcs/orbsvcs"
                then
                    ORB_INC_DIRS="${ACETAO_PREFIX}/include"
                    ORB_COSS_IDL_DIRS="${ACETAO_PREFIX}/include ${ACETAO_PREFIX}/include/orbsvcs ${ACETAO_PREFIX}/include/tao"
                else    # Debian
                    ORB_INC_DIRS="${ACETAO_PREFIX}/include ${ACETAO_PREFIX}/include/orbsvcs"
                    ORB_COSS_IDL_DIRS="${ACETAO_PREFIX}/include/orbsvcs ${ACETAO_PREFIX}/include/orbsvcs/orbsvcs ${ACETAO_PREFIX}/include/tao"
                fi

                if test -f "${ACETAO_PREFIX}/include/tao/AnyTypeCode/Any.h"
                then
                    TAO_ANY_H_INCLUDE="#include <tao/AnyTypeCode/Any.h>"
                elif test -f "${ACETAO_PREFIX}/include/tao/Any.h"
                then
                    TAO_ANY_H_INCLUDE="#include <tao/Any.h>"
                else
                    TAO_ANY_H_INCLUDE=""
                fi

                TAO_DEFINES=""
                ACE_ROOT="${ACETAO_PREFIX}"
                TAO_ROOT=""
            fi

            if test "x${TAO_USES_THREADS}" != "xno"
            then
                ORB_CFLAGS="${PTHREAD_CFLAGS}"
                ORB_CXXFLAGS="${PTHREAD_CFLAGS}"
            else
                ORB_CFLAGS=""
                ORB_CXXFLAGS=""
            fi
            ORB_LIBS=""

            EXT_ORB_LIBS=""
            if test "x${TAO_USES_THREADS}" != "xno"
            then
                _AI_LIST_PREPEND_WO_DUPLICATES([${EXT_ORB_LIBS}], [${PTHREAD_LIBS}], EXT_ORB_LIBS)
            fi
            _AI_LIST_PREPEND_WO_DUPLICATES([${EXT_ORB_LIBS}], [${AI_SOCKET_LIBS}], EXT_ORB_LIBS)
            if test "x${AI_DLOPEN}" = "xyes"
            then
                _AI_LIST_PREPEND_WO_DUPLICATES([${EXT_ORB_LIBS}], [${AI_DLOPEN_LIBS}], EXT_ORB_LIBS)
            fi
            if test "x${AI_POSIX_SHM}" = "xyes"
            then
                _AI_LIST_PREPEND_WO_DUPLICATES([${EXT_ORB_LIBS}], [${AI_POSIX_SHM_LIBS}], EXT_ORB_LIBS)
            fi

            _AI_LIST_ADD_PREFIX_AND_SUFFIX([${ORB_INC_DIRS}], [-I], [ ], ORB_CPPFLAGS)
            ORB_CPPFLAGS="${TAO_DEFINES} ${ORB_CPPFLAGS}"
            _AI_LIST_ADD_PREFIX_AND_SUFFIX([${ORB_LIB_DIRS}], [-L], [ ], ORB_LDFLAGS)


            AI_CHECK_TAO_save_CXXFLAGS="${CXXFLAGS}"
            AI_CHECK_TAO_save_CPPFLAGS="${CPPFLAGS}"
            AI_CHECK_TAO_save_LDFLAGS="${LDFLAGS}"
            AI_CHECK_TAO_save_LIBS="${LIBS}"
            CXXFLAGS="${CXXFLAGS} ${ORB_CXXFLAGS}"
            CPPFLAGS="${CPPFLAGS} ${ORB_CPPFLAGS}"
            LDFLAGS="${LDFLAGS} ${ORB_LDFLAGS}"

            AC_MSG_CHECKING([for TAO's mandatory libraries])
            LIBS="-lTAO -lACE ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/ORB.h>
                    ],
                    [
                        int argc;
                        CORBA::ORB_init(argc, 0);
                    ])],
                [
                    ORB_LIBS="-lTAO -lACE ${ORB_LIBS}"
                ],
                [
                    AC_MSG_RESULT([no])
                    CXXFLAGS="${AI_CHECK_TAO_save_CXXFLAGS}"
                    CPPFLAGS="${AI_CHECK_TAO_save_CPPFLAGS}"
                    LDFLAGS="${AI_CHECK_TAO_save_LDFLAGS}"
                    LIBS="${AI_CHECK_TAO_save_LIBS}"
                    return
                ])
            AC_MSG_RESULT([yes])

            AC_MSG_CHECKING([for TAO's TAO_Codeset library])
            LIBS="-lTAO_Codeset ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/Codeset/Codeset.h>
                    ],
                    [
                        TAO_Codeset_Initializer::init();
                    ])],
                [
                    ORB_LIBS="-lTAO_Codeset ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_Codeset], [1], [Define if TAO's TAO_Codeset library is detected])
                    HAVE_LIBTAO_Codeset="yes"
                ],
                [
                    HAVE_LIBTAO_Codeset="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_Codeset])

            AC_MSG_CHECKING([for TAO's TAO_AnyTypeCode library])
            LIBS="-lTAO_AnyTypeCode ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/AnyTypeCode/Any.h>
                    ],
                    [
                        CORBA::Any any;
                    ])],
                [
                    ORB_LIBS="-lTAO_AnyTypeCode ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_AnyTypeCode], [1], [Define if TAO's TAO_AnyTypeCode library is detected])
                    HAVE_LIBTAO_AnyTypeCode="yes"
                ],
                [
                    HAVE_LIBTAO_AnyTypeCode="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_AnyTypeCode])

            AC_MSG_CHECKING([for TAO's TAO_CodecFactory library])
            LIBS="-lTAO_CodecFactory ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/CodecFactory/CodecFactory.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        IOP::CodecFactory::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_CodecFactory ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_CodecFactory], [1], [Define if TAO's TAO_CodecFactory library is detected])
                    HAVE_LIBTAO_CodecFactory="yes"
                ],
                [
                    HAVE_LIBTAO_CodecFactory="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_CodecFactory])

            AC_MSG_CHECKING([for TAO's TAO_PI library])
            LIBS="-lTAO_PI ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/PI/PI.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        PortableInterceptor::Interceptor::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_PI ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_PI], [1], [Define if TAO's TAO_PI library is detected])
                    HAVE_LIBTAO_PI="yes"
                ],
                [
                    HAVE_LIBTAO_PI="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_PI])

            AC_MSG_CHECKING([for TAO's TAO_BiDirGIOP library])
            LIBS="-lTAO_BiDirGIOP ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/BiDir_GIOP/BiDirGIOP.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        BiDirPolicy::BidirectionalPolicy::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_BiDirGIOP ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_BiDirGIOP], [1], [Define if TAO's TAO_BiDirGIOP library is detected])
                    HAVE_LIBTAO_BiDirGIOP="yes"
                ],
                [
                    HAVE_LIBTAO_BiDirGIOP="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_BiDirGIOP])

            AC_MSG_CHECKING([for TAO's TAO_PortableServer library])
            LIBS="-lTAO_PortableServer ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/PortableServer/PortableServer.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        PortableServer::POA::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_PortableServer ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_PortableServer], [1], [Define if TAO's TAO_PortableServer library is detected])
                    HAVE_LIBTAO_PortableServer="yes"
                ],
                [
                    HAVE_LIBTAO_PortableServer="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_PortableServer])


# The following two libraries are new for TAO 1.4.8
# and at this moment they cause a segmentation fault upon process exit.
# They might be enabled later.

#            AC_MSG_CHECKING([for TAO's TAO_CSD_Framework library])
#            LIBS="-lTAO_CSD_Framework ${ORB_LIBS} ${EXT_ORB_LIBS}"
#            AC_LINK_IFELSE(
#                [AC_LANG_PROGRAM(
#                    [
#                        #include <tao/CSD_Framework/CSD_FrameworkC.h>
#                    ],
#                    [
#                        CORBA::Object_ptr t = CORBA::Object::_nil();
#                        CSD_Framework::POA::_narrow(t);
#                    ])],
#                [
#                    ORB_LIBS="-lTAO_CSD_Framework ${ORB_LIBS}"
#                    AC_DEFINE([HAVE_LIBTAO_CSD_Framework], [1], [Define if TAO's TAO_CSD_Framework library is detected])
#                    HAVE_LIBTAO_CSD_Framework="yes"
#                ],
#                [
#                    HAVE_LIBTAO_CSD_Framework="no"
#                ])
#            AC_MSG_RESULT([$HAVE_LIBTAO_CSD_Framework])
#
#            AC_MSG_CHECKING([for TAO's TAO_CSD_ThreadPool library])
#            LIBS="-lTAO_CSD_ThreadPool ${ORB_LIBS} ${EXT_ORB_LIBS}"
#            AC_LINK_IFELSE(
#                [AC_LANG_PROGRAM(
#                    [
#                        #include <tao/CSD_ThreadPool/CSD_ThreadPool.h>
#                    ],
#                    [
#                        TAO_CSD_ThreadPool::init();
#                    ])],
#                [
#                    ORB_LIBS="-lTAO_CSD_ThreadPool ${ORB_LIBS}"
#                    AC_DEFINE([HAVE_LIBTAO_CSD_ThreadPool], [1], [Define if TAO's TAO_CSD_ThreadPool library is detected])
#                    HAVE_LIBTAO_CSD_ThreadPool="yes"
#                ],
#                [
#                    HAVE_LIBTAO_CSD_ThreadPool="no"
#                ])
#            AC_MSG_RESULT([$HAVE_LIBTAO_CSD_ThreadPool])


            AC_MSG_CHECKING([for TAO's TAO_IFR_Client library])
            LIBS="-lTAO_IFR_Client ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/IFR_Client/IFR_BaseC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        CORBA::IRObject::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_IFR_Client ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_IFR_Client], [1], [Define if TAO's TAO_IFR_Client library is detected])
                    HAVE_LIBTAO_IFR_Client="yes"
                ],
                [
                    HAVE_LIBTAO_IFR_Client="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_IFR_Client])

            AC_MSG_CHECKING([for TAO's TAO_Domain library])
            LIBS="-lTAO_Domain ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/Domain/DomainS.h>
                    ],
                    [
                        POA_CORBA::DomainManager *p = NULL;
                        p->_this();
                    ])],
                [
                    ORB_LIBS="-lTAO_Domain ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_Domain], [1], [Define if TAO's TAO_Domain library is detected])
                    HAVE_LIBTAO_Domain="yes"
                ],
                [
                    HAVE_LIBTAO_Domain="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_Domain])

            AC_MSG_CHECKING([for TAO's TAO_DynamicAny library])
            LIBS="-lTAO_DynamicAny ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/DynamicAny/DynamicAny.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        DynamicAny::DynAny::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_DynamicAny ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_DynamicAny], [1], [Define if TAO's TAO_DynamicAny library is detected])
                    HAVE_LIBTAO_DynamicAny="yes"
                ],
                [
                    HAVE_LIBTAO_DynamicAny="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_DynamicAny])

            AC_MSG_CHECKING([for TAO's TAO_Valuetype library])
            LIBS="-lTAO_Valuetype ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/Valuetype/ValueFactory.h>
                    ],
                    [
                        CORBA::ValueFactoryBase *p = NULL; 
                        p->_add_ref();
                    ])],
                [
                    ORB_LIBS="-lTAO_Valuetype ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_Valuetype], [1], [Define if TAO's TAO_Valuetype library is detected])
                    HAVE_LIBTAO_Valuetype="yes"
                ],
                [
                    HAVE_LIBTAO_Valuetype="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_Valuetype])

            AC_MSG_CHECKING([for TAO's TAO_Messaging library])
            LIBS="-lTAO_Messaging ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/Messaging/Messaging.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        Messaging::ReplyHandler::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_Messaging ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_Messaging], [1], [Define if TAO's TAO_Messaging library is detected])
                    HAVE_LIBTAO_Messaging="yes"
                ],
                [
                    HAVE_LIBTAO_Messaging="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_Messaging])

            AC_MSG_CHECKING([for TAO's TAO_DynamicInterface library])
            LIBS="-lTAO_DynamicInterface ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/DynamicInterface/Request.h>
                    ],
                    [
                        CORBA::Request *p = NULL;
                        p->invoke();
                    ])],
                [
                    ORB_LIBS="-lTAO_DynamicInterface ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_DynamicInterface], [1], [Define if TAO's TAO_DynamicInterface library is detected])
                    HAVE_LIBTAO_DynamicInterface="yes"
                ],
                [
                    HAVE_LIBTAO_DynamicInterface="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_DynamicInterface])

            AC_MSG_CHECKING([for TAO's TAO_ObjRefTemplate library])
            LIBS="-lTAO_ObjRefTemplate ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/ObjRefTemplate/ObjectReferenceTemplate.h>
                    ],
                    [
                        TAO::ORT_Adapter_Factory_Impl::Initializer();
                    ])],
                [
                    ORB_LIBS="-lTAO_ObjRefTemplate ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_ObjRefTemplate], [1], [Define if TAO's TAO_ObjRefTemplate library is detected])
                    HAVE_LIBTAO_ObjRefTemplate="yes"
                ],
                [
                    HAVE_LIBTAO_ObjRefTemplate="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_ObjRefTemplate])

            AC_MSG_CHECKING([for TAO's TAO_IORInterceptor library])
            LIBS="-lTAO_IORInterceptor ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/IORInterceptor/IORInterceptor.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        PortableInterceptor::IORInterceptor::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_IORInterceptor ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_IORInterceptor], [1], [Define if TAO's TAO_IORInterceptor library is detected])
                    HAVE_LIBTAO_IORInterceptor="yes"
                ],
                [
                    HAVE_LIBTAO_IORInterceptor="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_IORInterceptor])

            AC_MSG_CHECKING([for TAO's TAO_IORManip library])
            LIBS="-lTAO_IORManip ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/IORManipulation/IORManipulation.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        TAO_IOP::TAO_IOR_Manipulation::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_IORManip ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_IORManip], [1], [Define if TAO's TAO_IORManip library is detected])
                    HAVE_LIBTAO_IORManip="yes"
                ],
                [
                    HAVE_LIBTAO_IORManip="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_IORManip])

            AC_MSG_CHECKING([for TAO's TAO_IORTable library])
            LIBS="-lTAO_IORTable ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/IORTable/IORTable.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        IORTable::Table::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_IORTable ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_IORTable], [1], [Define if TAO's TAO_IORTable library is detected])
                    HAVE_LIBTAO_IORTable="yes"
                ],
                [
                    HAVE_LIBTAO_IORTable="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_IORTable])

            AC_MSG_CHECKING([for TAO's TAO_ImR_Client library])
            LIBS="-lTAO_ImR_Client ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/ImR_Client/ServerObjectC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        ImplementationRepository::ServerObject::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_ImR_Client ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_ImR_Client], [1], [Define if TAO's TAO_ImR_Client library is detected])
                    HAVE_LIBTAO_ImR_Client="yes"
                ],
                [
                    HAVE_LIBTAO_ImR_Client="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_ImR_Client])

            AC_MSG_CHECKING([for TAO's TAO_PI_Server library])
            LIBS="-lTAO_PI_Server ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/PI_Server/ServerRequestInfoC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        PortableInterceptor::ServerRequestInfo::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_PI_Server ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_PI_Server], [1], [Define if TAO's TAO_PI_Server library is detected])
                    HAVE_LIBTAO_PI_Server="yes"
                ],
                [
                    HAVE_LIBTAO_PI_Server="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_PI_Server])

            AC_MSG_CHECKING([for TAO's TAO_RTCORBA library])
            LIBS="-lTAO_RTCORBA ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/RTCORBA/RTCORBA.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        RTCORBA::Current::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_RTCORBA ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_RTCORBA], [1], [Define if TAO's TAO_RTCORBA library is detected])
                    HAVE_LIBTAO_RTCORBA="yes"
                ],
                [
                    HAVE_LIBTAO_RTCORBA="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_RTCORBA])

            AC_MSG_CHECKING([for TAO's TAO_RTPortableServer library])
            LIBS="-lTAO_RTPortableServer ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/RTPortableServer/RTPortableServer.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        RTPortableServer::POA::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_RTPortableServer ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_RTPortableServer], [1], [Define if TAO's TAO_RTPortableServer library is detected])
                    HAVE_LIBTAO_RTPortableServer="yes"
                ],
                [
                    HAVE_LIBTAO_RTPortableServer="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_RTPortableServer])

            AC_MSG_CHECKING([for TAO's TAO_RTScheduler library])
            LIBS="-lTAO_RTScheduler ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/RTScheduling/RTScheduler.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        RTScheduling::Current::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_RTScheduler ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_RTScheduler], [1], [Define if TAO's TAO_RTScheduler library is detected])
                    HAVE_LIBTAO_RTScheduler="yes"
                ],
                [
                    HAVE_LIBTAO_RTScheduler="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_RTScheduler])

            AC_MSG_CHECKING([for TAO's TAO_SmartProxies library])
            LIBS="-lTAO_SmartProxies ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/SmartProxies/Smart_Proxies.h>
                    ],
                    [
                        TAO_Smart_Proxy_Base *p = NULL;
                        delete p;
                    ])],
                [
                    ORB_LIBS="-lTAO_SmartProxies ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_SmartProxies], [1], [Define if TAO's TAO_SmartProxies library is detected])
                    HAVE_LIBTAO_SmartProxies="yes"
                ],
                [
                    HAVE_LIBTAO_SmartProxies="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_SmartProxies])

            AC_MSG_CHECKING([for TAO's TAO_Strategies library])
            LIBS="-lTAO_Strategies ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/Strategies/DIOP_Factory.h>
                    ],
                    [
                        new TAO_DIOP_Protocol_Factory();
                    ])],
                [
                    ORB_LIBS="-lTAO_Strategies ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_Strategies], [1], [Define if TAO's TAO_Strategies library is detected])
                    HAVE_LIBTAO_Strategies="yes"
                ],
                [
                    HAVE_LIBTAO_Strategies="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_Strategies])

            AC_MSG_CHECKING([for TAO's TAO_TypeCodeFactory library])
            LIBS="-lTAO_TypeCodeFactory ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/TypeCodeFactory/TypeCodeFactory_Loader.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        CORBA::TypeCodeFactory::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_TypeCodeFactory ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_TypeCodeFactory], [1], [Define if TAO's TAO_TypeCodeFactory library is detected])
                    HAVE_LIBTAO_TypeCodeFactory="yes"
                ],
                [
                    HAVE_LIBTAO_TypeCodeFactory="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_TypeCodeFactory])

            AC_MSG_CHECKING([for TAO's TAO_Utils library])
            LIBS="-lTAO_Utils ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <tao/Utils/ORB_Manager.h>
                    ],
                    [
                        new TAO_ORB_Manager();
                    ])],
                [
                    ORB_LIBS="-lTAO_Utils ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_Utils], [1], [Define if TAO's TAO_Utils library is detected])
                    HAVE_LIBTAO_Utils="yes"
                ],
                [
                    HAVE_LIBTAO_Utils="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_Utils])


            AC_MSG_CHECKING([for TAO's TAO_CosNaming library])
            LIBS="-lTAO_CosNaming ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/CosNamingC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        CosNaming::NamingContext::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_CosNaming ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_CosNaming], [1], [Define if TAO's TAO_CosNaming library is detected])
                    HAVE_LIBTAO_CosNaming="yes"
                ],
                [
                    HAVE_LIBTAO_CosNaming="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_CosNaming])

            AC_MSG_CHECKING([for TAO's TAO_CosProperty library])
            LIBS="-lTAO_CosProperty ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/CosPropertyC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        CosPropertyService::PropertySet::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_CosProperty ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_CosProperty], [1], [Define if TAO's TAO_CosProperty library is detected])
                    HAVE_LIBTAO_CosProperty="yes"
                ],
                [
                    HAVE_LIBTAO_CosProperty="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_CosProperty])

            AC_MSG_CHECKING([for TAO's TAO_AV library])
            LIBS="-lTAO_AV ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/AVStreamsC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        AVStreams::StreamCtrl::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_AV ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_AV], [1], [Define if TAO's TAO_AV library is detected])
                    HAVE_LIBTAO_AV="yes"
                ],
                [
                    HAVE_LIBTAO_AV="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_AV])

            AC_MSG_CHECKING([for TAO's TAO_CosConcurrency library])
            LIBS="-lTAO_CosConcurrency ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/CosConcurrencyControlC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        CosConcurrencyControl::LockSet::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_CosConcurrency ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_CosConcurrency], [1], [Define if TAO's TAO_CosConcurrency library is detected])
                    HAVE_LIBTAO_CosConcurrency="yes"
                ],
                [
                    HAVE_LIBTAO_CosConcurrency="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_CosConcurrency])

            AC_MSG_CHECKING([for TAO's TAO_CosEvent library])
            LIBS="-lTAO_CosEvent ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/CosEventCommC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        CosEventComm::PushConsumer::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_CosEvent ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_CosEvent], [1], [Define if TAO's TAO_CosEvent library is detected])
                    HAVE_LIBTAO_CosEvent="yes"
                ],
                [
                    HAVE_LIBTAO_CosEvent="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_CosEvent])

            AC_MSG_CHECKING([for TAO's TAO_Svc_Utils library])
            LIBS="-lTAO_Svc_Utils ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/IOR_Multicast.h>
                    ],
                    [
                        new TAO_IOR_Multicast();
                    ])],
                [
                    ORB_LIBS="-lTAO_Svc_Utils ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_Svc_Utils], [1], [Define if TAO's TAO_Svc_Utils library is detected])
                    HAVE_LIBTAO_Svc_Utils="yes"
                ],
                [
                    HAVE_LIBTAO_Svc_Utils="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_Svc_Utils])

            AC_MSG_CHECKING([for TAO's TAO_CosEvent_Skel library])
            LIBS="-lTAO_CosEvent_Skel ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/CosEventCommS.h>
                    ],
                    [
                        POA_CosEventComm::PushConsumer *p = NULL;
                        p->_this();
                    ])],
                [
                    ORB_LIBS="-lTAO_CosEvent_Skel ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_CosEvent_Skel], [1], [Define if TAO's TAO_CosEvent_Skel library is detected])
                    HAVE_LIBTAO_CosEvent_Skel="yes"
                ],
                [
                    HAVE_LIBTAO_CosEvent_Skel="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_CosEvent_Skel])

            AC_MSG_CHECKING([for TAO's TAO_CosLifeCycle library])
            LIBS="-lTAO_CosLifeCycle ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/CosLifeCycleC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        CosLifeCycle::LifeCycleObject::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_CosLifeCycle ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_CosLifeCycle], [1], [Define if TAO's TAO_CosLifeCycle library is detected])
                    HAVE_LIBTAO_CosLifeCycle="yes"
                ],
                [
                    HAVE_LIBTAO_CosLifeCycle="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_CosLifeCycle])

            AC_MSG_CHECKING([for TAO's TAO_PortableGroup library])
            LIBS="-lTAO_PortableGroup ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/PortableGroupC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        PortableGroup::ObjectGroupManager::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_PortableGroup ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_PortableGroup], [1], [Define if TAO's TAO_PortableGroup library is detected])
                    HAVE_LIBTAO_PortableGroup="yes"
                ],
                [
                    HAVE_LIBTAO_PortableGroup="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_PortableGroup])

            AC_MSG_CHECKING([for TAO's TAO_CosLoadBalancing library])
            LIBS="-lTAO_CosLoadBalancing ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/CosLoadBalancingC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        CosLoadBalancing::LoadManager::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_CosLoadBalancing ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_CosLoadBalancing], [1], [Define if TAO's TAO_CosLoadBalancing library is detected])
                    HAVE_LIBTAO_CosLoadBalancing="yes"
                ],
                [
                    HAVE_LIBTAO_CosLoadBalancing="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_CosLoadBalancing])

            AC_MSG_CHECKING([for TAO's TAO_CosNaming_Skel library])
            LIBS="-lTAO_CosNaming_Skel ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/CosNamingS.h>
                    ],
                    [
                        POA_CosNaming::NamingContext *p = NULL;
                        p->_this();
                    ])],
                [
                    ORB_LIBS="-lTAO_CosNaming_Skel ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_CosNaming_Skel], [1], [Define if TAO's TAO_CosNaming_Skel library is detected])
                    HAVE_LIBTAO_CosNaming_Skel="yes"
                ],
                [
                    HAVE_LIBTAO_CosNaming_Skel="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_CosNaming_Skel])

            AC_MSG_CHECKING([for TAO's TAO_CosNotification library])
            LIBS="-lTAO_CosNotification ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/CosNotificationC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        CosNotification::AdminPropertiesAdmin::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_CosNotification ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_CosNotification], [1], [Define if TAO's TAO_CosNotification library is detected])
                    HAVE_LIBTAO_CosNotification="yes"
                ],
                [
                    HAVE_LIBTAO_CosNotification="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_CosNotification])

            AC_MSG_CHECKING([for TAO's TAO_ETCL library])
            LIBS="-lTAO_ETCL ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/ETCL/ETCL_Constraint.h>
                    ],
                    [
                        new TAO_ETCL_Identifier("");
                    ])],
                [
                    ORB_LIBS="-lTAO_ETCL ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_ETCL], [1], [Define if TAO's TAO_ETCL library is detected])
                    HAVE_LIBTAO_ETCL="yes"
                ],
                [
                    HAVE_LIBTAO_ETCL="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_ETCL])

            AC_MSG_CHECKING([for TAO's TAO_CosNotification_Skel library])
            LIBS="-lTAO_CosNotification_Skel ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/CosNotificationS.h>
                    ],
                    [
                        POA_CosNotification::AdminPropertiesAdmin *p = NULL;
                        p->_this();
                    ])],
                [
                    ORB_LIBS="-lTAO_CosNotification_Skel ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_CosNotification_Skel], [1], [Define if TAO's TAO_CosNotification_Skel library is detected])
                    HAVE_LIBTAO_CosNotification_Skel="yes"
                ],
                [
                    HAVE_LIBTAO_CosNotification_Skel="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_CosNotification_Skel])

            AC_MSG_CHECKING([for TAO's TAO_CosTime library])
            LIBS="-lTAO_CosTime ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/TimeServiceC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        CosTime::TimeService::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_CosTime ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_CosTime], [1], [Define if TAO's TAO_CosTime library is detected])
                    HAVE_LIBTAO_CosTime="yes"
                ],
                [
                    HAVE_LIBTAO_CosTime="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_CosTime])

            AC_MSG_CHECKING([for TAO's TAO_CosTrading library])
            LIBS="-lTAO_CosTrading ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/CosTradingC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        CosTrading::TraderComponents::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_CosTrading ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_CosTrading], [1], [Define if TAO's TAO_CosTrading library is detected])
                    HAVE_LIBTAO_CosTrading="yes"
                ],
                [
                    HAVE_LIBTAO_CosTrading="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_CosTrading])

            AC_MSG_CHECKING([for TAO's TAO_CosTrading_Skel library])
            LIBS="-lTAO_CosTrading_Skel ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/CosTradingS.h>
                    ],
                    [
                        POA_CosTrading::TraderComponents *p = NULL;
                        p->_this();
                    ])],
                [
                    ORB_LIBS="-lTAO_CosTrading_Skel ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_CosTrading_Skel], [1], [Define if TAO's TAO_CosTrading_Skel library is detected])
                    HAVE_LIBTAO_CosTrading_Skel="yes"
                ],
                [
                    HAVE_LIBTAO_CosTrading_Skel="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_CosTrading_Skel])

            AC_MSG_CHECKING([for TAO's TAO_DsLogAdmin library])
            LIBS="-lTAO_DsLogAdmin ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/DsLogAdminC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        DsLogAdmin::Log::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_DsLogAdmin ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_DsLogAdmin], [1], [Define if TAO's TAO_DsLogAdmin library is detected])
                    HAVE_LIBTAO_DsLogAdmin="yes"
                ],
                [
                    HAVE_LIBTAO_DsLogAdmin="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_DsLogAdmin])

            AC_MSG_CHECKING([for TAO's TAO_DsEventLogAdmin library])
            LIBS="-lTAO_DsEventLogAdmin ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/DsEventLogAdminC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        DsEventLogAdmin::EventLog::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_DsEventLogAdmin ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_DsEventLogAdmin], [1], [Define if TAO's TAO_DsEventLogAdmin library is detected])
                    HAVE_LIBTAO_DsEventLogAdmin="yes"
                ],
                [
                    HAVE_LIBTAO_DsEventLogAdmin="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_DsEventLogAdmin])

            AC_MSG_CHECKING([for TAO's TAO_DsLogAdmin_Skel library])
            LIBS="-lTAO_DsLogAdmin_Skel ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/DsLogAdminS.h>
                    ],
                    [
                        POA_DsLogAdmin::Log *p = NULL;
                        p->_this();
                    ])],
                [
                    ORB_LIBS="-lTAO_DsLogAdmin_Skel ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_DsLogAdmin_Skel], [1], [Define if TAO's TAO_DsLogAdmin_Skel library is detected])
                    HAVE_LIBTAO_DsLogAdmin_Skel="yes"
                ],
                [
                    HAVE_LIBTAO_DsLogAdmin_Skel="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_DsLogAdmin_Skel])

            AC_MSG_CHECKING([for TAO's TAO_DsEventLogAdmin_Skel library])
            LIBS="-lTAO_DsEventLogAdmin_Skel ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/DsEventLogAdminS.h>
                    ],
                    [
                        POA_DsEventLogAdmin::EventLog *p = NULL;
                        p->_this();
                    ])],
                [
                    ORB_LIBS="-lTAO_DsEventLogAdmin_Skel ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_DsEventLogAdmin_Skel], [1], [Define if TAO's TAO_DsEventLogAdmin_Skel library is detected])
                    HAVE_LIBTAO_DsEventLogAdmin_Skel="yes"
                ],
                [
                    HAVE_LIBTAO_DsEventLogAdmin_Skel="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_DsEventLogAdmin_Skel])

            AC_MSG_CHECKING([for TAO's TAO_DsNotifyLogAdmin library])
            LIBS="-lTAO_DsNotifyLogAdmin ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/DsNotifyLogAdminC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        DsNotifyLogAdmin::NotifyLog::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_DsNotifyLogAdmin ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_DsNotifyLogAdmin], [1], [Define if TAO's TAO_DsNotifyLogAdmin library is detected])
                    HAVE_LIBTAO_DsNotifyLogAdmin="yes"
                ],
                [
                    HAVE_LIBTAO_DsNotifyLogAdmin="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_DsNotifyLogAdmin])

            AC_MSG_CHECKING([for TAO's TAO_DsNotifyLogAdmin_Skel library])
            LIBS="-lTAO_DsNotifyLogAdmin_Skel ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/DsNotifyLogAdminS.h>
                    ],
                    [
                        POA_DsNotifyLogAdmin::NotifyLog *p = NULL;
                        p->_this();
                    ])],
                [
                    ORB_LIBS="-lTAO_DsNotifyLogAdmin_Skel ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_DsNotifyLogAdmin_Skel], [1], [Define if TAO's TAO_DsNotifyLogAdmin_Skel library is detected])
                    HAVE_LIBTAO_DsNotifyLogAdmin_Skel="yes"
                ],
                [
                    HAVE_LIBTAO_DsNotifyLogAdmin_Skel="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_DsNotifyLogAdmin_Skel])

            AC_MSG_CHECKING([for TAO's TAO_FTORB_Utils library])
            LIBS="-lTAO_FTORB_Utils ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/FT_CORBA_ORBC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        FT::HeartbeatPolicy::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_FTORB_Utils ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_FTORB_Utils], [1], [Define if TAO's TAO_FTORB_Utils library is detected])
                    HAVE_LIBTAO_FTORB_Utils="yes"
                ],
                [
                    HAVE_LIBTAO_FTORB_Utils="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_FTORB_Utils])

            AC_MSG_CHECKING([for TAO's TAO_FTRT_ClientORB library])
            LIBS="-lTAO_FTRT_ClientORB ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/FtRtEvent/ClientORB/FTRT_ClientORB_Loader.h>
                    ],
                    [
                        new TAO_FTRT::FTRT_ClientORB_Loader();
                    ])],
                [
                    ORB_LIBS="-lTAO_FTRT_ClientORB ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_FTRT_ClientORB], [1], [Define if TAO's TAO_FTRT_ClientORB library is detected])
                    HAVE_LIBTAO_FTRT_ClientORB="yes"
                ],
                [
                    HAVE_LIBTAO_FTRT_ClientORB="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_FTRT_ClientORB])

            AC_MSG_CHECKING([for TAO's TAO_RTEvent library])
            LIBS="-lTAO_RTEvent ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/RtecEventCommC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        RtecEventComm::PushConsumer::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_RTEvent ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_RTEvent], [1], [Define if TAO's TAO_RTEvent library is detected])
                    HAVE_LIBTAO_RTEvent="yes"
                ],
                [
                    HAVE_LIBTAO_RTEvent="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_RTEvent])

            AC_MSG_CHECKING([for TAO's TAO_RTEvent_Skel library])
            LIBS="-lTAO_RTEvent_Skel ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/RtecEventCommS.h>
                    ],
                    [
                        POA_RtecEventComm::PushConsumer *p = NULL;
                        p->_this();
                    ])],
                [
                    ORB_LIBS="-lTAO_RTEvent_Skel ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_RTEvent_Skel], [1], [Define if TAO's TAO_RTEvent_Skel library is detected])
                    HAVE_LIBTAO_RTEvent_Skel="yes"
                ],
                [
                    HAVE_LIBTAO_RTEvent_Skel="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_RTEvent_Skel])

            AC_MSG_CHECKING([for TAO's TAO_FtRtEvent library])
            LIBS="-lTAO_FtRtEvent -lTAO_RTEvent_Serv ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/FtRtecEventCommC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        FtRtecEventComm::PushConsumer::_narrow(t);
                    ])],
                [
                    _AI_LIST_PREPEND_WO_DUPLICATES([${ORB_LIBS}], [-lTAO_RTEvent_Serv], ORB_LIBS)
                    ORB_LIBS="-lTAO_FtRtEvent ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_FtRtEvent], [1], [Define if TAO's TAO_FtRtEvent library is detected])
                    HAVE_LIBTAO_FtRtEvent="yes"
                ],
                [
                    HAVE_LIBTAO_FtRtEvent="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_FtRtEvent])

            AC_MSG_CHECKING([for TAO's TAO_FT_ClientORB library])
            LIBS="-lTAO_FT_ClientORB ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        ${TAO_ANY_H_INCLUDE}
                        #include <orbsvcs/FaultTolerance/FT_ClientPolicy_i.h>
                    ],
                    [
                        CORBA::Any any;
                        TAO_FT_Heart_Beat_Policy::create(any);
                    ])],
                [
                    ORB_LIBS="-lTAO_FT_ClientORB ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_FT_ClientORB], [1], [Define if TAO's TAO_FT_ClientORB library is detected])
                    HAVE_LIBTAO_FT_ClientORB="yes"
                ],
                [
                    HAVE_LIBTAO_FT_ClientORB="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_FT_ClientORB])

            AC_MSG_CHECKING([for TAO's TAO_FT_ServerORB library])
            LIBS="-lTAO_FT_ServerORB ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        ${TAO_ANY_H_INCLUDE}
                        #include <orbsvcs/FaultTolerance/FT_ServerPolicy_i.h>
                    ],
                    [
                        CORBA::Any any;
                        TAO_FT_Heart_Beat_Enabled_Policy::create(any);
                    ])],
                [
                    ORB_LIBS="-lTAO_FT_ServerORB ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_FT_ServerORB], [1], [Define if TAO's TAO_FT_ServerORB library is detected])
                    HAVE_LIBTAO_FT_ServerORB="yes"
                ],
                [
                    HAVE_LIBTAO_FT_ServerORB="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_FT_ServerORB])

            AC_MSG_CHECKING([for TAO's TAO_FaultTolerance library])
            LIBS="-lTAO_FaultTolerance ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/FT_CORBAC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        FT::FTObjectGroupManager::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_FaultTolerance ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_FaultTolerance], [1], [Define if TAO's TAO_FaultTolerance library is detected])
                    HAVE_LIBTAO_FaultTolerance="yes"
                ],
                [
                    HAVE_LIBTAO_FaultTolerance="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_FaultTolerance])

            AC_MSG_CHECKING([for TAO's TAO_HTIOP library])
            LIBS="-lTAO_HTIOP -lACE_HTBP ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/HTIOP/HTIOP_Factory.h>
                    ],
                    [
                        new TAO::HTIOP::Protocol_Factory();
                    ])],
                [
                    _AI_LIST_PREPEND_WO_DUPLICATES([${ORB_LIBS}], [-lACE_HTBP], ORB_LIBS)
                    ORB_LIBS="-lTAO_HTIOP ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_HTIOP], [1], [Define if TAO's TAO_HTIOP library is detected])
                    HAVE_LIBTAO_HTIOP="yes"
                ],
                [
                    HAVE_LIBTAO_HTIOP="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_HTIOP])

            AC_MSG_CHECKING([for TAO's TAO_RTSched library])
            LIBS="-lTAO_RTSched ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/RtecSchedulerC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        RtecScheduler::Scheduler::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_RTSched ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_RTSched], [1], [Define if TAO's TAO_RTSched library is detected])
                    HAVE_LIBTAO_RTSched="yes"
                ],
                [
                    HAVE_LIBTAO_RTSched="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_RTSched])

            AC_MSG_CHECKING([for TAO's TAO_RTEventLogAdmin library])
            LIBS="-lTAO_RTEventLogAdmin -lTAO_DsLogAdmin_Serv -lTAO_RTEvent_Serv ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/RTEventLogAdminC.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        RTEventLogAdmin::EventLog::_narrow(t);
                    ])],
                [
                    _AI_LIST_PREPEND_WO_DUPLICATES([${ORB_LIBS}], [-lTAO_DsLogAdmin_Serv -lTAO_RTEvent_Serv], ORB_LIBS)
                    ORB_LIBS="-lTAO_RTEventLogAdmin ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_RTEventLogAdmin], [1], [Define if TAO's TAO_RTEventLogAdmin library is detected])
                    HAVE_LIBTAO_RTEventLogAdmin="yes"
                ],
                [
                    HAVE_LIBTAO_RTEventLogAdmin="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_RTEventLogAdmin])

            AC_MSG_CHECKING([for TAO's TAO_Security library])
            LIBS="-lTAO_Security ${ORB_LIBS} ${EXT_ORB_LIBS}"
            AC_LINK_IFELSE(
                [AC_LANG_PROGRAM(
                    [
                        #include <orbsvcs/SecurityLevel1C.h>
                    ],
                    [
                        CORBA::Object_ptr t = CORBA::Object::_nil();
                        SecurityLevel1::Current::_narrow(t);
                    ])],
                [
                    ORB_LIBS="-lTAO_Security ${ORB_LIBS}"
                    AC_DEFINE([HAVE_LIBTAO_Security], [1], [Define if TAO's TAO_Security library is detected])
                    HAVE_LIBTAO_Security="yes"
                ],
                [
                    HAVE_LIBTAO_Security="no"
                ])
            AC_MSG_RESULT([$HAVE_LIBTAO_Security])

            if test "x${AI_OPENSSL}" = "x"
            then
                AI_CHECK_OPENSSL
            fi
            if test "x${AI_OPENSSL}" = "xyes"
            then
                AC_MSG_CHECKING([for TAO's TAO_SSLIOP library])
                LIBS="-lTAO_SSLIOP -lACE_SSL ${ORB_LIBS} ${EXT_ORB_LIBS} ${AI_OPENSSL_LIBS}"
                AC_LINK_IFELSE(
                    [AC_LANG_PROGRAM(
                        [
                            #include <orbsvcs/SSLIOPC.h>
                        ],
                        [
                            CORBA::Object_ptr t = CORBA::Object::_nil();
                            SSLIOP::Current::_narrow(t);
                        ])],
                    [
                        _AI_LIST_PREPEND_WO_DUPLICATES([${ORB_LIBS}], [-lACE_SSL], ORB_LIBS)
                        ORB_LIBS="-lTAO_SSLIOP ${ORB_LIBS}"
                        AC_DEFINE([HAVE_LIBTAO_SSLIOP], [1], [Define if TAO's TAO_SSLIOP library is detected])
                        HAVE_LIBTAO_SSLIOP="yes"
                        _AI_LIST_PREPEND_WO_DUPLICATES([${EXT_ORB_LIBS}], [${AI_OPENSSL_LIBS}], EXT_ORB_LIBS)
                    ],
                    [
                        HAVE_LIBTAO_SSLIOP="no"
                    ])
                AC_MSG_RESULT([$HAVE_LIBTAO_SSLIOP])
            fi


            ORB_LIBS="${ORB_LIBS} ${EXT_ORB_LIBS}"

            CXXFLAGS="${AI_CHECK_TAO_save_CXXFLAGS}"
            CPPFLAGS="${AI_CHECK_TAO_save_CPPFLAGS}"
            LDFLAGS="${AI_CHECK_TAO_save_LDFLAGS}"
            LIBS="${AI_CHECK_TAO_save_LIBS}"


            _AI_LIST_ADD_SUFFIX([${ORB_BIN_DIRS}], [${PATH_SEPARATOR}], ORB_PATH)
            ORB_PATH="${ORB_PATH}\$\$PATH"
            if test "x${AI_BUILD_SHLIBPATH_VAR}" != "x"
            then
                _AI_LIST_ADD_SUFFIX([${ORB_LIB_DIRS}], [${PATH_SEPARATOR}], ORB_LD_LIBRARY_PATH)
                if test "x${AI_BUILD_SHLIBPATH_VAR}" != "xPATH"
                then
                    ORB_LD_LIBRARY_PATH="${ORB_LD_LIBRARY_PATH}\$\$${AI_BUILD_SHLIBPATH_VAR}"
                    IDLC="PATH=${ORB_PATH} ${AI_BUILD_SHLIBPATH_VAR}=${ORB_LD_LIBRARY_PATH} tao_idl"
                else
                    IDLC="PATH=${ORB_LD_LIBRARY_PATH}${ORB_PATH} tao_idl"
                fi
            else
                IDLC="PATH=${ORB_PATH} tao_idl"
            fi
            if test "x${ACE_ROOT}" != "x"
            then
                if test "x${TAO_ROOT}" != "x"
                then
                    IDLC="TAO_ROOT=${TAO_ROOT} ${IDLC}"
                fi
                IDLC="ACE_ROOT=${ACE_ROOT} ${IDLC}"
            fi

            _AI_LIST_ADD_PREFIX_AND_SUFFIX([${ORB_COSS_IDL_DIRS}], [-I], [ ], IDLCPPFLAGS)
            IDLCPPFLAGS="${AI_CHECK_TAO_save_IDLCPPFLAGS} ${IDLCPPFLAGS}"
            IDLCXXFLAGS="-in -hc .hpp -hs Server.hpp -hT Server_T.hpp -cs .cpp -ss Server.cpp -sT Server_T.cpp -ci .inl -si Server.inl -st Server_T.inl"

            # The double $ is required by make, but not when running the command directly with sh.
            IDLC_FIXED=`echo ${IDLC} | sed 's/[[$][$]]/$/g'`
            ORB_VERSION=`${SHELL} -c "${IDLC_FIXED} -V 2>&1 | grep version | head -n 1 | sed 's/^[[^(]]*version \([[0-9.]]*\).*$/\1/'"`

            TAO="yes"
            AC_DEFINE([HAVE_TAO], [1], [Define if TAO is used])
            ORB_DEFINES="${ORB_DEFINES} -DHAVE_TAO"
            ORB_TYPE="TAO"
        }


        AC_REQUIRE([AC_PROG_CXX])
        AC_REQUIRE([AI_BUILD_SHLIBPATH])

        AI_CHECK_TAO_save_IDLCPPFLAGS="${IDLCPPFLAGS}"
        findTao

        if test "x${TAO}" = "xyes"
        then
            _AI_ORB_BUILDTEST
            if test "x${ORB_BUILDTEST}" != "xyes"
            then
                TAO="no"
            fi
        fi
        ORB_DEFINES=""

        if test "x${TAO}" = "xyes"
        then
            AC_MSG_NOTICE([found TAO ${ORB_VERSION}])
        else
            AC_MSG_NOTICE([TAO not found])
            ORB_TYPE=""
            ORB_VERSION=""
            IDLC=""
            IDLCXXFLAGS=""
            IDLCPPFLAGS="${AI_CHECK_TAO_save_IDLCPPFLAGS}"
            ORB_CFLAGS=""
            ORB_CXXFLAGS=""
            ORB_CPPFLAGS=""
            ORB_LDFLAGS=""
            ORB_LIBS=""
            ORB_BIN_DIRS=""
            ORB_LIB_DIRS=""
            ORB_INC_DIRS=""
            ORB_COSS_IDL_DIRS=""
        fi

        AC_SUBST([ORB_TYPE])
        AC_SUBST([ORB_VERSION])
        AC_SUBST([IDLC])
        AC_SUBST([IDLCXXFLAGS])
        AC_SUBST([IDLCPPFLAGS])
        AC_SUBST([ORB_CFLAGS])
        AC_SUBST([ORB_CXXFLAGS])
        AC_SUBST([ORB_CPPFLAGS])
        AC_SUBST([ORB_LDFLAGS])
        AC_SUBST([ORB_LIBS])
        AC_SUBST([ORB_BIN_DIRS])
        AC_SUBST([ORB_LIB_DIRS])
        AC_SUBST([ORB_INC_DIRS])
        AC_SUBST([ORB_COSS_IDL_DIRS])

        AC_LANG_POP(C++)
    ])