gentoo-x86/eclass/toolchain-funcs.eclass

# Copyright 1999-2004 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/eclass/toolchain-funcs.eclass,v 1.14 2004/12/14 05:31:32 vapier Exp $
#
# Author: Toolchain Ninjas <ninjas@gentoo.org>
#
# This eclass contains (or should) functions to get common info 
# about the toolchain (libc/compiler/binutils/etc...)

inherit eutils

ECLASS=toolchain-funcs
INHERITED="$INHERITED $ECLASS"

DESCRIPTION="Based on the ${ECLASS} eclass"

tc-getPROG() {
        local var="$1"
        local prog="$2"
        local search=""

        if [ -n "${!var}" ] ; then
                echo "${!var}"
                return 0
        fi

        if [ -n "${CTARGET}" ] ; then
                search="$(type -p "${CTARGET}-${prog}")"
        elif [ -n "${CHOST}" ] ; then
                search="$(type -p "${CHOST}-${prog}")"
        fi

        if [ -n "${search}" ] ; then
                prog="${search##*/}"
        fi
        export ${var}="${prog}"
        echo "${!var}"
}

# Returns the name of the archiver
tc-getAR() { tc-getPROG AR ar; }
# Returns the name of the assembler
tc-getAS() { tc-getPROG AS as; }
# Returns the name of the C compiler
tc-getCC() { tc-getPROG CC gcc; }
# Returns the name of the C++ compiler
tc-getCXX() { tc-getPROG CXX g++; }
# Returns the name of the linker
tc-getLD() { tc-getPROG LD ld; }
# Returns the name of the symbol/object thingy
tc-getNM() { tc-getPROG NM nm; }
# Returns the name of the archiver indexer
tc-getRANLIB() { tc-getPROG RANLIB ranlib; }
# Returns the name of the fortran compiler
tc-getF77() { tc-getPROG F77 f77; }
# Returns the name of the java compiler
tc-getGCJ() { tc-getPROG GCJ gcj; }

# Returns the name of the C compiler for build
tc-getBUILD_CC() {
        if [ -n "${CC_FOR_BUILD}" ] ; then
                export BUILD_CC="${CC_FOR_BUILD}"
                echo "${CC_FOR_BUILD}"
                return 0
        fi

        local search=
        if [ -n "${CBUILD}" ] ; then
                search="$(type -p "${CBUILD}-gcc")"
        fi

        if [ -n "${search}" ] ; then
                search="${search##*/}"
        else
                search="gcc"
        fi

        export BUILD_CC="${search}"
        echo "${search}"
}

# Quick way to export a bunch of vars at once
tc-export() {
        local var
        for var in "$@" ; do
                eval tc-get${var}
        done
}

# A simple way to see if we're using a cross-compiler ...
tc-is-cross-compiler() {
        # Simple case ... the user tells us what's going on
        if [[ -n ${CBUILD} ]] ; then
                return $([[ ${CBUILD} != ${CHOST} ]])
        fi

        # Hard case ... compile a simple prog and run it ...
        local ret tmpfile=$(emktemp).c
        echo 'int main(){return 0;}' > "${tmpfile}"
        $(tc-getCC) "${tmpfile}" -o "${tmpfile}".bin
        ! "${tmpfile}".bin &>/dev/null
        ret=$?
        rm -f "${tmpfile}" "${tmpfile}".bin
        return ${ret}
}


# Returns the version as by `$CC -dumpversion`
gcc-fullversion() {
        echo "$($(tc-getCC) -dumpversion)"
}
# Returns the version, but only the <major>.<minor>
gcc-version() {
        echo "$(gcc-fullversion | cut -f1,2 -d.)"
}
# Returns the Major version
gcc-major-version() {
        echo "$(gcc-version | cut -f1 -d.)"
}
# Returns the Minor version
gcc-minor-version() {
        echo "$(gcc-version | cut -f2 -d.)"
}
# Returns the Micro version
gcc-micro-version() {
        echo "$(gcc-fullversion | cut -f3 -d.)"
}
1	vapier	1.1	# Copyright 1999-2004 Gentoo Foundation
2			# Distributed under the terms of the GNU General Public License v2
3	vapier	1.15	# $Header: /var/cvsroot/gentoo-x86/eclass/toolchain-funcs.eclass,v 1.14 2004/12/14 05:31:32 vapier Exp $
4	vapier	1.1	#
5			# Author: Toolchain Ninjas <ninjas@gentoo.org>
6			#
7			# This eclass contains (or should) functions to get common info
8			# about the toolchain (libc/compiler/binutils/etc...)
9
10			inherit eutils
11
12	vapier	1.3	ECLASS=toolchain-funcs
13	vapier	1.1	INHERITED="$INHERITED $ECLASS"
14
15			DESCRIPTION="Based on the ${ECLASS} eclass"
16
17			tc-getPROG() {
18			local var="$1"
19			local prog="$2"
20			local search=""
21
22			if [ -n "${!var}" ] ; then
23			echo "${!var}"
24			return 0
25			fi
26
27	vapier	1.6	if [ -n "${CTARGET}" ] ; then
28			search="$(type -p "${CTARGET}-${prog}")"
29	vapier	1.9	elif [ -n "${CHOST}" ] ; then
30			search="$(type -p "${CHOST}-${prog}")"
31	vapier	1.1	fi
32
33	vapier	1.5	if [ -n "${search}" ] ; then
34	vapier	1.1	prog="${search##*/}"
35			fi
36			export ${var}="${prog}"
37			echo "${!var}"
38			}
39
40			# Returns the name of the archiver
41			tc-getAR() { tc-getPROG AR ar; }
42			# Returns the name of the assembler
43			tc-getAS() { tc-getPROG AS as; }
44			# Returns the name of the C compiler
45			tc-getCC() { tc-getPROG CC gcc; }
46			# Returns the name of the C++ compiler
47			tc-getCXX() { tc-getPROG CXX g++; }
48			# Returns the name of the linker
49			tc-getLD() { tc-getPROG LD ld; }
50			# Returns the name of the symbol/object thingy
51			tc-getNM() { tc-getPROG NM nm; }
52			# Returns the name of the archiver indexer
53			tc-getRANLIB() { tc-getPROG RANLIB ranlib; }
54	vapier	1.7	# Returns the name of the fortran compiler
55			tc-getF77() { tc-getPROG F77 f77; }
56	vapier	1.8	# Returns the name of the java compiler
57			tc-getGCJ() { tc-getPROG GCJ gcj; }
58	vapier	1.1
59	vapier	1.4	# Returns the name of the C compiler for build
60			tc-getBUILD_CC() {
61			if [ -n "${CC_FOR_BUILD}" ] ; then
62	vapier	1.11	export BUILD_CC="${CC_FOR_BUILD}"
63	vapier	1.4	echo "${CC_FOR_BUILD}"
64			return 0
65			fi
66
67	vapier	1.9	local search=
68	vapier	1.11	if [ -n "${CBUILD}" ] ; then
69			search="$(type -p "${CBUILD}-gcc")"
70	vapier	1.4	fi
71
72	vapier	1.9	if [ -n "${search}" ] ; then
73	vapier	1.11	search="${search##*/}"
74	vapier	1.9	else
75	vapier	1.11	search="gcc"
76	vapier	1.9	fi
77	vapier	1.11
78			export BUILD_CC="${search}"
79			echo "${search}"
80	vapier	1.4	}
81	vapier	1.1
82	vapier	1.10	# Quick way to export a bunch of vars at once
83			tc-export() {
84			local var
85			for var in "$@" ; do
86			eval tc-get${var}
87			done
88			}
89
90	vapier	1.12	# A simple way to see if we're using a cross-compiler ...
91			tc-is-cross-compiler() {
92	vapier	1.15	# Simple case ... the user tells us what's going on
93			if [[ -n ${CBUILD} ]] ; then
94			return $([[ ${CBUILD} != ${CHOST} ]])
95			fi
96
97			# Hard case ... compile a simple prog and run it ...
98	vapier	1.12	local ret tmpfile=$(emktemp).c
99			echo 'int main(){return 0;}' > "${tmpfile}"
100			$(tc-getCC) "${tmpfile}" -o "${tmpfile}".bin
101	vapier	1.14	! "${tmpfile}".bin &>/dev/null
102	vapier	1.12	ret=$?
103			rm -f "${tmpfile}" "${tmpfile}".bin
104	vapier	1.13	return ${ret}
105	vapier	1.12	}
106
107	vapier	1.1
108			# Returns the version as by `$CC -dumpversion`
109			gcc-fullversion() {
110			echo "$($(tc-getCC) -dumpversion)"
111			}
112			# Returns the version, but only the <major>.<minor>
113			gcc-version() {
114	vapier	1.2	echo "$(gcc-fullversion \| cut -f1,2 -d.)"
115	vapier	1.1	}
116			# Returns the Major version
117			gcc-major-version() {
118	vapier	1.2	echo "$(gcc-version \| cut -f1 -d.)"
119	vapier	1.1	}
120			# Returns the Minor version
121			gcc-minor-version() {
122	vapier	1.2	echo "$(gcc-version \| cut -f2 -d.)"
123	vapier	1.1	}
124			# Returns the Micro version
125			gcc-micro-version() {
126	vapier	1.2	echo "$(gcc-fullversion \| cut -f3 -d.)"
127	vapier	1.1	}