SPATH=`echo $PATH | tr ' ' '\177' | tr ':' ' '`

pathcheck ()
{
    for i in $SPATH
    do
        PATHCHECK_FOUND="`echo $i | tr '\177' ' '`/$1"
        test -f "$PATHCHECK_FOUND" && return 0
    done
    PATHCHECK_FOUND=
    return 1
}

convert_windows_path ()
{
    case `uname` in
        CYGWIN_NT*)
            if [ ! -d "$1" ]
            then
            	  echo "Error: Path $1 does not exist"
            	  return 1
            fi
            #Make it a dos path to remove all spaces
            DOS_CONV_PATH=`cygpath -d "$1"`
            if [ $? != 0 ]
            then
                echo "Error: Could not convert to dos path $1"
                return 1
            fi
            #Now turn into a unix path for useage
            UNIX_CONV_PATH=`cygpath -u $DOS_CONV_PATH 2>/dev/null`
            if [ $? != 0 ]
            then
                echo "Error: Could not convert to unix path $1"
                return 1
            fi
            ;;
        *)
            UNIX_CONV_PATH="$1"
            DOS_CONV_PATH="$1"
            ;;
    esac
    return 0
}

csharp_check ()
{
    REQUIRED_VERSION="v2.0.50727"
    echo -n "C#: "
    pathcheck csc.exe
    if [ $? != 0 ]
    then
        MAIN_DRIVE=`echo $SYSTEMDRIVE | awk -F ':' '{ print $1 }'`
        if [ ! -d "/cygdrive/$MAIN_DRIVE/Windows/Microsoft.NET/Framework" ]
        then
            echo "Error - Microsoft.NET Framwork compiler not installed please add to PATH"
            return 1
        fi
        VERSIONS=`ls /cygdrive/$MAIN_DRIVE/Windows/Microsoft.NET/Framework | grep -E ^v`
        for i in $VERSIONS
        do
            NET_VERSION=`echo $i | tr -d '/'`
            echo "$REQUIRED_VERSION $NET_VERSION" | \
            awk ' \
            FS="" ;\
            { \
                vera1 = gensub( "^v([0-9]*).(.*)$", "\\1", 1 ) ; \
                vera2 = gensub( "^v([0-9]*).([0-9]*)(.*)$", "\\2", 1 ) ;\
                vera3 = gensub( "^v([0-9]*).([0-9]*).?([0-9]*)(.*)$", "\\3", 1 ) ;\
                verb1 = gensub( ".* v([0-9]*).([0-9]*).?([0-9]*)$", "\\1", 1 ) ; \
                verb2 = gensub( ".* v([0-9]*).([0-9]*).?([0-9]*)$", "\\2", 1 ) ;\
                verb3 = gensub( ".* v([0-9]*).([0-9]*).?([0-9]*)$", "\\3", 1 ) ;\
                if ( ( int(vera1) > int(verb1) ) \
                  || ( ( int(vera1) == int(verb1) ) && ( int(vera2) >  int(verb2) ) ) \
                  || ( ( int(vera1) == int(verb1) ) && ( int(vera2) == int(verb2) ) \
                  && (int(vera3) > int(verb3) ) ) ) \
                { \
                    exit 0 ; \
                } \
                else \
                { \
                    exit 1 ; \
                } \
            }'
            if [ "$?" = "1" ]
            then
                if [ ! -f "/cygdrive/$MAIN_DRIVE/Windows/Microsoft.NET/Framework/$i/csc.exe" ]
                then
                    continue
                fi

                PATH="/cygdrive/$MAIN_DRIVE/Windows/Microsoft.NET/Framework/$i:$PATH"
                break
            fi
        done
        if [ ! -f "/cygdrive/$MAIN_DRIVE/Windows/Microsoft.NET/Framework/$i/csc.exe" ]
        then
            echo "Error - no valid Microsoft.NET Framwork compiler installed"
            return 1
        fi
    else
        CSC_EXE=`which csc`
        if [ "$CSC_EXE" = "/usr/bin/csc" -o  "$CSC_EXE" = "/bin/csc" ]
        then
            echo "Error - Microsoft.NET Framwork compiler not installed please add to PATH"
            return 1
        fi
    fi

    echo "OK - using version `csc -help | grep \"Framework version\" | awk '{ print $NF }'`"
    return 0
}

# test if CL.exe is at least vs8
msvs_check ()
{
    echo -n "VS: "
    pathcheck cl.exe
    if [ $? != 0 ]
    then
        if [ -z "$VS_HOME" ]
        then
            echo "Error - No VS_HOME not set"
            return 1
        fi
        if [ ! -d "$VS_HOME" ]
        then
            echo "Error - $VS_HOME is not set to a directory"
            return 1
        fi
    else
        CL_EXE=`which cl.exe`
        if [ "$?" != "0" ]
        then
            echo "Error - cl.exe not found"
            return 1
        fi
  	    VS_HOME=`dirname $CL_EXE`
  	    VS_HOME=`dirname $VS_HOME`
  	    VS_HOME=`dirname $VS_HOME`
        set_var VS_HOME "$VS_HOME"
    fi
    convert_windows_path "$VS_HOME"
    if [ $? != 0 ]
    then
        return 1
    fi

    PATH="$UNIX_CONV_PATH/VC/bin:$PATH"
    PATH="$UNIX_CONV_PATH/Common7/IDE:$PATH"
    PATH="$OSPL_OUTER_HOME/testsuite/lib/$SPLICE_HOST:$PATH"
    set_var PATH "$PATH"

    COMPILER_VER=`cl -help 2>&1 | tr -d '\r' | head -1 | awk '{ printf v$8; }'`
    if [ -z $COMPILER_VER ]
    then
        echo "Error - Compiler version cannot be determined"
        return 1
    fi
    CL_MAJOR=`echo $COMPILER_VER | cut -f 1 -d .`
    if [ $CL_MAJOR -lt 14 ]
    then
        echo "Error - Only .NET 2005 and above supported"
        return 1
    fi

    if [ $CL_MAJOR = 14 ]
    then
        COMPILER_VER="VS .NET 2005"

        LIBPATH="$DOS_CONV_PATH\VC\ATLMFC\LIB"
        LIB="$DOS_CONV_PATH\VC\LIB;$DOS_CONV_PATH\VC\ATLMFC\LIB"
        FrameworkSDKDir="$UNIX_CONV_PATH/SDK/v2.0"
        set_var FrameworkSDKDir "$FrameworkSDKDir"
        set_var LIBPATH "$LIBPATH"
        set_var LIB "$LIB"

    fi

    if [ $CL_MAJOR = 15 ]
    then
        COMPILER_VER="VS .NET 2008"

        LIB="$DOS_CONV_PATH\VC\LIB;"
        SDK_DIR="$UNIX_CONV_PATH/../Microsoft SDKs/Windows/v6.0A"
        FrameworkSDKDir=`cygpath -d "$SDK_DIR"`
		PATH="$FrameworkSDKDir/bin:$PATH"
        set_var FrameworkSDKDir "$FrameworkSDKDir"
        set_var LIBPATH "$LIBPATH"
        set_var LIB "$LIB"
    fi

    echo "OK - using $COMPILER_VER"

    VS_VER=$CL_MAJOR
    set_var VS_VER "$VS_VER"

    return 0
}


# test if gcc is at least v3.2
gcc_check ()
{
    echo -n "GCC: "
    pathcheck gcc
    if [ $? != 0 ]
    then
        echo "Error - Not found"
        return 1
    fi

    GCC_MAJOR=`gcc -dumpversion | cut -f 1 -d .`
    if [ $GCC_MAJOR -lt 3 ]
    then
        echo "Error - Only gcc 3.2 and above is supported"
        return 1
    fi

    GCC_MINOR=`gcc -dumpversion | cut -f 2 -d .`
    if [ $GCC_MAJOR -eq 3 -a $GCC_MINOR -lt 2 ]
    then
        echo "Error - Only gcc 3.2 and above is supported"
        return 1
    fi

    echo "OK - using version" `gcc -dumpversion`
    return 0
}

# test if sun studio is at version 12
sun_cc_studio12_check ()
{
    echo -n "cc: "
    pathcheck cc
    if [ $? != 0 ]
    then
        echo "Error - Not found"
        return 1
    fi
    cc_VER=`cc -V 2>&1 | grep '^cc:' | sed 's/\(.*Sun C \)\([0-9.]*\)\( .*\)/\2/'`     
    if [ ${cc_VER} != "5.9" ]
    then
        echo "Error - Only SunCC 5.9 (Studio 12) is supported"
        return 1
    fi

    echo "OK - using version" `cc -V 2>&1 |  grep '^cc:'`
    return 0
}

# require GNU make 3.80 or 3.81
make_check ()
{
    echo -n "MAKE: "
    pathcheck make
    if [ $? != 0 ]
    then
        echo "Error - Not found"
        return 1
    fi

    MAKE_MAJOR=`make -v 2>/dev/null | head -1 | cut -f 2 -d . | cut -f 3 -d ' '`
    if [ $MAKE_MAJOR -lt 3 ]
    then
        echo "Error - Only make 3.80 and above is supported"
        return 1
    fi

    MAKE_MINOR=`make -v 2>/dev/null | head -1 | cut -f 2 -d .`
    if [ $MAKE_MAJOR -eq 3 -a $MAKE_MINOR -lt 80 ]
    then
        echo "Error - Only make 3.80 and above is supported"
        return 1
    fi

    echo "OK - using `make -v 2>/dev/null | head -1`"
    return 0
}

# required Bison
bison_check ()
{
    echo -n "BISON: "
    pathcheck bison
    if [ $? != 0 ]
    then
        echo "Error - Not found"
        return 1
    fi
    BISON_VERSION=`bison -V 2>/dev/null | head -1`
    #BISON_MAJOR=`echo $BISON_VERSION | cut -f 1 -d '.' | cut -f 4 -d ' '`
    #if [ $BISON_MAJOR -lt 2 ]
    #then
    #    echo "Error - Only bison 2.x and above is supported"
    #    return 1
    #fi

    echo "OK - using $BISON_VERSION"
    return 0
}

# required Flex
flex_check ()
{
    echo -n "FLEX: "
    pathcheck flex
    if [ $? != 0 ]
    then
        echo "Error - Not found"
        return 1
    fi

    FLEX_VERSION=`flex -V | cut -f 2 -d ' '`
    # some flex versions say "flex version x" rather than "flex x"
    if [ "$FLEX_VERSION" = "version" ]
    then
        FLEX_VERSION=`flex -V | cut -f 3 -d ' '`
    fi
    #FLEX_MAJOR=`echo $FLEX_VERSION | cut -f 1 -d '.'`
    #if [ $FLEX_MAJOR -lt 2 ]
    #then
    #    echo "Error - Only flex 2.5.x and above is supported"
    #    return 1
    #fi
    #FLEX_MINOR=`echo $FLEX_VERSION | cut -f 2 -d '.'`
    #if [ $FLEX_MAJOR -eq 2 -a $FLEX_MINOR -lt 5 ]
    #then
    #    echo "Error - Only flex 2.5.x and above is supported"
    #    return 1
    #fi

    echo "OK - using $FLEX_VERSION"
    return 0
}

# require ar and ld
binutils_native_check ()
{
    echo -n "BINUTILS: "

    pathcheck ar
    if [ $? != 0 ]
    then
        echo "Error - ar Not found"
        return 1
    fi

    pathcheck ld
    if [ $? != 0 ]
    then
        echo "Error - ld Not found"
        return 1
    fi

    echo "OK"
    return 0
}

# require javac and check JAVA_HOME
javac_check ()
{
    echo -n "JAVAC: "
    REQUIRED_VERSION=1.5
    REQUIRED_VERSION=`echo $REQUIRED_VERSION | sed -e 's;\.;0;g'`

    # Check JAVA_HOME directory first
    if [ -n "$JAVA_HOME" ]
    then
        convert_windows_path "$JAVA_HOME"
        if [ $? != 0 ]
        then
            return 1
        fi
        JAVAC_EXE="$UNIX_CONV_PATH/bin/javac"
        if [ ! -f "$JAVAC_EXE" ]
        then
            no_javac
            return $?
        fi
        PATH="$UNIX_CONV_PATH/bin:$PATH"
        set_var PATH "$PATH"
    else
        # If not check the path for java
        pathcheck javac
        if [ $? != 0 ]
        then
            no_javac
            return $?
        fi
        T_JAVAC_EXE="$PATHCHECK_FOUND"
        if [ "$?" != "0" ]
        then
            no_javac
            return $?
        fi
        JAVAC_EXE=`readlink -f "$T_JAVAC_EXE"`
    fi

    "$JAVAC_EXE" -version 2> javac.ver
    REAL_VERSION=`cat javac.ver | grep "javac" | head -1 | awk '{ print $2 }'`
    JAVAC_VERSION=`echo $REAL_VERSION | awk -F'.' '{ print $1"."$2 }' | sed -e 's;\.;0;g'`
    rm -f javac.ver
    if [ -n "$JAVAC_VERSION" ]
    then
        if [ "$JAVAC_VERSION" -ge "$REQUIRED_VERSION" ]
        then
            JAVA_HOME=`echo "$JAVAC_EXE" | sed 's@/bin/javac$@@' `
            set_var JAVA_HOME "$JAVA_HOME"
        else
            echo "Error - Only JAVA 1.5 and above is supported"
            return 1
        fi
        if [ ! -z "$OSPL_OUTER_HOME"  -a "$JAVAC_VERSION" -ne "$REQUIRED_VERSION" ]
        then
            echo "Error - Only JAVA 1.5 is supported"
            return 1
        fi
    else
        echo "Error - Only JAVA 1.5 and above is supported"
        return 1
    fi

    LD_LIBRARY_PATH="$JAVA_HOME/lib:$LD_LIBRARY_PATH"

    T_LD_PATH=yes
    TYPE=`uname -m`
    case `uname` in
        Linux)
            if [ "$TYPE" = "x86_64" ]
            then
		        JAVA_PATH_EXT=amd64
		        LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$JAVA_HOME/jre/lib/$JAVA_PATH_EXT/server"
	        else
		        JAVA_PATH_EXT=i386
	        fi
            ;;
        SunOS)
            JAVA_PATH_EXT=sparc
            ;;
        CYGWIN_NT*)
            JAVA_PATH_EXT=i386
            PATH="$UNIX_CONV_PATH/lib:$PATH"
            PATH="$PATH:$UNIX_CONV_PATH/jre/lib/$JAVA_PATH_EXT"
            PATH="$PATH:$UNIX_CONV_PATH/jre/lib/$JAVA_PATH_EXT/client"
            PATH="$PATH:$UNIX_CONV_PATH/jre/lib/$JAVA_PATH_EXT/native_threads"
            set_var PATH "$PATH"
            T_LD_PATH=no
            ;;
        *)
            echo "Error - Not yet supported Java setup"
            return 1
            ;;
    esac

    if [ "$T_LD_PATH" != "no" ]
    then
        LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$JAVA_HOME/jre/lib/$JAVA_PATH_EXT"
        LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$JAVA_HOME/jre/lib/$JAVA_PATH_EXT/client"
        LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$JAVA_HOME/jre/lib/$JAVA_PATH_EXT/native_threads"
        set_var LD_LIBRARY_PATH "$LD_LIBRARY_PATH"
        export LD_LIBRARY_PATH
    fi

    echo "OK - using JAVAC version $REAL_VERSION"
    echo "  setting JAVA_HOME to $JAVA_HOME"
    return 0
}

no_javac()
{
   if [ "$STRICT_CHECKS" = "yes" ]
   then
       echo "Error - Not found"
       return 1
   else
       echo "WARNING - Java compiler environment not set, building of all Java related features is disabled."
       unset_var INCLUDE_JAVA
       return 0;
   fi
}

tao_check()
{
   if [ "$STRICT_CHECKS" = "yes" ]
   then
       tao_check_fn "Error"
       RES=$?
   else
       tao_check_fn "Warning"
       if [ $? != 0 ]
       then
           echo "   TAO environment not set, disabling TAO related features."
           . $OSPL_HOME/setup/environment/exclude_tao
       fi
       RES=0
   fi
   return $RES
}

# require TAO and check TAO_ROOT
tao_check_fn ()
{
    echo -n "TAO: "
    pathcheck tao_idl
    if [ $? != 0 ]
    then
        if [ -z "$TAO_ROOT" ]
        then
            echo "$1 - No TAO found"
            return 1
        fi
        if [ ! -d "$TAO_ROOT" ]
        then
            echo "$1 - $TAO_ROOT is not set to a directory"
            return 1
        fi
    else
        TAOIDL_EXE="$PATHCHECK_FOUND"
        if [ "$?" != "0" ]
        then
            echo "$1 - Not TAO found"
            return 1
        fi
        TAO_ROOT1=`dirname "$TAOIDL_EXE"`
  	    TAO_ROOT=`dirname "$TAO_ROOT1"`
        set_var TAO_ROOT "$TAO_ROOT"
  	fi
    LD_LIBRARY_PATH="$TAO_ROOT/lib:$LD_LIBRARY_PATH"
    set_var LD_LIBRARY_PATH "$LD_LIBRARY_PATH"
    export LD_LIBRARY_PATH

    PATH="$TAO_ROOT/bin:$PATH"
    set_var PATH "$PATH"

    TAO_VERSION=`tao_idl -V 2>&1 | grep "PrismTech Version"`
    if [ $? != 0 ]
    then
        #ACE TAO
        TAO_VERSION=`tao_idl -V 2>&1 | grep "TAO_IDL_BE, version "`
        if [ $? = 0 ]
        then
            T_VAR="`echo $TAO_VERSION | awk '{ print $2\" \"$3 }'`"
            SPLICE_ORB=DDS_ACE_TAO_5_6_6
        else
            echo "$1 - Cannot setup TAO"
            tao_idl -V
            return 1
        fi
    else
        T_VAR="`echo $TAO_VERSION | grep \"PrismTech Version No: TAO 1.4.1\"`"
        if [ $? = 0 ]
        then
            SPLICE_ORB=DDS_OpenFusion_1_4_1
        else
            T_VAR="`echo $TAO_VERSION | grep \"PrismTech Version No: TAO 1.5.1\"`"
            if [ $? = 0 ]
            then
                SPLICE_ORB=DDS_OpenFusion_1_5_1
            else
                T_VAR="`echo $TAO_VERSION | grep \"PrismTech Version No: TAO 1.6.1\"`"
                if [ $? = 0 ]
                then
                    SPLICE_ORB=DDS_OpenFusion_1_6_1
                else
                    echo "$1 - Unsupported version of PrismTech TAO"
                    tao_idl -V
                    return 1
                fi
            fi
        fi
    fi

    set_var SPLICE_ORB $SPLICE_ORB
    echo "OK - SPLICE_ORB is TAO $TAO_VERSION"
    echo "  setting TAO_ROOT to $TAO_ROOT"
    return 0
}

# require gawk (no version checks)
gawk_check ()
{
    echo -n "GAWK: "
    pathcheck gawk
    if [ $? != 0 ]
    then
        echo "Error - Not found"
        return 1
    fi
    GAWK_VERSION=`gawk --version | head -1`
    echo "OK - using $GAWK_VERSION"
    return 0
}

jacorb_check()
{
   if [ "$STRICT_CHECKS" = "yes" ]
   then
       jacorb_check_fn "Error"
       RES=$?
   else
       jacorb_check_fn "Warning"
       if [ $? != 0 ]
       then
           echo "   JACORB environment not set, disabling JACORB related features."
           . $OSPL_HOME/setup/environment/exclude_jacorb
       fi
       RES=0
   fi
   return $RES
}

# converts mixed to unix paths. This operates on CLASSPATH

convert_native_classpath_to_unix_classpath ()
{
    case `uname` in
      CYGWIN_NT*)
         WIN32CP=true
    esac

    # Segments of classpath on windows ( seperated by ; ) may only have one
    # : character as either the first or second character.
    if [ "$WIN32CP" = "true" ]
    then
        for i in `echo $CLASSPATH | tr ' ' '%' | tr ';' ' '`
        {
            CPS=`echo $i| tr '%' ' ' `
            J=`echo $i | grep ':'`
            if [ "$J" != "" ]
            then
                case $J in
                   :*)
                      echo $J | grep '^:' | grep -v '^:[^:]*$' > /dev/null
                      RES=$?
                      ;;
                   *)
                      echo $J | grep -v '^[^:]:[^:]*$' > /dev/null
                      RES=$?
                      ;;
                esac
                if [ $RES = 0 ]
                then
                    echo
                    echo "ERROR: Invalid CLASSPATH segment \"$CPS\""
                    return 1 || return 1
                fi
            fi
        }

        PATHS=`echo $CLASSPATH | tr ' ' '%' | tr ';' ' ' | tr '\\\' '/' \
                               | sed 's@\(.\):@/cygdrive/\1@g'`
        CLASSPATH=`echo $CLASSPATH | sed 's@\([^;]\):@/cygdrive/\1@g' | tr ';' ':' | tr '\\\' '/'`
    else
        PATHS=`echo $CLASSPATH | tr ' ' '%' | tr ':' ' '`
    fi
}

# converts a unix path to the appropriate format on the native system
convert_unix_classpath_to_native_classpath ()
{
    case `uname` in
      CYGWIN_NT*)
         WIN32CP=true
    esac

    if [ "$WIN32CP" = "true" ]
    then
        WIN_CPATH=`echo "$CLASSPATH" | tr ' ' '%' | tr ':' ' '`
        CLASSPATH=""

        for i in $WIN_CPATH
        do
            CP=`echo $i | tr '%' ' '`
            CLASSPATH=`cygpath -w "$CP"`\;"$CLASSPATH"
        done
    fi
}

# jacorb_check - should be on the CLASSPATH
jacorb_check_fn ()
{
    echo -n "JACORB: "

    convert_native_classpath_to_unix_classpath
    FOUND_IN_CLASSPATH=false
    for i in PATHS
    do
        i=`echo $i | tr '%' ' '`
        if [ `basename $i` = "jacorb.jar" -o `basename $i` = "avalon-framework.jar" -o `basename $i` = "logkit.jar" ]
        then
            FOUND_IN_CLASSPATH=true
            JACORB_HOME=`dirname $i`
            JACORB_HOME=`dirname $JACORB_HOME`
            JACORB_HOME=`dirname $JACORB_HOME`
            set_var JACORB_HOME "$JACORB_HOME"
            break
        fi
    done

    if [ "$FOUND_IN_CLASSPATH" != "true" ]
    then
        if test ! -d "$JACORB_HOME"
        then
            echo "$1 - JACORB_HOME is not a directory"
            return 1
        fi
    fi

    if [ -z "$JACORB_HOME" ]
    then
        echo "$1 - JACORB_HOME not set and cannot find jacorb.jar in CLASSPATH"
        return 1
    fi

    if [ "$FOUND_IN_CLASSPATH" != "true" ]
    then
        if [ ! -f "$JACORB_HOME/lib/endorsed/jacorb.jar" ]
        then
            echo "$1 - $JACORB_HOME/lib/endorsed/jacorb.jar in CLASSPATH invalid"
            return 1
        fi
        CLASSPATH="$JACORB_HOME/lib/endorsed/jacorb.jar:$CLASSPATH"

        if [ ! -f "$JACORB_HOME/lib/endorsed/logkit.jar" ]
        then
            echo "$1 - $JACORB_HOME/lib/endorsed/logkit.jar in CLASSPATH invalid"
            return 1
        fi
        CLASSPATH="$JACORB_HOME/lib/endorsed/logkit.jar:$CLASSPATH"

        if [ ! -f "$JACORB_HOME/lib/endorsed/avalon-framework.jar" ]
        then
            echo "$1 - $JACORB_HOME/lib/endorsed/avalon-framework.jar in CLASSPATH invalid"
            return 1
        fi
        CLASSPATH="$JACORB_HOME/lib/endorsed/avalon-framework.jar:$CLASSPATH"
        if [ ! -f "$JACORB_HOME/lib/idl.jar" ]
        then
            echo "$1 - $JACORB_HOME/lib/idl.jar in CLASSPATH invalid"
            return 1
        fi
        CLASSPATH="$JACORB_HOME/lib/idl.jar:$CLASSPATH"

        convert_unix_classpath_to_native_classpath
        set_var CLASSPATH "$CLASSPATH"
    fi
    echo "OK"
    echo "  setting JACORB_HOME to $JACORB_HOME"
    if [ "$FOUND_IN_CLASSPATH" != "true" ]
    then
        echo "  \$JACORB_HOME/lib/endorsed/jacorb.jar added to CLASSPATH"
        echo "  \$JACORB_HOME/lib/endorsed/logkit.jar added to CLASSPATH"
        echo "  \$JACORB_HOME/lib/endorsed/avalon-framework.jar added to CLASSPATH"
    fi
    return 0
}

cleanup_checks ()
{
    unset msvs_check
    unset gcc_check
    unset make_check
    unset bison_check
    unset flex_check
    unset javac_check
    unset no_javac
    unset tao_check
    unset gawk_check
    unset csharp_check
    unset jacorb_check
    unset PATHCHECK_FOUND
    unset GCC_MAJOR GCC_MINOR BISON_VERSION FLEX_VERSION REAL_VERSION
    unset MAKE_MAJOR MAKE_MINOR BISON_MAJOR FLEX_MAJOR FLEX_MINOR
    unset REQUIRED_VERSION JAVAC_EXE JAVAC_VERSION MAIN_DRIVE
    unset T_JAVAC_EXE TAOIDL_EXE T_VAR SPATH TAO_ROOT1
    unset GAWK_VERSION JAVA_PATH_EXT CL_MAJOR COMPILER_VER CL_EXE
    unset VS_HOME_UNIX VS_HOME_DOS DOS_CONV_PATH UNIX_CONV_PATH T_LD_PATH
    unset CSC_EXE VERSIONS NET_VERSION TYPE
}
