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	# 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.14 2008/10/28 17:39:28 scarabeus 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 flag-o-matic
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 [[ -n "${CMAKE_IN_SOURCE_BUILD}" ]]; then
89	cmake-utils_src_configurein
90	else
91	cmake-utils_src_configureout
92	fi
93	}
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	2)
102	;;
103	*)
104	cmake-utils_src_configure
105	;;
106	esac
107
108	cmake-utils_src_make "$@"
109	}
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	_common_configure_code
119	local cmakeargs="${mycmakeargs} ${EXTRA_ECONF}"
120
121	debug-print "$LINENO $ECLASS $FUNCNAME: mycmakeargs is $cmakeargs"
122	cmake -C "${TMPDIR}/gentoo_common_config.cmake" ${cmakeargs} . \|\| die "Cmake failed"
123	}
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	_common_configure_code
133	local cmakeargs="${mycmakeargs} ${EXTRA_ECONF}"
134	mkdir -p "${WORKDIR}"/${PN}_build
135	pushd "${WORKDIR}"/${PN}_build > /dev/null
136
137	debug-print "$LINENO $ECLASS $FUNCNAME: mycmakeargs is $cmakeargs"
138	cmake -C "${TMPDIR}/gentoo_common_config.cmake" ${cmakeargs} "${S}" \|\| die "Cmake failed"
139
140	popd > /dev/null
141	}
142
143	# Internal use only. Common configuration options for all types of builds.
144	_common_configure_code() {
145	local tmp_libdir=$(get_libdir)
146	# 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	}
179
180	# @FUNCTION: cmake-utils_src_make
181	# @DESCRIPTION:
182	# Function for building the package. Automatically detects the build type.
183	# All arguments are passed to emake:
184	# "cmake-utils_src_make -j1" can be used to work around parallel make issues.
185	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	pushd "${WORKDIR}"/${PN}_build > /dev/null
192	fi
193	if ! [[ -z ${CMAKE_COMPILER_VERBOSE} ]]; then
194	emake VERBOSE=1 "$@" \|\| die "Make failed!"
195	else
196	emake "$@" \|\| die "Make failed!"
197	fi
198	if [[ -d ${WORKDIR}/${PN}_build ]]; then
199	popd > /dev/null
200	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	pushd "${WORKDIR}"/${PN}_build > /dev/null
213	fi
214	emake install DESTDIR="${D}" \|\| die "Make install failed"
215	if [[ -d ${WORKDIR}/${PN}_build ]]; then
216	popd > /dev/null
217	fi
218
219	# Manual document installation
220	[[ -n "${DOCS}" ]] && dodoc ${DOCS}
221	}
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	pushd "${WORKDIR}"/${PN}_build > /dev/null
233	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	if [[ -d ${WORKDIR}/${PN}_build ]]; then
249	popd > /dev/null
250	fi
251	}