# AX_LIB_OMNIORB(build_python = "no")
# -------------------------
AC_DEFUN([AX_LIB_OMNIORB],
    [
        need_omniorbpy="$1"
        AC_REQUIRE([PYTHON_SITE_PKG])
        AC_REQUIRE([PYTHON_VERSION])

        echo "need_omniorbpy is $need_omniorbpy"
        AC_LANG_PUSH(C++)

        AC_ARG_VAR([IDL_PY_CPP_FLAGS], [additional -I and -D IDL compiler flags])
        AC_ARG_VAR([IDLCPPFLAGS], [additional -I and -D IDL compiler flags])

        AC_ARG_WITH(
            [omniorb-prefix],
            AS_HELP_STRING(--with-omniorb-prefix=DIR,search for omniORB in DIR),
            [
                OMNIORB_PREFIX="${withval}"
            ],
            [
                OMNIORB_PREFIX=""
            ])

        checkOmniOrbPrefix()
        {
            OMNIORB_PREFIX="${1}"
            OMNIORB_PREFIX=`echo ${OMNIORB_PREFIX} | sed 's|[[\\/]]$||'`
            OMNIORBPY_PREFIX="${OMNIORB_PREFIX}"
            
            # using RELATIVE_ORB_LIB_DIRS is a hack to yield the path to 
            #	core omniORB libs relative to OMNIORB_PREFIX
            if test "x${OMNIORB_ARCH}" = "x"
            then
                if test ! -f "${OMNIORB_PREFIX}/bin/omniidl"
                then
                    return
                fi
                ORB_BIN_DIRS="${OMNIORB_PREFIX}/bin"
                ORB_LIB_DIRS="${OMNIORB_PREFIX}/lib"
                RELATIVE_ORB_LIB_DIRS="lib"
            else
                if test ! -f "${OMNIORB_PREFIX}/bin/${OMNIORB_ARCH}/omniidl"
                then
                    return
                fi
                ORB_BIN_DIRS="${OMNIORB_PREFIX}/bin/${OMNIORB_ARCH}"
                ORB_LIB_DIRS="${OMNIORB_PREFIX}/lib/${OMNIORB_ARCH}"
                RELATIVE_ORB_LIB_DIRS="lib/${OMNIORB_ARCH}"
            fi

            ORB_PY_BIN_DIRS="${ORB_BIN_DIRS}"
            ORB_PY_LIB_DIRS="${ORB_LIB_DIRS}"

            if test ! -f "${OMNIORB_PREFIX}/include/omniORB3/CORBA.h" && test ! -f "${OMNIORB_PREFIX}/include/omniORB4/CORBA.h"
            then
                OMNIORB_PREFIX=""
                OMNIORBPY_PREFIX=""
            else
                if test "x$need_omniorbpy" = "xyes" 
                then
                    dnl omniORB installs python modules in two places.
                    nonExecPySitePackages="${OMNIORB_PREFIX}/${PYTHON_RELATIVE_SITE_PKG}"
                    execPySitePackages="${OMNIORB_PREFIX}/${PYTHON_RELATIVE_EXEC_SITE_PKG}"

                    if test "$nonExecPySitePackages" = "$execPySitePackages"
                    then
                        PYTHON_PATH_WITH_ORB="$execPySitePackages"
                        RELATIVE_PYTHON_PATH_FOR_OMNIORBPY="${PYTHON_RELATIVE_SITE_PKG}"
                    else
                        PYTHON_PATH_WITH_ORB="$nonExecPySitePackages:$execPySitePackages"
                        RELATIVE_PYTHON_PATH_FOR_OMNIORBPY="${PYTHON_RELATIVE_SITE_PKG}:${PYTHON_RELATIVE_EXEC_SITE_PKG}"
                    fi
                    PYTHON_PATH_FOR_OMNIORBPY="$PYTHON_PATH_WITH_ORB"
                    if test -n "$PYTHONPATH"
                    then
                        PYTHON_PATH_WITH_ORB="$PYTHON_PATH_WITH_ORB:${PYTHONPATH}"
                    fi

                        dnl Terri - Only the first case below has been tested.
                    if test "x${AI_BUILD_SHLIBPATH_VAR}" != "x"
                    then
                        _AI_LIST_ADD_SUFFIX([${ORB_LIB_DIRS}${PATH_SEPARATOR}${PYTHON_PATH_WITH_ORB}], [${PATH_SEPARATOR}], P_ORB_LD_LIBRARY_PATH)
                        if test "x${AI_BUILD_SHLIBPATH_VAR}" != "xPATH"
                        then
                            failedInvoke="${AI_BUILD_SHLIBPATH_VAR}=${P_ORB_LD_LIBRARY_PATH} PYTHONPATH=$PYTHON_PATH_WITH_ORB python -c \"import omniORB\" 2>/dev/null"
                            ( 
                                eval ${AI_BUILD_SHLIBPATH_VAR}=${P_ORB_LD_LIBRARY_PATH}; 
                                eval export ${AI_BUILD_SHLIBPATH_VAR};  
                                PYTHONPATH="$PYTHON_PATH_WITH_ORB" python -c "import omniORB" 2>/dev/null
                            )
                            ac_status=$?
                            AC_MSG_NOTICE(["${failedInvoke} returned ${ac_status}"])
                        else
                            failedInvoke="PATH=${P_ORB_LD_LIBRARY_PATH}${PATH} PYTHONPATH=$OMNIORBPY_PREFIX/lib/python${PYTHON_VERSION}/site-packages python -c \"import omniORB\" 2>/dev/null"
                            (
                                eval PATH=${P_ORB_LD_LIBRARY_PATH}${PATH};
                                eval export $PATH;
                                PYTHONPATH="$PYTHON_PATH_WITH_ORB" python -c "import omniORB" 2>/dev/null
                            )
                            ac_status=$?
                            AC_MSG_NOTICE(["${failedInvoke} returned ${ac_status}"])
                        fi
                    else
                            failedInvoke="PYTHONPATH=$PYTHON_PATH_WITH_ORB python -c \"import omniORB\" 2>/dev/null"
                            PYTHONPATH="$PYTHON_PATH_WITH_ORB" python -c "import omniORB" 2>/dev/null
                            ac_status=$?
                            AC_MSG_NOTICE(["${failedInvoke} returned ${ac_status}"])
                    fi

                        dnl test taken from ac_python_module.m4
                    if ! test ${ac_status} -eq 0;
                    then
                        AC_MSG_WARN([$failedInvoke FAILED.])
                        OMNIORB_PREFIX=""
                        OMNIORBPY_PREFIX=""
                        PYTHON_PATH_FOR_OMNIORBPY=""
                        PYTHON_PATH_WITH_ORB=""
                    fi
                    JUST_OMNIORB_PYTHONPATH="$PYTHON_PATH_FOR_OMNIORBPY"
                    ORB_PYTHONPATH="$PYTHON_PATH_WITH_ORB"
                fi
            fi
        }

        checkOrbPythonLibPrefix() dnl Mark Holder added this test because his PYTHONPATH settings were messing up the omniidl compilation.  This test detects the problem.
        {
            ORB_PY_LIBRARYPATH="${1}"
            ORB_PY_LIBRARYPATH=`echo ${ORB_PY_LIBRARYPATH} | sed 's|[[\\/]]$||'`
            if test ! -d "${ORB_PY_LIBRARYPATH}/omniidl_be/cxx"
            then
                ORB_PY_LIBRARYPATH=""
            else
                if test "x$need_omniorbpy" = "xyes" 
                then
                    if test ! -f "${ORB_PY_LIBRARYPATH}/omniidl_be/python.py"
                    then
                        ORB_PY_LIBRARYPATH=""
                    fi
                fi
            fi
        }

        findOmniOrb()
        {
            OMNIORB="no"
            OMNIORBPY="no"
            AC_MSG_NOTICE([checking for omniORB python...])
            dnl AC_MSG_NOTICE([PYTHONPATH is $PYTHONPATH])

            ORB_DEFINES=""
            if test "x${acx_pthread_ok}" = "x"
            then
                ACX_PTHREAD
            fi
            if test "x${AI_SOCKET}" = "x"
            then
                AI_CHECK_SOCKET
            fi

            AC_MSG_NOTICE([checking for omniORB...])

            if test "x${acx_pthread_ok}" != "xyes" || test "x${AI_SOCKET}" != "xyes"
            then
                return
            fi

            if test "x${OMNIORB_PREFIX}" = "x"
            then
                AC_PATH_PROG(OMNIIDL, [omniidl], [])
                if test "x${OMNIIDL}" != "x"
                then
                    OMNIORB_PREFIX=`echo ${OMNIIDL} | sed 's|[[\\/]][[^\\/]]\{1,\}[[\\/]][[^\\/]]\{1,\}$||'`
                    OMNIORB_ARCH=`echo ${OMNIIDL} | sed 's|[[\\/]][[^\\/]]\{1,\}$||' | sed 's|^.*[[\\/]]\([[^\\/]]\{1,\}\)$|\1|'`
                    if test "x${OMNIORB_ARCH}" != "xbin"
                    then
                        OMNIORB_PREFIX=`echo ${OMNIORB_PREFIX} | sed 's|[[\\/]][[^\\/]]\{1,\}$||'`
                    fi
                    checkOmniOrbPrefix "${OMNIORB_PREFIX}"
                else
                    for OMNIORB_PREFIX in "/usr/local" "/usr" "/usr/pkg" "/opt/sfw" "/usr/sfw" "/opt/local"
                        do
                            checkOmniOrbPrefix "${OMNIORB_PREFIX}"
                            if test "x${OMNIORB_PREFIX}" != "x"
                            then
                                break
                            fi
                        done
                fi
            else
                checkOmniOrbPrefix "${OMNIORB_PREFIX}"
            fi
            if test "x${OMNIORB_PREFIX}" = "x"
            then
                return
            fi
            if test "x$need_omniorbpy" = "xyes" 
                then
                if test "x${OMNIORBPY_PREFIX}" = "x"
                then
                    return
                fi
            fi
            
            if test -f "${OMNIORB_PREFIX}/config/config.mk"
            then
                OMNIORB_ARCH=`grep '^ *platform *=' "${OMNIORB_PREFIX}/config/config.mk" | head -n 1`
                OMNIORB_ARCH=`echo ${OMNIORB_ARCH} | sed 's/^ *platform *= *\([[^ ]]\{1,\}\) *$/\1/'`
                if test "x${OMNIORB_ARCH}" = "x"
                then
                    return
                fi
                OMNIORB_DEFINES=`grep '^ *IMPORT_CPPFLAGS *+=' "${OMNIORB_PREFIX}/mk/platforms/${OMNIORB_ARCH}.mk" | head -n 1`
                OMNIORB_DEFINES=`echo ${OMNIORB_DEFINES} | sed 's/^ *IMPORT_CPPFLAGS *+= *\(.*\)$/\1/'`

                ORB_COSS_IDL_DIRS="${OMNIORB_PREFIX}/idl/COS"

                if test -f "${OMNIORB_PREFIX}/mk/unix.mk"
                then
                    ORB_VERSION=`grep '^ *OMNIORB_VERSION *=' "${OMNIORB_PREFIX}/mk/unix.mk" | head -n 1`
                    ORB_VERSION=`echo ${ORB_VERSION} | sed 's/^ *OMNIORB_VERSION *= *\([[^ ]]\{1,\}\) *$/\1/'`
                fi
            else
                OMNIORB_ARCH=""
                OMNIORB_DEFINES=""

                ORB_COSS_IDL_DIRS="${OMNIORB_PREFIX}/share/idl/omniORB/COS"

                if test -f "${OMNIORB_PREFIX}/include/omniORB4/acconfig.h"
                then
                    ORB_VERSION=`grep ' PACKAGE_VERSION ' "${OMNIORB_PREFIX}/include/omniORB4/acconfig.h" | head -n 1`
                    ORB_VERSION=`echo ${ORB_VERSION} | sed 's/^.*PACKAGE_VERSION *"\(.\{1,\}\)".*$/\1/'`
                fi
            fi
            ORB_PY_COSS_IDL_DIRS="${ORB_COSS_IDL_DIRS}"
            
            if test ! -d "${OMNIORB_PREFIX}/include"
            then
                return
            fi
            ORB_INC_DIRS="${OMNIORB_PREFIX}/include"
            ORB_COS_INC_DIR="${OMNIORB_PREFIX}/include/COS"

            for ORB_PY_LIBRARYPATH in "${OMNIORB_PREFIX}/${PYTHON_RELATIVE_SITE_PKG}" "${OMNIORBPY_PREFIX}/lib/python$PYTHON_VERSION/site-packages" "${OMNIORB_PREFIX}/lib/python$PYTHON_VERSION/site-packages"  "${PYTHON_SITE_PKG}"
                do
                    checkOrbPythonLibPrefix "${ORB_PY_LIBRARYPATH}"
                    if test "x${ORB_PY_LIBRARYPATH}" != "x"
                    then
                        break
                    fi
                done
            if test "x${ORB_PY_LIBRARYPATH}" = "x"
            then
                if test "x$need_omniorbpy" = "xyes" 
                then
                    AC_MSG_WARN([Could not find omniidl_be/cxx and omniidl_be/python.py in ${OMNIORB_PREFIX}/lib/python$PYTHON_VERSION/site-packages or ${PYTHON_SITE_PKG} ])
                else
                    AC_MSG_WARN([Could not find omniidl_be/cxx in ${OMNIORB_PREFIX}/lib/python$PYTHON_VERSION/site-packages or ${PYTHON_SITE_PKG} ])
                fi
                return
            fi

            ORB_CFLAGS="${PTHREAD_CFLAGS}"
            ORB_CXXFLAGS="${PTHREAD_CFLAGS}"
            ORB_LIBS=""

            EXT_ORB_LIBS=""
            _AI_LIST_PREPEND_WO_DUPLICATES([${EXT_ORB_LIBS}], [${PTHREAD_LIBS}], EXT_ORB_LIBS)
            _AI_LIST_PREPEND_WO_DUPLICATES([${EXT_ORB_LIBS}], [${AI_SOCKET_LIBS}], EXT_ORB_LIBS)

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

            AI_CHECK_OMNIORB_save_CXXFLAGS="${CXXFLAGS}"
            AI_CHECK_OMNIORB_save_CPPFLAGS="${CPPFLAGS}"
            AI_CHECK_OMNIORB_save_LDFLAGS="${LDFLAGS}"
            AI_CHECK_OMNIORB_save_LIBS="${LIBS}"
            CXXFLAGS="${AI_CHECK_OMNIORB_save_CXXFLAGS} ${ORB_CXXFLAGS}"
            CPPFLAGS="${AI_CHECK_OMNIORB_save_CPPFLAGS} ${ORB_CPPFLAGS}"
            LDFLAGS="${AI_CHECK_OMNIORB_save_LDFLAGS} ${ORB_LDFLAGS}"

            if test -d "${OMNIORB_PREFIX}/include/omniORB4"
            then
                AC_MSG_CHECKING([for omniORB's mandatory libraries])
                LIBS="-lomniORB4 -lomnithread ${ORB_LIBS} ${EXT_ORB_LIBS}"
                AC_LINK_IFELSE(
                    [AC_LANG_PROGRAM(
                        [
                            #include <omniORB4/CORBA.h>
                        ],
                        [
                            int argc;
                            CORBA::ORB_init(argc, 0);
                        ])],
                    [
                        ORB_LIBS="-lomniORB4 -lomnithread ${ORB_LIBS}"
                    ],
                    [
                        AC_MSG_RESULT([no])
                        CXXFLAGS="${AI_CHECK_OMNIORB_save_CXXFLAGS}"
                        CPPFLAGS="${AI_CHECK_OMNIORB_save_CPPFLAGS}"
                        LDFLAGS="${AI_CHECK_OMNIORB_save_LDFLAGS}"
                        LIBS="${AI_CHECK_OMNIORB_save_LIBS}"
                        return
                    ])
                AC_MSG_RESULT([yes])

                AC_MSG_CHECKING([for omniORB's omniDynamic4 library])
                LIBS="-lomniDynamic4 ${ORB_LIBS} ${EXT_ORB_LIBS}"
                AC_LINK_IFELSE(
                    [AC_LANG_PROGRAM(
                        [
                            #include <omniORB4/CORBA.h>
                        ],
                        [
                            CORBA::Any any;
                        ])],
                    [
                        ORB_LIBS="-lomniDynamic4 ${ORB_LIBS}"
                        AC_DEFINE([HAVE_LIBomniDynamic4], [1], [Define if omniORB's omniDynamic4 library is detected])
                        HAVE_LIBomniDynamic4="yes"
                    ],
                    [
                        HAVE_LIBomniDynamic4="no"
                    ])
                AC_MSG_RESULT([$HAVE_LIBomniDynamic4])

                AC_MSG_CHECKING([for omniORB's COS4 library])
                LIBS="-lCOS4 ${ORB_LIBS} ${EXT_ORB_LIBS}"
                AC_LINK_IFELSE(
                    [AC_LANG_PROGRAM(
                        [
                            #include <omniORB4/CORBA.h>
                            #include <COS/CosTime.hh>
                        ],
                        [
                            CORBA::Object_ptr t = CORBA::Object::_nil();
                            CosTime::TimeService::_narrow(t);
                        ])],
                    [
                        ORB_LIBS="-lCOS4 ${ORB_LIBS}"
                        AC_DEFINE([HAVE_LIBCOS4], [1], [Define if omniORB's COS4 library is detected])
                        HAVE_LIBCOS4="yes"
                    ],
                    [
                        HAVE_LIBCOS4="no"
                    ])
                AC_MSG_RESULT([$HAVE_LIBCOS4])

                AC_MSG_CHECKING([for omniORB's COSDynamic4 library])
                LIBS="-lCOSDynamic4 ${ORB_LIBS} ${EXT_ORB_LIBS}"
                AC_LINK_IFELSE(
                    [AC_LANG_PROGRAM(
                        [
                            #include <omniORB4/CORBA.h>
                            #include <COS/CosTime.hh>
                        ],
                        [
                            CORBA::Object_ptr t = CORBA::Object::_nil();
                            CORBA::Any any;
                            any <<= CosTime::TimeService::_narrow(t);
                        ])],
                    [
                        ORB_LIBS="-lCOSDynamic4 ${ORB_LIBS}"
                        AC_DEFINE([HAVE_LIBCOSDynamic4], [1], [Define if omniORB's COSDynamic4 library is detected])
                        HAVE_LIBCOSDynamic4="yes"
                    ],
                    [
                        HAVE_LIBCOSDynamic4="no"
                    ])
                AC_MSG_RESULT([$HAVE_LIBCOSDynamic4])

                AC_MSG_CHECKING([for omniORB's omniCodeSets4 library])
                LIBS="-lomniCodeSets4 ${ORB_LIBS} ${EXT_ORB_LIBS}"
                AC_LINK_IFELSE(
                    [AC_LANG_PROGRAM(
                        [
                            #include <omniORB4/optionalFeatures.h>
                        ],
                        [
                            _omni_omniCodeSets_should_be_linked_but_is_not_ = 1; 
                        ])],
                    [
                        ORB_LIBS="-lomniCodeSets4 ${ORB_LIBS}"
                        AC_DEFINE([HAVE_LIBomniCodeSets4], [1], [Define if omniORB's omniCodeSets4 library is detected])
                        HAVE_LIBomniCodeSets4="yes"
                    ],
                    [
                        HAVE_LIBomniCodeSets4="no"
                    ])
                AC_MSG_RESULT([$HAVE_LIBomniCodeSets4])

                LIBS="${AI_CHECK_OMNIORB_save_LIBS}"
                if test "x${AI_OPENSSL}" = "x"
                then
                    AI_CHECK_OPENSSL
                fi
                if test "x${AI_OPENSSL}" = "xyes"
                then
                    AC_MSG_CHECKING([for omniORB's omnisslTP library])
                    LIBS="${ORB_LIBS} -lomnisslTP ${EXT_ORB_LIBS} ${AI_OPENSSL_LIBS}"
                    AC_LINK_IFELSE(
                        [AC_LANG_PROGRAM(
                            [
                                #include <omniORB4/CORBA.h>
                                #include <omniORB4/sslContext.h>
                            ],
                            [
                                sslContext::singleton = NULL;
                            ])],
                        [
                            ORB_LIBS="${ORB_LIBS} -lomnisslTP"
                            AC_DEFINE([HAVE_LIBomnisslTP], [1], [Define if omniORB's omnisslTP library is detected])
                            HAVE_LIBomnisslTP="yes"
                            _AI_LIST_PREPEND_WO_DUPLICATES([${EXT_ORB_LIBS}], [${AI_OPENSSL_LIBS}], EXT_ORB_LIBS)

                            _AI_LIST_CONTAINS([${ORB_LIB_DIRS}], [${AI_OPENSSL_PREFIX}/lib],
                                [],
                                [
                                    ORB_LIB_DIRS="${ORB_LIB_DIRS} ${AI_OPENSSL_PREFIX}/lib"
                                    _AI_LIST_ADD_PREFIX_AND_SUFFIX([${ORB_LIB_DIRS}], [-L], [ ], ORB_LDFLAGS)
                                    LDFLAGS="${AI_CHECK_OMNIORB_save_LDFLAGS} ${ORB_LDFLAGS}"
                                ])
                            _AI_LIST_CONTAINS([${ORB_BIN_DIRS}], [${AI_OPENSSL_PREFIX}/bin],
                                [],
                                [
                                    ORB_BIN_DIRS="${ORB_BIN_DIRS} ${AI_OPENSSL_PREFIX}/bin"
                                ])
                            _AI_LIST_CONTAINS([${ORB_INC_DIRS}], [${AI_OPENSSL_PREFIX}/include],
                                [],
                                [
                                    ORB_INC_DIRS="${ORB_INC_DIRS} ${AI_OPENSSL_PREFIX}/include"
                                    _AI_LIST_ADD_PREFIX_AND_SUFFIX([${ORB_INC_DIRS}], [-I], [ ], ORB_CPPFLAGS)
                                    ORB_CPPFLAGS="${OMNIORB_DEFINES} ${ORB_CPPFLAGS}"
                                    CPPFLAGS="${AI_CHECK_OMNIORB_save_CPPFLAGS} ${ORB_CPPFLAGS}"
                                ])
                        ],
                        [
                            HAVE_LIBomnisslTP="no"
                        ])
                    AC_MSG_RESULT([$HAVE_LIBomnisslTP])
                fi

                OMNIORB3="no"
                OMNIORB4="yes"
                AC_DEFINE([HAVE_OMNIORB4], [1], [Define if omniORB 4.x.y is used])
                ORB_DEFINES="${ORB_DEFINES} -DHAVE_OMNIORB4"

            fi    # omniORB3 code removed by MTH changes were made to omniORB4 section and I could not test on 3.

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

            CXXFLAGS="${AI_CHECK_OMNIORB_save_CXXFLAGS}"
            CPPFLAGS="${AI_CHECK_OMNIORB_save_CPPFLAGS}"
            LDFLAGS="${AI_CHECK_OMNIORB_save_LDFLAGS}"
            LIBS="${AI_CHECK_OMNIORB_save_LIBS}"

            _AI_LIST_ADD_SUFFIX([${ORB_BIN_DIRS}], [${PATH_SEPARATOR}], ORB_PATH)
            _AI_LIST_ADD_SUFFIX([${ORB_PY_BIN_DIRS}], [${PATH_SEPARATOR}], PY_IDLC_DIR)
            PY_IDLC_PATH="${ORB_PY_BIN_DIRS}/omniidl"
            PY_IDLC_DIR="${PY_IDLC_DIR}:$PATH"
            
            ORB_PATH="${ORB_PATH}\$\$PATH"

            dnl omniORB installs python modules in two places.
            nonExecPySitePackages="${OMNIORB_PREFIX}/${PYTHON_RELATIVE_SITE_PKG}"
            execPySitePackages="${OMNIORB_PREFIX}/${PYTHON_RELATIVE_EXEC_SITE_PKG}"
            if test "$nonExecPySitePackages" = "$execPySitePackages"
            then
                PYTHON_PATH_WITH_ORB=":$execPySitePackages"
            else
                PYTHON_PATH_WITH_ORB="$nonExecPySitePackages:$execPySitePackages"
            fi
            if test "x$PYTHONPATH" != "x"
            then
                PYTHON_PATH_WITH_ORB="$PYTHON_PATH_WITH_ORB:$PYTHONPATH" 
            fi

            if test "x${AI_BUILD_SHLIBPATH_VAR}" != "x"
            then
                _AI_LIST_ADD_SUFFIX([${ORB_LIB_DIRS}], [${PATH_SEPARATOR}], ORB_LD_LIBRARY_PATH)
                _AI_LIST_ADD_SUFFIX([${ORB_PY_LIB_DIRS}], [${PATH_SEPARATOR}], ORB_PY_LD_LIBRARY_PATH)
                if test "x${AI_BUILD_SHLIBPATH_VAR}" != "xPATH"
                then
                    ORB_LD_LIBRARY_PATH="${ORB_LD_LIBRARY_PATH}:\$${AI_BUILD_SHLIBPATH_VAR}"
                    ORB_PY_LD_LIBRARY_PATH="${ORB_PY_LD_LIBRARY_PATH}:\$${AI_BUILD_SHLIBPATH_VAR}"
                    IDLC="PATH=${ORB_PATH} ${AI_BUILD_SHLIBPATH_VAR}=${ORB_LD_LIBRARY_PATH} PYTHONPATH=${PYTHON_PATH_WITH_ORB} omniidl"
                else
                    IDLC="PATH=${ORB_LD_LIBRARY_PATH}${ORB_PATH} PYTHONPATH=${PYTHON_PATH_WITH_ORB} omniidl"
                fi
            else
                IDLC="PATH=${ORB_PATH} PYTHONPATH=${PYTHON_PATH_WITH_ORB} omniidl"
            fi
            
            _AI_LIST_ADD_PREFIX_AND_SUFFIX([${ORB_COSS_IDL_DIRS}], [-I], [ ], IDLCPPFLAGS)
            _AI_LIST_ADD_PREFIX_AND_SUFFIX([${ORB_PY_COSS_IDL_DIRS}], [-I], [ ], IDL_PY_CPP_FLAGS)


            IDLCPPFLAGS="${AI_CHECK_OMNIORB_save_IDLCPPFLAGS} ${IDLCPPFLAGS}"
            IDL_PY_CPP_FLAGS="${AI_CHECK_OMNIORB_save_IDL_PY_CPP_FLAGS} ${IDL_PY_CPP_FLAGS}"
            dnl MTH removed old definition (we were just overriding it in framework/C++/CipresIDL/Makefile.am)
            dnl IDLCXXFLAGS="-bcxx -Wba -Wbtp -Wbh=.hpp -Wbs=.cpp -Wbd=Dyn.cpp -Wbuse_quotes"
            IDLCXXFLAGS="-bcxx -Wbh=.hpp -Wbs=.cpp -Wbuse_quotes"
            IDLPYFLAGS="-bpython"

            OMNIORB="yes"
            OMNIORBPY="yes"
            ORB_PY_TYPE="omniORBpy"
            AC_DEFINE([HAVE_OMNIORB], [1], [Define if omniORB is used])
            ORB_DEFINES="${ORB_DEFINES} -DHAVE_OMNIORB"
            ORB_TYPE="omniORB"
        }

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

        AX_LIB_OMNIORB_save_IDLCPPFLAGS="${IDLCPPFLAGS}"
        AX_LIB_OMNIORB_save_IDL_PY_CPP_FLAGS="${IDL_PY_CPP_FLAGS}"
        findOmniOrb

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

        if test "x${OMNIORB}" = "xyes"
        then
            if test "x$need_omniorbpy" = "xyes"
            then
                AC_MSG_NOTICE([found omniORB ${ORB_VERSION} and omniORBpy])
            else
                AC_MSG_NOTICE([found omniORB ${ORB_VERSION}])
            fi
        else
            if test "x$need_omniorbpy" = "xyes"
            then
                AC_MSG_NOTICE([omniORB or omniORBpy not found])
            else
                AC_MSG_NOTICE([omniORB not found])
            fi
            ORB_TYPE=""
            ORB_VERSION=""
            IDLC=""
            IDLCXXFLAGS=""
            IDLCPPFLAGS="${AX_LIB_OMNIORB_save_IDLCPPFLAGS}"
            ORB_CFLAGS=""
            ORB_CXXFLAGS=""
            ORB_CPPFLAGS=""
            ORB_LDFLAGS=""
            ORB_LIBS=""
            ORB_BIN_DIRS=""
            ORB_LIB_DIRS=""
            RELATIVE_ORB_LIB_DIRS=""
            ORB_INC_DIRS=""
            ORB_COS_INC_DIR=""
            ORB_COSS_IDL_DIRS=""
            OMNIORB_PREFIX=""
            IDLPYFLAGS=""
            IDL_PY_CPP_FLAGS="${AX_LIB_OMNIORB_save_IDL_PY_CPP_FLAGS}"
            ORB_PY_COSS_IDL_DIRS=""

        fi
        
        if test "x$need_omniorbpy" = "xyes" 
        then
            if test "x${OMNIORBPY}" = "xyes"
            then
                AC_MSG_NOTICE([found omniORBpy])
            else
                AC_MSG_NOTICE([omniORBpy not found])
                IDLPYFLAGS=""
                IDL_PY_CPP_FLAGS="${AI_CHECK_OMNIORBPY_save_IDL_PY_CPP_FLAGS}"
                ORB_PY_COSS_IDL_DIRS=""
                RELATIVE_PYTHON_PATH_FOR_OMNIORBPY=""
            fi
        fi
        
        AC_SUBST([IDLPYFLAGS])
        AC_SUBST([IDL_PY_CPP_FLAGS])
        AC_SUBST([ORB_PY_COSS_IDL_DIRS])
        AC_SUBST([PY_IDLC_PATH])
        AC_SUBST([ORB_PYTHONPATH])
        AC_SUBST([JUST_OMNIORB_PYTHONPATH])
        AC_SUBST([RELATIVE_PYTHON_PATH_FOR_OMNIORBPY])
            

        AC_SUBST([AI_BUILD_SHLIBPATH_VAR])
        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([RELATIVE_ORB_LIB_DIRS])
        AC_SUBST([ORB_INC_DIRS])
        AC_SUBST([ORB_COS_INC_DIR])
        AC_SUBST([ORB_COSS_IDL_DIRS])
        AC_SUBST([OMNIORB_PREFIX])

        AC_PROVIDE([OMNIORB_PREFIX])

        AC_SUBST([IDLPYFLAGS])
        AC_SUBST([IDL_PY_CPP_FLAGS])
        AC_SUBST([ORB_PY_COSS_IDL_DIRS])
        AC_SUBST([PY_IDLC_PATH])
        AC_SUBST([ORB_PYTHONPATH])
        AC_SUBST([JUST_OMNIORB_PYTHONPATH])
        AC_PROVIDE([ORB_LIB_DIRS])
        AC_PROVIDE([RELATIVE_ORB_LIB_DIRS])

        AC_LANG_POP(C++)
    ])