#
# $Id: misc.in,v 1.45 2004/03/22 15:35:05 jmmv Exp $
# Several checks that do not fit other files by category.
#
# 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.
#

# --------------------------------------------------------------------
# Miscellaneous checks
# --------------------------------------------------------------------

bt_define_ml_check bt_check_sizeof

bt_check_sizeof_c() { btown_check_sizeof c "$@"; }
bt_check_sizeof_cxx() { btown_check_sizeof cxx "$@"; }

btown_check_sizeof() {
    local lang=$1 type="$2"
    local defname=$(bt_def_name BT_SIZEOF ${lang} "${type}")
    local cachename=$(bt_cache_name BT_SIZEOF ${lang} "${type}")
    local cv ret size
    bt_cache ${cachename}

    bt_msg_chk "for ${lang} size of ${type}"

    eval cv=\"\${${cachename}:-unset}\"
    if [ ${cv} = unset ]; then
        size=$(bt_try_run_${lang} <<EOF
#include <stdio.h>
int main(void) { printf("%d", sizeof(${type})); return 0; }
EOF
)
        ret=$?
        if [ ${ret} -eq 0 ]; then
            bt_define_unquoted ${defname} ${size}
            eval ${defname}=\"${size}\"
            eval ${cachename}=\"${size}\"
            bt_msg_result ${size}
        else
            eval ${cachename}="\"unknown type\""
            bt_msg_result "unknown type"
        fi
    elif [ ${cv} = "unknown type" ]; then
        bt_msg_result "${cv} (cached)"
        ret=1
    else
        bt_define_unquoted ${defname} ${cv}
        eval ${defname}=\"${cv}\"
        bt_msg_result "${cv} (cached)"
        ret=0
    fi

    return ${ret}
}

bt_define_ml_check bt_check_bits

bt_check_bits_c() { btown_check_bits c; }
bt_check_bits_cxx() { btown_check_bits cxx; }

btown_check_bits() {
    local lang="$1"
    local so_char so_short so_int so_long so_long_long

    bt_check_sizeof char
    eval so_char=\"\$$(bt_def_name BT_SIZEOF ${lang} char)\"
    bt_check_sizeof short
    eval so_short=\"\$$(bt_def_name BT_SIZEOF ${lang} short)\"
    bt_check_sizeof int
    eval so_int=\"\$$(bt_def_name BT_SIZEOF ${lang} int)\"
    bt_check_sizeof long
    eval so_long=\"\$$(bt_def_name BT_SIZEOF ${lang} long)\"
    bt_check_sizeof "long long"
    eval so_long_long=\"\$$(bt_def_name BT_SIZEOF ${lang} "long long")\"

    # Determine 8 bits size
    if [ ${so_char} -eq 1 ]; then
        BT_TYPE_BITS8_S="signed char"
        BT_TYPE_BITS8_U="unsigned char"
        bt_define_unquoted BT_TYPE_BITS8_S "signed char"
        bt_define_unquoted BT_TYPE_BITS8_U "unsigned char"
    elif [ ${so_short} -eq 1 ]; then
        BT_TYPE_BITS8_S="signed short"
        BT_TYPE_BITS8_U="unsigned short"
        bt_define_unquoted BT_TYPE_BITS8_S "signed short"
        bt_define_unquoted BT_TYPE_BITS8_U "unsigned short"
    elif [ ${so_int} -eq 1 ]; then
        BT_TYPE_BITS8_S="signed int"
        BT_TYPE_BITS8_U="unsigned int"
        bt_define_unquoted BT_TYPE_BITS8_S "signed int"
        bt_define_unquoted BT_TYPE_BITS8_U "unsigned int"
    elif [ ${so_long} -eq 1 ]; then
        BT_TYPE_BITS8_S="signed long"
        BT_TYPE_BITS8_U="unsigned long"
        bt_define_unquoted BT_TYPE_BITS8_S "signed long"
        bt_define_unquoted BT_TYPE_BITS8_U "unsigned long"
    elif [ ${so_long_long} -eq 1 ]; then
        BT_TYPE_BITS8_S="signed long long"
        BT_TYPE_BITS8_U="unsigned long long"
        bt_define_unquoted BT_TYPE_BITS8_S "signed long long"
        bt_define_unquoted BT_TYPE_BITS8_U "unsigned long long"
    fi
    bt_subst BT_TYPE_BITS8_S BT_TYPE_BITS8_U

    # Determine 16 bits size
    if [ ${so_char} -eq 2 ]; then
        BT_TYPE_BITS16_S="signed char"
        BT_TYPE_BITS16_U="unsigned char"
        bt_define_unquoted BT_TYPE_BITS16_S "signed char"
        bt_define_unquoted BT_TYPE_BITS16_U "unsigned char"
    elif [ ${so_short} -eq 2 ]; then
        BT_TYPE_BITS16_S="signed short"
        BT_TYPE_BITS16_U="unsigned short"
        bt_define_unquoted BT_TYPE_BITS16_S "signed short"
        bt_define_unquoted BT_TYPE_BITS16_U "unsigned short"
    elif [ ${so_int} -eq 2 ]; then
        BT_TYPE_BITS16_S="signed int"
        BT_TYPE_BITS16_U="unsigned int"
        bt_define_unquoted BT_TYPE_BITS16_S "signed int"
        bt_define_unquoted BT_TYPE_BITS16_U "unsigned int"
    elif [ ${so_long} -eq 2 ]; then
        BT_TYPE_BITS16_S="signed long"
        BT_TYPE_BITS16_U="unsigned long"
        bt_define_unquoted BT_TYPE_BITS16_S "signed long"
        bt_define_unquoted BT_TYPE_BITS16_U "unsigned long"
    elif [ ${so_long_long} -eq 2 ]; then
        BT_TYPE_BITS16_S="signed long long"
        BT_TYPE_BITS16_U="unsigned long long"
        bt_define_unquoted BT_TYPE_BITS16_S "signed long long"
        bt_define_unquoted BT_TYPE_BITS16_U "unsigned long long"
    fi
    bt_subst BT_TYPE_BITS16_S BT_TYPE_BITS16_U

    # Determine 32 bits size
    if [ ${so_char} -eq 4 ]; then
        BT_TYPE_BITS32_S="signed char"
        BT_TYPE_BITS32_U="unsigned char"
        bt_define_unquoted BT_TYPE_BITS32_S "signed char"
        bt_define_unquoted BT_TYPE_BITS32_U "unsigned char"
    elif [ ${so_short} -eq 4 ]; then
        BT_TYPE_BITS32_S="signed short"
        BT_TYPE_BITS32_U="unsigned short"
        bt_define_unquoted BT_TYPE_BITS32_S "signed short"
        bt_define_unquoted BT_TYPE_BITS32_U "unsigned short"
    elif [ ${so_int} -eq 4 ]; then
        BT_TYPE_BITS32_S="signed int"
        BT_TYPE_BITS32_U="unsigned int"
        bt_define_unquoted BT_TYPE_BITS32_S "signed int"
        bt_define_unquoted BT_TYPE_BITS32_U "unsigned int"
    elif [ ${so_long} -eq 4 ]; then
        BT_TYPE_BITS32_S="signed long"
        BT_TYPE_BITS32_U="unsigned long"
        bt_define_unquoted BT_TYPE_BITS32_S "signed long"
        bt_define_unquoted BT_TYPE_BITS32_U "unsigned long"
    elif [ ${so_long_long} -eq 4 ]; then
        BT_TYPE_BITS32_S="signed long long"
        BT_TYPE_BITS32_U="unsigned long long"
        bt_define_unquoted BT_TYPE_BITS32_S "signed long long"
        bt_define_unquoted BT_TYPE_BITS32_U "unsigned long long"
    fi
    bt_subst BT_TYPE_BITS32_S BT_TYPE_BITS32_U

    # Determine 64 bits size
    if [ ${so_char} -eq 8 ]; then
        BT_TYPE_BITS64_S="signed char"
        BT_TYPE_BITS64_U="unsigned char"
        bt_define_unquoted BT_TYPE_BITS64_S "signed char"
        bt_define_unquoted BT_TYPE_BITS64_U "unsigned char"
    elif [ ${so_short} -eq 8 ]; then
        BT_TYPE_BITS64_S="signed short"
        BT_TYPE_BITS64_U="unsigned short"
        bt_define_unquoted BT_TYPE_BITS64_S "signed short"
        bt_define_unquoted BT_TYPE_BITS64_U "unsigned short"
    elif [ ${so_int} -eq 8 ]; then
        BT_TYPE_BITS64_S="signed int"
        BT_TYPE_BITS64_U="unsigned int"
        bt_define_unquoted BT_TYPE_BITS64_S "signed int"
        bt_define_unquoted BT_TYPE_BITS64_U "unsigned int"
    elif [ ${so_long} -eq 8 ]; then
        BT_TYPE_BITS64_S="signed long"
        BT_TYPE_BITS64_U="unsigned long"
        bt_define_unquoted BT_TYPE_BITS64_S "signed long"
        bt_define_unquoted BT_TYPE_BITS64_U "unsigned long"
    elif [ ${so_long_long} -eq 8 ]; then
        BT_TYPE_BITS64_S="signed long long"
        BT_TYPE_BITS64_U="unsigned long long"
        bt_define_unquoted BT_TYPE_BITS64_S "signed long long"
        bt_define_unquoted BT_TYPE_BITS64_U "unsigned long long"
    fi
    bt_subst BT_TYPE_BITS64_S BT_TYPE_BITS64_U
}

bt_check_host() {
    bt_msg_chk "for host system name"
    BT_HOST_OS=$(uname -s)
    bt_msg_result ${BT_HOST_OS}

    bt_msg_chk "for host system type"
    BT_HOST_TYPE=$(uname -s)-$(uname -r)-$(uname -m)
    bt_msg_result ${BT_HOST_TYPE}

    # TODO: Check endian type
}

bt_check_pkgflags() {
    local varc=$1 varl=$2; shift 2
    local res

    bt_msg_chk "for $@ flags"
    btcmn_run_module pkgflags "$@" >/dev/null 2>&1
    res=$?
    if [ ${res} -eq 0 ]; then
        eval ${varc}=\'$(btcmn_run_module pkgflags -c "$@" 2>/dev/null)\'
        eval ${varl}=\'$(btcmn_run_module pkgflags -l "$@" 2>/dev/null)\'
        bt_msg_result found
        return 0
    else
        bt_msg_result "not found"
        return ${res}
    fi
}

bt_define_ml_check bt_check_attribute

bt_check_attribute_c() { btown_check_attribute c; }
bt_check_attribute_cxx() { btown_check_attribute cxx; }

btown_check_attribute() {
    local lang=$1
    local defname=$(bt_def_name BT_HAVE_KEYWORD ${lang} ATTRIBUTE)
    local cachename=$(bt_cache_name BT_HAVE_KEYWORD ${lang} ATTRIBUTE)
    local cv ret
    bt_cache ${cachename}

    bt_msg_chk "for ${lang} __attribute__ keyword"

    eval cv=\"\${${cachename}:-unset}\"
    if [ ${cv} = yes ]; then
        bt_msg_result "yes (cached)"
        ret=0
    elif [ ${cv} = no ]; then
        bt_define_unquoted "__attribute__(x)"
        bt_msg_result "no (cached)"
        ret=1
    else
        bt_try_compile_${lang} <<EOF
#include <stdio.h>
static void foo(void) __attribute__((noreturn));
static void foo(void) {}
int main() { return 0; }
EOF
        ret=$?
        if [ ${ret} -eq 0 ]; then
            eval ${cachename}=yes
            bt_msg_result yes
        else
            eval ${cachename}=no
            bt_define_unquoted "__attribute__(x)"
            bt_msg_result no
        fi
    fi

    return ${ret}
}

# --------------------------------------------------------------------
# Generic types
# --------------------------------------------------------------------

bt_define_ml_check bt_check_type

bt_check_type_c() { btown_check_type c "$@"; }
bt_check_type_cxx() { btown_check_type cxx "$@"; }

btown_check_type() {
    local lang=$1 type="$2"
    local defname=$(bt_def_name BT_HAVE_TYPE ${lang} "${type}")
    local cachename=$(bt_cache_name BT_HAVE_TYPE ${lang} "${type}")
    local cv ret
    bt_cache ${cachename}

    bt_msg_chk "for ${lang} type ${type}"

    eval cv=\"\${${cachename}:-unset}\"
    if [ ${cv} = yes ]; then
        bt_define ${defname}
        bt_msg_result "yes (cached)"
        ret=0
    elif [ ${cv} = no ]; then
        bt_msg_result "no (cached)"
        ret=1
    else
        bt_try_compile_${lang} <<EOF
int main() { ${type} myvar; return 0; }
EOF
        ret=$?
        if [ ${ret} -eq 0 ]; then
            eval ${cachename}=yes
            bt_define ${defname}
            bt_msg_result yes
        else
            eval ${cachename}=no
            bt_msg_result no
        fi
    fi

    return ${ret}
}

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