]>
Commit | Line | Data |
---|---|---|
6db31708 | 1 | # AliRoot Build System Utility Macro and Function definitions |
2 | # | |
3 | # Author: Johny Jose (johny.jose@cern.ch) | |
4 | # Port of previous Makefile build to cmake | |
5 | ||
6 | cmake_minimum_required(VERSION 2.8 FATAL_ERROR) | |
7 | ||
8 | macro(ALICE_DevFlagsOutput) | |
9 | ||
10 | if(ALICEDEV STREQUAL "YES") | |
11 | message(STATUS "FFLAGS : ${FFLAGS}") | |
12 | message(STATUS "CXXFLAGS : ${CXXFLAGS}") | |
13 | message(STATUS "CFLAGS : ${CFLAGS}") | |
14 | message(STATUS "SOFLAGS : ${SOFLAGS}") | |
15 | message(STATUS "LDFLAGS : ${LDFLAGS}") | |
16 | message(STATUS "SHLIB : ${SHLIB}") | |
17 | message(STATUS "SYSLIBS : ${SYSLIBS}") | |
18 | message(STATUS "CINTFLAGS : ${CINTFLAGS}") | |
19 | endif(ALICEDEV STREQUAL "YES") | |
20 | ||
21 | endmacro(ALICE_DevFlagsOutput) | |
22 | ||
23 | function(ALICE_CleanOutput _output input) | |
24 | ||
25 | string(REGEX REPLACE "\n" " " clean ${input}) | |
26 | set(${_output} ${clean} PARENT_SCOPE) | |
27 | ||
28 | endfunction(ALICE_CleanOutput) | |
29 | ||
30 | function(ALICE_CorrectPaths _output value ) | |
31 | ||
32 | set(corrected) | |
33 | foreach(path ${value}) | |
34 | set(external) | |
35 | string(REGEX MATCH "^/" external ${path}) | |
36 | if(NOT external) | |
37 | list(APPEND corrected "${CMAKE_SOURCE_DIR}/${path}" ) | |
38 | else() | |
39 | list(APPEND corrected ${path}) | |
40 | endif(NOT external) | |
41 | endforeach(path) | |
42 | set(${_output} ${corrected} PARENT_SCOPE) | |
43 | ||
44 | endfunction(ALICE_CorrectPaths) | |
45 | ||
46 | function(ALICE_Format _output prefix suffix input) | |
47 | ||
48 | # DevNotes - input should be put in quotes or the complete list does not get passed to the function | |
49 | set(format) | |
50 | foreach(arg ${input}) | |
51 | set(item ${arg}) | |
52 | if(prefix) | |
53 | string(REGEX MATCH "^${prefix}" pre ${arg}) | |
54 | endif(prefix) | |
55 | if(suffix) | |
56 | string(REGEX MATCH "${suffix}$" suf ${arg}) | |
57 | endif(suffix) | |
58 | if(NOT pre) | |
59 | set(item "${prefix}${item}") | |
60 | endif(NOT pre) | |
61 | if(NOT suf) | |
62 | set(item "${item}${suffix}") | |
63 | endif(NOT suf) | |
64 | list(APPEND format ${item}) | |
65 | endforeach(arg) | |
66 | set(${_output} ${format} PARENT_SCOPE) | |
67 | ||
68 | endfunction(ALICE_Format) | |
69 | ||
70 | function(ALICE_CheckLibraries _output input) | |
71 | ||
72 | set(format) | |
73 | foreach(arg ${input}) | |
74 | set(item ${arg}) | |
75 | string(REGEX MATCH "^(/|-)" preformatted ${item}) | |
76 | if(NOT preformatted) | |
77 | set(item "-l${item}") | |
78 | endif(NOT preformatted) | |
79 | list(APPEND format ${item}) | |
80 | endforeach(arg) | |
81 | set(${_output} ${format} PARENT_SCOPE) | |
82 | ||
83 | endfunction(ALICE_CheckLibraries) | |
84 | ||
85 | function(ALICE_RootConfig _output parameters) | |
86 | ||
87 | if(ROOT_CONFIG) | |
88 | execute_process(COMMAND ${ROOT_CONFIG} ${parameters} OUTPUT_VARIABLE result ERROR_VARIABLE error OUTPUT_STRIP_TRAILING_WHITESPACE ) | |
89 | if(error) | |
90 | message(FATAL_ERROR "root-config ERROR : ${error}") | |
91 | endif(error) | |
92 | ALICE_CleanOutput(result "${result}") | |
93 | set(${_output} "${result}" PARENT_SCOPE) | |
94 | else() | |
95 | message(FATAL_ERROR "root-config not found") | |
96 | endif(ROOT_CONFIG) | |
97 | ||
98 | endfunction(ALICE_RootConfig) | |
99 | ||
100 | macro(ALICE_CheckOutOfSourceBuild) | |
101 | ||
102 | #Check if previous in-source build failed | |
103 | if(EXISTS ${CMAKE_SOURCE_DIR}/CMakeCache.txt OR EXISTS ${CMAKE_SOURCE_DIR}/CMakeFiles) | |
104 | message(FATAL_ERROR "CMakeCache.txt or CMakeFiles exists in source directory! Please remove them before running cmake $ALICE_ROOT") | |
105 | endif(EXISTS ${CMAKE_SOURCE_DIR}/CMakeCache.txt OR EXISTS ${CMAKE_SOURCE_DIR}/CMakeFiles) | |
106 | ||
107 | #Get Real Paths of the source and binary directories | |
108 | get_filename_component(srcdir "${CMAKE_SOURCE_DIR}" REALPATH) | |
109 | get_filename_component(bindir "${CMAKE_BINARY_DIR}" REALPATH) | |
110 | ||
111 | #Check for in-source builds | |
112 | if(${srcdir} STREQUAL ${bindir}) | |
113 | message(FATAL_ERROR "AliRoot cannot be built in-source! Please run cmake $ALICE_ROOT outside the source directory") | |
114 | endif(${srcdir} STREQUAL ${bindir}) | |
115 | ||
116 | endmacro(ALICE_CheckOutOfSourceBuild) | |
117 | ||
118 | macro(ALICE_ConfigureCompiler) | |
119 | ||
120 | if(ALIDEBUG STREQUAL "YES") | |
121 | set(ALICE_TARGET ${ALICE_TARGET}DEBUG) | |
122 | message("Befor ${CXXFLAGS}") | |
123 | string(REGEX MATCHALL "-O[^ ]*" FFLAGS ${FFLAGS}) | |
124 | string(REGEX MATCHALL "-O[^ ]*" CXXFLAGS ${CXXFLAGS}) | |
125 | message("After ${CXXFLAGS}") | |
126 | string(REGEX MATCHALL "-O[^ ]*" CFLAGS ${CFLAGS}) | |
127 | string(REGEX MATCHALL "-O[^ ]*" SOFLAGS ${SOFLAGS}) | |
128 | string(REGEX MATCHALL "-O[^ ]*" LDFLAGS ${LDFLAGS}) | |
129 | set(FFLAGS "-g ${FFLAGS}") | |
130 | set(CXXFLAGS "-g ${CXXFLAGS}") | |
131 | set(CFLAGS "-g ${CFLAGS}") | |
132 | set(SOFLAGS "-g ${SOFLAGS}") | |
133 | set(LDFLAGS "-g ${LDFLAGS}") | |
134 | endif(ALIDEBUG STREQUAL "YES") | |
135 | ||
136 | if(ALIPROFILE STREQUAL "YES") | |
137 | set(ALICE_TARGET ${ALICE_TARGET}PROF) | |
138 | set(FFLAGS "-pg ${FFLAGS}") | |
139 | set(CXXFLAGS "-pg ${CXXFLAGS}") | |
140 | set(CFLAGS "-pg ${CFLAGS}") | |
141 | set(SOFLAGS "-pg ${SOFLAGS}") | |
142 | set(LDFLAGS "-pg ${LDFLAGS}") | |
143 | endif(ALIPROFILE STREQUAL "YES") | |
144 | ||
145 | ALICE_RootConfig(RCFLAGS --auxcflags) | |
146 | ALICE_RootConfig(RLFLAGS --ldflags) | |
147 | ||
148 | set(CXXFLAGS "${CXXFLAGS} ${RCFLAGS}") | |
149 | set(CFLAGS "${CFLAGS} ${RCFLAGS}") | |
150 | set(SOFLAGS "${SOFLAGS} ${RLFLAGS}") | |
151 | set(LDFLAGS "${LDFLAGS} ${RLFLAGS}") | |
152 | ||
153 | if(NOT ALICXXWARN STREQUAL "NO") | |
154 | set(CXXFLAGS "${CXXFLAGS} ${CXXWARN}") | |
155 | endif(NOT ALICXXWARN STREQUAL "NO") | |
156 | ||
157 | set(CXXFLAGS "${DATEFLAGS} ${CXXFLAGS}") | |
158 | set(CFLAGS "${DATEFLAGS} ${CFLAGS}") | |
159 | set(CINTFLAGS "${DATEFLAGS}") | |
160 | ||
161 | endmacro(ALICE_ConfigureCompiler) | |
162 | ||
163 | macro(ALICE_ConfigurePlatform) | |
164 | ||
165 | ALICE_GetTarget() | |
166 | include("CMake${ALICE_TARGET}") | |
167 | ||
168 | endmacro(ALICE_ConfigurePlatform) | |
169 | ||
170 | macro(ALICE_GetTarget) | |
171 | ||
172 | #Set ALICE_TARGET if it has not been set yet | |
173 | if(NOT ALICE_TARGET) | |
174 | set(ALICE_TARGET $ENV{ALICE_TARGET}) | |
175 | #If ALICE_TARGET is not defined assign default values | |
176 | if(NOT ALICE_TARGET) | |
177 | message(WARNING "Environment variable ALICE_TARGET is not set ! Setting to default value.") | |
178 | ALICE_RootConfig(ALICE_TARGET --arch) | |
179 | message("ALICE_TARGET set to ${ALICE_TARGET}") | |
180 | endif(NOT ALICE_TARGET) | |
181 | endif(NOT ALICE_TARGET) | |
182 | ||
183 | endmacro(ALICE_GetTarget) | |
184 | ||
185 | macro(ALICE_ResetPackage) | |
186 | ||
187 | set(MODDIR ${MODULE}) | |
188 | set(MODDIRI ${PROJECT_SOURCE_DIR}/${MODULE}) | |
189 | ||
190 | set(SRCS) | |
191 | set(HDRS) | |
192 | set(FSRCS) | |
193 | set(DHDR) | |
194 | set(CSRCS) | |
195 | set(CHDRS) | |
196 | set(EINCLUDE) | |
197 | set(EDEFINE) | |
198 | set(ELIBS) | |
199 | set(ELIBSDIR) | |
200 | set(PACKFFLAGS) | |
201 | set(PACKCXXFLAGS) | |
202 | set(PACKCFLAGS) | |
203 | set(PACKDYFLAGS) | |
204 | set(PACKSOFLAGS) | |
205 | set(PACKLDFLAGS) | |
206 | set(PACKBLIBS) | |
207 | set(EXPORT) | |
208 | set(EHDRS) | |
209 | set(CINTHDRS) | |
210 | set(CINTAUTOLINK) | |
211 | set(ARLIBS) | |
212 | set(SHLIBS) | |
213 | ||
214 | #HLT Variables | |
215 | set(MODULE_HDRS) | |
216 | set(MODULE_SRCS) | |
217 | set(MODULE_DHDR) | |
218 | set(CLASS_HDRS) | |
219 | set(LIBRARY_DEP) | |
220 | set(HLTDEFS) | |
221 | set(HLTSOFLAGS) | |
222 | ||
223 | ||
224 | set(PSRCS) | |
225 | set(PHDRS) | |
226 | set(PFSRCS) | |
227 | set(PDHDR) | |
228 | set(PCSRCS) | |
229 | set(PCHDRS) | |
230 | set(PEINCLUDE) | |
231 | set(PEDEFINE) | |
232 | set(PELIBS) | |
233 | set(PELIBSDIR) | |
234 | set(PPACKFFLAGS) | |
235 | set(PPACKCXXFLAGS) | |
236 | set(PPACKCFLAGS) | |
237 | set(PPACKDYFLAGS) | |
238 | set(PPACKSOFLAGS) | |
239 | set(PPACKLDFLAGS) | |
240 | set(PPACKBLIBS) | |
241 | set(PEXPORT) | |
242 | set(PEHDRS) | |
243 | set(PCINTHDRS) | |
244 | set(PCINTAUTOLINK) | |
245 | set(PARLIBS) | |
246 | set(PSHLIBS) | |
247 | set(PDS) | |
248 | ||
249 | endmacro(ALICE_ResetPackage) | |
250 | ||
251 | function(ALICE_SetPackageVariable _var ext setvalue unsetvalue ) | |
252 | ||
253 | #DevNotes - setvalue and unsetcalue should both be put in quotes or cmake throws an error if they have undefined values | |
254 | if(setvalue) | |
255 | set(${_var} ${setvalue} PARENT_SCOPE) | |
256 | set(${PACKAGE}${ext} ${setvalue} PARENT_SCOPE) | |
257 | else() | |
258 | set(${_var} ${unsetvalue} PARENT_SCOPE) | |
259 | set(${PACKAGE}${ext} ${unsetvalue} PARENT_SCOPE) | |
260 | endif(setvalue) | |
261 | ||
262 | endfunction(ALICE_SetPackageVariable) | |
263 | ||
264 | macro(ALICE_BuildPackage) | |
265 | ||
266 | list(APPEND EINCLUDE STEER) | |
267 | ||
268 | ALICE_SetPackageVariable(PFFLAGS "FFLAGS" "${PACKFFLAGS}" "${FFLAGS}") | |
269 | ALICE_SetPackageVariable(PCFLAGS "CFLAGS" "${PACKCFLAGS}" "${CFLAGS}") | |
270 | ALICE_SetPackageVariable(PCXXFLAGS "CXXFLAGS" "${PACKCXXFLAGS}" "${CXXFLAGS}") | |
271 | ALICE_SetPackageVariable(PSOFLAGS "SOFLAGS" "${PACKSOFLAGS}" "${SOFLAGS}") | |
272 | ALICE_SetPackageVariable(PLDFLAGS "LDFLAGS" "${PACKLDFLAGS}" "${LDFLAGS}") | |
273 | ALICE_SetPackageVariable(PDCXXFLAGS "DCXXFLAGS" "${PACKDCXXFLAGS}" "${CXXFLAGSNO}") | |
274 | ALICE_SetPackageVariable(PBLIBS "BLIBS" "${PACKBLIBS}" "${LIBS}") | |
275 | ||
276 | set(WITHDICT) | |
277 | if(DHDR OR CINTAUTOLINK) | |
278 | set(WITHDICT TRUE) | |
279 | endif(DHDR OR CINTAUTOLINK) | |
280 | ||
281 | ALICE_SetPackageVariable(PEDEFINE "EDEFINE" "${EDEFINE}" "${EDEFINE}") | |
282 | ALICE_SetPackageVariable(PEXPORT "EXPORT" "${EXPORT}" "${EXPORT}") | |
283 | ALICE_SetPackageVariable(PEXPORTDEST "EXPORTDEST" "${CMAKE_INCLUDE_EXPORT_DIRECTORY}" "${CMAKE_INCLUDE_EXPORT_DIRECTORY}") | |
284 | ALICE_SetPackageVariable(PINC "INC" "${EINCLUDE};${MODULE}" "${EINCLUDE};${MODULE}") | |
285 | ALICE_SetPackageVariable(PELIBS "ELIBS" "${ELIBS}" "${ELIBS}") | |
286 | ALICE_SetPackageVariable(PELIBSDIR "ELIBSDIR" "${ELIBSDIR}" "${ELIBSDIR}") | |
287 | ||
288 | ALICE_SetPackageVariable(PCS "CS" "${CSRCS}" "${CSRCS}") | |
289 | ALICE_SetPackageVariable(PCH "CH" "${CHDRS}" "${CHDRS}") | |
290 | ||
291 | ALICE_SetPackageVariable(PFS "FS" "${FSRCS}" "${FSRCS}") | |
292 | ||
293 | ALICE_SetPackageVariable(PS "S" "${SRCS}" "${SRCS}") | |
294 | ALICE_SetPackageVariable(PH "H" "${HDRS} ${EHDRS}" "${HDRS} ${EHDRS}") | |
295 | ALICE_SetPackageVariable(PCINTHDRS "CINTHDRS" "${CINTHDRS}" "${PH}") | |
296 | ||
297 | string( REPLACE ".h" "" PCINTCLASSES "${PCINTHDRS}") | |
298 | set ( ${PACKAGE}CINTCLASSES ${PCINTCLASSES}) | |
299 | ||
300 | ALICE_SetPackageVariable(PDH "DH" "${DHDR}" "") | |
301 | ||
302 | if(CINTAUTOLINK) | |
303 | ALICE_SetPackageVariable(PDAL "DAL" "${CMAKE_CURRENT_BINARY_DIR}/G__${PACKAGE}AutoLinkDef.h" "${CMAKE_CURRENT_BINARY_DIR}/G__${PACKAGE}AutoLinkDef.h") | |
304 | ALICE_SetPackageVariable(PDH "DH" "${PDAL}" "${PDAL}") | |
305 | ALICE_GenerateLinkDef() | |
306 | endif(CINTAUTOLINK) | |
307 | ||
308 | if(lib) | |
45526b5e | 309 | list(APPEND PMLIBS ${PACKAGE}) |
6db31708 | 310 | list(APPEND ALLLIBS ${PACKAGE}) |
45526b5e | 311 | list(APPEND PMALIBS ${PACKAGE}_a) |
6db31708 | 312 | list(APPEND ALLALIBS ${PACKAGE}_a) |
313 | list(APPEND BINLIBS ${PACKAGE}) | |
314 | else() | |
315 | list(APPEND ALLEXECS ${PACKAGE}) | |
316 | endif(lib) | |
45526b5e | 317 | set(${MODULE}ALIBS "${PMALIBS}" PARENT_SCOPE) |
318 | set(${MODULE}LIBS "${PMLIBS}" PARENT_SCOPE) | |
319 | set(${MODULE}INC "${EINCLUDE}" PARENT_SCOPE) | |
6db31708 | 320 | list(APPEND INCLUDEFILES ${PEXPORTDEST}) |
321 | ALICE_CopyHeaders() | |
322 | if(WITHDICT) | |
323 | ALICE_SetPackageVariable(PDS "DS" "G__${PACKAGE}.cxx" "G__${PACKAGE}.cxx") | |
324 | ALICE_GenerateDictionary() | |
325 | else() | |
326 | if(lib) | |
327 | message(STATUS "No dictionary generated for ${PACKAGE}") | |
328 | endif(lib) | |
329 | endif(WITHDICT) | |
330 | ||
331 | if(PS OR PCS OR PFS) | |
332 | if(lib) | |
333 | ALICE_BuildLibrary() | |
334 | elseif(bin) | |
335 | ALICE_BuildExecutable() | |
336 | endif(lib) | |
337 | endif(PS OR PCS OR PFS) | |
338 | ||
339 | endmacro(ALICE_BuildPackage) | |
340 | ||
341 | ||
342 | macro(ALICE_BuildModule) | |
343 | ||
344 | add_definitions(-D_MODULE="${MODULE}") | |
345 | foreach(PACKAGEFILE ${PACKAGES}) | |
346 | set(lib) | |
347 | set(bin) | |
348 | string(REGEX MATCH "CMakelib" lib ${PACKAGEFILE}) | |
349 | string(REGEX MATCH "CMakebin" bin ${PACKAGEFILE}) | |
350 | get_filename_component(PACKAGE ${PACKAGEFILE} NAME) | |
351 | string(REGEX REPLACE "^CMake(lib|bin)(.*)\\.pkg" "\\2" PACKAGE ${PACKAGE}) | |
352 | if(ALICEDEV) | |
353 | message("Adding package ${PACKAGE} in ${MODULE}") | |
354 | endif(ALICEDEV) | |
355 | ALICE_ResetPackage() | |
356 | include(${PACKAGEFILE}) | |
357 | ALICE_BuildPackage() | |
358 | ||
359 | get_property(EXCLUDEPACKAGE TARGET ${PACKAGE} PROPERTY EXCLUDE_FROM_ALL) | |
360 | if(NOT EXCLUDEPACKAGE) | |
361 | install(TARGETS ${PACKAGE} | |
362 | RUNTIME DESTINATION bin | |
363 | LIBRARY DESTINATION lib | |
364 | ARCHIVE DESTINATION bin) | |
365 | endif(NOT EXCLUDEPACKAGE) | |
366 | endforeach(PACKAGEFILE) | |
367 | ||
368 | endmacro(ALICE_BuildModule) | |
369 | ||
370 | macro(ALICE_GenerateDictionary) | |
371 | ||
372 | if(ALICEDEV STREQUAL "YES") | |
373 | message("Generating Dictionary rule for ${PACKAGE}") | |
374 | message("${ROOTCINT} -f ${PDS} -c ${PEDEFINE} ${CINTFLAGS} ${PINC} ${PCINTHDRS} ${PDH}") | |
375 | endif(ALICEDEV STREQUAL "YES") | |
376 | ||
377 | # Split up all arguments | |
378 | ||
379 | set(DEDEFINE ${PEDEFINE}) | |
380 | set(DCINTFLAGS ${CINTFLAGS}) | |
381 | set(DINC ${PINC}) | |
382 | set(DCINTHDRS ${PCINTHDRS}) | |
383 | set(DDH ${PDH}) | |
384 | separate_arguments(DEDEFINE) | |
385 | separate_arguments(DCINTFLAGS) | |
386 | separate_arguments(DINC) | |
387 | separate_arguments(DCINTHDRS) | |
388 | separate_arguments(DDH) | |
389 | # Format neccesary arguments | |
390 | ALICE_Format(DINC "-I" "" "${DINC};${CMAKE_INCLUDE_EXPORT_DIRECTORY}") | |
391 | set_source_files_properties(${PDS} PROPERTIES GENERATED TRUE) | |
392 | add_custom_command(OUTPUT ${PDS} | |
393 | COMMAND cd ${PROJECT_SOURCE_DIR} && ${ROOTCINT} -f ${CMAKE_CURRENT_BINARY_DIR}/${PDS} -c -D_MODULE=\\\"${MODULE}\\\" ${DEDEFINE} ${DCINTFLAGS} ${DINC} ${DCINTHDRS} ${DDH} | |
394 | WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} | |
395 | DEPENDS ${DCINTHDRS} ${DDH} | |
396 | ) | |
397 | add_custom_target(G${PACKAGE}) | |
398 | add_dependencies(G${PACKAGE} ${PDS}) | |
399 | ||
400 | endmacro(ALICE_GenerateDictionary) | |
401 | ||
402 | macro(ALICE_BuildLibrary) | |
403 | ||
404 | ALICE_DevFlagsOutput() | |
405 | set(CMAKE_CXX_FLAGS "${PEDEFINE} ${PCXXFLAGS}") | |
406 | set(CMAKE_C_FLAGS "${PEDEFINE} ${PCFLAGS}") | |
407 | set(CMAKE_Fortran_FLAGS ${PEDEFINE} ${PFFLAGS}) | |
408 | set(CMAKE_SHARED_LINKER_FLAGS ${PSOFLAGS}) | |
409 | set(CMAKE_MODULE_LINKER_FLAGS ${PLDFLAGS}) | |
410 | ||
411 | ||
412 | separate_arguments(PINC) | |
413 | separate_arguments(EINCLUDE) | |
414 | separate_arguments(PELIBSDIR) | |
415 | separate_arguments(PBLIBS) | |
416 | separate_arguments(PELIBS) | |
417 | separate_arguments(SHLIB) | |
418 | ||
419 | ALICE_Format(PELIBSDIR "-L" "" "${PELIBSDIR}") | |
420 | ALICE_CheckLibraries(PBLIBS "${PBLIBS}") | |
421 | ALICE_CheckLibraries(PELIBS "${PELIBS}") | |
422 | ||
423 | ALICE_CorrectPaths(EINCLUDE "${EINCLUDE}") | |
424 | ALICE_CorrectPaths(PINC "${PINC}") | |
425 | ||
426 | include_directories(SYSTEM ${ROOTINCDIR}) | |
427 | include_directories(${PINC}) | |
428 | include_directories(${EINCLUDE}) | |
429 | include_directories(${CMAKE_INCLUDE_EXPORT_DIRECTORY}) | |
430 | ||
431 | add_library(${PACKAGE} SHARED ${PCS} ${PFS} ${PS} ${PDS}) | |
432 | ||
433 | ||
434 | if(PELIBS OR SHLIB) | |
435 | target_link_libraries(${PACKAGE} ${PELIBSDIR} ${PELIBS} ${SHLIB}) | |
436 | endif(PELIBS OR SHLIB) | |
437 | ||
438 | add_dependencies(${MODULE}-all ${PACKAGE}) | |
439 | ||
440 | add_library(${PACKAGE}_a STATIC EXCLUDE_FROM_ALL ${PCS} ${PFS} ${PS} ${PDS}) | |
441 | if(PELIBS OR ALLIB) | |
442 | target_link_libraries(${PACKAGE}_a ${PELIBSDIR} ${PELIBS} ${ALLIB}) | |
443 | endif(PELIBS OR ALLIB) | |
444 | ||
445 | add_dependencies(${MODULE}-static ${PACKAGE}_a) | |
446 | if(ALIPROFILE STREQUAL "YES") | |
447 | add_dependencies(${MODULE}-all ${MODULE}-static) | |
448 | endif(ALIPROFILE STREQUAL "YES") | |
449 | ||
450 | list(FIND EXCLUDEMODULES ${MODULE} RESULT) | |
451 | if(NOT RESULT STREQUAL "-1") | |
452 | message(STATUS "${MODULE} will not be built by default. Type make ${MODULE}-all to build.") | |
453 | set_property(TARGET ${PACKAGE} PROPERTY EXCLUDE_FROM_ALL TRUE) | |
454 | endif(NOT RESULT STREQUAL "-1") | |
455 | ||
456 | endmacro(ALICE_BuildLibrary) | |
457 | ||
458 | macro(ALICE_BuildExecutable) | |
459 | ||
460 | ALICE_DevFlagsOutput() | |
461 | set(CMAKE_CXX_FLAGS "${PEDEFINE} ${PCXXFLAGS} ${EXEFLAGS}") | |
462 | set(CMAKE_C_FLAGS "${PEDEFINE} ${PCFLAGS} ${EXEFLAGS}") | |
463 | set(CMAKE_Fortran_FLAGS "${PEDEFINE} ${PFFLAGS} ${EXEFLAGS}") | |
464 | set(CMAKE_SHARED_LINKER_FLAGS ${PSOFLAGS}) | |
465 | set(CMAKE_MODULE_LINKER_FLAGS ${PLDFLAGS}) | |
466 | ||
467 | separate_arguments(PINC) | |
468 | separate_arguments(EINCLUDE) | |
469 | separate_arguments(PELIBSDIR) | |
470 | separate_arguments(PBLIBS) | |
471 | separate_arguments(PELIBS) | |
472 | separate_arguments(SHLIB) | |
473 | ||
474 | ALICE_Format(PELIBSDIR "-L" "" "${PELIBSDIR}") | |
475 | ALICE_CheckLibraries(PBLIBS "${PBLIBS}") | |
476 | #ALICE_CheckLibraries(PELIBS "${PELIBS}") | |
477 | ||
478 | ALICE_CorrectPaths(EINCLUDE "${EINCLUDE}") | |
479 | ALICE_CorrectPaths(PINC "${PINC}") | |
480 | ||
481 | include_directories(SYSTEM ${ROOTINCDIR}) | |
482 | include_directories(${PINC}) | |
483 | include_directories(${EINCLUDE}) | |
484 | include_directories(${CMAKE_INCLUDE_EXPORT_DIRECTORY}) | |
485 | ||
486 | if(ALIPROFILE STREQUAL "YES") | |
487 | add_executable(${PACKAGE} ${PFS} ${PCS} ${PS} ${PDS}) | |
488 | if(ARLIBS OR SHLIBS OR PBLIBS OR EXEFLAGS) | |
489 | target_link_libraries(${PACKAGE} ${ARLIBS} ${SHLIBS} ${PBLIBS} ${EXEFLAGS}) | |
490 | endif(ARLIBS OR SHLIBS OR PBLIBS OR EXEFLAGS) | |
491 | add_dependencies(${MODULE}-all ${PACKAGE}) | |
492 | else() | |
493 | add_executable(${PACKAGE} ${PFS} ${PCS} ${PS} ${PDS}) | |
494 | if(PELIBS OR PBLIBS OR EXEFLAGS) | |
495 | target_link_libraries(${PACKAGE} ${BINLIBDIRS} ${PELIBSDIR} ${PELIBS} ${PBLIBS} ${EXEFLAGS}) | |
496 | endif(PELIBS OR PBLIBS OR EXEFLAGS) | |
497 | add_dependencies(${MODULE}-all ${PACKAGE}) | |
498 | endif(ALIPROFILE STREQUAL "YES") | |
499 | ||
500 | list(FIND EXCLUDEMODULES ${MODULE} RESULT) | |
501 | if(NOT RESULT STREQUAL "-1") | |
502 | set_property(TARGET ${PACKAGE} PROPERTY EXCLUDE_FROM_ALL TRUE) | |
503 | endif(NOT RESULT STREQUAL "-1") | |
504 | ||
505 | endmacro(ALICE_BuildExecutable) | |
506 | ||
507 | macro(ALICE_CopyHeaders) | |
508 | ||
509 | if(NOT EXPORT ) | |
510 | set(HEADERS) | |
511 | else() | |
512 | set(HEADERS ${EXPORT}) | |
513 | endif(NOT EXPORT) | |
514 | foreach(header ${HEADERS}) | |
515 | configure_file(${header} ${PEXPORTDEST} COPYONLY) | |
516 | install(FILES ${header} DESTINATION include) | |
517 | endforeach(header) | |
518 | ||
519 | endmacro(ALICE_CopyHeaders) | |
520 | ||
521 | macro(ALICE_GenerateLinkDef) | |
522 | ||
523 | file (WRITE ${PDAL} "//--------------------------------------------------------------------------------\n") | |
524 | file (APPEND ${PDAL} "// This is an automatically generated Root Dictionary Linkdef file for ${PACKAGE}\n") | |
525 | file (APPEND ${PDAL} "// !!! DO NOT EDIT THIS FILE !!!\n") | |
526 | file (APPEND ${PDAL} "#ifdef __CINT__\n") | |
527 | file (APPEND ${PDAL} "#pragma link off all globals;\n") | |
528 | file (APPEND ${PDAL} "#pragma link off all classes;\n") | |
529 | file (APPEND ${PDAL} "#pragma link off all functions;\n") | |
530 | foreach (class ${PCINTCLASSES}) | |
531 | get_filename_component(classname ${class} NAME) | |
532 | file(APPEND ${PDAL} "#pragma link C++ class ${classname}+;\n") | |
533 | endforeach(class) | |
534 | file (APPEND ${PDAL} "#endif\n") | |
535 | endmacro(ALICE_GenerateLinkDef) |