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.18 2004/12/31 03:18:42 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

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

        if [[ -n ${CHOST} ]] ; then
                local search=$(type -p "${CHOST}-${prog}")
                [[ -n ${search} ]] && 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")
                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() {
        if [[ -n ${CBUILD} ]] ; then
                return $([[ ${CBUILD} != ${CHOST} ]])
        fi
        return 1
}


# Translate a CBUILD/CHOST/CTARGET into the kernel/portage
# equivalent of $ARCH
ninja_magic_to_arch() {
ninj() { [[ ${type} = "kern" ]] && echo $1 || echo $2 ; }

        local type=$1
        local host=$2

        case ${host} in
                alpha*)         echo alpha;;
                x86_64*)        ninj x86_64 amd64;;
                arm*)           echo arm;;
                hppa*)          ninj parisc hppa;;
                ia64*)          echo ia64;;
                mips*)          echo mips;;
                powerpc64*)     echo ppc64;;
                powerpc*)       echo ppc;;
                sparc64*)       ninj sparc64 sparc;;
                sparc*)         echo sparc;;
                s390*)          echo s390;;
                sh64*)          ninj sh64 sh;;
                sh*)            echo sh;;
                i?86*)          echo x86;;
                *)                      echo wtf;;
        esac
}
host_to_arch_kernel() {
        ninja_magic_to_arch kern $@
}
host_to_arch_portage() {
        ninja_magic_to_arch portage $@
}


# 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	# Copyright 1999-2004 Gentoo Foundation
2	# Distributed under the terms of the GNU General Public License v2
3	# $Header: /var/cvsroot/gentoo-x86/eclass/toolchain-funcs.eclass,v 1.18 2004/12/31 03:18:42 vapier Exp $
4	#
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	ECLASS=toolchain-funcs
13	INHERITED="$INHERITED $ECLASS"
14
15	DESCRIPTION="Based on the ${ECLASS} eclass"
16
17	tc-getPROG() {
18	local var=$1
19	local prog=$2
20
21	if [[ -n ${!var} ]] ; then
22	echo "${!var}"
23	return 0
24	fi
25
26	if [[ -n ${CHOST} ]] ; then
27	local search=$(type -p "${CHOST}-${prog}")
28	[[ -n ${search} ]] && prog=${search##*/}
29	fi
30
31	export ${var}=${prog}
32	echo "${!var}"
33	}
34
35	# Returns the name of the archiver
36	tc-getAR() { tc-getPROG AR ar; }
37	# Returns the name of the assembler
38	tc-getAS() { tc-getPROG AS as; }
39	# Returns the name of the C compiler
40	tc-getCC() { tc-getPROG CC gcc; }
41	# Returns the name of the C++ compiler
42	tc-getCXX() { tc-getPROG CXX g++; }
43	# Returns the name of the linker
44	tc-getLD() { tc-getPROG LD ld; }
45	# Returns the name of the symbol/object thingy
46	tc-getNM() { tc-getPROG NM nm; }
47	# Returns the name of the archiver indexer
48	tc-getRANLIB() { tc-getPROG RANLIB ranlib; }
49	# Returns the name of the fortran compiler
50	tc-getF77() { tc-getPROG F77 f77; }
51	# Returns the name of the java compiler
52	tc-getGCJ() { tc-getPROG GCJ gcj; }
53
54	# Returns the name of the C compiler for build
55	tc-getBUILD_CC() {
56	if [[ -n ${CC_FOR_BUILD} ]] ; then
57	export BUILD_CC=${CC_FOR_BUILD}
58	echo "${CC_FOR_BUILD}"
59	return 0
60	fi
61
62	local search=
63	if [[ -n ${CBUILD} ]] ; then
64	search=$(type -p "${CBUILD}-gcc")
65	search=${search##*/}
66	else
67	search=gcc
68	fi
69
70	export BUILD_CC=${search}
71	echo "${search}"
72	}
73
74	# Quick way to export a bunch of vars at once
75	tc-export() {
76	local var
77	for var in "$@" ; do
78	eval tc-get${var}
79	done
80	}
81
82	# A simple way to see if we're using a cross-compiler ...
83	tc-is-cross-compiler() {
84	if [[ -n ${CBUILD} ]] ; then
85	return $([[ ${CBUILD} != ${CHOST} ]])
86	fi
87	return 1
88	}
89
90
91	# Translate a CBUILD/CHOST/CTARGET into the kernel/portage
92	# equivalent of $ARCH
93	ninja_magic_to_arch() {
94	ninj() { [[ ${type} = "kern" ]] && echo $1 \|\| echo $2 ; }
95
96	local type=$1
97	local host=$2
98
99	case ${host} in
100	alpha*) echo alpha;;
101	x86_64*) ninj x86_64 amd64;;
102	arm*) echo arm;;
103	hppa*) ninj parisc hppa;;
104	ia64*) echo ia64;;
105	mips*) echo mips;;
106	powerpc64*) echo ppc64;;
107	powerpc*) echo ppc;;
108	sparc64*) ninj sparc64 sparc;;
109	sparc*) echo sparc;;
110	s390*) echo s390;;
111	sh64*) ninj sh64 sh;;
112	sh*) echo sh;;
113	i?86*) echo x86;;
114	*) echo wtf;;
115	esac
116	}
117	host_to_arch_kernel() {
118	ninja_magic_to_arch kern $@
119	}
120	host_to_arch_portage() {
121	ninja_magic_to_arch portage $@
122	}
123
124
125	# Returns the version as by `$CC -dumpversion`
126	gcc-fullversion() {
127	echo "$($(tc-getCC) -dumpversion)"
128	}
129	# Returns the version, but only the <major>.<minor>
130	gcc-version() {
131	echo "$(gcc-fullversion \| cut -f1,2 -d.)"
132	}
133	# Returns the Major version
134	gcc-major-version() {
135	echo "$(gcc-version \| cut -f1 -d.)"
136	}
137	# Returns the Minor version
138	gcc-minor-version() {
139	echo "$(gcc-version \| cut -f2 -d.)"
140	}
141	# Returns the Micro version
142	gcc-micro-version() {
143	echo "$(gcc-fullversion \| cut -f3 -d.)"
144	}