/[gentoo-x86]/eclass/cmake-utils.eclass
Gentoo

Contents of /eclass/cmake-utils.eclass

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.16 - (show annotations) (download)
Wed Dec 24 15:41:06 2008 UTC (5 years, 3 months ago) by scarabeus
Branch: MAIN
Changes since 1.15: +3 -3 lines
Disable stripping in cmake fashion, we do it on portage side later and we dont need it done by cmake itself. Fixes bug #251304.

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.15 2008/11/05 20:59:37 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} -DCMAKE_INSTALL_DO_STRIP=OFF"
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} -DCMAKE_INSTALL_DO_STRIP=OFF"
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 }

  ViewVC Help
Powered by ViewVC 1.1.20