#
# $Id: progs.in,v 1.53 2004/03/23 15:21:16 jmmv Exp $
# Program checks.
#
# buildtool
# Copyright (c) 2002, 2003, 2004 Julio M. Merino Vidal.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in
#    the documentation and/or other materials provided with the
#    distribution.
# 3. Neither the name of the author nor the names of contributors may
#    be used to endorse or promote products derived from this software
#    without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS''
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
# PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
# SUCH DAMAGE.
#

# --------------------------------------------------------------------
# Generic program checks
# ----------------------------------------------------------------------

bt_check_progs() {
    local varname="$1" progs="$2" optpath="$3"
    local prog tmp
    bt_cache ${varname}

    # If the variable is already set, return.
    eval tmp=\"\$${varname}\"
    if [ -n "${tmp}" ]; then
        bt_msg_chk "for program ${progs}"
        bt_msg_result "${tmp} (cached)"
        bt_subst ${varname}
        return 0
    fi

    # Use BT_PATH if $optpath is not used.
    optpath=$(echo ${optpath:=${BT_PATH}} | tr ':' ' ')

    # Recurse programs in each directory
    for prog in ${progs}; do
        bt_msg_chk "for program ${prog}"
        for dir in ${optpath}; do
            if [ -f "${dir}/${prog}" ]; then
                # Program found
                bt_msg_result "${dir}/${prog}"
                eval ${varname}=\""${dir}/${prog}"\"
                bt_subst ${varname}
                return 0
            fi
        done
        bt_msg_result "not found."
    done

    # Program not found
    return 1
}

# --------------------------------------------------------------------
# Specific program checks
# ----------------------------------------------------------------------

bt_check_prog_awk() {
    bt_check_progs BT_PROG_AWK "gawk nawk awk"
}

bt_check_prog_cc() {
    if bt_check_progs BT_PROG_CC "gcc cc bcc"; then
        bt_msg_chk "for C compiler name"

        if [ -z "${BT_PROG_CC_NAME}" ]; then
            BT_PROG_CC_NAME=$(bt_try_run_c <<EOF
#include <stdio.h>
int main(void) {
#if defined(__GNUC__)
printf("gnu"); /* NOLINT */
#elif defined(__SUNPRO_C)
printf("sunpro"); /* NOLINT */
#else
printf("unknown"); /* NOLINT */
#endif
return 0;
}
EOF
)
            bt_msg_result ${BT_PROG_CC_NAME}
            if [ ${BT_PROG_CC_NAME} != gnu ]; then
                bt_warn "Using a C compiler that is not GNU C." \
                        "Buildtool may behave unexpectedly; please report any problems." # NOLINT
            fi
        else
            bt_msg_result "${BT_PROG_CC_NAME} (cached)"
        fi

        bt_msg_chk "for C compiler version"
        if [ -z "${BT_PROG_CC_VERSION}" ]; then
            case ${BT_PROG_CC_NAME} in
                gnu)
                    BT_PROG_CC_VERSION=$(${BT_PROG_CC} -dumpversion)
                    if echo ${BT_PROG_CC_VERSION} | grep egcs >/dev/null; then
                        BT_PROG_CC_VERSION=2.8.1
                    fi
                    ;;
                *)
                    BT_PROG_CC_VERSION=unknown
                    ;;
            esac
            bt_msg_result ${BT_PROG_CC_VERSION}
        else
            bt_msg_result "${BT_PROG_CC_VERSION} (cached)"
        fi

        bt_subst BT_PROG_CC_NAME
        bt_subst BT_PROG_CC_VERSION
        bt_subst BT_FLAGS_CPP
        bt_subst BT_FLAGS_CC
        bt_subst BT_LIBS

        return 0
    fi

    bt_err "no C compiler available, cannot continue"
}

bt_check_prog_cc_flag() {
    local flag="$1"
    local cachename=$(bt_cache_name BT_PROG_HAVE_FLAG c ${flag})
    local cv ret saved_flags_cc

    [ -z "${BT_PROG_CC}" ] && bt_check_prog_cc

    bt_cache ${cachename}

    bt_msg_chk "for c compiler flag ${flag}"

    eval cv=\"\${${cachename}:-name}\"
    if [ ${cv} = yes ]; then
        bt_msg_result "yes (cached)"
        ret=0
    elif [ ${cv} = no ]; then
        bt_msg_result "no (cached)"
        ret=1
    else
        saved_flags_cc=${BT_FLAGS_CC}
        BT_FLAGS_CC+=${flag}
        bt_try_compile_c <<EOF
#include <stdio.h>
int main(void) { return 0; }
EOF
        ret=$?
        if [ ${ret} -eq 0 ]; then
            eval ${cachename}=yes
            bt_msg_result yes
        else
            eval ${cachename}=no
            bt_msg_result no
        fi
        BT_FLAGS_CC=${saved_flags_cc}
    fi

    return ${ret}
}

bt_check_prog_cpp() {
    if bt_check_progs BT_PROG_CPP cpp; then
        bt_subst BT_FLAGS_CPP

        return 0
    fi
    return 1
}

bt_check_prog_cxx() {
    if bt_check_progs BT_PROG_CXX "g++ c++ cxx cc++ gcc CC"; then
        bt_msg_chk "for C++ compiler name"

        if [ -z "${BT_PROG_CXX_NAME}" ]; then
            BT_PROG_CXX_NAME=$(bt_try_run_cxx <<EOF
#include <stdio.h>
int main(void) {
#if defined(__GNUC__)
printf("gnu"); /* NOLINT */
#elif defined(__SUNPRO_C)
printf("sunpro"); /* NOLINT */
#else
printf("unknown"); /* NOLINT */
#endif
}
EOF
)
            bt_msg_result ${BT_PROG_CXX_NAME}
            if [ ${BT_PROG_CXX_NAME} != gnu ]; then
                bt_warn "Using a C++ compiler that is not GNU C++." \
                        "Buildtool may behave unexpectedly; please report any problems." # NOLINT
            fi
        else
            bt_msg_result "${BT_PROG_CXX_NAME} (cached)"
        fi

        bt_msg_chk "for C++ compiler version"
        if [ -z "${BT_PROG_CXX_VERSION}" ]; then
            case ${BT_PROG_CXX_NAME} in
                gnu)
                    BT_PROG_CXX_VERSION=$(${BT_PROG_CXX} -dumpversion)
                    if echo ${BT_PROG_CXX_VERSION} | grep egcs >/dev/null; then
                        BT_PROG_CXX_VERSION=2.8.1
                    fi
                    ;;
                *)
                    BT_PROG_CXX_VERSION=unknown
                    ;;
            esac
            bt_msg_result ${BT_PROG_CXX_VERSION}
        else
            bt_msg_result "${BT_PROG_CXX_VERSION} (cached)"
        fi

        bt_subst BT_PROG_CXX_NAME
        bt_subst BT_PROG_CXX_VERSION
        bt_subst BT_FLAGS_CPP
        bt_subst BT_FLAGS_CXX
        bt_subst BT_LIBS

        return 0
    fi
    bt_err "no C++ compiler available, cannot continue"
}

bt_check_prog_cxx_flag() {
    local flag="$1"
    local cachename=$(bt_cache_name BT_PROG_HAVE_FLAG cxx ${flag})
    local cv ret saved_flags_cxx

    [ -z "${BT_PROG_CXX}" ] && bt_check_prog_cxx

    bt_cache ${cachename}

    bt_msg_chk "for cxx compiler flag ${flag}"

    eval cv=\"\${${cachename}:-name}\"
    if [ ${cv} = yes ]; then
        bt_msg_result "yes (cached)"
        ret=0
    elif [ ${cv} = no ]; then
        bt_msg_result "no (cached)"
        ret=1
    else
        saved_flags_cxx=${BT_FLAGS_CXX}
        BT_FLAGS_CXX+=${flag}
        bt_try_compile_cxx <<EOF
#include <stdio.h>
int main(void) { return 0; }
EOF
        ret=$?
        if [ ${ret} -eq 0 ]; then
            eval ${cachename}=yes
            bt_msg_result yes
        else
            eval ${cachename}=no
            bt_msg_result no
        fi
        BT_FLAGS_CXX=${saved_flags_cxx}
    fi

    return ${ret}
}

bt_check_prog_depgen() {
    if [ -n "${BT_PROG_FASTDEP}" ] || bt_check_progs BT_PROG_FASTDEP fastdep
    then
        BT_PROG_DEPGEN=${BT_PROG_FASTDEP}
    else
        BT_PROG_DEPGEN=
        [ -n "${BT_PROG_CPP}" ] && BT_PROG_DEPGEN="${BT_PROG_CPP} -M"
        [ -n "${BT_PROG_CC}" -a ${BT_PROG_CC_NAME:-unset} = gnu ] && \
            BT_PROG_DEPGEN="${BT_PROG_CC} -MM"
        [ -n "${BT_PROG_CXX}" -a ${BT_PROG_CXX_NAME:-unset} = gnu ] && \
            BT_PROG_DEPGEN="${BT_PROG_CXX} -MM"
    fi
    bt_subst BT_PROG_DEPGEN
}

bt_check_prog_info() {
    local res=0
    if ! bt_check_progs BT_PROG_MAKEINFO makeinfo; then
        res=1
    fi
    if ! bt_check_progs BT_PROG_INSTALLINFO install-info; then
        res=1
    fi
    return ${res}
}

bt_check_prog_lex() {
    if bt_check_progs BT_PROG_LEX flex; then
        BT_LIBS_LEX=-lfl
    elif bt_check_progs BT_PROG_LEX lex; then
        BT_LIBS_LEX=-ll
    else
        return 1
    fi
    bt_subst BT_LIBS_LEX
    return 0
}

bt_check_prog_ld() {
    if bt_check_progs BT_PROG_LD ld; then
        bt_subst BT_FLAGS_LD

        return 0
    fi
    return 1
}

bt_check_prog_m4() {
    bt_check_progs BT_PROG_M4 "gm4 m4"
}

bt_check_prog_make() {
    local ret=1 tmp

    if bt_check_progs BT_PROG_MAKE "gmake bmake make"; then
        bt_msg_chk "for make type"

        if [ -z "${BT_PROG_MAKE_TYPE}" ]; then
            tmp=$(${BT_PROG_MAKE} --version 2>/dev/null | head -n 1 | grep GNU)
            if [ -n "${tmp}" ]; then
                BT_PROG_MAKE_TYPE=gnu
            else
                cat >${BT_WORKDIR}/bt_test.mk <<EOF
FOO=yes
.if defined(FOO) && !empty(FOO:M[Yy][Ee][Ss])
FOO=no
.endif
all:
	true # NOLINT
EOF
                if ${BT_PROG_MAKE} -f ${BT_WORKDIR}/bt_test.mk all \
                   >/dev/null 2>&1; then
                    BT_PROG_MAKE_TYPE=bsd
                else
                    BT_PROG_MAKE_TYPE=unknown
                fi
                rm -f ${BT_WORKDIR}/bt_test.mk
            fi
            bt_msg_result "${BT_PROG_MAKE_TYPE}"
        else
            bt_msg_result "${BT_PROG_MAKE_TYPE} (cached)"
        fi

        bt_subst BT_PROG_MAKE_TYPE

        ret=0
    fi

    return ${ret}
}

bt_check_prog_sh() {
    bt_check_progs BT_PROG_SH "ksh pdksh sh bash zsh"
}

bt_check_prog_yacc() {
    local proglist="${1:-bison byacc yacc}"
    bt_check_progs BT_PROG_YACC "${proglist}"
}

# Local Variables: ***
# mode: shell-script ***
# End: ***
# vim: syntax=sh