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.14 2008/10/28 17:39:28 scarabeus 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 flag-o-matic

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 [[ -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 $*

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

        debug-print "$LINENO $ECLASS $FUNCNAME: mycmakeargs is $cmakeargs"
        cmake -C "${TMPDIR}/gentoo_common_config.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 $*

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

        debug-print "$LINENO $ECLASS $FUNCNAME: mycmakeargs is $cmakeargs"
        cmake -C "${TMPDIR}/gentoo_common_config.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)
        # here we set the compiler explicitly, set install directories prefixes, and
        # make sure that the gentoo user compiler flags trump those set in the
        # program
        local modules_dir=/usr/share/cmake/Modules
        local cxx_create_shared_library=$(sed -n -e 's/)/ CACHE STRING "")/' -e "s/<TARGET_SONAME>/<TARGET_SONAME> ${CXXFLAGS}/" -e '/SET(CMAKE_CXX_CREATE_SHARED_LIBRARY/,/)/p' "${modules_dir}/CMakeCXXInformation.cmake")
        local c_create_shared_library=$(sed -n -e 's/)/ CACHE STRING "")/' -e "s/<TARGET_SONAME>/<TARGET_SONAME> ${CFLAGS}/" -e '/SET(CMAKE_C_CREATE_SHARED_LIBRARY/,/)/p' "${modules_dir}/CMakeCInformation.cmake")
        local c_compile_object=$(sed -n -e 's/)/ CACHE STRING "")/' -e "s/<FLAGS>/<FLAGS> ${CFLAGS}/" -e '/SET(CMAKE_C_COMPILE_OBJECT/,/)/p' "${modules_dir}/CMakeCInformation.cmake")
        local cxx_compile_object=$(sed -n -e 's/)/ CACHE STRING "")/' -e "s/<FLAGS>/<FLAGS> ${CXXFLAGS}/" -e '/SET(CMAKE_CXX_COMPILE_OBJECT/,/)/p' "${modules_dir}/CMakeCXXInformation.cmake")
        local c_link_executable=$(sed -n -e 's/)/ CACHE STRING "")/' -e "s/<FLAGS>/<FLAGS> ${CFLAGS}/" -e "s/<LINK_FLAGS>/<LINK_FLAGS> ${LDFLAGS}/" -e '/SET(CMAKE_C_LINK_EXECUTABLE/,/)/p' "${modules_dir}/CMakeCInformation.cmake")
        local cxx_link_executable=$(sed -n -e 's/)/ CACHE STRING "")/' -e "s/<FLAGS>/<FLAGS> ${CXXFLAGS}/" -e "s/<LINK_FLAGS>/<LINK_FLAGS> ${LDFLAGS}/" -e '/SET(CMAKE_CXX_LINK_EXECUTABLE/,/)/p' "${modules_dir}/CMakeCXXInformation.cmake")
        cat > "${TMPDIR}/gentoo_common_config.cmake" <<_EOF_
SET(CMAKE_C_COMPILER $(type -P $(tc-getCC)) CACHE STRING "package building C compiler")
SET(CMAKE_CXX_COMPILER $(type -P $(tc-getCXX)) CACHE STRING "package building C++ compiler")
${c_create_shared_library}
${cxx_create_shared_library}
${c_compile_object}
${cxx_compile_object}
${c_link_executable}
${cxx_link_executable}
SET(CMAKE_INSTALL_PREFIX ${PREFIX:-/usr} CACHE FILEPATH "install path prefix")
SET(LIB_SUFFIX ${tmp_libdir/lib} CACHE FILEPATH "library path suffix")
SET(LIB_INSTALL_DIR ${PREFIX:-/usr}/${tmp_libdir} CACHE FILEPATH "library install directory")

_EOF_

        [[ -n ${CMAKE_NO_COLOR} ]] && echo 'SET(CMAKE_COLOR_MAKEFILE OFF CACHE BOOL "pretty colors during make")' >> "${TMPDIR}/gentoo_common_config.cmake"

        if has debug ${IUSE//+} && use debug ; then
                echo 'SET(CMAKE_BUILD_TYPE Debug CACHE STRING "determines build settings")' >> "${TMPDIR}/gentoo_common_config.cmake"
        else
                echo 'SET(CMAKE_BUILD_TYPE Release CACHE STRING "determines build settings")' >> "${TMPDIR}/gentoo_common_config.cmake"
        fi
}

# @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	philantrop	1.1	# Copyright 1999-2007 Gentoo Foundation
2			# Distributed under the terms of the GNU General Public License v2
3	scarabeus	1.15	# $Header: /var/cvsroot/gentoo-x86/eclass/cmake-utils.eclass,v 1.14 2008/10/28 17:39:28 scarabeus Exp $
4	philantrop	1.1
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	scarabeus	1.14	inherit toolchain-funcs multilib flag-o-matic
19	philantrop	1.1
20			DESCRIPTION="Based on the ${ECLASS} eclass"
21
22	ingmar	1.8	DEPEND=">=dev-util/cmake-2.4.6"
23	philantrop	1.1
24	jmbsvicetto	1.10	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	philantrop	1.1
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	zlin	1.5	# @VARIABLE: DOCS
42			# @DESCRIPTION:
43			# Documents to dodoc
44
45	philantrop	1.1	# @FUNCTION: cmake-utils_use_with
46			# @USAGE: <USE flag> [flag name]
47			# @DESCRIPTION:
48	philantrop	1.3	# Based on use_with. See ebuild(5).
49	betelgeuse	1.4	#
50	philantrop	1.3	# `cmake-utils_use_with foo FOO` echoes -DWITH_FOO=ON if foo is enabled
51			# and -DWITH_FOO=OFF if it is disabled.
52	philantrop	1.1	cmake-utils_use_with() { _use_me_now WITH "$@" ; }
53
54			# @FUNCTION: cmake-utils_use_enable
55			# @USAGE: <USE flag> [flag name]
56			# @DESCRIPTION:
57	philantrop	1.3	# Based on use_enable. See ebuild(5).
58	betelgeuse	1.4	#
59	philantrop	1.3	# `cmake-utils_use_enable foo FOO` echoes -DENABLE_FOO=ON if foo is enabled
60			# and -DENABLE_FOO=OFF if it is disabled.
61	philantrop	1.1	cmake-utils_use_enable() { _use_me_now ENABLE "$@" ; }
62
63	philantrop	1.2	# @FUNCTION: cmake-utils_use_want
64			# @USAGE: <USE flag> [flag name]
65			# @DESCRIPTION:
66	philantrop	1.3	# Based on use_enable. See ebuild(5).
67	betelgeuse	1.4	#
68	philantrop	1.3	# `cmake-utils_use_want foo FOO` echoes -DWANT_FOO=ON if foo is enabled
69			# and -DWANT_FOO=OFF if it is disabled.
70	philantrop	1.2	cmake-utils_use_want() { _use_me_now WANT "$@" ; }
71
72	philantrop	1.3	# @FUNCTION: cmake-utils_has
73			# @USAGE: <USE flag> [flag name]
74			# @DESCRIPTION:
75			# Based on use_enable. See ebuild(5).
76	betelgeuse	1.4	#
77	philantrop	1.3	# `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	jmbsvicetto	1.9	# @FUNCTION: cmake-utils_src_configure
82	philantrop	1.1	# @DESCRIPTION:
83	jmbsvicetto	1.9	# General function for configuring with cmake. Default behaviour is to start an
84			# out-of-source build.
85			cmake-utils_src_configure() {
86	philantrop	1.1	debug-print-function $FUNCNAME $*
87
88	philantrop	1.2	if [[ -n "${CMAKE_IN_SOURCE_BUILD}" ]]; then
89			cmake-utils_src_configurein
90			else
91			cmake-utils_src_configureout
92			fi
93	jmbsvicetto	1.9	}
94
95			# @FUNCTION: cmake-utils_src_compile
96			# @DESCRIPTION:
97			# General function for compiling with cmake. Default behaviour is to check for
98			# eapi and based on it configure or only compile
99			cmake-utils_src_compile() {
100			case ${EAPI} in
101	jmbsvicetto	1.10	2)
102	jmbsvicetto	1.9	;;
103			*)
104			cmake-utils_src_configure
105			;;
106			esac
107
108	philantrop	1.3	cmake-utils_src_make "$@"
109	philantrop	1.1	}
110
111			# @FUNCTION: cmake-utils_src_configurein
112			# @DESCRIPTION:
113			# Function for software that requires configure and building in the source
114			# directory.
115			cmake-utils_src_configurein() {
116			debug-print-function $FUNCNAME $*
117
118	scarabeus	1.15	_common_configure_code
119			local cmakeargs="${mycmakeargs} ${EXTRA_ECONF}"
120	philantrop	1.1
121			debug-print "$LINENO $ECLASS $FUNCNAME: mycmakeargs is $cmakeargs"
122	scarabeus	1.15	cmake -C "${TMPDIR}/gentoo_common_config.cmake" ${cmakeargs} . \|\| die "Cmake failed"
123	philantrop	1.1	}
124
125			# @FUNCTION: cmake-utils_src_configureout
126			# @DESCRIPTION:
127			# Function for software that requires configure and building outside the source
128			# tree - default.
129			cmake-utils_src_configureout() {
130			debug-print-function $FUNCNAME $*
131
132	scarabeus	1.15	_common_configure_code
133			local cmakeargs="${mycmakeargs} ${EXTRA_ECONF}"
134	philantrop	1.2	mkdir -p "${WORKDIR}"/${PN}_build
135			pushd "${WORKDIR}"/${PN}_build > /dev/null
136	philantrop	1.1
137			debug-print "$LINENO $ECLASS $FUNCNAME: mycmakeargs is $cmakeargs"
138	scarabeus	1.15	cmake -C "${TMPDIR}/gentoo_common_config.cmake" ${cmakeargs} "${S}" \|\| die "Cmake failed"
139	philantrop	1.2
140			popd > /dev/null
141	philantrop	1.1	}
142
143			# Internal use only. Common configuration options for all types of builds.
144			_common_configure_code() {
145			local tmp_libdir=$(get_libdir)
146	scarabeus	1.15	# here we set the compiler explicitly, set install directories prefixes, and
147			# make sure that the gentoo user compiler flags trump those set in the
148			# program
149			local modules_dir=/usr/share/cmake/Modules
150			local cxx_create_shared_library=$(sed -n -e 's/)/ CACHE STRING "")/' -e "s/<TARGET_SONAME>/<TARGET_SONAME> ${CXXFLAGS}/" -e '/SET(CMAKE_CXX_CREATE_SHARED_LIBRARY/,/)/p' "${modules_dir}/CMakeCXXInformation.cmake")
151			local c_create_shared_library=$(sed -n -e 's/)/ CACHE STRING "")/' -e "s/<TARGET_SONAME>/<TARGET_SONAME> ${CFLAGS}/" -e '/SET(CMAKE_C_CREATE_SHARED_LIBRARY/,/)/p' "${modules_dir}/CMakeCInformation.cmake")
152			local c_compile_object=$(sed -n -e 's/)/ CACHE STRING "")/' -e "s/<FLAGS>/<FLAGS> ${CFLAGS}/" -e '/SET(CMAKE_C_COMPILE_OBJECT/,/)/p' "${modules_dir}/CMakeCInformation.cmake")
153			local cxx_compile_object=$(sed -n -e 's/)/ CACHE STRING "")/' -e "s/<FLAGS>/<FLAGS> ${CXXFLAGS}/" -e '/SET(CMAKE_CXX_COMPILE_OBJECT/,/)/p' "${modules_dir}/CMakeCXXInformation.cmake")
154			local c_link_executable=$(sed -n -e 's/)/ CACHE STRING "")/' -e "s/<FLAGS>/<FLAGS> ${CFLAGS}/" -e "s/<LINK_FLAGS>/<LINK_FLAGS> ${LDFLAGS}/" -e '/SET(CMAKE_C_LINK_EXECUTABLE/,/)/p' "${modules_dir}/CMakeCInformation.cmake")
155			local cxx_link_executable=$(sed -n -e 's/)/ CACHE STRING "")/' -e "s/<FLAGS>/<FLAGS> ${CXXFLAGS}/" -e "s/<LINK_FLAGS>/<LINK_FLAGS> ${LDFLAGS}/" -e '/SET(CMAKE_CXX_LINK_EXECUTABLE/,/)/p' "${modules_dir}/CMakeCXXInformation.cmake")
156			cat > "${TMPDIR}/gentoo_common_config.cmake" <<_EOF_
157			SET(CMAKE_C_COMPILER $(type -P $(tc-getCC)) CACHE STRING "package building C compiler")
158			SET(CMAKE_CXX_COMPILER $(type -P $(tc-getCXX)) CACHE STRING "package building C++ compiler")
159			${c_create_shared_library}
160			${cxx_create_shared_library}
161			${c_compile_object}
162			${cxx_compile_object}
163			${c_link_executable}
164			${cxx_link_executable}
165			SET(CMAKE_INSTALL_PREFIX ${PREFIX:-/usr} CACHE FILEPATH "install path prefix")
166			SET(LIB_SUFFIX ${tmp_libdir/lib} CACHE FILEPATH "library path suffix")
167			SET(LIB_INSTALL_DIR ${PREFIX:-/usr}/${tmp_libdir} CACHE FILEPATH "library install directory")
168
169			_EOF_
170
171			[[ -n ${CMAKE_NO_COLOR} ]] && echo 'SET(CMAKE_COLOR_MAKEFILE OFF CACHE BOOL "pretty colors during make")' >> "${TMPDIR}/gentoo_common_config.cmake"
172
173			if has debug ${IUSE//+} && use debug ; then
174			echo 'SET(CMAKE_BUILD_TYPE Debug CACHE STRING "determines build settings")' >> "${TMPDIR}/gentoo_common_config.cmake"
175			else
176			echo 'SET(CMAKE_BUILD_TYPE Release CACHE STRING "determines build settings")' >> "${TMPDIR}/gentoo_common_config.cmake"
177			fi
178	philantrop	1.1	}
179
180			# @FUNCTION: cmake-utils_src_make
181			# @DESCRIPTION:
182			# Function for building the package. Automatically detects the build type.
183	philantrop	1.3	# All arguments are passed to emake:
184			# "cmake-utils_src_make -j1" can be used to work around parallel make issues.
185	philantrop	1.1	cmake-utils_src_make() {
186			debug-print-function $FUNCNAME $*
187
188			# At this point we can automatically check if it's an out-of-source or an
189			# in-source build
190			if [[ -d ${WORKDIR}/${PN}_build ]]; then
191	philantrop	1.2	pushd "${WORKDIR}"/${PN}_build > /dev/null
192	philantrop	1.1	fi
193			if ! [[ -z ${CMAKE_COMPILER_VERBOSE} ]]; then
194	philantrop	1.3	emake VERBOSE=1 "$@" \|\| die "Make failed!"
195	philantrop	1.1	else
196	philantrop	1.3	emake "$@" \|\| die "Make failed!"
197	philantrop	1.2	fi
198			if [[ -d ${WORKDIR}/${PN}_build ]]; then
199			popd > /dev/null
200	philantrop	1.1	fi
201			}
202
203			# @FUNCTION: cmake-utils_src_install
204			# @DESCRIPTION:
205			# Function for installing the package. Automatically detects the build type.
206			cmake-utils_src_install() {
207			debug-print-function $FUNCNAME $*
208
209			# At this point we can automatically check if it's an out-of-source or an
210			# in-source build
211			if [[ -d ${WORKDIR}/${PN}_build ]]; then
212	philantrop	1.2	pushd "${WORKDIR}"/${PN}_build > /dev/null
213	philantrop	1.1	fi
214			emake install DESTDIR="${D}" \|\| die "Make install failed"
215	philantrop	1.2	if [[ -d ${WORKDIR}/${PN}_build ]]; then
216			popd > /dev/null
217			fi
218	zlin	1.5
219			# Manual document installation
220			[[ -n "${DOCS}" ]] && dodoc ${DOCS}
221	philantrop	1.1	}
222
223			# @FUNCTION: cmake-utils_src_test
224			# @DESCRIPTION:
225			# Function for testing the package. Automatically detects the build type.
226			cmake-utils_src_test() {
227			debug-print-function $FUNCNAME $*
228
229			# At this point we can automatically check if it's an out-of-source or an
230			# in-source build
231			if [[ -d ${WORKDIR}/${PN}_build ]]; then
232	philantrop	1.2	pushd "${WORKDIR}"/${PN}_build > /dev/null
233	philantrop	1.1	fi
234			# Standard implementation of src_test
235			if emake -j1 check -n &> /dev/null; then
236			einfo ">>> Test phase [check]: ${CATEGORY}/${PF}"
237			if ! emake -j1 check; then
238			die "Make check failed. See above for details."
239			fi
240			elif emake -j1 test -n &> /dev/null; then
241			einfo ">>> Test phase [test]: ${CATEGORY}/${PF}"
242			if ! emake -j1 test; then
243			die "Make test failed. See above for details."
244			fi
245			else
246			einfo ">>> Test phase [none]: ${CATEGORY}/${PF}"
247			fi
248	philantrop	1.2	if [[ -d ${WORKDIR}/${PN}_build ]]; then
249			popd > /dev/null
250			fi
251	philantrop	1.1	}