gentoo-x86/eclass/cmake-utils.eclass

# Copyright 1999-2007 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/eclass/cmake-utils.eclass,v 1.10 2008/09/28 18:52:16 jmbsvicetto Exp $

# @ECLASS: cmake-utils.eclass
# @MAINTAINER:
# kde@gentoo.org
# @BLURB: common ebuild functions for cmake-based packages
# @DESCRIPTION:
# The cmake-utils eclass contains functions that make creating ebuilds for
# cmake-based packages much easier.
# Its main features are support of out-of-source builds as well as in-source
# builds and an implementation of the well-known use_enable and use_with
# functions for CMake.

# Original author: Zephyrus (zephyrus@mirach.it)

inherit toolchain-funcs multilib

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

DEPEND=">=dev-util/cmake-2.4.6"

case ${EAPI} in
        2)
                EXPORT_FUNCTIONS src_configure src_compile src_test src_install
                ;;
        *)
                EXPORT_FUNCTIONS src_compile src_test src_install
                ;;
esac


# Internal function use by cmake-utils_use_with and cmake-utils_use_enable
_use_me_now() {
        debug-print-function $FUNCNAME $*
        [[ -z $2 ]] && die "cmake-utils_use-$1 <USE flag> [<flag name>]"
        echo "-D$1_${3:-$2}=$(use $2 && echo ON || echo OFF)"
}

# @VARIABLE: DOCS
# @DESCRIPTION:
# Documents to dodoc

# @FUNCTION: cmake-utils_use_with
# @USAGE: <USE flag> [flag name]
# @DESCRIPTION:
# Based on use_with. See ebuild(5).
#
# `cmake-utils_use_with foo FOO` echoes -DWITH_FOO=ON if foo is enabled
# and -DWITH_FOO=OFF if it is disabled.
cmake-utils_use_with() { _use_me_now WITH "$@" ; }

# @FUNCTION: cmake-utils_use_enable
# @USAGE: <USE flag> [flag name]
# @DESCRIPTION:
# Based on use_enable. See ebuild(5).
#
# `cmake-utils_use_enable foo FOO` echoes -DENABLE_FOO=ON if foo is enabled
# and -DENABLE_FOO=OFF if it is disabled.
cmake-utils_use_enable() { _use_me_now ENABLE "$@" ; }

# @FUNCTION: cmake-utils_use_want
# @USAGE: <USE flag> [flag name]
# @DESCRIPTION:
# Based on use_enable. See ebuild(5).
#
# `cmake-utils_use_want foo FOO` echoes -DWANT_FOO=ON if foo is enabled
# and -DWANT_FOO=OFF if it is disabled.
cmake-utils_use_want() { _use_me_now WANT "$@" ; }

# @FUNCTION: cmake-utils_has
# @USAGE: <USE flag> [flag name]
# @DESCRIPTION:
# Based on use_enable. See ebuild(5).
#
# `cmake-utils_has foo FOO` echoes -DHAVE_FOO=ON if foo is enabled
# and -DHAVE_FOO=OFF if it is disabled.
cmake-utils_has() { _use_me_now HAVE "$@" ; }

# @FUNCTION: cmake-utils_src_configure
# @DESCRIPTION:
# General function for configuring with cmake. Default behaviour is to start an
# out-of-source build.
cmake-utils_src_configure() {
        debug-print-function $FUNCNAME $*

        if has debug ${IUSE//+} && use debug ; then
                append-cppflags -DNDEBUG
        fi

        if [[ -n "${CMAKE_IN_SOURCE_BUILD}" ]]; then
                cmake-utils_src_configurein
        else
                cmake-utils_src_configureout
        fi
}

# @FUNCTION: cmake-utils_src_compile
# @DESCRIPTION:
# General function for compiling with cmake. Default behaviour is to check for
# eapi and based on it configure or only compile
cmake-utils_src_compile() {
        case ${EAPI} in
                2)
                ;;
        *)
                cmake-utils_src_configure
                ;;
        esac

        cmake-utils_src_make "$@"
}

# @FUNCTION: cmake-utils_src_configurein
# @DESCRIPTION:
# Function for software that requires configure and building in the source
# directory.
cmake-utils_src_configurein() {
        debug-print-function $FUNCNAME $*

        local cmakeargs="$(_common_configure_code) ${mycmakeargs} ${EXTRA_ECONF}"

        debug-print "$LINENO $ECLASS $FUNCNAME: mycmakeargs is $cmakeargs"
        cmake ${cmakeargs} . || die "Cmake failed"
}

# @FUNCTION: cmake-utils_src_configureout
# @DESCRIPTION:
# Function for software that requires configure and building outside the source
# tree - default.
cmake-utils_src_configureout() {
        debug-print-function $FUNCNAME $*

        local cmakeargs="$(_common_configure_code) ${mycmakeargs} ${EXTRA_ECONF}"
        mkdir -p "${WORKDIR}"/${PN}_build
        pushd "${WORKDIR}"/${PN}_build > /dev/null

        debug-print "$LINENO $ECLASS $FUNCNAME: mycmakeargs is $cmakeargs"
        cmake ${cmakeargs} "${S}" || die "Cmake failed"

        popd > /dev/null
}

# Internal use only. Common configuration options for all types of builds.
_common_configure_code() {
        local tmp_libdir=$(get_libdir)
        # CMAKE_BUILD_TYPE only modifies compiler flags, so set to None
        echo -DCMAKE_BUILD_TYPE=None
        echo -DCMAKE_C_COMPILER=$(type -P $(tc-getCC))
        echo -DCMAKE_CXX_COMPILER=$(type -P $(tc-getCXX))
        echo -DCMAKE_INSTALL_PREFIX=${PREFIX:-/usr}
        echo -DLIB_SUFFIX=${tmp_libdir/lib}
        echo -DLIB_INSTALL_DIR=${PREFIX:-/usr}/${tmp_libdir}
        [[ -n ${CMAKE_NO_COLOR} ]] && echo -DCMAKE_COLOR_MAKEFILE=OFF
}

# @FUNCTION: cmake-utils_src_make
# @DESCRIPTION:
# Function for building the package. Automatically detects the build type.
# All arguments are passed to emake:
# "cmake-utils_src_make -j1" can be used to work around parallel make issues.
cmake-utils_src_make() {
        debug-print-function $FUNCNAME $*

        # At this point we can automatically check if it's an out-of-source or an
        # in-source build
        if [[ -d ${WORKDIR}/${PN}_build ]]; then
                pushd "${WORKDIR}"/${PN}_build > /dev/null
        fi
        if ! [[ -z ${CMAKE_COMPILER_VERBOSE} ]]; then
                emake VERBOSE=1 "$@" || die "Make failed!"
        else
                emake "$@" || die "Make failed!"
        fi
        if [[ -d ${WORKDIR}/${PN}_build ]]; then
                popd > /dev/null
        fi
}

# @FUNCTION: cmake-utils_src_install
# @DESCRIPTION:
# Function for installing the package. Automatically detects the build type.
cmake-utils_src_install() {
        debug-print-function $FUNCNAME $*

        # At this point we can automatically check if it's an out-of-source or an
        # in-source build
        if [[ -d  ${WORKDIR}/${PN}_build ]]; then
                pushd "${WORKDIR}"/${PN}_build > /dev/null
        fi
        emake install DESTDIR="${D}" || die "Make install failed"
        if [[ -d  ${WORKDIR}/${PN}_build ]]; then
                popd > /dev/null
        fi

        # Manual document installation
        [[ -n "${DOCS}" ]] && dodoc ${DOCS}
}

# @FUNCTION: cmake-utils_src_test
# @DESCRIPTION:
# Function for testing the package. Automatically detects the build type.
cmake-utils_src_test() {
        debug-print-function $FUNCNAME $*

        # At this point we can automatically check if it's an out-of-source or an
        # in-source build
        if [[ -d ${WORKDIR}/${PN}_build ]]; then
                pushd "${WORKDIR}"/${PN}_build > /dev/null
        fi
        # Standard implementation of src_test
        if emake -j1 check -n &> /dev/null; then
                einfo ">>> Test phase [check]: ${CATEGORY}/${PF}"
                if ! emake -j1 check; then
                        die "Make check failed. See above for details."
                fi
        elif emake -j1 test -n &> /dev/null; then
                einfo ">>> Test phase [test]: ${CATEGORY}/${PF}"
                if ! emake -j1 test; then
                        die "Make test failed. See above for details."
                fi
        else
                einfo ">>> Test phase [none]: ${CATEGORY}/${PF}"
        fi
        if [[ -d  ${WORKDIR}/${PN}_build ]]; then
                popd > /dev/null
        fi
}
1	# Copyright 1999-2007 Gentoo Foundation
2	# Distributed under the terms of the GNU General Public License v2
3	# $Header: /var/cvsroot/gentoo-x86/eclass/cmake-utils.eclass,v 1.10 2008/09/28 18:52:16 jmbsvicetto Exp $
4
5	# @ECLASS: cmake-utils.eclass
6	# @MAINTAINER:
7	# kde@gentoo.org
8	# @BLURB: common ebuild functions for cmake-based packages
9	# @DESCRIPTION:
10	# The cmake-utils eclass contains functions that make creating ebuilds for
11	# cmake-based packages much easier.
12	# Its main features are support of out-of-source builds as well as in-source
13	# builds and an implementation of the well-known use_enable and use_with
14	# functions for CMake.
15
16	# Original author: Zephyrus (zephyrus@mirach.it)
17
18	inherit toolchain-funcs multilib
19
20	DESCRIPTION="Based on the ${ECLASS} eclass"
21
22	DEPEND=">=dev-util/cmake-2.4.6"
23
24	case ${EAPI} in
25	2)
26	EXPORT_FUNCTIONS src_configure src_compile src_test src_install
27	;;
28	*)
29	EXPORT_FUNCTIONS src_compile src_test src_install
30	;;
31	esac
32
33
34	# Internal function use by cmake-utils_use_with and cmake-utils_use_enable
35	_use_me_now() {
36	debug-print-function $FUNCNAME $*
37	[[ -z $2 ]] && die "cmake-utils_use-$1 <USE flag> [<flag name>]"
38	echo "-D$1_${3:-$2}=$(use $2 && echo ON \|\| echo OFF)"
39	}
40
41	# @VARIABLE: DOCS
42	# @DESCRIPTION:
43	# Documents to dodoc
44
45	# @FUNCTION: cmake-utils_use_with
46	# @USAGE: <USE flag> [flag name]
47	# @DESCRIPTION:
48	# Based on use_with. See ebuild(5).
49	#
50	# `cmake-utils_use_with foo FOO` echoes -DWITH_FOO=ON if foo is enabled
51	# and -DWITH_FOO=OFF if it is disabled.
52	cmake-utils_use_with() { _use_me_now WITH "$@" ; }
53
54	# @FUNCTION: cmake-utils_use_enable
55	# @USAGE: <USE flag> [flag name]
56	# @DESCRIPTION:
57	# Based on use_enable. See ebuild(5).
58	#
59	# `cmake-utils_use_enable foo FOO` echoes -DENABLE_FOO=ON if foo is enabled
60	# and -DENABLE_FOO=OFF if it is disabled.
61	cmake-utils_use_enable() { _use_me_now ENABLE "$@" ; }
62
63	# @FUNCTION: cmake-utils_use_want
64	# @USAGE: <USE flag> [flag name]
65	# @DESCRIPTION:
66	# Based on use_enable. See ebuild(5).
67	#
68	# `cmake-utils_use_want foo FOO` echoes -DWANT_FOO=ON if foo is enabled
69	# and -DWANT_FOO=OFF if it is disabled.
70	cmake-utils_use_want() { _use_me_now WANT "$@" ; }
71
72	# @FUNCTION: cmake-utils_has
73	# @USAGE: <USE flag> [flag name]
74	# @DESCRIPTION:
75	# Based on use_enable. See ebuild(5).
76	#
77	# `cmake-utils_has foo FOO` echoes -DHAVE_FOO=ON if foo is enabled
78	# and -DHAVE_FOO=OFF if it is disabled.
79	cmake-utils_has() { _use_me_now HAVE "$@" ; }
80
81	# @FUNCTION: cmake-utils_src_configure
82	# @DESCRIPTION:
83	# General function for configuring with cmake. Default behaviour is to start an
84	# out-of-source build.
85	cmake-utils_src_configure() {
86	debug-print-function $FUNCNAME $*
87
88	if has debug ${IUSE//+} && use debug ; then
89	append-cppflags -DNDEBUG
90	fi
91
92	if [[ -n "${CMAKE_IN_SOURCE_BUILD}" ]]; then
93	cmake-utils_src_configurein
94	else
95	cmake-utils_src_configureout
96	fi
97	}
98
99	# @FUNCTION: cmake-utils_src_compile
100	# @DESCRIPTION:
101	# General function for compiling with cmake. Default behaviour is to check for
102	# eapi and based on it configure or only compile
103	cmake-utils_src_compile() {
104	case ${EAPI} in
105	2)
106	;;
107	*)
108	cmake-utils_src_configure
109	;;
110	esac
111
112	cmake-utils_src_make "$@"
113	}
114
115	# @FUNCTION: cmake-utils_src_configurein
116	# @DESCRIPTION:
117	# Function for software that requires configure and building in the source
118	# directory.
119	cmake-utils_src_configurein() {
120	debug-print-function $FUNCNAME $*
121
122	local cmakeargs="$(_common_configure_code) ${mycmakeargs} ${EXTRA_ECONF}"
123
124	debug-print "$LINENO $ECLASS $FUNCNAME: mycmakeargs is $cmakeargs"
125	cmake ${cmakeargs} . \|\| die "Cmake failed"
126	}
127
128	# @FUNCTION: cmake-utils_src_configureout
129	# @DESCRIPTION:
130	# Function for software that requires configure and building outside the source
131	# tree - default.
132	cmake-utils_src_configureout() {
133	debug-print-function $FUNCNAME $*
134
135	local cmakeargs="$(_common_configure_code) ${mycmakeargs} ${EXTRA_ECONF}"
136	mkdir -p "${WORKDIR}"/${PN}_build
137	pushd "${WORKDIR}"/${PN}_build > /dev/null
138
139	debug-print "$LINENO $ECLASS $FUNCNAME: mycmakeargs is $cmakeargs"
140	cmake ${cmakeargs} "${S}" \|\| die "Cmake failed"
141
142	popd > /dev/null
143	}
144
145	# Internal use only. Common configuration options for all types of builds.
146	_common_configure_code() {
147	local tmp_libdir=$(get_libdir)
148	# CMAKE_BUILD_TYPE only modifies compiler flags, so set to None
149	echo -DCMAKE_BUILD_TYPE=None
150	echo -DCMAKE_C_COMPILER=$(type -P $(tc-getCC))
151	echo -DCMAKE_CXX_COMPILER=$(type -P $(tc-getCXX))
152	echo -DCMAKE_INSTALL_PREFIX=${PREFIX:-/usr}
153	echo -DLIB_SUFFIX=${tmp_libdir/lib}
154	echo -DLIB_INSTALL_DIR=${PREFIX:-/usr}/${tmp_libdir}
155	[[ -n ${CMAKE_NO_COLOR} ]] && echo -DCMAKE_COLOR_MAKEFILE=OFF
156	}
157
158	# @FUNCTION: cmake-utils_src_make
159	# @DESCRIPTION:
160	# Function for building the package. Automatically detects the build type.
161	# All arguments are passed to emake:
162	# "cmake-utils_src_make -j1" can be used to work around parallel make issues.
163	cmake-utils_src_make() {
164	debug-print-function $FUNCNAME $*
165
166	# At this point we can automatically check if it's an out-of-source or an
167	# in-source build
168	if [[ -d ${WORKDIR}/${PN}_build ]]; then
169	pushd "${WORKDIR}"/${PN}_build > /dev/null
170	fi
171	if ! [[ -z ${CMAKE_COMPILER_VERBOSE} ]]; then
172	emake VERBOSE=1 "$@" \|\| die "Make failed!"
173	else
174	emake "$@" \|\| die "Make failed!"
175	fi
176	if [[ -d ${WORKDIR}/${PN}_build ]]; then
177	popd > /dev/null
178	fi
179	}
180
181	# @FUNCTION: cmake-utils_src_install
182	# @DESCRIPTION:
183	# Function for installing the package. Automatically detects the build type.
184	cmake-utils_src_install() {
185	debug-print-function $FUNCNAME $*
186
187	# At this point we can automatically check if it's an out-of-source or an
188	# in-source build
189	if [[ -d ${WORKDIR}/${PN}_build ]]; then
190	pushd "${WORKDIR}"/${PN}_build > /dev/null
191	fi
192	emake install DESTDIR="${D}" \|\| die "Make install failed"
193	if [[ -d ${WORKDIR}/${PN}_build ]]; then
194	popd > /dev/null
195	fi
196
197	# Manual document installation
198	[[ -n "${DOCS}" ]] && dodoc ${DOCS}
199	}
200
201	# @FUNCTION: cmake-utils_src_test
202	# @DESCRIPTION:
203	# Function for testing the package. Automatically detects the build type.
204	cmake-utils_src_test() {
205	debug-print-function $FUNCNAME $*
206
207	# At this point we can automatically check if it's an out-of-source or an
208	# in-source build
209	if [[ -d ${WORKDIR}/${PN}_build ]]; then
210	pushd "${WORKDIR}"/${PN}_build > /dev/null
211	fi
212	# Standard implementation of src_test
213	if emake -j1 check -n &> /dev/null; then
214	einfo ">>> Test phase [check]: ${CATEGORY}/${PF}"
215	if ! emake -j1 check; then
216	die "Make check failed. See above for details."
217	fi
218	elif emake -j1 test -n &> /dev/null; then
219	einfo ">>> Test phase [test]: ${CATEGORY}/${PF}"
220	if ! emake -j1 test; then
221	die "Make test failed. See above for details."
222	fi
223	else
224	einfo ">>> Test phase [none]: ${CATEGORY}/${PF}"
225	fi
226	if [[ -d ${WORKDIR}/${PN}_build ]]; then
227	popd > /dev/null
228	fi
229	}